| import Mathlib | |
| namespace OAI | |
| /-! Quadratic remainders, adic contraction and Tougeron corrections. -/ | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators | |
| open MvPolynomial | |
| variable {R σ : Type*} [CommRing R] [Fintype σ] [DecidableEq σ] | |
| def mvShift (a : σ → R) : MvPolynomial σ R →ₐ[R] MvPolynomial σ R := | |
| aeval (fun i=>C (a i)+X i) | |
| def mvLinearPart (a : σ → R) (f : MvPolynomial σ R) : MvPolynomial σ R := | |
| ∑ i : σ,C (eval a (pderiv i f))*X i | |
| def mvRemainder (a : σ → R) (f : MvPolynomial σ R) : MvPolynomial σ R := | |
| mvShift a f-C (eval a f)-mvLinearPart a f | |
| private theorem mvLinearPart_mul_X (a : σ → R) (f : MvPolynomial σ R) (k : σ) : | |
| mvLinearPart a (f*X k)=mvLinearPart a f*C (a k)+C (eval a f)*X k := by | |
| simp only [mvLinearPart,pderiv_mul,map_add,map_mul,eval_X,add_mul, | |
| Finset.sum_add_distrib] | |
| congr 1 | |
| · rw [Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| ring | |
| · rw [Finset.sum_eq_single k] | |
| · simp | |
| · intro i hi hik | |
| simp [pderiv_X,Ne.symm hik] | |
| · simp | |
| private theorem mvRemainder_mul_X (a : σ → R) (f : MvPolynomial σ R) (k : σ) : | |
| mvRemainder a (f*X k)=mvRemainder a f*(C (a k)+X k)+mvLinearPart a f*X k := by | |
| rw [mvRemainder,mvRemainder,mvLinearPart_mul_X] | |
| simp only [map_mul,eval_X,mvShift,aeval_X] | |
| ring | |
| private theorem mvRemainder_mem (a : σ → R) (f : MvPolynomial σ R) : | |
| mvRemainder a f ∈ Ideal.span (Set.range (fun ij : σ×σ=>(X ij.1*X ij.2 : MvPolynomial σ R))) := by | |
| let J : Ideal (MvPolynomial σ R) := Ideal.span (Set.range (fun ij : σ×σ=>X ij.1*X ij.2)) | |
| change mvRemainder a f∈J | |
| induction f using MvPolynomial.induction_on with | |
| | C r => | |
| have h : mvRemainder a (C r)=0 := by | |
| simp only [mvRemainder,mvShift,aeval_C,eval_C,mvLinearPart,pderiv_C, | |
| map_zero,zero_mul,Finset.sum_const_zero,sub_zero] | |
| change C r-C r=0 | |
| exact sub_self _ | |
| rw [h] | |
| exact J.zero_mem | |
| | add f g hf hg => | |
| have h : mvRemainder a (f+g)=mvRemainder a f+mvRemainder a g := by | |
| simp only [mvRemainder,map_add,mvLinearPart,map_add,add_mul,Finset.sum_add_distrib] | |
| ring | |
| rw [h] | |
| exact J.add_mem hf hg | |
| | mul_X f k hf => | |
| rw [mvRemainder_mul_X] | |
| apply J.add_mem (J.mul_mem_right _ hf) | |
| rw [mvLinearPart,Finset.sum_mul] | |
| apply J.sum_mem | |
| intro i hi | |
| have h : X i*X k∈J := Ideal.subset_span (Set.mem_range_self (i,k)) | |
| simpa only [mul_assoc] using J.mul_mem_left (C (eval a (pderiv i f))) h | |
| theorem mv_polynomial_quadratic_remainder (f : MvPolynomial σ R) (a : σ → R) : | |
| ∃ q : σ → σ → MvPolynomial σ R, | |
| mvShift a f=C (eval a f)+mvLinearPart a f+ | |
| ∑ i : σ,∑ j : σ,X i*X j*q i j := by | |
| obtain ⟨q,hq⟩ := Ideal.mem_span_range_iff_exists_fun.mp (mvRemainder_mem a f) | |
| refine ⟨fun i j=>q (i,j),?_⟩ | |
| have he : (∑ i : σ,∑ j : σ,X i*X j*q (i,j))=mvRemainder a f := by | |
| rw [←Finset.sum_product'] | |
| rw [Finset.univ_product_univ] | |
| calc | |
| _ = ∑ ij : σ×σ,q ij*(X ij.1*X ij.2) := by | |
| apply Finset.sum_congr rfl | |
| intro ij hij | |
| cases ij | |
| exact mul_comm _ _ | |
| _ = _ := hq | |
| rw [he,mvRemainder] | |
| ring | |
| theorem mv_eval_quadratic_remainder (f : MvPolynomial σ R) (a : σ → R) : | |
| ∃ q : σ → σ → MvPolynomial σ R,∀ h : σ → R, | |
| eval (a+h) f=eval a f+(∑ i : σ,eval a (pderiv i f)*h i)+ | |
| ∑ i : σ,∑ j : σ,h i*h j*eval h (q i j) := by | |
| obtain ⟨q,hq⟩ := mv_polynomial_quadratic_remainder f a | |
| refine ⟨q,?_⟩ | |
| intro h | |
| have he := congrArg (eval h) hq | |
| have hshift : eval h (mvShift a f)=eval (a+h) f := by | |
| have hh : (eval h).comp (mvShift a).toRingHom=eval (a+h) := by | |
| apply MvPolynomial.ringHom_ext | |
| · intro r | |
| simp only [RingHom.comp_apply,mvShift,AlgHom.toRingHom_eq_coe, | |
| AlgHom.coe_toRingHom,aeval_C,algebraMap_eq,eval_C] | |
| · intro i | |
| change eval h ((aeval (fun i=>C (a i)+X i)) (X i)) = _ | |
| simp only [aeval_X,map_add,eval_C,eval_X,Pi.add_apply] | |
| exact RingHom.congr_fun hh f | |
| simpa only [hshift,map_add,map_sum,map_mul,eval_C,eval_X,mvLinearPart] | |
| using he | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators | |
| open MvPolynomial | |
| variable {R σ : Type*} [CommRing R] [Fintype σ] [DecidableEq σ] | |
| omit [Fintype σ] [DecidableEq σ] in | |
| theorem mv_eval_sub_mem (J : Ideal R) (f : MvPolynomial σ R) (u v : σ → R) | |
| (h : ∀ i,u i-v i∈J) : eval u f-eval v f∈J := by | |
| apply Ideal.Quotient.eq_zero_iff_mem.mp | |
| rw [map_sub,sub_eq_zero] | |
| have he : (Ideal.Quotient.mk J).comp (eval u)=(Ideal.Quotient.mk J).comp (eval v) := by | |
| apply MvPolynomial.ringHom_ext | |
| · intro r | |
| simp | |
| · intro i | |
| simp only [RingHom.comp_apply,eval_X] | |
| exact sub_eq_zero.mp ((map_sub _ _ _).symm.trans (Ideal.Quotient.eq_zero_iff_mem.mpr (h i))) | |
| exact RingHom.congr_fun he f | |
| omit [DecidableEq σ] in | |
| theorem mv_quadratic_sub_mem (I : Ideal R) (n : ℕ) | |
| (q : σ → σ → MvPolynomial σ R) (u v : σ → R) | |
| (hu : ∀i,u i∈I) (hv : ∀i,v i∈I) (h : ∀i,u i-v i∈I^n) : | |
| (∑ i : σ,∑ j : σ,u i*u j*eval u (q i j))- | |
| (∑ i : σ,∑ j : σ,v i*v j*eval v (q i j))∈I^(n+1) := by | |
| rw [←Finset.sum_sub_distrib] | |
| apply Ideal.sum_mem | |
| intro i hi | |
| rw [←Finset.sum_sub_distrib] | |
| apply Ideal.sum_mem | |
| intro j hj | |
| have he : u i*u j*eval u (q i j)-v i*v j*eval v (q i j)= | |
| (u i-v i)*u j*eval u (q i j)+ | |
| v i*(u j-v j)*eval u (q i j)+ | |
| v i*v j*(eval u (q i j)-eval v (q i j)) := by ring | |
| rw [he] | |
| apply Ideal.add_mem | |
| · apply Ideal.add_mem | |
| · apply Ideal.mul_mem_right | |
| rw [pow_succ] | |
| exact Ideal.mul_mem_mul (h i) (hu j) | |
| · apply Ideal.mul_mem_right | |
| rw [pow_succ'] | |
| exact Ideal.mul_mem_mul (hv i) (h j) | |
| · rw [mul_assoc] | |
| apply Ideal.mul_mem_left | |
| rw [pow_succ'] | |
| exact Ideal.mul_mem_mul (hv j) (mv_eval_sub_mem _ _ _ _ h) | |
| omit [DecidableEq σ] in | |
| theorem adic_quadratic_system (I : Ideal R) [IsAdicComplete I R] | |
| (e : σ → R) (he : ∀i,e i∈I) (q : σ → σ → σ → MvPolynomial σ R) : | |
| ∃ z : σ → R,(∀i,z i∈I) ∧ ∀k, | |
| e k+z k+∑ i : σ,∑ j : σ,z i*z j*eval z (q k i j)=0 := by | |
| let Q (z : σ → R) (k : σ) : R := ∑ i : σ,∑ j : σ,z i*z j*eval z (q k i j) | |
| let c : ℕ → σ → R := fun n=>Nat.recOn n 0 (fun _ z k=>-e k-Q z k) | |
| have hc (n : ℕ) (k : σ) : c (n+1) k=-e k-Q (c n) k := rfl | |
| have hmem : ∀ n k,c n k∈I := by | |
| intro n | |
| induction n with | |
| | zero => intro k; exact I.zero_mem | |
| | succ n ih => | |
| intro k | |
| rw [hc] | |
| apply I.sub_mem (I.neg_mem (he k)) | |
| apply I.sum_mem | |
| intro i hi | |
| apply I.sum_mem | |
| intro j hj | |
| exact I.mul_mem_right _ (I.mul_mem_right _ (ih i)) | |
| have hstep : ∀ n k,c (n+1) k-c n k∈I^(n+1) := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro k | |
| simpa only [Nat.zero_add,pow_one,show c 0 k=0 from rfl,sub_zero] using hmem 1 k | |
| | succ n ih => | |
| intro k | |
| rw [hc (n+1),hc n] | |
| have hh := mv_quadratic_sub_mem I (n+1) (q k) (c (n+1)) (c n) | |
| (hmem (n+1)) (hmem n) ih | |
| have heq : -e k-Q (c (n+1)) k-(-e k-Q (c n) k)= | |
| -(Q (c (n+1)) k-Q (c n) k) := by ring | |
| rw [heq] | |
| exact (I^((n+1)+1)).neg_mem hh | |
| have hdiff : ∀ m n,m ≤ n → ∀k,c m k-c n k∈I^m := by | |
| intro m n hmn | |
| obtain ⟨l,rfl⟩ := Nat.exists_eq_add_of_le hmn | |
| induction l with | |
| | zero => intro k; simp only [add_zero,sub_self]; exact Ideal.zero_mem _ | |
| | succ l ih => | |
| intro k | |
| have ha := Ideal.pow_le_pow_right (by omega : m ≤ m+l+1) (hstep (m+l) k) | |
| have hb := (I^m).sub_mem (ih (by omega) k) ha | |
| convert hb using 1 | |
| simp only [Nat.add_assoc] | |
| ring | |
| have hex : ∀k,∃z : R,∀n,c n k-z∈I^n := by | |
| intro k | |
| obtain ⟨z,hz⟩ := IsPrecomplete.prec' (I:=I) (fun n=>c n k) (by | |
| intro m n hmn | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one] | |
| exact SModEq.sub_mem.mpr (hdiff m n hmn k)) | |
| refine ⟨z,?_⟩ | |
| intro n | |
| specialize hz n | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one] at hz | |
| exact SModEq.sub_mem.mp hz | |
| choose z hz using hex | |
| have hzi (k : σ) : z k∈I := by | |
| have hh := hz k 1 | |
| rw [pow_one] at hh | |
| have h := I.sub_mem (hmem 1 k) hh | |
| simpa only [sub_sub_cancel] using h | |
| refine ⟨z,hzi,?_⟩ | |
| intro k | |
| apply IsHausdorff.haus' (I:=I) | |
| intro n | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one,SModEq.zero] | |
| have hq := mv_quadratic_sub_mem I n (q k) (c n) z (hmem n) hzi (fun i=>hz i n) | |
| have hqn : Q (c n) k-Q z k∈I^n := | |
| Ideal.pow_le_pow_right (by omega : n ≤ n+1) hq | |
| have hcn : c (n+1) k-z k∈I^n := | |
| Ideal.pow_le_pow_right (by omega : n ≤ n+1) (hz k (n+1)) | |
| have hh := (I^n).neg_mem ((I^n).add_mem hcn hqn) | |
| rw [hc] at hh | |
| convert hh using 1 | |
| dsimp only [Q] | |
| ring | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators | |
| open MvPolynomial | |
| variable {R σ : Type*} [CommRing R] [Fintype σ] [DecidableEq σ] | |
| omit [Fintype σ] [DecidableEq σ] in | |
| theorem adic_contractive_system (I : Ideal R) [IsAdicComplete I R] | |
| (e : σ → R) (he : ∀ i,e i∈I) (Q : (σ → R) → σ → R) | |
| (hQI : ∀ z,(∀ i,z i∈I) → ∀ k,Q z k∈I) | |
| (hQC : ∀ n u v,(∀ i,u i∈I) → (∀ i,v i∈I) → | |
| (∀ i,u i-v i∈I^n) → ∀ k,Q u k-Q v k∈I^(n+1)) : | |
| ∃ z : σ → R,(∀ i,z i∈I) ∧ ∀ k,e k+z k+Q z k=0 := by | |
| let c : ℕ → σ → R := fun n=>Nat.recOn n 0 (fun _ z k=>-e k-Q z k) | |
| have hc (n : ℕ) (k : σ) : c (n+1) k=-e k-Q (c n) k := rfl | |
| have hmem : ∀ n k,c n k∈I := by | |
| intro n | |
| induction n with | |
| | zero => intro k; exact I.zero_mem | |
| | succ n ih => | |
| intro k | |
| rw [hc] | |
| apply I.sub_mem (I.neg_mem (he k)) | |
| exact hQI (c n) ih k | |
| have hstep : ∀ n k,c (n+1) k-c n k∈I^(n+1) := by | |
| intro n | |
| induction n with | |
| | zero => | |
| intro k | |
| simpa only [Nat.zero_add,pow_one,show c 0 k=0 from rfl,sub_zero] using hmem 1 k | |
| | succ n ih => | |
| intro k | |
| rw [hc (n+1),hc n] | |
| have hh := hQC (n+1) (c (n+1)) (c n) (hmem (n+1)) (hmem n) ih k | |
| have heq : -e k-Q (c (n+1)) k-(-e k-Q (c n) k)= | |
| -(Q (c (n+1)) k-Q (c n) k) := by ring | |
| rw [heq] | |
| exact (I^((n+1)+1)).neg_mem hh | |
| have hdiff : ∀ m n,m ≤ n → ∀k,c m k-c n k∈I^m := by | |
| intro m n hmn | |
| obtain ⟨l,rfl⟩ := Nat.exists_eq_add_of_le hmn | |
| induction l with | |
| | zero => intro k; simp only [add_zero,sub_self]; exact Ideal.zero_mem _ | |
| | succ l ih => | |
| intro k | |
| have ha := Ideal.pow_le_pow_right (by omega : m ≤ m+l+1) (hstep (m+l) k) | |
| have hb := (I^m).sub_mem (ih (by omega) k) ha | |
| convert hb using 1 | |
| simp only [Nat.add_assoc] | |
| ring | |
| have hex : ∀k,∃z : R,∀n,c n k-z∈I^n := by | |
| intro k | |
| obtain ⟨z,hz⟩ := IsPrecomplete.prec' (I:=I) (fun n=>c n k) (by | |
| intro m n hmn | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one] | |
| exact SModEq.sub_mem.mpr (hdiff m n hmn k)) | |
| refine ⟨z,?_⟩ | |
| intro n | |
| specialize hz n | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one] at hz | |
| exact SModEq.sub_mem.mp hz | |
| choose z hz using hex | |
| have hzi (k : σ) : z k∈I := by | |
| have hh := hz k 1 | |
| rw [pow_one] at hh | |
| have h := I.sub_mem (hmem 1 k) hh | |
| simpa only [sub_sub_cancel] using h | |
| refine ⟨z,hzi,?_⟩ | |
| intro k | |
| apply IsHausdorff.haus' (I:=I) | |
| intro n | |
| rw [←Ideal.one_eq_top,Ideal.smul_eq_mul,mul_one,SModEq.zero] | |
| have hq := hQC n (c n) z (hmem n) hzi (fun i=>hz i n) k | |
| have hqn : Q (c n) k-Q z k∈I^n := | |
| Ideal.pow_le_pow_right (by omega : n ≤ n+1) hq | |
| have hcn : c (n+1) k-z k∈I^n := | |
| Ideal.pow_le_pow_right (by omega : n ≤ n+1) (hz k (n+1)) | |
| have hh := (I^n).neg_mem ((I^n).add_mem hcn hqn) | |
| rw [hc] at hh | |
| convert hh using 1 | |
| ring | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators Matrix | |
| open MvPolynomial | |
| variable {R σ : Type*} [CommRing R] [Fintype σ] [DecidableEq σ] | |
| omit [DecidableEq σ] in | |
| theorem mv_quadratic_mixed_sub_mem (I : Ideal R) (n : ℕ) | |
| (q : σ → σ → MvPolynomial σ R) (u v u' v' : σ → R) | |
| (hu : ∀i,u i∈I) (hv : ∀i,v i∈I) (h : ∀i,u i-v i∈I^n) (h' : ∀i,u' i-v' i∈I^n) : | |
| (∑ i : σ,∑ j : σ,u i*u j*eval u' (q i j))- | |
| (∑ i : σ,∑ j : σ,v i*v j*eval v' (q i j))∈I^(n+1) := by | |
| rw [←Finset.sum_sub_distrib] | |
| apply Ideal.sum_mem | |
| intro i hi | |
| rw [←Finset.sum_sub_distrib] | |
| apply Ideal.sum_mem | |
| intro j hj | |
| have he : u i*u j*eval u' (q i j)-v i*v j*eval v' (q i j)= | |
| (u i-v i)*u j*eval u' (q i j)+ | |
| v i*(u j-v j)*eval u' (q i j)+ | |
| v i*v j*(eval u' (q i j)-eval v' (q i j)) := by ring | |
| rw [he] | |
| apply Ideal.add_mem | |
| · apply Ideal.add_mem | |
| · apply Ideal.mul_mem_right | |
| rw [pow_succ] | |
| exact Ideal.mul_mem_mul (h i) (hu j) | |
| · apply Ideal.mul_mem_right | |
| rw [pow_succ'] | |
| exact Ideal.mul_mem_mul (hv i) (h j) | |
| · rw [mul_assoc] | |
| apply Ideal.mul_mem_left | |
| rw [pow_succ'] | |
| exact Ideal.mul_mem_mul (hv j) (mv_eval_sub_mem _ _ _ _ h') | |
| omit [DecidableEq σ] in | |
| private theorem mulVec_mem_ideal (I : Ideal R) (A : Matrix σ σ R) (z : σ → R) | |
| (hz : ∀ i,z i∈I) (k : σ) : (A*ᵥz) k∈I := by | |
| apply I.sum_mem | |
| intro i hi | |
| exact I.mul_mem_left _ (hz i) | |
| omit [DecidableEq σ] in | |
| private theorem mulVec_sub_mem_ideal (I : Ideal R) (A : Matrix σ σ R) (u v : σ → R) | |
| (h : ∀ i,u i-v i∈I) (k : σ) : (A*ᵥu) k-(A*ᵥv) k∈I := by | |
| rw [←Pi.sub_apply,←Matrix.mulVec_sub] | |
| exact mulVec_mem_ideal I A (u-v) h k | |
| theorem mv_tougeron_correction (I : Ideal R) [IsAdicComplete I R] | |
| (f : σ → MvPolynomial σ R) (a e : σ → R) | |
| (he : ∀ k,e k∈I) | |
| (hf : ∀ k,eval a (f k)= | |
| (Matrix.det (fun k i=>eval a (pderiv i (f k))))^2*e k) : | |
| ∃ b : σ → R,(∀ k,eval b (f k)=0) ∧ ∀ i,∃ v∈I, | |
| b i=a i+(Matrix.det (fun k i=>eval a (pderiv i (f k))))*v := by | |
| let J : Matrix σ σ R := fun k i=>eval a (pderiv i (f k)) | |
| let δ : R := J.det | |
| let A : Matrix σ σ R := J.adjugate | |
| choose q hq using fun k=>mv_eval_quadratic_remainder (f k) a | |
| let Q (z : σ → R) (k : σ) : R := | |
| ∑ i : σ,∑ j : σ,(A*ᵥz) i*(A*ᵥz) j*eval (δ • (A*ᵥz)) (q k i j) | |
| have hQI (z : σ → R) (hz : ∀ i,z i∈I) (k : σ) : Q z k∈I := by | |
| apply I.sum_mem | |
| intro i hi | |
| apply I.sum_mem | |
| intro j hj | |
| exact I.mul_mem_right _ (I.mul_mem_right _ (mulVec_mem_ideal I A z hz i)) | |
| have hQC (n : ℕ) (u v : σ → R) (hu : ∀ i,u i∈I) (hv : ∀ i,v i∈I) | |
| (huv : ∀ i,u i-v i∈I^n) (k : σ) : Q u k-Q v k∈I^(n+1) := by | |
| apply mv_quadratic_mixed_sub_mem I n (q k) (A*ᵥu) (A*ᵥv) | |
| (δ • (A*ᵥu)) (δ • (A*ᵥv)) | |
| (mulVec_mem_ideal I A u hu) (mulVec_mem_ideal I A v hv) | |
| (mulVec_sub_mem_ideal (I^n) A u v huv) | |
| intro i | |
| simpa only [Pi.smul_apply,smul_eq_mul,mul_sub] using | |
| (I^n).mul_mem_left δ (mulVec_sub_mem_ideal (I^n) A u v huv i) | |
| obtain ⟨z,hz,hroot⟩ := adic_contractive_system I e he Q hQI hQC | |
| let h : σ → R := δ • (A*ᵥz) | |
| have hlin : J*ᵥh=δ^2 • z := by | |
| dsimp only [h,A] | |
| rw [Matrix.mulVec_smul,Matrix.mulVec_mulVec,Matrix.mul_adjugate, | |
| Matrix.smul_mulVec,Matrix.one_mulVec,smul_smul] | |
| simp only [δ,pow_two] | |
| refine ⟨a+h,?_,?_⟩ | |
| · intro k | |
| rw [hq k h,hf k] | |
| have hl : (∑ i : σ,eval a (pderiv i (f k))*h i)=δ^2*z k := by | |
| exact congrFun hlin k | |
| rw [hl] | |
| have hquad : (∑ i : σ,∑ j : σ,h i*h j*eval h (q k i j))=δ^2*Q z k := by | |
| dsimp only [Q,h] | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro j hj | |
| simp only [Pi.smul_apply,smul_eq_mul] | |
| ring | |
| rw [hquad] | |
| change δ^2*e k+δ^2*z k+δ^2*Q z k=0 | |
| rw [←mul_add,←mul_add,hroot k,mul_zero] | |
| · intro i | |
| refine ⟨(A*ᵥz) i,mulVec_mem_ideal I A z hz i,?_⟩ | |
| rfl | |
| end | |
| end PD4Tensor.Spreading | |
| namespace PD4Tensor.Spreading | |
| noncomputable section | |
| open scoped BigOperators Matrix | |
| open MvPolynomial | |
| variable {R σ : Type*} [CommRing R] [Fintype σ] [DecidableEq σ] | |
| private theorem det_sub_mem_ideal (I : Ideal R) (A B : Matrix σ σ R) | |
| (h : ∀ i j,A i j-B i j∈I) : A.det-B.det∈I := by | |
| apply Ideal.Quotient.eq_zero_iff_mem.mp | |
| rw [map_sub,sub_eq_zero,RingHom.map_det,RingHom.map_det] | |
| congr 1 | |
| ext i j | |
| change Ideal.Quotient.mk I (A i j)=Ideal.Quotient.mk I (B i j) | |
| exact sub_eq_zero.mp ((map_sub _ _ _).symm.trans (Ideal.Quotient.eq_zero_iff_mem.mpr (h i j))) | |
| theorem corrected_jacobian_factor (I : Ideal R) (f : σ → MvPolynomial σ R) | |
| (a b : σ → R) | |
| (hab : ∀ i,∃ v∈I,b i=a i+(Matrix.det (fun k j=>eval a (pderiv j (f k))))*v) : | |
| ∃ r∈I,Matrix.det (fun k j=>eval b (pderiv j (f k)))= | |
| (Matrix.det (fun k j=>eval a (pderiv j (f k))))*(1+r) := by | |
| let δ := Matrix.det (fun k j=>eval a (pderiv j (f k))) | |
| have hc (i : σ) : b i-a i∈Ideal.span {δ}*I := by | |
| obtain ⟨v,hv,h⟩ := hab i | |
| apply Ideal.mem_span_singleton_mul.mpr | |
| exact ⟨v,hv,by rw [h]; ring⟩ | |
| have hdet := det_sub_mem_ideal (Ideal.span {δ}*I) | |
| (fun k j=>eval b (pderiv j (f k))) (fun k j=>eval a (pderiv j (f k))) | |
| (fun k j=>mv_eval_sub_mem _ _ _ _ hc) | |
| obtain ⟨r,hr,heq⟩ := Ideal.mem_span_singleton_mul.mp hdet | |
| refine ⟨r,hr,?_⟩ | |
| change _=δ*(1+r) | |
| change δ*r=Matrix.det (fun k j=>eval b (pderiv j (f k)))-δ at heq | |
| linear_combination -heq | |
| theorem mv_tougeron_nondegenerate [IsDomain R] (I : Ideal R) [IsAdicComplete I R] | |
| (f : σ → MvPolynomial σ R) (a e : σ → R) | |
| (he : ∀ k,e k∈I) | |
| (hJ : Matrix.det (fun k i=>eval a (pderiv i (f k)))≠0) | |
| (hf : ∀ k,eval a (f k)= | |
| (Matrix.det (fun k i=>eval a (pderiv i (f k))))^2*e k) : | |
| ∃ b : σ → R,(∀ k,eval b (f k)=0) ∧ | |
| (Matrix.det (fun k i=>eval b (pderiv i (f k)))≠0) ∧ | |
| ∀ i,∃ v∈I,b i=a i+(Matrix.det (fun k j=>eval a (pderiv j (f k))))*v := by | |
| obtain ⟨b,hb,hclose⟩ := mv_tougeron_correction I f a e he hf | |
| obtain ⟨r,hr,hfactor⟩ := corrected_jacobian_factor I f a b hclose | |
| refine ⟨b,hb,?_,hclose⟩ | |
| rw [hfactor] | |
| apply mul_ne_zero hJ | |
| have hu : IsUnit (1+r) := by | |
| simpa only [mul_one,add_comm] using | |
| (Ideal.mem_jacobson_bot.mp (IsAdicComplete.le_jacobson_bot I hr) 1) | |
| exact hu.ne_zero | |
| end | |
| end PD4Tensor.Spreading | |
| end | |
| end OAI | |