math / data /lean /OAI /GroupTheory /SimpleAmenable /Simplicial /DiagonalResolution.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
8.43 kB
import Mathlib
namespace OAI
open CategoryTheory Limits SimplicialObject Simplicial Opposite AlgebraicTopology
namespace DiagonalResolution
abbrev D := SimplexCategory × SimplexCategory
abbrev A := ModuleCat.{0} ℤ
noncomputable abbrev Z : A := ModuleCat.of ℤ ℤ
noncomputable abbrev free (d : D) : D ⥤ A := (evaluationLeftAdjoint A d).obj Z
noncomputable def pre {a b : D} (k : a ⟶ b) : free b ⟶ free a where
app d := Sigma.desc (fun f => Sigma.ι (fun _ : a ⟶ d => Z) (k ≫ f))
naturality d e f := by
apply Sigma.hom_ext
intro g
simp [free,evaluationLeftAdjoint,Category.assoc]
@[reassoc (attr := simp)] lemma ι_pre {a b : D} (k : a ⟶ b) (d : D) (f : b ⟶ d) :
Sigma.ι (fun _ : b ⟶ d => Z) f ≫ (pre k).app d =
Sigma.ι (fun _ : a ⟶ d => Z) (k ≫ f) := by
exact Sigma.ι_comp_desc _ _
@[simp] lemma pre_id (a : D) : pre (𝟙 a) = 𝟙 (free a) := by
apply NatTrans.ext
funext d
apply Sigma.hom_ext
intro f
simp only [ι_pre, NatTrans.id_app, Category.id_comp]
exact (Category.comp_id _).symm
@[simp] lemma pre_comp {a b c : D} (f : a ⟶ b) (g : b ⟶ c) :
pre (f ≫ g) = pre g ≫ pre f := by
apply NatTrans.ext
funext d
apply Sigma.hom_ext
intro h
simp only [NatTrans.comp_app]
erw [← Category.assoc, ι_pre, ι_pre, ι_pre]
rw [Category.assoc]
noncomputable def preDiag {a b : SimplexCategory} (f : a ⟶ b) : free (b,b) ⟶ free (a,a) :=
pre (a := (a,a)) (b := (b,b)) (f,f)
noncomputable def chains : SimplicialObject (D ⥤ A) where
obj n := free (n.unop,n.unop)
map f := pre (f.unop,f.unop)
map_id n := pre_id _
map_comp {X Y W} f g := by
simpa only [unop_comp, prod_comp, Prod.mkHom] using (pre_comp (a := (W.unop,W.unop))
(b := (Y.unop,Y.unop)) (c := (X.unop,X.unop)) (g.unop,g.unop) (f.unop,f.unop))
noncomputable def augmentation : chains ⟶ (SimplicialObject.const _).obj ((Functor.const D).obj Z) where
app n :=
{ app d := Sigma.desc (fun _ : (n.unop,n.unop) ⟶ d => 𝟙 Z)
naturality d e f := by
apply Sigma.hom_ext
intro g
simp [chains,free,evaluationLeftAdjoint] }
naturality n m f := by
apply NatTrans.ext
funext d
apply Sigma.hom_ext
intro g
simp only [NatTrans.comp_app, chains, pre, Functor.const_obj_map]
erw [Sigma.ι_comp_desc_assoc, Sigma.ι_comp_desc, Sigma.ι_comp_desc_assoc,
NatTrans.id_app, Category.id_comp]
rfl
noncomputable def augmented : SimplicialObject.Augmented (D ⥤ A) where
left := chains
right := (Functor.const D).obj Z
hom := augmentation
noncomputable def complex : ChainComplex (D ⥤ A) ℕ :=
AlternatingFaceMapComplex.obj chains
instance projective (n : ℕ) : Projective (complex.X n) := by
change Projective (free (⦋n⦌,⦋n⦌))
exact (evaluationAdjunctionRight A (⦋n⦌,⦋n⦌)).map_projective Z inferInstance
open SSet.Augmented.StandardSimplex
def zeroSimplex (a : SimplexCategory) : ⦋0⦌ ⟶ a := SimplexCategory.Hom.mk (OrderHom.const _ 0)
@[simp] lemma shift_δ₀ {n : ℕ} {a : SimplexCategory} (f : ⦋n⦌ ⟶ a) :
SimplexCategory.δ 0 ≫ shift f = f := by
exact congrArg SSet.stdSimplex.objEquiv.{0}
(ConcreteCategory.congr_hom ((SSet.Augmented.StandardSimplex.extraDegeneracy a).s_comp_δ₀ n)
(SSet.stdSimplex.objEquiv.symm f))
@[simp] lemma shift_δ_succ {n : ℕ} {a : SimplexCategory} (f : ⦋n+1⦌ ⟶ a) (i : Fin (n+2)) :
SimplexCategory.δ i.succ ≫ shift f = shift (SimplexCategory.δ i ≫ f) := by
exact congrArg SSet.stdSimplex.objEquiv.{0}
(ConcreteCategory.congr_hom ((SSet.Augmented.StandardSimplex.extraDegeneracy a).s_comp_δ n i)
(SSet.stdSimplex.objEquiv.symm f))
@[simp] lemma shift_σ_succ {n : ℕ} {a : SimplexCategory} (f : ⦋n⦌ ⟶ a) (i : Fin (n+1)) :
SimplexCategory.σ i.succ ≫ shift f = shift (SimplexCategory.σ i ≫ f) := by
exact congrArg SSet.stdSimplex.objEquiv.{0}
(ConcreteCategory.congr_hom ((SSet.Augmented.StandardSimplex.extraDegeneracy a).s_comp_σ n i)
(SSet.stdSimplex.objEquiv.symm f))
@[simp] lemma shift_δ₁ {a : SimplexCategory} (f : ⦋0⦌ ⟶ a) :
SimplexCategory.δ 1 ≫ shift f = zeroSimplex a := by
exact congrArg SSet.stdSimplex.objEquiv.{0}
(ConcreteCategory.congr_hom ((SSet.Augmented.StandardSimplex.extraDegeneracy a).s₀_comp_δ₁)
(SSet.stdSimplex.objEquiv.symm f))
noncomputable abbrev augmentedAt (d : D) : SimplicialObject.Augmented A :=
((SimplicialObject.Augmented.whiskering _ _).obj ((evaluation D A).obj d)).obj augmented
noncomputable def extraAt (d : D) : (augmentedAt d).ExtraDegeneracy where
s' := Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z) (zeroSimplex d.1,zeroSimplex d.2)
s n := Sigma.desc (fun f : (⦋n⦌,⦋n⦌) ⟶ d =>
Sigma.ι (fun _ : (⦋n+1⦌,⦋n+1⦌) ⟶ d => Z) (shift f.1,shift f.2))
s'_comp_ε := by
change Sigma.ι (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => Z) (zeroSimplex d.1,zeroSimplex d.2) ≫
Sigma.desc (fun _ : (⦋0⦌,⦋0⦌) ⟶ d => 𝟙 Z) = 𝟙 Z
simp
s₀_comp_δ₁ := by
change Sigma.desc _ ≫ (preDiag (SimplexCategory.δ 1)).app d =
Sigma.desc _ ≫ Sigma.ι _ _
apply Sigma.hom_ext
intro f
dsimp only [preDiag]
erw [Sigma.ι_comp_desc_assoc, ι_pre, Sigma.ι_comp_desc_assoc]
simp only [prod_comp, Prod.mkHom, shift_δ₁]
exact (Category.id_comp _).symm
s_comp_δ₀ n := by
change Sigma.desc _ ≫ (preDiag (SimplexCategory.δ 0)).app d = 𝟙 _
apply Sigma.hom_ext
intro f
dsimp only [preDiag]
erw [Sigma.ι_comp_desc_assoc, ι_pre]
simp only [prod_comp, Prod.mkHom, shift_δ₀, Prod.eta]
exact (Category.comp_id _).symm
s_comp_δ n i := by
change Sigma.desc _ ≫ (preDiag (SimplexCategory.δ i.succ)).app d =
(preDiag (SimplexCategory.δ i)).app d ≫ Sigma.desc _
apply Sigma.hom_ext
intro f
dsimp only [preDiag]
erw [Sigma.ι_comp_desc_assoc, ι_pre, ι_pre_assoc, Sigma.ι_comp_desc]
simp only [prod_comp, Prod.mkHom, shift_δ_succ]
rfl
s_comp_σ n i := by
change Sigma.desc _ ≫ (preDiag (SimplexCategory.σ i.succ)).app d =
(preDiag (SimplexCategory.σ i)).app d ≫ Sigma.desc _
apply Sigma.hom_ext
intro f
dsimp only [preDiag]
erw [Sigma.ι_comp_desc_assoc, ι_pre, ι_pre_assoc, Sigma.ι_comp_desc]
simp only [prod_comp, Prod.mkHom, shift_σ_succ]
rfl
noncomputable def pi : complex ⟶ (ChainComplex.single₀ (D ⥤ A)).obj ((Functor.const D).obj Z) :=
AlternatingFaceMapComplex.ε.app augmented
noncomputable def atIso (d : D) :
(((evaluation D A).obj d).mapHomologicalComplex (ComplexShape.down ℕ)).obj complex ≅
AlternatingFaceMapComplex.obj (augmentedAt d).left :=
eqToIso (congrArg (fun F => F.obj chains)
(map_alternatingFaceMapComplex ((evaluation D A).obj d)))
noncomputable def singleAtIso (d : D) :
(((evaluation D A).obj d).mapHomologicalComplex (ComplexShape.down ℕ)).obj
((ChainComplex.single₀ (D ⥤ A)).obj ((Functor.const D).obj Z)) ≅
(ChainComplex.single₀ A).obj Z :=
(HomologicalComplex.singleMapHomologicalComplex ((evaluation D A).obj d)
(ComplexShape.down ℕ) 0).app ((Functor.const D).obj Z)
instance pi_quasiIso : QuasiIso pi := by
rw [HomologicalComplex.quasiIso_iff_evaluation]
intro d
let f := (((evaluation D A).obj d).mapHomologicalComplex (ComplexShape.down ℕ)).map pi
have h : f ≫ (singleAtIso d).hom = (atIso d).hom ≫ (extraAt d).homotopyEquiv.hom := by
apply HomologicalComplex.to_single_hom_ext
dsimp [f,pi,atIso,singleAtIso]
simp [HomologicalComplex.singleMapHomologicalComplex,
SimplicialObject.Augmented.ExtraDegeneracy.homotopyEquiv,
Functor.mapHomologicalComplex, augmentedAt, augmented, augmentation]
dsimp only [NatIso.ofComponents, SimplicialObject.Augmented.whiskering,
SimplicialObject.Augmented.whiskeringObj, CategoryTheory.eqToIso]
erw [HomologicalComplex.eqToHom_f]
rfl
change QuasiIso f
rw [← quasiIso_iff_comp_right f (singleAtIso d).hom, h]
have : QuasiIso (extraAt d).homotopyEquiv.hom :=
(extraAt d).homotopyEquiv.quasiIso_hom
have hcomp := quasiIso_comp (atIso d).hom (extraAt d).homotopyEquiv.hom
exact hcomp
noncomputable def resolution : ProjectiveResolution ((Functor.const D).obj Z) where
complex := complex
π := pi
quasiIso := pi_quasiIso
end DiagonalResolution
end OAI