CVP verified calculation capability

Fractions Calculation Capability

Exact safe-integer fraction and signed mixed-number arithmetic (+,−,×,÷), simplification and decimal previews. From decimal converts the shortest normalized binary64 decimal to an exact base10 rational, or rejects an unsafe reduced n/d; no continued-fraction or silent-zero substitute.

Math Capability ID math.fractions version 1.0.8 CVP VERIFIED CURRENT Core

Model

Add

Add: L = LCM(b, d); a/b + c/d = [a(L/b) + c(L/d)] / L
Subtract: L = LCM(b, d); a/b − c/d = [a(L/b) − c(L/d)] / L
Multiply: a/b × c/d = (ac) / (bd)
Divide: a/b ÷ c/d = a/b × d/c
Simplify: a/b = (a÷g)/(b÷g) where g = GCF(a,b)

Modes: operate · simplify · to-dec · from-dec

Inputs / Outputs

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

Symbol	Quantity	Unit	Role
`op`	—	—	input / output
`operator`	—	—	input / output
`aWhole`	—	—	input / output
`bWhole`	—	—	input / output
`aNum`	—	—	input / output
`n`	—	—	input / output
`bNum`	—	—	input / output
`c`	—	—	input / output
`aDen`	—	—	input / output
`d`	—	—	input / output
`bDen`	—	—	input / output
`decimal`	—	—	input / output
`decInput`	—	—	input / output
`improper`	—	—	output
`mixed`	—	—	output
`decimal_display`	—	—	output
`inputs_label`	—	—	output
`rational_exact`	—	—	output
`conversion_source`	—	—	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`	safe-integer LCD/product and GCD reduction; from-dec exact base10 rational of shortest normalized binary64 decimal, rejecting unsafe reduced numerator/denominator
`valid_domain`	fraction integer inputs and every arithmetic intermediate must satisfy \|x\| ≤ 2^53−1; denominator ≠ 0
`singularity_policy`	DENOMINATOR_MUST_BE_NONZERO when an input denominator is 0; DIVISION_BY_ZERO only when dividing by a zero-valued second fraction
`branch_policy`	not applicable — rational, not complex
`tolerance`	not applicable — fraction arithmetic is exact within the safe-integer envelope; decimal conversion/display uses float64
`convergence`	not applicable — non-iterative
`conditioning`	Exact within the safe-integer intermediate envelope; binary64 input normalization and decimal previews introduce finite rounding. Near cancellation in fractional arithmetic is exact only when every intermediate is safe.
`rounding`	rational_exact refers to normalized rational n/d; decimal preview12 significant digits or9 scientific; from-dec converts shortest binary64 decimal, not exact binary fraction; nonzero-to-zero rejected
`overflow`	VALUE_OUT_OF_RANGE when a fraction input, mixed-number construction, or arithmetic intermediate exceeds the safe-integer envelope
`reproducibility`	deterministic safe-integer fraction arithmetic + Capability@Version
`independent_oracle`	Evidence published cases
`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

Fraction inputs and every arithmetic intermediate must be safe integers (absolute value at most 2^53−1); otherwise VALUE_OUT_OF_RANGE.
From decimal converts the shortest normalized binary64 decimal exactly within the reduced safe-integer envelope; all four modes are in the current numerical verification scope.
Results reduced by GCF; signs normalized onto the numerator.

Example

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

3/4 + 1/6 = 11/12

Open this example in the calculator

Trust

CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · operate (+/−/×/÷), simplify, to-dec and from-dec. 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 · operate (+/−/×/÷), simplify, to-dec and from-dec· View Manifest · CVP overview · Specification
Verified scope: operate (+/−/×/÷), simplify, to-dec and from-dec
Assurance: Core
Declared partition coverage: PASS · 8/8 declared partitions (operate:add, operate:subtract, operate:multiply, operate:divide, to-dec, from-dec, simplify, invalid-domain)
Calculation version: 1.0.8
Verification: 32/32 calculation tests · 20/20 legacy golden · 8/8 legacy boundary · 4/4 legacy property
Production surface contract: 6/6
Versions: Calculation 1.0.8 · CVP protocol 1.0.0-proposed · Evidence 2026-10-20.fractions-complete-contract-v2
Verification revision: 2026-10-20.fractions-complete-contract-v2 · 2/2 property · digest 8059211bd24b
Reference: O1 model · O2 expected_values · O2 numerical_behavior
Interfaces: PASS · UI (SSR) / REST / MCP
ui-ssr is query-result HTML, not a live browser session.
CVP suite: 10/10 golden · 8/8 CVP boundary · 9/9 invalid · 2/2 property · 1/1 metamorphic · 1/1 round-trip · 7/7 cross-interface · 6/6 CVP contract
Supplemental domain review: Not performed
Named expert review: Not performed
Version lock: Supported (409 VERSION_MISMATCH)
Artifact consistency: Build verified · 1.0.8 (workspace artifacts agree)
Review-policy tier: Engine tested — catalog token engine_tested; supplemental; not CVP status

This calculator CURRENT · Public schema 1.0.8 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 6/6.

curl -sS -X POST 'https://www.calculatorx.com/api/v1/calc/fractions' \
  -H 'Content-Type: application/json' \
  -d '{"inputs":{"mode":"operate","op":"+","aNum":3,"aDen":4,"bNum":1,"bDen":6},"calculation_version":"1.0.8"}'

{
  "inputs": {
    "mode": "operate",
    "op": "+",
    "aNum": 3,
    "aDen": 4,
    "bNum": 1,
    "bDen": 6
  },
  "calculation_version": "1.0.8"
}

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

Full REST contract: REST API docs.

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

Operations

Declared calculation modes for this capability.

operate
simplify
to-dec
from-dec

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.fractions"},"_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.fractions","inputs":{"mode":"operate","op":"+","aNum":3,"aDen":4,"bNum":1,"bDen":6},"calculation_version":"1.0.8"},"_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.8) when the result must stay reproducible.

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