import OAI.Algebra.Determinantal.Multigraded

namespace OAI
namespace PermanentBorder.Multigraded
open MvPolynomial
section LinearCoefficients
variable {K σ τ : Type*} [Field K] [Fintype τ]

noncomputable def linearFormMap (v : τ → σ) : (τ → K) →ₗ[K] MvPolynomial σ K :=
  ∑ t, (LinearMap.proj t).smulRight (X (v t))

lemma linearFormMap_apply (v : τ → σ) (c : τ → K) :
    linearFormMap v c = ∑ t, C (c t) * X (v t) := by
  simp [linearFormMap, smul_eq_C_mul]

lemma linearFormMap_single [DecidableEq τ] (v : τ → σ) (t : τ) :
    linearFormMap v (Pi.single t (1 : K)) = X (v t) := by
  classical
  simp [linearFormMap_apply, Pi.single_apply]

noncomputable def linearCoefficientSubspace (v : τ → σ) (I : Ideal (MvPolynomial σ K)) :
    Submodule K (τ → K) := (I.restrictScalars K).comap (linearFormMap v)

theorem linear_relations_of_codimension_le_one (v : τ → σ) (I : Ideal (MvPolynomial σ K))
    (h : Module.finrank K ((τ → K) ⧸ linearCoefficientSubspace v I) ≤ 1) :
    ∃ z : MvPolynomial σ K, ∃ c : τ → K, ∀ t, X (v t) - C (c t) * z ∈ I := by
  classical
  obtain ⟨a,ha⟩ := finrank_le_one_iff.mp h
  obtain ⟨b,rfl⟩ := Submodule.Quotient.mk_surjective (linearCoefficientSubspace v I) a
  choose c hc using fun t => ha (Submodule.Quotient.mk (Pi.single t (1 : K)))
  refine ⟨linearFormMap v b,c,fun t => ?_⟩
  have hmem : Pi.single t (1 : K) - c t • b ∈ linearCoefficientSubspace v I := by
    apply (Submodule.Quotient.eq (linearCoefficientSubspace v I)).mp
    simpa only [Submodule.Quotient.mk_smul] using (hc t).symm
  change linearFormMap v (Pi.single t 1 - c t • b) ∈ I at hmem
  simpa only [map_sub, map_smul, linearFormMap_single, smul_eq_C_mul] using hmem

theorem variables_mem_of_codimension_zero (v : τ → σ) (I : Ideal (MvPolynomial σ K))
    (h : Module.finrank K ((τ → K) ⧸ linearCoefficientSubspace v I) = 0) :
    ∀ t, X (v t) ∈ I := by
  classical
  intro t
  have hz : Submodule.Quotient.mk (Pi.single t (1 : K)) =
      (0 : (τ → K) ⧸ linearCoefficientSubspace v I) := by
    obtain ⟨c,hc,hq⟩ := Module.finrank_eq_zero_iff.mp h
      (Submodule.Quotient.mk (Pi.single t (1 : K)))
    exact (smul_eq_zero.mp hq).resolve_left hc
  have hm := (Submodule.Quotient.mk_eq_zero (linearCoefficientSubspace v I)).mp hz
  change linearFormMap v (Pi.single t (1 : K)) ∈ I at hm
  simpa only [linearFormMap_single] using hm

end LinearCoefficients

section Vandermonde
variable {K : Type*} [Field K]

lemma linearIndependent_rect_vandermonde {n N : ℕ} (hn : n ≤ N)
    (t : Fin n → K) (ht : Function.Injective t) :
    LinearIndependent K (fun i : Fin n => fun j : Fin N => t i ^ j.val) := by
  let f : (Fin N → K) →ₗ[K] Fin n → K :=
    LinearMap.funLeft K K (Fin.castLE hn)
  apply LinearIndependent.of_comp f
  exact Matrix.linearIndependent_rows_of_det_ne_zero
    (Matrix.det_vandermonde_ne_zero_iff.mpr ht)

