Download data/lean/OAI/Analysis/FactorGeneration/Convolution.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 22 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/Convolution.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Analysis/FactorGeneration/Convolution.lean
-
curl -L -o Convolution.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Analysis/FactorGeneration/Convolution.lean
22 kB
| import Mathlib.Algebra.MonoidAlgebra.Basic | |
| import Mathlib.Analysis.InnerProductSpace.Orthonormal | |
| import Mathlib.Analysis.InnerProductSpace.l2Space | |
| import Mathlib.Analysis.Real.Sqrt | |
| import Mathlib.GroupTheory.FreeGroup.Reduce | |
| import OAI.Analysis.FactorGeneration.FreeWords | |
| namespace OAI | |
| noncomputable section | |
| namespace Generator | |
| /-! Coordinate masks and permutations on the actual complex square-summable space. | |
| These implement the Hilbert-space operations used in lem:length-one-convolution. -/ | |
| section | |
| open scoped BigOperators InnerProductSpace ENNReal | |
| attribute [local instance] Classical.propDecidable | |
| abbrev SquareSpace (X : Type*) := lp (fun _ : X => β) 2 | |
| variable {X I : Type*} | |
| theorem squareSpace_norm_sq (f : SquareSpace X) : | |
| βfβ ^ 2 = β' x, βf xβ ^ 2 := by | |
| simpa using lp.norm_rpow_eq_tsum (p := 2) (by norm_num) f | |
| def coordinateMask (s : Set X) (f : SquareSpace X) : SquareSpace X := | |
| β¨s.indicator f, f.property.mono' (fun x => by | |
| by_cases hx : x β s <;> simp [Set.indicator, hx])β© | |
| @[simp] theorem coordinateMask_apply (s : Set X) (f : SquareSpace X) (x : X) : | |
| coordinateMask s f x = if x β s then f x else 0 := rfl | |
| theorem coordinateMask_norm_le (s : Set X) (f : SquareSpace X) : | |
| βcoordinateMask s fβ β€ βfβ := by | |
| apply lp.norm_mono (by norm_num : (2 : ββ₯0β) β 0) | |
| intro x | |
| by_cases hx : x β s <;> simp [hx] | |
| theorem coordinateMask_add_compl (s : Set X) (f : SquareSpace X) : | |
| coordinateMask s f + coordinateMask sαΆ f = f := by | |
| ext x | |
| change coordinateMask s f x + coordinateMask sαΆ f x = f x | |
| by_cases hx : x β s <;> simp [hx] | |
| def coordinatePermute (e : X β X) (f : SquareSpace X) : SquareSpace X := | |
| β¨fun x => f (e x), memβp_gen ((e.summable_iff).2 (f.property.summable (by norm_num)))β© | |
| @[simp] theorem coordinatePermute_apply (e : X β X) (f : SquareSpace X) (x : X) : | |
| coordinatePermute e f x = f (e x) := rfl | |
| theorem coordinatePermute_norm (e : X β X) (f : SquareSpace X) : | |
| βcoordinatePermute e fβ = βfβ := by | |
| have h : βcoordinatePermute e fβ ^ 2 = βfβ ^ 2 := by | |
| rw [squareSpace_norm_sq, squareSpace_norm_sq] | |
| exact e.tsum_eq (fun x => βf xβ ^ 2) | |
| nlinarith [norm_nonneg (coordinatePermute e f), norm_nonneg f] | |
| /-- Reindexing by a permutation, as a bounded complex linear operator. -/ | |
| def coordinatePermuteCLM (e : X β X) : SquareSpace X βL[β] SquareSpace X := | |
| LinearMap.mkContinuous | |
| { toFun := coordinatePermute e | |
| map_add' := by intros; ext x; rfl | |
| map_smul' := by intros; ext x; rfl } | |
| 1 (fun f => by simpa using (coordinatePermute_norm e f).le) | |
| @[simp] theorem coordinatePermuteCLM_apply (e : X β X) (f : SquareSpace X) (x : X) : | |
| coordinatePermuteCLM e f x = f (e x) := rfl | |
| /-- Disjoint coordinate support implies genuine Hilbert orthogonality. -/ | |
| theorem squareSpace_inner_zero {f g : SquareSpace X} | |
| (h : β x, f x = 0 β¨ g x = 0) : inner β f g = 0 := by | |
| change (β' x, inner β (f x) (g x)) = 0 | |
| have hz : β x, inner β (f x) (g x) = 0 := by | |
| intro x | |
| rcases h x with hx | hx <;> simp [hx] | |
| simp only [hz, tsum_zero] | |
| /-- Pythagoras for a finite family with disjoint supports. -/ | |
| theorem squareSpace_sum_norm_sq (s : Finset I) (f : I β SquareSpace X) | |
| (h : β i β s, β j β s, i β j β β x, f i x = 0 β¨ f j x = 0) : | |
| ββ i β s, f iβ ^ 2 = β i β s, βf iβ ^ 2 := by | |
| have hc : inner β (β i β s, f i) (β i β s, f i) = | |
| β i β s, inner β (f i) (f i) := by | |
| rw [sum_inner] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| rw [inner_sum] | |
| exact Finset.sum_eq_single i | |
| (fun j hj hji => squareSpace_inner_zero (h i hi j hj hji.symm)) | |
| (fun hn => (hn hi).elim) | |
| have hr := congrArg (RCLike.re : β β β) hc | |
| simpa only [map_sum, inner_self_eq_norm_sq] using hr | |
| /-- The projections onto finitely many disjoint coordinate sets have total | |
| squared mass at most that of the original vector. -/ | |
| theorem coordinateMask_sum_sq_le (s : Finset I) (U : I β Set X) | |
| (hU : β i β s, β j β s, i β j β Disjoint (U i) (U j)) | |
| (f : SquareSpace X) : | |
| β i β s, βcoordinateMask (U i) fβ ^ 2 β€ βfβ ^ 2 := by | |
| have horth : β i β s, β j β s, i β j β β x, | |
| coordinateMask (U i) f x = 0 β¨ coordinateMask (U j) f x = 0 := by | |
| intro i hi j hj hij x | |
| by_cases hx : x β U i | |
| Β· right | |
| have hn : x β U j := fun hxj => Set.disjoint_left.mp (hU i hi j hj hij) hx hxj | |
| simp [hn] | |
| Β· left; simp [hx] | |
| rw [β squareSpace_sum_norm_sq s _ horth] | |
| have hnorm : ββ i β s, coordinateMask (U i) fβ β€ βfβ := by | |
| apply lp.norm_mono (by norm_num : (2 : ββ₯0β) β 0) | |
| intro x | |
| simp only [lp.coeFn_sum, Finset.sum_apply] | |
| by_cases hex : β i β s, x β U i | |
| Β· obtain β¨i, hi, hxiβ© := hex | |
| rw [Finset.sum_eq_single i] | |
| Β· simp [hxi] | |
| Β· intro j hj hji | |
| have hn : x β U j := fun hxj => | |
| Set.disjoint_left.mp (hU i hi j hj hji.symm) hxi hxj | |
| simp [hn] | |
| Β· exact fun hn => (hn hi).elim | |
| Β· have hz : β i β s, coordinateMask (U i) f x = 0 := by | |
| intro i hi | |
| simp [show x β U i from fun hx => hex β¨i, hi, hxβ©] | |
| rw [Finset.sum_eq_zero hz, norm_zero] | |
| exact norm_nonneg _ | |
| nlinarith [norm_nonneg (β i β s, coordinateMask (U i) f), norm_nonneg f] | |
| end | |
| /-! Length-one convolution bounds for the left regular representation of a free group on an arbitrary basis. -/ | |
| section | |
| open scoped BigOperators InnerProductSpace | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| namespace FreeConvolution | |
| variable {A : Type*} | |
| abbrev Letter (A : Type*) := A Γ Bool | |
| def inverseLetter (a : Letter A) : Letter A := (a.1, !a.2) | |
| def letter (a : Letter A) : FreeGroup A := FreeGroup.mk [a] | |
| def begins (a : Letter A) (w : FreeGroup A) : Prop := w.toWord.head? = some a | |
| @[simp] theorem inverseLetter_inverse (a : Letter A) : inverseLetter (inverseLetter a) = a := by | |
| cases a; simp [inverseLetter] | |
| theorem inverseLetter_injective : Function.Injective (inverseLetter : Letter A β Letter A) := | |
| Function.Involutive.injective inverseLetter_inverse | |
| @[simp] theorem letter_toWord (a : Letter A) : (letter a).toWord = [a] := by | |
| simp [letter] | |
| @[simp] theorem letter_inverse (a : Letter A) : letter (inverseLetter a) = (letter a)β»ΒΉ := by | |
| simp [letter, FreeGroup.inv_mk, FreeGroup.invRev, inverseLetter] | |
| @[simp] theorem letter_true (a : A) : letter (a, true) = FreeGroup.of a := rfl | |
| theorem letter_false (a : A) : letter (a, false) = (FreeGroup.of a)β»ΒΉ := by | |
| simpa [inverseLetter] using letter_inverse (a, true) | |
| theorem letter_injective : Function.Injective (letter : Letter A β FreeGroup A) := by | |
| intro a b h | |
| have hw := congrArg FreeGroup.toWord h | |
| simpa only [letter_toWord, List.singleton_inj] using hw | |
| /-- A noncancelling left multiplication creates its signed letter as the head. -/ | |
| theorem begins_letter_mul (a : Letter A) (w : FreeGroup A) | |
| (h : Β¬ begins (inverseLetter a) w) : begins a (letter a * w) := by | |
| unfold begins at * | |
| rw [FreeGroup.toWord_mul, letter_toWord, List.singleton_append, | |
| FreeGroup.reduce.cons, FreeGroup.reduce_toWord] | |
| cases hw : w.toWord with | |
| | nil => simp | |
| | cons b bs => | |
| have hn : Β¬ (a.1 = b.1 β§ a.2 = !b.2) := by | |
| intro he | |
| apply h | |
| simp only [hw, List.head?_cons, Option.some.injEq] | |
| apply Prod.ext | |
| Β· exact he.1.symm | |
| Β· simpa [inverseLetter] using congrArg Bool.not he.2.symm | |
| simp [hn] | |
| /-- The actual left regular translation Ξ»(g)Ξ·(x)=Ξ·(gβ»ΒΉx). -/ | |
| def leftRegular (g : FreeGroup A) : SquareSpace (FreeGroup A) βL[β] SquareSpace (FreeGroup A) := | |
| coordinatePermuteCLM (Equiv.mulLeft gβ»ΒΉ) | |
| @[simp] theorem leftRegular_apply (g : FreeGroup A) (f : SquareSpace (FreeGroup A)) | |
| (x : FreeGroup A) : leftRegular g f x = f (gβ»ΒΉ * x) := rfl | |
| @[simp] theorem leftRegular_norm (g : FreeGroup A) (f : SquareSpace (FreeGroup A)) : | |
| βleftRegular g fβ = βfβ := coordinatePermute_norm _ _ | |
| def creation (a : Letter A) (f : SquareSpace (FreeGroup A)) : SquareSpace (FreeGroup A) := | |
| leftRegular (letter a) (coordinateMask {w | Β¬ begins (inverseLetter a) w} f) | |
| def cancellation (a : Letter A) (f : SquareSpace (FreeGroup A)) : SquareSpace (FreeGroup A) := | |
| leftRegular (letter a) (coordinateMask {w | begins (inverseLetter a) w} f) | |
| theorem creation_add_cancellation (a : Letter A) (f : SquareSpace (FreeGroup A)) : | |
| creation a f + cancellation a f = leftRegular (letter a) f := by | |
| rw [creation, cancellation, β map_add] | |
| congr 1 | |
| ext x | |
| change coordinateMask {w | Β¬ begins (inverseLetter a) w} f x + | |
| coordinateMask {w | begins (inverseLetter a) w} f x = f x | |
| by_cases hx : begins (inverseLetter a) x <;> simp [hx] | |
| theorem creation_support (a : Letter A) (f : SquareSpace (FreeGroup A)) (x : FreeGroup A) | |
| (hx : Β¬ begins a x) : creation a f x = 0 := by | |
| simp only [creation, leftRegular_apply, coordinateMask_apply, Set.mem_ofPred_eq] | |
| rw [ite_eq_right] | |
| intro hn | |
| apply hx | |
| simpa using begins_letter_mul a ((letter a)β»ΒΉ * x) hn | |
| theorem begins_disjoint {a b : Letter A} (hab : a β b) : | |
| Disjoint {w : FreeGroup A | begins a w} {w | begins b w} := by | |
| apply Set.disjoint_left.mpr | |
| intro w ha hb | |
| exact hab (Option.some.inj (ha.symm.trans hb)) | |
| theorem creation_norm_le (a : Letter A) (f : SquareSpace (FreeGroup A)) : | |
| βcreation a fβ β€ βfβ := by | |
| rw [creation, leftRegular_norm] | |
| exact coordinateMask_norm_le _ _ | |
| theorem creation_sum_bound (s : Finset (Letter A)) (b : Letter A β β) | |
| (f : SquareSpace (FreeGroup A)) : | |
| ββ a β s, b a β’ creation a fβ β€ Real.sqrt (β a β s, βb aβ ^ 2) * βfβ := by | |
| have horth : β a β s, β c β s, a β c β β x, | |
| (b a β’ creation a f) x = 0 β¨ (b c β’ creation c f) x = 0 := by | |
| intro a _ c _ hac x | |
| by_cases hx : begins a x | |
| Β· right | |
| have hn : Β¬ begins c x := fun hc => Set.disjoint_left.mp (begins_disjoint hac) hx hc | |
| simp [lp.coeFn_smul, creation_support c f x hn] | |
| Β· left; simp [lp.coeFn_smul, creation_support a f x hx] | |
| have hsq : ββ a β s, b a β’ creation a fβ ^ 2 β€ | |
| (β a β s, βb aβ ^ 2) * βfβ ^ 2 := by | |
| rw [squareSpace_sum_norm_sq s _ horth, Finset.sum_mul] | |
| apply Finset.sum_le_sum | |
| intro a _ | |
| rw [norm_smul, mul_pow] | |
| apply mul_le_mul_of_nonneg_left _ (sq_nonneg _) | |
| exact sq_le_sqβ (norm_nonneg _) (norm_nonneg _) |>.mpr (creation_norm_le a f) | |
| have hS : 0 β€ β a β s, βb aβ ^ 2 := Finset.sum_nonneg (fun _ _ => sq_nonneg _) | |
| have he : (Real.sqrt (β a β s, βb aβ ^ 2) * βfβ) ^ 2 = | |
| (β a β s, βb aβ ^ 2) * βfβ ^ 2 := by rw [mul_pow, Real.sq_sqrt hS] | |
| exact (sq_le_sqβ (norm_nonneg _) (mul_nonneg (Real.sqrt_nonneg _) (norm_nonneg _))).mp | |
| (hsq.trans_eq he.symm) | |
| theorem cancellation_sum_bound (s : Finset (Letter A)) (b : Letter A β β) | |
| (f : SquareSpace (FreeGroup A)) : | |
| ββ a β s, b a β’ cancellation a fβ β€ Real.sqrt (β a β s, βb aβ ^ 2) * βfβ := by | |
| have hmass : β a β s, βcancellation a fβ ^ 2 β€ βfβ ^ 2 := by | |
| simp only [cancellation, leftRegular_norm] | |
| exact coordinateMask_sum_sq_le s _ | |
| (fun a _ c _ hac => begins_disjoint (fun h => hac (inverseLetter_injective h))) f | |
| calc | |
| _ β€ β a β s, βb aβ * βcancellation a fβ := by | |
| simpa only [norm_smul] using norm_sum_le s (fun a => b a β’ cancellation a f) | |
| _ β€ Real.sqrt (β a β s, βb aβ ^ 2) * | |
| Real.sqrt (β a β s, βcancellation a fβ ^ 2) := Real.sum_mul_le_sqrt_mul_sqrt _ _ _ | |
| _ β€ Real.sqrt (β a β s, βb aβ ^ 2) * Real.sqrt (βfβ ^ 2) := | |
| mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt hmass) (Real.sqrt_nonneg _) | |
| _ = _ := by rw [Real.sqrt_sq (norm_nonneg f)] | |
| /-- The manuscript's length-one bound on every vector of βΒ²(FreeGroup A). -/ | |
| theorem length_one_convolution_vector_bound (s : Finset (Letter A)) (b : Letter A β β) | |
| (f : SquareSpace (FreeGroup A)) : | |
| β(β a β s, b a β’ leftRegular (letter a)) fβ β€ | |
| (2 * Real.sqrt (β a β s, βb aβ ^ 2)) * βfβ := by | |
| have he : (β a β s, b a β’ leftRegular (letter a)) f = | |
| (β a β s, b a β’ creation a f) + (β a β s, b a β’ cancellation a f) := by | |
| simp only [sum_apply, smul_apply, | |
| β creation_add_cancellation, smul_add, Finset.sum_add_distrib] | |
| rw [he] | |
| have ht := norm_add_le (β a β s, b a β’ creation a f) (β a β s, b a β’ cancellation a f) | |
| have hc := creation_sum_bound s b f | |
| have hd := cancellation_sum_bound s b f | |
| linarith | |
| /-- The length-one convolution estimate for the operator norm of the left regular action. -/ | |
| theorem length_one_convolution_operator_bound (s : Finset (Letter A)) (b : Letter A β β) : | |
| ββ a β s, b a β’ leftRegular (letter a)β β€ | |
| 2 * Real.sqrt (β a β s, βb aβ ^ 2) := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (by positivity) | |
| exact length_one_convolution_vector_bound s b | |
| end FreeConvolution | |
| end | |
| /-! Group-ring action on βΒ² and the coefficient-vector identity. -/ | |
| section | |
| open scoped BigOperators ENNReal | |
| attribute [local instance] Classical.propDecidable Classical.decEq | |
| namespace FreeConvolution | |
| variable {A : Type*} | |
| local notation "H" => SquareSpace (FreeGroup A) | |
| local notation "Op" => H βL[β] H | |
| def leftRegularHom : FreeGroup A β* Op where | |
| toFun := leftRegular | |
| map_one' := by ext f x; simp | |
| map_mul' g h := by ext f x; simp [mul_inv_rev, mul_assoc] | |
| def regular : MonoidAlgebra β (FreeGroup A) ββ[β] Op := | |
| MonoidAlgebra.lift β Op (FreeGroup A) leftRegularHom | |
| def realRegular : MonoidAlgebra β (FreeGroup A) ββ[β] Op := | |
| MonoidAlgebra.lift β Op (FreeGroup A) leftRegularHom | |
| def delta : H := lp.single 2 1 1 | |
| @[simp] theorem delta_apply (x : FreeGroup A) : (delta : H) x = if x = 1 then 1 else 0 := by | |
| by_cases hx : x = 1 <;> simp [delta, lp.single_apply, hx] | |
| @[simp] theorem delta_norm : β(delta : H)β = 1 := by | |
| simp [delta, lp.norm_single (by norm_num : (0 : ββ₯0β) < 2)] | |
| @[simp] theorem leftRegular_delta_apply (g x : FreeGroup A) : | |
| leftRegular g (delta : H) x = if x = g then 1 else 0 := by | |
| simp [inv_mul_eq_one, eq_comm] | |
| /-- Applying the actual convolution operator to Ξ΄β recovers every coefficient. -/ | |
| theorem regular_delta_apply (f : MonoidAlgebra β (FreeGroup A)) (x : FreeGroup A) : | |
| regular f delta x = f.coeff x := by | |
| simp only [regular, MonoidAlgebra.lift_apply, Finsupp.sum, sum_apply, smul_apply, | |
| leftRegularHom] | |
| simp only [lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply] | |
| simp [inv_mul_eq_one, eq_comm, Finsupp.mem_support_iff] | |
| theorem realRegular_delta_apply (f : MonoidAlgebra β (FreeGroup A)) (x : FreeGroup A) : | |
| realRegular f delta x = (f.coeff x : β) := by | |
| simp only [realRegular, MonoidAlgebra.lift_apply, Finsupp.sum, sum_apply, smul_apply, | |
| leftRegularHom] | |
| simp only [lp.coeFn_sum, Finset.sum_apply, lp.coeFn_smul, Pi.smul_apply] | |
| simp [inv_mul_eq_one, eq_comm, Finsupp.mem_support_iff] | |
| intro h | |
| simp [β h] | |
| theorem regular_single_delta (g : FreeGroup A) : | |
| regular (MonoidAlgebra.single g 1) delta = lp.single 2 g 1 := by | |
| ext x | |
| rw [regular_delta_apply] | |
| by_cases hx : x = g <;> simp [MonoidAlgebra.coeff_single, lp.single_apply, hx] | |
| theorem regular_delta_orthonormal : | |
| Orthonormal β (fun g : FreeGroup A => regular (MonoidAlgebra.single g 1) delta) := by | |
| rw [orthonormal_iff_ite] | |
| intro g h | |
| simp only [regular_single_delta] | |
| by_cases hgh : g = h | |
| Β· subst h | |
| simp [inner_self_eq_norm_sq_to_K, lp.norm_single (by norm_num : (0 : ββ₯0β) < 2)] | |
| Β· rw [ite_eq_right hgh] | |
| apply squareSpace_inner_zero | |
| intro x | |
| by_cases hx : x = g | |
| Β· right | |
| have hx' : x β h := by simpa [hx] using hgh | |
| simp [lp.single_apply, hx'] | |
| Β· left; simp [lp.single_apply, hx] | |
| /-- Exact finite coefficient LΒ² isometry in the regular representation. -/ | |
| theorem regular_coefficient_isometry (f : MonoidAlgebra β (FreeGroup A)) : | |
| βregular f deltaβ ^ 2 = β x β f.coeff.support, βf.coeff xβ ^ 2 := by | |
| rw [squareSpace_norm_sq] | |
| simp only [regular_delta_apply] | |
| apply tsum_eq_sum | |
| intro x hx | |
| simp [Finsupp.notMem_support_iff.mp hx] | |
| /-- Coefficient domination implies the βΒ² inequality; no comparison between | |
| operator norms in distinct representations is used. -/ | |
| theorem regular_delta_norm_le {f : MonoidAlgebra β (FreeGroup A)} | |
| {a : MonoidAlgebra β (FreeGroup A)} (h : β x, βf.coeff xβ β€ a.coeff x) : | |
| βregular f deltaβ β€ βrealRegular a deltaβ := by | |
| apply lp.norm_mono (by norm_num : (2 : ββ₯0β) β 0) | |
| intro x | |
| rw [regular_delta_apply, realRegular_delta_apply, Complex.norm_real] | |
| exact (h x).trans (le_abs_self _) | |
| /-- Actual coefficient-vector power estimate. -/ | |
| theorem realRegular_pow_delta_norm_le (a : MonoidAlgebra β (FreeGroup A)) (d : β) : | |
| βrealRegular (a ^ d) deltaβ β€ βrealRegular aβ ^ d := by | |
| rw [map_pow] | |
| induction d with | |
| | zero => simp | |
| | succ d ih => | |
| rw [pow_succ', pow_succ'] | |
| exact (ContinuousLinearMap.le_opNorm (realRegular a) _).trans | |
| (mul_le_mul_of_nonneg_left ih (norm_nonneg _)) | |
| end FreeConvolution | |
| end | |
| /-! The finite coefficient LΒ² identity from orthonormality of reduced-word images. -/ | |
| section | |
| open scoped BigOperators InnerProductSpace | |
| variable {G E : Type*} [Monoid G] [NormedAddCommGroup E] [InnerProductSpace β E] | |
| /-- Linear images of a group-ring sum are its literal finite coefficient combination. -/ | |
| theorem groupRing_linear_combination (Ξ¨ : MonoidAlgebra β G ββ[β] E) | |
| (f : MonoidAlgebra β G) : | |
| Ξ¨ f = β g β f.coeff.support, f.coeff g β’ Ξ¨ (MonoidAlgebra.single g 1) := by | |
| conv_lhs => rw [β MonoidAlgebra.sum_coeff_single f] | |
| simp only [Finsupp.sum, map_sum] | |
| apply Finset.sum_congr rfl | |
| intro g _ | |
| rw [β map_smul] | |
| congr 1 | |
| simp | |
| /-- The source's coefficient isometry from actual orthonormal word images. -/ | |
| theorem groupRing_coefficient_isometry (Ξ¨ : MonoidAlgebra β G ββ[β] E) | |
| (hΞ¨ : Orthonormal β (fun g => Ξ¨ (MonoidAlgebra.single g 1))) | |
| (f : MonoidAlgebra β G) : | |
| βΞ¨ fβ ^ 2 = β g β f.coeff.support, βf.coeff gβ ^ 2 := by | |
| rw [groupRing_linear_combination Ξ¨ f, β inner_self_eq_norm_sq (π := β), hΞ¨.inner_sum] | |
| rw [map_sum] | |
| apply Finset.sum_congr rfl | |
| intro g _ | |
| rw [mul_comm] | |
| exact inner_self_eq_norm_sq (π := β) (f.coeff g) | |
| /-- Two orthonormal realizations have exactly the same coefficient norm. -/ | |
| theorem groupRing_norm_eq_of_orthonormal {E' : Type*} [NormedAddCommGroup E'] | |
| [InnerProductSpace β E'] (Ξ¨ : MonoidAlgebra β G ββ[β] E) | |
| (Ξ : MonoidAlgebra β G ββ[β] E') | |
| (hΞ¨ : Orthonormal β (fun g => Ξ¨ (MonoidAlgebra.single g 1))) | |
| (hΞ : Orthonormal β (fun g => Ξ (MonoidAlgebra.single g 1))) | |
| (f : MonoidAlgebra β G) : βΞ¨ fβ = βΞ fβ := by | |
| exact (sq_eq_sqβ (norm_nonneg _) (norm_nonneg _)).mp | |
| ((groupRing_coefficient_isometry Ψ hΨ f).trans | |
| (groupRing_coefficient_isometry Ξ hΞ f).symm) | |
| /-- For orthonormal word images, the finite coefficient norm agrees with the regular representation norm. -/ | |
| theorem groupRing_norm_eq_regular {A : Type*} | |
| (Ξ¨ : MonoidAlgebra β (FreeGroup A) ββ[β] E) | |
| (hΞ¨ : Orthonormal β (fun g => Ξ¨ (MonoidAlgebra.single g 1))) | |
| (f : MonoidAlgebra β (FreeGroup A)) : | |
| βΞ¨ fβ = βFreeConvolution.regular f FreeConvolution.deltaβ := by | |
| have h := (groupRing_coefficient_isometry Ψ hΨ f).trans | |
| (FreeConvolution.regular_coefficient_isometry f).symm | |
| exact (sq_eq_sqβ (norm_nonneg _) (norm_nonneg _)).mp h | |
| end | |
| /-! Multiplicity-weighted length-one convolution bounds. -/ | |
| open scoped BigOperators | |
| open Generator.FreeConvolution | |
| def prefixLetterSupport (n : β) : Finset (Letter (FreeGroup β)) := | |
| (ratioLabels n).product Finset.univ | |
| def prefixWeight (n : β) (Ξ± : β) (a : Letter (FreeGroup β)) : β := | |
| Ξ± / (2 * n) * multiplicity n a.1 | |
| /-- The exact collected multiplicities imply the required square-coefficient budget. -/ | |
| theorem prefixWeight_square_sum_le (n : β) (hn : 0 < n) (Ξ± : β) : | |
| β a β prefixLetterSupport n, β(prefixWeight n Ξ± a : β)β ^ 2 β€ Ξ± ^ 2 := by | |
| have hm : β p β ratioLabels n, (multiplicity n p : β) ^ 2 β€ 2 * (n : β) ^ 2 := by | |
| have hNat : β p β ratioLabels n, multiplicity n p ^ 2 β€ 2 * n ^ 2 := by | |
| rw [multiplicity_square_sum] | |
| exact Nat.sub_le _ _ | |
| exact_mod_cast hNat | |
| have he : (β a β prefixLetterSupport n, β(prefixWeight n Ξ± a : β)β ^ 2) = | |
| 2 * (Ξ± / (2 * n)) ^ 2 * β p β ratioLabels n, (multiplicity n p : β) ^ 2 := by | |
| unfold prefixLetterSupport | |
| rw [Finset.product_eq_sprod, Finset.sum_product] | |
| simp only [prefixWeight, Complex.norm_real, | |
| Real.norm_eq_abs, sq_abs, mul_pow] | |
| simp only [Fintype.sum_bool] | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro p _ | |
| ring | |
| rw [he] | |
| have hn' : (n : β) β 0 := by exact_mod_cast hn.ne' | |
| calc | |
| _ β€ 2 * (Ξ± / (2 * n)) ^ 2 * (2 * (n : β) ^ 2) := | |
| mul_le_mul_of_nonneg_left hm (by positivity) | |
| _ = Ξ± ^ 2 := by field_simp [hn'] | |
| /-- The manuscript's actual coefficient family has convolution norm at most 2Ξ±. -/ | |
| theorem prefix_convolution_operator_bound (n : β) (hn : 0 < n) | |
| (Ξ± : β) (hΞ± : 0 β€ Ξ±) : | |
| ββ a β prefixLetterSupport n, (prefixWeight n Ξ± a : β) β’ leftRegular (letter a)β β€ | |
| 2 * Ξ± := by | |
| calc | |
| _ β€ 2 * Real.sqrt (β a β prefixLetterSupport n, β(prefixWeight n Ξ± a : β)β ^ 2) := | |
| length_one_convolution_operator_bound _ _ | |
| _ β€ 2 * Real.sqrt (Ξ± ^ 2) := by | |
| gcongr | |
| exact prefixWeight_square_sum_le n hn Ξ± | |
| _ = _ := by rw [Real.sqrt_sq hΞ±] | |
| end Generator | |
| end | |
| end OAI | |