PIRTM / paper /counter-paper.md
SNAPKITTYWEST's picture
October 2026 main drop: mirror from GitHub
74db60e verified
|
Raw History Blame Contribute Delete
9.3 kB

On the Vacuity of Fact/Assert-Identical Verification

An Alloy counter-paper on the HCALC verification logs

PIRTM — Prime-Indexed Recursive Tensor Mathematics Ahmad Ali Parr · 2026-10-10


0. Abstract

The HCALC repository (github.com/AHMADALIPARR/hcalc) ships Alloy 6.2.0 verification logs in which every check — A1–A7, P1–P8, and ten INV_* invariants — reports UNSAT (PASS). We show that these results are vacuous: in every case we examined, the assertion under check is formula-identical to (a fragment of) a fact already enforced on the model, so no counterexample is possible by construction. We prove the method cannot distinguish true claims from false ones by exhibiting a runnable Alloy model in which a false real-world claim passes with UNSAT under the identical pattern. We close by crediting what is genuinely verified (the Lean 4 formalization: 1968 jobs, zero sorry) and stating what non-vacuous Alloy verification would require.

Nothing in this paper disputes the HCALC definitions (PRODUCTION.md). It disputes what the Alloy logs establish.


1. The claim under test

hcalc/alloy/logs/alloy-check.txt (2026-10-07) reports, for Alloy 6.2.0:

=== A1-A7 sealed PROPERTY_MAP (UNSAT = pass) ===
A1_P64_cardinality_and_distinct              UNSAT (PASS)
...
A7_production_defined_records                UNSAT (PASS)

=== Production P1-P8 (UNSAT = pass) ===
P1_carrier_linf_dim                          UNSAT (PASS)
...
P8_contractalg_gershgorin_then_c             UNSAT (PASS)

=== INV_* checks (UNSAT = pass) ===
... (10 more) ...

The governing note reads: "UNSAT = PASS for checks". The reader is invited to conclude that Alloy verified the sealed properties. It did not. It re-confirmed its own input.


2. The pattern

Every check we inspected follows one shape. Using A7 as the canonical example (alloy/HCALC.als):

fact A7_production_all_spec_defined {
  GapRecord_LambdaM.status = SpecDefined
  ...                                   -- P enforced on all instances
}

assert A7_production_defined_records {
  ...
  GapRecord_LambdaM.status = SpecDefined
  ...                                   -- P asserted
}

check A7_production_defined_records     -- UNSAT, logged as "PASS"

The assert is formula-identical to the fact. Alloy's check searches for an instance satisfying all facts and violating the assertion. The facts define the assertion's content, so the search space of counterexamples is empty a priori. UNSAT is not a discovery; it is a restatement of the input.

The same identity holds, verbatim, across the model:

Check Fact enforces Assert restates File
A1 P64Carrier.declaredCard = 64 declaredCard = 64 + index ranges modules/PrimeIndex.als
P2 tp.isDiagonal = 1 ∧ tp.alphaLaw = SpecAlphaLaw identical formula modules/Transform.als
INV_converge convergence_hyps_production convergence_hyps_production modules/Converge.als
A6 guardian verdict implications identical implications modules/Converge.als
INV_evolution_total all s: State | some t: Time | t.at = s identical formula modules/State.als
A7 all GapRecords = SpecDefined identical conjunction HCALC.als

In no case does the assertion derive anything from independently modeled structure. In no case could a counterexample exist without contradicting a fact.


3. What the flags hide

Even where the pattern were sound, the model checks flags, not mathematics:

  • A1 does not verify 64 primes. It sets the integer constant declaredCard = 64 and checks the constant equals 64. The prime values are explicitly deferred: "Numeric prime VALUES remain Lean L1; here we only constrain indices 0..63 distinct." The comment is honest; the UNSAT (PASS) line is not.
  • P2 does not verify αⱼ = 1/(1+log p_{j mod 64}). No logarithm, no prime value, no real arithmetic appears in the model. SpecAlphaLaw is an uninterpreted atom; the check confirms the atom is attached where the fact attached it. That is bookkeeping.
  • A2 ("contractive ↔ Gershgorin bound") never computes a Gershgorin disc. The operator norm is an Int flag.
  • A6 ("guardian rejects spectral_radius ≥ 1") never computes a spectral radius. The radius is an Int flag (spectralRadiusGeOne).

A check that cannot see the mathematics cannot verify the mathematics. What Alloy verified, at most, is that the flag bookkeeping is self-consistent — which the facts already guaranteed.


