| 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 |
|
|
