lean/OAI/RingTheory/Multiplicity/AlternatingCechUnaugmentedComplex.lean

import Mathlib
import OAI.RingTheory.Multiplicity.LechConnectingIso

namespace OAI

section
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
open scoped Classical
namespace Lech.AlternatingCech
open Set 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 ι] [LinearOrder ι]
variable (F : Finset ι → Submodule R M) (hF : Monotone F)
abbrev unaugmentedComplex := sortedComplex R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF)
def unaugmentedInclusion (p : ℕ) : sorted R M (zeroAugmentation R M F) p →ₗ[R] sorted R M F p where
  toFun f s := ⟨f s,by
    have h := (f s).property
    by_cases hs : s.val=∅
    · have hz : (f s:M)=0 := by simpa only [zeroAugmentation,ite_eq_left hs,Submodule.mem_bot] using h
      rw [hz];exact (F s.val).zero_mem
    · simpa only [zeroAugmentation,ite_eq_right hs] using h⟩
  map_add' f g := rfl
  map_smul' r f := rfl
omit [Fintype ι] in
lemma unaugmentedInclusion_injective (p : ℕ) : Function.Injective (unaugmentedInclusion R M F p) := by
  intro f g h
  ext s
  exact congrArg (fun f : sorted R M F p => (f s:M)) h
omit [Fintype ι] in
lemma unaugmentedInclusion_delta (p : ℕ) (f : sorted R M (zeroAugmentation R M F) p) :
    unaugmentedInclusion R M F (p+1) (sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) p f)=
      sortedDelta R M F hF p (unaugmentedInclusion R M F p f) := by
  ext s
  simp only [unaugmentedInclusion,sortedDelta,LinearMap.coe_mk,AddHom.coe_mk,
    Submodule.coe_sum,Submodule.coe_smul_of_tower]
  rfl
omit [Fintype ι] in
lemma unaugmentedInclusion_surjective (p : ℕ) (hp : 0<p) : Function.Surjective (unaugmentedInclusion R M F p) := by
  intro f
  refine ⟨(fun s => ⟨f s,?_⟩),rfl⟩
  have hs : s.val≠∅ := (Finset.card_pos.mp (s.property.symm ▸ hp)).ne_empty
  simpa only [zeroAugmentation,ite_eq_right hs] using (f s).property
def unaugmentedEquiv (p : ℕ) (hp : 0<p) : sorted R M (zeroAugmentation R M F) p ≃ₗ[R] sorted R M F p :=
  LinearEquiv.ofBijective (unaugmentedInclusion R M F p)
    ⟨unaugmentedInclusion_injective R M F p,unaugmentedInclusion_surjective R M F p hp⟩
lemma unaugmented_isZero_zero : IsZero ((unaugmentedComplex R M F hF).X 0) := by
  have : Subsingleton (sorted R M (zeroAugmentation R M F) 0) := ⟨fun f g => by
    ext s
    rw [DoubleCech.zeroIndex_eq s]
    have hf : (f DoubleCech.emptyIndex:M)=0 := by simpa [DoubleCech.emptyIndex, zeroAugmentation] using (f DoubleCech.emptyIndex).property
    have hg : (g DoubleCech.emptyIndex:M)=0 := by simpa [DoubleCech.emptyIndex, zeroAugmentation] using (g DoubleCech.emptyIndex).property
    exact hf.trans hg.symm⟩
  exact ModuleCat.isZero_of_subsingleton (ModuleCat.of R (sorted R M (zeroAugmentation R M F) 0))
 

