Foundation Singular Prism Prism Comp Face Of Le

The prism and the face

In topology, a simplex is the generalization of a triangle or tetrahedron to any number of dimensions: a point, a line segment, a filled triangle, a filled tetrahedron, and so on. Its faces are the lower-dimensional simplices that form its boundary, such as the three edges of a triangle or the four triangular faces of a tetrahedron. A prism is the product of a simplex with a unit interval, which in one dimension turns a line segment into a square and in two dimensions turns a triangle into a triangular prism.

The theorem prism_comp_face_of_le in the framework's machine-checked library of formal theorems concerns a specific map that embeds a prism into a higher-dimensional simplex. It states a commutation relation: when you first compose this prism map with a face map (the inclusion of a boundary face) and the index condition holds, the result equals the composition of a product map with the prism map. In plain terms, the order in which you apply the prism construction and the face inclusion does not change the final continuous map, provided the face index is not greater than the prism index.

This is a technical lemma about the singular chain complex, an algebraic object that records the shapes of a topological space. The declaration is part of a larger development that constructs a chain homotopy, a standard tool that shows two maps induce the same map on homology. The theorem itself is a formal statement in the ledger, a discrete record of mathematical events, that the framework's library maintains with machine-checked proofs.

The theorem does not claim anything about the physical world, nor does it establish any property of the recognition cost function or the forcing chain. It is a purely combinatorial statement about finite index sets and continuous maps between standard simplices. It does not prove that a prism is a face of a simplex, nor does it say anything about the uniqueness of the prism decomposition. Its role is internal: it is one of the building blocks that the library uses to verify that the prism construction behaves correctly under composition with face maps.

What this theorem changes for a reader is the confidence that the framework's algebraic topology is built on solid, verified foundations. It is a small but necessary piece of the machinery that the framework uses to connect its abstract recognition principles to the standard tools of geometry and topology. Without such lemmas, the larger claims of the framework would rest on unverified assumptions.

/-- Commutation with lower faces (`j ≤ i`): the composite of a prism map
with a low face factors through the prism one dimension down.  This matches
the `(i, j)` terms of `∂P` with `j < i+1` against the terms of `P∂`. -/
theorem prism_comp_face_of_le {i : Fin (n + 1)} {j : Fin (n + 2)}
    (hij : j ≤ i.castSucc) :
    (prism i.succ).comp (face j.castSucc) =
      ((face j).prodMap (ContinuousMap.id I)).comp (prism i) := by
  have hij' : (j : ℕ) ≤ (i : ℕ) := by simpa [Fin.le_def] using hij
  refine ContinuousMap.ext fun x => Prod.ext ?_ (Subtype.ext ?_)
  · show stdSimplex.map (Fin.predAbove i.succ)
        (stdSimplex.map (Fin.succAbove j.castSucc) x) =
      stdSimplex.map (Fin.succAbove j) (stdSimplex.map (Fin.predAbove i) 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.succ (stdSimplex.map (Fin.succAbove j.castSucc) x) =
      prismSndFun i x
    rw [prismSndFun_map_succAbove, prismSndFun]
    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

/-- A homotopy of continuous maps induces a chain homotopy of the induced
maps of singular chain complexes, via the prism operator. -/
noncomputable def prismHomotopy {F₀ F₁ : X ⟶ Y}
    (Ho : ContinuousMap.Homotopy F₀.hom F₁.hom) :
    Homotopy (sChainMap F₀) (sChainMap F₁) where
  hom i j :=
    if h : i + 1 = j then
      (-prismOp Ho.toContinuousMap i prism) ≫ eqToHom (by subst h; rfl)
    else 0
  zero i j hij := by
    rw [dif_neg]
    intro h
    exact hij (by simpa using h)
  comm i := by
    match i with
    | 0 =>
      rw [Homotopy.dNext_zero_chainComplex, Homotopy.prevD_chainComplex]
      rw [dif_pos rfl, eqToHom_refl, Category.comp_id, Preadditive.neg_comp]
      show chainMap F₀ 0 =
        0 + -prismOp Ho.toContinuousMap 0 prism ≫ bnd Y 0 + chainMap F₁ 0
      have h0 := prism_chain_homotopy_zero Ho
      rw [eq_sub_iff_add_eq] at h0
      rw [← h0]
      abel
    | n + 1 =>
      rw [Homotopy.dNext_succ_chainComplex, Homotopy.prevD_chainComplex]
      rw [dif_pos rfl, dif_pos rfl, eqToHom_refl, eqToHom_refl, Category.comp_id,
        Category.comp_id, Preadditive.neg_comp, Preadditive.comp_neg]
      show chainMap F₀ (n + 1) =
        -bnd X n ≫ prismOp Ho.toContinuousMap n prism +
          -prismOp Ho.toContinuousMap (n + 1) prism ≫ bnd Y (n + 1) +
          chainMap F₁ (n + 1)
      have h0 := prism_chain_homotopy_succ Ho n
      rw [eq_sub_iff_add_eq] at h0
      rw [← h0]
      abel

What this page does not claim

The theorem does not assert any physical or empirical fact. It does not establish the uniqueness of the prism decomposition. It does not connect to the recognition cost function or the forcing chain.

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: