| import Mathlib.Algebra.BigOperators.Fin |
| import OAI.Analysis.FactorGeneration.Coefficients |
| import OAI.Analysis.FactorGeneration.Convolution |
| import OAI.Analysis.FactorGeneration.Exponential |
| import OAI.Analysis.FactorGeneration.Words |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace Generator |
|
|
| /-! Factorial coefficient majorization in every homogeneous degree. -/ |
| section |
| open scoped BigOperators |
| open Generator.CoefficientOrder |
| variable {G : Type*} [Monoid G] |
|
|
| @[simp] theorem normCoefficients_zero : normCoefficients (0 : MonoidAlgebra ℂ G) = 0 := by |
| ext w; simp |
|
|
| @[simp] theorem normCoefficients_one : normCoefficients (1 : MonoidAlgebra ℂ G) = 1 := by |
| classical |
| ext w |
| simp only [normCoefficients_apply, MonoidAlgebra.one_def, MonoidAlgebra.coeff_single, |
| Finsupp.single_apply] |
| split_ifs <;> norm_num |
|
|
| omit [Monoid G] in |
| @[simp] theorem normCoefficients_single (g : G) (c : ℂ) : |
| normCoefficients (MonoidAlgebra.single g c) = MonoidAlgebra.single g ‖c‖ := by |
| classical |
| ext w |
| simp only [normCoefficients_apply, MonoidAlgebra.coeff_single, Finsupp.single_apply] |
| split_ifs <;> simp |
|
|
| theorem normCoefficients_sub_le (f g : MonoidAlgebra ℂ G) : |
| normCoefficients (f - g) ≤ normCoefficients f + normCoefficients g := by |
| intro w |
| simpa using norm_sub_le (f.coeff w) (g.coeff w) |
|
|
| theorem normCoefficients_sum_le {I : Type*} (s : Finset I) (f : I → MonoidAlgebra ℂ G) : |
| normCoefficients (∑ i ∈ s, f i) ≤ ∑ i ∈ s, normCoefficients (f i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi ih => |
| simp only [Finset.sum_insert hi] |
| exact le_trans (normCoefficients_add_le _ _) (add_le_add le_rfl ih) |
|
|
| theorem normCoefficients_pow_le (b : MonoidAlgebra ℂ G) (a : MonoidAlgebra ℝ G) |
| (ha : 0 ≤ a) (hb : normCoefficients b ≤ a) (d : ℕ) : |
| normCoefficients (b ^ d) ≤ a ^ d := by |
| induction d with |
| | zero => simp |
| | succ d ih => |
| rw [pow_succ, pow_succ] |
| exact le_trans (normCoefficients_mul_le _ _) |
| (mul_le_mul ih hb (fun w => normCoefficients_nonnegative b w) (pow_nonneg ha d)) |
|
|
| theorem normCoefficients_real_smul (r : ℝ) (hr : 0 ≤ r) (b : MonoidAlgebra ℂ G) : |
| normCoefficients (r • b) = r • normCoefficients b := by |
| ext w |
| simp [Real.norm_eq_abs, abs_of_nonneg hr] |
|
|
| /-- Original-degree factorial terms are bounded by nondecreasing row words. -/ |
| theorem exponentialDegree_le_orderedWords |
| (rows : List (MonoidAlgebra ℂ G × MonoidAlgebra ℝ G)) |
| (h : ∀ row ∈ rows, 0 ≤ row.2 ∧ normCoefficients row.1 ≤ row.2) (d : ℕ) : |
| normCoefficients (exponentialDegree (rows.map Prod.fst) d) ≤ |
| orderedWords (rows.map Prod.snd) d := by |
| induction rows generalizing d with |
| | nil => |
| cases d <;> simp [exponentialDegree] |
| | cons row rows ih => |
| have hr := h row (by simp) |
| have ht : ∀ r ∈ rows, 0 ≤ r.2 ∧ normCoefficients r.1 ≤ r.2 := |
| fun r hm => h r (by simp [hm]) |
| have hp : ∀ a ∈ rows.map Prod.snd, 0 ≤ a := by |
| intro a ha |
| obtain ⟨r, hm, rfl⟩ := List.mem_map.mp ha |
| exact (ht r hm).1 |
| simp only [List.map_cons, exponentialDegree] |
| rw [orderedWords_cons] |
| apply (normCoefficients_sum_le _ _).trans |
| apply Finset.sum_le_sum |
| intro k _ |
| have hw0 : 0 ≤ (k.factorial : ℝ)⁻¹ := by positivity |
| have hw1 : (k.factorial : ℝ)⁻¹ ≤ 1 := by |
| apply inv_le_one_of_one_le₀ |
| exact_mod_cast Nat.factorial_pos k |
| have hpow := normCoefficients_pow_le row.1 row.2 hr.1 hr.2 k |
| have hfactor : normCoefficients ((k.factorial : ℝ)⁻¹ • row.1 ^ k) ≤ row.2 ^ k := by |
| rw [normCoefficients_real_smul _ hw0] |
| intro w |
| change (k.factorial : ℝ)⁻¹ * ‖(row.1 ^ k).coeff w‖ ≤ (row.2 ^ k).coeff w |
| exact (mul_le_mul_of_nonneg_left (hpow w) hw0).trans |
| (by simpa using mul_le_mul_of_nonneg_right hw1 ((pow_nonneg hr.1 k) w)) |
| exact le_trans (normCoefficients_mul_le _ _) |
| (mul_le_mul hfactor (ih ht (d - k)) |
| (fun w => normCoefficients_nonnegative _ w) (pow_nonneg hr.1 k)) |
|
|
| /-- The source's full coefficient inequality, for arbitrary monoids and all d. |
| The sum on the right is the actual collected convolution power. -/ |
| theorem exponentialDegree_coefficient_majorization |
| (rows : List (MonoidAlgebra ℂ G × MonoidAlgebra ℝ G)) |
| (h : ∀ row ∈ rows, 0 ≤ row.2 ∧ normCoefficients row.1 ≤ row.2) (d : ℕ) : |
| normCoefficients (exponentialDegree (rows.map Prod.fst) d) ≤ |
| (rows.map Prod.snd).sum ^ d := by |
| apply (exponentialDegree_le_orderedWords rows h d).trans |
| apply orderedWords_le_sum_pow |
| intro a ha |
| obtain ⟨r, hm, rfl⟩ := List.mem_map.mp ha |
| exact (h r hm).1 |
|
|
| end |
|
|
| /-! The nonlinear remainder of the actual ordered convolution-operator |
| exponentials, evaluated at δ₁, without assumed degree estimates. -/ |
| section |
| open scoped BigOperators |
| open Generator.CoefficientOrder Generator.FreeConvolution |
| variable {A : Type*} |
| local notation "H" => SquareSpace (FreeGroup A) |
| local notation "Op" => H →L[ℂ] H |
|
|
| /-- All original-degree bounds follow from coefficient majorization and the |
| norm of the positive total convolution operator. -/ |
| theorem free_exponentialDegree_bound |
| (rows : List (MonoidAlgebra ℂ (FreeGroup A) × MonoidAlgebra ℝ (FreeGroup A))) |
| (h : ∀ row ∈ rows, 0 ≤ row.2 ∧ normCoefficients row.1 ≤ row.2) (d : ℕ) : |
| ‖regular (exponentialDegree (rows.map Prod.fst) d) delta‖ ≤ |
| ‖realRegular (rows.map Prod.snd).sum‖ ^ d := by |
| exact (regular_delta_norm_le (exponentialDegree_coefficient_majorization rows h d)).trans |
| (realRegular_pow_delta_norm_le _ d) |
|
|
| /-- Actual nonlinear remainder. The positive total's norm bound is the only |
| analytic bound required; no degree-bound or series-sum hypothesis is assumed. -/ |
| theorem free_exponential_product_remainder |
| (rows : List (MonoidAlgebra ℂ (FreeGroup A) × MonoidAlgebra ℝ (FreeGroup A))) |
| (h : ∀ row ∈ rows, 0 ≤ row.2 ∧ normCoefficients row.1 ≤ row.2) |
| {α : ℝ} (hα : 0 < α) (hhalf : α < 1 / 2) |
| (hbound : ‖realRegular (rows.map Prod.snd).sum‖ ≤ 2 * α) : |
| ‖((rows.map (fun r => NormedSpace.exp (regular r.1))).prod - 1 - |
| (rows.map (fun r => regular r.1)).sum) delta‖ ≤ 4 * α ^ 2 / (1 - 2 * α) := by |
| let xs : List Op := rows.map (fun r => regular r.1) |
| let coeff : ℕ → H := fun d => exponentialDegree xs d delta |
| have hsum : HasSum coeff ((xs.map NormedSpace.exp).prod delta) := by |
| exact (exponentialDegree_hasSum xs).map |
| (ContinuousLinearMap.apply ℂ H delta).toAddMonoidHom |
| (ContinuousLinearMap.apply ℂ H delta).continuous |
| have hid (d : ℕ) : exponentialDegree xs d = |
| regular (exponentialDegree (rows.map Prod.fst) d) := by |
| simpa [xs, List.map_map, Function.comp_def] using |
| (exponentialDegree_map (regular.restrictScalars ℝ) (rows.map Prod.fst) d).symm |
| have hdegree (d : ℕ) : ‖coeff d‖ ≤ (2 * α) ^ d := by |
| change ‖exponentialDegree xs d delta‖ ≤ _ |
| rw [hid] |
| exact (free_exponentialDegree_bound rows h d).trans |
| (pow_le_pow_left₀ (norm_nonneg _) hbound d) |
| have ht := perturbation_remainder_from_degree_bounds hα hhalf coeff hsum |
| (fun n => hdegree (n + 2)) |
| simpa [coeff, xs, List.map_map, Function.comp_def, sub_apply] using ht |
|
|
| end |
|
|
| /-! Signed rows B_k and positive rows A_k with free basis indexed by prefix ratios in FreeGroup Nat. -/ |
| section |
| open scoped BigOperators |
| open Generator.CoefficientOrder Generator.FreeConvolution |
| local notation "G" => FreeGroup ℕ |
| local notation "F" => FreeGroup G |
| local instance : DecidableEq G := Classical.decEq _ |
| local instance : DecidableEq F := Classical.decEq _ |
|
|
| def positiveLetterPair (p : G) : MonoidAlgebra ℝ F := |
| MonoidAlgebra.single (letter (p, true)) 1 + MonoidAlgebra.single (letter (p, false)) 1 |
|
|
| def negativeLetterPair (p : G) : MonoidAlgebra ℂ F := |
| MonoidAlgebra.single (letter (p, true)) 1 - MonoidAlgebra.single (letter (p, false)) 1 |
|
|
| def perturbationRow {n : ℕ} (α : ℝ) (k : Fin n) : MonoidAlgebra ℂ F × MonoidAlgebra ℝ F := |
| ((α / (2 * n)) • ∑ j : Fin n, negativeLetterPair (pairRatio (k, j)), |
| (α / (2 * n)) • ∑ j : Fin n, positiveLetterPair (pairRatio (k, j))) |
|
|
| def perturbationRows (n : ℕ) (α : ℝ) : |
| List (MonoidAlgebra ℂ F × MonoidAlgebra ℝ F) := List.ofFn (perturbationRow (n := n) α) |
|
|
| theorem positiveLetterPair_nonnegative (p : G) : 0 ≤ positiveLetterPair p := by |
| intro w |
| simp only [positiveLetterPair, MonoidAlgebra.coeff_add, Finsupp.add_apply, |
| MonoidAlgebra.coeff_single, Finsupp.single_apply] |
| split_ifs <;> norm_num |
|
|
| theorem negativeLetterPair_dominated (p : G) : |
| normCoefficients (negativeLetterPair p) ≤ positiveLetterPair p := by |
| simpa [negativeLetterPair, positiveLetterPair] using |
| normCoefficients_sub_le (MonoidAlgebra.single (letter (p, true)) 1) |
| (MonoidAlgebra.single (letter (p, false)) 1) |
|
|
| /-- Positivity and domination are proved for the source rows, not assumed. -/ |
| theorem perturbationRows_dominated (n : ℕ) (α : ℝ) (hα : 0 ≤ α) : |
| ∀ row ∈ perturbationRows n α, 0 ≤ row.2 ∧ normCoefficients row.1 ≤ row.2 := by |
| intro row hr |
| obtain ⟨k, rfl⟩ := List.mem_ofFn.mp (show row ∈ List.ofFn (perturbationRow (n := n) α) from hr) |
| have hc : 0 ≤ α / (2 * n) := by positivity |
| have hp : 0 ≤ ∑ j : Fin n, positiveLetterPair (pairRatio (k, j)) := |
| Finset.sum_nonneg (fun j _ => positiveLetterPair_nonnegative _) |
| constructor |
| · intro w |
| change 0 ≤ α / (2 * n) * (∑ j : Fin n, positiveLetterPair (pairRatio (k, j))).coeff w |
| exact mul_nonneg hc (hp w) |
| · change normCoefficients ((α / (2 * n)) • _) ≤ (α / (2 * n)) • _ |
| rw [normCoefficients_real_smul _ hc] |
| have hb : normCoefficients (∑ j : Fin n, negativeLetterPair (pairRatio (k, j))) ≤ |
| ∑ j : Fin n, positiveLetterPair (pairRatio (k, j)) := |
| (normCoefficients_sum_le _ _).trans |
| (Finset.sum_le_sum (fun j _ => negativeLetterPair_dominated _)) |
| intro w |
| exact mul_le_mul_of_nonneg_left (hb w) hc |
|
|
| /-- Exact regrouping of the ordered-pair sum using the proved fiber counts. -/ |
| theorem pairRatio_sum_multiplicity {R : Type*} [AddCommMonoid R] |
| (n : ℕ) (hn : 0 < n) (f : G → R) : |
| (∑ k : Fin n, ∑ j : Fin n, f (pairRatio (k, j))) = |
| ∑ p ∈ ratioLabels n, multiplicity n p • f p := by |
| have hm : ∀ ij ∈ (Finset.univ : Finset (Fin n × Fin n)), pairRatio ij ∈ ratioLabels n := by |
| intro ij _ |
| rw [ratioLabels_eq_image hn] |
| exact Finset.mem_image.mpr ⟨ij, Finset.mem_univ _, rfl⟩ |
| have h := Finset.sum_fiberwise_of_maps_to' hm f |
| simpa [multiplicity, Fintype.sum_prod_type] using h.symm |
|
|
| /-- The sum of the source's positive rows is exactly its collected coefficient |
| family, including the n copies of the identity prefix ratio. -/ |
| theorem perturbationRows_positive_total (n : ℕ) (hn : 0 < n) (α : ℝ) : |
| (perturbationRows n α |>.map Prod.snd).sum = |
| (α / (2 * n)) • ∑ p ∈ ratioLabels n, multiplicity n p • positiveLetterPair p := by |
| simp only [perturbationRows, List.map_ofFn, List.sum_ofFn, Function.comp_def, perturbationRow] |
| rw [← Finset.smul_sum, pairRatio_sum_multiplicity n hn] |
|
|
| /-- Identification of λ(A) with the signed-letter operator already bounded. -/ |
| theorem perturbationRows_total_operator (n : ℕ) (hn : 0 < n) (α : ℝ) : |
| realRegular (perturbationRows n α |>.map Prod.snd).sum = |
| ∑ a ∈ prefixLetterSupport n, (prefixWeight n α a : ℂ) • leftRegular (letter a) := by |
| rw [perturbationRows_positive_total n hn] |
| simp only [map_smul, map_sum, map_nsmul, Finset.smul_sum] |
| simp only [prefixLetterSupport, Finset.product_eq_sprod, prefixWeight, |
| Finset.sum_product, Fintype.sum_bool] |
| apply Finset.sum_congr rfl |
| intro p _ |
| simp [positiveLetterPair, realRegular, MonoidAlgebra.lift_single, leftRegularHom, |
| smul_add] |
| simp only [← nsmul_eq_mul, ← Nat.cast_smul_eq_nsmul ℝ, smul_smul] |
| norm_cast |
|
|
| /-- Uniform all-degree bound for the manuscript's literal formal rows. -/ |
| theorem perturbationRows_degree_bound (n : ℕ) (hn : 0 < n) |
| (α : ℝ) (hα : 0 ≤ α) (d : ℕ) : |
| ‖regular (exponentialDegree (perturbationRows n α |>.map Prod.fst) d) delta‖ ≤ |
| (2 * α) ^ d := by |
| apply (free_exponentialDegree_bound _ (perturbationRows_dominated n α hα) d).trans |
| apply pow_le_pow_left₀ (norm_nonneg _) |
| rw [perturbationRows_total_operator n hn] |
| exact prefix_convolution_operator_bound n hn α hα |
|
|
| /-- The source's nonlinear estimate on the actual regular representation, |
| with its exact rows and constants, for every positive word length. -/ |
| theorem perturbationRows_remainder (n : ℕ) (hn : 0 < n) |
| (α : ℝ) (hα : 0 < α) (hhalf : α < 1 / 2) : |
| ‖((perturbationRows n α |>.map (fun r => NormedSpace.exp (regular r.1))).prod - 1 - |
| (perturbationRows n α |>.map (fun r => regular r.1)).sum) delta‖ ≤ |
| 4 * α ^ 2 / (1 - 2 * α) := by |
| apply free_exponential_product_remainder _ (perturbationRows_dominated n α hα.le) hα hhalf |
| rw [perturbationRows_total_operator n hn] |
| exact prefix_convolution_operator_bound n hn α hα.le |
|
|
| end |
|
|
| /-! Transfer of the nonlinear estimate to an algebra with a continuous Hilbert |
| realization and orthonormal reduced-word images, without an independence hypothesis. -/ |
| section |
| open scoped BigOperators InnerProductSpace |
| open Generator.FreeConvolution |
| variable {B E : Type*} [NormedRing B] [NormedAlgebra ℂ B] [CompleteSpace B] |
| variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] |
| local notation "F" => FreeGroup (FreeGroup ℕ) |
|
|
| /-- The literal source remainder in any continuous Hilbert realization whose |
| reduced-word images are orthonormal. -/ |
| theorem perturbationRows_remainder_transfer |
| (Φ : MonoidAlgebra ℂ F →ₐ[ℂ] B) (ι : B →L[ℂ] E) |
| (horth : Orthonormal ℂ (fun g => ι (Φ (MonoidAlgebra.single g 1)))) |
| (n : ℕ) (hn : 0 < n) (α : ℝ) (hα : 0 < α) (hhalf : α < 1 / 2) : |
| ‖ι ((perturbationRows n α |>.map (fun r => NormedSpace.exp (Φ r.1))).prod - |
| 1 - (perturbationRows n α |>.map (fun r => Φ r.1)).sum)‖ ≤ |
| 4 * α ^ 2 / (1 - 2 * α) := by |
| let xs : List B := (perturbationRows n α).map (fun r => Φ r.1) |
| let coeff : ℕ → E := fun d => ι (exponentialDegree xs d) |
| have hsum : HasSum coeff (ι (xs.map NormedSpace.exp).prod) := |
| (exponentialDegree_hasSum xs).map ι.toAddMonoidHom ι.continuous |
| have hbound : ‖realRegular (perturbationRows n α |>.map Prod.snd).sum‖ ≤ 2 * α := by |
| rw [perturbationRows_total_operator n hn] |
| exact prefix_convolution_operator_bound n hn α hα.le |
| have hid (d : ℕ) : exponentialDegree xs d = |
| Φ (exponentialDegree (perturbationRows n α |>.map Prod.fst) d) := by |
| simpa [xs, List.map_map, Function.comp_def] using |
| (exponentialDegree_map (Φ.restrictScalars ℝ) (perturbationRows n α |>.map Prod.fst) d).symm |
| have hdegree (d : ℕ) : ‖coeff d‖ ≤ (2 * α) ^ d := by |
| change ‖ι (exponentialDegree xs d)‖ ≤ _ |
| rw [hid] |
| have hiso := groupRing_norm_eq_regular (ι.toLinearMap.comp Φ.toLinearMap) horth |
| (exponentialDegree (perturbationRows n α |>.map Prod.fst) d) |
| change ‖ι (Φ (exponentialDegree (perturbationRows n α |>.map Prod.fst) d))‖ = _ at hiso |
| rw [hiso] |
| exact (free_exponentialDegree_bound (perturbationRows n α) |
| (perturbationRows_dominated n α hα.le) d).trans |
| (pow_le_pow_left₀ (norm_nonneg _) hbound d) |
| have ht := perturbation_remainder_from_degree_bounds hα hhalf coeff hsum |
| (fun k => hdegree (k + 2)) |
| simpa [coeff, xs, List.map_map, Function.comp_def, map_sub] using ht |
|
|
| end |
|
|
| /-! The exact finite free basis and its injective realization in a countable free basis. -/ |
| section |
| open scoped BigOperators |
| open Generator.FreeConvolution |
| local notation "G" => FreeGroup ℕ |
| local notation "F" => FreeGroup G |
| local instance : DecidableEq G := Classical.decEq _ |
|
|
| /-- The manuscript's finite set S, including the identity prefix ratio as a label. -/ |
| def PrefixLabel (n : ℕ) := {p : G // p ∈ ratioLabels n} |
|
|
| def pairLabel {n : ℕ} (k j : Fin n) : PrefixLabel n := |
| ⟨pairRatio (k, j), by |
| rw [ratioLabels_eq_image (Nat.zero_lt_of_lt k.isLt)] |
| exact Finset.mem_image.mpr ⟨(k, j), Finset.mem_univ _, rfl⟩⟩ |
|
|
| def prefixWordEmbedding (n : ℕ) : FreeGroup (PrefixLabel n) →* F := |
| FreeGroup.map Subtype.val |
|
|
| theorem prefixWordEmbedding_injective (n : ℕ) : Function.Injective (prefixWordEmbedding n) := |
| FreeGroup.map_injective Subtype.val_injective |
|
|
| def prefixRingEmbedding (n : ℕ) : MonoidAlgebra ℂ (FreeGroup (PrefixLabel n)) →ₐ[ℂ] |
| MonoidAlgebra ℂ F := MonoidAlgebra.mapDomainAlgHom ℂ ℂ (prefixWordEmbedding n) |
|
|
| @[simp] theorem prefixRingEmbedding_single (n : ℕ) (g : FreeGroup (PrefixLabel n)) (c : ℂ) : |
| prefixRingEmbedding n (MonoidAlgebra.single g c) = |
| MonoidAlgebra.single (prefixWordEmbedding n g) c := by |
| exact MonoidAlgebra.mapDomain_single |
|
|
| /-- Literal B_k in the free group on the finite label set S. -/ |
| def finitePerturbationRow {n : ℕ} (α : ℝ) (k : Fin n) : |
| MonoidAlgebra ℂ (FreeGroup (PrefixLabel n)) := |
| (α / (2 * n)) • ∑ j : Fin n, |
| (MonoidAlgebra.single (FreeGroup.of (pairLabel k j)) 1 - |
| MonoidAlgebra.single ((FreeGroup.of (pairLabel k j))⁻¹) 1) |
|
|
| def finitePerturbationRows (n : ℕ) (α : ℝ) := |
| List.ofFn (finitePerturbationRow (n := n) α) |
|
|
| @[simp] theorem finitePerturbationRow_embed {n : ℕ} (α : ℝ) (k : Fin n) : |
| prefixRingEmbedding n (finitePerturbationRow α k) = (perturbationRow α k).1 := by |
| have hs (c : ℝ) (f : MonoidAlgebra ℂ (FreeGroup (PrefixLabel n))) : |
| prefixRingEmbedding n (c • f) = c • prefixRingEmbedding n f := |
| map_smul ((prefixRingEmbedding n).restrictScalars ℝ).toLinearMap c f |
| simp only [finitePerturbationRow, perturbationRow, hs, map_sum, map_sub, |
| prefixRingEmbedding_single] |
| congr 1 |
|
|
| theorem finitePerturbationRows_embed (n : ℕ) (α : ℝ) : |
| (finitePerturbationRows n α).map (prefixRingEmbedding n) = |
| (perturbationRows n α).map Prod.fst := by |
| simp [finitePerturbationRows, perturbationRows, List.map_ofFn, Function.comp_def] |
|
|
| def embeddedCoefficientMap (n : ℕ) : |
| MonoidAlgebra ℂ (FreeGroup (PrefixLabel n)) →ₗ[ℂ] SquareSpace F := |
| (ContinuousLinearMap.apply ℂ (SquareSpace F) delta).toLinearMap.comp |
| (regular.toLinearMap.comp (prefixRingEmbedding n).toLinearMap) |
|
|
| theorem embeddedCoefficientMap_orthonormal (n : ℕ) : |
| Orthonormal ℂ (fun g => embeddedCoefficientMap n (MonoidAlgebra.single g 1)) := by |
| have h := regular_delta_orthonormal.comp (prefixWordEmbedding n) (prefixWordEmbedding_injective n) |
| simpa [embeddedCoefficientMap, LinearMap.comp_apply, Function.comp_def] using h |
|
|
| /-- All-degree estimate on the exact finite formal group F_S. -/ |
| theorem finitePerturbationRows_degree_bound (n : ℕ) (hn : 0 < n) |
| (α : ℝ) (hα : 0 ≤ α) (d : ℕ) : |
| ‖embeddedCoefficientMap n (exponentialDegree (finitePerturbationRows n α) d)‖ ≤ |
| (2 * α) ^ d := by |
| change ‖regular (prefixRingEmbedding n (exponentialDegree (finitePerturbationRows n α) d)) delta‖ ≤ _ |
| have hmap := exponentialDegree_map ((prefixRingEmbedding n).restrictScalars ℝ) |
| (finitePerturbationRows n α) d |
| change prefixRingEmbedding n (exponentialDegree (finitePerturbationRows n α) d) = |
| exponentialDegree ((finitePerturbationRows n α).map (prefixRingEmbedding n)) d at hmap |
| rw [hmap, finitePerturbationRows_embed] |
| exact perturbationRows_degree_bound n hn α hα d |
|
|
| end |
|
|
| /-! Exact finite-basis version of the source's nonlinear estimate. Unlike the |
| ambient transport lemma, only reduced words in F_S occur in the hypothesis. -/ |
| open scoped BigOperators InnerProductSpace |
| variable {B E : Type*} [NormedRing B] [NormedAlgebra ℂ B] [CompleteSpace B] |
| variable [NormedAddCommGroup E] [InnerProductSpace ℂ E] |
|
|
| /-- Remainder bounds in a continuous Hilbert realization of the finite free group with orthonormal word images. -/ |
| theorem finite_prefix_remainder_transfer (n : ℕ) (hn : 0 < n) |
| (Φ : MonoidAlgebra ℂ (FreeGroup (PrefixLabel n)) →ₐ[ℂ] B) (ι : B →L[ℂ] E) |
| (horth : Orthonormal ℂ (fun g => ι (Φ (MonoidAlgebra.single g 1)))) |
| (α : ℝ) (hα : 0 < α) (hhalf : α < 1 / 2) : |
| ‖ι ((finitePerturbationRows n α |>.map (fun r => NormedSpace.exp (Φ r))).prod - |
| 1 - (finitePerturbationRows n α |>.map Φ).sum)‖ ≤ |
| 4 * α ^ 2 / (1 - 2 * α) := by |
| let xs : List B := (finitePerturbationRows n α).map Φ |
| let coeff : ℕ → E := fun d => ι (exponentialDegree xs d) |
| have hsum : HasSum coeff (ι (xs.map NormedSpace.exp).prod) := |
| (exponentialDegree_hasSum xs).map ι.toAddMonoidHom ι.continuous |
| have hid (d : ℕ) : exponentialDegree xs d = |
| Φ (exponentialDegree (finitePerturbationRows n α) d) := by |
| exact (exponentialDegree_map (Φ.restrictScalars ℝ) _ d).symm |
| have hdegree (d : ℕ) : ‖coeff d‖ ≤ (2 * α) ^ d := by |
| change ‖ι (exponentialDegree xs d)‖ ≤ _ |
| rw [hid] |
| have hiso := groupRing_norm_eq_of_orthonormal (ι.toLinearMap.comp Φ.toLinearMap) |
| (embeddedCoefficientMap n) horth (embeddedCoefficientMap_orthonormal n) |
| (exponentialDegree (finitePerturbationRows n α) d) |
| change ‖ι (Φ (exponentialDegree (finitePerturbationRows n α) d))‖ = _ at hiso |
| rw [hiso] |
| exact finitePerturbationRows_degree_bound n hn α hα.le d |
| have ht := perturbation_remainder_from_degree_bounds hα hhalf coeff hsum |
| (fun k => hdegree (k + 2)) |
| simpa [coeff, xs, List.map_map, Function.comp_def, map_sub] using ht |
|
|
| /-- The unconditional finite-free-group remainder, on the actual left regular |
| representation of exactly F_S and for every positive word length. -/ |
| theorem finite_prefix_regular_remainder (n : ℕ) (hn : 0 < n) |
| (α : ℝ) (hα : 0 < α) (hhalf : α < 1 / 2) : |
| ‖((finitePerturbationRows n α |>.map (fun r => NormedSpace.exp (FreeConvolution.regular r))).prod - |
| 1 - (finitePerturbationRows n α |>.map FreeConvolution.regular).sum) |
| FreeConvolution.delta‖ ≤ 4 * α ^ 2 / (1 - 2 * α) := by |
| exact finite_prefix_remainder_transfer n hn FreeConvolution.regular |
| (ContinuousLinearMap.apply ℂ (SquareSpace (FreeGroup (PrefixLabel n))) FreeConvolution.delta) |
| FreeConvolution.regular_delta_orthonormal α hα hhalf |
|
|
| end Generator |
|
|
| end |
|
|
| end OAI |
|
|