lemma unaugmented_exactAt (p : ℕ) (h : (sortedComplex R M F hF).ExactAt (p+2)) :
    (unaugmentedComplex R M F hF).ExactAt (p+2) := by
  apply ((unaugmentedComplex R M F hF).exactAt_iff' (i:=p+1) (j:=p+2) (k:=p+3) (by simp) (by simp)).mpr
  rw [ShortComplex.moduleCat_exact_iff]
  intro f hf
  change sorted R M (zeroAugmentation R M F) (p+2) at f
  change ((unaugmentedComplex R M F hF).d (p+2) (p+3)).hom f=0 at hf
  rw [sortedComplex_d] at hf
  change sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) (p+2) f=0 at hf
  have he := ((sortedComplex R M F hF).exactAt_iff' (i:=p+1) (j:=p+2) (k:=p+3) (by simp) (by simp)).mp h
  rw [ShortComplex.moduleCat_exact_iff] at he
  obtain ⟨g,hg⟩ := he (unaugmentedInclusion R M F (p+2) f) (by
    change ((sortedComplex R M F hF).d (p+2) (p+3)).hom _=0
    rw [sortedComplex_d]
    change sortedDelta R M F hF (p+2) (unaugmentedInclusion R M F (p+2) f)=0
    rw [←unaugmentedInclusion_delta R M F hF,hf,map_zero])
  change sorted R M F (p+1) at g
  change ((sortedComplex R M F hF).d (p+1) (p+2)).hom g = _ at hg
  rw [sortedComplex_d] at hg
  obtain ⟨g',rfl⟩ := unaugmentedInclusion_surjective R M F (p+1) (by omega) g
  refine ⟨g',?_⟩
  change ((unaugmentedComplex R M F hF).d (p+1) (p+2)).hom g'=f
  rw [sortedComplex_d]
  change sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) (p+1) g'=f
  apply unaugmentedInclusion_injective R M F (p+2)
  rw [unaugmentedInclusion_delta R M F hF]
  exact hg
 

def sortedZeroEquiv : sorted R M F 0 ≃ₗ[R] F ∅ where
  toFun f := f DoubleCech.emptyIndex
  invFun x s := (DoubleCech.zeroIndex_eq s).symm ▸ x
  left_inv f := by funext s;cases DoubleCech.zeroIndex_eq s;rfl
  right_inv x := rfl
  map_add' f g := rfl
  map_smul' r f := rfl
variable [Nonempty ι]
omit [Fintype ι] in
lemma sorted_zero_injective : Function.Injective (sortedDelta R M F hF 0) := by
  intro f g h
  apply (sortedZeroEquiv R M F).injective
  let i : ι := Classical.choice (inferInstance : Nonempty ι)
  let s : powersetCard ι 1 := ⟨{i},Finset.card_singleton _⟩
  have hv := congrArg (fun z : sorted R M F 1 => (z s:M)) h
  apply Subtype.ext
  change (∑ j : Fin 1,(-1:ℤ)^j.val • (f (delete s j):M))=(∑ j : Fin 1,(-1:ℤ)^j.val • (g (delete s j):M)) at hv
  simp only [Fin.sum_univ_one,Fin.val_zero,pow_zero,one_zsmul] at hv
  rw [DoubleCech.zeroIndex_eq (delete s 0)] at hv
  exact hv

def unaugmentedAugmentation : sorted R M F 0 →ₗ[R] sorted R M (zeroAugmentation R M F) 1 :=
  (unaugmentedEquiv R M F 1 (by omega)).symm.toLinearMap.comp (sortedDelta R M F hF 0)
omit [Nonempty ι] in
lemma unaugmentedAugmentation_square :
    (sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) 1).comp
      (unaugmentedAugmentation R M F hF)=0 := by
  apply LinearMap.ext
  intro f
  change sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) 1 (unaugmentedAugmentation R M F hF f)=0
  apply unaugmentedInclusion_injective R M F 2
  rw [map_zero,unaugmentedInclusion_delta R M F hF]
  change sortedDelta R M F hF 1 ((unaugmentedEquiv R M F 1 (by omega))
    ((unaugmentedEquiv R M F 1 (by omega)).symm (sortedDelta R M F hF 0 f)))=0
  rw [LinearEquiv.apply_symm_apply,sortedDelta_square]
def augmentationShortComplex := ShortComplex.moduleCatMk (unaugmentedAugmentation R M F hF)
    (sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) 1)
    (unaugmentedAugmentation_square R M F hF)
omit [Nonempty ι] in
lemma augmentationShortComplex_exact (h : (sortedComplex R M F hF).ExactAt 1) :
    (augmentationShortComplex R M F hF).Exact := by
  rw [ShortComplex.moduleCat_exact_iff]
  intro f hf
  change sorted R M (zeroAugmentation R M F) 1 at f
  change sortedDelta R M (zeroAugmentation R M F) (zeroAugmentation_mono R M F hF) 1 f=0 at hf
  have he := ((sortedComplex R M F hF).exactAt_iff' (i:=0) (j:=1) (k:=2) (by simp) (by simp)).mp h
  rw [ShortComplex.moduleCat_exact_iff] at he
  obtain ⟨g,hg⟩ := he (unaugmentedInclusion R M F 1 f) (by
    change ((sortedComplex R M F hF).d 1 2).hom _=0
    rw [sortedComplex_d]
    change sortedDelta R M F hF 1 (unaugmentedInclusion R M F 1 f)=0
    rw [←unaugmentedInclusion_delta R M F hF,hf,map_zero])
  change sorted R M F 0 at g
  change ((sortedComplex R M F hF).d 0 1).hom g = _ at hg
  rw [sortedComplex_d] at hg
  refine ⟨g,?_⟩
  apply (unaugmentedEquiv R M F 1 (by omega)).injective
  change (unaugmentedEquiv R M F 1 (by omega))
    ((unaugmentedEquiv R M F 1 (by omega)).symm (sortedDelta R M F hF 0 g))=_
  rw [LinearEquiv.apply_symm_apply]
  exact hg
instance augmentationShortComplex_mono : Mono (augmentationShortComplex R M F hF).f := by
  apply (ModuleCat.mono_iff_injective _).mpr
  exact (unaugmentedEquiv R M F 1 (by omega)).symm.injective.comp (sorted_zero_injective R M F hF)
 

def unaugmented_homology_one (h : (sortedComplex R M F hF).ExactAt 1) :
    (unaugmentedComplex R M F hF).homology 1 ≅ ModuleCat.of R (F ∅) := by
  let U := unaugmentedComplex R M F hF
  let S := U.sc' 0 1 2
  have hf : S.f=0 := (unaugmented_isZero_zero R M F hF).eq_of_src _ _
  let T := augmentationShortComplex R M F hF
  let c : KernelFork S.g := KernelFork.ofι T.f (by
    exact T.zero)
  have hc : IsLimit c := (augmentationShortComplex_exact R M F hF h).fIsKernel
  exact U.homologyIsoSc' 0 1 2 (by simp) (by simp) ≪≫
    (ShortComplex.LeftHomologyData.ofIsLimitKernelFork S hf c hc).homologyIso ≪≫
    (sortedZeroEquiv R M F).toModuleIso
end Lech.AlternatingCech


namespace Lech.AlternatingCech
open CategoryTheory CategoryTheory.Limits HomologicalComplex
open scoped BigOperators Classical
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)
lemma zeroAug_cochains_le (p : ℕ) : cochains R M (zeroAugmentation R M F) p ≤ cochains R M F p := by
  intro f hf a
  have h := hf a
  by_cases hs : FiniteCoverCech.intersection a=∅
  · have hz : evaluation R M p f a=0 := by
      simpa [zeroAugmentation,hs] using h
    rw [hz]
    exact (F _).zero_mem
  · simpa only [zeroAugmentation,ite_eq_right hs] using h
lemma zeroAug_cochains_pos (p : ℕ) (hp : 0<p) :
    cochains R M (zeroAugmentation R M F) p=cochains R M F p := by
  apply le_antisymm (zeroAug_cochains_le R M F p)
  intro f hf a
  have hs : FiniteCoverCech.intersection a≠∅ := by
    intro he
    have hm : a ⟨0,hp⟩∈FiniteCoverCech.intersection a := by simp [FiniteCoverCech.intersection]
    rw [he] at hm
    exact Finset.notMem_empty _ hm
  simpa only [zeroAugmentation,ite_eq_right hs] using hf a
lemma zeroAug_cochains_zero (f : Alt R M (ι:=ι) 0)
    (hf : f∈cochains R M (zeroAugmentation R M F) 0) : f=0 := by
  apply evaluation_injective R M 0
  apply funext;intro a
  have he : FiniteCoverCech.intersection a=∅ := by simp [FiniteCoverCech.intersection]
  have h := hf a
  simpa [zeroAugmentation,he] using h
end Lech.AlternatingCech


namespace Lech.AlternatingCech
open CategoryTheory CategoryTheory.Limits HomologicalComplex
universe u
variable (R : Type u) [CommRing R]
variable (M N : Type u) [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N]
variable {ι κ : Type} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
variable (F : Finset ι → Submodule R M) (G : Finset κ → Submodule R N)
variable (hF : Monotone F) (hG : Monotone G)
variable (t : ∀ p,Alt R M (ι:=ι) p →ₗ[R] Alt R N (ι:=κ) p)
variable (ht : ∀ p f,f∈cochains R M F p → t p f∈cochains R N G p)
variable (hc : ∀ p f,t (p+1) (delta R M p f)=delta R N p (t p f))
 

def complexMap : complex R M F hF ⟶ complex R N G hG :=
  CochainComplex.ofHom (fun p => ModuleCat.ofHom ((t p).restrict (ht p))) (fun p => by
    rw [complex_d,complex_d]
    apply ModuleCat.hom_ext;apply LinearMap.ext;intro f
    exact Subtype.ext (hc p f.val).symm)
lemma complexMap_apply (p : ℕ) (f : cochains R M F p) :
    ((complexMap R M N F G hF hG t ht hc).f p).hom f=⟨t p f.val,ht p f.val f.property⟩ := rfl
end Lech.AlternatingCech


namespace Lech.ProductSourceCover
open AlternatingCech CategoryTheory CategoryTheory.Limits HomologicalComplex
open scoped BigOperators Classical
universe u
variable (R : Type u) [CommRing R] (n : ℕ)
abbrev ordinarySections (m : Fin n → ℤ) := zeroAugmentation R (LaurentModule R n) (sections R n m)
lemma ordinarySections_mono (m : Fin n → ℤ) : Monotone (ordinarySections R n m) :=
  zeroAugmentation_mono R (LaurentModule R n) (sections R n m) (sections_mono R n m)
abbrev ordinaryCochains (m : Fin n → ℤ) (p : ℕ) :=
  cochains R (LaurentModule R n) (ordinarySections R n m) p
lemma ordinaryCochains_pos (m : Fin n → ℤ) (p : ℕ) (hp : 0<p) :
    ordinaryCochains R n m p=divisorCochains R n m p :=
  zeroAug_cochains_pos R (LaurentModule R n) (sections R n m) p hp
lemma ordinaryCochains_zero (m : Fin n → ℤ) (f : ordinaryCochains R n m 0) : f=0 :=
  Subtype.ext (zeroAug_cochains_zero R (LaurentModule R n) (sections R n m) f.val f.property)
lemma ordinary_slice_mem (k : ℤ) (m : Fin n → ℤ) (p : ℕ)
    (f : ordinaryCochains R (n+1) (Fin.cons k m) p) :
    faceSlice R n k p f.val∈ordinaryCochains R n m p := by
  cases p with
  | zero =>
    rw [ordinaryCochains_zero R (n+1) (Fin.cons k m) f]
    change faceSlice R n k 0 0∈ordinaryCochains R n m 0
    rw [map_zero]
    exact (ordinaryCochains R n m 0).zero_mem
  | succ p =>
    rw [ordinaryCochains_pos R n m (p+1) (by omega)]
    apply faceSlice_mem R n k m
    exact zeroAug_cochains_le R (LaurentModule R (n+1)) (sections R (n+1) (Fin.cons k m)) (p+1) f.property
lemma ordinary_lift_mem (k : ℤ) (m : Fin n → ℤ) (p : ℕ)
    (f : ordinaryCochains R n m p) : faceLift R n k p f.val∈ordinaryCochains R (n+1) (Fin.cons k m) p := by
  cases p with
  | zero =>
    rw [ordinaryCochains_zero R n m f]
    change faceLift R n k 0 0∈ordinaryCochains R (n+1) (Fin.cons k m) 0
    rw [map_zero]
    exact (ordinaryCochains R (n+1) (Fin.cons k m) 0).zero_mem
  | succ p =>
    rw [ordinaryCochains_pos R (n+1) (Fin.cons k m) (p+1) (by omega)]
    apply faceLift_mem R n k m (p+1) (by omega)
    exact zeroAug_cochains_le R (LaurentModule R n) (sections R n m) (p+1) f.property
