Exact computation & engineering software / Recorded software timing / energy projection
Exact computation & engineering software
The saved H22 study compared square_direction_factored with the internal factored_hybrid control on 2,500 selected requests. Adding each request’s median time gives 3.54% less time overall. The exact-direction family used 31.88% less; the late-mismatch family took 6.92% longer. These timings came from the original host and the measured function-call scope. The 15 October independent AI accounting review confirms that FI was slower than capable ordinary gmpy2 in all 26 preserved first-call and warm timing groups. The separate H22 study covers 2,500 cases against the prior FI hybrid.
Calculation time / 100-second baseline
3.5423 stime saved
3.54% less time
Before100 s
→
After96.4577 s
Before
After
Sum of per-request medians, versus the earlier FI implementation.
Matching-input time / 100-second baseline
31.8834 stime saved
31.88% less time
Before100 s
→
After68.1166 s
Before
After
Only the matching-input group; not the whole workload.
Overall energy at constant 1 W
3.5423 Jenergy saved
3.54% less energy
Before100 J
→
After96.4577 J
Before
After
Energy projection from overall time at constant power.
Recorded software timing / projected energy
What we compared
Inputs: Time is shown relative to a 100-second baseline. The energy example assumes constant 1 W active power and unchanged output. Startup and imports were excluded from the recorded comparison.
Evidence: The study timed 2,500 requests. In 1,248 cases, the median time was higher; four input groups improved and six slowed. Recorded software timing; energy uses the stated constant-power model.
CUMULATIVE APPLICATION BUDGET / 17 OCTOBER 2026
Related reference jobs.
Engineering reference models tie the strongest tested ordinary controls at nominal. In the separate API pilot, gmpy2 led all 26 preserved timing groups. The report-cache design removes 737,280 expression evaluations.
Related model jobs: D066, D081, D082, D083, D084. Integration into a product remains open.
Reusing exact intermediate values removes 737,280 repeated expression evaluations from this report design.
Same result. Less repetition.
Same math.
separate checker retained
The calculation and checker each keep their own saved intermediate values. They repeat less arithmetic while the checker remains independent.
Conventional comparison
0%
additional FI arithmetic reduction
Caching means keeping intermediate answers in memory for reuse.
A conventional implementation using the same cache reaches the same arithmetic count.
These figures compare the arithmetic used to build the reports.
Calculation and comparison
The count covers five reports, three jobs, two states and 4,096 sample pairs: 122,880 pairs per calculation path. The original calculation and checker use 26 rational-expression operations per pair; with caching they use 20. Both counts include 60 final divisions: 3,194,940 → 2,457,660. The reduction is 737,280 ÷ 3,194,940 = 23.0764897%.
RECORDER STORAGE · RECOVERY · COMPUTING / 8 OCTOBER 2026
Full history. Less overhead.
The proposed layout keeps all 2,592,000 records from 30 days of one reading per second, with two durable copies and timing evidence for every record. It reserves less storage and reduces reads and writes during normal recording.
The design calculations leave more storage available around the same history and reduce the data read during routine restart. Restart time and installed energy remain unmeasured.
Metric
Earlier design
Revised design
Practical change
Reserved recorder storage
1,153,112,064 B
862,808,256 B
25.18% less reserved recorder storage
Recorder + complete input-history storage
1,453,784,064 B
1,163,480,256 B
19.97% less for recorder and input-history storage
Normal capture writes
580,608,000 B
518,400,000 B
10.71% fewer written bytes
Normal capture reads
1,410,048,000 B
1,161,216,000 B
17.65% fewer read bytes
Data read on routine restart
656,580,608 B
8,391,072 B
98.72% fewer read bytes; restart time unmeasured
Checksum work for timing records
1,658,880,000 bit-level checksum steps
663,552,000 bit-level checksum steps
60% fewer bit-level checksum steps for timing records
Requests to save writes durably
15,552,000
15,552,000
Unchanged; six calls per record
Complete exported recording
228,096,016 B
228,096,016 B
Complete history and final state retained
Where the saving comes from
Storing shared identification once reduces each record’s timing data from 48 to 24 bytes. The layout also reserves less extra storage on the recorder. The complete 30-day history remains available for export and review.
Conventional software can implement these same layout changes.
The recovery tradeoff
Routine restart finds where recording stopped without rereading the entire history. It assumes previously checked data stays unchanged and postpones the full corruption scan.
The complete diagnostic scan remains available. It reads 594,374,304 bytes before saving the restart and final-state records. The number of requests to save writes durably stays unchanged.
Setting the earlier FI implementation’s combined time to 100 seconds gives 96.46 seconds for the revised version; the exact-direction family scales to 100 → 68.12 seconds. A separate source count removes 737,280 helper-expression evaluations (23.08%) by caching exact report results. Conventional implementations can use the same cache.
What the design aims to improve
Reuse calculations and simplify data handling to do more within the same processing budget, or study smaller hardware where peak demand allows.
THE APPLICATION
Exact computation & engineering software
Engineering-software vendors and teams building numerical workflows
Reuse repeated calculations and simplify history handling to free processing capacity. Compare task time, memory and energy with optimized software.
The study covers known input families and repeated histories, with equivalent results and a general method to fall back on.
REFERENCES & CHECKED RESULTS
Comparison.
Measure
Reference or conventional method
FI result or stated assumption
What it means
Aggregate recorded timing
Prior FI hybrid implementation
3.54% less total time when each case’s median time is added
A gain over that earlier FI version. The 15 October independent AI accounting review found FI slower than capable conventional gmpy2 in all 26 saved first-call and warm timing groups. The separate H22 study compares 2,500 cases with the prior FI hybrid.
Distribution of results
10 designed timing families
4 improved; 6 slowed
Some selected jobs improved and others slowed
Strong arithmetic comparator
gmpy2 2.3.1 in the separately saved pilot
The 15 October independent AI accounting review found FI slower in all 26 saved first-call and warm groups
The saved pilot is a loss, separate from the internal H22 study; timings were not rerun
Exact report-helper arithmetic
Earlier helpers, without caching: 3,194,940 expression evaluations
Helpers with cached results: 2,457,660; 737,280 fewer (23.08%)
Calculated report arithmetic. Conventional code with the same cache ties; device speed remains unmeasured
Shared-history source work
Two types of repeated history handling at 4,096 records
16,777,216 positions removed, with full checks retained
A calculated reduction in work; elapsed time was not measured
Executed software comparisons and calculated bounds · 12 October 2026
Smaller records, mixed timing results.
FI compared ways to store calculation records while keeping the same required output, checks and record behavior. The smaller formats saved memory, but timing depended on the comparison. A separate signal-recording calculation exceeded its frame budget.
Read-only calculation records
A packed, ordered snapshot used less traced Python memory in all 16 matched groups. The detailed record was faster in six groups; two comparisons were uncertain. Against a second read-only format, eight timing comparisons were uncertain.
The snapshot preserves the complete ordered record for reading. It gives up persistent edits, object identity, live changes, custom traces and the full list interface.
Signal-recording deadlines
One specified validation job needs at least 16,896 recording units per frame to retain the unchanged record. Its budget is 8,192 units.
These are recording-work units from a fixed, uncalibrated model, rather than processor clock cycles.
Saved sensing-energy ranges, independently checked thermal calculations and recorded software comparisons. The device calculations show energy shares, heat paths and component budgets.
Exact computation & engineering software evidence | FI Systems
