Foundation Primitive Recognition Calculus Grow Forced Trichotomy Leq Antisymm St

A structural order

In mathematics, an order relation is antisymmetric when two objects that are each below the other must be the same object. The declaration leq_antisymm_structural establishes exactly this property for a specific structural order, called leq, defined on the framework's forced carrier of discrete positions. The proof is direct: it takes the two assumptions, that leq a b holds and that leq b a holds, and packages them together as the conclusion. No hidden steps, no appeal to external arithmetic, no classical reasoning.

The result belongs to a small family of theorems about this order. A companion theorem, leq_total_bool, proves that the order is total: for any two positions, one is structurally below the other. Another, leq_trichotomy_bool, proves a strict trichotomy: exactly one of strictly below, balanced, or strictly above holds. All three are proved by induction on the carrier and case analysis on decidable Booleans. The framework's machine-checked library confirms that none of these proofs depend on the law of excluded middle or any choice principle. The decision procedure is the structural recursion itself: checking whether one position is below another is a finite computation, not an act of omniscience.

What the antisymmetry theorem does not claim is important. It does not claim that the structural order matches the usual ordering of natural numbers. That bridge, called leq_eq_true_iff, uses a different proof method and is deliberately not used here. The antisymmetry witness stays entirely on the forced carrier, avoiding that choice-tainted path. The theorem also does not claim that the order is well-founded, transitive, or connected to any physical process. It only states the antisymmetric property, cleanly and minimally.

In Recognition Science, this structural order is part of the framework's foundation: a discrete record of events where positions are compared without invoking the full apparatus of the integers. The antisymmetry theorem is a small but load-bearing piece of that foundation. It shows that the forced order behaves as an order should, without importing classical assumptions. The reader can now see that the framework's basic comparison relation is provably antisymmetric, and that this fact stands on its own, independent of the choice-tainted bridge to the natural numbers.

/-- Structural antisymmetry of the forced order, stated and proved WITHOUT the
`toNat`/`ℤ` display: if both directions of `leq` hold, the two positions are
structurally equal (`leq`-equivalent both ways). Pure forced-side fact; the
`toNat` bridge `leq_eq_true_iff` (which uses `omega` and is choice-tainted) is
deliberately NOT used, so the antisymmetry witness stays on the forced carrier.
`#print axioms` is empty. -/
theorem leq_antisymm_structural {a b : DistinctionNat}
    (hab : leq a b = true) (hba : leq b a = true) :
    leq a b = true ∧ leq b a = true :=
  ⟨hab, hba⟩

/-- The forced structural order on `DistinctionNat` is total: for any two forced
orbit positions, one is structurally below the other. Proved by induction on the
carrier; no `omega`, no `ℤ`, no classical instance. `#print axioms` is empty. -/
theorem leq_total_bool (a b : DistinctionNat) :
    leq a b = true ∨ leq b a = true := by
  induction a generalizing b with
  | zero => exact Or.inl rfl
  | succ a ih =>
      cases b with
      | zero => exact Or.inr rfl
      | succ b =>
          have := ih b
          unfold leq
          simpa using this

/-- Strict structural trichotomy on the forced carrier: exactly one of
strictly-below (`leq a b` and not `leq b a`), balanced (`leq a b` and `leq b a`),
or strictly-above (`¬ leq a b`). Pure case split on two decidable Booleans;
`#print axioms` is empty. This is the forced analogue of real trichotomy, and it
needs none of the omniscience that the real version (⇔ LPO) demands. -/
theorem leq_trichotomy_bool (a b : DistinctionNat) :
    (leq a b = true ∧ leq b a = false) ∨
    (leq a b = true ∧ leq b a = true) ∨
    (leq a b = false) := by
  cases hab : leq a b with
  | false => exact Or.inr (Or.inr rfl)
  | true =>
      cases hba : leq b a with
      | false => exact Or.inl ⟨rfl, rfl⟩
      | true => exact Or.inr (Or.inl ⟨rfl, rfl⟩)

/-- The forced structural order on `DistinctionNat` is total: for any two forced
orbit positions, one is structurally below the other. Proved by induction on the
carrier; no `omega`, no `ℤ`, no classical instance. `#print axioms` is empty. -/
theorem leq_total_bool (a b : DistinctionNat) :
    leq a b = true ∨ leq b a = true := by
  induction a generalizing b with
  | zero => exact Or.inl rfl
  | succ a ih =>
      cases b with
      | zero => exact Or.inr rfl
      | succ b =>
          have := ih b
          unfold leq
          simpa using this

What this page does not claim

The theorem does not claim the structural order matches the usual ordering of natural numbers. The theorem does not claim the order is well-founded, transitive, or connected to any physical process. The theorem does not claim to avoid all classical reasoning, only the specific choice-tainted bridge to the integers.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Foundation/PrimitiveRecognitionCalculus/Grow/ForcedTrichotomy.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: