Finite Erdos Denominator-Order Certificate Strike

Component sums s

This component sums S_F(b) = sum 1/(b^n - 1) as an exact fraction P/Q and checks whether the multiplicative order of b modulo the reduced denominator Q equals lcm(F). finite_erdos_denominator_certificate_strike computes one finite number-theoretic object in exact whole-number arithmetic and checks a sharp claim about it. For a finite set of exponents F and a base b, it sums S_F(b) = sum_{n in F} 1/(b^n - 1) as an exact fraction P/Q, then asks whether the multiplicative order of b modulo the reduced denominator Q equals the least common multiple of F.

Runs four small

It runs four small cases, two true certificates to accept and two forgeries to reject, and writes a metadata-only result record of the status and per-case values. The component runs four small cases. Two are true certificates the checker should accept, including one where a common prime cancels in the fraction. Two are forged certificates the checker should reject. Each run writes a metadata-only result record that reports the status and the per-case values.

Is finite identity

This is the finite identity behind the Erdos #257 period-noncollapse strike, not a solution to the open infinite problem, and a holding certificate is computational evidence, not a proof. This is the finite identity behind the Erdos #257 period-noncollapse strike. It is not a solution to the open infinite problem, and a holding certificate over the bounded fixture set is computational evidence, not a proof.

Purpose

An easy claim to get wrong

The claim ord_Q(b) = lcm(F) is easy to get wrong: floating-point order, a trusted stored answer, or a single-derivation denominator each let a wrong certificate slip through. The claim ord_Q(b) = lcm(F) is easy to state and easy to get wrong. A loose version would compute the order with floating point, or trust a stored expected answer, or check the denominator without deriving it a second way. Any of those lets a wrong certificate slip through unnoticed.

Exact arithmetic and a recomputing checker

The component sums in exact Python fractions, derives the denominator two independent ways that must agree, and never accepts a claimed certificate on its word: the checker recomputes and compares. This component computes the object exactly and lets a small checker decide it, so a reader can see where the evidence stops. The arithmetic uses Python fractions, never floats. The denominator is derived once by reduction and a second time by a closed form, and the two must agree. A claimed certificate is never accepted on its word: the checker recomputes the truth and compares.

How it works

Bundle arithmetic, component driver

The engine-room bundle finite_denominator_order_certificate.py holds the exact arithmetic while the component file drives it over fixture cases and writes the records. The engine-room bundle finite_denominator_order_certificate.py holds the arithmetic. The component file drives it over fixture cases and writes the records.

compute_* sums and cross-checks Q

compute_finite_denominator_order_certificate sums the exact fraction, reads the reduced denominator Q, finds ord_Q(b) by repeated multiplication, and cross-checks Q against the closed form B/gcd(A_L, B). compute_finite_denominator_order_certificate(support, base) is the core. It normalises F to a sorted set, sums Fraction(1, base**n - 1) over the members, and reads the reduced denominator Q from the resulting fraction. It computes ord_Q(b) with multiplicative_order, which finds the smallest k with b**k = 1 mod Q by repeated multiplication, with no factorisation. It then derives Q a second, independent way: with L = lcm(F), B = b^L - 1, and A_L = sum_{n in F} B/(b^n - 1), the closed form is Q = B / gcd(A_L, B). Every n in F divides L, so each b^n - 1 divides B and A_L is an exact integer; an assert guards that exact division. The returned holds is true only when the order equals L, the reduced denominator equals the closed form, b is coprime to Q, and Q > 1.

verify_* is self-falsifying

verify_finite_denominator_order_certificate recomputes the truth from (support, base), emits a typed mismatch code per disagreeing field, and returns valid only when nothing mismatches and the recomputed certificate holds. verify_finite_denominator_order_certificate(support, base, claimed) is the self-falsifying check. It recomputes the truth from (support, base) and ignores the claimed values except to compare them. For each supplied field it emits a mismatch code: ERDOS_CERT_NUMERATOR_MISMATCH, ERDOS_CERT_DENOMINATOR_MISMATCH, or ERDOS_CERT_ORDER_MISMATCH. It returns valid only when nothing mismatches and the recomputed certificate holds.

The component drives fixtures to a status

