Foundation Primitive Recognition Calculus Completion Conservativity Function Con

Certifying whole fields

A completion, in the Recognition Science framework, is a bridge between two kinds of data: native data that carries its own certificates of authenticity, and display data that a person or machine actually reads. The bridge has two parts. It turns each native datum into a display datum, and it defines what it means for a certificate to vouch for a display. A display predicate is a test, a yes or no question you can ask about a display datum, such as "is this entry a valid measurement?" A completion is conservative for a predicate when every display datum that passes the test carries at least one certificate. In plainer words: nothing that looks genuine is actually a forgery.

The declaration function_conservative proves a specific lifting property. One can have a display that is really a finite collection of fields, a vector of entries or a table of cells, and suppose each individual cell passes some test and carries its own certificate. The theorem says the whole collection, considered as one display datum, also passes the lifted test and carries a certificate: a certificate for the whole is just the list of certificates for the cells. The framework's library proves this by choosing, for each coordinate, the certificate that the coordinate's own conservativity guarantees, and packaging those certificates together. The same idea works for finite functions, where the display is a function from some finite index set to display data, and the certificate is a function from the same index set to certificates.

The theorem is one of three closure results in the same file. The identity completion, where display data and native data are the same type and the certificate is just equality, is conservative for every predicate. Products of conservative completions are conservative for product predicates. And function completions are conservative for pointwise predicates. Together they say that conservativity survives the standard ways of building larger displays out of smaller ones. If you can certify each cell, you can certify the table; if you can certify each component, you can certify the pair.

The declaration does not claim that every possible completion is conservative. It does not say that any particular display system, such as the framework's own recognition ledger, is conservative. It does not claim that certificates are unique, or that the native data behind a display is recoverable from the certificate. It only establishes a conditional: if a base completion is conservative for a predicate, then the lifted function completion is conservative for the lifted predicate. The proof is constructive, which means it actually builds the certificate for the whole from the certificates for the parts.

What this changes for a reader is simple. When the framework later claims that a large display object, a vector of particle masses or a field of recognition events, is genuine, it does not need a separate proof for the whole object. It is enough to certify each coordinate, and the closure theorem supplies the rest. The framework gets a composable notion of authenticity, and the reader gets a guarantee that the composition step itself is not where forgery slips in.

/-- A completion is conservative for a predicate when the predicate is certificate-covered. -/
def ConservativeFor {N D Cert : Type*} (C : Completion N D Cert) (P : D → Prop) : Prop :=
  CertificateCovered C P

/-- Conservativity lifts pointwise to finite function displays: if each coordinate
predicate has a certificate, the whole function has a coordinatewise certificate. -/
theorem function_conservative
    {I N D Cert : Type*} (C : Completion N D Cert) (P : D → Prop)
    (hC : ConservativeFor C P) :
    ConservativeFor (functionCompletion I N D Cert C) (AllPredicate P) := by
  intro d hd
  choose c hc using fun i : I => hC (d i) (hd i)
  exact ⟨c, hc⟩

theorem identity_conservative (N : Type*) (P : N → Prop) :
    ConservativeFor (identityCompletion N) P := by
  intro d _
  exact ⟨d, rfl⟩

/-- Conservative completions compose across products: if each component display
predicate descends to a certificate, the product predicate descends to paired
certificates. -/
theorem product_conservative
    {N₁ D₁ Cert₁ N₂ D₂ Cert₂ : Type*}
    (C₁ : Completion N₁ D₁ Cert₁) (C₂ : Completion N₂ D₂ Cert₂)
    (P₁ : D₁ → Prop) (P₂ : D₂ → Prop)
    (h₁ : ConservativeFor C₁ P₁) (h₂ : ConservativeFor C₂ P₂) :
    ConservativeFor (productCompletion C₁ C₂) (ProductPredicate P₁ P₂) := by
  intro d hd
  rcases hd with ⟨hP₁, hP₂⟩
  rcases h₁ d.1 hP₁ with ⟨c₁, hc₁⟩
  rcases h₂ d.2 hP₂ with ⟨c₂, hc₂⟩
  exact ⟨(c₁, c₂), ⟨hc₁, hc₂⟩⟩

What this page does not claim

No claim that every completion is conservative, only that the identity, product, and function constructions preserve conservativity. No claim that any specific display system in the framework, such as the recognition ledger, is conservative. No claim that certificates are unique or that native data is recoverable from a certificate. No claim about infinite index sets; the theorem is stated for arbitrary types but the intended display pattern is finite vectors and fields.

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