Foundation Primitive Recognition Calculus Prcone Primitive Act Judgment

The derived act of comparison

In the Recognition Science framework, the foundational question is how a system that only records discrete events can ever judge whether two things are the same or different. The declaration actJudgment answers this by showing that comparison is not a separate primitive: it is a derived capacity, computed from the structure of the act itself. The framework defines a ledger, a discrete record of events, whose most basic entries are two endpoints, called left and right. The judgment same is then simply equality of endpoints, and diff is their inequality, both decided by the structure of the record alone.

This is a formal construction in the framework's machine-checked library of formal theorems. The key theorems state that for any comparison judgment satisfying three plain conditions, being an equivalence relation, being tight (diff is the negation of same), and separating the two endpoints, the same-relation is forced to be exactly the equality carried by the act-generated structure. The proof uses only the reflexivity and symmetry of the equivalence, supplied by the admissibility fields. The result is that the same/different judgment is derived, not an independent second primitive: comparison needs no extra rule beyond the act itself.

What this does not claim is broader than what it establishes. It does not claim that the physical act of recognition in the world is literally this formal construction, only that within the framework's calculus, comparison is so derived. It does not claim that the judgment is decidable in any computational sense beyond the structural recursion on the constructors, which is a formal property of the type, not a claim about practical algorithms. It does not claim that the two endpoints exhaust all possible distinctions, only that a distinction has exactly two endpoints in this primitive calculus.

The consequence is that the framework's foundational vocabulary shrinks: recognition is one primitive, and comparison falls out of it. This matters because it removes a potential circularity in the framework's starting point, where one might have feared that sameness and difference had to be assumed before any recognition could occur. The formal result shows that within the calculus, the act itself generates the capacity to compare, and this is what the declaration establishes.

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

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

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

/-- A distinction has exactly two endpoints. -/
theorem endpoint_eq_left_or_right (e : Endpoint) :
    e = Endpoint.left ∨ e = Endpoint.right := by
  obtain ⟨s⟩ := e
  cases s with
  | left => exact Or.inl rfl
  | right => exact Or.inr rfl

What this page does not claim

The declaration does not claim that physical recognition in the world is literally this formal construction. It does not claim the judgment is decidable beyond the structural recursion on the constructors. It does not claim the two endpoints exhaust all possible distinctions in the framework.

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: