Download data/lean/OAI/NumberTheory/PiExponent/Analysis/FormalLogTruncation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 18.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PiExponent/Analysis/FormalLogTruncation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PiExponent/Analysis/FormalLogTruncation.lean
-
curl -L -o FormalLogTruncation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PiExponent/Analysis/FormalLogTruncation.lean
18.2 kB
| import Mathlib.RingTheory.MvPowerSeries.Equiv | |
| import Mathlib.RingTheory.MvPowerSeries.Substitution | |
| import OAI.NumberTheory.PiExponent.Jets.FormalLogJet | |
| import OAI.NumberTheory.PiExponent.Jets.JetGeometry | |
| namespace OAI | |
| namespace PiExponent.FormalLogTruncation | |
| open MvPowerSeries | |
| open scoped BigOperators | |
| variable {R : Type*} [CommRing R] | |
| theorem liftSeries_eq_toMvPowerSeries (m : β) (f : PowerSeries R) : | |
| FormalLogJet.liftSeries m f = f.toMvPowerSeries (0 : Fin (m+1)) := by | |
| classical | |
| let e : Unit βͺ Fin (m+1) := β¨fun _ => 0, fun a b _ => Subsingleton.elim a bβ© | |
| ext d | |
| rw [FormalLogJet.coeff_liftSeries] | |
| change (if d.tail = 0 then PowerSeries.coeff (d 0) f else 0) = coeff d (rename e f) | |
| by_cases ht : d.tail = 0 | |
| Β· rw [ite_eq_left ht] | |
| have hd : d = Finsupp.single 0 (d 0) := by | |
| calc | |
| d = Finsupp.cons (d 0) d.tail := (Finsupp.cons_tail d).symm | |
| _ = Finsupp.single 0 (d 0) := by rw [ht, Finsupp.cons_zero_eq_single_zero] | |
| have he : Finsupp.embDomain e (Finsupp.single () (d 0)) = Finsupp.single 0 (d 0) := by | |
| rw [Finsupp.embDomain_single] | |
| rfl | |
| conv_rhs => rw [hd, β he, coeff_embDomain_rename] | |
| rfl | |
| Β· rw [ite_eq_right ht] | |
| symm | |
| apply coeff_rename_eq_zero | |
| rintro β¨x, hxβ© | |
| have hx' : x = Finsupp.single () (x ()) := by ext; simp | |
| rw [hx', Finsupp.mapDomain_single] at hx | |
| apply ht | |
| rw [β hx] | |
| ext i | |
| change (Finsupp.single (0 : Fin (m+1)) (x ())) i.succ = 0 | |
| exact Finsupp.single_eq_of_ne (Fin.succ_ne_zero i) | |
| noncomputable def shiftVars {m : β} (tail : Fin m β PowerSeries R) : | |
| Fin (m+1) β MvPowerSeries (Fin (m+1)) R := | |
| Fin.cases (X 0) (fun i => X i.succ + (tail i).toMvPowerSeries 0) | |
| theorem shiftVars_hasSubst {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) : HasSubst (shiftVars tail) := by | |
| apply hasSubst_of_constantCoeff_zero | |
| intro i | |
| cases i using Fin.cases with | |
| | zero => simp [shiftVars] | |
| | succ i => | |
| simp only [shiftVars, Fin.cases_succ, map_add, constantCoeff_X, | |
| PowerSeries.toMvPowerSeries_apply, constantCoeff_rename, zero_add] | |
| exact ht i | |
| noncomputable def shiftMap {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) : | |
| MvPowerSeries (Fin (m+1)) R ββ[R] MvPowerSeries (Fin (m+1)) R := | |
| substAlgHom (shiftVars_hasSubst tail ht) | |
| @[simp] theorem shiftMap_X_zero {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) : | |
| shiftMap tail ht (X 0) = X 0 := by | |
| rw [shiftMap, substAlgHom_X] | |
| rfl | |
| @[simp] theorem shiftMap_X_succ {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (i : Fin m) : | |
| shiftMap tail ht (X i.succ) = X i.succ + (tail i).toMvPowerSeries 0 := by | |
| rw [shiftMap, substAlgHom_X] | |
| rfl | |
| @[simp] theorem shiftMap_toMvPowerSeries {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (f : PowerSeries R) : | |
| shiftMap tail ht (f.toMvPowerSeries (0 : Fin (m+1))) = f.toMvPowerSeries 0 := by | |
| rw [shiftMap, substAlgHom_apply, PowerSeries.subst_toMvPowerSeries (shiftVars_hasSubst tail ht)] | |
| change PowerSeries.subst (X (0 : Fin (m+1))) f = f.toMvPowerSeries 0 | |
| exact PowerSeries.toMvPowerSeries_eq_subst.symm | |
| @[simp] theorem shiftMap_liftSeries {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (f : PowerSeries R) : | |
| shiftMap tail ht (FormalLogJet.liftSeries m f) = FormalLogJet.liftSeries m f := by | |
| rw [liftSeries_eq_toMvPowerSeries, shiftMap_toMvPowerSeries] | |
| @[simp] theorem shiftMap_apply {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (f) : | |
| shiftMap tail ht f = subst (shiftVars tail) f := substAlgHom_apply _ _ | |
| theorem shiftMap_inverse {m : β} (s t : Fin m β PowerSeries R) | |
| (hs : β i, PowerSeries.constantCoeff (s i) = 0) | |
| (ht : β i, PowerSeries.constantCoeff (t i) = 0) | |
| (hst : β i, s i + t i = 0) (f : MvPowerSeries (Fin (m+1)) R) : | |
| shiftMap s hs (shiftMap t ht f) = f := by | |
| simp only [shiftMap_apply] | |
| rw [subst_comp_subst_apply (shiftVars_hasSubst t ht) (shiftVars_hasSubst s hs)] | |
| have hvars : (fun i => subst (shiftVars s) (shiftVars t i)) = X := by | |
| funext i | |
| rw [β shiftMap_apply s hs] | |
| cases i using Fin.cases with | |
| | zero => exact shiftMap_X_zero s hs | |
| | succ i => | |
| change shiftMap s hs (X i.succ + (t i).toMvPowerSeries 0) = X i.succ | |
| rw [map_add, shiftMap_X_succ, shiftMap_toMvPowerSeries, add_assoc, | |
| β map_add, hst i, map_zero, add_zero] | |
| rw [hvars] | |
| exact congrFun subst_self f | |
| noncomputable def shiftEquiv {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) : | |
| MvPowerSeries (Fin (m+1)) R ββ[R] MvPowerSeries (Fin (m+1)) R := by | |
| let hn : β i, PowerSeries.constantCoeff (-tail i) = 0 := by simp [ht] | |
| refine AlgEquiv.ofAlgHom (shiftMap tail ht) (shiftMap (fun i => -tail i) hn) ?_ ?_ | |
| Β· apply AlgHom.ext | |
| intro f | |
| exact shiftMap_inverse tail (fun i => -tail i) ht hn (fun i => add_neg_cancel _) f | |
| Β· apply AlgHom.ext | |
| intro f | |
| exact shiftMap_inverse (fun i => -tail i) tail hn ht (fun i => neg_add_cancel _) f | |
| @[simp] theorem shiftEquiv_apply {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (f) : | |
| shiftEquiv tail ht f = shiftMap tail ht f := rfl | |
| open JetGeometry | |
| theorem rationalWeightedIdeal_prod {Ο ΞΉ : Type*} (v : Ο β β) (hv : β i, 0 β€ v i) | |
| (s : Finset ΞΉ) (f : ΞΉ β MvPowerSeries Ο R) (c : ΞΉ β β) | |
| (hf : β i β s, f i β rationalWeightedIdeal v hv (c i)) : | |
| β i β s, f i β rationalWeightedIdeal v hv (β i β s, c i) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => | |
| intro d hd | |
| simp only [Finset.sum_empty] at hd | |
| exact False.elim ((not_lt_of_ge (rational_weight_nonneg v hv d)) hd) | |
| | @insert i s hi ih => | |
| rw [Finset.prod_insert hi, Finset.sum_insert hi] | |
| exact Ideal.mul_le.mp (rationalWeightedIdeal_mul_le v hv (c i) (βjβs,c j)) | |
| _ (hf i (Finset.mem_insert_self _ _)) _ | |
| (ih (fun j hj => hf j (Finset.mem_insert_of_mem hj))) | |
| theorem subst_mem_rationalWeightedIdeal {Ο Ο : Type*} | |
| (w : Ο β β) (v : Ο β β) (hw : β i, 0 β€ w i) (hv : β i, 0 β€ v i) | |
| (a : Ο β MvPowerSeries Ο R) (ha : HasSubst a) | |
| (hweight : β i, a i β rationalWeightedIdeal v hv (w i)) | |
| (H : β) (f : MvPowerSeries Ο R) (hf : f β rationalWeightedIdeal w hw H) : | |
| subst a f β rationalWeightedIdeal v hv H := by | |
| classical | |
| intro d hd | |
| rw [coeff_subst ha] | |
| apply finsum_eq_zero_of_forall_eq_zero | |
| intro e | |
| by_cases he : coeff e f = 0 | |
| Β· rw [he, zero_smul] | |
| have hHe : H β€ Finsupp.weight w e := le_of_not_gt (fun h => he (hf e h)) | |
| have hprod : e.prod (fun i n => a i ^ n) β | |
| rationalWeightedIdeal v hv (Finsupp.weight w e) := by | |
| rw [Finsupp.prod, Finsupp.weight_apply, Finsupp.sum] | |
| apply rationalWeightedIdeal_prod | |
| intro i hi | |
| have hp := Ideal.pow_mem_pow (hweight i) (e i) | |
| have hh := ideal_pow_le_rationalWeightedIdeal v hv | |
| (rationalWeightedIdeal v hv (w i)) (w i) le_rfl (e i) hp | |
| simpa only [nsmul_eq_mul] using hh | |
| rw [hprod d (hd.trans_le hHe), smul_zero] | |
| theorem X_mem_rationalWeightedIdeal {Ο : Type*} (v : Ο β β) (hv : β i, 0 β€ v i) | |
| (i : Ο) : (X i : MvPowerSeries Ο R) β rationalWeightedIdeal v hv (v i) := by | |
| classical | |
| intro d hd | |
| rw [coeff_X] | |
| split_ifs with he | |
| Β· subst d | |
| simp only [Finsupp.weight_single, one_nsmul] at hd | |
| exact False.elim (lt_irrefl _ hd) | |
| Β· rfl | |
| theorem shiftMap_mem_rationalWeightedIdeal {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) | |
| (v : Fin (m+1) β β) (hv : β i, 0 β€ v i) | |
| (hweight : β i, (tail i).toMvPowerSeries (0 : Fin (m+1)) β | |
| rationalWeightedIdeal v hv (v i.succ)) (H : β) | |
| (f : MvPowerSeries (Fin (m+1)) R) (hf : f β rationalWeightedIdeal v hv H) : | |
| shiftMap tail ht f β rationalWeightedIdeal v hv H := by | |
| rw [shiftMap_apply] | |
| apply subst_mem_rationalWeightedIdeal v v hv hv _ (shiftVars_hasSubst tail ht) _ H f hf | |
| intro i | |
| cases i using Fin.cases with | |
| | zero => exact X_mem_rationalWeightedIdeal v hv 0 | |
| | succ i => exact Ideal.add_mem _ (X_mem_rationalWeightedIdeal v hv i.succ) (hweight i) | |
| theorem rationalCoefficientPacket_eq_iff {Ο : Type*} (v : Ο β β) | |
| (hv : β i, 0 β€ v i) (H : β) (f g : MvPowerSeries Ο R) : | |
| rationalCoefficientPacket v H f = rationalCoefficientPacket v H g β | |
| f - g β rationalWeightedIdeal v hv H := by | |
| constructor | |
| Β· intro h d hd | |
| exact sub_eq_zero.mpr (congrFun h β¨d,hdβ©) | |
| Β· intro h | |
| funext d | |
| exact sub_eq_zero.mp (h d.val d.property) | |
| theorem rationalCoefficientPacket_surjective {Ο : Type*} (v : Ο β β) (H : β) : | |
| Function.Surjective (rationalCoefficientPacket (R := R) v H) := by | |
| classical | |
| intro p | |
| refine β¨fun d => if hd : Finsupp.weight v d < H then p β¨d,hdβ© else 0, ?_β© | |
| funext d | |
| exact dite_eq_left d.property | |
| theorem packet_surjective_comp_equiv {Ο Ξ± : Type*} (v : Ο β β) | |
| (hv : β i, 0 β€ v i) (H : β) | |
| (e : MvPowerSeries Ο R ββ[R] MvPowerSeries Ο R) | |
| (he : β f β rationalWeightedIdeal v hv H, e f β rationalWeightedIdeal v hv H) | |
| (f : Ξ± β MvPowerSeries Ο R) | |
| (hf : Function.Surjective (fun a => rationalCoefficientPacket v H (f a))) : | |
| Function.Surjective (fun a => rationalCoefficientPacket v H (e (f a))) := by | |
| intro p | |
| obtain β¨F,hFβ© := rationalCoefficientPacket_surjective (R := R) v H p | |
| obtain β¨a,haβ© := hf (rationalCoefficientPacket v H (e.symm F)) | |
| have hdiff := he _ ((rationalCoefficientPacket_eq_iff v hv H _ _).mp ha) | |
| rw [map_sub, e.apply_symm_apply] at hdiff | |
| exact β¨a, ((rationalCoefficientPacket_eq_iff v hv H _ _).mpr hdiff).trans hFβ© | |
| theorem packet_surjective_comp_equiv_iff {Ο Ξ± : Type*} (v : Ο β β) | |
| (hv : β i, 0 β€ v i) (H : β) | |
| (e : MvPowerSeries Ο R ββ[R] MvPowerSeries Ο R) | |
| (he : β f β rationalWeightedIdeal v hv H, e f β rationalWeightedIdeal v hv H) | |
| (hi : β f β rationalWeightedIdeal v hv H, e.symm f β rationalWeightedIdeal v hv H) | |
| (f : Ξ± β MvPowerSeries Ο R) : | |
| Function.Surjective (fun a => rationalCoefficientPacket v H (e (f a))) β | |
| Function.Surjective (fun a => rationalCoefficientPacket v H (f a)) := by | |
| constructor | |
| Β· intro h | |
| simpa only [e.symm_apply_apply] using | |
| packet_surjective_comp_equiv v hv H e.symm hi (fun a => e (f a)) h | |
| Β· exact packet_surjective_comp_equiv v hv H e he f | |
| @[simp] theorem shiftEquiv_symm_apply {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) (f) : | |
| (shiftEquiv tail ht).symm f = | |
| shiftMap (fun i => -tail i) (by simp [ht]) f := rfl | |
| theorem shiftEquiv_mem_iff {m : β} (tail : Fin m β PowerSeries R) | |
| (ht : β i, PowerSeries.constantCoeff (tail i) = 0) | |
| (v : Fin (m+1) β β) (hv : β i, 0 β€ v i) | |
| (hweight : β i, (tail i).toMvPowerSeries (0 : Fin (m+1)) β | |
| rationalWeightedIdeal v hv (v i.succ)) (H : β) (f) : | |
| shiftEquiv tail ht f β rationalWeightedIdeal v hv H β | |
| f β rationalWeightedIdeal v hv H := by | |
| have hn : β i, (-tail i).toMvPowerSeries (0 : Fin (m+1)) β | |
| rationalWeightedIdeal v hv (v i.succ) := by | |
| intro i | |
| rw [map_neg] | |
| intro d hd | |
| rw [map_neg, hweight i d hd, neg_zero] | |
| constructor | |
| Β· intro hf | |
| have h := shiftMap_mem_rationalWeightedIdeal (fun i => -tail i) | |
| (by simp [ht]) v hv hn H _ hf | |
| change (shiftEquiv tail ht).symm (shiftEquiv tail ht f) β _ at h | |
| simpa only [AlgEquiv.symm_apply_apply] using h | |
| Β· exact shiftMap_mem_rationalWeightedIdeal tail ht v hv hweight H f | |
| noncomputable def logTail (T : β) : PowerSeries β := | |
| PowerSeries.log β - (PowerSeries.trunc T (PowerSeries.log β) : PowerSeries β) | |
| @[simp] theorem logTail_constantCoeff (T : β) : PowerSeries.constantCoeff (logTail T) = 0 := by | |
| simp [logTail, Polynomial.constantCoeff_coe, PowerSeries.coeff_trunc, | |
| PowerSeries.coeff_log] | |
| theorem coeff_logTail_eq_zero (T n : β) (hn : n < T) : | |
| PowerSeries.coeff n (logTail T) = 0 := by | |
| simp [logTail, Polynomial.coeff_coe, PowerSeries.coeff_trunc, hn] | |
| theorem logTail_mem_rationalWeightedIdeal {m : β} (v : Fin (m+1) β β) | |
| (hv : β i, 0 β€ v i) (T : β) (H : β) (hT : H β€ (T : β) * v 0) : | |
| (logTail T).toMvPowerSeries (0 : Fin (m+1)) β rationalWeightedIdeal v hv H := by | |
| intro d hd | |
| rw [β liftSeries_eq_toMvPowerSeries, FormalLogJet.coeff_liftSeries] | |
| split_ifs with ht | |
| Β· have he : d = Finsupp.single 0 (d 0) := by | |
| calc | |
| d = Finsupp.cons (d 0) d.tail := (Finsupp.cons_tail d).symm | |
| _ = Finsupp.single 0 (d 0) := by rw [ht, Finsupp.cons_zero_eq_single_zero] | |
| have hdeg : (d 0 : β) * v 0 < H := by | |
| calc | |
| (d 0 : β) * v 0 = Finsupp.weight v (Finsupp.single 0 (d 0)) := by | |
| rw [Finsupp.weight_single, nsmul_eq_mul] | |
| _ = Finsupp.weight v d := congrArg _ he.symm | |
| _ < H := hd | |
| apply coeff_logTail_eq_zero | |
| by_contra hn | |
| have hcast : (T : β) β€ d 0 := by exact_mod_cast (Nat.le_of_not_gt hn) | |
| exact (not_lt_of_ge ((mul_le_mul_of_nonneg_right hcast (hv 0)).trans' hT)) hdeg | |
| Β· rfl | |
| noncomputable def truncatedFormalJet {m : β} (c : Fin m β β) (T : Fin m β β) : | |
| PiExponentApprox.FramePolynomial m ββ[β] MvPowerSeries (Fin (m+1)) β := | |
| MvPolynomial.aeval (Fin.cases (1 + X 0) (fun i => | |
| C (c i) + X i.succ + FormalLogJet.liftSeries m | |
| (PowerSeries.trunc (T i) (PowerSeries.log β) : PowerSeries β))) | |
| theorem shiftMap_truncatedFormalJet {m : β} (c : Fin m β β) (T : Fin m β β) | |
| (P : PiExponentApprox.FramePolynomial m) : | |
| shiftMap (fun i => logTail (T i)) (fun i => logTail_constantCoeff (T i)) | |
| (truncatedFormalJet c T P) = FormalLogJet.formalJet c P := by | |
| have he : (shiftMap (fun i => logTail (T i)) (fun i => logTail_constantCoeff (T i))).comp | |
| (truncatedFormalJet c T) = FormalLogJet.formalJet c := by | |
| apply MvPolynomial.algHom_ext | |
| intro i | |
| cases i using Fin.cases with | |
| | zero => | |
| simp only [AlgHom.comp_apply, truncatedFormalJet, MvPolynomial.aeval_X, | |
| Fin.cases_zero, FormalLogJet.formalJet_Y, map_add, map_one, shiftMap_X_zero] | |
| | succ i => | |
| simp only [AlgHom.comp_apply, truncatedFormalJet, MvPolynomial.aeval_X, | |
| Fin.cases_succ, FormalLogJet.formalJet_X, map_add, | |
| shiftMap_X_succ, shiftMap_liftSeries] | |
| rw [β liftSeries_eq_toMvPowerSeries, logTail, map_sub, FormalLogJet.formalLog] | |
| have hc : shiftMap (fun i => logTail (T i)) (fun i => logTail_constantCoeff (T i)) | |
| (C (c i)) = C (c i) := (shiftMap _ _).commutes (c i) | |
| rw [hc] | |
| ring | |
| exact DFunLike.congr_fun he P | |
| theorem packets_surjective_comp_equiv {Ο Ξ± J : Type*} (v : Ο β β) | |
| (hv : β i, 0 β€ v i) (H : β) | |
| (e : MvPowerSeries Ο R ββ[R] MvPowerSeries Ο R) | |
| (he : β f β rationalWeightedIdeal v hv H, e f β rationalWeightedIdeal v hv H) | |
| (f : Ξ± β J β MvPowerSeries Ο R) | |
| (hf : Function.Surjective (fun a j => rationalCoefficientPacket v H (f a j))) : | |
| Function.Surjective (fun a j => rationalCoefficientPacket v H (e (f a j))) := by | |
| intro p | |
| choose F hF using fun j => rationalCoefficientPacket_surjective (R := R) v H (p j) | |
| obtain β¨a,haβ© := hf (fun j => rationalCoefficientPacket v H (e.symm (F j))) | |
| refine β¨a, ?_β© | |
| funext j | |
| have hdiff := he _ ((rationalCoefficientPacket_eq_iff v hv H _ _).mp (congrFun ha j)) | |
| rw [map_sub, e.apply_symm_apply] at hdiff | |
| exact ((rationalCoefficientPacket_eq_iff v hv H _ _).mpr hdiff).trans (hF j) | |
| theorem packets_surjective_comp_equiv_iff {Ο Ξ± J : Type*} (v : Ο β β) | |
| (hv : β i, 0 β€ v i) (H : β) | |
| (e : MvPowerSeries Ο R ββ[R] MvPowerSeries Ο R) | |
| (he : β f β rationalWeightedIdeal v hv H, e f β rationalWeightedIdeal v hv H) | |
| (hi : β f β rationalWeightedIdeal v hv H, e.symm f β rationalWeightedIdeal v hv H) | |
| (f : Ξ± β J β MvPowerSeries Ο R) : | |
| Function.Surjective (fun a j => rationalCoefficientPacket v H (e (f a j))) β | |
| Function.Surjective (fun a j => rationalCoefficientPacket v H (f a j)) := by | |
| constructor | |
| Β· intro h | |
| simpa only [e.symm_apply_apply] using | |
| packets_surjective_comp_equiv v hv H e.symm hi (fun a j => e (f a j)) h | |
| Β· exact packets_surjective_comp_equiv v hv H e he f | |
| theorem formalLog_packets_surjective_iff_truncated {m : β} {Ξ± J : Type*} | |
| (v : Fin (m+1) β β) (hv : β i, 0 β€ v i) (H : β) | |
| (T : Fin m β β) (hT : β i, v i.succ β€ (T i : β) * v 0) | |
| (c : J β Fin m β β) (P : Ξ± β PiExponentApprox.FramePolynomial m) : | |
| Function.Surjective (fun a j => rationalCoefficientPacket v H (FormalLogJet.formalJet (c j) (P a))) β | |
| Function.Surjective (fun a j => rationalCoefficientPacket v H (truncatedFormalJet (c j) T (P a))) := by | |
| let tail := fun i => logTail (T i) | |
| let ht := fun i => logTail_constantCoeff (T i) | |
| let e := shiftEquiv tail ht | |
| have hw : β i, (tail i).toMvPowerSeries (0 : Fin (m+1)) β | |
| rationalWeightedIdeal v hv (v i.succ) := | |
| fun i => logTail_mem_rationalWeightedIdeal v hv (T i) (v i.succ) (hT i) | |
| have he : β f β rationalWeightedIdeal v hv H, e f β rationalWeightedIdeal v hv H := | |
| fun f hf => (shiftEquiv_mem_iff tail ht v hv hw H f).mpr hf | |
| have hi : β f β rationalWeightedIdeal v hv H, e.symm f β rationalWeightedIdeal v hv H := by | |
| intro f hf | |
| apply (shiftEquiv_mem_iff tail ht v hv hw H (e.symm f)).mp | |
| change e (e.symm f) β rationalWeightedIdeal v hv H | |
| simpa only [AlgEquiv.apply_symm_apply] using hf | |
| have hh := packets_surjective_comp_equiv_iff v hv H e he hi | |
| (fun a j => truncatedFormalJet (c j) T (P a)) | |
| simpa only [e, tail, ht, shiftEquiv_apply, shiftMap_truncatedFormalJet] using hh | |
| end PiExponent.FormalLogTruncation | |
| end OAI | |