lemma linear_block_codimension_le {σ : Type*} {n N : ℕ} (hn : n ≤ N)
    (v : Fin N → σ) (I : Ideal (MvPolynomial σ K))
    (t : Fin n → K) (ht : Function.Injective t)
    (hforms : ∀ i, linearFormMap v (fun j => t i ^ j.val) ∈ I) :
    Module.finrank K ((Fin N → K) ⧸ linearCoefficientSubspace v I) + n ≤ N := by
  have hi := linearIndependent_rect_vandermonde hn t ht
  have hspan : Submodule.span K (Set.range (fun i : Fin n => fun j : Fin N => t i ^ j.val)) ≤
      linearCoefficientSubspace v I := by
    apply Submodule.span_le.mpr
    rintro _ ⟨i,rfl⟩
    exact hforms i
  have hr := Submodule.finrank_mono hspan
  rw [finrank_span_eq_card hi, Fintype.card_fin] at hr
  have he := Submodule.finrank_quotient_add_finrank (linearCoefficientSubspace v I)
  rw [Module.finrank_fintype_fun_eq_card, Fintype.card_fin] at he
  omega

end Vandermonde
end PermanentBorder.Multigraded
namespace PermanentBorder.Multigraded
open MvPolynomial
section VandermondeLeaves
variable {K ι L : Type*} [Field K] [Fintype ι] [DecidableEq ι] [Fintype L]

abbrev BlockVariables (a : ι → ℕ) := (j : ι) × Fin (a j + 1)

def blockVar (a : ι → ℕ) (j : ι) (h : Fin (a j+1)) : BlockVariables a := ⟨j,h⟩

noncomputable def blockLinearForm (a : ι → ℕ) (j : ι) (t : K) :
    MvPolynomial (BlockVariables a) K :=
  linearFormMap (blockVar a j) (fun h : Fin (a j+1) => t ^ h.val)

omit [Fintype ι] in
lemma blockLinearForm_homogeneous (a : ι → ℕ) (j : ι) (t : K) :
    (blockLinearForm a j t).IsWeightedHomogeneous (blockWeight (fun v : BlockVariables a => v.1))
      (Pi.single j 1) := by
  classical
  rw [blockLinearForm,linearFormMap_apply]
  apply IsWeightedHomogeneous.sum
  intro h _
  exact (isWeightedHomogeneous_X K (blockWeight (fun v : BlockVariables a => v.1)) (blockVar a j h)).C_mul _

omit [Fintype ι] in
lemma labeled_codimension (a : ι → ℕ) (g : L → ι) (t : L → K)
    (ht : Function.Injective t) (I : Ideal (MvPolynomial (BlockVariables a) K))
    (hforms : ∀ l, blockLinearForm a (g l) (t l) ∈ I)
    (j : ι) (n : ℕ) (hn : n ≤ a j+1) (hj : n ≤ Fintype.card {l // g l = j}) :
    Module.finrank K ((Fin (a j+1) → K) ⧸ linearCoefficientSubspace (blockVar a j) I) + n ≤ a j+1 := by
  classical
  obtain ⟨e⟩ := Function.Embedding.nonempty_of_card_le (α := Fin n)
    (β := {l // g l = j}) (by simpa using hj)
  apply linear_block_codimension_le hn (blockVar a j) I (fun i => t (e i).val)
    (ht.comp (Subtype.val_injective.comp e.injective))
  intro i
  have h := hforms (e i).val
  have hij : g (e i).val = j := (e i).property
  rw [hij] at h
  exact h

theorem labeled_leaf_bound (a : ι → ℕ) (g : L → ι) (t : L → K)
    (ht : Function.Injective t) (hcard : Fintype.card L = ∑ j, a j)
    (I : Ideal (MvPolynomial (BlockVariables a) K))
    (hforms : ∀ l, blockLinearForm a (g l) (t l) ∈ I)
    (d : ι → ℤ) (hd : ∀ j, 0 < d j) :
    Module.finrank K (componentQuotient (blockWeight (fun v : BlockVariables a => v.1)) I d) ≤
      if ∀ j, Fintype.card {l // g l = j} = a j then 1 else 0 := by
  classical
  split_ifs with hbalanced
  · have hj (j : ι) :
        Module.finrank K ((Fin (a j+1) → K) ⧸ linearCoefficientSubspace (blockVar a j) I) ≤ 1 := by
      have h := labeled_codimension a g t ht I hforms j (a j) (by omega) (by rw [hbalanced])
      omega
    choose z c hc using fun j => linear_relations_of_codimension_le_one (blockVar a j) I (hj j)
    exact component_finrank_le_one_of_linear_relations (fun v : BlockVariables a => v.1) I z
      (fun v => c v.1 v.2) (fun v => hc v.1 v.2) d
  · have hs : (∑ j, Fintype.card {l // g l = j}) = ∑ j, a j := by
      rw [← Fintype.card_sigma, Fintype.card_congr (Equiv.sigmaFiberEquiv g), hcard]
    have hex : ∃ j, a j < Fintype.card {l // g l = j} := by
      by_contra! hn
      apply hbalanced
      exact fun j => (Finset.sum_eq_sum_iff_of_le (fun j _ => hn j)).mp hs j (Finset.mem_univ j)
    obtain ⟨j,hj⟩ := hex
    have hdim := labeled_codimension a g t ht I hforms j (a j+1) le_rfl hj
    have hz := variables_mem_of_codimension_zero (blockVar a j) I (by omega)
    have hb : ∀ v : BlockVariables a, v.1 = j → X v ∈ I := by
      rintro ⟨i,v⟩ hv
      change i = j at hv
      subst i
      exact hz v
    exact (component_finrank_zero_of_block_killed (fun v : BlockVariables a => v.1) I j hb d (hd j)).le

end VandermondeLeaves
end PermanentBorder.Multigraded
namespace PermanentBorder.Multigraded
open MvPolynomial
section BinaryChoices
variable {K σ G : Type*} [Field K] [AddCommGroup G]
variable (w : σ → G)

noncomputable def pieceDim (I : Ideal (MvPolynomial σ K)) (d : G) : ℕ :=
  Module.finrank K (componentQuotient w I d)

noncomputable def choiceIdeal : (qs : List (FactorPair (K := K) w)) →
    (Fin qs.length → Bool) → Ideal (MvPolynomial σ K)
  | [], _ => ⊥
  | q::qs, c => Ideal.span {if c 0 then q.right else q.left} ⊔
      choiceIdeal qs (fun i => c i.succ)

noncomputable def choiceShift : (qs : List (FactorPair (K := K) w)) →
    (Fin qs.length → Bool) → G
  | [], _ => 0
  | q::qs, c => (if c 0 then q.leftDegree else 0) + choiceShift qs (fun i => c i.succ)

lemma splitBound_eq_choiceSum (qs : List (FactorPair (K := K) w))
    (I : Ideal (MvPolynomial σ K)) (d : G) :
    splitBound w I d qs = ∑ c : Fin qs.length → Bool,
      pieceDim w (I ⊔ choiceIdeal w qs c) (d-choiceShift w qs c) := by
  classical
  induction qs generalizing I d with
  | nil =>
    change pieceDim w I d = ∑ c : Fin 0 → Bool,
      pieceDim w (I ⊔ choiceIdeal w [] c) (d-choiceShift w [] c)
    simp only [choiceIdeal, choiceShift, sup_bot_eq, sub_zero]
    simp
  | cons q qs ih =>
    rw [splitBound, ih, ih]
    let f : (Fin (qs.length+1) → Bool) → ℕ := fun c =>
      pieceDim w (I ⊔ choiceIdeal w (q::qs) c) (d-choiceShift w (q::qs) c)
    have hs := (Fin.consEquiv (fun _ : Fin (qs.length+1) => Bool)).sum_comp f
    apply Eq.trans (b := ∑ p : Bool × (Fin qs.length → Bool), f (Fin.cons p.1 p.2)) _ hs
    simp only [f, Fintype.sum_prod_type, Fintype.sum_bool,
      choiceIdeal, choiceShift, Fin.cons_zero, Fin.cons_succ, Bool.false_eq_true,
      ite_false, ite_true, zero_add, ← sup_assoc]
    simp_rw [sub_add_eq_sub_sub]
    exact add_comm _ _

lemma choice_mem_choiceIdeal (qs : List (FactorPair (K := K) w))
    (c : Fin qs.length → Bool) (i : Fin qs.length) :
    (if c i then (qs.get i).right else (qs.get i).left) ∈ choiceIdeal w qs c := by
  induction qs with
  | nil => exact Fin.elim0 i
  | cons q qs ih =>
    refine Fin.cases ?_ (fun i => ?_) i
    · exact Submodule.mem_sup_left (Ideal.subset_span (Set.mem_singleton _))
    · exact Submodule.mem_sup_right (ih (fun j => c j.succ) i)

end BinaryChoices
end PermanentBorder.Multigraded
namespace PermanentBorder.Multigraded
open MvPolynomial
section MixedCoefficient
variable {ι E : Type*} [Fintype E] [DecidableEq ι]

noncomputable def choiceCount (g : E → ι) : ι →₀ ℕ := ∑ e, Finsupp.single (g e) 1

lemma choiceCount_apply (g : E → ι) (j : ι) :
    choiceCount g j = Fintype.card {e // g e = j} := by
  classical
  rw [Fintype.card_subtype, Finset.card_filter]
  simp only [choiceCount, Finsupp.finsetSum_apply, Finsupp.single_apply]

noncomputable def mixedPolynomial (u v : E → ι) : MvPolynomial ι ℕ :=
  ∏ e, (X (u e) + X (v e))

omit [DecidableEq ι] in
lemma mixedPolynomial_eq_choices [DecidableEq E] (u v : E → ι) :
    mixedPolynomial u v = ∑ c : E → Bool,
      monomial (choiceCount (fun e => if c e then v e else u e)) (1 : ℕ) := by
  classical
  have h := Fintype.prod_sum (fun e (b : Bool) =>
    if b then X (v e) else X (u e) : E → Bool → MvPolynomial ι ℕ)
  simp only [Fintype.sum_bool, ite_true, Bool.false_eq_true, ite_false] at h
  rw [mixedPolynomial]
  simp_rw [add_comm] at h
  rw [h]
  apply Finset.sum_congr rfl
  intro c _
  rw [choiceCount, monomial_sum_one]
  apply Finset.prod_congr rfl
  intro e _
  cases c e <;> rfl

lemma mixed_coefficient_eq_count [Fintype ι] [DecidableEq E] (u v : E → ι) (a : ι →₀ ℕ) :
    (mixedPolynomial u v).coeff a =
      ∑ c : E → Bool, if ∀ j,
        Fintype.card {e // (if c e then v e else u e) = j} = a j then 1 else 0 := by
  classical
  rw [mixedPolynomial_eq_choices, coeff_sum]
  apply Finset.sum_congr rfl
  intro c _
  rw [coeff_monomial]
  congr 1
  rw [Finsupp.ext_iff]
  simp only [choiceCount_apply]

end MixedCoefficient
end PermanentBorder.Multigraded

namespace PermanentBorder.Multigraded
open MvPolynomial
section ComparisonPieceBound
variable {K ι σ : Type*} [Field K] [DecidableEq ι]

omit [DecidableEq ι] in
lemma choiceShift_le_length (w : σ → (ι → ℤ))
    (qs : List (FactorPair (K := K) w)) (c : Fin qs.length → Bool)
    (hdeg : ∀ q ∈ qs, ∀ j, q.leftDegree j ≤ 1) (j : ι) :
    choiceShift w qs c j ≤ (qs.length : ℤ) := by
  induction qs with
  | nil => simp [choiceShift]
  | cons q qs ih =>
    have hq := hdeg q (List.mem_cons_self) j
    have hs := ih (fun i => c i.succ) (fun q h => hdeg q (List.mem_cons_of_mem _ h))
    by_cases hc : c 0 = true
    · simpa [choiceShift, hc, add_comm] using add_le_add hq hs
    · simpa [choiceShift, hc] using hs.trans (show (qs.length : ℤ) ≤ qs.length + 1 by omega)

variable [Fintype ι]

theorem comparison_piece_bound (a : ι →₀ ℕ)
    (qs : List (FactorPair (K := K) (blockWeight (fun v : BlockVariables a => v.1))))
    (u v : Fin qs.length → ι) (t : (Fin qs.length × Bool) → K)
    (ht : Function.Injective t)
    (hleft : ∀ i, (qs.get i).left = blockLinearForm a (u i) (t (i,false)))
    (hright : ∀ i, (qs.get i).right = blockLinearForm a (v i) (t (i,true)))
    (hdeg : ∀ q ∈ qs, ∀ j, q.leftDegree j ≤ 1)
    (hlen : qs.length = ∑ j, a j) (d : ι → ℤ) (hd : ∀ j, (qs.length : ℤ) < d j) :
    pieceDim (blockWeight (fun v : BlockVariables a => v.1))
      (productIdeal (blockWeight (fun v : BlockVariables a => v.1)) qs) d ≤
      (mixedPolynomial u v).coeff a := by
  classical
  let w := blockWeight (fun v : BlockVariables a => v.1)
  have hf := finrank_le_splitBound w qs ⊥ (componentClosed_bot w) d
  change pieceDim w (⊥ ⊔ productIdeal w qs) d ≤ splitBound w ⊥ d qs at hf
  rw [bot_sup_eq] at hf
  apply hf.trans
  rw [splitBound_eq_choiceSum, mixed_coefficient_eq_count]
  apply Finset.sum_le_sum
  intro c _
  simp only [bot_sup_eq]
  let g : Fin qs.length → ι := fun i => if c i then v i else u i
  let t' : Fin qs.length → K := fun i => t (i,c i)
  have ht' : Function.Injective t' := by
    intro i j hij
    exact congrArg Prod.fst (ht hij)
  have hforms (i : Fin qs.length) :
      blockLinearForm a (g i) (t' i) ∈ choiceIdeal w qs c := by
    have h := choice_mem_choiceIdeal w qs c i
    dsimp only [g,t']
    cases hc : c i
    · simpa only [hc, Bool.false_eq_true, ite_false, hleft i] using h
    · simpa only [hc, ite_true, hright i] using h
  have hp (j : ι) : 0 < (d-choiceShift w qs c) j := by
    have hb := choiceShift_le_length w qs c hdeg j
    have hh := hd j
    simp only [Pi.sub_apply]
    omega
  exact labeled_leaf_bound a g t' ht' (by simpa using hlen)
    (choiceIdeal w qs c) hforms (d-choiceShift w qs c) hp

end ComparisonPieceBound
end PermanentBorder.Multigraded

namespace PermanentBorder.Multigraded
open MvPolynomial
section HomogeneousIdealMap
variable {K σ G E : Type*} [Field K] [AddCommGroup G] [Fintype E]
variable (w : σ → G) (e : E → G) (F : E → MvPolynomial σ K)
  (hF : ∀ i, (F i).IsWeightedHomogeneous w (e i))

noncomputable def homogeneousIdealMap (d : G) :
    (∀ i : E, Piece (K := K) w (d-e i)) →ₗ[K] Piece (K := K) w d :=
  ∑ i, (mulPiece w (hF i) d).comp (LinearMap.proj i)

lemma homogeneousIdealMap_val (d : G) (p : ∀ i : E, Piece (K := K) w (d-e i)) :
    (homogeneousIdealMap w e F hF d p).val = ∑ i, F i * (p i).val := by
  simp [homogeneousIdealMap]

lemma homogeneousIdealMap_range (d : G) :
    LinearMap.range (homogeneousIdealMap w e F hF d) =
      ((Ideal.span (Set.range F)).restrictScalars K).comap (Piece (K := K) w d).subtype := by
  classical
  ext p
  constructor
  · rintro ⟨g,rfl⟩
    change (homogeneousIdealMap w e F hF d g).val ∈ Ideal.span (Set.range F)
    rw [homogeneousIdealMap_val]
    exact Ideal.sum_mem _ fun i _ => Ideal.mul_mem_right _ _ (Ideal.mem_span_range_self)
  · intro hp
    change p.val ∈ Ideal.span (Set.range F) at hp
    obtain ⟨g,hg⟩ := Ideal.mem_span_range_iff_exists_fun.mp hp
    let g' : ∀ i : E, Piece (K := K) w (d-e i) := fun i =>
      ⟨weightedHomogeneousComponent w (d-e i) (g i),
        weightedHomogeneousComponent_mem w (g i) (d-e i)⟩
    refine ⟨g', Subtype.ext ?_⟩
    rw [homogeneousIdealMap_val]
    change ∑ i, F i * weightedHomogeneousComponent w (d-e i) (g i) = p.val
    simp_rw [← project_mul w (hF _)]
    rw [← map_sum]
    simp_rw [mul_comm (F _) _]
    rw [hg, weightedHomogeneousComponent_eq_self p.property]

lemma isWeightedHomogeneous_smul {p : MvPolynomial σ K} {a : G}
    (hp : p.IsWeightedHomogeneous w a) (c : K) :
    (c • p).IsWeightedHomogeneous w a := by
  simpa only [Algebra.smul_def, MvPolynomial.algebraMap_eq] using hp.C_mul c

lemma homogeneousIdealMap_affine (Q : E → MvPolynomial σ K)
    (hQ : ∀ i, (Q i).IsWeightedHomogeneous w (e i)) (d : G) (t : K) :
    homogeneousIdealMap w e (fun i => (1-t) • Q i + t • F i)
      (fun i => (isWeightedHomogeneous_smul w (hQ i) (1-t)).add
        (isWeightedHomogeneous_smul w (hF i) t)) d =
      (1-t) • homogeneousIdealMap w e Q hQ d + t • homogeneousIdealMap w e F hF d := by
  classical
  apply LinearMap.ext
  intro p
  apply Subtype.ext
  simp only [LinearMap.add_apply, LinearMap.smul_apply, Submodule.coe_add,
    Submodule.coe_smul]
  rw [homogeneousIdealMap_val, homogeneousIdealMap_val, homogeneousIdealMap_val]
  simp only [add_mul, smul_mul_assoc, Finset.sum_add_distrib, ← Finset.smul_sum]

end HomogeneousIdealMap

lemma pairProduct_mem_productIdeal {K σ G : Type*} [Field K] [AddCommGroup G]
    (w : σ → G) (qs : List (FactorPair (K := K) w)) (i : Fin qs.length) :
    (qs.get i).left * (qs.get i).right ∈ productIdeal w qs := by
  induction qs with
  | nil => exact Fin.elim0 i
  | cons q qs ih =>
    refine Fin.cases ?_ (fun i => ?_) i
    · exact Submodule.mem_sup_left (Ideal.subset_span (Set.mem_singleton _))
    · exact Submodule.mem_sup_right (ih i)

lemma productIdeal_le {K σ G : Type*} [Field K] [AddCommGroup G]
    (w : σ → G) (qs : List (FactorPair (K := K) w)) (I : Ideal (MvPolynomial σ K))
    (h : ∀ i : Fin qs.length, (qs.get i).left * (qs.get i).right ∈ I) :
    productIdeal w qs ≤ I := by
  induction qs with
  | nil => exact bot_le
  | cons q qs ih =>
    exact sup_le (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr (h 0)))
      (ih (fun i => h i.succ))

lemma productIdeal_eq_span {K σ G : Type*} [Field K] [AddCommGroup G]
    (w : σ → G) (qs : List (FactorPair (K := K) w)) :
    productIdeal w qs = Ideal.span (Set.range (fun i : Fin qs.length =>
      (qs.get i).left * (qs.get i).right)) := by
  apply le_antisymm
  · exact productIdeal_le w qs _ (fun _ => Ideal.mem_span_range_self)
  · apply Ideal.span_le.mpr
    rintro _ ⟨i,rfl⟩
    exact pairProduct_mem_productIdeal w qs i

end PermanentBorder.Multigraded

namespace PermanentBorder.Multigraded
section AffineIndependent
variable {K E V : Type*} [Field K] [Fintype E]
  [AddCommGroup V] [Module K V]

theorem affine_independent_polynomial (v w : E → V) (hv : LinearIndependent K v) :
    ∃ p : Polynomial K, p.eval 0 = 1 ∧ ∀ t : K, p.eval t ≠ 0 →
      LinearIndependent K (fun i => (1-t) • v i + t • w i) := by
  classical
  let f := Fintype.linearCombination K v
  obtain ⟨g,hg⟩ := f.exists_leftInverse_of_injective
    (LinearMap.ker_eq_bot.mpr hv.fintypeLinearCombination_injective)
  have hgv (i : E) : g (v i) = Pi.single i 1 := by
    have h := LinearMap.congr_fun hg (Pi.single i 1)
    simpa [f, Fintype.linearCombination_apply] using h
  let M : Matrix E E (Polynomial K) := fun j i =>
    (1-Polynomial.X) * Polynomial.C (g (v i) j) + Polynomial.X * Polynomial.C (g (w i) j)
  have hM (t : K) : M.map (Polynomial.evalRingHom t) =
      (fun j i => g ((1-t) • v i + t • w i) j) := by
    ext j i
    change (Polynomial.evalRingHom t) (M j i) = _
    simp [M]
    ring
  have hzero : M.map (Polynomial.evalRingHom 0) = 1 := by
    rw [hM]
    ext j i
    by_cases h : j = i
    · subst j; simp [hgv]
    · simp [hgv, h]
  refine ⟨M.det, ?_, ?_⟩
  · change Polynomial.evalRingHom 0 M.det = 1
    rw [RingHom.map_det, RingHom.mapMatrix_apply, hzero, Matrix.det_one]
  · intro t ht
    have hu : IsUnit ((M.map (Polynomial.evalRingHom t)).det) := by
      rw [← RingHom.mapMatrix_apply, ← RingHom.map_det]
      exact isUnit_iff_ne_zero.mpr ht
    have hi := (Matrix.linearIndependent_cols_iff_isUnit).mpr
      ((Matrix.isUnit_iff_isUnit_det _).mpr hu)
    apply LinearIndependent.of_comp g
    rw [hM] at hi
    exact hi

end AffineIndependent
end PermanentBorder.Multigraded

end OAI