Foundation Pair Kernel Production Quotient Identification S23 Classifier Commuta

The classifier's reach

The declaration classifierCommutation_forces_responseCommutation is a theorem in the machine-checked library of formal theorems that Recognition Science builds on. In plain language, it says: if you have a physical system whose raw states you have already identified with the framework's response classes (a recognition quotient), and if your classifier agrees with the system's own classification on every state, then the system's responses are exactly what the response classes dictate. The classifier's agreement on the front end forces the responses to agree on the back end. The identification is not just a label; it is a commitment that the system's behavior follows the recognition classes all the way through.

To see what this buys, consider what could go wrong. You might identify a system's states with response classes, and your classifier might match the system's classification, but the system's responses might still wander off in some other direction. The theorem rules that out. It proves that once the identification and the classifier agreement are in place, the response is forced to be the one the quotient class specifies. The theorem is proved for any system in the framework's posting physical response system (a system that takes physical events and returns responses through channels), for any event, and for any identification that respects the classifier. It is a fully general statement, not a property of one example.

The theorem also has a uniqueness consequence. The library proves that there is at most one identification from a system's raw states to the response quotient that makes the classifier commute. If two identifications both respect the classifier, they are the same identification. This means the classifier does not leave room for ambiguity: the structure of the recognition classes pins down the identification uniquely, once the classifier is fixed. The theorem is part of a larger module that separates three distinct statements: observational equivalence (states agree under every probe), type equivalence (the carrier is equivalent to the quotient), and physical observational identity (the quotient by probes is equivalent to the response quotient). The classifier commutation theorem sits at the level of the second and third, linking the identification to the responses.

What the theorem does not claim is just as important. It does not prove that any particular physical system exists that realizes the recognition classes. The library states this explicitly: no committed declaration names a production system, so the strongest theorem-backed result is a canonical embedding plus the exact residual that a candidate system must satisfy. Selecting an actual production system and proving it exhausts the recognition classes remains a hypothesis, not a theorem. The classifier commutation theorem is conditional: it says if you have such a system and such an identification, then the responses follow. It does not supply the system itself. The gap between the conditional theorem and an actual physical realization is the open target the module names.

/-- Classifier commutation already forces response commutation. Hence the
requested classifier-commuting but response-noncommuting countermodel cannot
inhabit the committed response-system structure. -/
theorem classifierCommutation_forces_responseCommutation
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N)
    (event : RealizedPostingEvent3 N)
    (identification :
      system.physical.Carrier event ≃
        RecognitionResponseQuotient3)
    (hclassify :
      ∀ channel,
        classifyResponseQuotient3 event
            (identification channel) =
          system.physical.classify event channel) :
    ∀ channel,
      responseFromQuotientClass3
          (identification channel) =
        system.respond event channel := by
  intro channel
  calc
    responseFromQuotientClass3
        (identification channel) =
        parentTagResponse3
          (classifyResponseQuotient3 event
            (identification channel)) := by
          simp [classifyResponseQuotient3]
    _ =
        parentTagResponse3
          (system.physical.classify event channel) :=
      congrArg parentTagResponse3
        (hclassify channel)
    _ = system.respond event channel :=
      (system.respond_factors event channel).symm

theorem productionIdentification_unique
    {N : ℕ} [NeZero N]
    (system : PostingPhysicalResponseSystem3 N)
    (event : RealizedPostingEvent3 N)
    (left right :
      system.physical.Carrier event ≃
        RecognitionResponseQuotient3)
    (hleft :
      ∀ channel,
        classifyResponseQuotient3 event
            (left channel) =
          system.physical.classify event channel)
    (hright :
      ∀ channel,
        classifyResponseQuotient3 event
            (right channel) =
          system.physical.classify event channel) :
    left = right := by
  apply Equiv.ext
  intro channel
  apply (classifyResponseQuotient3_bijective event).1
  rw [hleft, hright]

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 theorem does not prove that any particular physical system realizes the recognition classes; that remains a hypothesis. The theorem does not claim that the identification is unique without the classifier condition; the uniqueness proof uses the classifier commutation as a premise. The theorem does not say that the response quotient is the only possible quotient; it is conditional on the identification being given.

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: