Public evidence

math.lcm

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· ≥2 integers; any zero → 0 · Protocol · Schema · Production report

Declared partition coverage: PASS · 8/8 declared partitions (lcm, zero, negative, beyond-safe-integer, multi-input-fold, method-unavailable, xcal, 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 · 3/3 property · digest 243e5df78591

Verification

Legacy regression suite: 20/20 calculation tests · Production surface contract 3/3

Three distinct suites: educational examples on the calculator page, this legacy regression count (20/20 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. 6/6 golden · 7/7 CVP boundary · 3/3 invalid · 3/3 property · 1/1 metamorphic · 1/1 cross-interface · 5/5 cross-calculator · 3/3 CVP contract. digest 243e5df78591.

Golden (oracle-backed) 6 / 6
CVP boundary 7 / 7
Invalid input 3 / 3
Property 3 / 3
Metamorphic 1 / 1
Cross-interface 1 / 1
Cross-calculator 5 / 5
CVP contract 3 / 3
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

Fingerprint sha256:62a0e9019643f335db75c98d5c88ecee0126aa9f73cf7bf254e05ebe0a8df03d

Input schema sha256:406a5bb31353872aa4fe85e38681683b0888c28cf55e160479c44d913b2e2676 · Output schema sha256:f1ed2b6e695a6cfece646896e9d9bedd8a4f1bb989bcbf17c38ca66e061106cf · 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: lcm
Engine: lcm
Engine build: 2026-09-16
Evidence core: 2026-09-16T06:41:00.884Z
Rendered: 2026-09-16T22:03:43.771Z
Last reviewed: —

Assumptions

Integer inputs; negatives treated by absolute value.
If any input is 0, LCM = 0. LCM(0,0)=0 is a CalculatorX/Python convention, not a GCF-identity derivation.
For nonzero inputs the result is a positive integer.

Limitations

Integers only; negatives treated by absolute value
Each integer ≤ 48 decimal digits (product bound, not a mathematical bound)
If any input is 0, LCM = 0. LCM(0,0)=0 is a CalculatorX/Python convention (not a GCF-identity derivation)
Need at least two numbers → NEED_TWO_NUMBERS
Non-integers → INVALID_NUMBER
Integers beyond MAX_SAFE_INTEGER must be decimal strings in JSON

Sources

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

Encyclopedia of Mathematics — Least common multiple — Definition; pairwise fold; relation to GCD
Supports: LCM of n integers via pairwise fold; lcm(a,b)·gcd(a,b)=|ab| for nonzero a,b
Python math.lcm — zero convention — If any argument is zero, LCM = 0
Supports: Any zero argument → 0; LCM(0,0)=0 is that convention, not |a/GCF(a,b)×b| (GCF(0,0)=0)
CalculatorX integer convention — Absolute value; 48-digit BigInt domain; divide-first identity
Supports: Negatives by |n|; exact BigInt with a product digit cap; LCM(a,b)=|a/GCF(a,b)×b|

Methods

Algorithms this engine uses. Not external references.

Pairwise GCF-identity fold (canonical engine; divide before multiply)
Prime-factor LCM (cross-check when every |n| ≤ 1,000,000 and none is 0)
Listing multiples (cross-check when LCM ≤ 5,000 and every |n| ≤ 500)

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
`pair`	golden	pass	Expected value=24 · exact=24 · Actual value=24 · exact=24 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`via-gcf`	golden	pass	Expected value=30 · Actual value=30 · exact=30 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`triple`	golden	pass	Expected value=180 · Actual value=180 · exact=180 · count=3 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`with-zero`	golden	pass	Expected value=0 · Actual value=0 · exact=0 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`bigint-unsafe`	golden	pass	Expected value=9007199254740993 · Actual value=9007199254740993 · exact=9007199254740993 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`numsInput`	golden	pass	Expected value=24 · Actual value=24 · exact=24 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`boundary-one-number`	boundary	pass	Expected NEED_TWO_NUMBERS · Actual NEED_TWO_NUMBERS
`boundary-missing`	boundary	pass	Expected MISSING_REQUIRED_INPUT · Actual MISSING_REQUIRED_INPUT
`boundary-non-integer`	boundary	pass	Expected INVALID_NUMBER · Actual INVALID_NUMBER
`boundary-alias-numsInput`	boundary	pass	Expected value=24 · exact=24 · Actual value=24 · exact=24 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`boundary-all-zero`	boundary	pass	Expected value=0 · Actual value=0 · exact=0 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`boundary-bigint-unsafe`	boundary	pass	Expected value=9007199254740993 · Actual value=9007199254740993 · exact=9007199254740993 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`boundary-negatives`	boundary	pass	Expected value=24 · Actual value=24 · exact=24 · count=2 · formula=LCM(a,b,c,…) = LCM(LCM(a,b),c,…) · binary_formula=LCM(a,b)=\|a/GCF(a,b)×b\| · zero_formula=If any input is 0, LCM = 0 · max_digits=48
`property-commutative-fold`	property	pass	LCM(8,12) = LCM(12,8) = 24
`property-three-methods-agree`	property	pass	listing, prime, and GCF identity all return 24
`property-zero-annihilates`	property	pass	LCM(0,12,18) = 0
`property-gcf-identity`	property	pass	LCM(8,12)×GCF(8,12) = \|8×12\|
`property-bigint-beyond-safe-integer`	property	pass	LCM(9007199254740993, 3) = 9007199254740993 (BigInt; IEEE-754 Number would round)
`property-pairwise-associative`	property	pass	LCM(LCM(12,18),30) = LCM(12,18,30)
`property-multiple-of-each`	property	pass	24 is a multiple of 8 and 12