lemma ordinary_neighbor_le (k : ℤ) (m : Fin n → ℤ) (p : ℕ) :
    ordinaryCochains R (n+1) (Fin.cons (k-1) m) p ≤ ordinaryCochains R (n+1) (Fin.cons k m) p := by
  intro f hf
  cases p with
  | zero => rw [zeroAug_cochains_zero R (LaurentModule R (n+1)) _ f hf];exact (ordinaryCochains R (n+1) _ 0).zero_mem
  | succ p =>
    rw [ordinaryCochains_pos R (n+1) (Fin.cons (k-1) m) (p+1) (by omega)] at hf
    rw [ordinaryCochains_pos R (n+1) (Fin.cons k m) (p+1) (by omega)]
    exact (divisorInclusion R n k m (p+1) ⟨f,hf⟩).property
def ordinaryInclusion (k : ℤ) (m : Fin n → ℤ) (p : ℕ) :
    ordinaryCochains R (n+1) (Fin.cons (k-1) m) p →ₗ[R] ordinaryCochains R (n+1) (Fin.cons k m) p :=
  Submodule.inclusion (ordinary_neighbor_le R n k m p)
def ordinaryRestriction (k : ℤ) (m : Fin n → ℤ) (p : ℕ) :
    ordinaryCochains R (n+1) (Fin.cons k m) p →ₗ[R] ordinaryCochains R n m p :=
  (faceSlice R n k p).restrict (fun f hf => ordinary_slice_mem R n k m p ⟨f,hf⟩)
def ordinarySection (k : ℤ) (m : Fin n → ℤ) (p : ℕ) :
    ordinaryCochains R n m p →ₗ[R] ordinaryCochains R (n+1) (Fin.cons k m) p :=
  (faceLift R n k p).restrict (fun f hf => ordinary_lift_mem R n k m p ⟨f,hf⟩)
def ordinaryComplex (m : Fin n → ℤ) :=
  complex R (LaurentModule R n) (ordinarySections R n m) (ordinarySections_mono R n m)
end Lech.ProductSourceCover


namespace Lech.ProductSourceCover
open AddMonoidAlgebra
open scoped BigOperators
universe u
variable (R : Type u) [CommRing R] (n : ℕ)
abbrev Ambient := ProductLaurent.Ring R n
 

def ringSections (m : Fin n → ℤ) (s : Finset (Chart n)) : Submodule R (Ambient R n) :=
  (sections R n m s).comap (coeffLinearEquiv R).toLinearMap
lemma ringSections_mem (m : Fin n → ℤ) (s : Finset (Chart n)) (x : Ambient R n) :
    x∈ringSections R n m s ↔ ∀ e∈x.coeff.support,allowed n m s e := by
  exact Finsupp.mem_supported R x.coeff
lemma single_mem (m : Fin n → ℤ) (s : Finset (Chart n)) (e : Exponent n) (r : R)
    (he : allowed n m s e) : single e r∈ringSections R n m s := by
  rw [ringSections_mem]
  intro f hf
  have hfe : f=e := Finset.mem_singleton.mp (Finsupp.support_single_subset hf)
  exact hfe ▸ he
lemma allowed_add (m k : Fin n → ℤ) (s : Finset (Chart n)) (e f : Exponent n)
    (he : allowed n m s e) (hf : allowed n k s f) : allowed n (m+k) s (e+f) := by
  intro i
  exact ⟨fun h => add_nonneg ((he i).1 h) ((hf i).1 h),fun h => add_le_add ((he i).2 h) ((hf i).2 h)⟩
lemma mul_mem (m k : Fin n → ℤ) (s : Finset (Chart n)) (x y : Ambient R n)
    (hx : x∈ringSections R n m s) (hy : y∈ringSections R n k s) :
    x*y∈ringSections R n (m+k) s := by
  rw [mul_def]
  apply (ringSections R n (m+k) s).sum_mem
  intro e he
  apply (ringSections R n (m+k) s).sum_mem
  intro f hf
  exact single_mem R n (m+k) s (e+f) _
    (allowed_add n m k s e f ((ringSections_mem R n m s x).mp hx e he)
      ((ringSections_mem R n k s y).mp hy f hf))
