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..10750bf42 --- /dev/null +++ b/fixtures/formal/CMDG-NAT-CONCORDANCE-001/CMDGCondensedCM4P3DerivedCM5R0FreeSheafificationComparison.lean @@ -0,0 +1,109 @@ +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 h.map moduleSheafification + +#print axioms genuineFreeModule_eq_sheafification +#print axioms genuineFreeModuleSheafificationIso +#print axioms moduleSheafification_preservesFiniteLimits +#print axioms moduleSheafification_preservesFiniteColimits +#print axioms moduleSheafification_preservesExact + +end CMDG.CondensedCM5R0 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..d09f77663 --- /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 + (G := 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 (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