math.divide

Three distinct suites: educational examples on the calculator page, this legacy regression count (34/34 golden + boundary), and the CVP verification suite below. They are not the same number. Property, metamorphic, round-trip, O3, and interface statuses/checks are recorded in the CVP Manifest . SKIP (0/0) means that suite has no published vectors.

STALE · Build schema 1.0.7 matches page · production binding STALE · Semantic contract ✓ · Last attestation PASS · current evidence changed · re-attestation required · CVP STALE · attestation STALE — Production CURRENT withheld · Public/cache ✓ · Origin ✓

CVP verification suite

Protocol checks from the Evidence Manifest. Distinct from the legacy regression suite above. Verification revision 2026-09-08.exact-contract. Calculation version 1.0.5. CVP 1.0.0-proposed. 10/10 golden · 9/9 CVP boundary · 9/9 invalid · 8/8 property · 2/2 metamorphic · 2/2 round-trip · 9/9 O3 · 2/2 cross-interface · 1/1 CVP contract. digest e5997fd9b998. ≤2 ULP vs O3 applies to the published tabulated quotient vectors (1/3, 100/7, 1.005/1, 1/1e-300, (2^53−1)/7). Long-division vectors are exact integer q,r (Python int divmod). This is not a whole-domain guarantee.

• Golden (oracle-backed) 10 / 10
• CVP boundary 9 / 9
• Invalid input 9 / 9
• Property 8 / 8
• Metamorphic 2 / 2
• Round-trip 2 / 2
• O3 high-precision 9 / 9
• Cross-interface 2 / 2
• CVP contract 1 / 1
• Interfaces PASS · UI (SSR) / REST / MCP
• Interface claim ui-ssr is query-result HTML, not a live browser session.
• Assurance Core

• release artifacts aligned PASS
• schema output required declared PASS
• schema valid input executes PASS
• engine success output validates schema PASS
• rest success payload validates schema PASS

Fingerprint sha256:05136052816fe802b95ce1f369c0341dfe5f63760c652c650da94052ac1624f2

Input schema sha256:c2fbe7133f0d6d938d97df912ce41744cab1a9b9c4c036e7d96091ea87b90b86 · Output schema sha256:cd04600caf14ef379fce2d64ad8015d48c4e2db551808873c8e534cf37d8159f · Build-time SHA-256 digests prove published artifacts agree with each other (release_integrity.scope=workspace). Production attestation GETs canonical URLs twice (public/cached view and origin), including Capability HTML, via npm run attest:production --write (published at /.well-known/calculatorx-production-attestation.json) and fails if the public Capability page advertises a different calculation_version. This is artifact consistency, not an independent immutable release log.

Tool

division

Engine

divide

Engine build

2026-10-14

Evidence core

2026-10-14T05:05:51.930Z

Rendered

2026-10-22T04:36:23.980Z

Last reviewed

—

Assumptions

• Quotient mode divides in IEEE-754 binary64, then rounds the display with Number.prototype.toFixed (round half away from 0 on that binary64 value). Trailing zeros may be stripped.
• The displayed decimal is not claimed to be an exact repeating expansion.
• REST field exact is true iff ieee_value equals the real number a÷b for those binary64 operands. It is not display round-trip and not integer divisibility. Example: (2^53−1)÷7 has remainder 3, so exact is false even when toFixed round-trips.
• REST field display_exact is true iff Number(ieee_value.toFixed(n)) === ieee_value (display did not change the binary64 value).
• Long division uses exact BigInt Euclidean division for non-negative integers: a, b ∈ ℤ≥0, b > 0. Integers are limited to 48 decimal digits to bound computation and long-division step output (a CalculatorX product contract, not a JavaScript BigInt limit).
• Remainder satisfies 0 ≤ r < b in long division (verified as b·q + r = a in BigInt). Long-mode exact is true iff remainder is 0.
• Quotient mode does not silently round plain integer tokens outside ±(2^53−1); those inputs return INTEGER_OUT_OF_SAFE_RANGE. Send large integers as decimal strings and use Long division for an exact result.
• REST/JSON reports ieee_value (raw binary64, or null when the long-division operands do not fit in a safe integer), decimal_value (display string), precision, rounding, exact (mathematical vs binary64 operands), display_exact (toFixed round-trip), exact_value (a/b when both are integers), integer_quotient/remainder for integer quotient-mode operands, and integer_engine=bigint in long mode.

Limitations

• b = 0 → DIVISION_BY_ZERO
• Long mode uses BigInt integers only