lemma one_mem (s : Finset (Chart n)) : (1:Ambient R n)∈ringSections R n 0 s := by
  rw [one_def]
  apply single_mem
  intro i
  exact ⟨fun _ => le_refl _,fun _ => le_refl _⟩
lemma pow_mem (m : Fin n → ℤ) (s : Finset (Chart n)) (x : Ambient R n)
    (hx : x∈ringSections R n m s) (N : ℕ) : x^N∈ringSections R n (N • m) s := by
  induction N with
  | zero => simpa only [pow_zero,zero_smul] using one_mem R n s
  | succ N ih =>
    simpa only [pow_succ,succ_nsmul] using mul_mem R n (N • m) m s (x^N) x ih hx
lemma ringSections_mono (m : Fin n → ℤ) : Monotone (ringSections R n m) := by
  intro s t hst
  exact Submodule.comap_mono (sections_mono R n m hst)
lemma twist_mono (m k : Fin n → ℤ) (hmk : m≤k) (s : Finset (Chart n)) :
    ringSections R n m s≤ringSections R n k s := by
  intro x hx
  rw [ringSections_mem] at hx ⊢
  intro e he i
  exact ⟨(hx e he i).1,fun h => ((hx e he i).2 h).trans (hmk i)⟩

 
def twistExponent (m : Fin n → ℤ) (σ : Chart n) : Exponent n :=
  Finsupp.equivFunOnFinite.symm (fun i => if σ i then m i else 0)
lemma twistExponent_apply (m : Fin n → ℤ) (σ : Chart n) (i : Fin n) :
    twistExponent n m σ i=(if σ i then m i else 0) := rfl
def affineExponent (m : Fin n → ℤ) (σ : Chart n) (e : Fin n →₀ ℕ) : Exponent n :=
  twistExponent n m σ+ProductLaurent.signedExponent n σ e
lemma affineExponent_allowed (m : Fin n → ℤ) (σ : Chart n) (e : Fin n →₀ ℕ) :
    allowed n m {σ} (affineExponent n m σ e) := by
  intro i
  simp only [affineExponent,Finsupp.add_apply,twistExponent_apply,ProductLaurent.signedExponent_apply]
  cases hs : σ i <;> simp [hs]
def affineCoordinates (m : Fin n → ℤ) (σ : Chart n) (e : Exponent n) : Fin n →₀ ℕ :=
  Finsupp.equivFunOnFinite.symm (fun i => if σ i then (m i-e i).toNat else (e i).toNat)
lemma affineExponent_coordinates (m : Fin n → ℤ) (σ : Chart n) (e : Exponent n)
    (he : allowed n m {σ} e) : affineExponent n m σ (affineCoordinates n m σ e)=e := by
  ext i
  have hi := he i
  simp only [Finset.mem_singleton,forall_eq] at hi
  simp only [affineExponent,Finsupp.add_apply,twistExponent_apply,ProductLaurent.signedExponent_apply]
  change (if σ i then m i else 0)+(if σ i then -(↑(if σ i then (m i-e i).toNat else (e i).toNat):ℤ)
    else (↑(if σ i then (m i-e i).toNat else (e i).toNat):ℤ))=e i
  cases hs : σ i <;> simp only [hs,Bool.false_eq_true,↓reduceIte] at hi ⊢
  · rw [Int.toNat_of_nonneg (hi.1 trivial),zero_add]
  · rw [Int.toNat_of_nonneg (sub_nonneg.mpr (hi.2 trivial))];omega
 

def chartLine (m : Fin n → ℤ) (σ : Chart n) : ProductLinearChart.Ring R n →ₗ[R] Ambient R n :=
  (LinearMap.mulLeft R (ProductLaurent.monomialUnit R n (twistExponent n m σ):Ambient R n)).comp
    (ProductLaurent.chartMap R n σ).toLinearMap
lemma chartLine_monomial (m : Fin n → ℤ) (σ : Chart n) (e : Fin n →₀ ℕ) (r : R) :
    chartLine R n m σ (MvPolynomial.monomial e r)=single (affineExponent n m σ e) r := by
  change single (twistExponent n m σ) 1 * ProductLaurent.chartMap R n σ (MvPolynomial.monomial e r)=_
  rw [ProductLaurent.chartMap_monomial,single_mul_single,one_mul]
  rfl
