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-10-28.meta-metrics-v2. Calculation version 1.0.7. CVP 1.0.0-proposed. 212/212 golden · 9/9 CVP boundary · 9/9 invalid · 8/8 property · 2/2 metamorphic · 2/2 round-trip · 14/14 cross-interface · 5/5 CVP contract. digest e8465f3c7103. Complete output identity vs212 independently generated CPython Fraction/Decimal/int vectors, including rounding, signed truncation, normalized-operand exactness, subnormals,48-digit work and every output field; no whole-domain guarantee.

• Golden (oracle-backed) 212 / 212
• CVP boundary 9 / 9
• Invalid input 9 / 9
• Property 8 / 8
• Metamorphic 2 / 2
• Round-trip 2 / 2
• Cross-interface 14 / 14
• CVP contract 5 / 5
• Interfaces PASS · UI (SSR) / REST / MCP
• Interface claim ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 12/12 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only.
• 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:336126b78ddfd09554798ec44eafd1697f899316154bb273fd47a26bdbccd280

Input schema sha256:f5d0e515cf0934608b3f0e3918fc0690d2b711a48959202f6dfd7b1621cdc17d · Output schema sha256:74e81546fd61ab7b194601c7508c66a0c979364e4042ea5002461b549401bcd8 · 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-22

Evidence core

2026-10-22T08:53:13.096Z

Rendered

2026-10-28T03:01:57.884Z

Last reviewed

—

Assumptions

• Typing computes locally. Shared URLs send their parameters to the server for SSR and may appear in logs; REST/MCP also receive the inputs. Share links run the current engine, not a historical runtime.
• 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 normalized integral operands 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

• Quotient exact/display_exact refer to normalized binary64 operands and rounded display separately; decimal parsing is not exact decimal arithmetic.
• All integral quotient operands must fit±(2^53−1). Use Long mode with non-negative integer strings for larger values, up to48 digits.
• Tokens at most512 characters; unknown fields, mode/type errors and conflicting aliases rejected. Nonzero text/JSON/result underflow is rejected; subnormal nonzero values accepted.
• Division by zero and overflow rejected. Decimal places default8 when absent/blank, otherwise integer0–16.
• Share URLs restore current-engine inputs; not a historical runtime.