run and build_result evaluate each fixture case, and the run is pass only with at least one positive and one negative case, every positive holding, every negative rejected, and both forgery ids present. The component file wraps these. run loads the input directory, calls build_result, and writes the result, board, and validation records. build_result reads the cases through _fixture_cases and evaluates each with _evaluate_case. A positive case calls compute_* and, for the reduction case, also requires that a reduction occurred. A negative case calls verify_* and checks that it was rejected with the exact codes named in EXPECTED_NEGATIVE_CASES. The run status is pass only when there is at least one positive and one negative case, every positive holds, every negative is rejected as expected, and both planted forgery ids are present.

flowchart TD Input["Support F, base b"] Sum["Exact sum S_F(b) = P/Q as a Fraction"] Denom["Reduced denominator Q cross-checked against B/gcd(A_L,B)"] Order["Multiplicative order ord_Q(b) by repeated multiplication"] Check["Certificate holds if ord_Q(b) = lcm(F)"] Verify["Forgery check recompute and compare claimed values"] Input --> Sum Sum --> Denom Denom --> Order Order --> Check Check --> Verify

Negative cases

Two forgeries in

The two forgeries in the fixture set both change exactly one field and rely on recomputation to catch it. The two forgeries in the fixture set both change exactly one field and rely on recomputation to catch it.

A forged denominator is recomputed away

forged_denominator_rejected claims Q = 5 for F = {3}, b = 2, but the checker recomputes the true Q = 7 and rejects with ERDOS_CERT_DENOMINATOR_MISMATCH. forged_denominator_rejected uses F = {3}, b = 2. The true sum is 1/7, so Q = 7 and ord_7(2) = 3 = lcm({3}). The claim states the denominator is 5. The checker recomputes Q = 7, sees the disagreement, and rejects with ERDOS_CERT_DENOMINATOR_MISMATCH.

A forged order is recomputed away

forged_order_rejected claims order 5 for F = {1, 2}, b = 2, but the checker recomputes ord_3(2) = 2 and rejects with ERDOS_CERT_ORDER_MISMATCH. forged_order_rejected uses F = {1, 2}, b = 2. The true sum is 4/3, so Q = 3 and ord_3(2) = 2 = lcm({1, 2}). The claim states the order is 5. The checker recomputes the order as 2 and rejects with ERDOS_CERT_ORDER_MISMATCH.

The identity survives a reduction

certificate_holds_after_reduction uses F = {2, 3}, b = 2 where the prime 3 cancels to Q = 21, and ord_21(2) = 6 = lcm({2, 3}) still holds. For contrast, certificate_holds_after_reduction uses F = {2, 3}, b = 2. The sum is 1/3 + 1/7 = 10/21. The closed form gives B = 63, A_L = 30, gcd(30, 63) = 3, so Q = 63/3 = 21. The prime 3 cancels, Q is smaller than B, and ord_21(2) = 6 = lcm({2, 3}) still holds. This is the case that shows the identity surviving a reduction rather than only the no-reduction case certificate_holds where F = {2} gives 1/3 directly.

Prior Art Grounding

Elementary number theory with a cross-check

The arithmetic is standard elementary number theory, exact rational summation, reduced denominators, and multiplicative order, with a closed-form cross-check, stated here only for finite support under Erdos #257. The arithmetic is standard elementary number theory: exact rational summation, reduced denominators, and multiplicative order by repeated multiplication, with a closed-form cross-check Q = B/gcd(A_L, B) derived from divisibility of b^n - 1 into b^L - 1. The finite identity ord_Q(b) = lcm(F) sits under the Erdos #257 period-noncollapse question and is stated here only for finite support. The engineering lineage is the local Plectis coverage contract: a reader page states what fixture can be rerun, what generated projections are navigation aids, and what stays outside the evidence boundary. No external citation is claimed.

Validation Result record Path

Run the component over its fixture set and rerun its test:

What a pass means here

A pass means both positive certificates held, both forgeries were rejected with their expected mismatch codes, and the run wrote a metadata-only record, covering only the bounded fixture inputs in this checkout. A pass means both positive certificates held, both forgeries were rejected with their expected mismatch codes, and the run wrote a metadata-only result record. A pass covers only the bounded fixture inputs in this checkout.