| import Mathlib |
| import OAI.RingTheory.Multiplicity.FilteredFractionReesDenominatorTheory |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits HomologicalComplex |
| open CategoryTheory CategoryTheory.Limits |
| open scoped ENNReal ZeroObject |
| open CategoryTheory |
| attribute [local instance] Classical.propDecidable |
| open CategoryTheory CategoryTheory.Limits CategoryTheory.ComposableArrows |
| open HomologicalComplex HomologicalComplex.HomologySequence CategoryTheory.Abelian |
| open scoped BigOperators |
| namespace Lech.AlternatingCech |
| open scoped BigOperators |
| universe u v w |
| variable (R : Type u) [CommRing R] (M : Type v) [AddCommGroup M] [Module R M] |
| variable {ι : Type w} [Fintype ι] [DecidableEq ι] |
| abbrev Alt (n : ℕ) := (ι → R) [⋀^Fin n]→ₗ[R] M |
| abbrev basis : Module.Basis ι R (ι → R) := Pi.basisFun R ι |
| def evaluation (n : ℕ) : Alt R M (ι := ι) n →ₗ[R] FiniteCoverCech.Row M (ι := ι) n where |
| toFun f a := f (fun i => basis R (a i)) |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
| omit [DecidableEq ι] in |
| lemma evaluation_injective (n : ℕ) : Function.Injective (evaluation R M (ι := ι) n) := by |
| intro f g h |
| apply (basis R (ι := ι)).ext_alternating |
| intro a _ |
| exact congrFun h a |
|
|
| def epsilon : (ι → R) →ₗ[R] R := ∑ i : ι,LinearMap.proj i |
| lemma epsilon_basis (i : ι) : epsilon R (basis R i)=1 := by |
| simp [epsilon,basis,Pi.basisFun_apply] |
|
|
| def delta (n : ℕ) : Alt R M (ι := ι) n →ₗ[R] Alt R M (ι := ι) (n+1) where |
| toFun f := AlternatingMap.alternatizeUncurryFin ((epsilon R).smulRight f) |
| map_add' f g := by |
| ext v |
| simp [AlternatingMap.alternatizeUncurryFin_apply,smul_add,Finset.sum_add_distrib] |
| map_smul' r f := by |
| ext v |
| simp only [AlternatingMap.alternatizeUncurryFin_apply,LinearMap.smulRight_apply, |
| AlternatingMap.smul_apply,RingHom.id_apply,Finset.smul_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [smul_comm (epsilon R (v i)) r,smul_comm ((-1:ℤ)^i.val) r] |
| lemma evaluation_delta (n : ℕ) (f : Alt R M (ι := ι) n) : |
| evaluation R M (n+1) (delta R M n f)=FiniteCoverCech.delta R M n (evaluation R M n f) := by |
| ext a |
| simp only [evaluation,LinearMap.coe_mk,AddHom.coe_mk,delta, |
| AlternatingMap.alternatizeUncurryFin_apply,LinearMap.smulRight_apply, |
| epsilon_basis,one_smul,FiniteCoverCech.delta] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [←Int.cast_smul_eq_zsmul R] |
| simp only [Int.cast_pow,Int.cast_neg,Int.cast_one] |
| rfl |
|
|
| def extra (j : ι) (n : ℕ) : Alt R M (ι := ι) (n+1) →ₗ[R] Alt R M (ι := ι) n where |
| toFun f := f.curryLeft (basis R j) |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
| omit [DecidableEq ι] in |
| lemma evaluation_extra (j : ι) (n : ℕ) (f : Alt R M (ι := ι) (n+1)) : |
| evaluation R M n (extra R M j n f)=FiniteCoverCech.extra R M j n (evaluation R M (n+1) f) := by |
| ext a |
| change f (Fin.cons (basis R j) (fun i => basis R (a i)))= |
| f (fun i => basis R ((Fin.cons j a : Fin (n+1) → ι) i)) |
| congr 1 |
| funext i |
| exact Fin.cases rfl (fun _ => rfl) i |
| lemma delta_square (n : ℕ) (f : Alt R M (ι := ι) n) : delta R M (n+1) (delta R M n f)=0 := by |
| apply evaluation_injective R M (n+2) |
| rw [evaluation_delta,evaluation_delta,map_zero,FiniteCoverCech.delta_square] |
| lemma extra_delta (j : ι) (n : ℕ) (f : Alt R M (ι := ι) (n+1)) : |
| extra R M j (n+1) (delta R M (n+1) f)+delta R M n (extra R M j n f)=f := by |
| apply evaluation_injective R M (n+1) |
| rw [map_add,evaluation_extra,evaluation_delta,evaluation_delta,evaluation_extra] |
| exact FiniteCoverCech.extra_delta R M j n (evaluation R M (n+1) f) |
| omit [DecidableEq ι] in |
| |
|
|
| lemma eq_zero_above_card (n : ℕ) (hn : Fintype.card ι<n) (f : Alt R M (ι := ι) n) : f=0 := by |
| apply (basis R (ι := ι)).ext_alternating |
| intro a ha |
| have h := Fintype.card_le_of_injective a ha |
| simp only [Fintype.card_fin] at h |
| omega |
|
|
| variable (F : Finset ι → Submodule R M) (hF : Monotone F) |
| def cochains (n : ℕ) : Submodule R (Alt R M (ι := ι) n) := |
| (FiniteCoverCech.cochains R M F n).comap (evaluation R M n) |
| include hF in |
| lemma delta_mem (n : ℕ) {f : Alt R M (ι := ι) n} (hf : f∈cochains R M F n) : |
| delta R M n f∈cochains R M F (n+1) := by |
| change evaluation R M (n+1) (delta R M n f)∈FiniteCoverCech.cochains R M F (n+1) |
| rw [evaluation_delta] |
| exact FiniteCoverCech.delta_mem R M F hF n hf |
| variable (q : ι → R) (hq : Ideal.span (Set.range q)=⊤) |
| variable (hclear : ∀ (s : Finset ι) (j : ι) (x : M),x∈F (insert j s) → ∃ N : ℕ,q j^N • x∈F s) |
| include hq hclear in |
| |
|
|
| theorem exact (n : ℕ) (f : cochains R M F (n+1)) (hf : delta R M (n+1) f.val=0) : |
| ∃ g : cochains R M F n,delta R M n g.val=f.val := by |
| let ef : FiniteCoverCech.cochains R M F (n+1) := ⟨evaluation R M (n+1) f.val,f.property⟩ |
| obtain ⟨N,hN⟩ := FiniteCoverCech.uniform_clear R M F q hclear n ef |
| obtain ⟨c,hc⟩ := FiniteCoverCech.partition R q hq N |
| let g : Alt R M (ι := ι) n := ∑ j,c j • (q j^N • extra R M j n f.val) |
| have hg : g∈cochains R M F n := by |
| intro a |
| change (evaluation R M n g) a∈F (FiniteCoverCech.intersection a) |
| simp only [g,map_sum,map_smul,evaluation_extra,Finset.sum_apply,Pi.smul_apply] |
| exact (F _).sum_mem fun j _ => (F _).smul_mem _ (hN j a) |
| refine ⟨⟨g,hg⟩,?_⟩ |
| have hj (j : ι) : delta R M n (extra R M j n f.val)=f.val := by |
| have h := extra_delta R M j n f.val |
| rw [hf,map_zero,zero_add] at h |
| exact h |
| simp only [g,map_sum,map_smul,hj,smul_smul,←Finset.sum_smul,hc,one_smul] |
| end Lech.AlternatingCech |
|
|
|
|
| namespace Lech.AlternatingCech |
| open CategoryTheory CategoryTheory.Limits HomologicalComplex |
| open scoped BigOperators |
| universe u |
| variable (R : Type u) [CommRing R] (M : Type u) [AddCommGroup M] [Module R M] |
| variable {ι : Type} [Fintype ι] [DecidableEq ι] |
| variable (F : Finset ι → Submodule R M) (hF : Monotone F) |
| def differential (n : ℕ) : cochains R M F n →ₗ[R] cochains R M F (n+1) := |
| (delta R M n).restrict (fun _ h => delta_mem R M F hF n h) |
| lemma differential_square (n : ℕ) (f : cochains R M F n) : |
| differential R M F hF (n+1) (differential R M F hF n f)=0 := by |
| apply Subtype.ext |
| exact delta_square R M n f.val |
| |
|
|
| def complex : CochainComplex (ModuleCat.{u} R) ℕ := |
| CochainComplex.of (fun n => ModuleCat.of R (cochains R M F n)) |
| (fun n => ModuleCat.ofHom (differential R M F hF n)) (fun n => by |
| apply ModuleCat.hom_ext |
| apply LinearMap.ext |
| intro f |
| exact differential_square R M F hF n f) |
| lemma complex_d (n : ℕ) : (complex R M F hF).d n (n+1)= |
| ModuleCat.ofHom (differential R M F hF n) := by |
| change CochainComplex.of.d (fun n => ModuleCat.of R (cochains R M F n)) |
| (fun n => ModuleCat.ofHom (differential R M F hF n)) n (n+1)=_ |
| exact CochainComplex.of_d _ _ n |
| lemma complex_bounded (n : ℕ) (hn : Fintype.card ι<n) : IsZero ((complex R M F hF).X n) := by |
| have : Subsingleton (cochains R M F n) := subsingleton_of_forall_eq 0 (fun f => |
| Subtype.ext (eq_zero_above_card R M n hn f.val)) |
| exact ModuleCat.isZero_of_subsingleton (ModuleCat.of R (cochains R M F n)) |
| variable (q : ι → R) (hq : Ideal.span (Set.range q)=⊤) |
| variable (hclear : ∀ (s : Finset ι) (j : ι) (x : M),x∈F (insert j s) → ∃ N : ℕ,q j^N • x∈F s) |
| include hq hclear in |
| lemma complex_exactAt (n : ℕ) : (complex R M F hF).ExactAt (n+1) := by |
| apply ((complex R M F hF).exactAt_iff' (i := n) (j := n+1) (k := n+2) |
| (by simp) (by simp)).mpr |
| rw [ShortComplex.moduleCat_exact_iff] |
| intro f hf |
| change ((complex R M F hF).d (n+1) (n+2)).hom f=0 at hf |
| rw [complex_d] at hf |
| obtain ⟨g,hg⟩ := exact R M F q hq hclear n f (congrArg Subtype.val hf) |
| refine ⟨g,?_⟩ |
| change ((complex R M F hF).d n (n+1)).hom g=f |
| rw [complex_d] |
| exact Subtype.ext hg |
| omit [DecidableEq ι] in |
| lemma extra_delta_zero (j : ι) (f : Alt R M (ι := ι) 0) : |
| extra R M j 0 (delta R M 0 f)=f := by |
| classical |
| ext v |
| change AlternatingMap.alternatizeUncurryFin ((epsilon R).smulRight f) |
| (Fin.cons (basis R j) v)=f v |
| simp [AlternatingMap.alternatizeUncurryFin_apply] |
| change (epsilon R) (basis R j) • f v = f v |
| rw [epsilon_basis,one_smul] |
| include hq in |
| lemma differential_injective : Function.Injective (differential R M F hF 0) := by |
| apply (differential R M F hF 0).ker_eq_bot.mp |
| apply (LinearMap.ker_eq_bot').mpr |
| intro f hf |
| have hδ : delta R M 0 f.val=0 := congrArg Subtype.val hf |
| obtain ⟨c,hc⟩ := FiniteCoverCech.partition R q hq 0 |
| simp only [pow_zero,mul_one] at hc |
| have hz (j : ι) : f.val=0 := by |
| have h := extra_delta_zero R M j f.val |
| rw [hδ,map_zero] at h |
| exact h.symm |
| apply Subtype.ext |
| calc |
| f.val = (∑ j,c j) • f.val := by rw [hc,one_smul] |
| _ = ∑ j,c j • f.val := Finset.sum_smul |
| _ = 0 := by |
| apply Finset.sum_eq_zero |
| intro j _ |
| rw [hz j,smul_zero] |
| include hq in |
| lemma complex_exactAt_zero : (complex R M F hF).ExactAt 0 := by |
| apply ((complex R M F hF).exactAt_iff' (i := 0) (j := 0) (k := 1) |
| (by simp) (by simp)).mpr |
| rw [ShortComplex.moduleCat_exact_iff] |
| intro f hf |
| change ((complex R M F hF).d 0 1).hom f=0 at hf |
| rw [complex_d] at hf |
| have hf0 : f=0 := differential_injective R M F hF q hq (hf.trans (map_zero _).symm) |
| exact ⟨0,by simp [hf0]⟩ |
| include hq hclear in |
| |
| theorem complex_acyclic : (complex R M F hF).Acyclic := by |
| intro n |
| cases n with |
| | zero => exact complex_exactAt_zero R M F hF q hq |
| | succ n => exact complex_exactAt R M F hF q hq hclear n |
| end Lech.AlternatingCech |
| |
| |
| namespace Lech.AlternatingCech |
| open scoped BigOperators |
| open Set |
| universe u v w |
| variable (R : Type u) [CommRing R] (M : Type v) [AddCommGroup M] [Module R M] |
| variable {ι : Type w} [Fintype ι] [LinearOrder ι] |
| |
| def sortedCoordinates (n : ℕ) : Alt R M (ι := ι) n ≃ₗ[R] (powersetCard ι n → M) := |
| exteriorPower.alternatingMapLinearEquiv.trans |
| (((basis R (ι := ι)).exteriorPower n).constr R).symm |
| lemma sortedCoordinates_apply (n : ℕ) (f : Alt R M (ι := ι) n) (s : powersetCard ι n) : |
| sortedCoordinates R M n f s = f (fun i => basis R (s.val.orderEmbOfFin s.property i)) := by |
| change exteriorPower.alternatingMapLinearEquiv f ((basis R).exteriorPower n s)=_ |
| rw [exteriorPower.basis_apply,exteriorPower.ιMulti_family, |
| exteriorPower.alternatingMapLinearEquiv_apply_ιMulti] |
| rfl |
| omit [Fintype ι] in |
| lemma tuple_sort {n : ℕ} (a : Fin n → ι) (ha : Function.Injective a) : |
| ∃ s : powersetCard ι n,∃ σ : Equiv.Perm (Fin n), |
| FiniteCoverCech.intersection a=s.val ∧ a=(s.val.orderEmbOfFin s.property) ∘ σ := by |
| let s : powersetCard ι n := ⟨FiniteCoverCech.intersection a,by |
| change (FiniteCoverCech.intersection a).card=n |
| rw [FiniteCoverCech.intersection,Finset.card_image_of_injective _ ha,Finset.card_univ,Fintype.card_fin]⟩ |
| let e : Fin n ≃ s.val := Equiv.ofBijective |
| (fun i => ⟨a i,Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩⟩) |
| ⟨fun i j h => ha (congrArg Subtype.val h),by |
| intro j |
| obtain ⟨i,_,hi⟩ := Finset.mem_image.mp j.property |
| exact ⟨i,Subtype.ext hi⟩⟩ |
| let σ : Equiv.Perm (Fin n) := e.trans (s.val.orderIsoOfFin s.property).symm.toEquiv |
| refine ⟨s,σ,rfl,?_⟩ |
| funext i |
| change a i = ((s.val.orderIsoOfFin s.property) ((s.val.orderIsoOfFin s.property).symm (e i))).val |
| rw [OrderIso.apply_symm_apply] |
| rfl |
| omit [Fintype ι] in |
| lemma sorted_intersection (n : ℕ) (s : powersetCard ι n) : |
| FiniteCoverCech.intersection (s.val.orderEmbOfFin s.property)=s.val := by |
| ext i |
| simp only [FiniteCoverCech.intersection,Finset.mem_image,Finset.mem_univ,true_and] |
| change (∃ j, s.val.orderEmbOfFin s.property j=i) ↔ _ |
| change i∈Set.range (s.val.orderEmbOfFin s.property) ↔ i∈s.val |
| exact Iff.of_eq (congrArg (fun S : Set ι => i∈S) (Finset.range_orderEmbOfFin s.val s.property)) |
| |
| variable (F : Finset ι → Submodule R M) |
| lemma mem_cochains_iff_sorted (n : ℕ) (f : Alt R M (ι := ι) n) : |
| f∈cochains R M F n ↔ ∀ s : powersetCard ι n,sortedCoordinates R M n f s∈F s.val := by |
| constructor |
| · intro hf s |
| rw [sortedCoordinates_apply] |
| have h := hf (s.val.orderEmbOfFin s.property) |
| rw [sorted_intersection] at h |
| exact h |
| · intro hf a |
| by_cases ha : Function.Injective a |
| · obtain ⟨s,σ,hs,hσ⟩ := tuple_sort a ha |
| change f (fun i => basis R (a i))∈F (FiniteCoverCech.intersection a) |
| rw [hs,hσ] |
| change f ((fun i => basis R (s.val.orderEmbOfFin s.property i)) ∘ σ)∈F s.val |
| rw [f.map_perm] |
| have hh := hf s |
| rw [sortedCoordinates_apply] at hh |
| change ((Equiv.Perm.sign σ : ℤ) • f (fun i => basis R (s.val.orderEmbOfFin s.property i)))∈F s.val |
| rw [←Int.cast_smul_eq_zsmul R] |
| exact (F s.val).smul_mem _ hh |
| · change f (fun i => basis R (a i))∈F (FiniteCoverCech.intersection a) |
| rw [f.map_eq_zero_of_not_injective _ (fun hh => ha (fun i j hij => hh (congrArg (basis R) hij)))] |
| exact (F _).zero_mem |
| |
| |
| def cochainsSorted (n : ℕ) : cochains R M F n ≃ₗ[R] (∀ s : powersetCard ι n,F s.val) where |
| toFun f s := ⟨sortedCoordinates R M n f.val s,(mem_cochains_iff_sorted R M F n f.val).mp f.property s⟩ |
| invFun f := ⟨(sortedCoordinates R M n).symm (fun s => (f s).val), |
| (mem_cochains_iff_sorted R M F n _).mpr (by |
| intro s |
| simpa only [LinearEquiv.apply_symm_apply] using (f s).property)⟩ |
| left_inv f := Subtype.ext ((sortedCoordinates R M n).symm_apply_apply f.val) |
| right_inv f := by ext s; exact congrFun ((sortedCoordinates R M n).apply_symm_apply (fun s => (f s).val)) s |
| map_add' f g := by |
| ext s |
| exact congrFun ((sortedCoordinates R M n).map_add f.val g.val) s |
| map_smul' r f := by |
| ext s |
| exact congrFun ((sortedCoordinates R M n).map_smul r f.val) s |
| end Lech.AlternatingCech |
| |
| |
| namespace Lech.AlternatingCech |
| open Set |
| open scoped BigOperators |
| universe u |
| variable (R : Type u) [CommRing R] (M : Type u) [AddCommGroup M] [Module R M] |
| variable {ι : Type} [Fintype ι] [LinearOrder ι] |
| def vertexMap (τ : ι → ι) : (ι → R) →ₗ[R] (ι → R) := |
| (basis R).constr R (fun i => basis R (τ i)) |
| omit [LinearOrder ι] in |
| lemma vertexMap_basis (τ : ι → ι) (i : ι) : vertexMap R τ (basis R i)=basis R (τ i) := by |
| simp [vertexMap] |
| def pullback (τ : ι → ι) (p : ℕ) : Alt R M (ι:=ι) p →ₗ[R] Alt R M (ι:=ι) p where |
| toFun f := f.compLinearMap (vertexMap R τ) |
| map_add' f g := by ext v;rfl |
| map_smul' r f := by ext v;rfl |
| omit [LinearOrder ι] in |
| lemma pullback_eval (τ : ι → ι) (p : ℕ) (f : Alt R M (ι:=ι) p) (a : Fin p → ι) : |
| evaluation R M p (pullback R M τ p f) a = evaluation R M p f (τ ∘ a) := by |
| change f (fun i => vertexMap R τ (basis R (a i)))=f (fun i => basis R (τ (a i))) |
| simp only [vertexMap_basis] |
| omit [LinearOrder ι] in |
| lemma pullback_delta (τ : ι → ι) (p : ℕ) (f : Alt R M (ι:=ι) p) : |
| pullback R M τ (p+1) (delta R M p f)=delta R M p (pullback R M τ p f) := by |
| apply evaluation_injective R M (p+1) |
| ext a |
| rw [pullback_eval,evaluation_delta,evaluation_delta] |
| simp only [FiniteCoverCech.delta,LinearMap.coe_mk,AddHom.coe_mk] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [pullback_eval] |
| rfl |
| |
| |
| def prism (τ : ι → ι) : (p : ℕ) → Alt R M (ι:=ι) (p+1) →ₗ[R] Alt R M (ι:=ι) p |
| | 0 => 0 |
| | p+1 => |
| (sortedCoordinates R M (p+1)).symm.toLinearMap.comp |
| (LinearMap.pi (fun s : powersetCard ι (p+1) => |
| let c := τ (s.val.orderEmbOfFin s.property 0) |
| (LinearMap.proj s).comp ((sortedCoordinates R M (p+1)).toLinearMap.comp |
| ((extra R M c (p+1)) - (delta R M p).comp ((prism τ p).comp (extra R M c (p+1))))))) |
| lemma prism_succ (τ : ι → ι) (p : ℕ) (f : Alt R M (ι:=ι) (p+2)) (s : powersetCard ι (p+1)) : |
| sortedCoordinates R M (p+1) (prism R M τ (p+1) f) s = |
| let c := τ (s.val.orderEmbOfFin s.property 0) |
| sortedCoordinates R M (p+1) (extra R M c (p+1) f - delta R M p (prism R M τ p (extra R M c (p+1) f))) s := by |
| change (sortedCoordinates R M (p+1)) ((sortedCoordinates R M (p+1)).symm _) s=_ |
| rw [LinearEquiv.apply_symm_apply] |
| rfl |
| omit [LinearOrder ι] in |
| lemma pullback_zero (τ : ι → ι) (f : Alt R M (ι:=ι) 0) : pullback R M τ 0 f=f := by |
| ext v |
| change f _=f v |
| congr 1 |
| exact Subsingleton.elim _ _ |
| lemma pullback_extra_sorted_zero (τ : ι → ι) (p : ℕ) (f : Alt R M (ι:=ι) (p+2)) |
| (s : powersetCard ι (p+1)) : |
| sortedCoordinates R M (p+1) |
| (pullback R M τ (p+1) (extra R M (τ (s.val.orderEmbOfFin s.property 0)) (p+1) f)) s=0 := by |
| rw [sortedCoordinates_apply] |
| change evaluation R M (p+1) |
| (pullback R M τ (p+1) (extra R M (τ (s.val.orderEmbOfFin s.property 0)) (p+1) f)) |
| (s.val.orderEmbOfFin s.property)=0 |
| rw [pullback_eval,evaluation_extra] |
| let a : Fin (p+1) → ι := s.val.orderEmbOfFin s.property |
| change f (fun i => basis R ((Fin.cons (τ (a 0)) (τ ∘ a) : Fin (p+2) → ι) i))=0 |
| apply f.map_eq_zero_of_eq (i:=0) (j:=Fin.succ 0) |
| · rfl |
| · exact (Fin.succ_ne_zero (0 : Fin (p+1))).symm |
| lemma prism_identity_step (τ : ι → ι) (p : ℕ) |
| (h : ∀ g : Alt R M (ι:=ι) p, |
| delta R M p (prism R M τ p (delta R M p g))= |
| delta R M p g-pullback R M τ (p+1) (delta R M p g)) |
| (f : Alt R M (ι:=ι) (p+1)) : |
| prism R M τ (p+1) (delta R M (p+1) f)+delta R M p (prism R M τ p f)= |
| f-pullback R M τ (p+1) f := by |
| apply (sortedCoordinates R M (p+1)).injective |
| ext s |
| rw [map_add,Pi.add_apply,prism_succ] |
| let c := τ (s.val.orderEmbOfFin s.property 0) |
| let g := extra R M c p f |
| have he : extra R M c (p+1) (delta R M (p+1) f)=f-delta R M p g := |
| eq_sub_iff_add_eq.mpr (extra_delta R M c p f) |
| have hp : pullback R M τ (p+1) (delta R M p g)= |
| pullback R M τ (p+1) f - pullback R M τ (p+1) (extra R M c (p+1) (delta R M (p+1) f)) := by |
| rw [he,map_sub] |
| abel |
| have hh : extra R M c (p+1) (delta R M (p+1) f)- |
| delta R M p (prism R M τ p (extra R M c (p+1) (delta R M (p+1) f)))+ |
| delta R M p (prism R M τ p f)= |
| f-pullback R M τ (p+1) f+ |
| pullback R M τ (p+1) (extra R M c (p+1) (delta R M (p+1) f)) := by |
| rw [he,map_sub,map_sub,h g,hp,he] |
| abel |
| have hs := congrArg (fun z => sortedCoordinates R M (p+1) z s) hh |
| simpa only [c,map_add,Pi.add_apply,pullback_extra_sorted_zero,add_zero] using hs |
| |
| |
| lemma prism_identity (τ : ι → ι) (p : ℕ) (f : Alt R M (ι:=ι) (p+1)) : |
| prism R M τ (p+1) (delta R M (p+1) f)+delta R M p (prism R M τ p f)= |
| f-pullback R M τ (p+1) f := by |
| induction p with |
| | zero => |
| apply prism_identity_step |
| intro g |
| rw [prism,LinearMap.zero_apply,map_zero,pullback_delta,pullback_zero,sub_self] |
| | succ p ih => |
| apply prism_identity_step |
| intro g |
| have hi := congrArg (delta R M (p+1)) (ih g) |
| rw [map_add,delta_square,add_zero,map_sub,←pullback_delta] at hi |
| exact hi |
| |
| |
| lemma sortedCoordinates_eq_evaluation (p : ℕ) (f : Alt R M (ι:=ι) p) (s : powersetCard ι p) : |
| sortedCoordinates R M p f s=evaluation R M p f (s.val.orderEmbOfFin s.property) := |
| sortedCoordinates_apply R M p f s |
| lemma evaluation_mem_of_sorted (T : Finset ι) (P : Submodule R M) (p : ℕ) (f : Alt R M (ι:=ι) p) |
| (hf : ∀ s : powersetCard ι p,s.val⊆T → sortedCoordinates R M p f s∈P) |
| (a : Fin p → ι) (ha : ∀ i,a i∈T) : evaluation R M p f a∈P := by |
| let F : Finset ι → Submodule R M := fun s => if s⊆T then P else ⊤ |
| have hh : f∈cochains R M F p := (mem_cochains_iff_sorted R M F p f).mpr (by |
| intro s |
| by_cases hs : s.val⊆T |
| · simpa only [F,ite_eq_left hs] using hf s hs |
| · simp only [F,ite_eq_right hs,Submodule.mem_top]) |
| have hs : FiniteCoverCech.intersection a⊆T := by |
| intro i hi |
| obtain ⟨j,_,rfl⟩ := Finset.mem_image.mp hi |
| exact ha j |
| simpa only [F,ite_eq_left hs] using hh a |
| |
| |
| lemma prism_local (τ : ι → ι) (T : Finset ι) (hT : ∀ i∈T,τ i∈T) |
| (P : Submodule R M) (p : ℕ) (f : Alt R M (ι:=ι) (p+1)) |
| (hf : ∀ a : Fin (p+1) → ι,(∀ i,a i∈T) → evaluation R M (p+1) f a∈P) |
| (a : Fin p → ι) (ha : ∀ i,a i∈T) : evaluation R M p (prism R M τ p f) a∈P := by |
| induction p with |
| | zero => simpa only [prism,LinearMap.zero_apply,map_zero,Pi.zero_apply] using P.zero_mem |
| | succ p ih => |
| apply evaluation_mem_of_sorted R M T P (p+1) _ ?_ a ha |
| intro s hs |
| let c := τ (s.val.orderEmbOfFin s.property 0) |
| rw [prism_succ] |
| change sortedCoordinates R M (p+1) |
| (extra R M c (p+1) f-delta R M p (prism R M τ p (extra R M c (p+1) f))) s∈P |
| rw [map_sub,Pi.sub_apply] |
| have hc : c∈T := hT _ (hs (s.val.orderEmbOfFin_mem s.property 0)) |
| have hextra : ∀ b : Fin (p+1) → ι,(∀ i,b i∈T) → |
| evaluation R M (p+1) (extra R M c (p+1) f) b∈P := by |
| intro b hb |
| rw [evaluation_extra] |
| change evaluation R M (p+2) f (Fin.cons c b)∈P |
| apply hf |
| intro i |
| exact Fin.cases hc (fun i => hb i) i |
| apply P.sub_mem |
| · rw [sortedCoordinates_eq_evaluation] |
| exact hextra _ (fun i => hs (s.val.orderEmbOfFin_mem s.property i)) |
| · rw [sortedCoordinates_eq_evaluation,evaluation_delta] |
| change (∑ i : Fin (p+1),(-1:R)^i.val • |
| evaluation R M p (prism R M τ p (extra R M c (p+1) f)) |
| ((s.val.orderEmbOfFin s.property) ∘ i.succAbove))∈P |
| apply P.sum_mem |
| intro i _ |
| apply P.smul_mem |
| apply ih (extra R M c (p+1) f) hextra |
| intro j |
| exact hs (s.val.orderEmbOfFin_mem s.property (i.succAbove j)) |
| |
| |
| lemma prism_mem (τ : ι → ι) (hτ : ∀ i,τ (τ i)=τ i) |
| (F : Finset ι → Submodule R M) (hF : Monotone F) |
| (hcarrier : ∀ s,F (s∪s.image τ)≤F s) (p : ℕ) |
| (f : Alt R M (ι:=ι) (p+1)) (hf : f∈cochains R M F (p+1)) : |
| prism R M τ p f∈cochains R M F p := by |
| apply (mem_cochains_iff_sorted R M F p _).mpr |
| intro s |
| rw [sortedCoordinates_eq_evaluation] |
| apply hcarrier s.val |
| have hstable : ∀ i∈s.val∪s.val.image τ,τ i∈s.val∪s.val.image τ := by |
| intro i hi |
| rcases Finset.mem_union.mp hi with hi|hi |
| · exact Finset.mem_union_right _ (Finset.mem_image.mpr ⟨i,hi,rfl⟩) |
| · obtain ⟨j,hj,rfl⟩ := Finset.mem_image.mp hi |
| rw [hτ] |
| exact Finset.mem_union_right _ (Finset.mem_image.mpr ⟨j,hj,rfl⟩) |
| apply prism_local R M τ (s.val∪s.val.image τ) hstable (F (s.val∪s.val.image τ)) p f |
| · intro a ha |
| apply hF ?_ (hf a) |
| intro i hi |
| obtain ⟨j,_,rfl⟩ := Finset.mem_image.mp hi |
| exact ha j |
| · intro i |
| exact Finset.mem_union_left _ (s.val.orderEmbOfFin_mem s.property i) |
| end Lech.AlternatingCech |
| end |
| |
| end OAI |
| |
