import Mathlib

namespace OAI

noncomputable section

namespace CampanaPeternellSix.RelativeCech
section
open CategoryTheory AlgebraicGeometry Limits Opposite TopologicalSpace
universe u v w
variable {C : Type v} [Category.{w} C] {J : GrothendieckTopology C}
variable (𝒪 : Sheaf J RingCat.{u})
variable [HasSheafify J AddCommGrpCat.{u}] [J.WEqualsLocallyBijective AddCommGrpCat.{u}]

private lemma finiteRingPi (A : RingCat.{u}) (I : Type u) [Finite I] :
    Module.Finite A (I → A) := inferInstance

lemma finite_free_evaluation (I : Type u) [Finite I] (U : Cᵒᵖ) :
    Module.Finite (𝒪.obj.obj U) ((SheafOfModules.evaluation 𝒪 U).obj
      (SheafOfModules.free I)) := by
  classical
  let := Fintype.ofFinite I
  let F := SheafOfModules.evaluation 𝒪 U
  let f : I → SheafOfModules 𝒪 := fun _ ↦ SheafOfModules.unit 𝒪
  let : HasBiproduct f := HasBiproduct.of_hasProduct f
  let i₁ : SheafOfModules.free I ≅ ∏ᶜ f :=
    (biproduct.isoCoproduct f).symm ≪≫ biproduct.isoProduct f
  let i₂ := F.mapIso i₁ ≪≫ asIso (piComparison F f) ≪≫ ModuleCat.piIsoPi (F.obj ∘ f)
  have : Module.Finite (𝒪.obj.obj U) (ModuleCat.of (𝒪.obj.obj U) ((i : I) → (F.obj (f i)))) := by
    change Module.Finite (𝒪.obj.obj U) (I → (𝒪.obj.obj U))
    exact finiteRingPi (𝒪.obj.obj U) I
  exact @Module.Finite.equiv _ _ _ _ _ _ _ _ this i₂.symm.toLinearEquiv

lemma finite_sections_of_le_frame (X : Scheme.{u}) (E : X.Modules)
    (q : E.LocalGeneratorsData) [q.IsLocallyFreeData] [q.IsFiniteType]
    (i : q.I) (V : X.Opens) (hV : V ≤ q.X i) : Module.Finite Γ(X,V) Γ(E,V) := by
  have := SheafOfModules.LocalGeneratorsData.IsFiniteType.isFiniteType (p := q) i
  have := SheafOfModules.LocalGeneratorsData.IsLocallyFreeData.isIso (q := q) i
  let a : Over (q.X i) := Over.mk (homOfLE hV)
  let F := SheafOfModules.evaluation (X.ringCatSheaf.over (q.X i)) (op a)
  have := finite_free_evaluation (X.ringCatSheaf.over (q.X i)) (q.generators i).I (op a)
  change Module.Finite ((X.ringCatSheaf.over (q.X i)).obj.obj (op a))
    (F.obj (E.over (q.X i)))
  exact Module.Finite.equiv
    (R := ↑((X.ringCatSheaf.over (q.X i)).obj.obj (op a)))
    (F.mapIso (asIso (q.generators i).π)).toLinearEquiv

theorem finite_affine_sections (R : CommRingCat.{u}) (E : (Spec R).Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType) :
    Module.Finite R (moduleSpecΓFunctor.obj E) := by
  classical
  obtain ⟨q, hq, ht⟩ := hE
  let := hq
  let := ht
  let := q.isLocallyFree
  have : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent
  let T : Set R := {r | ∃ i, PrimeSpectrum.basicOpen r ≤ q.X i}
  have hT : Ideal.span T = ⊤ := by
    have he : Set.range (fun r : T ↦ (r : R)) = T := by ext r; simp
    rw [← he, ← PrimeSpectrum.iSup_basicOpen_eq_top_iff]
    apply top_unique
    intro x hx
    have hcov := (Opens.coversTop_iff _ _).mp q.coversTop
    obtain ⟨i, hi⟩ := Opens.mem_iSup.mp (show x ∈ ⨆ i, q.X i from by rw [hcov]; trivial)
    obtain ⟨V, ⟨r, rfl⟩, hxV, hV⟩ :=
      PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hi (q.X i).isOpen
    exact Opens.mem_iSup.mpr ⟨⟨r, i, hV⟩, hxV⟩
  let M := (modulesSpecToSheaf.obj E)
  let D (r : R) : (Spec R).Opens := PrimeSpectrum.basicOpen r
  have : IsIso E.fromTildeΓ := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent E
  let f (r : T) : moduleSpecΓFunctor.obj E →ₗ[R] Γ(E, D r.val) :=
    (M.obj.map (show (Spec R).Opens from PrimeSpectrum.basicOpen r.val).leTop.op).hom
  have (r : T) : IsLocalizedModule.Away r.val (f r) :=
    (isIso_fromTildeΓ_iff_isLocalizing E).mp inferInstance r.val
  exact Module.Finite.of_localizationSpan' T hT
    (Rₚ := fun r ↦ Γ(Spec R, D r.val)) f (fun r ↦ by
      obtain ⟨i, hi⟩ := r.property
      exact finite_sections_of_le_frame (Spec R) E q i _ hi)

lemma finite_restriction_sections (X Y : Scheme.{u}) (E : Y.Modules)
    (f : X ⟶ Y) [IsOpenImmersion f] (U : X.Opens)
    [Module.Finite Γ(Y, f ''ᵁ U) Γ(E, f ''ᵁ U)] :
    Module.Finite Γ(X,U) Γ(E.restrict f,U) := by
  let g : Γ(E, f ''ᵁ U) →ₛₗ[(f.appIso U).hom.hom] Γ(E.restrict f,U) := {
    toFun := (E.restrictAppIso f U).inv
    map_add' := map_add _
    map_smul' := fun r m ↦ by
      exact Scheme.Modules.smul_restrictAppIso_inv_apply f E U r m
  }
  exact Module.Finite.of_surjective g (ConcreteCategory.bijective_of_isIso
    (E.restrictAppIso f U).inv).surjective

theorem finite_affine_restriction (R : CommRingCat.{u}) (X : Scheme.{u})
    (E : X.Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (f : Spec R ⟶ X) [IsOpenImmersion f] :
    Module.Finite R (moduleSpecΓFunctor.obj (E.restrict f)) := by
  classical
  obtain ⟨q, hq, ht⟩ := hE
  let := hq
  let := ht
  let := q.isLocallyFree
  have : E.IsQuasicoherent := q.quasiCoherentData.isQuasicoherent
  let T : Set R := {r | ∃ i, f ''ᵁ (PrimeSpectrum.basicOpen r) ≤ q.X i}
  have hT : Ideal.span T = ⊤ := by
    have he : Set.range (fun r : T ↦ (r : R)) = T := by ext r; simp
    rw [← he, ← PrimeSpectrum.iSup_basicOpen_eq_top_iff]
    apply top_unique
    intro x hx
    have hcov := (Opens.coversTop_iff _ _).mp q.coversTop
    obtain ⟨i, hi⟩ := Opens.mem_iSup.mp (show f x ∈ ⨆ i, q.X i from by rw [hcov]; trivial)
    obtain ⟨V, ⟨r, rfl⟩, hxV, hV⟩ :=
      PrimeSpectrum.isTopologicalBasis_basic_opens.exists_subset_of_mem_open hi
        (f ⁻¹ᵁ (q.X i)).isOpen
    refine Opens.mem_iSup.mpr ⟨⟨r, i, ?_⟩, hxV⟩
    rintro y ⟨z, hz, rfl⟩
    exact hV hz
  let E' := E.restrict f
  let M := modulesSpecToSheaf.obj E'
  let D (r : R) : (Spec R).Opens := PrimeSpectrum.basicOpen r
  have : E'.IsQuasicoherent := Scheme.Modules.isQuasicoherent_restrictFunctor f E
  have : IsIso E'.fromTildeΓ := Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent E'
  let res (r : T) : moduleSpecΓFunctor.obj E' →ₗ[R] Γ(E', D r.val) :=
    (M.obj.map (show (Spec R).Opens from PrimeSpectrum.basicOpen r.val).leTop.op).hom
  have (r : T) : IsLocalizedModule.Away r.val (res r) :=
    (isIso_fromTildeΓ_iff_isLocalizing E').mp inferInstance r.val
  exact Module.Finite.of_localizationSpan' T hT
    (Rₚ := fun r ↦ Γ(Spec R, D r.val)) res (fun r ↦ by
      obtain ⟨i, hi⟩ := r.property
      have := finite_sections_of_le_frame X E q i _ hi
      exact finite_restriction_sections (Spec R) X E f _)

lemma finite_affine_image (R : CommRingCat.{u}) (X : Scheme.{u})
    (E : X.Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (f : Spec R ⟶ X) [IsOpenImmersion f] :
    Module.Finite Γ(X,f ''ᵁ ⊤) Γ(E, f ''ᵁ ⊤) := by
  have := finite_affine_restriction R X E hE f
  let σ : R →+* Γ(X, f ''ᵁ ⊤) :=
    (f.appIso ⊤).inv.hom.comp (Scheme.ΓSpecIso R).inv.hom
  let m : moduleSpecΓFunctor.obj (E.restrict f) →ₛₗ[σ] Γ(E,f ''ᵁ ⊤) := {
    toFun := (E.restrictAppIso f ⊤).hom
    map_add' := map_add _
    map_smul' := fun r m ↦ by
      exact Scheme.Modules.smul_restrictAppIso_hom_apply f E ⊤
        ((Scheme.ΓSpecIso R).inv r) m
  }
  exact Module.Finite.of_surjective m (ConcreteCategory.bijective_of_isIso
    (E.restrictAppIso f ⊤).hom).surjective

lemma finite_affine_open (X : Scheme.{u}) (E : X.Modules)
    (hE : ∃ q : E.LocalGeneratorsData, q.IsLocallyFreeData ∧ q.IsFiniteType)
    (U : X.Opens) (hU : IsAffineOpen U) : Module.Finite Γ(X,U) Γ(E,U) := by
  have h := finite_affine_image Γ(X,U) X E hE hU.fromSpec
  rw [hU.fromSpec.image_top_eq_opensRange, hU.opensRange_fromSpec] at h
  exact h

end

open CategoryTheory AlgebraicGeometry Opposite TopologicalSpace
universe u
lemma affine_image_restriction_spans (R : CommRingCat.{u}) (X : Scheme.{u})
    (E : X.Modules) [E.IsQuasicoherent] (f : Spec R ⟶ X)
    [IsOpenImmersion f] (r : R)
    (hle : f ''ᵁ (PrimeSpectrum.basicOpen r) ≤ f ''ᵁ ⊤) :
    Submodule.span Γ(X, f ''ᵁ (PrimeSpectrum.basicOpen r))
      (Set.range (E.presheaf.map (homOfLE hle).op)) = ⊤ := by
  let E' := E.restrict f
  let M := modulesSpecToSheaf.obj E'
  let D : (Spec R).Opens := PrimeSpectrum.basicOpen r
  let res : moduleSpecΓFunctor.obj E' →ₗ[R] Γ(E',D) :=
    (M.obj.map D.leTop.op).hom
  have : IsLocalizedModule.Away r res :=
    (isIso_fromTildeΓ_iff_isLocalizing E').mp inferInstance r
  have hspan : Submodule.span Γ(Spec R,D) (Set.range res) = ⊤ := by
    simpa only [Set.image_univ] using
      (span_eq_top_of_isLocalizedModule Γ(Spec R,D) (.powers r) res
        (v := Set.univ) (by simp))
  let V := f ''ᵁ D
  let B : Submodule Γ(X,V) Γ(E,V) := Submodule.span Γ(X,V)
    (Set.range (E.presheaf.map (homOfLE (f.image_mono D.leTop.le)).op))
  have hB : ∀ x : Γ(E',D), (E.restrictAppIso f D).hom x ∈ B := by
    intro x
    have hx : x ∈ Submodule.span Γ(Spec R,D) (Set.range res) := by rw [hspan]; trivial
    induction hx using Submodule.span_induction with
    | mem x hx =>
        obtain ⟨y, rfl⟩ := hx
        apply Submodule.subset_span
        refine ⟨(E.restrictAppIso f ⊤).hom y, ?_⟩
        exact (Scheme.Modules.map_restrictAppIso_hom_apply f E D.leTop.op y).symm
    | zero => simp
    | add x y hx hy ihx ihy => simpa using B.add_mem ihx ihy
    | smul a x hx ih =>
        rw [Scheme.Modules.smul_restrictAppIso_hom_apply]
        exact B.smul_mem _ ih
  apply top_unique
  intro x hx
  obtain ⟨y, rfl⟩ := (ConcreteCategory.bijective_of_isIso
    (E.restrictAppIso f D).hom).surjective x
  exact hB y

theorem affine_restriction_spans (X : Scheme.{u}) (E : X.Modules)
    [E.IsQuasicoherent] (U : X.Opens) (hU : IsAffineOpen U) (s : Γ(X,U)) :
    Submodule.span Γ(X,X.basicOpen s)
      (Set.range (E.presheaf.map (homOfLE (X.basicOpen_le s)).op)) = ⊤ := by
  have h := affine_image_restriction_spans Γ(X,U) X E hU.fromSpec s
  rw [hU.fromSpec_image_basicOpen, hU.fromSpec.image_top_eq_opensRange,
    hU.opensRange_fromSpec] at h
  exact h _
end CampanaPeternellSix.RelativeCech

end

end OAI