| import Mathlib |
| import OAI.Algebra.FiniteTensor.ScalarModels |
|
|
| namespace OAI |
|
|
| /-! Squarefree box coefficients and finite tensor primitives. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace PD4Tensor.Spreading |
| open scoped BigOperators |
| variable (A : Type*) [CommRing A] (m : ℕ) |
|
|
| abbrev Box := Fin m → Fin 2 |
|
|
| def boxExponent (b : Box m) : Fin m →₀ ℕ := |
| Finsupp.equivFunOnFinite.symm (fun i => (b i).val) |
|
|
| @[simp] theorem boxExponent_apply (b : Box m) (i : Fin m) : boxExponent m b i=(b i).val := by |
| simp [boxExponent] |
|
|
| theorem boxExponent_injective : Function.Injective (boxExponent m) := by |
| intro b c h |
| funext i |
| apply Fin.ext |
| simpa only [boxExponent_apply] using congrArg (fun f : Fin m →₀ ℕ => f i) h |
|
|
| theorem squareIdeal_as_monomials : squareIdeal A m = |
| Ideal.span ((fun a : Fin m →₀ ℕ => MvPolynomial.monomial a (1 : A)) '' |
| Set.range (fun i : Fin m => Finsupp.single i 2)) := by |
| unfold squareIdeal |
| congr 1 |
| ext f |
| simp only [Set.mem_range,Set.mem_image] |
| constructor |
| · rintro ⟨i,rfl⟩ |
| exact ⟨Finsupp.single i 2,⟨i,rfl⟩,MvPolynomial.X_pow_eq_monomial.symm⟩ |
| · rintro ⟨a,⟨i,rfl⟩,rfl⟩ |
| exact ⟨i,MvPolynomial.X_pow_eq_monomial⟩ |
|
|
| theorem squareIdeal_coeff_iff (f : MvPolynomial (Fin m) A) : |
| f∈squareIdeal A m ↔ ∀ b : Box m,f.coeff (boxExponent m b)=0 := by |
| classical |
| rw [squareIdeal_as_monomials,MvPolynomial.mem_ideal_span_monomial_image] |
| constructor |
| · intro hf b |
| by_contra hb |
| obtain ⟨_,⟨i,rfl⟩,hi⟩ := hf _ (MvPolynomial.mem_support_iff.mpr hb) |
| have hpi : 2≤(b i).val := by simpa only [Finsupp.single_eq_same,boxExponent_apply] using hi i |
| exact (not_le_of_gt (b i).isLt) hpi |
| · intro hf a ha |
| have hn : ¬∀ i,a i<2 := by |
| intro h |
| let b : Box m := fun i => ⟨a i,h i⟩ |
| have hab : boxExponent m b=a := by ext i; rfl |
| exact (MvPolynomial.mem_support_iff.mp ha) (hab ▸ hf b) |
| push Not at hn |
| obtain ⟨i,hi⟩ := hn |
| refine ⟨Finsupp.single i 2,⟨i,rfl⟩,?_⟩ |
| intro j |
| by_cases hji : j=i |
| · subst j |
| simpa using hi |
| · simp only [Finsupp.single_eq_of_ne hji,zero_le] |
|
|
| def boxCoeff (b : Box m) : Parameters A m →ₗ[A] A := |
| ((squareIdeal A m).restrictScalars A).liftQ (MvPolynomial.lcoeff A (boxExponent m b)) |
| (by intro f hf; exact (squareIdeal_coeff_iff A m f).mp hf b) |
|
|
| @[simp] theorem boxCoeff_mk (b : Box m) (f : MvPolynomial (Fin m) A) : |
| boxCoeff A m b (Ideal.Quotient.mk (squareIdeal A m) f)=f.coeff (boxExponent m b) := rfl |
|
|
| theorem parameters_ext (x y : Parameters A m) |
| (h : ∀ b,boxCoeff A m b x=boxCoeff A m b y) : x=y := by |
| obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x |
| obtain ⟨q,rfl⟩ := Ideal.Quotient.mk_surjective y |
| apply sub_eq_zero.mp |
| rw [←map_sub,Ideal.Quotient.eq_zero_iff_mem,squareIdeal_coeff_iff] |
| intro b |
| rw [MvPolynomial.coeff_sub,sub_eq_zero] |
| exact h b |
|
|
| variable {A m} {B : Type*} [CommRing B] |
|
|
| @[simp] theorem boxCoeff_mapParameters (f : A →+* B) (b : Box m) (x : Parameters A m) : |
| boxCoeff B m b (mapParameters f x)=f (boxCoeff A m b x) := by |
| obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x |
| change (MvPolynomial.map f p).coeff (boxExponent m b)=f (p.coeff (boxExponent m b)) |
| exact MvPolynomial.coeff_map _ _ _ |
|
|
| theorem mapParameters_injective (f : A →+* B) (hf : Function.Injective f) : |
| Function.Injective (mapParameters (m:=m) f) := by |
| intro x y h |
| apply parameters_ext A m x y |
| intro b |
| apply hf |
| rw [←boxCoeff_mapParameters,←boxCoeff_mapParameters,h] |
|
|
| variable (A m) |
|
|
| def boxMonomial (b : Box m) : Parameters A m := |
| Ideal.Quotient.mk (squareIdeal A m) (MvPolynomial.monomial (boxExponent m b) 1) |
|
|
| @[simp] theorem boxCoeff_boxMonomial (b c : Box m) : |
| boxCoeff A m b (boxMonomial A m c)=if b=c then 1 else 0 := by |
| classical |
| simp only [boxMonomial,boxCoeff_mk,MvPolynomial.coeff_monomial, |
| (boxExponent_injective m).eq_iff,eq_comm] |
|
|
| theorem sum_boxMonomial (x : Parameters A m) : |
| (∑ b : Box m,boxCoeff A m b x • boxMonomial A m b)=x := by |
| apply parameters_ext A m |
| intro b |
| simp only [map_sum,map_smul,boxCoeff_boxMonomial,smul_eq_mul,mul_ite,mul_one,mul_zero] |
| simp |
|
|
| |
| def boxSeries {σ : Type*} (b : Box m) (f : MvPowerSeries σ (Parameters A m)) : MvPowerSeries σ A := |
| fun d => boxCoeff A m b (MvPowerSeries.coeff d f) |
|
|
| @[simp] theorem coeff_boxSeries {σ : Type*} (b : Box m) |
| (f : MvPowerSeries σ (Parameters A m)) (d : σ →₀ ℕ) : |
| MvPowerSeries.coeff d (boxSeries A m b f)=boxCoeff A m b (MvPowerSeries.coeff d f) := rfl |
|
|
| theorem sum_boxSeries {σ : Type*} (f : MvPowerSeries σ (Parameters A m)) : |
| (∑ b : Box m,MvPowerSeries.C (boxMonomial A m b)* |
| MvPowerSeries.map (algebraMap A (Parameters A m)) (boxSeries A m b f))=f := by |
| ext d |
| simp only [map_sum,MvPowerSeries.coeff_C_mul,MvPowerSeries.coeff_map,coeff_boxSeries] |
| calc |
| _ = ∑ b : Box m,boxCoeff A m b (MvPowerSeries.coeff d f) • boxMonomial A m b := by |
| apply Finset.sum_congr rfl |
| intro b _ |
| rw [mul_comm] |
| exact (Algebra.smul_def (R:=A) _ _).symm |
| _ = _ := sum_boxMonomial A m (MvPowerSeries.coeff d f) |
|
|
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| open scoped BigOperators |
| variable {A B : Type*} [CommRing A] [CommRing B] {m : ℕ} |
|
|
| @[simp] theorem map_boxMonomial (f : A →+* B) (b : Box m) : |
| mapParameters f (boxMonomial A m b)=boxMonomial B m b := by |
| change Ideal.Quotient.mk (squareIdeal B m) (MvPolynomial.map f (MvPolynomial.monomial _ 1))=_ |
| rw [MvPolynomial.map_monomial,map_one] |
| rfl |
|
|
| theorem sub_constant_parameters_mem (a : Parameters A m) : |
| a-algebraMap A (Parameters A m) (augmentation A m a)∈parameterIdeal A m := by |
| refine Quotient.inductionOn' a ?_ |
| intro p |
| change Ideal.Quotient.mk (squareIdeal A m) p - |
| algebraMap A (Parameters A m) (augmentation A m (Ideal.Quotient.mk (squareIdeal A m) p))∈_ |
| induction p using MvPolynomial.induction_on with |
| | C c => |
| change algebraMap A (Parameters A m) c-algebraMap A (Parameters A m) |
| (augmentation A m (algebraMap A (Parameters A m) c))∈_ |
| simp |
| | add p q hp hq => |
| simpa only [map_add,add_sub_add_comm] using (parameterIdeal A m).add_mem hp hq |
| | mul_X p i _ => |
| simp only [map_mul,show Ideal.Quotient.mk (squareIdeal A m) (MvPolynomial.X i)=parameter A m i from rfl, |
| augmentation_parameter,mul_zero,map_zero,sub_zero] |
| exact Ideal.mul_mem_left _ _ (Ideal.subset_span (Set.mem_range_self i)) |
| |
| theorem augmentation_eq_zero_of_mem {a : Parameters A m} (ha : a∈parameterIdeal A m) : |
| augmentation A m a=0 := by |
| have hh : parameterIdeal A m≤RingHom.ker (augmentation A m) := by |
| apply Ideal.span_le.mpr |
| rintro _ ⟨i,rfl⟩ |
| exact augmentation_parameter A m i |
| exact hh ha |
| |
| theorem mem_parameterIdeal_iff (a : Parameters A m) : |
| a∈parameterIdeal A m ↔ augmentation A m a=0 := by |
| constructor |
| · exact augmentation_eq_zero_of_mem |
| · intro ha |
| simpa only [ha,map_zero,sub_zero] using sub_constant_parameters_mem a |
| |
| theorem mapParameters_mem_iff (f : A →+* B) (hf : Function.Injective f) |
| (a : Parameters A m) : mapParameters f a∈parameterIdeal B m ↔ a∈parameterIdeal A m := by |
| simp only [mem_parameterIdeal_iff,augmentation_mapParameters] |
| exact (map_eq_zero_iff f hf) |
| |
| variable {K σ : Type*} [Field K] (R : Subring K) |
| |
| |
| def liftParameterSeries (f : MvPowerSeries σ (Parameters K m)) |
| (hf : ∀ b d,MvPowerSeries.coeff d (boxSeries K m b f)∈R) : |
| MvPowerSeries σ (Parameters R m) := |
| ∑ b : Box m,MvPowerSeries.C (boxMonomial R m b)* |
| MvPowerSeries.map (algebraMap R (Parameters R m)) |
| (MvPowerSeries.toSubring (boxSeries K m b f) R (hf b)) |
| |
| theorem map_liftParameterSeries (f : MvPowerSeries σ (Parameters K m)) |
| (hf : ∀ b d,MvPowerSeries.coeff d (boxSeries K m b f)∈R) : |
| MvPowerSeries.map (mapParameters R.subtype) (liftParameterSeries R f hf)=f := by |
| calc |
| _ = ∑ b : Box m,MvPowerSeries.C (boxMonomial K m b)* |
| MvPowerSeries.map (algebraMap K (Parameters K m)) (boxSeries K m b f) := by |
| rw [liftParameterSeries,map_sum] |
| apply Finset.sum_congr rfl |
| intro b _ |
| rw [map_mul,MvPowerSeries.map_C,map_boxMonomial] |
| congr 1 |
| ext d |
| simp only [MvPowerSeries.coeff_map,mapParameters_algebraMap] |
| rfl |
| _ = f := sum_boxSeries K m f |
| |
| end PD4Tensor.Spreading |
| |
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open scoped BigOperators |
| universe u |
| variable (A : Type*) [CommRing A] {l : ℕ} (σ : Fin l → Type u) |
| [∀ i,Fintype (σ i)] [∀ i,DecidableEq (σ i)] (m : ℕ) |
| |
| abbrev Triple := {p : Fin m × Fin m × Fin m // |
| p.1≠p.2.1 ∧ p.1≠p.2.2 ∧ p.2.1≠p.2.2} |
| |
| |
| |
| structure TensorPrimitives {d c : ℕ} {e : ((i : Fin l) × σ i) ≃ Fin d ⊕ Fin c} |
| {active : Fin m ↪ Fin l} (M : TensorModel A σ m d c e active) where |
| left : Triple m → ((i : Fin l) × σ i) → MvPowerSeries (Fin d) (Parameters A m) |
| right : Triple m → ((i : Fin l) × σ i) → MvPowerSeries (Fin c) A |
| left_eq : ∀ q, (∑ v,left q v*MvPowerSeries.subst M.H |
| (MvPowerSeries.pderiv v (deformed A σ m M.F active M.b)))= |
| MvPowerSeries.C (parameter A m q.val.1*parameter A m q.val.2.1*parameter A m q.val.2.2) |
| right_eq : ∀ q, (∑ v,right q v*MvPowerSeries.subst M.G |
| (MvPowerSeries.pderiv v (potential A σ M.F)))= |
| MvPowerSeries.subst M.G (perturbation A σ m active M.b q.val.1* |
| perturbation A σ m active M.b q.val.2.1*perturbation A σ m active M.b q.val.2.2) |
| |
| |
| |
| theorem exists_tensorPrimitives {d c : ℕ} {e : ((i : Fin l) × σ i) ≃ Fin d ⊕ Fin c} |
| {active : Fin m ↪ Fin l} (M : TensorModel A σ m d c e active) : |
| Nonempty (TensorPrimitives A σ m M) := by |
| classical |
| have hL : ∀ q : Triple m, ∃ a : ((i : Fin l) × σ i) → _, |
| (∑ v,a v*MvPowerSeries.subst M.H |
| (MvPowerSeries.pderiv v (deformed A σ m M.F active M.b)))= |
| MvPowerSeries.C (parameter A m q.val.1*parameter A m q.val.2.1*parameter A m q.val.2.2) := by |
| intro q |
| exact Ideal.mem_span_range_iff_exists_fun.mp |
| (M.left_triple _ _ _ q.property.1 q.property.2.1 q.property.2.2) |
| have hR : ∀ q : Triple m, ∃ a : ((i : Fin l) × σ i) → _, |
| (∑ v,a v*MvPowerSeries.subst M.G (MvPowerSeries.pderiv v (potential A σ M.F)))= |
| MvPowerSeries.subst M.G (perturbation A σ m active M.b q.val.1* |
| perturbation A σ m active M.b q.val.2.1*perturbation A σ m active M.b q.val.2.2) := by |
| intro q |
| exact Ideal.mem_span_range_iff_exists_fun.mp |
| (M.right_triple _ _ _ q.property.1 q.property.2.1 q.property.2.2) |
| choose L hL using hL |
| choose R hR using hR |
| exact ⟨⟨L,R,hL,hR⟩⟩ |
| |
| end |
| end PD4Tensor.Spreading |
| end |
| |
| end OAI |
| |