4. Exhibit A — the method passes a false claim

alloy/vacuity-demo.als (runnable, Alloy 6.2.0):

one sig Moon { madeOfCheese: Int }

fact claim_as_fact { Moon.madeOfCheese = 1 }   -- the HCALC move

assert MoonIsCheese { Moon.madeOfCheese = 1 }  -- the HCALC "verification"

check MoonIsCheese for 3

Result, reproduced 2026-10-10:

00. check MoonIsCheese             0       UNSAT

The moon is not made of cheese. The check "passed." Any claim installed as a fact passes. The HCALC UNSAT (PASS) lines therefore carry zero bits of information about the world, the primes, the contraction bounds, or the guardian. They carry exactly one bit: the facts were read successfully.


5. Exhibit B — structural mirrors of A7 and P2

alloy/hcalc-mirror.als reproduces the A7 and P2 fact/assert pairs with renamed signatures and the identical logical shape, plus a non-vacuous control:

00. check hcalc_A7_assert          0       UNSAT
01. check hcalc_P2_assert          0       UNSAT
02. check weights_positive         0       UNSAT

Checks 00 and 01 are the tautologies. Check 02 is different: its fact models a generator (c.w = 2, standing in for a computed weight law) while the assertion (all c: Cell | c.w > 0) is not among the facts. Had the generator been c.w = -5, Alloy would have produced a counterexample. Falsifiability is the difference between verification and transcription. Checks 00/01 (and every HCALC check in §2) lack it; check 02 has it.


6. What is genuinely verified — credited in full

The Lean 4 formalization is the real thing:

  • lean/build.log: build completed successfully (1968 jobs)
  • grep -rn "sorry": zero occurrences
  • Toolchain pinned: leanprover/lean4:v4.34.1

A zero-sorry Lean build is machine-checked proof, not bookkeeping. The convergence lemmas (L5), the InstanceBridge non-identity morphism (L7), and the prime-indexed definitions (L1/L6) stand on this ground. This paper does not touch them. The flaw is localized entirely to what the Alloy logs are claimed to establish — and, by extension, to any downstream claim that "Alloy verified" the sealed properties A1–A7 / P1–P8.


7. What non-vacuous Alloy verification would require

  1. Facts model generators, not conclusions. Model the prime list (or a faithful finite fragment), the weight-law computation, the norm estimates — then assert the consequences.
  2. Assertions must be falsifiable in principle. For each check, exhibit (or argue) an instance class the facts admit in which the assertion fails. If none exists, the check is transcription.
  3. No flag-encoding of the thing to be proved. An uninterpreted atom named SpecAlphaLaw cannot verify αⱼ = 1/(1+log pⱼ).
  4. Separate the harness from the honor. A log line UNSAT (PASS) must mean "no counterexample exists in scope," not "the fact was restated correctly."

8. Conclusion

The HCALC Alloy logs prove that the HCALC Alloy model is consistent with itself. They do not verify A1–A7, P1–P8, or any INV_* invariant in any sense that could fail. Exhibit A shows the method passes false claims; Exhibit B shows the exact structural identity between HCALC's facts and its assertions, alongside a falsifiable control that demonstrates what the missing property looks like.

The mathematics may well be correct — the Lean build suggests much of it is — but correctness of the definitions and verification by the Alloy logs are different claims, and only the first is earned. Until the Alloy model is rewritten so its checks can fail, every UNSAT (PASS) should be read as TAUTOLOGY (UNINFORMATIVE).


Reproduction

# Exhibits A and B (Alloy 6.2.0, bundled jar):
java -jar alloy.jar exec -f -t text alloy/vacuity-demo.als
java -jar alloy.jar exec -f -t text alloy/hcalc-mirror.als

# Expected:
#   00. check MoonIsCheese             0       UNSAT
#   00. check hcalc_A7_assert          0       UNSAT
#   01. check hcalc_P2_assert          0       UNSAT
#   02. check weights_positive         0       UNSAT

Model under test: github.com/AHMADALIPARR/hcalc (Alloy sources as of 2026-10-07; log alloy/logs/alloy-check.txt).


PIRTM is Prime-Indexed Recursive Tensor Mathematics: the compiler IR for tensor programs lowering to Goldilocks field arithmetic. This paper is issued from inside that program, against the HCALC instantiation's verification claims — not against its definitions, its Lean proofs, or its authors' mathematics.