lemma chartLine_mem (m : Fin n → ℤ) (σ : Chart n) (p : ProductLinearChart.Ring R n) :
    chartLine R n m σ p∈ringSections R n m {σ} := by
  rw [MvPolynomial.as_sum p,map_sum]
  apply (ringSections R n m {σ}).sum_mem
  intro e _
  rw [chartLine_monomial]
  exact single_mem R n m {σ} _ _ (affineExponent_allowed n m σ e)
 

theorem chartLine_range (m : Fin n → ℤ) (σ : Chart n) :
    (chartLine R n m σ).range=ringSections R n m {σ} := by
  apply le_antisymm
  · rintro _ ⟨p,rfl⟩;exact chartLine_mem R n m σ p
  · intro x hx
    refine ⟨∑ e∈x.coeff.support,MvPolynomial.monomial (affineCoordinates n m σ e) (x.coeff e),?_⟩
    rw [map_sum]
    calc
      _ = ∑ e∈x.coeff.support,single e (x.coeff e) := by
        apply Finset.sum_congr rfl
        intro e he
        rw [chartLine_monomial,affineExponent_coordinates n m σ e ((ringSections_mem R n m {σ} x).mp hx e he)]
      _ = x := AddMonoidAlgebra.sum_coeff_single x
end Lech.ProductSourceCover


namespace Lech.ProductSourceCover
open AddMonoidAlgebra CategoryTheory CategoryTheory.Limits HomologicalComplex
open scoped BigOperators
universe u
variable (R : Type u) [CommRing R] (n : ℕ)
def ringProjector (m : Fin n → ℤ) (σ : Chart n) : Ambient R n →ₗ[R] Ambient R n :=
  (coeffLinearEquiv R).symm.toLinearMap.comp
    ((projector R n m σ).comp (coeffLinearEquiv R).toLinearMap)
lemma ringProjector_coeff (m : Fin n → ℤ) (σ : Chart n) (x : Ambient R n) :
    (ringProjector R n m σ x).coeff=projector R n m σ x.coeff := by
  change (coeffLinearEquiv R) ((coeffLinearEquiv R).symm _)=_
  exact (coeffLinearEquiv R).apply_symm_apply _
lemma ringProjector_sum (m : Fin n → ℤ) (x : Ambient R n) : ∑ σ,ringProjector R n m σ x=x := by
  apply (coeffLinearEquiv R).injective
  change (coeffLinearEquiv R) (∑ σ,ringProjector R n m σ x)=x.coeff
  rw [map_sum]
  simpa only [coeffLinearEquiv_apply,ringProjector_coeff] using projector_sum R n m x.coeff
lemma ringProjector_mem (m : Fin n → ℤ) (hm : ∀ i,-1≤ m i) (s : Finset (Chart n))
    (σ : Chart n) (x : Ambient R n) (hx : x∈ringSections R n m (insert σ s)) :
    ringProjector R n m σ x∈ringSections R n m s := by
  change (ringProjector R n m σ x).coeff∈sections R n m s
  rw [ringProjector_coeff]
  exact projector_mem R n m hm s σ x.coeff hx
 

theorem ring_augmented_acyclic (m : Fin n → ℤ) (hm : ∀ i,-1≤ m i) :
    (AlternatingCech.complex R (Ambient R n) (ringSections R n m) (ringSections_mono R n m)).Acyclic :=
  AlternatingCech.projection_complex_acyclic R (Ambient R n) (ringSections R n m)
    (ringSections_mono R n m) (ringProjector R n m) (ringProjector_sum R n m)
      (ringProjector_mem R n m hm)
theorem ring_sorted_acyclic [LinearOrder (Chart n)] (m : Fin n → ℤ) (hm : ∀ i,-1≤ m i) :
    (AlternatingCech.sortedComplex R (Ambient R n) (ringSections R n m) (ringSections_mono R n m)).Acyclic := by
  intro j
  apply (ring_augmented_acyclic R n m hm j).of_iso
  convert AlternatingCech.cochainsSortedIso R (Ambient R n) (ringSections R n m) (ringSections_mono R n m) using 1
  congr 1
end Lech.ProductSourceCover
end
end

end OAI