import Mathlib
import OAI.AlgebraicGeometry.RelativeTriviality.Cech

namespace OAI

namespace CampanaPeternellSix.ActualCech
noncomputable section
open AlgebraicGeometry CategoryTheory Limits Opposite
open RelativeLineCharts
open scoped Polynomial LaurentPolynomial
universe u

lemma laurent_parts (R : Type u) [CommRing R] (f : R[T;T⁻¹]) :
    ∃ p q : R[X], f = p.toLaurent + LaurentPolynomial.invert q.toLaurent := by
  induction f using LaurentPolynomial.induction_on' with
  | add f g hf hg =>
      obtain ⟨p,q,h⟩ := hf
      obtain ⟨p',q',h'⟩ := hg
      exact ⟨p+p',q+q', by simp only [map_add,h,h']; abel⟩
  | C_mul_T n a =>
      cases n with
      | ofNat n =>
          exact ⟨Polynomial.C a * Polynomial.X^n,0, by simp⟩
      | negSucc n =>
          exact ⟨0,Polynomial.C a * Polynomial.X^(n+1), by
            simp only [map_zero, zero_add, map_mul, Polynomial.toLaurent_C,
              map_mul, map_pow, Polynomial.toLaurent_X, LaurentPolynomial.invert_C,
              LaurentPolynomial.invert_T, LaurentPolynomial.T_pow]
            congr 2
            omega⟩

variable (X : Scheme.{u}) (I : Type u) [Finite I]
def freeProductIso : (SheafOfModules.free I : X.Modules) ≅
    ∏ᶜ (fun _ : I => SheafOfModules.unit X.ringCatSheaf) := by
  classical
  letI := Fintype.ofFinite I
  let f : I → X.Modules := fun _ => SheafOfModules.unit X.ringCatSheaf
  letI : HasBiproduct f := HasBiproduct.of_hasProduct f
  exact (biproduct.isoCoproduct f).symm ≪≫ biproduct.isoProduct f

def freeProjection (i : I) : (SheafOfModules.free I : X.Modules) ⟶
    SheafOfModules.unit X.ringCatSheaf := (freeProductIso X I).hom ≫ Pi.π _ i

local instance freeSectionsModule (U : X.Opens) :
    Module Γ(X,U) Γ((SheafOfModules.free I : X.Modules), U) :=
  ((SheafOfModules.free I : X.Modules).val.obj (op U)).isModule

def freeSectionEquiv (U : X.Opens) :
    Γ((SheafOfModules.free I : X.Modules), U) ≃ₗ[Γ(X,U)] (I → Γ(X,U)) := by
  classical
  letI := Fintype.ofFinite I
  let F := SheafOfModules.evaluation X.ringCatSheaf (op U)
  let f : I → X.Modules := fun _ => SheafOfModules.unit X.ringCatSheaf
  exact (F.mapIso (freeProductIso X I) ≪≫ asIso (piComparison F f) ≪≫
    ModuleCat.piIsoPi (F.obj ∘ f)).toLinearEquiv

lemma freeSectionEquiv_apply (U : X.Opens)
    (m : Γ((SheafOfModules.free I : X.Modules), U)) (i : I) :
    freeSectionEquiv X I U m i = (freeProjection X I i).val.app (op U) m := by
  classical
  let := Fintype.ofFinite I
  let F := SheafOfModules.evaluation X.ringCatSheaf (op U)
  let f : I → X.Modules := fun _ => SheafOfModules.unit X.ringCatSheaf
  have h : (F.map (freeProductIso X I).hom ≫ piComparison F f ≫
      (ModuleCat.piIsoPi (F.obj ∘ f)).hom) ≫ ModuleCat.ofHom (LinearMap.proj i) =
      F.map ((freeProductIso X I).hom ≫ Pi.π f i) := by
    simp only [Category.assoc, ModuleCat.piIsoPi_hom_ker_subtype]
    erw [piComparison_comp_π, ← CategoryTheory.Functor.map_comp]
    rfl
  exact ConcreteCategory.congr_hom h m

lemma freeSectionEquiv_restrict {U V : X.Opens} (h : U ≤ V)
    (m : Γ((SheafOfModules.free I : X.Modules), V)) (i : I) :
    freeSectionEquiv X I U ((SheafOfModules.free I : X.Modules).val.map
      (homOfLE h).op m) i =
    X.presheaf.map (homOfLE h).op (freeSectionEquiv X I V m i) := by
  erw [freeSectionEquiv_apply, freeSectionEquiv_apply]
  exact ConcreteCategory.congr_hom ((freeProjection X I i).val.naturality (homOfLE h).op) m

variable (R : Type u) [CommRing R]

lemma free_ranges_top :
    leftImage R (SheafOfModules.free I) ⊔ rightImage R (SheafOfModules.free I) = ⊤ := by
  classical
  let E : (scheme R).Modules := SheafOfModules.free I
  apply top_unique
  intro m hm
  change Γ(E,leftOpen R ⊓ rightOpen R) at m
  let c : I → R[T;T⁻¹] := fun i => overlapSectionEquiv R
    (freeSectionEquiv (scheme R) I (leftOpen R ⊓ rightOpen R) m i)
  choose p q hpq using fun i => laurent_parts R (c i)
  let a : Γ(E,leftOpen R) := (freeSectionEquiv (scheme R) I (leftOpen R)).symm
    (fun i => (leftSectionEquiv R).symm (p i))
  let b : Γ(E,rightOpen R) := (freeSectionEquiv (scheme R) I (rightOpen R)).symm
    (fun i => (rightSectionEquiv R).symm (q i))
  let ra : Γ(E,leftOpen R ⊓ rightOpen R) := E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ leftOpen R from inf_le_left)).op a
  let rb : Γ(E,leftOpen R ⊓ rightOpen R) := E.val.map (homOfLE (show leftOpen R ⊓ rightOpen R ≤ rightOpen R from inf_le_right)).op b
  have hsum : ra + rb = m := by
    apply (freeSectionEquiv (scheme R) I (leftOpen R ⊓ rightOpen R)).injective
    ext i
    rw [map_add, Pi.add_apply]
    dsimp only [ra, rb]
    rw [freeSectionEquiv_restrict, freeSectionEquiv_restrict]
    change _ = freeSectionEquiv (scheme R) I (leftOpen R ⊓ rightOpen R) m i
    apply (overlapSectionEquiv R).injective
    rw [map_add, (standard_section_restrictions R).1, (standard_section_restrictions R).2]
    simp only [a,b,LinearEquiv.apply_symm_apply, RingEquiv.apply_symm_apply]
    exact (hpq i).symm
  have ha : ra ∈ leftImage R E := ⟨a,rfl⟩
  have hb : rb ∈ rightImage R E := ⟨b,rfl⟩
  exact hsum ▸ Submodule.add_mem_sup ha hb

theorem subsingleton_free_quotient :
    Subsingleton (quotient R (SheafOfModules.free I)) :=
  Submodule.Quotient.subsingleton_iff.mpr (free_ranges_top I R)

end
end CampanaPeternellSix.ActualCech

end OAI