CVP verified calculation capability

Division Calculation Capability

Binary64 quotient with0–16 display places, or exact non-negative integer long division and full working up to48 digits.

Math Capability ID math.divide version 1.0.7 CVP VERIFIED CURRENT Core

Model

Quotient

Quotient: q = a ÷ b
Displayed decimal: round_toFixed(a ÷ b, n) after IEEE-754 binary64 division
Long division: a, b ∈ ℤ≥0, b > 0; q = ⌊a/b⌋; r = a − bq; 0 ≤ r < b
Check: b·q + r = a

Modes: quotient · long

Inputs / Outputs

Canonical symbols for this capability. Agent schemas remain the contract.

Symbol	Quantity	Unit	Role
`a`	—	—	input / output
`b`	—	—	input / output
`decimals`	—	—	input / output
`review`	—	—	output
`api_version`	—	—	output
`api_contract_version`	—	—	output
`spec_version`	—	—	output
`page`	Canonical calculator page URL	—	output
`links`	—	—	output

Trusted Math contract

Inspectable numeric contract for this Capability@Version. Not a rewrite of the engine.

Field	Declaration
`numeric_domain`	rational
`exactness`	exact + float64
`algorithm`	Shared binary64 quotient with0–16 toFixed places; BigInt Euclidean long division with per-digit text working
`valid_domain`	Quotient finite decimal numbers/strings; integral operands within±(2^53−1). Long non-negative integers up to48 digits, b>0. Tokens at most512 characters; matching aliases only.
`singularity_policy`	DIVISION_BY_ZERO at b=0; input/result nonzero-to-zero→NUMERIC_UNDERFLOW and overflow→INVALID_NUMBER
`branch_policy`	not applicable — Single real quotient; long unique Euclidean q,r
`tolerance`	Complete212-case independent CPython Fraction/Decimal/int identity; exact is relative to normalized binary64 operands, or zero long remainder. display_exact is separate display round-trip.
`convergence`	not applicable — Finite arithmetic/digit algorithm
`conditioning`	Relative sensitivity is one per nonzero operand; near b=0 absolute sensitivity grows as \|a\|/b². Binary64 conversion/division/display can round; subnormal results have degraded relative precision. Measurement uncertainty is not modeled.
`rounding`	Binary64 operands and division, then toFixed half away from zero on that binary64 value. Long q,r exact; optional decimal preview is approximate or null.
`overflow`	Nonfinite quotient rejected; nonzero underflow rejected. Large exact integers require long strings;48 digits and512-character tokens bound work.
`reproducibility`	Versioned shared engine; share restores current inputs, not historical replay.
`independent_oracle`	Private CPython Fraction, Decimal precision1200 ROUND_HALF_UP and integer divmod; no IUT imports
`golden_vectors`	Evidence golden + boundary + property (and published_reference_case when listed)

Assumptions / Validity

Declared scope for this capability. Do not use it outside this domain.

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.

Example

One numerical check. The calculator page holds worked steps and FAQ.

100 ÷ 7 at 8 decimal places → 14.28571429 (rounded); long 100 ÷ 7 → 14 R 2; long 9007199254740993 ÷ 1 → 9007199254740993 R 0

Open this example in the calculator

Trust

CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance. Computational verification is defined by CVP. Supplemental domain review (internal) and named expert review are defined by the Review policy and do not by themselves determine CVP conformance.

CVP: CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance· View Manifest · CVP overview · Specification
Assurance: Core
Declared partition coverage: PASS · 7/7 declared partitions (quotient-normal, quotient-rounding, quotient-boundary, long-normal, long-large-integer, long-boundary, invalid-domain)
Calculation version: 1.0.7
Verification: 34/34 calculation tests · 25/25 legacy golden · 9/9 legacy boundary
Production surface contract: 5/5
Versions: Calculation 1.0.7 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.meta-metrics-v2
Verification revision: 2026-10-28.meta-metrics-v2 · 8/8 property · digest e8465f3c7103
Reference: O1 model · O2 expected_values · O2 numerical_behavior
Numerical scope: 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.
Interfaces: PASS · UI (SSR) / REST / MCP
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.
CVP suite: 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
Supplemental domain review: Not performed
Named expert review: Not performed
Version lock: Supported (409 VERSION_MISMATCH)
Artifact consistency: Build verified · 1.0.7 (workspace artifacts agree)
Review-policy tier: Engine tested — catalog token engine_tested; supplemental; not CVP status

This calculator CURRENT · Public schema 1.0.7 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓

Call this capability

Human page, REST, and MCP share the same engine and calculation_version. Build verified hashes workspace artifacts only. After deploy, attest:production GETs canonical URLs twice — the public/cached view an Agent actually hits, and origin — including every /capabilities/{id} HTML page. Public Capability HTML version must match catalog before production attestation passes. Live Trust rows above fetch /.well-known/calculatorx-production-attestation.json and the output schema const. Build hashes: release integrity. That proves currently published page / engine / schema / evidence / MCP agree — not that a historical version is independently immutable. Reference Calculation Standard — Production surface contract 5/5.

curl -sS -X POST 'https://www.calculatorx.com/api/v1/calc/division' \
  -H 'Content-Type: application/json' \
  -d '{"inputs":{"a":8,"b":4,"decimals":8,"mode":"quotient"},"calculation_version":"1.0.7"}'

{
  "inputs": {
    "a": 8,
    "b": 4,
    "decimals": 8,
    "mode": "quotient"
  },
  "calculation_version": "1.0.7"
}

POST /api/v1/calc/division. This is a POST calculate endpoint — do not GET it.

Full REST contract: REST API docs.

Tool id: division
Engine: divide
REST: POST /api/v1/calc/division
MCP: execute_calculation with capability_id: "math.divide"
Agent input schema: Canonical (MCP / Agent)
REST input schema: Compatibility (tol[] / tol1…)
Output schema: JSON Schema (latest)
Versioned input schema: Immutable pin (1.0.7)
Versioned output schema: Immutable pin (1.0.7)

Operations

Declared calculation modes for this capability.

quotient
long

References

Human-readable sources plus CVP reference evidence classes.

Sources

Reference evidence classes: O1 model · O2 expected_values · O2 numerical_behavior

Try with an agent

Inspect, then execute. Same engine as REST and the human calculator.

curl -sS -X POST 'https://www.calculatorx.com/mcp' \
  -H 'Content-Type: application/json' \
  -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: tools/call' \
  -H 'Mcp-Name: inspect_capability' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"inspect_capability","arguments":{"capability_id":"math.divide"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"calculatorx-docs-example","version":"1.0.0"},"io.modelcontextprotocol/clientCapabilities":{}}}}'

curl -sS -X POST 'https://www.calculatorx.com/mcp' \
  -H 'Content-Type: application/json' \
  -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: tools/call' \
  -H 'Mcp-Name: execute_calculation' \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"execute_calculation","arguments":{"capability_id":"math.divide","inputs":{"a":8,"b":4,"decimals":8,"mode":"quotient"},"calculation_version":"1.0.7"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"calculatorx-docs-example","version":"1.0.0"},"io.modelcontextprotocol/clientCapabilities":{}}}}'

Pin calculation_version (1.0.7) when the result must stay reproducible.

Inspect the trust tier and required assurance level before execution. Full protocol notes: MCP docs.