From 99fe46a99337bb05adb889ea07e054d83c5d06fc Mon Sep 17 00:00:00 2001 From: Fyre Mael Date: Mon, 16 Nov 2026 16:39:34 -0700 Subject: [PATCH 1/5] CMDG CM5: naturally identify genuine free condensed modules with sheafified free presheaves and exact sheafification --- ...ivedCM5R0FreeSheafificationComparison.lean | 110 ++++++++++++++++++ 1 file changed, 110 insertions(+) create mode 100644 fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean diff --git a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean new file mode 100644 index 000000000..223b70835 --- /dev/null +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean @@ -0,0 +1,110 @@ +import CMDGCondensedCM4P3DerivedCM5R0StoneanProbeBarDescent +import Mathlib.Algebra.Homology.ShortComplex.ExactFunctor +import Mathlib.CategoryTheory.Sites.Abelian + +/-! +# CMDG CM5 — genuine free-condensed-module sheafification comparison + +This is the essential SHEAFIFICATION interface, not an identification +of a free abelian group on Hom(U,X) with F_X(U). + +For any profinite X, the genuine free condensed Coeff-module F_X is +the associated sheaf of the presheaf of ordinary free Coeff-modules on +the (universe-lifted) representable condensed SET presheaf of X. + +More strongly, this identification is NATURAL in X, with all module +maps given by the actual functor ModuleCat.free. The sheafification +functor is exact between the genuine abelian presheaf and sheaf module +categories: it preserves both finite limits (pinned left exact +sheafification) and finite colimits (pinned left adjoint). + +CRITICAL: The preceding bar contraction is objectwise exact on +Stonean test objects, not necessarily on all CompHaus test objects. +One must still transport that exactness through the Stonean dense-site +comparison to infer an exact sheafified complex on CompHaus. +No global arbitrary-profinite second Cech relation epi is asserted +in this source, and no Ext² or derived solidity claim is made. +-/ + +noncomputable section + +universe u + +open CategoryTheory Limits + +namespace CMDG.CondensedCM5R0 + +/-- Presheaves of the *actual* universe-lifted coefficient modules on +CompHaus, rather than unsheafified integer functions. -/ +private abbrev CompHausModulePresheaves := + CompHaus.{u}ᵒᵖ ⥤ ModuleCat.{u + 1} Coeff + +/-- The true ordinary free module presheaf on the representable +condensed set of X, before sheafification. -/ +noncomputable abbrev freeCompHausModulePresheaf + (X : Profinite.{u}) : CompHausModulePresheaves := + (profiniteToCondensed.obj X).obj ⋙ ModuleCat.free Coeff + +/-- Sheafification of module presheaves with the actual coherent +CompHaus topology, into the exact CondensedMod category. -/ +noncomputable abbrev moduleSheafification : + CompHausModulePresheaves ⥤ Ambient := + presheafToSheaf (coherentTopology CompHaus) (ModuleCat Coeff) + +/-- The NATURAL presheaf of free modules on the representable +profinite-to-condensed set, with maps induced by profinite morphisms. -/ +noncomputable abbrev freeCompHausModulePresheafFunctor : + Profinite.{u} ⥤ CompHausModulePresheaves := + profiniteToCondensed ⋙ + sheafToPresheaf (coherentTopology CompHaus) (Type (u + 1)) ⋙ + (Functor.whiskeringRight _ _ _).obj (ModuleCat.free Coeff) + +/-- The actual free condensed module F_X is precisely the +SHEAFIFICATION of the free module presheaf of X. This is the +sheafification comparison, not an incorrect objectwise equality. -/ +theorem genuineFreeModule_eq_sheafification (X : Profinite.{u}) : + (Condensed.profiniteFree Coeff).obj X = + moduleSheafification.obj (freeCompHausModulePresheaf X) := by + rfl + +/-- The comparison in the preceding theorem is NATURAL in all +profinite morphisms: it uses the genuine, preexisting free functor +on the site, not chosen local generators. -/ +noncomputable def genuineFreeModuleSheafificationIso : + freeCompHausModulePresheafFunctor ⋙ moduleSheafification ≅ + Condensed.profiniteFree Coeff := + Iso.refl _ + +/-- Left exactness of the actual sheafification on the abelian +presheaf category of Coeff-modules. -/ +theorem moduleSheafification_preservesFiniteLimits : + PreservesFiniteLimits moduleSheafification := by + infer_instance + +/-- Right exactness follows from the genuine sheafification adjunction: +the associated-sheaf functor is a LEFT adjoint. -/ +theorem moduleSheafification_preservesFiniteColimits : + PreservesFiniteColimits moduleSheafification := by + infer_instance + +/-- Sheafification is exact on the genuine abelian module presheaf +category, so it transports the exactness of ANY pre-sheaf short +complex, once source exactness is proved (at all test objects or, +after restriction, on a dense projective subsite). -/ +theorem moduleSheafification_preservesExact + (S : ShortComplex CompHausModulePresheaves) (h : S.Exact) : + (S.map moduleSheafification).Exact := by + haveI : PreservesFiniteLimits moduleSheafification := + moduleSheafification_preservesFiniteLimits + haveI : PreservesFiniteColimits moduleSheafification := + moduleSheafification_preservesFiniteColimits + exact ((Functor.exact_tfae moduleSheafification).out 3 1).mp + ⟨inferInstance, inferInstance⟩ S h + +#print axioms genuineFreeModule_eq_sheafification +#print axioms genuineFreeModuleSheafificationIso +#print axioms moduleSheafification_preservesFiniteLimits +#print axioms moduleSheafification_preservesFiniteColimits +#print axioms moduleSheafification_preservesExact + +end CMDG.CondensedCM5R0 From 8a2b8148231a5cf5fad0a1e9a28b67c91e4e18a8 Mon Sep 17 00:00:00 2001 From: Fyre Mael Date: Mon, 16 Nov 2026 16:45:29 -0700 Subject: [PATCH 2/5] CMDG CM5: dense Stonean sheafification comparison and objectwise positive-degree bar exactness --- ...erivedCM5R0StoneanDenseSheafification.lean | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean diff --git a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean new file mode 100644 index 000000000..8b850a090 --- /dev/null +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean @@ -0,0 +1,114 @@ +import CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison +import Mathlib.CategoryTheory.Sites.DenseSubsite.SheafEquiv +import Mathlib.Algebra.Homology.QuasiIso +import Mathlib.Algebra.Homology.SingleHomology + +/-! +# CMDG CM5 — dense Stonean-site sheafification compatibility + +The genuine free condensed module on any profinite X is naturally +isomorphic to the sheafification of its ordinary free-module +representable presheaf on CompHaus (prior module). + +The pinned dense-subsite comparison theorem supplies the exact +NATURAL ISOMORPHISM between the Stonean restriction of this +CompHaus sheafification and the sheafification of the Stonean +restriction of the unsheafified free presheaf. This directly +accounts for local clopen gluing; it does NOT identify the free +presheaf itself with the sheaf. + +Separately, the previously verified Stonean-probe free-Hom Čech +homotopy equivalence yields ACTUAL exactness in EVERY POSITIVE +DEGREE of the bar complex at each Stonean probe. This is a +module-category exactness result rather than a mere split-epi +statement on Hom sets. + +The remaining global obligation is to assemble these natural +identifications into the Čech simplicial chain complex, then +transport the degree-one exactness through the exact sheafification +and check that the alternating differential coincides (up to the +explicit sign convention) with the genuine second kernel map +F_triples → L_T. No global epi or Ext² claim is made here. +-/ + +noncomputable section + +universe u + +open CategoryTheory Limits + +namespace CMDG.CondensedCM5R0 + +/-- **Genuine pinned dense-subsite theorem.** Sheafification of +module presheaves on CompHaus, then restriction to Stonean, is +naturally isomorphic to restriction first and then Stonean +sheafification. The target is the *actual* Stonean-to-CompHaus +condensed-module equivalence, not a new artificial module category. -/ +noncomputable def stoneanCompHausSheafificationCompatibility : + (Functor.whiskeringLeft _ _ (ModuleCat.{u + 1} Coeff)).obj + Stonean.toCompHaus.op ⋙ + presheafToSheaf (coherentTopology Stonean) (ModuleCat Coeff) + ≅ + moduleSheafification ⋙ + (Condensed.StoneanCompHaus.equivalence + (ModuleCat Coeff)).inverse := by + exact Functor.IsDenseSubsite.sheafEquivSheafificationCompatibility + Stonean.toCompHaus (coherentTopology Stonean) + (coherentTopology CompHaus) (ModuleCat Coeff) + +/-- Canonical sheafified comparison at ANY profinite X: +the Stonean sheafification of the free-Hom presheaf is the +Stonean restriction of the GENUINE free condensed module F_X. +In particular it includes every clopen-local section. -/ +noncomputable def genuineFreeStoneanSheafificationIso + (X : Profinite.{u}) : + (presheafToSheaf (coherentTopology Stonean) + (ModuleCat Coeff)).obj + (((Functor.whiskeringLeft _ _ (ModuleCat Coeff)).obj + Stonean.toCompHaus.op).obj (freeCompHausModulePresheaf X)) + ≅ + (Condensed.StoneanCompHaus.equivalence + (ModuleCat Coeff)).inverse.obj + ((Condensed.profiniteFree Coeff).obj X) := by + change + (presheafToSheaf (coherentTopology Stonean) + (ModuleCat Coeff)).obj + (((Functor.whiskeringLeft _ _ (ModuleCat Coeff)).obj + Stonean.toCompHaus.op).obj (freeCompHausModulePresheaf X)) + ≅ + (Condensed.StoneanCompHaus.equivalence + (ModuleCat Coeff)).inverse.obj + (moduleSheafification.obj (freeCompHausModulePresheaf X)) + exact stoneanCompHausSheafificationCompatibility.app + (freeCompHausModulePresheaf X) + +/-- The ACTUAL free Hom-set alternating Čech chain complex of +the projective Stonean probe, not the sheafified complex. -/ +noncomputable abbrev stoneanProbeFreeBarComplex + (T : Profinite.{u}) (U : Stonean.{u}) : + ChainComplex (ModuleCat.{u + 1} Coeff) ℕ := + AlgebraicTopology.AlternatingFaceMapComplex.obj + (SimplicialObject.Augmented.drop.obj + (((SimplicialObject.Augmented.whiskering _ _).obj + (ModuleCat.free Coeff)).obj + (stoneanProbePresentationCechNerve T U))) + +/-- For EACH Stonean U and EVERY degree n+1, the actual objectwise +free-Hom bar complex is exact. We use the true quasi-isomorphism +induced by the previously established chain-homotopy equivalence +to the degree-zero augmentation, not an informal pointwise claim. -/ +theorem stoneanProbeFreeBarComplex_exactAt_positive + (T : Profinite.{u}) (U : Stonean.{u}) (n : ℕ) : + (stoneanProbeFreeBarComplex T U).ExactAt (n + 1) := by + let e := stoneanProbeFreeCechHomotopyEquiv T U + haveI : QuasiIso e.hom := e.quasiIso_hom + exact (HomologicalComplex.exactAt_iff_of_quasiIsoAt + e.hom (n + 1)).2 + (ChainComplex.exactAt_succ_single_obj _ n) + +#check genuineFreeStoneanSheafificationIso +#check stoneanProbeFreeBarComplex_exactAt_positive +#print axioms genuineFreeStoneanSheafificationIso +#print axioms stoneanProbeFreeBarComplex_exactAt_positive + +end CMDG.CondensedCM5R0 From 9e2017818f7357b78b4da08c1e3d605ca7876e30 Mon Sep 17 00:00:00 2001 From: Fyre Mael Date: Mon, 16 Nov 2026 16:54:59 -0700 Subject: [PATCH 3/5] CMDG CM5: type exact-sheafification TFAE witness explicitly from verified finite (co)limit preservation --- ...sedCM4P3DerivedCM5R0FreeSheafificationComparison.lean | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean index 223b70835..ba9c6eabc 100644 --- a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean @@ -98,8 +98,13 @@ theorem moduleSheafification_preservesExact moduleSheafification_preservesFiniteLimits haveI : PreservesFiniteColimits moduleSheafification := moduleSheafification_preservesFiniteColimits - exact ((Functor.exact_tfae moduleSheafification).out 3 1).mp - ⟨inferInstance, inferInstance⟩ S h + have hExact : + ∀ (R : ShortComplex CompHausModulePresheaves), + R.Exact → (R.map moduleSheafification).Exact := + ((Functor.exact_tfae moduleSheafification).out 3 1).mp + ⟨moduleSheafification_preservesFiniteLimits, + moduleSheafification_preservesFiniteColimits⟩ + exact hExact S h #print axioms genuineFreeModule_eq_sheafification #print axioms genuineFreeModuleSheafificationIso From d28ad5800897f47c68a11f5bc61c8499fe8fd0d0 Mon Sep 17 00:00:00 2001 From: Fyre Mael Date: Mon, 16 Nov 2026 17:01:55 -0700 Subject: [PATCH 4/5] CMDG CM5: use pinned ShortComplex.Exact.map directly with exact sheafification's finite (co)limits --- ...nsedCM4P3DerivedCM5R0FreeSheafificationComparison.lean | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean index ba9c6eabc..10750bf42 100644 --- a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean @@ -98,13 +98,7 @@ theorem moduleSheafification_preservesExact moduleSheafification_preservesFiniteLimits haveI : PreservesFiniteColimits moduleSheafification := moduleSheafification_preservesFiniteColimits - have hExact : - ∀ (R : ShortComplex CompHausModulePresheaves), - R.Exact → (R.map moduleSheafification).Exact := - ((Functor.exact_tfae moduleSheafification).out 3 1).mp - ⟨moduleSheafification_preservesFiniteLimits, - moduleSheafification_preservesFiniteColimits⟩ - exact hExact S h + exact h.map moduleSheafification #print axioms genuineFreeModule_eq_sheafification #print axioms genuineFreeModuleSheafificationIso From 35476cd24a9c4cbd8adb21f6f2e61f6e04c58727 Mon Sep 17 00:00:00 2001 From: Fyre Mael Date: Mon, 16 Nov 2026 17:09:44 -0700 Subject: [PATCH 5/5] CMDG CM5: bind dense-subsite embedding by name and use root-scoped quasi-iso exactness lemma --- ...GCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean index 8b850a090..d09f77663 100644 --- a/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0StoneanDenseSheafification.lean @@ -53,7 +53,7 @@ noncomputable def stoneanCompHausSheafificationCompatibility : (Condensed.StoneanCompHaus.equivalence (ModuleCat Coeff)).inverse := by exact Functor.IsDenseSubsite.sheafEquivSheafificationCompatibility - Stonean.toCompHaus (coherentTopology Stonean) + (G := Stonean.toCompHaus) (coherentTopology Stonean) (coherentTopology CompHaus) (ModuleCat Coeff) /-- Canonical sheafified comparison at ANY profinite X: @@ -102,7 +102,7 @@ theorem stoneanProbeFreeBarComplex_exactAt_positive (stoneanProbeFreeBarComplex T U).ExactAt (n + 1) := by let e := stoneanProbeFreeCechHomotopyEquiv T U haveI : QuasiIso e.hom := e.quasiIso_hom - exact (HomologicalComplex.exactAt_iff_of_quasiIsoAt + exact (exactAt_iff_of_quasiIsoAt e.hom (n + 1)).2 (ChainComplex.exactAt_succ_single_obj _ n)