Inverse involute accuracy

In the upcoming API v1, our inverse involute function, for 0 < y < 2, is faithfully rounded: the result is always within 1 unit in the last place (ulp) of the exact value. Across 44,232 test points the largest error was under 0.54 ulp against an 80-digit reference, and the published proof bounds it at 0.6 ulp. See our proof and assumptions.

This page describes how we tested the numerical accuracy of one function under the stated assumptions (IEEE 754 double precision, the stated input range, the stated reference). It isn't a warranty. It doesn't cover inputs outside that range, other functions, or the engineering suitability of any gear design. All results, including those from the API and from Cogsworth, are for reference and must be checked by a qualified engineer before manufacture or use. Your use of Gearcalculators.com is governed by our Terms of Service, including the engineering disclaimer and limitation of liability.

What this covers

This page is about the inverse involute only. It does not say that every number a calculator prints is accurate to 1 ulp.

The function and its domain

The inverse involute function is the angle whose involute equals the input. The involute of an angle is the tangent of that angle, minus the angle.

The statement above is for 0 < y < 2. On that domain the maximum error measured against an 80-digit reference is 0.5316 ulp, over 44,232 points, which is under 0.54 ulp. The acceptance gate is 1 ulp (faithful rounding). A proof gives at most 0.6 ulp for y < 2.

No tooth count, module, pressure angle, or helix angle is part of this statement.

API version

The sentence above says the upcoming API v1. This document's decision on the forward-involute change was a patch with no API version bump (2 November 2026). It does not name a commit for the inverse measurement.

How the error was measured

This document records a maximum of 0.5316 ulp over 44,232 points, and a proof of 0.6 ulp for y < 2.

The proof and its assumptions

The bound is proved relative to a named list of assumptions, not outright. The list recorded with the approved claim is:

  • the error bound on a double-double tangent
  • binary64 round-to-nearest without fused multiply-add, on x86_64 and in V8
  • the one-step lemmas as proved by z3 and cvc5
  • the interval proofs, with one named exception, E-IVEXP: in the run that produced them, 19 of 54,075 unique exponential evaluations at 269-bit precision had an interval endpoint on the wrong side of the true value, by at most 0.000432 ulp (about 2⁻²⁸⁰ relative); no other function showed one across 644,296 records. The verdict does not depend on it: the same run with every such interval widened by 1 ulp per side prints the identical verdict. Accepted as measured on 27 October 2026.
  • the series branch for α ≤ 0.5
  • the identities that are replayed numerically and proved by hand
  • an iteration bound of 86 against a cap of 100, composed from the stage constants and the one-step lemmas; that composition is machine-checked (8 of 8 obligations, 18 of 18 planted faults caught)

The checks are on x86_64.

Assumptions

Floating-point format and rounding mode. The approved technical terms name binary64 round-to-nearest without fused multiply-add, on x86_64 and in V8.

Input domain and endpoints. The measurement counts every harness point with 0 < y < 2, open at both ends: neither y = 0 nor y = 2 is a measured point, and sample draws at or below zero are dropped and counted. The smallest measured point is about 3.3 × 10⁻¹⁹ (the round-trip set at an angle of 10⁻⁶ radians) and the largest is the double just below 2. y = 0 is one of eight special inputs the harness checks separately, requiring only that the recorded output does not change; that check is not an accuracy figure. Below the smallest measured point the harness has a separate gate: 171 distinct values of y under 10⁻²⁰⁰, at most 0.4982 ulp against a limit of 0.6.

The 44,232 test points. They are every point with 0 < y < 2 from five sets the harness builds from a fixed seed, so a rerun hits the same doubles: 30,000 from ten gear-geometry contexts drawn at random (3,000 valid draws kept of 30,000 per context); 4,048 of 6,500 log-uniform values between 10⁻¹² and 10⁸; 7,381 of 7,800 log-spaced values, 600 per decade from 10⁻¹²; 826 of 954 region-boundary points (neighbouring doubles of the solver's branch points and of the powers of two from 2⁻⁴⁰ to 2¹⁰); and 1,977 of 2,000 round-trip points, y = fl(inv(α)) for log-spaced α from 10⁻⁶ to 1.5. The worst point, 0.5316 ulp, was y = 0.5370916452982755 in one of the ten contexts.

Reference method. Every one of the 44,232 results was compared with an 80-digit mpmath oracle. The forward involute is evaluated at 80 digits, directly as tan α − α for α ≥ 0.2 and by its positive-coefficient series below that; the inverse is the root of that function, found by a bracketed Newton iteration at the same precision and stopped at a relative step of 10⁻⁷², so about 70 correct digits. The error of a result is its distance from that root divided by the ulp of the binade holding the root. The oracle is one library with two evaluation paths, not two libraries; Arb is not used. The harness self-test re-evaluates the residual of each solved root by a sine and cosine path at 400 digits.

Version or commit. The 0.5316 ulp figure was first produced by solver commit 6766293e and recorded in commit cf1e6899 on 17 October 2026, on branch inv-perfect/s4-owned-tan, merged to stage in PR #1592 the same day. The same figure at the same worst point was recorded again on a clean checkout on 18 October 2026, and on Node 20 and Python 3.10 on 21 October 2026. The solver file changed after that (22 October, 1 November and 2 November 2026). The harness run of 2 November 2026 is recorded as every gate passing, including the 1 ulp gate over these points, but the record does not state the maximum that run measured.

Future versions. A public API release is a promotion of a stage cut: the same immutable container image digests, so the same results, frozen once cut. Cutting a release runs each changed calculator's tests in its image and records and checks golden results on fixed inputs; promotion commits those golden results and a changelog of the differences from the previous public release. No release workflow runs the harness that produced the 44,232-point figure, so a future version is not re-measured by it as part of release. Separately, a pull request to stage that changes the backend or the shared engine runs a test comparing the inverse involute with a 256-bit integer oracle at 4,000 log-spaced points between 10⁻¹² and 1.3, limit 1 ulp.

Limits

  • Inverse involute only. The forward involute, a certified bracket, and any other calculator output are outside this statement.
  • Inputs y ≤ 0 are outside this statement. This page does not say that an invalid request is refused, or that a result of zero is never returned. That refusal was not established for bevel gears, spiral bevel gears, or worms at y ≥ 2.
  • For 2 ≤ y ≤ 10^6 the approved record states a different result: availability there is proved relative to the named list above, not outright. It is not the 0.54 ulp measurement on 0 < y < 2.
  • No tooth-count, module, pressure-angle, or helix range is claimed.

Recorded from the approved public claim of 2 November 2026 (technical terms) and the white paper section on what that claim rests on. The 44,232-point figure is the evidence row for 0 < y < 2. The assumptions are recorded from the harness and its run records in the repository (tools/inv-harness, docs/inverse-involute-overnight, docs/inv-cross-runtime-t7-results.md) and from the public API release documentation.