Foundation Singular Prism Prism Comp Face Cancel

The cancellation identity

In algebraic topology, a simplex is the simplest possible shape in a given dimension: a point in zero dimensions, a line segment in one, a triangle in two, a tetrahedron in three. A face of a simplex is a lower-dimensional slice obtained by fixing one coordinate. A prism here is a geometric construction that takes a simplex and extrudes it into one higher dimension, like stretching a triangle into a triangular column. The theorem prism_comp_face_cancel states that when you build a prism from a simplex and then take a certain face of that prism, the order in which you do these two operations does not change the final result, provided you choose the correct matching indices.

More precisely, the declaration proves an identity involving the composition of two maps: the prism map and the face map. The theorem states that for any index i, the composition of the prism at index i.castSucc with the face at index i.succ.castSucc is equal to the composition of the prism at index i.succ with the face at index i.succ.castSucc. In plain language, this says that there is a specific way to slide a face across a prism such that the resulting boundary is the same regardless of whether you start from the lower or the higher edge. This is a local consistency condition, a piece of the larger puzzle that ensures the whole construction behaves well under gluing.

The theorem is one of several similar statements in the same file. Its siblings, prism_comp_face_top and prism_comp_face_bot, handle the two extreme cases where the face is at the very top or the very bottom of the prism. The cancellation identity covers all the middle cases, filling the gap between the extremes. Together, these identities are the building blocks for proving that the prism construction respects the boundary maps of the singular chain complex, a standard object in algebraic topology used to compute homology. The framework's machine-checked library of formal theorems records this identity as a proved statement, with no gaps in its logical derivation.

What the theorem does not claim is any physical or empirical content. It is a purely combinatorial and topological statement about abstract shapes. It does not say anything about the recognition cost function, the golden ratio, or any of the framework's physical constants. It does not assert that prisms exist in physical space or that the cancellation property has any direct observable consequence. The theorem is a piece of internal mathematical infrastructure, a gear in a larger machine, not a claim about the world.

The practical upshot is that the framework's foundational geometry is internally consistent at this level of detail. The cancellation identity is a necessary condition for the prism construction to be well-defined, and its proof in the machine-checked library means that a reader can trust this particular step without having to re-derive it. This is the kind of result that makes larger proofs possible: once a local identity is established, it can be used freely as a lemma in more complex arguments, knowing that it will not introduce a contradiction.

/-- Adjacent prism maps agree on their shared face (the cancelling terms
of `∂P`): `prism i ∘ face (i+1) = prism (i+1) ∘ face (i+1)`. -/
theorem prism_comp_face_cancel (i : Fin (n + 1)) :
    (prism i.castSucc).comp (face i.succ.castSucc) =
      (prism i.succ).comp (face i.succ.castSucc) := by
  refine ContinuousMap.ext fun x => Prod.ext ?_ (Subtype.ext ?_)
  · show stdSimplex.map (Fin.predAbove i.castSucc)
        (stdSimplex.map (Fin.succAbove i.succ.castSucc) x) =
      stdSimplex.map (Fin.predAbove i.succ)
        (stdSimplex.map (Fin.succAbove i.succ.castSucc) x)
    refine map_map_eq_map_map _ _ _ _ (fun k => ?_) x
    apply Fin.ext
    have hk := k.isLt
    simp only [coe_predAbove, coe_succAbove, Fin.val_castSucc, Fin.val_succ]
    split_ifs <;> omega
  · show prismSndFun i.castSucc (stdSimplex.map (Fin.succAbove i.succ.castSucc) x) =
      prismSndFun i.succ (stdSimplex.map (Fin.succAbove i.succ.castSucc) x)
    rw [prismSndFun_map_succAbove, prismSndFun_map_succAbove]
    refine Finset.sum_congr (Finset.filter_congr fun m _ => ?_) fun _ _ => rfl
    have hm := m.isLt
    simp only [Fin.lt_def, coe_succAbove, Fin.val_castSucc, Fin.val_succ]
    split_ifs <;> omega

What this page does not claim

This theorem makes no statement about physical space or empirical observations. This theorem does not involve the recognition cost function or any framework-specific physical constant. This theorem does not assert that prisms exist in the physical world.

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