Public evidence

math.multiplication

Machine-checked verification for calculation version 1.0.3 · tier engine_tested

Open calculator API Capability Download JSON CVP Manifest MCP Review policy

CVP: CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance· product or long mode; shared exact path; long steps independently reconstructed · Protocol · Schema · Production report

Declared partition coverage: PASS · 5/5 declared partitions (product, long, long-grid, digit-bound, invalid-domain)
Versions: Calculation 1.0.3 · CVP protocol 1.0.0-proposed · Evidence 2026-09-16.sources-no-wolfram
Verification revision: 2026-09-16.sources-no-wolfram · 6/6 property · digest 7a9319794cf7

Verification

Legacy regression suite: 15/15 calculation tests · Production surface contract 4/4

Three distinct suites: educational examples on the calculator page, this legacy regression count (15/15 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.

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

CVP verification suite

Protocol checks from the Evidence Manifest. Distinct from the legacy regression suite above. Verification revision 2026-09-16.sources-no-wolfram. Calculation version 1.0.3. CVP 1.0.0-proposed. 12/12 golden · 5/5 CVP boundary · 4/4 invalid · 6/6 property · 2/2 metamorphic · 2/2 round-trip · 3/3 cross-interface · 4/4 CVP contract. digest 7a9319794cf7. Exact decimal-string identity (productStr) vs O2 mantissa×BigInt dual-checked against per-digit BigInt partials. Long vectors also require IUT work to contain those partials, or LONG_GRID_TRUNCATED at 25 digits. 48 significant digits per factor; 49-digit factors are rejected. This is not a whole-domain proof beyond the published vectors.

Golden (oracle-backed) 12 / 12
CVP boundary 5 / 5
Invalid input 4 / 4
Property 6 / 6
Metamorphic 2 / 2
Round-trip 2 / 2
Cross-interface 3 / 3
CVP contract 4 / 4
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 valid input executes PASS
engine success output validates schema PASS
schema rejects incomplete input PASS

Fingerprint sha256:390204c17741107554921e0df97b92e39c1abeb92f6fc6d12aabcea1757958a9

Input schema sha256:694d72a0edef2b5a16d886a9b9d3aab856f17118d177c4fbb72bc3648a508d20 · Output schema sha256:82034e8d4b53198a999d386a7775a13a278e82762b93bfbfa317f5e7a1a11ae9 · 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.

Build & scope

Engine identity and declared limitations.

Tool: multiplication
Engine: multiplication
Engine build: 2026-09-16
Evidence core: 2026-09-16T06:41:00.884Z
Rendered: 2026-09-16T22:03:43.784Z
Last reviewed: —

Assumptions

Real decimal inputs parsed as exact decimal strings (integer mantissa × 10^−scale), not binary floating-point.
Product mode and Long multiplication mode use the same exact mantissa multiplication; Long adds partial-product steps.

Limitations

Missing a or b → INVALID_INPUT
Product and long modes share exact decimal mantissa × BigInt arithmetic
Very wide long grids may set LONG_GRID_TRUNCATED

Sources

Standards and references supporting this tool specification. Methods are listed separately — they are algorithms, not bibliographic sources.

OpenStax Prealgebra 2e — Multiply Whole Numbers — 1.4 Product of two numbers
Supports: Standard multiplication as the product of a multiplicand and a multiplier.
CalculatorX mathematical conventions — Exact decimal place-count multiplication
Supports: Long-multiplication algorithm with partial products; exact decimal mantissa × BigInt; sign rules for negatives.

Legacy published checks

Golden and boundary cases from the legacy Evidence JSON. CVP property, metamorphic, round-trip, O3, and interface statuses/checks are recorded in the Manifest — including SKIP when a suite has no vectors.

ID	Kind	Status	Detail
`basic`	golden	pass	Expected product=48 · Actual product=48 · productStr=48 · mode=product · gridTruncated=false
`large`	golden	pass	Expected product=163328 · Actual product=163328 · productStr=163328 · mode=product · gridTruncated=false
`decimal`	golden	pass	Expected product=9.492 · Actual product=9.492 · productStr=9.492 · mode=product · gridTruncated=false
`negative`	golden	pass	Expected product=-55 · Actual product=-55 · productStr=-55 · mode=product · gridTruncated=false
`zero`	golden	pass	Expected product=0 · Actual product=0 · productStr=0 · mode=product · gridTruncated=false
`long-mode`	golden	pass	Expected product=144 · productStr=144 · mode=long · Actual product=144 · productStr=144 · mode=long · work=Long multiplication (standard algorithm) 12 × 12 ---- 24 + 120 -------- = 144 Step-by-step: 1. Multiply by the ones digit (2): 12 × 2 = 24 2. Multiply by the tens digit (1): 12 × 1 = 12 (shift 1 place → 120) Add the partial products. Therefore: 12 × 12 = 144 · gridTruncated=false
`exact-0p1-0p2`	golden	pass	Expected productStr=0.02 · Actual product=0.02 · productStr=0.02 · mode=product · gridTruncated=false
`forty-eight-digits`	golden	pass	Expected productStr=111111111111111111111111111111111111111111111111 · Actual product=1.1111111111111111e+47 · productStr=111111111111111111111111111111111111111111111111 · mode=product · gridTruncated=false
`long-carry`	golden	pass	Expected productStr=998001 · mode=long · Actual product=998001 · productStr=998001 · mode=long · work=Long multiplication (standard algorithm) 999 × 999 ----- 8991 + 89910 + 899100 -------- = 998001 Step-by-step: 1. Multiply by the ones digit (9): 999 × 9 = 8991 2. Multiply by the tens digit (9): 999 × 9 = 8991 (shift 1 place → 89910) 3. Multiply by the 10^2 digit (9): 999 × 9 = 8991 (shift 2 places → 899100) Add the partial products. Therefore: 999 × 999 = 998001 · gridTruncated=false
`long-24-digit`	golden	pass	Expected productStr=222222222222222222222222 · mode=long · gridTruncated=false · Actual product=2.2222222222222222e+23 · productStr=222222222222222222222222 · mode=long · work=Long multiplication (standard algorithm) 111111111111111111111111 × 2 ------------------------ 222222222222222222222222 ------------------------ = 222222222222222222222222 Step-by-step: 1. Multiply by the ones digit (2): 111111111111111111111111 × 2 = 222222222222222222222222 Add the partial products. Therefore: 111111111111111111111111 × 2 = 222222222222222222222222 · gridTruncated=false
`missing-a`	boundary	pass	Expected INVALID_INPUT · Actual INVALID_INPUT
`missing-b`	boundary	pass	Expected INVALID_INPUT · Actual INVALID_INPUT
`boundary-mul-sci`	boundary	pass	Expected SCIENTIFIC_NOT_SUPPORTED · Actual SCIENTIFIC_NOT_SUPPORTED
`boundary-mul-49-digits`	boundary	pass	Expected TOO_MANY_DIGITS · Actual TOO_MANY_DIGITS
`boundary-mul-long-25-grid`	boundary	pass	Expected productStr=2222222222222222222222222 · gridTruncated=true · warning=LONG_GRID_TRUNCATED · Actual product=2.2222222222222222e+24 · productStr=2222222222222222222222222 · mode=long · gridTruncated=true · warning=LONG_GRID_TRUNCATED