Download data/lean/OAI/Computability/DirectedFeedback/Games/KMSAnalyticSmallTransport.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 33.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/KMSAnalyticSmallTransport.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/DirectedFeedback/Games/KMSAnalyticSmallTransport.lean
-
curl -L -o KMSAnalyticSmallTransport.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/KMSAnalyticSmallTransport.lean
33.2 kB
| import Mathlib | |
| import OAI.Computability.DirectedFeedback.Probability.KMSFourthMomentZoomTransport | |
| namespace OAI | |
| namespace DFVSGames.Inverse.KMSAnalytic | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open DFVSGames.Integration.BinaryLinear (F2) | |
| open DFVSGames.Fourier.MatrixCharacters | |
| (linearTraceCharacter linearTraceCharacter_apply linearTracePair) | |
| variable {E F I I' J : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F] | |
| [AddCommGroup I] [Module F2 I] [AddCommGroup I'] [Module F2 I'] | |
| [AddCommGroup J] [Module F2 J] | |
| def smallFrequencyEquiv (e : I ββ[F2] I') : (F ββ[F2] I) β (F ββ[F2] I') where | |
| toFun T := e.toLinearMap.comp T | |
| invFun T := e.symm.toLinearMap.comp T | |
| left_inv T := by ext x; simp | |
| right_inv T := by ext x; simp | |
| @[simp] theorem smallFrequencyEquiv_apply (e : I ββ[F2] I') (T : F ββ[F2] I) : | |
| smallFrequencyEquiv e T = e.toLinearMap.comp T := rfl | |
| theorem surjective_smallFrequencyEquiv_iff (e : I ββ[F2] I') (T : F ββ[F2] I) : | |
| Function.Surjective (e.toLinearMap.comp T) β Function.Surjective T := by | |
| constructor | |
| Β· intro h y | |
| obtain β¨x, hxβ© := h (e y) | |
| exact β¨x, e.injective hxβ© | |
| Β· intro h y | |
| obtain β¨x, hxβ© := h (e.symm y) | |
| refine β¨x, ?_β© | |
| change e (T x) = y | |
| rw [hx, e.apply_symm_apply] | |
| theorem smallFrequency_transport_comp (e : I ββ[F2] I') (Ο : I ββ[F2] J) | |
| (T : F ββ[F2] I) : | |
| (Ο.comp e.symm.toLinearMap).comp (e.toLinearMap.comp T) = Ο.comp T := by | |
| ext x | |
| simp | |
| variable [FiniteDimensional F2 E] [FiniteDimensional F2 F] | |
| [FiniteDimensional F2 I] [FiniteDimensional F2 I'] | |
| [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] | |
| [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] | |
| [Fintype (I' ββ[F2] F)] [Fintype (F ββ[F2] I')] | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 F] [FiniteDimensional F2 I] [FiniteDimensional F2 I'] [Fintype (F ββ[F2] E)] [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] [Fintype (I' ββ[F2] F)] [Fintype (F ββ[F2] I')] in | |
| theorem smallCoeff_transport (e : I ββ[F2] I') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (T : F ββ[F2] I) : | |
| smallCoeff (ΞΉ.comp e.symm.toLinearMap) f (e.toLinearMap.comp T) = | |
| smallCoeff ΞΉ f T := by | |
| unfold smallCoeff | |
| rw [surjective_smallFrequencyEquiv_iff, smallFrequency_transport_comp] | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 F] [FiniteDimensional F2 I] [FiniteDimensional F2 I'] [Fintype (F ββ[F2] E)] [Fintype (I ββ[F2] F)] [Fintype (I' ββ[F2] F)] in | |
| theorem fixedFrequencyEnergy_transport (e : I ββ[F2] I') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (Ο : I ββ[F2] J) (A : F ββ[F2] J) : | |
| fixedFrequencyEnergy (ΞΉ.comp e.symm.toLinearMap) f | |
| (Ο.comp e.symm.toLinearMap) A = fixedFrequencyEnergy ΞΉ f Ο A := by | |
| unfold fixedFrequencyEnergy | |
| rw [Finset.sum_filter, Finset.sum_filter] | |
| symm | |
| apply Fintype.sum_equiv (smallFrequencyEquiv (F := F) e) | |
| intro T | |
| simp only [smallFrequencyEquiv_apply, smallFrequency_transport_comp, | |
| smallCoeff_transport] | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 F] | |
| [FiniteDimensional F2 I] [FiniteDimensional F2 I'] | |
| [Fintype (F ββ[F2] E)] [Fintype (I ββ[F2] F)] [Fintype (I' ββ[F2] F)] | |
| theorem smallComponent_transport (e : I ββ[F2] I') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (X : I' ββ[F2] F) : | |
| smallComponent (ΞΉ.comp e.symm.toLinearMap) f X = | |
| smallComponent ΞΉ f (X.comp e.toLinearMap) := by | |
| unfold smallComponent synthesis | |
| simp only [Finset.sum_apply, Pi.smul_apply, smul_eq_mul] | |
| symm | |
| apply Fintype.sum_equiv (smallFrequencyEquiv (F := F) e) | |
| intro T | |
| simp only [smallFrequencyEquiv_apply, smallCoeff_transport, | |
| linearTraceCharacter_apply, linearTracePair, LinearMap.comp_assoc] | |
| theorem smallComponent_precomp_equiv (g : I ββ[F2] I') (ΞΉ : I' ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (X : I ββ[F2] F) : | |
| smallComponent (ΞΉ.comp g.toLinearMap) f X = | |
| smallComponent ΞΉ f (X.comp g.symm.toLinearMap) := by | |
| simpa only [LinearEquiv.symm_symm] using smallComponent_transport g.symm ΞΉ f X | |
| end | |
| end DFVSGames.Inverse.KMSAnalytic | |
| namespace DFVSGames.Inverse.KMSPointComplement | |
| noncomputable section | |
| open DFVSGames.Integration.BinaryLinear (F2) | |
| open KMSAnalytic (pointLift) | |
| variable {E I : Type*} [AddCommGroup E] [Module F2 E] | |
| [AddCommGroup I] [Module F2 I] | |
| def pointEquivOfIsCompl (U : Submodule F2 E) (v : E) (hv : v β 0) | |
| (hc : IsCompl U (Submodule.span F2 {v})) : (U Γ F2) ββ[F2] E := | |
| ((LinearEquiv.refl F2 U).prodCongr | |
| (LinearEquiv.toSpanNonzeroSingleton F2 E v hv)).trans | |
| (Submodule.prodEquivOfIsCompl U (Submodule.span F2 {v}) hc) | |
| @[simp] theorem pointEquivOfIsCompl_apply (U : Submodule F2 E) (v : E) (hv : v β 0) | |
| (hc : IsCompl U (Submodule.span F2 {v})) (x : U) (c : F2) : | |
| pointEquivOfIsCompl U v hv hc (x, c) = (x : E) + c β’ v := rfl | |
| theorem exists_aligned_point_equiv (ΞΉ : (I Γ F2) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) : | |
| β U : Submodule F2 E, β e : (U Γ F2) ββ[F2] E, | |
| β ΞΊ : I ββ[F2] U, Function.Injective ΞΊ β§ | |
| e.toLinearMap.comp (pointLift ΞΊ) = ΞΉ := by | |
| let z : I ββ[F2] E := ΞΉ.comp (LinearMap.inl F2 I F2) | |
| let v : E := ΞΉ (0, 1) | |
| have hv : v β z.range := by | |
| rintro β¨x, hxβ© | |
| have hx' : ΞΉ (x, 0) = ΞΉ (0, 1) := hx | |
| have h01 : (0 : F2) = 1 := congrArg Prod.snd (hΞΉ hx') | |
| exact zero_ne_one h01 | |
| have hv0 : v β 0 := by | |
| intro h | |
| apply hv | |
| rw [h] | |
| exact z.range.zero_mem | |
| obtain β¨U, hU, hcβ© := (Submodule.disjoint_span_singleton_of_notMem hv).exists_isCompl | |
| let ΞΊ : I ββ[F2] U := z.codRestrict U (fun x => hU β¨x, rflβ©) | |
| let e : (U Γ F2) ββ[F2] E := pointEquivOfIsCompl U v hv0 hc | |
| refine β¨U, e, ΞΊ, ?_, ?_β© | |
| Β· intro x y h | |
| have hxy : ΞΉ (x, 0) = ΞΉ (y, 0) := congrArg Subtype.val h | |
| exact congrArg Prod.fst (hΞΉ hxy) | |
| Β· apply LinearMap.ext | |
| rintro β¨x, cβ© | |
| change ΞΉ (x, 0) + c β’ ΞΉ (0, 1) = ΞΉ (x, c) | |
| rw [β map_smul, β map_add] | |
| congr 1 | |
| ext <;> simp | |
| theorem exists_point_equiv [FiniteDimensional F2 E] | |
| (h : 0 < Module.finrank F2 E) : | |
| β U : Submodule F2 E, β _e : (U Γ F2) ββ[F2] E, | |
| Module.finrank F2 U + 1 = Module.finrank F2 E := by | |
| obtain β¨v, hvβ© := Module.finrank_pos_iff_exists_ne_zero.mp h | |
| obtain β¨U, hcβ© := (Submodule.span F2 {v}).exists_isCompl | |
| let e := pointEquivOfIsCompl U v hv hc.symm | |
| refine β¨U, e, ?_β© | |
| simpa only [Module.finrank_prod, Module.finrank_self] using e.finrank_eq | |
| end | |
| end DFVSGames.Inverse.KMSPointComplement | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped Classical | |
| open DFVSGames.Fourier.MatrixCharacters | |
| open DFVSGames.Inverse.KMSAnalytic | |
| variable {E E0 F A A0 I : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup E0] [Module F2 E0] | |
| [AddCommGroup F] [Module F2 F] [AddCommGroup A] [Module F2 A] | |
| [AddCommGroup A0] [Module F2 A0] [AddCommGroup I] [Module F2 I] | |
| theorem exists_mixed_aligned_point (ΞΉ : (A Γ I) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) (eA : (A0 Γ F2) ββ[F2] A) : | |
| β U : Submodule F2 E, β eE : (U Γ F2) ββ[F2] E, | |
| β ΞΊ : (A0 Γ I) ββ[F2] U, Function.Injective ΞΊ β§ | |
| eE.toLinearMap.comp (pointLift ΞΊ) = | |
| ΞΉ.comp (pointShuffle eA).toLinearMap := | |
| KMSPointComplement.exists_aligned_point_equiv | |
| (ΞΉ.comp (pointShuffle eA).toLinearMap) (hΞΉ.comp (pointShuffle eA).injective) | |
| variable [FiniteDimensional F2 E] [FiniteDimensional F2 E0] | |
| [FiniteDimensional F2 F] [FiniteDimensional F2 A] | |
| [FiniteDimensional F2 A0] [FiniteDimensional F2 I] | |
| [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] | |
| [Fintype ((E0 Γ F2) ββ[F2] F)] [Fintype (F ββ[F2] (E0 Γ F2))] | |
| [Fintype ((A Γ I) ββ[F2] F)] [Fintype (F ββ[F2] (A Γ I))] | |
| [Fintype (((A0 Γ I) Γ F2) ββ[F2] F)] | |
| [Fintype (F ββ[F2] ((A0 Γ I) Γ F2))] | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 E0] [FiniteDimensional F2 F] | |
| [FiniteDimensional F2 A] [FiniteDimensional F2 A0] [FiniteDimensional F2 I] | |
| [Fintype (F ββ[F2] E)] [Fintype (F ββ[F2] (E0 Γ F2))] | |
| [Fintype ((A Γ I) ββ[F2] F)] [Fintype (((A0 Γ I) Γ F2) ββ[F2] F)] | |
| theorem smallComponent_mixed_aligned (ΞΉ : (A Γ I) ββ[F2] E) | |
| (eA : (A0 Γ F2) ββ[F2] A) (eE : (E0 Γ F2) ββ[F2] E) | |
| (ΞΊ : (A0 Γ I) ββ[F2] E0) | |
| (halign : eE.toLinearMap.comp (pointLift ΞΊ) = | |
| ΞΉ.comp (pointShuffle eA).toLinearMap) (f : (E ββ[F2] F) β β) : | |
| smallComponent (pointLift ΞΊ) | |
| (fun X : (E0 Γ F2) ββ[F2] F => f (X.comp eE.symm.toLinearMap)) = | |
| pointShuffleTransport eA (smallComponent ΞΉ f) := by | |
| have he : eE.symm.toLinearMap.comp (ΞΉ.comp (pointShuffle eA).toLinearMap) = | |
| pointLift ΞΊ := by | |
| rw [β halign] | |
| apply LinearMap.ext | |
| intro x | |
| simp | |
| have htransport := smallComponent_ambient_transport | |
| (E := E) (E' := E0 Γ F2) (F := F) (I := (A0 Γ I) Γ F2) | |
| eE.symm (ΞΉ.comp (pointShuffle eA).toLinearMap) f | |
| rw [he] at htransport | |
| rw [htransport] | |
| funext X | |
| exact smallComponent_precomp_equiv (I := (A0 Γ I) Γ F2) (I' := A Γ I) | |
| (E := E) (F := F) (pointShuffle eA) ΞΉ f X | |
| theorem partialRestrict_smallComponent_mixed_aligned (ΞΉ : (A Γ I) ββ[F2] E) | |
| (eA : (A0 Γ F2) ββ[F2] A) (eE : (E0 Γ F2) ββ[F2] E) | |
| (ΞΊ : (A0 Γ I) ββ[F2] E0) | |
| (halign : eE.toLinearMap.comp (pointLift ΞΊ) = | |
| ΞΉ.comp (pointShuffle eA).toLinearMap) | |
| (f : (E ββ[F2] F) β β) (a : A ββ[F2] F) : | |
| partialRestrict (smallComponent ΞΉ f) a = | |
| partialRestrict (pointRestrict (smallComponent (pointLift ΞΊ) | |
| (fun X : (E0 Γ F2) ββ[F2] F => f (X.comp eE.symm.toLinearMap))) | |
| (a (eA (0, 1)))) | |
| ((a.comp eA.toLinearMap).comp (LinearMap.inl F2 A0 F2)) := by | |
| rw [smallComponent_mixed_aligned ΞΉ eA eE ΞΊ halign f, | |
| partialRestrict_pointRestrict_pointShuffleTransport] | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open DFVSGames.Fourier.MatrixCharacters | |
| open DFVSGames.Fourier.MatrixFourier | |
| open DFVSGames.Inverse.KMSAnalytic | |
| variable {A I : Type*} [AddCommGroup A] [Module F2 A] | |
| [AddCommGroup I] [Module F2 I] [Subsingleton A] | |
| def zeroFixedEquiv : I ββ[F2] (A Γ I) := | |
| { LinearMap.inr F2 A I with | |
| invFun := Prod.snd | |
| left_inv := fun _ => rfl | |
| right_inv := by | |
| rintro β¨a, xβ© | |
| exact Prod.ext (Subsingleton.elim _ _) rfl } | |
| @[simp] theorem zeroFixedEquiv_apply (x : I) : | |
| zeroFixedEquiv (A := A) x = (0, x) := rfl | |
| @[simp] theorem zeroFixedEquiv_symm_apply (a : A) (x : I) : | |
| (zeroFixedEquiv (A := A) (I := I)).symm (a, x) = x := rfl | |
| variable {E F J : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F] | |
| [AddCommGroup J] [Module F2 J] | |
| [FiniteDimensional F2 A] [FiniteDimensional F2 I] | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 F] | |
| [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] | |
| [Fintype ((A Γ I) ββ[F2] F)] [Fintype (F ββ[F2] (A Γ I))] | |
| [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] | |
| omit [FiniteDimensional F2 A] [FiniteDimensional F2 I] | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 F] | |
| [Fintype (F ββ[F2] E)] [Fintype ((A Γ I) ββ[F2] F)] | |
| [Fintype (I ββ[F2] F)] in | |
| theorem partialRestrict_smallComponent_zeroFixed (ΞΉ : (A Γ I) ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (a : A ββ[F2] F) : | |
| partialRestrict (smallComponent ΞΉ f) a = | |
| smallComponent (ΞΉ.comp (LinearMap.inr F2 A I)) f := by | |
| funext X | |
| have hmap : a.coprod X = | |
| X.comp (zeroFixedEquiv (A := A) (I := I)).symm.toLinearMap := by | |
| apply LinearMap.ext | |
| rintro β¨u, xβ© | |
| have hu : u = 0 := Subsingleton.elim _ _ | |
| simp [hu] | |
| change smallComponent ΞΉ f (a.coprod X) = _ | |
| rw [hmap] | |
| exact (smallComponent_precomp_equiv (zeroFixedEquiv (A := A) (I := I)) ΞΉ f X).symm | |
| omit [FiniteDimensional F2 A] [FiniteDimensional F2 E] | |
| [Fintype (F ββ[F2] E)] [Fintype ((A Γ I) ββ[F2] F)] in | |
| theorem mixedEnergy_zeroFixed (ΞΉ : (A Γ I) ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (a : A ββ[F2] F) | |
| (Ο : I ββ[F2] J) (Ξ½ : F ββ[F2] J) : | |
| sliceEnergy (fun T => Ο.comp T = Ξ½) (partialRestrict (smallComponent ΞΉ f) a) = | |
| fixedFrequencyEnergy (ΞΉ.comp (LinearMap.inr F2 A I)) f Ο Ξ½ := by | |
| rw [partialRestrict_smallComponent_zeroFixed] | |
| simp only [sliceEnergy, fixedFrequencyEnergy, coeff_smallComponent] | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open DFVSGames.Fourier.MatrixCharacters | |
| open DFVSGames.Inverse.KMSAnalytic | |
| variable {E F A I : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F] | |
| [AddCommGroup A] [Module F2 A] [AddCommGroup I] [Module F2 I] | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 F] | |
| [FiniteDimensional F2 A] [FiniteDimensional F2 I] | |
| [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] | |
| [Fintype ((E Γ F2) ββ[F2] F)] [Fintype (F ββ[F2] (E Γ F2))] | |
| [Fintype ((A Γ I) ββ[F2] F)] [Fintype (F ββ[F2] (A Γ I))] | |
| [Fintype (((A Γ I) Γ F2) ββ[F2] F)] | |
| [Fintype (F ββ[F2] ((A Γ I) Γ F2))] | |
| [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] | |
| [Fintype (F ββ[F2] F2)] [Fintype ((A Γ I) ββ[F2] F2)] | |
| omit [FiniteDimensional F2 A] [Fintype ((A Γ I) ββ[F2] F)] | |
| [Fintype (((A Γ I) Γ F2) ββ[F2] F)] | |
| theorem mixed_point_sliceEnergy_le (ΞΉ : (A Γ I) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) (f : ((E Γ F2) ββ[F2] F) β β) | |
| (hf : KMSBasisInvariant.IsBasisInvariant f) (a : A ββ[F2] F) (b : F) | |
| (P : (F ββ[F2] I) β Prop) : | |
| sliceEnergy P (partialRestrict | |
| (pointRestrict (smallComponent (pointLift ΞΉ) f) b) a) β€ | |
| 2 * (sliceEnergy P (partialRestrict (smallComponent ΞΉ (pointRestrict f b)) a) + | |
| (Fintype.card ((A Γ I) ββ[F2] F2) : β) * | |
| β Ο : (A Γ I) ββ[F2] F2, sliceEnergy P | |
| (partialRestrict (smallComponent (pointPad ΞΉ) f) | |
| (a + (Ο.smulRight b).comp (LinearMap.inl F2 A I)))) := by | |
| have he : pointRestrict (smallComponent (pointLift ΞΉ) f) b = | |
| fun X => smallComponent ΞΉ (pointRestrict f b) X - | |
| β Ο : (A Γ I) ββ[F2] F2, | |
| smallComponent (pointPad ΞΉ) f (X + Ο.smulRight b) := by | |
| funext X | |
| exact point_restriction_recursion ΞΉ hΞΉ f hf X b | |
| rw [he] | |
| exact sliceEnergy_partialRestrict_sub_translates_le P | |
| (smallComponent ΞΉ (pointRestrict f b)) | |
| (fun _ : (A Γ I) ββ[F2] F2 => smallComponent (pointPad ΞΉ) f) | |
| a (fun Ο => Ο.smulRight b) | |
| theorem mixed_point_sliceEnergy_le_of_bounds (ΞΉ : (A Γ I) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) (f : ((E Γ F2) ββ[F2] F) β β) | |
| (hf : KMSBasisInvariant.IsBasisInvariant f) (a : A ββ[F2] F) (b : F) | |
| (P : (F ββ[F2] I) β Prop) (Hβ Hβ : β) | |
| (hβ : sliceEnergy P | |
| (partialRestrict (smallComponent ΞΉ (pointRestrict f b)) a) β€ Hβ) | |
| (hβ : β a' : A ββ[F2] F, | |
| sliceEnergy P (partialRestrict (smallComponent (pointPad ΞΉ) f) a') β€ Hβ) : | |
| sliceEnergy P (partialRestrict | |
| (pointRestrict (smallComponent (pointLift ΞΉ) f) b) a) β€ | |
| 2 * (Hβ + (Fintype.card ((A Γ I) ββ[F2] F2) : β) ^ 2 * Hβ) := by | |
| apply (mixed_point_sliceEnergy_le ΞΉ hΞΉ f hf a b P).trans | |
| have hs : (β Ο : (A Γ I) ββ[F2] F2, sliceEnergy P | |
| (partialRestrict (smallComponent (pointPad ΞΉ) f) | |
| (a + (Ο.smulRight b).comp (LinearMap.inl F2 A I)))) β€ | |
| (Fintype.card ((A Γ I) ββ[F2] F2) : β) * Hβ := by | |
| calc | |
| _ β€ β _Ο : (A Γ I) ββ[F2] F2, Hβ := | |
| Finset.sum_le_sum (fun Ο _ => hβ _) | |
| _ = _ := by simp | |
| calc | |
| _ β€ 2 * (Hβ + (Fintype.card ((A Γ I) ββ[F2] F2) : β) * | |
| ((Fintype.card ((A Γ I) ββ[F2] F2) : β) * Hβ)) := by | |
| gcongr | |
| _ = _ := by ring | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| def mixedStepFactor (R : β) : β := 2 ^ (2 * R + 2) | |
| theorem mixedStepFactor_nonneg (R : β) : 0 β€ mixedStepFactor R := by | |
| unfold mixedStepFactor | |
| positivity | |
| theorem one_le_mixedStepFactor (R : β) : 1 β€ mixedStepFactor R := by | |
| exact one_le_powβ (by norm_num : (1 : β) β€ 2) | |
| theorem mixed_step_factor_bound (R t n : β) (ht : t β€ 2 * R) (hn : n β€ R) : | |
| 2 * ((2 : β) ^ t + ((2 : β) ^ n) ^ 2) β€ mixedStepFactor R := by | |
| have ht' : (2 : β) ^ t β€ 2 ^ (2 * R) := | |
| pow_le_pow_rightβ (by norm_num) ht | |
| have hn' : ((2 : β) ^ n) ^ 2 β€ 2 ^ (2 * R) := by | |
| rw [β pow_mul] | |
| apply pow_le_pow_rightβ (by norm_num) | |
| omega | |
| have he : mixedStepFactor R = 4 * (2 : β) ^ (2 * R) := by | |
| unfold mixedStepFactor | |
| rw [pow_add] | |
| ring | |
| rw [he] | |
| linarith | |
| theorem mixed_weighted_step {M A B q w n C : β} | |
| (hq : 0 β€ q) (hw : 0 β€ w) | |
| (hrec : M β€ 2 * (A + n ^ 2 * B)) | |
| (hA : w * A β€ C) (hB : (q * w) * B β€ C) : | |
| (q * w) * M β€ 2 * (q + n ^ 2) * C := by | |
| calc | |
| (q * w) * M β€ (q * w) * (2 * (A + n ^ 2 * B)) := | |
| mul_le_mul_of_nonneg_left hrec (mul_nonneg hq hw) | |
| _ = 2 * (q * (w * A) + n ^ 2 * ((q * w) * B)) := by ring | |
| _ β€ 2 * (q * C + n ^ 2 * C) := by | |
| gcongr | |
| _ = 2 * (q + n ^ 2) * C := by ring | |
| theorem mixed_weighted_step_pow (R s ell t n : β) (H Ξ΅ M A B : β) | |
| (hH : 0 β€ H) (hΞ΅ : 0 β€ Ξ΅) (ht : t β€ 2 * R) (hn : n β€ R) | |
| (hrec : M β€ 2 * (A + ((2 : β) ^ n) ^ 2 * B)) | |
| (hA : (2 : β) ^ (t * ell) * A β€ H * mixedStepFactor R ^ s * Ξ΅) | |
| (hB : (2 : β) ^ (t * (ell + 1)) * B β€ H * mixedStepFactor R ^ s * Ξ΅) : | |
| (2 : β) ^ (t * (ell + 1)) * M β€ H * mixedStepFactor R ^ (s + 1) * Ξ΅ := by | |
| have he : (2 : β) ^ (t * (ell + 1)) = 2 ^ t * 2 ^ (t * ell) := by | |
| rw [Nat.mul_add, Nat.mul_one, pow_add] | |
| ring | |
| have hc : 0 β€ H * mixedStepFactor R ^ s * Ξ΅ := | |
| mul_nonneg (mul_nonneg hH (pow_nonneg (mixedStepFactor_nonneg R) _)) hΞ΅ | |
| have h := mixed_weighted_step (q := (2 : β) ^ t) | |
| (w := (2 : β) ^ (t * ell)) (n := (2 : β) ^ n) | |
| (by positivity) (by positivity) hrec hA (by simpa only [he] using hB) | |
| rw [β he] at h | |
| calc | |
| _ β€ 2 * ((2 : β) ^ t + ((2 : β) ^ n) ^ 2) * | |
| (H * mixedStepFactor R ^ s * Ξ΅) := h | |
| _ β€ mixedStepFactor R * (H * mixedStepFactor R ^ s * Ξ΅) := | |
| mul_le_mul_of_nonneg_right (mixed_step_factor_bound R t n ht hn) hc | |
| _ = _ := by rw [pow_succ]; ring | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSAnalytic | |
| noncomputable section | |
| open scoped BigOperators | |
| open DFVSGames.Integration.BinaryLinear (F2) | |
| open DFVSGames.Inverse.KMSBasisInvariant | |
| universe u v | |
| variable {E : Type u} {F B : Type v} | |
| [AddCommGroup E] [Module F2 E] | |
| [AddCommGroup F] [Module F2 F] | |
| [AddCommGroup B] [Module F2 B] | |
| def HomogeneousRestrictionBound (r : β) (Ξ΅ : β) (f : (E ββ[F2] F) β β) : Prop := | |
| β (C : Type v) [AddCommGroup C] [Module F2 C] [FiniteDimensional F2 C] | |
| [Fintype (E ββ[F2] C)], | |
| β J : C ββ[F2] F, Function.Injective J β | |
| Module.finrank F2 F β€ Module.finrank F2 C + r β | |
| (πΌ X : E ββ[F2] C, f (J.comp X) ^ 2) β€ Ξ΅ | |
| theorem HomogeneousRestrictionBound.codomain_pullback | |
| [FiniteDimensional F2 B] (r s : β) (Ξ΅ : β) | |
| (f : (E ββ[F2] F) β β) | |
| (hf : HomogeneousRestrictionBound (r + s) Ξ΅ f) | |
| (J : B ββ[F2] F) (hJ : Function.Injective J) | |
| (hcodim : Module.finrank F2 F β€ Module.finrank F2 B + s) : | |
| HomogeneousRestrictionBound r Ξ΅ (fun X : E ββ[F2] B => f (J.comp X)) := by | |
| intro C _ _ _ _ K hK hdim | |
| have hdim' : Module.finrank F2 F β€ Module.finrank F2 C + (r + s) := by omega | |
| simpa only [LinearMap.comp_assoc] using hf C (J.comp K) (hJ.comp hK) hdim' | |
| theorem HomogeneousRestrictionBound.energy_le | |
| [FiniteDimensional F2 F] [Fintype (E ββ[F2] F)] | |
| (r : β) (Ξ΅ : β) (f : (E ββ[F2] F) β β) | |
| (hf : HomogeneousRestrictionBound r Ξ΅ f) : (πΌ X, f X ^ 2) β€ Ξ΅ := by | |
| simpa using hf F (LinearMap.id : F ββ[F2] F) Function.injective_id | |
| (Nat.le_add_right (Module.finrank F2 F) r) | |
| theorem basisInvariant_codomain_pullback (f : (E ββ[F2] F) β β) | |
| (hf : IsBasisInvariant f) (J : B ββ[F2] F) : | |
| IsBasisInvariant (fun X : E ββ[F2] B => f (J.comp X)) := by | |
| intro g X | |
| simpa only [LinearMap.comp_assoc] using hf g (J.comp X) | |
| end | |
| end DFVSGames.Inverse.KMSAnalytic | |
| namespace DFVSGames.Inverse.KMSAnalytic | |
| noncomputable section | |
| open scoped Classical | |
| open DFVSGames.Fourier.MatrixCharacters | |
| variable {E F : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F] | |
| theorem pointAppend_comp_basis (X : E ββ[F2] F) (a : F) (g : E ββ[F2] E) : | |
| pointAppend (X.comp g.toLinearMap) a = | |
| (pointAppend X a).comp (g.prodCongr (LinearEquiv.refl F2 F2)).toLinearMap := by | |
| apply LinearMap.ext | |
| intro x | |
| rfl | |
| theorem pointRestrict_invariant (f : ((E Γ F2) ββ[F2] F) β β) | |
| (hf : KMSBasisInvariant.IsBasisInvariant f) (a : F) : | |
| KMSBasisInvariant.IsBasisInvariant (pointRestrict f a) := by | |
| intro g X | |
| change f (pointAppend (X.comp g.toLinearMap) a) = f (pointAppend X a) | |
| rw [pointAppend_comp_basis] | |
| exact hf (g.prodCongr (LinearEquiv.refl F2 F2)) (pointAppend X a) | |
| theorem pointAppend_add (X : E ββ[F2] F) (a : F) | |
| (Z : (E Γ F2) ββ[F2] F) : | |
| pointAppend X a + Z = | |
| pointAppend (X + Z.comp (LinearMap.inl F2 E F2)) (a + Z (0, 1)) := by | |
| have hZ (x : E) (c : F2) : Z (x, c) = Z (x, 0) + c β’ Z (0, 1) := by | |
| calc | |
| Z (x, c) = Z ((x, 0) + c β’ (0, 1)) := by simp | |
| _ = Z (x, 0) + c β’ Z (0, 1) := by rw [map_add, map_smul] | |
| apply LinearMap.ext | |
| intro p | |
| rcases p with β¨x, cβ© | |
| simp only [LinearMap.add_apply, pointAppend_apply, LinearMap.comp_apply, | |
| LinearMap.inl_apply, smul_add] | |
| rw [hZ] | |
| abel | |
| theorem pointRestrict_translate (f : ((E Γ F2) ββ[F2] F) β β) | |
| (Z : (E Γ F2) ββ[F2] F) (a : F) : | |
| pointRestrict (fun Y => f (Y + Z)) a = | |
| fun X => pointRestrict f (a + Z (0, 1)) | |
| (X + Z.comp (LinearMap.inl F2 E F2)) := by | |
| funext X | |
| change f (pointAppend X a + Z) = _ | |
| rw [pointAppend_add] | |
| rfl | |
| end | |
| end DFVSGames.Inverse.KMSAnalytic | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped BigOperators | |
| open DFVSGames.Integration.BinaryLinear (F2) | |
| open DFVSGames.Inverse.KMSAnalytic | |
| universe u v | |
| variable {E : Type u} {F : Type v} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup F] [Module F2 F] | |
| def AffineDensityBound (r : β) (Ξ΅ : β) (f : (E ββ[F2] F) β β) : Prop := | |
| β (D : Type u) [AddCommGroup D] [Module F2 D] [FiniteDimensional F2 D] | |
| (C : Type v) [AddCommGroup C] [Module F2 C] [FiniteDimensional F2 C] | |
| [Fintype (D ββ[F2] C)], | |
| β L : E ββ[F2] D, Function.Surjective L β | |
| β J : C ββ[F2] F, Function.Injective J β | |
| β T : E ββ[F2] F, | |
| Module.finrank F2 E + Module.finrank F2 F β€ | |
| Module.finrank F2 D + Module.finrank F2 C + r β | |
| (πΌ X : D ββ[F2] C, f (T + J.comp (X.comp L)) ^ 2) β€ Ξ΅ | |
| theorem AffineDensityBound.mono {r s : β} (hrs : r β€ s) (Ξ΅ : β) | |
| (f : (E ββ[F2] F) β β) (hf : AffineDensityBound s Ξ΅ f) : | |
| AffineDensityBound r Ξ΅ f := by | |
| intro D _ _ _ C _ _ _ _ L hL J hJ T hdim | |
| exact hf D C L hL J hJ T (by omega) | |
| theorem AffineDensityBound.homogeneous [FiniteDimensional F2 E] | |
| (r : β) (Ξ΅ : β) (f : (E ββ[F2] F) β β) | |
| (hf : AffineDensityBound r Ξ΅ f) : HomogeneousRestrictionBound r Ξ΅ f := by | |
| intro C _ _ _ _ J hJ hdim | |
| have h := hf E C (LinearMap.id : E ββ[F2] E) Function.surjective_id | |
| J hJ 0 (by omega) | |
| simpa using h | |
| theorem AffineDensityBound.pointRestrict [FiniteDimensional F2 E] | |
| (r : β) (Ξ΅ : β) (f : ((E Γ F2) ββ[F2] F) β β) | |
| (hf : AffineDensityBound (r + 1) Ξ΅ f) (a : F) : | |
| AffineDensityBound r Ξ΅ (pointRestrict f a) := by | |
| intro D _ _ _ C _ _ _ _ L hL J hJ T hdim | |
| let L' : (E Γ F2) ββ[F2] D := L.comp (LinearMap.fst F2 E F2) | |
| have hL' : Function.Surjective L' := by | |
| intro y | |
| obtain β¨x, hxβ© := hL y | |
| exact β¨(x, 0), hxβ© | |
| have hdim' : Module.finrank F2 (E Γ F2) + Module.finrank F2 F β€ | |
| Module.finrank F2 D + Module.finrank F2 C + (r + 1) := by | |
| rw [Module.finrank_prod, Module.finrank_self] | |
| omega | |
| have he (X : D ββ[F2] C) : | |
| pointAppend (T + J.comp (X.comp L)) a = | |
| pointAppend T a + J.comp (X.comp L') := by | |
| apply LinearMap.ext | |
| intro p | |
| rcases p with β¨x, cβ© | |
| simp only [pointAppend_apply, LinearMap.add_apply, LinearMap.comp_apply, | |
| L', LinearMap.fst_apply] | |
| abel | |
| have h := hf D C L' hL' J hJ (pointAppend T a) hdim' | |
| simpa only [KMSAnalytic.pointRestrict, he] using h | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped BigOperators | |
| open DFVSGames.Integration.BinaryLinear (F2) | |
| universe u v | |
| variable {E E' : Type u} {F B : Type v} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup E'] [Module F2 E'] | |
| [AddCommGroup F] [Module F2 F] [AddCommGroup B] [Module F2 B] | |
| theorem AffineDensityBound.domain_equiv | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 E'] | |
| (r : β) (Ξ΅ : β) (f : (E ββ[F2] F) β β) | |
| (hf : AffineDensityBound r Ξ΅ f) (e : E ββ[F2] E') : | |
| AffineDensityBound r Ξ΅ (fun X : E' ββ[F2] F => f (X.comp e.toLinearMap)) := by | |
| intro D _ _ _ C _ _ _ _ L hL J hJ T hdim | |
| have hdim' : Module.finrank F2 E + Module.finrank F2 F β€ | |
| Module.finrank F2 D + Module.finrank F2 C + r := by | |
| rw [e.finrank_eq] | |
| exact hdim | |
| have h := hf D C (L.comp e.toLinearMap) (hL.comp e.surjective) J hJ | |
| (T.comp e.toLinearMap) hdim' | |
| simpa only [LinearMap.add_comp, LinearMap.comp_assoc] using h | |
| theorem AffineDensityBound.codomain_pullback | |
| [FiniteDimensional F2 B] (r s : β) (Ξ΅ : β) | |
| (f : (E ββ[F2] F) β β) (hf : AffineDensityBound (r + s) Ξ΅ f) | |
| (K : B ββ[F2] F) (hK : Function.Injective K) | |
| (hdimK : Module.finrank F2 F β€ Module.finrank F2 B + s) : | |
| AffineDensityBound r Ξ΅ (fun X : E ββ[F2] B => f (K.comp X)) := by | |
| intro D _ _ _ C _ _ _ _ L hL J hJ T hdim | |
| have hdim' : Module.finrank F2 E + Module.finrank F2 F β€ | |
| Module.finrank F2 D + Module.finrank F2 C + (r + s) := by omega | |
| have h := hf D C L hL (K.comp J) (hK.comp hJ) (K.comp T) hdim' | |
| simpa only [LinearMap.comp_add, LinearMap.comp_assoc] using h | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| namespace DFVSGames.Inverse.KMSFourthMoment | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open DFVSGames.Fourier.MatrixCharacters | |
| open DFVSGames.Inverse.KMSAnalytic | |
| universe u v | |
| local instance mapFintype {V : Type*} {W : Type*} | |
| [AddCommGroup V] [Module F2 V] [AddCommGroup W] [Module F2 W] | |
| [Fintype V] [Fintype W] : Fintype (V ββ[F2] W) := | |
| Fintype.ofInjective (fun L : V ββ[F2] W => (L : V β W)) DFunLike.coe_injective | |
| variable {F : Type v} {I J : Type u} | |
| [AddCommGroup F] [Module F2 F] [AddCommGroup I] [Module F2 I] | |
| [AddCommGroup J] [Module F2 J] | |
| [FiniteDimensional F2 F] [FiniteDimensional F2 I] [FiniteDimensional F2 J] | |
| [Fintype F] [Fintype I] [Fintype J] | |
| omit [FiniteDimensional F2 J] [Fintype J] in | |
| theorem mixed_bound_of_character_bound (R : β) (H Ξ΅ : β) | |
| (hH : 0 β€ H) (hΞ΅ : 0 β€ Ξ΅) (Ο : I ββ[F2] J) (Ξ½ : F ββ[F2] J) | |
| (hΟ : Function.Surjective Ο) | |
| (hbase : β (E : Type u) [AddCommGroup E] [Module F2 E] | |
| [FiniteDimensional F2 E] [Fintype E], | |
| β (ΞΉ : I ββ[F2] E), Function.Injective ΞΉ β | |
| β (f : (E ββ[F2] F) β β), KMSBasisInvariant.IsBasisInvariant f β | |
| AffineDensityBound (Module.finrank F2 I) Ξ΅ f β | |
| (2 : β) ^ ((Module.finrank F2 I + Module.finrank F2 J) * Module.finrank F2 E) * | |
| fixedFrequencyEnergy ΞΉ f Ο Ξ½ β€ H * Ξ΅) : | |
| β (n : β) (E : Type u) [AddCommGroup E] [Module F2 E] | |
| [FiniteDimensional F2 E] [Fintype E] | |
| (A : Type u) [AddCommGroup A] [Module F2 A] | |
| [FiniteDimensional F2 A] [Fintype A], | |
| Module.finrank F2 A = n β | |
| β (ΞΉ : (A Γ I) ββ[F2] E), Function.Injective ΞΉ β | |
| β (f : (E ββ[F2] F) β β), KMSBasisInvariant.IsBasisInvariant f β | |
| AffineDensityBound (Module.finrank F2 A + Module.finrank F2 I) Ξ΅ f β | |
| β (a : A ββ[F2] F), Module.finrank F2 A + Module.finrank F2 I β€ R β | |
| (2 : β) ^ ((Module.finrank F2 I + Module.finrank F2 J) * Module.finrank F2 E) * | |
| sliceEnergy (fun T => Ο.comp T = Ξ½) (partialRestrict (smallComponent ΞΉ f) a) β€ | |
| H * mixedStepFactor R ^ n * Ξ΅ := by | |
| intro n | |
| induction n using Nat.strong_induction_on with | |
| | h n ih => | |
| intro E _ _ _ _ A _ _ _ _ hAn ΞΉ hΞΉ f hf hd a hr | |
| by_cases hn : n = 0 | |
| Β· have hz : Module.finrank F2 A = 0 := hAn.trans hn | |
| let : Subsingleton A := Module.finrank_zero_iff.mp hz | |
| have hi : Function.Injective (ΞΉ.comp (LinearMap.inr F2 A I)) := by | |
| intro x y hxy | |
| exact congrArg Prod.snd (hΞΉ hxy) | |
| have hd0 : AffineDensityBound (Module.finrank F2 I) Ξ΅ f := by simpa [hz] using hd | |
| rw [mixedEnergy_zeroFixed] | |
| simpa only [hn, pow_zero, mul_one] using | |
| hbase E (ΞΉ.comp (LinearMap.inr F2 A I)) hi f hf hd0 | |
| Β· have hp : 0 < Module.finrank F2 A := by omega | |
| obtain β¨A0, eA, hAdropβ© := KMSPointComplement.exists_point_equiv hp | |
| change Module.finrank F2 A0 + 1 = Module.finrank F2 A at hAdrop | |
| obtain β¨E0, eE, ΞΊ, hΞΊ, halignβ© := exists_mixed_aligned_point ΞΉ hΞΉ eA | |
| let f' : ((E0 Γ F2) ββ[F2] F) β β := | |
| fun X => f (X.comp eE.symm.toLinearMap) | |
| let a0 : A0 ββ[F2] F := (a.comp eA.toLinearMap).comp (LinearMap.inl F2 A0 F2) | |
| let b : F := a (eA (0, 1)) | |
| let r0 := Module.finrank F2 A0 + Module.finrank F2 I | |
| let t := Module.finrank F2 I + Module.finrank F2 J | |
| have hs : Module.finrank F2 A0 < n := by omega | |
| have hr0 : r0 β€ R := by dsimp [r0]; omega | |
| have hf' : KMSBasisInvariant.IsBasisInvariant f' := | |
| ambient_basisInvariant_transport eE.symm f hf | |
| have hd' : AffineDensityBound (r0 + 1) Ξ΅ f' := by | |
| have h := AffineDensityBound.domain_equiv _ Ξ΅ f hd eE.symm | |
| have he : Module.finrank F2 A + Module.finrank F2 I = r0 + 1 := by | |
| dsimp [r0]; omega | |
| simpa only [he] using h | |
| have hdp : AffineDensityBound r0 Ξ΅ (pointRestrict f' b) := | |
| AffineDensityBound.pointRestrict r0 Ξ΅ f' hd' b | |
| have hdo : AffineDensityBound r0 Ξ΅ f' := | |
| AffineDensityBound.mono (Nat.le_succ r0) Ξ΅ f' hd' | |
| have hdimE : Module.finrank F2 E = Module.finrank F2 E0 + 1 := by | |
| simpa only [Module.finrank_prod, Module.finrank_self] using eE.finrank_eq.symm | |
| have ht : t β€ 2 * R := by | |
| have hji : Module.finrank F2 J β€ Module.finrank F2 I := | |
| LinearMap.finrank_le_finrank_of_surjective hΟ | |
| dsimp [t] | |
| omega | |
| have hcard : (Fintype.card ((A0 Γ I) ββ[F2] F2) : β) = (2 : β) ^ r0 := by | |
| rw [Module.card_eq_pow_finrank (K := F2)] | |
| simp [Module.finrank_prod, r0, F2, ZMod.card] | |
| let C := H * mixedStepFactor R ^ Module.finrank F2 A0 * Ξ΅ | |
| let W0 : β := 2 ^ (t * Module.finrank F2 E0) | |
| let W1 : β := 2 ^ (t * (Module.finrank F2 E0 + 1)) | |
| have hW0 : 0 < W0 := by dsimp [W0]; positivity | |
| have hW1 : 0 < W1 := by dsimp [W1]; positivity | |
| have hfirst : sliceEnergy (fun T => Ο.comp T = Ξ½) | |
| (partialRestrict (smallComponent ΞΊ (pointRestrict f' b)) a0) β€ C / W0 := by | |
| apply (le_div_iffβ hW0).mpr | |
| have h := ih (Module.finrank F2 A0) hs E0 A0 rfl ΞΊ hΞΊ | |
| (pointRestrict f' b) (pointRestrict_invariant f' hf' b) hdp a0 hr0 | |
| simpa only [C, W0, t, mul_comm] using h | |
| have hsecond (a' : A0 ββ[F2] F) : sliceEnergy (fun T => Ο.comp T = Ξ½) | |
| (partialRestrict (smallComponent (pointPad ΞΊ) f') a') β€ C / W1 := by | |
| apply (le_div_iffβ hW1).mpr | |
| have h := ih (Module.finrank F2 A0) hs (E0 Γ F2) A0 rfl | |
| (pointPad ΞΊ) (pointPad_injective ΞΊ hΞΊ) f' hf' hdo a' hr0 | |
| simpa only [C, W1, t, Module.finrank_prod, Module.finrank_self, mul_comm] using h | |
| have hrec := mixed_point_sliceEnergy_le_of_bounds ΞΊ hΞΊ f' hf' a0 b | |
| (fun T => Ο.comp T = Ξ½) (C / W0) (C / W1) hfirst hsecond | |
| rw [hcard] at hrec | |
| have hweighted := mixed_weighted_step_pow R (Module.finrank F2 A0) | |
| (Module.finrank F2 E0) t r0 H Ξ΅ _ (C / W0) (C / W1) | |
| hH hΞ΅ ht hr0 hrec | |
| (by change W0 * (C / W0) β€ C; rw [mul_div_cancelβ _ (ne_of_gt hW0)]) | |
| (by change W1 * (C / W1) β€ C; rw [mul_div_cancelβ _ (ne_of_gt hW1)]) | |
| rw [partialRestrict_smallComponent_mixed_aligned ΞΉ eA eE ΞΊ halign f a] | |
| simpa only [hdimE, β hAn, β hAdrop, f', a0, b, t] using hweighted | |
| end | |
| end DFVSGames.Inverse.KMSFourthMoment | |
| end OAI | |