Foundation Primitive Recognition Calculus Prcone Primitive Act Judgment Same

The forced comparison

In ordinary mathematics, deciding whether two objects are equal is usually taken for granted. Recognition Science asks what happens when comparison itself must be derived from a more primitive act. The framework's ledger, a discrete record of events, begins with a single act that generates two distinct endpoints, conventionally called left and right. The question is whether the judgment "same" or "different" requires an additional primitive rule, or whether the act itself forces it.

The declaration actJudgment_same establishes the answer in formal terms. It states that for any trace in the ledger, the judgment that two endpoints are the same holds exactly when the endpoints are equal. In symbols, actJudgment.same T a b ↔ a = b. This is not an assumption; it is a theorem proved by direct structural recursion on the act-generated endpoints. The companion theorem actJudgment_diff states the dual: the judgment that two endpoints differ holds exactly when they are not equal.

The force of these theorems is that comparison is derived, not posited. The framework proves a stronger result, comparison_is_derived_not_primitive: any judgment that is an equivalence, tight (different is the negation of same), and separating (left and right are always judged different) must coincide with the act-generated equality. In plain language, if a comparison mechanism behaves like a proper equivalence relation and distinguishes the two endpoints, then it has no freedom; it is forced to be the equality carried by the structure itself. The same/different judgment is therefore a consequence of the act, not an independent second primitive.

This result matters because it removes a potential circularity. If the framework needed a separate rule for comparison, that rule would itself require justification. Instead, the act of generating two distinct endpoints automatically supplies decidable equality. The framework's library of machine-checked theorems shows that "compare" needs no second primitive: it is computed purely from the freely generated type. This is the formal sense in which recognition is one primitive, not two.

What the declaration does not claim is equally important. It does not say that all comparison in mathematics reduces to this act; it concerns only the two-endpoint type generated by the primitive act. It does not assert that the endpoints have any internal structure; they are just two distinct markers. And it does not address how the judgment extends to larger structures; that is a separate question. The theorem is narrow, but within its scope it is complete: comparison is forced, not chosen.

theorem actJudgment_same (T : Trace) (a b : Endpoint) :
    actJudgment.same T a b ↔ a = b := Iff.rfl

theorem actJudgment_diff (T : Trace) (a b : Endpoint) :
    actJudgment.diff T a b ↔ a ≠ b := Iff.rfl

/-- **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⟩

/-- **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⟩

What this page does not claim

The theorem does not claim that all comparison in mathematics reduces to this primitive act. It does not assert that the endpoints have any internal structure beyond being distinct markers. It does not address how the judgment extends to larger structures beyond the two-endpoint type.

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: