lean/OAI/Algebra/Determinantal/HomogeneousPadding.lean

import OAI.Algebra.Determinantal.AffineSelectors

namespace OAI

namespace PermanentBorder.Selector
open MvPolynomial
variable {A B R : Type*} [Fintype A] [Fintype B] [CommSemiring R]
 theorem weight_one_sumElim (d : A →₀ ℕ) (e : B →₀ ℕ) :
    Finsupp.weight (1 : A ⊕ B → ℕ) (d.sumElim e) =
      Finsupp.weight (1 : A → ℕ) d + Finsupp.weight (1 : B → ℕ) e := by
  simp only [Finsupp.weight_eq_sum, Pi.one_apply, smul_eq_mul, mul_one,
    Fintype.sum_sum_type, Finsupp.sumElim_inl, Finsupp.sumElim_inr]

 theorem homogeneous_coefficient {p : MvPolynomial (A ⊕ B) R} {r : ℕ}
    (hp : p.IsHomogeneous r) (d : A →₀ ℕ) :
    ((sumRingEquiv R A B p).coeff d).IsHomogeneous
      (r - Finsupp.weight (1 : A → ℕ) d) := by
  intro e he
  rw [← coeff_nested] at he
  have hh := hp he
  rw [weight_one_sumElim] at hh
  omega

variable {I : Type*} [Fintype I] [DecidableEq I]
noncomputable def universalHomogeneousPencil (θ : I → R) :
    Matrix I I (MvPolynomial (Fin 2 ⊕ (I × I)) R) :=
  Matrix.of fun i j => X (.inr (i,j)) +
    if i=j then X (.inl 0) + C (θ i)*X (.inl 1) else 0

 theorem universalHomogeneousPencil_permanent (θ : I → R) :
    (universalHomogeneousPencil θ).permanent.IsHomogeneous (Fintype.card I) := by
  classical
  unfold Matrix.permanent
  apply IsHomogeneous.sum
  intro σ _
  convert IsHomogeneous.prod Finset.univ
    (fun i => universalHomogeneousPencil θ (σ i) i) (fun _ => 1) ?_ using 1 <;> try simp
  intro i _
  apply IsHomogeneous.add (isHomogeneous_X _ _)
  split_ifs
  · exact (isHomogeneous_X _ _).add (isHomogeneous_C_mul_X _ _)
  · exact isHomogeneous_zero _ _ _

 theorem coefficientPolynomial_homogeneous (θ : I → R) (q : ℕ) :
    (diagonalCoefficient (Matrix.of fun i j => (X (i,j) : MvPolynomial (I × I) R))
      (fun i => C (θ i)) q).IsHomogeneous (Fintype.card I - 2*q) := by
  classical
  have hm : sumRingEquiv R (Fin 2) (I × I) (universalHomogeneousPencil θ).permanent =
      ((Matrix.of fun i j => C (X (i,j))) +
        Matrix.diagonal (fun i => X (0 : Fin 2) + C (C (θ i))*X 1)).permanent := by
    unfold Matrix.permanent
    simp only [map_sum, map_prod]
    apply Finset.sum_congr rfl
    intro σ _
    apply Finset.prod_congr rfl
    intro i _
    by_cases hi : σ i = i
    · simp [universalHomogeneousPencil, hi]
    · simp [universalHomogeneousPencil, hi]
  have hw : Finsupp.weight (1 : Fin 2 → ℕ) (countIndex q) = 2*q := by
    simp [Finsupp.weight_apply, Finsupp.sum_fintype, countIndex]
  have h := homogeneous_coefficient (universalHomogeneousPencil_permanent θ) (countIndex q)
  rw [hm, hw] at h
  exact h
end PermanentBorder.Selector

namespace PermanentBorder.HomogeneousPadding
open MvPolynomial
variable {σ τ R : Type*} [Fintype σ] [CommRing R]

noncomputable def dehomogenize : MvPolynomial (Option σ) R →+* MvPolynomial σ R :=
  (Polynomial.evalRingHom 1).comp (optionEquivLeft R σ).toRingHom

 theorem weight_optionElim (d : σ →₀ ℕ) (i : ℕ) :
    Finsupp.weight (1 : Option σ → ℕ) (d.optionElim i) =
      i + Finsupp.weight (1 : σ → ℕ) d := by
  simp only [Finsupp.weight_eq_sum, Pi.one_apply, smul_eq_mul, mul_one,
    Fintype.sum_option, Finsupp.optionElim_apply_none, Finsupp.optionElim_apply_some]

 theorem weight_some (d : Option σ →₀ ℕ) :
    Finsupp.weight (1 : Option σ → ℕ) d =
      d none + Finsupp.weight (1 : σ → ℕ) d.some := by
  convert weight_optionElim d.some (d none) using 1; simp

 theorem dehomogenize_coeff_of_homogeneous {p : MvPolynomial (Option σ) R} {m : ℕ}
    (hp : p.IsHomogeneous m) (d : Option σ →₀ ℕ)
    (hd : Finsupp.weight (1 : Option σ → ℕ) d = m) :
    (dehomogenize p).coeff d.some = p.coeff d := by
  classical
  change (((optionEquivLeft R σ p).eval 1)).coeff d.some = _
  simp only [Polynomial.eval_eq_sum, Polynomial.sum, one_pow, mul_one, coeff_sum]
  rw [← optionEquivLeft_coeff_some_coeff_none R σ d p]
  apply Finset.sum_eq_single (d none)
  · intro i hi hne
    rw [optionEquivLeft_coeff_coeff]
    apply IsWeightedHomogeneous.coeff_eq_zero hp
    rw [weight_optionElim]
    rw [weight_some] at hd
    omega
  · intro hn
    have hh := Polynomial.notMem_support_iff.mp hn
    rw [hh, AddMonoidAlgebra.coeff_zero, Finsupp.zero_apply]

 theorem homogeneous_eq_of_dehomogenize_eq {p q : MvPolynomial (Option σ) R} {m : ℕ}
    (hp : p.IsHomogeneous m) (hq : q.IsHomogeneous m)
    (h : dehomogenize p = dehomogenize q) : p=q := by
  apply sub_eq_zero.mp
  have hsub := hp.sub hq
  have hzero : dehomogenize (p-q) = 0 := by rw [map_sub,h,sub_self]
  ext d
  by_cases hd : Finsupp.weight (1 : Option σ → ℕ) d = m
  · have hc := dehomogenize_coeff_of_homogeneous hsub d hd
    rw [hzero, AddMonoidAlgebra.coeff_zero, Finsupp.zero_apply] at hc
    exact hc.symm
  · exact IsWeightedHomogeneous.coeff_eq_zero hsub d hd

omit [Fintype σ] in
@[simp] theorem dehomogenize_C (r : R) : dehomogenize (C r : MvPolynomial (Option σ) R) = C r := by
  simp [dehomogenize]
omit [Fintype σ] in
@[simp] theorem dehomogenize_none : dehomogenize (X (none : Option σ) : MvPolynomial (Option σ) R) = 1 := by
  simp [dehomogenize]
omit [Fintype σ] in
@[simp] theorem dehomogenize_some (i : σ) : dehomogenize (X (some i) : MvPolynomial (Option σ) R) = X i := by
  simp [dehomogenize]
omit [Fintype σ] in
@[simp] theorem dehomogenize_rename (p : MvPolynomial σ R) :
    dehomogenize (rename some p) = p := by
  induction p using MvPolynomial.induction_on with
  | C r => simp
  | add p q hp hq => simp [hp,hq]
  | mul_X p i hp => simp [hp]

variable [Fintype τ]
noncomputable def affineSubstitution (b : σ → R) (B : σ → τ → R) :
    MvPolynomial σ R →+* MvPolynomial τ R :=
  eval₂Hom C (fun i => C (b i) + ∑ j, C (B i j)*X j)
noncomputable def homogeneousSubstitution (b : σ → R) (B : σ → τ → R) :
    MvPolynomial σ R →+* MvPolynomial (Option τ) R :=
  eval₂Hom C (fun i => C (b i)*X none + ∑ j, C (B i j)*X (some j))

omit [Fintype σ] in
 theorem dehomogenize_homogeneousSubstitution (b : σ → R) (B : σ → τ → R)
    (p : MvPolynomial σ R) :
    dehomogenize (homogeneousSubstitution b B p) = affineSubstitution b B p := by
  have he : (dehomogenize (σ := τ) (R := R)).comp (homogeneousSubstitution b B) =
      affineSubstitution b B := by
    apply MvPolynomial.ringHom_ext
    · intro r
      simp only [RingHom.comp_apply, homogeneousSubstitution, affineSubstitution,
        eval₂Hom_C, dehomogenize_C]
    · intro i
      simp only [RingHom.comp_apply, homogeneousSubstitution, affineSubstitution,
        eval₂Hom_X', map_add, map_mul, map_sum, dehomogenize_C,
        dehomogenize_none, dehomogenize_some, mul_one]
  exact RingHom.congr_fun he p

omit [Fintype σ] in

 theorem independent_padding {p : MvPolynomial σ R} {g : MvPolynomial τ R}
    {m r : ℕ} (hp : p.IsHomogeneous m) (hg : g.IsHomogeneous r) (hrm : r ≤ m)
    (b : σ → R) (B : σ → τ → R) (h : affineSubstitution b B p = g) :
    homogeneousSubstitution b B p = (X none)^(m-r) * rename some g := by
  apply homogeneous_eq_of_dehomogenize_eq (m := m)
  · change (eval₂ C _ p).IsHomogeneous m
    convert hp.eval₂ C _ (fun a => isHomogeneous_C _ a) (fun i =>
      (isHomogeneous_C_mul_X (b i) none).add
        (IsHomogeneous.sum Finset.univ _ 1 (fun j _ => isHomogeneous_C_mul_X (B i j) (some j)))) using 1; simp
  · have hg' := (isHomogeneous_X_pow (none : Option τ) (m-r)).mul (hg.rename_isHomogeneous (f := some))
    simpa only [Nat.sub_add_cancel hrm] using hg'
  · simp [dehomogenize_homogeneousSubstitution,h]
end PermanentBorder.HomogeneousPadding

namespace PermanentBorder
open MvPolynomial

 theorem permanentPolynomial_homogeneous (m : ℕ) :
    (permanentPolynomial m).IsHomogeneous m := by
  classical
  unfold permanentPolynomial
  apply IsHomogeneous.sum
  intro τ _
  convert IsHomogeneous.prod Finset.univ
    (fun i : Fin m => (X (i,τ i) : Poly (Variables m))) (fun _ => 1)
    (fun i _ => isHomogeneous_X _ _) using 1; simp

 theorem coefficientPolynomial_homogeneous (k q : ℕ) (θ : Fin k → ℂ) :
    (coefficientPolynomial k q θ).IsHomogeneous (k-2*q) := by
  simpa only [coefficientPolynomial,Fintype.card_fin] using
    Selector.coefficientPolynomial_homogeneous θ q

 theorem exists_selector_projection_homogeneous (k q m : ℕ)
    (hk : 1 ≤ k) (hq : q ≤ k/2) (hm : 11*k-2*q ≤ m) (θ : Fin k → ℂ) :
    ∃ (b : Variables m → ℂ) (B : Variables m → Variables k → ℂ),
      affineSubstitution b B (permanentPolynomial m) =
        selectorScalar k q • coefficientPolynomial k q θ ∧
      HomogeneousPadding.homogeneousSubstitution b B (permanentPolynomial m) =
        selectorScalar k q • ((X (none : Option (Variables k)))^(m-(k-2*q)) *
          rename some (coefficientPolynomial k q θ)) := by
  have hqk : q ≤ k := hq.trans (Nat.div_le_self ..)
  obtain ⟨b,B,h⟩ := exists_selector_affine_projection k q m hqk hm θ
  refine ⟨b,B,h,?_⟩
  have hg : (selectorScalar k q • coefficientPolynomial k q θ).IsHomogeneous (k-2*q) := by
    rw [smul_eq_C_mul]
    simpa only [zero_add] using
      (isHomogeneous_C (Variables k) (selectorScalar k q)).mul
        (coefficientPolynomial_homogeneous k q θ)
  have h' : HomogeneousPadding.affineSubstitution b B (permanentPolynomial m) =
      selectorScalar k q • coefficientPolynomial k q θ := h
  have hh := HomogeneousPadding.independent_padding (permanentPolynomial_homogeneous m)
    hg (by omega : k-2*q ≤ m) b B h'
  rw [hh,smul_eq_C_mul,map_mul,rename_C]
  simp only [smul_eq_C_mul]
  ring
end PermanentBorder
namespace PermanentBorder.Selector
open MvPolynomial

lemma diagonalCoefficient_map {I R S : Type*} [Fintype I] [DecidableEq I]
    [CommSemiring R] [CommSemiring S] (φ : R →+* S)
    (M : Matrix I I R) (θ : I → R) (q : ℕ) :
    φ (diagonalCoefficient M θ q) =
      diagonalCoefficient (fun i j => φ (M i j)) (fun i => φ (θ i)) q := by
  classical
  unfold diagonalCoefficient
  rw [← coeff_map]
  apply congrArg (fun polynomial : MvPolynomial (Fin 2) S => polynomial.coeff (countIndex q))
  unfold Matrix.permanent
  simp only [map_sum,map_prod]
  apply Finset.sum_congr rfl
  intro π _
  apply Finset.prod_congr rfl
  intro i _
  simp only [Matrix.add_apply, Matrix.of_apply,Matrix.diagonal_apply,map_add,map_C]
  split_ifs <;> simp

noncomputable def integralCoefficientFamily (k q : ℕ) :
    MvPolynomial (Variables k) (MvPolynomial (Fin k) ℤ) :=
  diagonalCoefficient (Matrix.of fun i j => X (i,j)) (fun i => C (X i)) q

lemma integralCoefficientFamily_homogeneous (k q : ℕ) :
    (integralCoefficientFamily k q).IsHomogeneous (k-2*q) := by
  simpa only [integralCoefficientFamily,Fintype.card_fin] using
    coefficientPolynomial_homogeneous (fun i : Fin k => (X i : MvPolynomial (Fin k) ℤ)) q

lemma integralCoefficientFamily_specialize {K : Type*} [CommRing K]
    (k q : ℕ) (θ : Fin k → K) :
    map (eval₂Hom (Int.castRingHom K) θ) (integralCoefficientFamily k q) =
      diagonalCoefficient (Matrix.of fun i j => (X (i,j) : MvPolynomial (Variables k) K))
        (fun i => C (θ i)) q := by
  unfold integralCoefficientFamily
  rw [diagonalCoefficient_map]
  simp only [Matrix.of_apply,map_X,map_C,eval₂Hom_X']
  rfl

lemma integralCoefficientFamily_complex (k q : ℕ) (θ : Fin k → ℂ) :
    map (eval₂Hom (Int.castRingHom ℂ) θ) (integralCoefficientFamily k q) =
      coefficientPolynomial k q θ := by
  exact integralCoefficientFamily_specialize k q θ
end PermanentBorder.Selector

namespace PermanentBorder.AlgebraicDimension

open Order

theorem krullDim_le_of_injective_integral {R S : Type*} [CommRing R] [CommRing S]
    (f : R →+* S) (hf : Function.Injective f) (hi : f.IsIntegral) :
    ringKrullDim R ≤ ringKrullDim S := by
  let : Algebra R S := f.toAlgebra
  let : Algebra.IsIntegral R S := ⟨hi⟩
  change (⨆ l : LTSeries (PrimeSpectrum R), (l.length : WithBot ℕ∞)) ≤ _
  apply iSup_le
  intro l
  have h0 : (⊥ : Ideal S).comap (algebraMap R S) ≤ l.head.asIdeal := by
    rw [← RingHom.ker_eq_comap_bot]
    change RingHom.ker f ≤ _
    rw [(RingHom.injective_iff_ker_eq_bot f).mp hf]
    exact bot_le
  obtain ⟨P, _, hP, hPc⟩ := Ideal.exists_ideal_over_prime_of_isIntegral
    l.head.asIdeal (⊥ : Ideal S) h0
  let : P.IsPrime := hP
  let : P.LiesOver l.head.asIdeal := ⟨hPc.symm⟩
  obtain ⟨L, hlen, _, _⟩ := Ideal.exists_ltSeries_of_hasGoingUp l P
  exact le_krullDim_iff.mpr ⟨L, hlen⟩

universe u

theorem trdeg_le_of_krullDim_le {K A : Type u} [Field K] [CommRing A] [IsDomain A]
    [Algebra K A] [Algebra.FiniteType K A] (n : ℕ) (h : ringKrullDim A ≤ n) :
    Algebra.trdeg K A ≤ (n : Cardinal) := by
  obtain ⟨s, g, hg, hint⟩ := exists_integral_inj_algHom_of_fg K A
  let R := MvPolynomial (Fin s) K
  let : Algebra R A := g.toRingHom.toAlgebra
  let : IsScalarTower K R A := IsScalarTower.of_algebraMap_eq fun k => (g.commutes k).symm
  let : Algebra.IsIntegral R A := ⟨hint⟩
  have hs : s ≤ n := by
    have hd := (krullDim_le_of_injective_integral g.toRingHom hg hint).trans h
    simpa using hd
  let : FaithfulSMul R A := (faithfulSMul_iff_algebraMap_injective R A).mpr hg
  have ht : Algebra.trdeg K A = s := by
    rw [← trdeg_add_eq K R (A := A), trdeg_eq_zero (R := R), add_zero]
    simp [R]
  rw [ht]
  exact_mod_cast hs

theorem field_image_trdeg_le {K A L : Type u} [Field K] [CommRing A]
    [Field L] [Algebra K A] [Algebra K L] [Algebra.FiniteType K A]
    (n : ℕ) (h : ringKrullDim A ≤ n) (f : A →ₐ[K] L) :
    Algebra.trdeg K f.range ≤ (n : Cardinal) := by
  let : Algebra.FiniteType K f.range := Algebra.FiniteType.of_surjective
    f.rangeRestrict f.rangeRestrict_surjective
  have hd : ringKrullDim f.range ≤ ringKrullDim A :=
    ringKrullDim_le_of_surjective f.rangeRestrict.toRingHom f.rangeRestrict_surjective
  exact trdeg_le_of_krullDim_le n (hd.trans h)

open scoped IntermediateField.algebraAdjoinAdjoin in

theorem point_field_trdeg_le {K L : Type u} [Field K] [Field L] [Algebra K L]
    {v : ℕ} (I : Ideal (MvPolynomial (Fin v) K)) (n : ℕ)
    (h : ringKrullDim (MvPolynomial (Fin v) K ⧸ I) ≤ n)
    (x : Fin v → L) (hx : ∀ p ∈ I, MvPolynomial.aeval x p = 0) :
    Algebra.trdeg K (IntermediateField.adjoin K (Set.range x)) ≤ (n : Cardinal) := by
  let f := Ideal.Quotient.liftₐ I (MvPolynomial.aeval x) hx
  have hr : f.range = Algebra.adjoin K (Set.range x) := by
    rw [← MvPolynomial.aeval_range]
    ext y
    constructor
    · rintro ⟨z, rfl⟩
      obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective z
      exact ⟨p, rfl⟩
    · rintro ⟨p, rfl⟩
      exact ⟨Ideal.Quotient.mk I p, rfl⟩
  have ht := field_image_trdeg_le n h f
  rw [hr] at ht
  rw [← trdeg_add_eq K (Algebra.adjoin K (Set.range x)),
    trdeg_eq_zero (R := Algebra.adjoin K (Set.range x)), add_zero]
  exact ht

end PermanentBorder.AlgebraicDimension

namespace PermanentBorder.SliceParameters

universe u
open MvPolynomial

variable {K L : Type u} [Field K] [Field L] [Algebra K L]

open scoped IntermediateField.algebraAdjoinAdjoin in
lemma field_adjoin_trdeg_le {κ : Type*} [Fintype κ] (x : κ → L) :
    Algebra.trdeg K (IntermediateField.adjoin K (Set.range x)) ≤
      (Fintype.card κ : Cardinal) := by
  let A := Algebra.adjoin K (Set.range x)
  let y : κ → A := fun i => ⟨x i, Algebra.subset_adjoin (Set.mem_range_self i)⟩
  have htop : Algebra.adjoin K (Set.range y) = ⊤ := by
    apply Subalgebra.map_injective (show Function.Injective A.val from Subtype.val_injective)
    rw [AlgHom.map_adjoin, Algebra.map_top, A.range_val, ← Set.range_comp]
    rfl
  let : Algebra.IsAlgebraic (Algebra.adjoin K (Set.range y)) A := by
    constructor
    intro a
    have ha : a ∈ Algebra.adjoin K (Set.range y) := by rw [htop]; trivial
    exact isAlgebraic_algebraMap (R := Algebra.adjoin K (Set.range y)) ⟨a, ha⟩
  have hA : Algebra.trdeg K A ≤ (Fintype.card κ : Cardinal) := by
    calc
      Algebra.trdeg K A ≤ Cardinal.mk (Set.range y) :=
        Algebra.IsAlgebraic.trdeg_le_cardinalMk K (Set.range y)
      _ ≤ Fintype.card κ := by
        simpa using (Cardinal.mk_range_le_lift (f := y))
  rw [← trdeg_add_eq K A, trdeg_eq_zero (R := A), add_zero]
  exact hA

lemma add_parameters {κ : Type*} [Fintype κ] (F : IntermediateField K L)
    (n : ℕ) (hF : Algebra.trdeg K F ≤ (n : Cardinal)) (z : κ → L) :
    ∃ E : IntermediateField K L,
      F ≤ E ∧ (∀ i, z i ∈ E) ∧
      Algebra.trdeg K E ≤ (n + Fintype.card κ : ℕ) := by
  let E := IntermediateField.adjoin F (Set.range z)
  let : FaithfulSMul F E := (faithfulSMul_iff_algebraMap_injective F E).mpr
    (algebraMap F E).injective
  let : IsScalarTower K F E := IsScalarTower.of_algebraMap_eq fun _ => rfl
  refine ⟨E.restrictScalars K, ?_, ?_, ?_⟩
  · intro x hx
    exact E.algebraMap_mem ⟨x, hx⟩
  · intro i
    exact IntermediateField.subset_adjoin F _ (Set.mem_range_self i)
  · change Algebra.trdeg K E ≤ _
    rw [← trdeg_add_eq K F]
    exact (add_le_add hF (field_adjoin_trdeg_le (K := F) z)).trans_eq (by simp)

lemma independent_card_le {κ : Type*} [Fintype κ] (H : κ → L)
    (hH : AlgebraicIndependent K H) (F : IntermediateField K L)
    (hF : ∀ i, H i ∈ F) (n : ℕ) (ht : Algebra.trdeg K F ≤ (n : Cardinal)) :
    Fintype.card κ ≤ n := by
  let x : κ → F := fun i => ⟨H i, hF i⟩
  have hx : AlgebraicIndependent K x := hH.of_comp F.val
  have hc := hx.lift_cardinalMk_le_trdeg.trans (Cardinal.lift_le.mpr ht)
  simpa using hc

end PermanentBorder.SliceParameters

end OAI