Foundation Pair Kernel Production Quotient Identification S23 Physical Observabl

What the theorem ties together

In the Recognition Science framework, a physical system is modeled as a discrete record of recognition events, a ledger that keeps track of every response the system makes. The framework's library, a machine-checked collection of formal results, proves a statement that connects what you can see with what must happen. The result physicalObservableStates_iff_forcedResponsesRealized says, in plain terms, that the observable states of a system are exactly the recognition responses that the system is forced to realize. That is, if a state is observable, then the system must produce it, and if the system is forced to produce a response, that response is observable.

This is not a trivial identity. The proof separates two different notions that could be conflated. One is observational equivalence: two raw implementation states are the same if every committed probe, a test you can run, cannot tell them apart. The other is type equivalence: the raw carrier itself, the underlying set of states, is equivalent to the response quotient, the set of recognition classes. The result establishes that the physical observable states, formed by quotienting raw states by the probes, are exactly the recognition response classes. The key map from raw channels to recognition classes is injective, meaning no hidden observable content can exist beyond the committed response classes. Surjectivity, the missing direction, is exactly the condition that responses are physically realized.

The result is proved in the framework's library with no sorry and no new axiom, meaning it rests only on the standard postulates of the ambient type theory. It is a formal result about the structure of any system that satisfies the framework's posting response axioms. The result does not, however, select any particular production system. No committed declaration names a concrete production system, so the strongest result is a canonical embedding plus the exact residual condition. Proving that a specific system exhausts the recognition classes remains an open hypothesis.

What does this change for a reader? It tells you that in this framework, the question of what is observable is not separate from the question of what is forced. If you can observe a state, the system must realize it, and if the system is forced to realize a response, you can observe it. The only remaining gap is whether a given candidate system actually realizes all the forced responses, and that is a concrete question you can test for any particular system.

theorem physicalObservableStates_iff_forcedResponsesRealized
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N) :
    PhysicalObservableStatesAreRecognitionClasses3 system ↔
      RecognitionForcedResponsesArePhysicallyRealized3
        system := by
  rw [physicalObservableStates_iff_responsesRealize,
    forcedResponsesPhysicallyRealized_iff_realizeParents]

theorem physicalObservableStates_iff_forcedResponsesRealized
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N) :
    PhysicalObservableStatesAreRecognitionClasses3 system ↔
      RecognitionForcedResponsesArePhysicallyRealized3
        system := by
  rw [physicalObservableStates_iff_responsesRealize,
    forcedResponsesPhysicallyRealized_iff_realizeParents]

/-- The external observational quotient embeds canonically into the committed
Recognition response quotient for every response system. No raw hidden state
can add a physical observable degree without enlarging the probe family. -/
theorem productionObservableClassMap_injective
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N)
    (event : RealizedPostingEvent3 N) :
    Function.Injective
      (productionObservableClassMap3 system event) := by
  intro leftClass rightClass hclasses
  refine
    Quotient.inductionOn₂ leftClass rightClass
      (fun left right hrepresentatives => ?_)
      hclasses
  apply identified_of_obsEquiv
  have hresponses :
      system.respond event left =
        system.respond event right := by
    apply responseCoordinateQuotient_projection_injective
    exact hrepresentatives
  intro observation hobservation
  obtain ⟨probe, rfl⟩ := hobservation
  change
    responseCoordinateObservation3 probe
        (system.respond event left) =
      responseCoordinateObservation3 probe
        (system.respond event right)
  rw [hresponses]

theorem physicalObservableStates_iff_responsesRealize
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N) :
    PhysicalObservableStatesAreRecognitionClasses3 system ↔
      PostingResponsesRealizeParents3 system := by
  constructor
  · intro hexhaustive event parent
    obtain ⟨stateClass, hstateClass⟩ :=
      hexhaustive event
        (proj responseCoordinateProbeFamily3
          (parentTagResponse3 parent))
    refine
      Quotient.inductionOn stateClass
        (fun channel hchannel => ?_)
        hstateClass
    refine ⟨channel, ?_⟩
    apply responseCoordinateQuotient_projection_injective
    exact hchannel
  · intro hrealize event responseClass
    refine
      Quotient.inductionOn responseClass
        (fun response => ?_)
    obtain ⟨channel, hchannel⟩ :=
      hrealize event
        (responseParentTag3 response)
    refine
      ⟨proj (physicalChannelProbeFamily3 system event)
          channel, ?_⟩
    change
      proj responseCoordinateProbeFamily3
          (system.respond event channel) =
        proj responseCoordinateProbeFamily3 response
    rw [hchannel,
      parentTagResponse_responseParentTag]

theorem physicalObservableStates_iff_forcedResponsesRealized
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N) :
    PhysicalObservableStatesAreRecognitionClasses3 system ↔
      RecognitionForcedResponsesArePhysicallyRealized3
        system := by
  rw [physicalObservableStates_iff_responsesRealize,
    forcedResponsesPhysicallyRealized_iff_realizeParents]

What this page does not claim

The result does not identify any specific production system as the one that exhausts the recognition classes. The result does not claim that the raw carrier itself is equivalent to the response quotient; that is a separate, stronger condition. The result does not prove that every possible physical system satisfies the exhaustive condition; it only characterizes what that condition is.

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