| import Mathlib |
| import OAI.RingTheory.Multiplicity.CechCarrierOperators |
| import OAI.RingTheory.Multiplicity.ReesRootCech |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace Lech.CechNormalization |
| open CategoryTheory CategoryTheory.Limits HomologicalComplex Set CarrierOperators |
| universe u |
| variable {R : Type u} [CommRing R] {ι : Type} [Fintype ι] [LinearOrder ι] |
| (D : FiniteModuleCech.Diagram R ι) |
|
|
| abbrev fullCochains (p : ℕ) := Sections D (fullCarrier p) |
| abbrev fullD (p : ℕ) := lift D (deltaOp p) |
| abbrev fullSort (p : ℕ) := lift D (sortOp p) |
| abbrev fullExpand (p : ℕ) := lift D (expandOp p) |
| abbrev fullH (p : ℕ) := lift D (contractionOp p) |
| abbrev fullN (p : ℕ) := lift D (normalizeOp p) |
|
|
| omit [Fintype ι] in |
| lemma fullD_square (p : ℕ) (f : fullCochains D p) : fullD D (p+1) (fullD D p f)=0 := by |
| change ((lift D (deltaOp (p+1))).comp (lift D (deltaOp p))) f=0 |
| rw [←lift_comp] |
| funext a |
| exact congrFun (FiniteCoverCech.delta_square R (D.obj (FiniteCoverCech.intersection a)) p |
| (toFixed D (fullCarrier p) (FiniteCoverCech.intersection a) f)) a |
|
|
| omit [Fintype ι] in |
| lemma sortedD_eq (p : ℕ) : lift D (sortedDeltaOp p)=FiniteModuleCech.d D p := by |
| apply LinearMap.ext |
| intro f |
| funext s |
| change (∑ i : Fin (p+1),(-1:ℤ)^i.val • |
| toFixed D (sortedCarrier p) s.val f (AlternatingCech.delete s i))=_ |
| apply Finset.sum_congr rfl |
| intro i hi |
| congr 1 |
| change (if h : (AlternatingCech.delete s i).val⊆s.val then _ else _)=_ |
| rw [dite_eq_left (AlternatingCech.delete_subset s i)] |
|
|
| omit [Fintype ι] in |
| lemma fullSort_d (p : ℕ) : |
| (fullSort D (p+1)).comp (fullD D p)=(FiniteModuleCech.d D p).comp (fullSort D p) := by |
| rw [←sortedD_eq] |
| exact (by |
| rw [←lift_comp,←lift_comp] |
| exact lift_congr D (fun M => sort_delta M p)) |
|
|
| lemma fullExpand_d (p : ℕ) : |
| (fullExpand D (p+1)).comp (FiniteModuleCech.d D p)=(fullD D p).comp (fullExpand D p) := by |
| rw [←sortedD_eq] |
| rw [←lift_comp,←lift_comp] |
| exact lift_congr D (fun M => expand_delta M p) |
|
|
| lemma fullSort_expand (p : ℕ) : (fullSort D p).comp (fullExpand D p)=LinearMap.id := by |
| rw [←lift_id D (sortedCarrier p)] |
| rw [←lift_comp] |
| exact lift_congr D (fun M => sort_expand M p) |
|
|
| lemma fullExpand_sort (p : ℕ) : (fullExpand D p).comp (fullSort D p)=fullN D p := by |
| rw [←lift_comp] |
| exact lift_congr D (fun M => expand_sort M p) |
|
|
| lemma fullH_zero : fullH D 0=0 := by |
| apply LinearMap.ext |
| intro f |
| funext a |
| rfl |
|
|
| lemma fullH_identity (p : ℕ) : |
| (fullH D (p+1)).comp (fullD D (p+1))+(fullD D p).comp (fullH D p)= |
| LinearMap.id-fullN D (p+1) := by |
| change (lift D (contractionOp (p+1))).comp (lift D (deltaOp (p+1)))+ |
| (lift D (deltaOp p)).comp (lift D (contractionOp p))=LinearMap.id-lift D (normalizeOp (p+1)) |
| rw [←lift_comp,←lift_comp,←lift_add,←lift_id D (fullCarrier (p+1)),←lift_sub] |
| apply lift_congr D |
| intro M |
| apply LinearMap.ext |
| exact contraction_identity R M p |
|
|
| |
| def fullPositive : CochainComplex (ModuleCat.{u} R) ℕ := |
| CochainComplex.of (fun p => ModuleCat.of R (fullCochains D (p+1))) |
| (fun p => ModuleCat.ofHom (fullD D (p+1))) (fun p => by |
| apply ModuleCat.hom_ext |
| apply LinearMap.ext |
| exact fullD_square D (p+1)) |
|
|
| omit [Fintype ι] in |
| lemma fullPositive_d (p : ℕ) : (fullPositive D).d p (p+1)=ModuleCat.ofHom (fullD D (p+1)) := by |
| unfold fullPositive |
| exact CochainComplex.of_d (fun q => ModuleCat.of R (fullCochains D (q+1))) |
| (fun q => ModuleCat.ofHom (fullD D (q+1))) p |
|
|
| def sortMap : fullPositive D ⟶ FiniteModuleCech.positiveComplex D := |
| CochainComplex.ofHom (fun p => ModuleCat.ofHom (fullSort D (p+1))) (fun p => by |
| rw [fullPositive_d,FiniteModuleCech.positiveComplex_d] |
| apply ModuleCat.hom_ext |
| exact (fullSort_d D (p+1)).symm) |
|
|
| def expandMap : FiniteModuleCech.positiveComplex D ⟶ fullPositive D := |
| CochainComplex.ofHom (fun p => ModuleCat.ofHom (fullExpand D (p+1))) (fun p => by |
| rw [fullPositive_d,FiniteModuleCech.positiveComplex_d] |
| apply ModuleCat.hom_ext |
| exact (fullExpand_d D (p+1)).symm) |
|
|
| lemma expand_sortMap : expandMap D ≫ sortMap D=𝟙 _ := by |
| apply Hom.ext |
| funext p |
| apply ModuleCat.hom_ext |
| exact fullSort_expand D (p+1) |
|
|
| lemma sort_expandMap (p : ℕ) : |
| ((sortMap D ≫ expandMap D).f p).hom=fullN D (p+1) := fullExpand_sort D (p+1) |
|
|
| def homotopyComponent (i j : ℕ) : (fullPositive D).X i ⟶ (fullPositive D).X j := |
| if h : j+1=i then by subst i; exact ModuleCat.ofHom (fullH D (j+1)) else 0 |
|
|
| lemma homotopyComponent_succ (j : ℕ) : |
| homotopyComponent D (j+1) j=ModuleCat.ofHom (fullH D (j+1)) := by |
| rw [homotopyComponent,dite_eq_left rfl] |
|
|
| def normalizationHomotopy : Homotopy (𝟙 (fullPositive D)) (sortMap D ≫ expandMap D) where |
| hom := homotopyComponent D |
| zero i j h := by |
| change ¬j+1=i at h |
| rw [homotopyComponent,dite_eq_right h] |
| comm i := by |
| rw [Homotopy.dNext_cochainComplex,homotopyComponent_succ,fullPositive_d] |
| cases i with |
| | zero => |
| rw [Homotopy.prevD_zero_cochainComplex,add_zero] |
| apply ModuleCat.hom_ext |
| have hh := fullH_identity D 0 |
| rw [fullH_zero,LinearMap.comp_zero,add_zero] at hh |
| change LinearMap.id=(fullH D 1).comp (fullD D 1)+_ |
| rw [sort_expandMap] |
| exact (eq_sub_iff_add_eq.mp hh).symm |
| | succ i => |
| rw [Homotopy.prevD_succ_cochainComplex,homotopyComponent_succ,fullPositive_d] |
| apply ModuleCat.hom_ext |
| change LinearMap.id=(fullH D (i+2)).comp (fullD D (i+2))+ |
| (fullD D (i+1)).comp (fullH D (i+1))+_ |
| rw [sort_expandMap] |
| exact (eq_sub_iff_add_eq.mp (fullH_identity D (i+1))).symm |
|
|
| |
| def homotopyEquiv : HomotopyEquiv (fullPositive D) (FiniteModuleCech.positiveComplex D) where |
| hom := sortMap D |
| inv := expandMap D |
| homotopyHomInvId := (normalizationHomotopy D).symm |
| homotopyInvHomId := Homotopy.ofEq (expand_sortMap D) |
| end Lech.CechNormalization |
|
|
| end |
|
|
| end OAI |
|
|
