Foundation Primitive Recognition Calculus Prcone Primitive Comparison Is Derived

The derived comparison

In the Recognition Science framework, the act of recognition is the single primitive event. It produces a discrete record, called a ledger, of what was recognized. The question this theorem answers is whether the framework also needs a second, independent primitive: the ability to compare two entries and judge them the same or different. The theorem states that it does not. Comparison is derived from the act-generated structure, not posited as a separate axiom.

The formal setting is deliberately minimal. A trace of acts generates a type with exactly two endpoints, named left and right. A judgment is any relation on these endpoints that is an equivalence, is tight (the diff judgment is the negation of same), and separates the two endpoints (they are judged different). The theorem proves that any such judgment, satisfying only those three conditions, is forced to be the decidable equality carried by the structure itself. In symbols: for any endpoints a and b, J.same T a b holds if and only if a = b. The proof uses only structural recursion on the constructors and the admissibility fields of the judgment.

This is a uniqueness result in the same spirit as the framework's central cost theorem: a small set of plain conditions leaves no freedom. Here, the conditions are that the judgment is an equivalence, tight, and separating. The conclusion is that the same/different judgment is not a second primitive but a derived instance, computed by decide on a freely generated type. The framework's library proves this in a machine-checked collection of formal theorems.

What this does not claim is broader. It does not claim that all comparison in all of mathematics reduces to this construction; it concerns only the two-endpoint type generated by a single act. It does not claim that the act-generated structure is the only way to build a decidable equality. And it does not claim that the framework's other primitives, such as the cost function, are derived from this comparison. The theorem is a precise, local statement about one primitive, and it is exactly as strong as its hypotheses.

/-- **Item 5 resolution.** Recognition is one primitive. For any judgment that is
an equivalence (the admissibility fields), tight, and separating, the `same`
relation is forced to be the decidable equality carried by the act-generated
structure. Hence the same/different judgment is derived from the act, not an
independent second primitive. -/
theorem comparison_is_derived_not_primitive
    (J : TraceJudgment)
    (htight : ∀ (T : Trace) (a b : Endpoint), J.diff T a b ↔ ¬ J.same T a b)
    (hsep : ∀ T : Trace, J.diff T Endpoint.left Endpoint.right) :
    ∀ (T : Trace) (a b : Endpoint),
      (J.same T a b ↔ a = b)
        ∧ (J.same T a b ↔ actJudgment.same T a b) := by
  intro T a b
  have h := genuine_judgment_same_is_equality J htight hsep T a b
  exact ⟨h, h.trans (actJudgment_same T a b).symm⟩

/-- Core forcing lemma. On the two-endpoint type, an equivalence that does not
relate `left` to `right` is equality. Only reflexivity and symmetry of `same`
are used, both supplied by the `TraceJudgment` admissibility fields. -/
theorem genuine_judgment_same_is_equality
    (J : TraceJudgment)
    (htight : ∀ (T : Trace) (a b : Endpoint), J.diff T a b ↔ ¬ J.same T a b)
    (hsep : ∀ T : Trace, J.diff T Endpoint.left Endpoint.right)
    (T : Trace) (a b : Endpoint) :
    J.same T a b ↔ a = b := by
  have hne : ¬ J.same T Endpoint.left Endpoint.right :=
    (htight T Endpoint.left Endpoint.right).mp (hsep T)
  constructor
  · intro hsame
    rcases endpoint_eq_left_or_right a with ha | ha <;>
      rcases endpoint_eq_left_or_right b with hb | hb <;>
      subst ha <;> subst hb
    · rfl
    · exact absurd hsame hne
    · exact absurd (J.same_symm T hsame) hne
    · rfl
  · intro hab
    subst hab
    exact J.same_refl T a

/-- The forced comparison is decidable, computed purely from the act-generated
inductive structure. This is the formal sense in which "compare" needs no second
primitive: it is `decide` on a freely generated type. -/
instance actJudgment_same_decidable (T : Trace) (a b : Endpoint) :
    Decidable (actJudgment.same T a b) := by
  show Decidable (a = b)
  exact inferInstance

What this page does not claim

All comparison in all of mathematics reduces to this construction. The act-generated structure is the only way to build a decidable equality. The framework's other primitives, such as the cost function, are derived from this comparison.

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/PRCOnePrimitive.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: