| import Mathlib |
| import OAI.Algebra.FiniteTensor.JetTopology |
|
|
| namespace OAI |
|
|
| /-! Regular linear charts and polynomial compatibility of coordinate changes. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open scoped BigOperators |
| open MvPolynomial |
|
|
| |
| theorem totalDegree_eval₂_linear {K σ τ : Type*} [CommSemiring K] |
| (p : MvPolynomial σ K) (q : σ → MvPolynomial τ K) |
| (hq : ∀ i,(q i).totalDegree≤1) : |
| (eval₂ C q p).totalDegree≤p.totalDegree := by |
| classical |
| have hm (d : σ →₀ ℕ) (c : K) : |
| (eval₂ C q (monomial d c)).totalDegree≤d.sum (fun _ e=>e) := by |
| rw [eval₂_monomial] |
| apply (totalDegree_mul _ _).trans |
| rw [totalDegree_C,zero_add] |
| apply (totalDegree_finsetProd d.support _).trans |
| apply Finset.sum_le_sum |
| intro i hi |
| exact (totalDegree_pow _ _).trans (by simpa using Nat.mul_le_mul_left (d i) (hq i)) |
| change ((eval₂Hom C q) p).totalDegree≤p.totalDegree |
| conv_lhs => rw [p.as_sum,map_sum] |
| apply totalDegree_finsetSum_le |
| intro d hd |
| exact (hm d _).trans (le_totalDegree hd) |
|
|
| |
| theorem coe_eval₂_polynomials {K σ τ : Type*} [CommRing K] |
| (p : MvPolynomial σ K) (q : σ → MvPolynomial τ K) : |
| ((eval₂ C q p : MvPolynomial τ K) : MvPowerSeries τ K) = |
| MvPowerSeries.subst (fun i=>(q i : MvPowerSeries τ K)) (p : MvPowerSeries σ K) := by |
| rw [MvPowerSeries.subst_coe] |
| have he : MvPolynomial.coeToMvPowerSeries.ringHom.comp (eval₂Hom C q) = |
| (aeval (fun i=>(q i : MvPowerSeries τ K))).toRingHom := by |
| apply MvPolynomial.ringHom_ext |
| · intro c |
| simp [MvPowerSeries.algebraMap_apply] |
| · intro i |
| simp |
| exact RingHom.congr_fun he p |
|
|
| |
|
|
| theorem exists_nonzero_line {K σ : Type*} [Field K] [Infinite K] [Finite σ] |
| (f : MvPowerSeries σ K) (hf : f≠0) : |
| ∃ a : σ → K,MvPowerSeries.subst |
| (fun i=>MvPowerSeries.C (a i)*MvPowerSeries.X ()) f≠0 := by |
| classical |
| obtain ⟨d,hd⟩ : ∃ d, MvPowerSeries.coeff d f≠0 := by |
| by_contra h |
| push Not at h |
| exact hf (MvPowerSeries.ext fun d=>by simp [h d]) |
| let n := d.degree+1 |
| let p := MvPowerSeries.truncTotal n f |
| have hn : n≠0 := Nat.succ_ne_zero _ |
| have hp : p≠0 := by |
| intro h |
| apply hd |
| have hh := congrArg (fun polynomial : MvPolynomial σ K=>polynomial.coeff d) h |
| change (MvPowerSeries.truncTotal n f).coeff d=0 at hh |
| rw [MvPowerSeries.coeff_truncTotal f (show d.degree<n from Nat.lt_succ_self _)] at hh |
| exact hh |
| obtain ⟨a,ha⟩ : ∃ a : σ → K,eval a p≠0 := by |
| by_contra h |
| push Not at h |
| apply hp |
| apply MvPolynomial.funext |
| intro x |
| simpa only [map_zero] using h x |
| let q (i : σ) : MvPolynomial Unit K := C (a i)*X () |
| let g := eval₂ C q p |
| have hgdeg : g.totalDegree<n := |
| (totalDegree_eval₂_linear p q (fun i=>by |
| exact (totalDegree_mul _ _).trans (by simp))).trans_lt |
| (MvPowerSeries.totalDegree_truncTotal_lt f hn) |
| have hg : g≠0 := by |
| intro h |
| apply ha |
| have hh := congrArg (eval (fun (_ : Unit)=>(1:K))) h |
| have he : (eval (fun (_ : Unit)=>(1:K))).comp C = RingHom.id K := by |
| ext c |
| simp |
| simpa [g,q,eval_eval₂,he] using hh |
| refine ⟨a,?_⟩ |
| intro hz |
| have hzconst : ∀ i : σ,(MvPowerSeries.C (a i)* |
| MvPowerSeries.X () : MvPowerSeries Unit K).constantCoeff=0 := by |
| intro i |
| simp |
| have he := MvPowerSeries.truncTotal_subst_eq_truncTotal_truncTotal_subst |
| (f:=f) (k:=n) hzconst |
| rw [hz,map_zero] at he |
| have hc : (g : MvPowerSeries Unit K) = |
| MvPowerSeries.subst (fun i=>MvPowerSeries.C (a i)*MvPowerSeries.X ()) |
| (p : MvPowerSeries σ K) := by |
| simpa only [q,MvPolynomial.coe_mul,MvPolynomial.coe_C,MvPolynomial.coe_X] using |
| coe_eval₂_polynomials p q |
| change 0 = MvPowerSeries.truncTotal n |
| (MvPowerSeries.subst (fun i=>MvPowerSeries.C (a i)*MvPowerSeries.X ()) |
| (p : MvPowerSeries σ K)) at he |
| rw [←hc,(MvPowerSeries.truncTotal_coe_eq_self_iff g hn).mpr hgdeg] at he |
| exact hg he.symm |
|
|
| end |
| end PD4Tensor.Spreading |
|
|
| |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open MvPowerSeries |
| variable {K σ : Type*} [Field K] [Finite σ] [DecidableEq σ] |
|
|
| def linearChartVars (p : σ) (a : σ → K) (i : σ) : MvPowerSeries σ K := |
| if i=p then C (a i)*X p else X i+C (a i)*X p |
|
|
| omit [Finite σ] in |
| theorem linearChartVars_const (p : σ) (a : σ → K) (i : σ) : |
| constantCoeff (linearChartVars p a i)=0 := by |
| simp [linearChartVars]; split <;> simp |
|
|
| theorem linearChartVars_hasSubst (p : σ) (a : σ → K) : HasSubst (linearChartVars p a) := |
| hasSubst_of_constantCoeff_zero (linearChartVars_const p a) |
|
|
| theorem linearChartVars_comp (p : σ) (a b : σ → K) |
| (hp : a p*b p=1) (hi : ∀ i,i≠p → b i+a i*b p=0) (i : σ) : |
| subst (linearChartVars p b) (linearChartVars p a i)=X i := by |
| have hb := linearChartVars_hasSubst p b |
| by_cases h : i=p |
| · subst i |
| simp only [linearChartVars,ite_true,subst_mul hb,subst_C,subst_X hb] |
| rw [←mul_assoc,←map_mul,hp,map_one,one_mul] |
| · simp only [linearChartVars,h,ite_false,subst_add hb,subst_X hb,subst_mul hb,subst_C] |
| calc |
| X i+C (b i)*X p+C (a i)*(C (b p)*X p) = X i+C (b i+a i*b p)*X p := by |
| rw [map_add,map_mul]; ring |
| _ = X i := by rw [hi i h]; simp |
|
|
| def inverseChartPoint (p : σ) (a : σ → K) (i : σ) : K := |
| if i=p then (a p)⁻¹ else -(a i)/(a p) |
|
|
| omit [Finite σ] in |
| theorem chart_inverse_relations (p : σ) (a : σ → K) (hp : a p≠0) : |
| a p*inverseChartPoint p a p=1 ∧ |
| (∀ i,i≠p → inverseChartPoint p a i+a i*inverseChartPoint p a p=0) ∧ |
| inverseChartPoint p a p*a p=1 ∧ |
| (∀ i,i≠p → a i+inverseChartPoint p a i*a p=0) := by |
| refine ⟨by simp [inverseChartPoint,hp],?_,by simp [inverseChartPoint,hp],?_⟩ |
| · intro i hi |
| simp [inverseChartPoint,hi,div_eq_mul_inv] |
| · intro i hi |
| simp [inverseChartPoint,hi,div_eq_mul_inv,hp] |
|
|
| def linearSeriesChart (p : σ) (a : σ → K) (hp : a p≠0) : |
| MvPowerSeries σ K ≃ₐ[K] MvPowerSeries σ K := by |
| let f : MvPowerSeries σ K →ₐ[K] MvPowerSeries σ K := substAlgHom (linearChartVars_hasSubst p a) |
| let g : MvPowerSeries σ K →ₐ[K] MvPowerSeries σ K := substAlgHom (linearChartVars_hasSubst p (inverseChartPoint p a)) |
| have h := chart_inverse_relations p a hp |
| have hfg : f.comp g=AlgHom.id K _ := by |
| apply AlgHom.ext |
| intro x |
| simp only [f,g,AlgHom.comp_apply,substAlgHom_apply,AlgHom.id_apply] |
| change subst (linearChartVars p a) (subst (linearChartVars p (inverseChartPoint p a)) x)=x |
| rw [subst_comp_subst_apply (linearChartVars_hasSubst p _) (linearChartVars_hasSubst p _)] |
| simp_rw [linearChartVars_comp p _ _ h.2.2.1 h.2.2.2] |
| simp only [subst_self,Function.id_def] |
| have hgf : g.comp f=AlgHom.id K _ := by |
| apply AlgHom.ext |
| intro x |
| simp only [f,g,AlgHom.comp_apply,substAlgHom_apply,AlgHom.id_apply] |
| change subst (linearChartVars p (inverseChartPoint p a)) (subst (linearChartVars p a) x)=x |
| rw [subst_comp_subst_apply (linearChartVars_hasSubst p _) (linearChartVars_hasSubst p _)] |
| simp_rw [linearChartVars_comp p _ _ h.1 h.2.1] |
| simp only [subst_self,Function.id_def] |
| exact AlgEquiv.ofAlgHom f g hfg hgf |
|
|
| theorem linearSeriesChart_apply (p : σ) (a : σ → K) (hp : a p≠0) |
| (f : MvPowerSeries σ K) : linearSeriesChart p a hp f=subst (linearChartVars p a) f := by |
| simp [linearSeriesChart,AlgEquiv.ofAlgHom] |
|
|
| def axisVars (p : σ) (i : σ) : MvPowerSeries Unit K := if i=p then X () else 0 |
|
|
| theorem axisVars_hasSubst (p : σ) : HasSubst (axisVars (K:=K) p) := |
| hasSubst_of_constantCoeff_zero fun i=>by simp [axisVars]; split <;> simp |
|
|
| theorem axisVars_subst_linearChartVars (p : σ) (a : σ → K) (i : σ) : |
| subst (axisVars p) (linearChartVars p a i)=C (a i)*X () := by |
| have hh := axisVars_hasSubst (K:=K) p |
| by_cases hi : i=p |
| · subst i |
| simp [linearChartVars,subst_mul hh,axisVars,subst_X hh] |
| · simp [linearChartVars,hi,subst_add hh,subst_mul hh,subst_X hh,axisVars] |
|
|
| |
|
|
| theorem axis_linearSeriesChart (p : σ) (a : σ → K) (hp : a p≠0) |
| (f : MvPowerSeries σ K) : |
| subst (axisVars p) (linearSeriesChart p a hp f)= |
| subst (fun i=>C (a i)*X ()) f := by |
| rw [linearSeriesChart_apply,subst_comp_subst_apply (linearChartVars_hasSubst p a) (axisVars_hasSubst p)] |
| simp_rw [axisVars_subst_linearChartVars] |
|
|
| end |
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open MvPowerSeries |
| variable {K σ : Type*} [Field K] [Infinite K] [Finite σ] [DecidableEq σ] |
|
|
| |
|
|
| theorem exists_regular_linear_chart (f : MvPowerSeries σ K) |
| (hf : f≠0) (hf0 : constantCoeff f=0) : |
| ∃ (p : σ) (a : σ → K) (hp : a p≠0), |
| subst (axisVars (K:=K) p) (linearSeriesChart p a hp f)≠0 := by |
| obtain ⟨a,ha⟩ := exists_nonzero_line f hf |
| have hex : ∃ p,a p≠0 := by |
| by_contra hn |
| push Not at hn |
| apply ha |
| simp only [hn,map_zero,zero_mul] |
| exact subst_zero_of_constantCoeff_zero hf0 |
| obtain ⟨p,hp⟩ := hex |
| exact ⟨p,a,hp,by rwa [axis_linearSeriesChart]⟩ |
|
|
| end |
| end PD4Tensor.Spreading |
|
|
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open MvPowerSeries |
| variable {K σ τ : Type*} [Field K] [Finite σ] [Finite τ] |
|
|
| |
|
|
| theorem series_equiv_jet (E : MvPowerSeries σ K ≃+* MvPowerSeries τ K) |
| {f : MvPowerSeries σ K} {n : ℕ} (hf : f∈(jetIdeal (K:=K) (σ:=σ))^n) : |
| E f∈(jetIdeal (K:=K) (σ:=τ))^n := by |
| have he : (jetIdeal (K:=K) (σ:=σ)).map E.toRingHom=jetIdeal (K:=K) (σ:=τ) := by |
| rw [jetIdeal_eq_maximalIdeal,jetIdeal_eq_maximalIdeal] |
| ext x |
| change x∈(IsLocalRing.maximalIdeal (MvPowerSeries σ K)).map E ↔ _ |
| rw [←Ideal.symm_apply_mem_of_equiv_iff (f:=E)] |
| simp only [IsLocalRing.mem_maximalIdeal,mem_nonunits_iff,isUnit_map_iff E.symm] |
| have h := Ideal.mem_map_of_mem E.toRingHom hf |
| rwa [Ideal.map_pow,he] at h |
|
|
| variable [DecidableEq σ] |
|
|
| def polynomialChartVars (p : σ) (a : σ → K) (i : σ) : MvPolynomial σ K := |
| if i=p then MvPolynomial.C (a p)*MvPolynomial.X p |
| else MvPolynomial.X i+MvPolynomial.C (a i)*MvPolynomial.X p |
|
|
| def polynomialChart (p : σ) (a : σ → K) : MvPolynomial σ K →+* MvPolynomial σ K := |
| MvPolynomial.eval₂Hom MvPolynomial.C (polynomialChartVars p a) |
|
|
| theorem polynomialChart_square (p : σ) (a : σ → K) (hp : a p≠0) : |
| (algebraMap (MvPolynomial σ K) (MvPowerSeries σ K)).comp (polynomialChart p a)= |
| (linearSeriesChart p a hp).toRingHom.comp |
| (algebraMap (MvPolynomial σ K) (MvPowerSeries σ K)) := by |
| apply MvPolynomial.ringHom_ext |
| · intro c |
| simp [polynomialChart,linearSeriesChart_apply,algebraMap_apply'] |
| · intro i |
| simp only [RingHom.comp_apply,algebraMap_apply',MvPolynomial.coe_X] |
| change ((polynomialChart p a (MvPolynomial.X i) : MvPolynomial σ K) : MvPowerSeries σ K)= |
| linearSeriesChart p a hp (X i) |
| rw [linearSeriesChart_apply,subst_X (linearChartVars_hasSubst p a)] |
| by_cases hi : i=p <;> simp [polynomialChart,polynomialChartVars,linearChartVars,hi] |
|
|
| theorem polynomialChart_injective (p : σ) (a : σ → K) (hp : a p≠0) : |
| Function.Injective (polynomialChart p a) := by |
| intro f g h |
| apply MvPolynomial.coe_injective |
| apply (linearSeriesChart p a hp).injective |
| have hf := RingHom.congr_fun (polynomialChart_square p a hp) f |
| have hg := RingHom.congr_fun (polynomialChart_square p a hp) g |
| change (linearSeriesChart p a hp) (f : MvPowerSeries σ K)= |
| (linearSeriesChart p a hp) (g : MvPowerSeries σ K) |
| simp only [RingHom.comp_apply,algebraMap_apply'] at hf hg |
| change ((polynomialChart p a f : MvPolynomial σ K) : MvPowerSeries σ K)=linearSeriesChart p a hp (f : MvPowerSeries σ K) at hf |
| change ((polynomialChart p a g : MvPolynomial σ K) : MvPowerSeries σ K)=linearSeriesChart p a hp (g : MvPowerSeries σ K) at hg |
| rw [←hf,←hg,h] |
| |
| theorem algebraic_linearSeriesChart (p : σ) (a : σ → K) (hp : a p≠0) |
| {f : MvPowerSeries σ K} (hf : IsAlgebraic (MvPolynomial σ K) f) : |
| IsAlgebraic (MvPolynomial σ K) (linearSeriesChart p a hp f) := by |
| exact hf.ringHom_of_comp_eq (polynomialChart p a) (linearSeriesChart p a hp).toRingHom |
| (polynomialChart_injective p a hp) (polynomialChart_square p a hp) |
| |
| theorem linearSeriesChart_symm_apply (p : σ) (a : σ → K) (hp : a p≠0) |
| (f : MvPowerSeries σ K) : |
| (linearSeriesChart p a hp).symm f=subst (linearChartVars p (inverseChartPoint p a)) f := by |
| simp [linearSeriesChart,AlgEquiv.ofAlgHom] |
| |
| theorem algebraic_linearSeriesChart_symm (p : σ) (a : σ → K) (hp : a p≠0) |
| {f : MvPowerSeries σ K} (hf : IsAlgebraic (MvPolynomial σ K) f) : |
| IsAlgebraic (MvPolynomial σ K) ((linearSeriesChart p a hp).symm f) := by |
| have hi : inverseChartPoint p a p≠0 := by simp [inverseChartPoint,hp] |
| simpa only [linearSeriesChart_symm_apply,linearSeriesChart_apply] using |
| algebraic_linearSeriesChart p (inverseChartPoint p a) hi hf |
| |
| end |
| end PD4Tensor.Spreading |
| |
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open MvPowerSeries WithPiTopology |
| variable {K σ : Type*} [Field K] [Finite σ] [DecidableEq σ] |
| |
| def axisEmbedding (p : σ) : Unit ↪ σ := ⟨fun _=>p,fun _ _ _=>Subsingleton.elim _ _⟩ |
| |
| theorem axis_subst_eq_killCompl (p : σ) (f : MvPowerSeries σ K) : |
| subst (axisVars p) f=killCompl (axisEmbedding p) f := by |
| let : UniformSpace K := ⊥ |
| let ε := killCompl (R:=K) (axisEmbedding p) |
| have hε : Continuous ε := by |
| apply continuous_pi |
| intro d |
| exact continuous_coeff K (Finsupp.embDomain (axisEmbedding p) d) |
| have hvars : (fun i : σ=>ε (X i))=axisVars p := by |
| funext i |
| by_cases hi : i=p |
| · subst i |
| simp only [axisVars,ite_true] |
| exact killCompl_X (R:=K) (e:=axisEmbedding p) () |
| · have hn : i∉Set.range (axisEmbedding p) := by |
| rintro ⟨u,hu⟩ |
| exact hi hu.symm |
| simpa [ε,axisVars,hi] using killCompl_X_eq_zero (R:=K) (e:=axisEmbedding p) hn |
| have he := aeval_unique hε |
| have hR := axisVars_hasSubst (K:=K) p |
| change subst (axisVars p) f=ε f |
| rw [←AlgHom.congr_fun he f] |
| rw [←substAlgHom_apply hR,substAlgHom_eq_aeval hR] |
| simp only [coe_aeval] |
| change eval₂ (algebraMap K (MvPowerSeries Unit K)) (axisVars p) f= |
| eval₂ (algebraMap K (MvPowerSeries Unit K)) (fun s=>ε (X s)) f |
| rw [hvars] |
| |
| theorem option_axis_constant (f : MvPowerSeries (Option σ) K) : |
| subst (axisVars none) f=(MvPowerSeries.optionEquivLeft σ K f).map |
| (MvPowerSeries.constantCoeff : MvPowerSeries σ K →+* K) := by |
| rw [axis_subst_eq_killCompl] |
| apply PowerSeries.ext |
| intro n |
| change coeff (Finsupp.single () n) (killCompl (axisEmbedding none) f)=_ |
| rw [coeff_killCompl,PowerSeries.coeff_map,←coeff_zero_eq_constantCoeff_apply, |
| coeff_coeff_optionEquivLeft] |
| have he : Finsupp.embDomain (axisEmbedding (σ:=Option σ) none) (Finsupp.single () n)= |
| Finsupp.optionElim n 0 := by |
| rw [Finsupp.optionElim_zero,Finsupp.embDomain_single] |
| rfl |
| rw [he] |
| |
| theorem option_axis_rename (p : σ) (f : MvPowerSeries σ K) : |
| subst (axisVars (K:=K) none) (rename (Equiv.optionSubtypeNe p).symm f)=subst (axisVars (K:=K) p) f := by |
| rw [rename_eq_subst,subst_comp_subst_apply (HasSubst.X_comp _) (axisVars_hasSubst none)] |
| congr 1 |
| funext i |
| rw [Function.comp_apply,subst_X (axisVars_hasSubst none)] |
| by_cases hi : i=p |
| · subst i |
| simp [axisVars] |
| · simp [axisVars,hi,Equiv.optionSubtypeNe_symm_of_ne hi] |
| |
| end |
| end PD4Tensor.Spreading |
| |
| namespace PD4Tensor.Spreading |
| noncomputable section |
| open MvPowerSeries |
| variable {K τ : Type*} [Field K] [Finite τ] |
| |
| omit [Finite τ] in |
| theorem residue_regular_of_constant_regular (f : PowerSeries (MvPowerSeries τ K)) |
| (hf : f.map (MvPowerSeries.constantCoeff : MvPowerSeries τ K →+* K)≠0) : |
| f.map (IsLocalRing.residue (MvPowerSeries τ K))≠0 := by |
| intro hz |
| apply hf |
| apply PowerSeries.ext |
| intro n |
| rw [PowerSeries.coeff_map,map_zero] |
| have he := congrArg (PowerSeries.coeff n) hz |
| rw [PowerSeries.coeff_map,map_zero] at he |
| have hm : PowerSeries.coeff n f∈IsLocalRing.maximalIdeal (MvPowerSeries τ K) := |
| (IsLocalRing.residue_eq_zero_iff _).mp he |
| rw [IsLocalRing.mem_maximalIdeal,mem_nonunits_iff, |
| MvPowerSeries.isUnit_iff_constantCoeff,isUnit_iff_ne_zero,not_not] at hm |
| exact hm |
| |
| end |
| end PD4Tensor.Spreading |
| end |
| |
| end OAI |
| |
