import Mathlib

namespace OAI

namespace PiExponent.CurveCycle
noncomputable section
open AlgebraicGeometry CategoryTheory TopologicalSpace Topology

theorem generic_iff_no_proper_generalization {T : Type*} [TopologicalSpace T] [QuasiSober T]
    (x : T) : x ∈ genericPoints T ↔ ∀ y : T, y ⤳ x → x ⤳ y := by
  constructor
  · intro hx y hy
    apply specializes_iff_closure_subset.mpr
    exact hx.2 isIrreducible_singleton.closure hy.closure_subset
  · intro hx
    let C : irreducibleComponents T :=
      ⟨irreducibleComponent x, irreducibleComponent_mem_irreducibleComponents x⟩
    let y := (genericPoints.ofComponent C).val
    have hy : y ⤳ x := (genericPoints.isGenericPoint_ofComponent C).specializes
      mem_irreducibleComponent
    have he : closure ({x} : Set T) = C.val := by
      apply Set.Subset.antisymm
      · exact closure_minimal (Set.singleton_subset_iff.mpr mem_irreducibleComponent)
          (isClosed_of_mem_irreducibleComponents C.val C.property)
      · rw [← (genericPoints.isGenericPoint_ofComponent C).def]
        exact (hx y hy).closure_subset
    change closure ({x} : Set T) ∈ irreducibleComponents T
    rw [he]
    exact C.property

theorem generic_embedding_iff {T S : Type*} [TopologicalSpace T] [QuasiSober T]
    [TopologicalSpace S] [QuasiSober S] {f : S → T} (hf : IsEmbedding f)
    (hstable : ∀ y : S, ∀ x : T, x ⤳ f y → x ∈ Set.range f) (y : S) :
    y ∈ genericPoints S ↔ f y ∈ genericPoints T := by
  rw [generic_iff_no_proper_generalization, generic_iff_no_proper_generalization]
  constructor
  · intro hy x hx
    obtain ⟨z,rfl⟩ := hstable y x hx
    exact (hy z (hf.isInducing.specializes_iff.mp hx)).map hf.continuous
  · intro hy z hz
    exact hf.isInducing.specializes_iff.mp (hy (f z) (hz.map hf.continuous))

def genericPointsEmbeddingEquiv {T S : Type*} [TopologicalSpace T] [QuasiSober T]
    [TopologicalSpace S] [QuasiSober S] {f : S → T} (hf : IsEmbedding f)
    (hstable : ∀ y : S, ∀ x : T, x ⤳ f y → x ∈ Set.range f) :
    genericPoints S ≃ {x : genericPoints T // x.val ∈ Set.range f} := by
  let g : genericPoints S → {x : genericPoints T // x.val ∈ Set.range f} := fun y =>
    ⟨⟨f y.val, (generic_embedding_iff hf hstable y.val).mp y.property⟩, ⟨y.val,rfl⟩⟩
  apply Equiv.ofBijective g
  constructor
  · intro x y h
    exact Subtype.ext (hf.injective (congrArg (fun z => z.val.val) h))
  · intro x
    obtain ⟨y,hy⟩ := x.property
    have hgen : y ∈ genericPoints S :=
      (generic_embedding_iff hf hstable y).mpr (hy ▸ x.val.property)
    exact ⟨⟨y,hgen⟩, Subtype.ext (Subtype.ext hy)⟩

def minimalPrimesGenericEquiv (A : CommRingCat) :
    minimalPrimes A ≃ genericPoints (Spec A) where
  toFun P := ⟨⟨P.val,P.property.1.1⟩, by
    change closure ({⟨P.val,P.property.1.1⟩} : Set (PrimeSpectrum A)) ∈
      irreducibleComponents (PrimeSpectrum A)
    rw [← PrimeSpectrum.vanishingIdeal_mem_minimalPrimes,
      PrimeSpectrum.vanishingIdeal_singleton]
    exact P.property⟩
  invFun y := ⟨y.val.asIdeal, by
    rw [← PrimeSpectrum.vanishingIdeal_singleton y.val]
    exact PrimeSpectrum.vanishingIdeal_mem_minimalPrimes.mpr y.property⟩
  left_inv P := rfl
  right_inv y := by rfl

theorem fromSpecStalk_generizing (X : Scheme.{0}) (x : X)
    (y : Spec (X.presheaf.stalk x)) (z : X) (hz : z ⤳ X.fromSpecStalk x y) :
    z ∈ Set.range (X.fromSpecStalk x) := by
  rw [Scheme.range_fromSpecStalk]
  have hy : X.fromSpecStalk x y ⤳ x := by
    have hmem : X.fromSpecStalk x y ∈ Set.range (X.fromSpecStalk x) := ⟨y,rfl⟩
    rw [Scheme.range_fromSpecStalk] at hmem
    exact hmem
  exact hz.trans hy

def genericPointsThroughEquiv (X : Scheme.{0}) (x : X) :
    {y : genericPoints X // y.val ∈ Set.range (X.fromSpecStalk x)} ≃
      {C : irreducibleComponents X // x ∈ C.val} where
  toFun y := ⟨genericPoints.component y.val, by
    have hmem : y.val.val ⤳ x :=
      (congrArg (fun S : Set X => y.val.val ∈ S)
        (Scheme.range_fromSpecStalk (X := X) (x := x))).mp y.property
    exact hmem.mem_closure⟩
  invFun C := ⟨genericPoints.ofComponent C.val, by
    rw [Scheme.range_fromSpecStalk]
    exact (genericPoints.isGenericPoint_ofComponent C.val).specializes C.property⟩
  left_inv y := by
    apply Subtype.ext
    exact genericPoints.ofComponent_component y.val
  right_inv C := by
    apply Subtype.ext
    exact genericPoints.component_ofComponent C.val

def stalkMinimalPrimesEquivComponentsThrough (X : Scheme.{0}) (x : X) :
    minimalPrimes (X.presheaf.stalk x) ≃
      {C : irreducibleComponents X // x ∈ C.val} :=
  (minimalPrimesGenericEquiv (X.presheaf.stalk x)).trans
    ((genericPointsEmbeddingEquiv (X.fromSpecStalk x).isEmbedding
      (fromSpecStalk_generizing X x)).trans (genericPointsThroughEquiv X x))

theorem stalkMinimalPrimesEquivComponentsThrough_point (X : Scheme.{0}) (x : X)
    (P : minimalPrimes (X.presheaf.stalk x)) :
    X.fromSpecStalk x (⟨P.val,P.property.1.1⟩ : Spec (X.presheaf.stalk x)) =
      (genericPoints.ofComponent
        (stalkMinimalPrimesEquivComponentsThrough X x P).val).val := by
  symm
  exact congrArg Subtype.val (genericPoints.ofComponent_component
    ((genericPointsEmbeddingEquiv (X.fromSpecStalk x).isEmbedding
      (fromSpecStalk_generizing X x))
        (minimalPrimesGenericEquiv (X.presheaf.stalk x) P)).val)

end
end PiExponent.CurveCycle

end OAI