| import Mathlib |
| import OAI.Algebra.FiniteTensor.ClosedSpecialization |
| import OAI.Algebra.FiniteTensor.CoefficientDescent |
| import OAI.Algebra.FiniteTensor.KernelRelations |
|
|
| namespace OAI |
|
|
| /-! Finite-type algebraic coefficient descent and the algebraic tensor contradiction. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace PD4Tensor.Spreading |
| open scoped BigOperators |
| variable {K σ : Type*} [Field K] [Finite σ] |
|
|
| def truncSeries (n : ℕ) (f : MvPowerSeries σ K) : MvPowerSeries σ K := |
| (MvPowerSeries.truncTotal n f : MvPolynomial σ K) |
|
|
| theorem coeff_truncSeries (n : ℕ) (f : MvPowerSeries σ K) (d : σ →₀ ℕ) : |
| MvPowerSeries.coeff d (truncSeries n f)= |
| if d.degree<n then MvPowerSeries.coeff d f else 0 := by |
| exact MvPowerSeries.coeff_truncTotal_eq_ite _ |
|
|
| theorem order_truncSeries_sub (n : ℕ) (f : MvPowerSeries σ K) : |
| (n : ℕ∞)≤(truncSeries n f-f).order := by |
| apply MvPowerSeries.nat_le_order |
| intro d hd |
| simp only [map_sub,coeff_truncSeries,ite_eq_left hd,sub_self] |
|
|
| theorem homogeneous_truncSeries (n : ℕ) (f : MvPowerSeries σ K) : |
| MvPowerSeries.homogeneousComponent n (truncSeries n f)=0 := by |
| ext d |
| simp only [MvPowerSeries.coeff_homogeneousComponent,coeff_truncSeries,map_zero] |
| split_ifs <;> simp_all |
|
|
| |
|
|
| theorem homogeneous_root_equation (P : Polynomial (MvPowerSeries σ K)) |
| (f : MvPowerSeries σ K) (hf : P.eval f=0) (r n : ℕ) (hrn : r<n) |
| (hD : (r : ℕ∞)≤(P.derivative.eval f).order) : |
| MvPowerSeries.homogeneousComponent r (P.derivative.eval f)* |
| MvPowerSeries.homogeneousComponent n f = |
| -MvPowerSeries.homogeneousComponent (r+n) (P.eval (truncSeries n f)) := by |
| let h := truncSeries n f-f |
| obtain ⟨c,hc⟩ := Polynomial.exists_mul_sq_add_linear_part_eq_eval_add P f h |
| have hn : (n : ℕ∞)≤h.order := order_truncSeries_sub n f |
| have hrem : MvPowerSeries.homogeneousComponent (r+n) (c*h^2)=0 := by |
| apply MvPowerSeries.homogeneousComponent_of_lt_order_eq_zero |
| calc |
| ((r+n : ℕ) : ℕ∞) < ((n+n : ℕ) : ℕ∞) := by exact_mod_cast Nat.add_lt_add_right hrn n |
| _ ≤ h.order+h.order := by simpa only [Nat.cast_add] using add_le_add hn hn |
| _ ≤ (h^2).order := by simpa only [two_nsmul] using MvPowerSeries.le_order_pow (f:=h) 2 |
| _ ≤ c.order+(h^2).order := le_add_of_nonneg_left zero_le |
| _ ≤ (c*h^2).order := MvPowerSeries.le_order_mul |
| have hh := congrArg (MvPowerSeries.homogeneousComponent (r+n)) hc |
| rw [show f+h=truncSeries n f by dsimp [h]; ring,hf,map_add,map_add,hrem, |
| map_zero,add_zero,zero_add] at hh |
| rw [MvPowerSeries.homogeneousComponent_mul_of_le_order hD hn] at hh |
| have hh' : MvPowerSeries.homogeneousComponent n h= |
| -MvPowerSeries.homogeneousComponent n f := by |
| simp only [h,map_sub,homogeneous_truncSeries,zero_sub] |
| rw [hh',mul_neg] at hh |
| exact neg_eq_iff_eq_neg.mp hh |
|
|
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| open scoped BigOperators |
| open Finsupp |
| variable {K σ : Type*} [Field K] |
|
|
| theorem eval_mem_seriesOver (A : Subring K) (P : Polynomial (MvPowerSeries σ K)) |
| (hP : ∀ i,P.coeff i ∈seriesOver A) (f : MvPowerSeries σ K) |
| (hf : f∈seriesOver A) : P.eval f∈seriesOver A := by |
| rw [Polynomial.eval_eq_sum,Polynomial.sum] |
| exact (seriesOver A).sum_mem (fun i _ => (seriesOver A).mul_mem (hP i) ((seriesOver A).pow_mem hf i)) |
|
|
| theorem homogeneous_mem_seriesOver (A : Subring K) (f : MvPowerSeries σ K) |
| (hf : f∈seriesOver A) (n : ℕ) : MvPowerSeries.homogeneousComponent n f∈seriesOver A := by |
| rw [mem_seriesOver] at hf ⊢ |
| intro d |
| rw [MvPowerSeries.coeff_homogeneousComponent] |
| split_ifs |
| · exact hf d |
| · exact A.zero_mem |
|
|
| variable [Finite σ] [LinearOrder σ] [WellFoundedGT σ] |
|
|
| theorem coefficients_root_mem (A : Subring K) (P : Polynomial (MvPowerSeries σ K)) |
| (f : MvPowerSeries σ K) (hf : P.eval f=0) (r : ℕ) |
| (hDr : (r : ℕ∞)≤(P.derivative.eval f).order) |
| (a : σ →₀ ℕ) |
| (ha : MvPowerSeries.coeff a (MvPowerSeries.homogeneousComponent r (P.derivative.eval f))≠0) |
| (hmin : ∀ u,toLex u<toLex a → |
| MvPowerSeries.coeff u (MvPowerSeries.homogeneousComponent r (P.derivative.eval f))=0) |
| (hP : ∀ i,P.coeff i∈seriesOver A) |
| (hD : MvPowerSeries.homogeneousComponent r (P.derivative.eval f)∈seriesOver A) |
| (hinv : (MvPowerSeries.coeff a (MvPowerSeries.homogeneousComponent r (P.derivative.eval f)))⁻¹∈A) |
| (hlow : ∀ b,b.degree≤r → MvPowerSeries.coeff b f∈A) : |
| f∈seriesOver A := by |
| rw [mem_seriesOver] |
| suffices hall : ∀ n,∀ b : σ →₀ ℕ,b.degree=n → MvPowerSeries.coeff b f∈A by |
| intro b |
| exact hall b.degree b rfl |
| intro n |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| intro b hb |
| by_cases hn : n≤r |
| · exact hlow b (hb ▸ hn) |
| have hrn : r<n := lt_of_not_ge hn |
| have ht : truncSeries n f∈seriesOver A := by |
| rw [mem_seriesOver] |
| intro d |
| rw [coeff_truncSeries] |
| split_ifs with hd |
| · exact ih d.degree hd d rfl |
| · exact A.zero_mem |
| have heval := eval_mem_seriesOver A P hP (truncSeries n f) ht |
| have hmul : MvPowerSeries.homogeneousComponent r (P.derivative.eval f)* |
| MvPowerSeries.homogeneousComponent n f∈seriesOver A := by |
| rw [homogeneous_root_equation P f hf r n hrn hDr] |
| exact (seriesOver A).neg_mem (homogeneous_mem_seriesOver A _ heval _) |
| have hout := coefficients_of_product A _ (MvPowerSeries.homogeneousComponent n f) a ha hmin |
| ((mem_seriesOver A _).mp hD) hinv ((mem_seriesOver A _).mp hmul) b |
| simpa only [MvPowerSeries.coeff_homogeneousComponent,hb,ite_true] using hout |
|
|
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| open scoped BigOperators |
| open Finsupp |
| variable {K σ : Type*} [Field K] [CharZero K] |
| [Finite σ] [LinearOrder σ] [WellFoundedGT σ] |
|
|
| |
|
|
| theorem algebraic_series_finiteType (f : MvPowerSeries σ K) |
| (hf : IsAlgebraic (MvPolynomial σ K) f) : |
| ∃ A : Subalgebra ℤ K, Algebra.FiniteType ℤ A ∧ |
| ∀ d,MvPowerSeries.coeff d f∈A := by |
| classical |
| have hi : Function.Injective (algebraMap (MvPolynomial σ K) (MvPowerSeries σ K)) := by |
| intro x y h |
| apply MvPolynomial.coe_injective σ K |
| simpa only [MvPowerSeries.algebraMap_apply',Algebra.algebraMap_self, |
| MvPowerSeries.map_id,RingHom.id_apply] using h |
| obtain ⟨P,_,hPf,hPd⟩ := exists_relation_derivative_ne_zero hi f hf |
| let Q := P.map (algebraMap (MvPolynomial σ K) (MvPowerSeries σ K)) |
| have hQf : Q.eval f=0 := by |
| simpa only [Q,Polynomial.eval_map,←Polynomial.aeval_def] using hPf |
| have hQd : Q.derivative.eval f≠0 := by |
| simpa only [Q,Polynomial.derivative_map,Polynomial.eval_map,←Polynomial.aeval_def] using hPd |
| let D := Q.derivative.eval f |
| let r := D.order.toNat |
| have hr : (r : ℕ∞)=D.order := MvPowerSeries.ne_zero_iff_order_finite.mp hQd |
| let H := MvPowerSeries.homogeneousComponent r D |
| have hH : H≠0 := MvPowerSeries.homogeneousComponent_of_order hr |
| have hn : {b : Lex (σ →₀ ℕ) | MvPowerSeries.coeff (ofLex b) H≠0}.Nonempty := by |
| by_contra hn |
| apply hH |
| ext d |
| have hh : MvPowerSeries.coeff d H=0 := by |
| by_contra hd |
| exact hn ⟨toLex d,hd⟩ |
| simpa only [map_zero] using hh |
| obtain ⟨a,ha,hminimal⟩ := (wellFounded_lt : |
| WellFounded ((· < ·) : Lex (σ →₀ ℕ) → _ → Prop)).has_min _ hn |
| let sp : Finset K := P.support.biUnion (fun i => (P.coeff i).coeffs) |
| let sl : Finset K := (finite_of_degree_le r).toFinset.image (fun d => MvPowerSeries.coeff d f) |
| let sd : Finset K := (finite_of_degree_le r).toFinset.image (fun d => MvPowerSeries.coeff d H) |
| let s : Finset K := sp ∪ sl ∪ sd ∪ {(MvPowerSeries.coeff (ofLex a) H)⁻¹} |
| let A := Algebra.adjoin ℤ (s : Set K) |
| have hgen {x : K} (hx : x∈s) : x∈A.toSubring := Algebra.subset_adjoin hx |
| refine ⟨A,Algebra.FiniteType.adjoin_of_finite s.finite_toSet,?_⟩ |
| have hout : f∈seriesOver A.toSubring := by |
| apply coefficients_root_mem A.toSubring Q f hQf r (le_of_eq hr) (ofLex a) ha |
| · intro u hu |
| by_contra h |
| exact hminimal (toLex u) h (by simpa only [toLex_ofLex] using hu) |
| · intro i |
| rw [mem_seriesOver] |
| intro d |
| simp only [Q,Polynomial.coeff_map,MvPowerSeries.algebraMap_apply', |
| Algebra.algebraMap_self,MvPowerSeries.map_id,RingHom.id_apply,MvPolynomial.coeff_coe] |
| by_cases hc : (P.coeff i).coeff d=0 |
| · rw [hc] |
| exact A.zero_mem |
| · apply hgen |
| have hp : P.coeff i≠0 := by intro h; exact hc (by simp [h]) |
| have hh : (P.coeff i).coeff d∈sp := |
| Finset.mem_biUnion.mpr ⟨i,Polynomial.mem_support_iff.mpr hp, |
| MvPolynomial.coeff_mem_coeffs d hc⟩ |
| exact Finset.mem_union_left _ (Finset.mem_union_left _ (Finset.mem_union_left _ hh)) |
| · rw [mem_seriesOver] |
| intro d |
| change MvPowerSeries.coeff d H∈A.toSubring |
| by_cases hd : d.degree=r |
| · apply hgen |
| have hh : MvPowerSeries.coeff d H∈sd := |
| Finset.mem_image.mpr ⟨d,(finite_of_degree_le r).mem_toFinset.mpr (le_of_eq hd),rfl⟩ |
| exact Finset.mem_union_left _ (Finset.mem_union_right _ hh) |
| · have hh : MvPowerSeries.coeff d H=0 := by |
| simp only [H,MvPowerSeries.coeff_homogeneousComponent,ite_eq_right hd] |
| rw [hh] |
| exact A.zero_mem |
| · exact hgen (Finset.mem_union_right _ (Finset.mem_singleton_self _)) |
| · intro d hd |
| apply hgen |
| have hh : MvPowerSeries.coeff d f∈sl := |
| Finset.mem_image.mpr ⟨d,(finite_of_degree_le r).mem_toFinset.mpr hd,rfl⟩ |
| exact Finset.mem_union_left _ (Finset.mem_union_left _ (Finset.mem_union_right _ hh)) |
| exact (mem_seriesOver A.toSubring f).mp hout |
|
|
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| variable {K ι : Type*} [Field K] [CharZero K] [Fintype ι] |
|
|
| |
|
|
| theorem algebraic_family_finiteType (n : ι → ℕ) |
| (f : ∀ i,MvPowerSeries (Fin (n i)) K) |
| (hf : ∀ i,IsAlgebraic (MvPolynomial (Fin (n i)) K) (f i)) (extra : Finset K) : |
| ∃ A : Subalgebra ℤ K, Algebra.FiniteType ℤ A ∧ |
| (∀ x∈extra,x∈A) ∧ ∀ i d,MvPowerSeries.coeff d (f i)∈A := by |
| classical |
| choose B hB hcoef using fun i => algebraic_series_finiteType (f i) (hf i) |
| have hfg : ∀ i,(B i).FG := fun i => (Subalgebra.fg_iff_finiteType (B i)).mpr (hB i) |
| choose gens hgens using hfg |
| let s := Finset.univ.biUnion gens ∪ extra |
| let A := Algebra.adjoin ℤ (s : Set K) |
| have hBA : ∀ i,B i≤A := by |
| intro i |
| rw [←hgens i] |
| apply Algebra.adjoin_mono |
| intro x hx |
| exact Finset.mem_union_left _ (Finset.mem_biUnion.mpr ⟨i,Finset.mem_univ i,hx⟩) |
| refine ⟨A,Algebra.FiniteType.adjoin_of_finite s.finite_toSet,?_,?_⟩ |
| · intro x hx |
| exact Algebra.subset_adjoin (Finset.mem_union_right _ hx) |
| · intro i d |
| exact hBA i (hcoef i d) |
|
|
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open scoped BigOperators |
| variable {K : Type*} [Field K] [CharZero K] {l m d c : ℕ} {n : Fin l → ℕ} |
| {e : ((i : Fin l) × Fin (n i)) ≃ Fin d ⊕ Fin c} {active : Fin m ↪ Fin l} |
|
|
| |
|
|
| structure AlgebraicData (M : TensorModel K (fun i=>Fin (n i)) m d c e active) |
| (W : TensorPrimitives K (fun i=>Fin (n i)) m M) : Prop where |
| F : ∀ i,IsAlgebraic (MvPolynomial (Fin (n i)) K) (M.F i) |
| b : ∀ i,IsAlgebraic (MvPolynomial (Fin (n (active i))) K) (M.b i) |
| H : ∀ v q,IsAlgebraic (MvPolynomial (Fin d) K) (boxSeries K m q (M.H v)) |
| G : ∀ v,IsAlgebraic (MvPolynomial (Fin c) K) (M.G v) |
| left : ∀ t v q,IsAlgebraic (MvPolynomial (Fin d) K) (boxSeries K m q (W.left t v)) |
| right : ∀ t v,IsAlgebraic (MvPolynomial (Fin c) K) (W.right t v) |
|
|
| |
|
|
| theorem algebraic_data_descends (M : TensorModel K (fun i=>Fin (n i)) m d c e active) |
| (W : TensorPrimitives K (fun i=>Fin (n i)) m M) (h : AlgebraicData M W) : |
| ∃ A : Subalgebra ℤ K, Algebra.FiniteType ℤ A.toSubring ∧ IsUnit (2 : A.toSubring) ∧ |
| Nonempty (TensorModel A.toSubring (fun i=>Fin (n i)) m d c e active) := by |
| classical |
| let V := (i : Fin l) × Fin (n i) |
| let I := Fin l ⊕ Fin m ⊕ (V × Box m) ⊕ V ⊕ (Triple m × V × Box m) ⊕ (Triple m × V) |
| let size : I → ℕ := Sum.elim n (Sum.elim (fun i=>n (active i)) |
| (Sum.elim (fun _=>d) (Sum.elim (fun _=>c) (Sum.elim (fun _=>d) (fun _=>c))))) |
| let f : ∀ i:I,MvPowerSeries (Fin (size i)) K := fun i=> |
| match i with |
| | .inl i => M.F i |
| | .inr (.inl i) => M.b i |
| | .inr (.inr (.inl (v,q))) => boxSeries K m q (M.H v) |
| | .inr (.inr (.inr (.inl v))) => M.G v |
| | .inr (.inr (.inr (.inr (.inl (t,v,q))))) => boxSeries K m q (W.left t v) |
| | .inr (.inr (.inr (.inr (.inr (t,v))))) => W.right t v |
| have hf : ∀ i,IsAlgebraic (MvPolynomial (Fin (size i)) K) (f i) := by |
| rintro (i|i) |
| · exact h.F i |
| rcases i with i|i |
| · exact h.b i |
| rcases i with i|i |
| · exact h.H i.1 i.2 |
| rcases i with i|i |
| · exact h.G i |
| rcases i with i|i |
| · exact h.left i.1 i.2.1 i.2.2 |
| · exact h.right i.1 i.2 |
| let det := (tangent K (fun i=>Fin (n i)) m e M.H M.G).det |
| obtain ⟨A,hA,hex,hcoef⟩ := algebraic_family_finiteType size f hf {(2:K)⁻¹,det⁻¹} |
| have h2inv : (2:K)⁻¹∈A := hex _ (Finset.mem_insert_self _ _) |
| have hdetinv : det⁻¹∈A := hex _ (Finset.mem_insert_of_mem (Finset.mem_singleton_self _)) |
| have hc : CoefficientsIn A.toSubring M W := { |
| F := fun i b=>hcoef (.inl i) b |
| b := fun i a=>hcoef (.inr (.inl i)) a |
| H := fun v q b=>hcoef (.inr (.inr (.inl (v,q)))) b |
| G := fun v b=>hcoef (.inr (.inr (.inr (.inl v)))) b |
| left := fun t v q b=>hcoef (.inr (.inr (.inr (.inr (.inl (t,v,q)))))) b |
| right := fun t v b=>hcoef (.inr (.inr (.inr (.inr (.inr (t,v)))))) b |
| det_inv := hdetinv } |
| refine ⟨A,hA,?_,⟨descendTensorModel A.toSubring M W hc⟩⟩ |
| apply isUnit_iff_exists_inv.mpr |
| refine ⟨⟨(2:K)⁻¹,h2inv⟩,?_⟩ |
| apply Subtype.val_injective |
| change (2:K)*(2:K)⁻¹=1 |
| exact mul_inv_cancel₀ (by norm_num) |
|
|
| end |
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| variable {K : Type*} [Field K] [CharZero K] {l m d c : ℕ} {n : Fin l → ℕ} |
| {e : ((i : Fin l) × Fin (n i)) ≃ Fin d ⊕ Fin c} {active : Fin m ↪ Fin l} |
|
|
| |
|
|
| theorem no_algebraic_tensor_model (hm : 5 ≤ m) |
| (M : TensorModel K (fun i=>Fin (n i)) m d c e active) |
| (W : TensorPrimitives K (fun i=>Fin (n i)) m M) (h : AlgebraicData M W) : False := by |
| obtain ⟨A,hA,h2,⟨M'⟩⟩ := algebraic_data_descends M W h |
| let : Algebra.FiniteType ℤ A.toSubring := hA |
| exact (no_tensor_model_finiteType (fun i=>Fin (n i)) A.toSubring h2 e hm active).false M' |
|
|
| end |
| end PD4Tensor.Spreading |
| end |
|
|
| end OAI |
|
|
