Download data/lean/OAI/Computability/MaxCut/Games/KMSAnalyticFrequencyShift.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 35.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MaxCut/Games/KMSAnalyticFrequencyShift.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/MaxCut/Games/KMSAnalyticFrequencyShift.lean
-
curl -L -o KMSAnalyticFrequencyShift.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MaxCut/Games/KMSAnalyticFrequencyShift.lean
35.5 kB
| import Mathlib | |
| import OAI.Computability.MaxCut.Games.KMSInjectionCountBounds | |
| namespace OAI | |
| /-! | |
| The dependent branches in the KMS fixed-character recursion inject into the | |
| lower-rank restricted Fourier sum. The new coordinate value is kept fixed, | |
| so no multiplicity or ambient-dimension loss is introduced here. | |
| -/ | |
| namespace MaxCutGames.Inverse.KMSAnalytic | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Fourier.MatrixFourier | |
| variable {E B J K : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup B] [Module F2 B] | |
| [AddCommGroup J] [Module F2 J] [AddCommGroup K] [Module F2 K] | |
| /-- Fixing the new coordinate still allows recovery of the entire old map. -/ | |
| theorem hyperplaneExtend_old_injective (w : J) : | |
| Function.Injective (fun z : B ββ[F2] J => hyperplaneExtend z w) := by | |
| intro z z' h | |
| have hc := congrArg | |
| (fun T : (B Γ F2) ββ[F2] J => T.comp (LinearMap.inl F2 B F2)) h | |
| simpa only [hyperplaneExtend_comp_inl] using hc | |
| /-- A surjective old frequency stays surjective after any new coordinate. -/ | |
| theorem hyperplaneExtend_surjective {z : B ββ[F2] J} | |
| (hz : Function.Surjective z) (w : J) : | |
| Function.Surjective (hyperplaneExtend z w) := by | |
| intro y | |
| obtain β¨b, hbβ© := hz y | |
| refine β¨(b, 0), ?_β© | |
| simpa using hb | |
| /-- The fixed partial frequency extends by its actual projected new value. -/ | |
| theorem comp_hyperplaneExtend (Ο : J ββ[F2] K) (z : B ββ[F2] J) (w : J) : | |
| Ο.comp (hyperplaneExtend z w) = hyperplaneExtend (Ο.comp z) (Ο w) := by | |
| apply LinearMap.ext | |
| rintro β¨b, cβ© | |
| simp [LinearMap.comp_apply] | |
| variable [FiniteDimensional F2 E] [FiniteDimensional F2 B] [FiniteDimensional F2 J] | |
| [Fintype (E ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] E)] | |
| [Fintype (J ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] J)] | |
| [Fintype (B ββ[F2] J)] | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 B] [FiniteDimensional F2 J] | |
| [Fintype ((B Γ F2) ββ[F2] E)] [Fintype (J ββ[F2] (B Γ F2))] in | |
| /-- Each fixed dependent extension branch is bounded by the genuine restricted | |
| small-component energy. There is no hidden cardinality factor. -/ | |
| theorem dependent_extension_energy_le | |
| (ΞΉ : J ββ[F2] E) (f : (E ββ[F2] (B Γ F2)) β β) | |
| (Ο : J ββ[F2] K) (A0 : B ββ[F2] K) (w : J) : | |
| (β z : B ββ[F2] J with Ο.comp z = A0 β§ Function.Surjective z, | |
| linearCoeff f (ΞΉ.comp (hyperplaneExtend z w)) ^ 2) β€ | |
| fixedFrequencyEnergy ΞΉ f Ο (hyperplaneExtend A0 (Ο w)) := by | |
| let P : Finset (B ββ[F2] J) := | |
| Finset.univ.filter fun z => Ο.comp z = A0 β§ Function.Surjective z | |
| let Q : Finset ((B Γ F2) ββ[F2] J) := | |
| Finset.univ.filter fun T => | |
| Ο.comp T = hyperplaneExtend A0 (Ο w) β§ Function.Surjective T | |
| have hsub : P.image (fun z => hyperplaneExtend z w) β Q := by | |
| intro T hT | |
| obtain β¨z, hz, rflβ© := Finset.mem_image.mp hT | |
| have hp := (Finset.mem_filter.mp hz).2 | |
| apply Finset.mem_filter.mpr | |
| refine β¨Finset.mem_univ _, ?_, hyperplaneExtend_surjective hp.2 wβ© | |
| rw [comp_hyperplaneExtend, hp.1] | |
| rw [fixedFrequencyEnergy_eq] | |
| change (β z β P, linearCoeff f (ΞΉ.comp (hyperplaneExtend z w)) ^ 2) β€ | |
| β T β Q, linearCoeff f (ΞΉ.comp T) ^ 2 | |
| calc | |
| _ = β T β P.image (fun z => hyperplaneExtend z w), | |
| linearCoeff f (ΞΉ.comp T) ^ 2 := by | |
| rw [Finset.sum_image] | |
| exact fun z _ z' _ h => hyperplaneExtend_old_injective w h | |
| _ β€ _ := Finset.sum_le_sum_of_subset_of_nonneg hsub | |
| (fun T _ _ => sq_nonneg _) | |
| end | |
| /-! A denominator-cleared fixed-character induction step. Its right side | |
| contains only the actual smaller restricted Fourier energies, obtained from | |
| the exact zoom-out identity and injective reindexing of each dependent branch. | |
| -/ | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Fourier.MatrixFourier | |
| open MaxCutGames.Inverse.KMSBasisInvariant | |
| variable {E B J K : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup B] [Module F2 B] | |
| [AddCommGroup J] [Module F2 J] [AddCommGroup K] [Module F2 K] | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 B] [FiniteDimensional F2 J] | |
| [Fintype E] [Fintype J] | |
| [Fintype (E ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] E)] | |
| [Fintype (E ββ[F2] B)] [Fintype (B ββ[F2] E)] | |
| [Fintype (J ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] J)] | |
| [Fintype (J ββ[F2] B)] [Fintype (B ββ[F2] J)] | |
| omit [FiniteDimensional F2 J] [Fintype (J ββ[F2] B Γ F2)] [Fintype (B Γ F2 ββ[F2] J)] | |
| [Fintype (J ββ[F2] B)] [Fintype (B ββ[F2] J)] [Fintype (B ββ[F2] E)] in | |
| /-- The exact zoom-out square bound after embedding the small frequency | |
| space; the dependent sum is indexed by that small space itself. -/ | |
| theorem coefficient_lifted_zoomOut_sq_bound | |
| (ΞΉ : (J Γ F2) ββ[F2] E) (hΞΉ : Function.Injective ΞΉ) | |
| (f : (E ββ[F2] (B Γ F2)) β β) (hf : IsBasisInvariant f) | |
| (z : B ββ[F2] J) (hz : Function.Surjective z) : | |
| (((Fintype.card E - Fintype.card J : β) : β) ^ 2) * | |
| linearCoeff f (hyperplaneExtend ((leftEmbedding ΞΉ).comp z) (ΞΉ (0, 1))) ^ 2 β€ | |
| ((Fintype.card J : β) + 1) * | |
| (linearCoeff (fun X => f ((LinearMap.inl F2 B F2).comp X)) | |
| ((leftEmbedding ΞΉ).comp z) ^ 2 + | |
| β w : J, linearCoeff f ((leftEmbedding ΞΉ).comp (hyperplaneExtend z w)) ^ 2) := by | |
| have hv : ΞΉ (0, 1) β ((leftEmbedding ΞΉ).comp z).range := by | |
| rw [range_left_comp_of_surjective ΞΉ z hz] | |
| exact lastVector_not_mem_left_range ΞΉ hΞΉ | |
| have h := coefficient_zoomOut_sq_bound f hf ((leftEmbedding ΞΉ).comp z) hv | |
| rw [card_lifted_range ΞΉ hΞΉ z hz, | |
| sum_lifted_range ΞΉ hΞΉ z hz | |
| (fun u => linearCoeff f (hyperplaneExtend ((leftEmbedding ΞΉ).comp z) u) ^ 2)] at h | |
| simpa only [hyperplaneExtend_left_comp] using h | |
| omit [Fintype (J ββ[F2] B)] [FiniteDimensional F2 J] [Fintype (B ββ[F2] E)] | |
| [Fintype (J ββ[F2] (B Γ F2))] in | |
| /-- Summing the genuine pointwise recurrence bounds every dependent branch | |
| by an actual lower-rank fixed-character energy, with no missing multiplicity. -/ | |
| theorem fixedCharacter_step_sum | |
| (ΞΉ : (J Γ F2) ββ[F2] E) (hΞΉ : Function.Injective ΞΉ) | |
| (f : (E ββ[F2] (B Γ F2)) β β) (hf : IsBasisInvariant f) | |
| (Ο : J ββ[F2] K) (A : B ββ[F2] K) : | |
| (((Fintype.card E - Fintype.card J : β) : β) ^ 2) * | |
| (β z β Finset.univ.filter (fun z : B ββ[F2] J => | |
| Ο.comp z = A β§ Function.Surjective z), | |
| linearCoeff f (hyperplaneExtend ((leftEmbedding ΞΉ).comp z) (ΞΉ (0, 1))) ^ 2) β€ | |
| ((Fintype.card J : β) + 1) * | |
| (fixedFrequencyEnergy (leftEmbedding ΞΉ) | |
| (fun X : E ββ[F2] B => f ((LinearMap.inl F2 B F2).comp X)) Ο A + | |
| β w : J, fixedFrequencyEnergy (leftEmbedding ΞΉ) f Ο (hyperplaneExtend A (Ο w))) := by | |
| let P : Finset (B ββ[F2] J) := | |
| Finset.univ.filter fun z => Ο.comp z = A β§ Function.Surjective z | |
| change _ * (β z β P, _) β€ _ | |
| calc | |
| _ β€ β z β P, ((Fintype.card J : β) + 1) * | |
| (linearCoeff (fun X => f ((LinearMap.inl F2 B F2).comp X)) | |
| ((leftEmbedding ΞΉ).comp z) ^ 2 + | |
| β w : J, linearCoeff f ((leftEmbedding ΞΉ).comp (hyperplaneExtend z w)) ^ 2) := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_le_sum | |
| intro z hz | |
| exact coefficient_lifted_zoomOut_sq_bound ΞΉ hΞΉ f hf z | |
| (Finset.mem_filter.mp hz).2.2 | |
| _ = ((Fintype.card J : β) + 1) * | |
| ((β z β P, linearCoeff | |
| (fun X => f ((LinearMap.inl F2 B F2).comp X)) ((leftEmbedding ΞΉ).comp z) ^ 2) + | |
| β w : J, β z β P, | |
| linearCoeff f ((leftEmbedding ΞΉ).comp (hyperplaneExtend z w)) ^ 2) := by | |
| rw [β Finset.mul_sum, Finset.sum_add_distrib, Finset.sum_comm] | |
| _ β€ _ := by | |
| apply mul_le_mul_of_nonneg_left _ (by positivity) | |
| apply add_le_add | |
| Β· rw [fixedFrequencyEnergy_eq] | |
| Β· apply Finset.sum_le_sum | |
| intro w _ | |
| exact dependent_extension_energy_le (leftEmbedding ΞΉ) f Ο A w | |
| end | |
| /-! | |
| # Compatible block frequencies | |
| A compatible surjection on `B Γ F2` has a unique old surjection and a new | |
| vector in the kernel of the partial projection. The new vector does not | |
| change its kernel. Consequently actual basis-invariant Fourier coefficients | |
| are constant along this fiber, yielding its exact energy multiplicity. | |
| -/ | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Fourier.MatrixFourier | |
| variable {B J K E : Type*} | |
| [AddCommGroup B] [Module F2 B] [AddCommGroup J] [Module F2 J] | |
| [AddCommGroup K] [Module F2 K] [AddCommGroup E] [Module F2 E] | |
| /-- Adjoin a new identity coordinate and an arbitrary off-diagonal vector. -/ | |
| def blockFrequency (z : B ββ[F2] J) (w : J) : (B Γ F2) ββ[F2] (J Γ F2) := | |
| (hyperplaneExtend z w).prod (LinearMap.snd F2 B F2) | |
| @[simp] theorem blockFrequency_apply (z : B ββ[F2] J) (w : J) (b : B) (c : F2) : | |
| blockFrequency z w (b, c) = (z b + c β’ w, c) := rfl | |
| theorem blockFrequency_surjective_iff (z : B ββ[F2] J) (w : J) : | |
| Function.Surjective (blockFrequency z w) β Function.Surjective z := by | |
| constructor | |
| Β· intro h y | |
| obtain β¨β¨b, cβ©, hxβ© := h (y, 0) | |
| have hc : c = 0 := congrArg Prod.snd hx | |
| refine β¨b, ?_β© | |
| simpa only [blockFrequency_apply, hc, zero_smul, add_zero] using congrArg Prod.fst hx | |
| Β· intro h x | |
| obtain β¨b, hbβ© := h (x.1 - x.2 β’ w) | |
| refine β¨(b, x.2), ?_β© | |
| simp only [blockFrequency_apply, hb, sub_add_cancel, Prod.eta] | |
| /-- The kernel is independent of the off-diagonal vector, without any | |
| surjectivity assumption. -/ | |
| theorem ker_blockFrequency (z : B ββ[F2] J) (w : J) : | |
| (blockFrequency z w).ker = z.ker.prod (β₯ : Submodule F2 F2) := by | |
| ext β¨b, cβ© | |
| change ((z b + c β’ w, c) = (0, 0)) β (z b = 0 β§ c = 0) | |
| rw [Prod.mk.injEq] | |
| constructor | |
| Β· rintro β¨h, rflβ© | |
| exact β¨by simpa using h, rflβ© | |
| Β· rintro β¨h, rflβ© | |
| simpa using h | |
| theorem blockFrequency_compatible_iff (Ο : J ββ[F2] K) (A : B ββ[F2] K) | |
| (z : B ββ[F2] J) (w : J) : | |
| (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)).comp (blockFrequency z w) = | |
| A.prodMap (LinearMap.id : F2 ββ[F2] F2) β Ο.comp z = A β§ Ο w = 0 := by | |
| constructor | |
| Β· intro h | |
| constructor | |
| Β· apply LinearMap.ext | |
| intro b | |
| simpa using congrArg (fun T : (B Γ F2) ββ[F2] (K Γ F2) => (T (b, 0)).1) h | |
| Β· simpa using congrArg (fun T : (B Γ F2) ββ[F2] (K Γ F2) => (T (0, 1)).1) h | |
| Β· rintro β¨hz, hwβ© | |
| apply LinearMap.ext | |
| rintro β¨b, cβ© | |
| have hb : Ο (z b) = A b := congrArg (fun T : B ββ[F2] K => T b) hz | |
| simp [hb, hw] | |
| def blockOld (T : (B Γ F2) ββ[F2] (J Γ F2)) : B ββ[F2] J := | |
| ((LinearMap.fst F2 J F2).comp T).comp (LinearMap.inl F2 B F2) | |
| def blockNew (T : (B Γ F2) ββ[F2] (J Γ F2)) : J := (T (0, 1)).1 | |
| @[simp] theorem blockOld_blockFrequency (z : B ββ[F2] J) (w : J) : | |
| blockOld (blockFrequency z w) = z := by | |
| ext b | |
| simp [blockOld] | |
| @[simp] theorem blockNew_blockFrequency (z : B ββ[F2] J) (w : J) : | |
| blockNew (blockFrequency z w) = w := by simp [blockNew] | |
| theorem blockFrequency_recover (Ο : J ββ[F2] K) (A : B ββ[F2] K) | |
| (T : (B Γ F2) ββ[F2] (J Γ F2)) | |
| (hT : (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)).comp T = | |
| A.prodMap (LinearMap.id : F2 ββ[F2] F2)) : | |
| blockFrequency (blockOld T) (blockNew T) = T := by | |
| apply LinearMap.ext | |
| intro x | |
| apply Prod.ext | |
| Β· exact congrArg (fun R : (B Γ F2) ββ[F2] J => R x) | |
| (hyperplaneExtend_recover ((LinearMap.fst F2 J F2).comp T)) | |
| Β· have h := congrArg (fun R : (B Γ F2) ββ[F2] (K Γ F2) => (R x).2) hT | |
| exact h.symm | |
| abbrev CompatibleBlockFrequency (Ο : J ββ[F2] K) (A : B ββ[F2] K) := | |
| {T : (B Γ F2) ββ[F2] (J Γ F2) // Function.Surjective T β§ | |
| (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)).comp T = | |
| A.prodMap (LinearMap.id : F2 ββ[F2] F2)} | |
| abbrev CompatibleOldFrequency (Ο : J ββ[F2] K) (A : B ββ[F2] K) := | |
| {z : B ββ[F2] J // Function.Surjective z β§ Ο.comp z = A} | |
| /-- The actual compatible frequency fiber, with its exact kernel-vector parameter. -/ | |
| def compatibleBlockFrequencyEquiv (Ο : J ββ[F2] K) (A : B ββ[F2] K) : | |
| CompatibleBlockFrequency Ο A β CompatibleOldFrequency Ο A Γ Ο.ker where | |
| toFun T := by | |
| have hr := blockFrequency_recover Ο A T.val T.property.2 | |
| have hc : Ο.comp (blockOld T.val) = A β§ Ο (blockNew T.val) = 0 := | |
| (blockFrequency_compatible_iff Ο A _ _).mp (by rw [hr]; exact T.property.2) | |
| refine (β¨blockOld T.val, ?_, hc.1β©, β¨blockNew T.val, hc.2β©) | |
| apply (blockFrequency_surjective_iff (blockOld T.val) (blockNew T.val)).mp | |
| rw [hr] | |
| exact T.property.1 | |
| invFun p := β¨blockFrequency p.1.val p.2.val, | |
| (blockFrequency_surjective_iff _ _).mpr p.1.property.1, | |
| (blockFrequency_compatible_iff Ο A _ _).mpr β¨p.1.property.2, p.2.propertyβ©β© | |
| left_inv T := by | |
| apply Subtype.ext | |
| exact blockFrequency_recover Ο A T.val T.property.2 | |
| right_inv p := by | |
| apply Prod.ext | |
| Β· apply Subtype.ext | |
| exact blockOld_blockFrequency _ _ | |
| Β· apply Subtype.ext | |
| exact blockNew_blockFrequency _ _ | |
| variable [FiniteDimensional F2 E] [Fintype (E ββ[F2] (B Γ F2))] | |
| /-- Actual lifted coefficients are independent of the block vector. -/ | |
| theorem coefficient_blockFrequency_eq (ΞΉ : (J Γ F2) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) (f : (E ββ[F2] (B Γ F2)) β β) | |
| (hf : KMSBasisInvariant.IsBasisInvariant f) (z : B ββ[F2] J) (u v : J) : | |
| linearCoeff f (ΞΉ.comp (blockFrequency z u)) = | |
| linearCoeff f (ΞΉ.comp (blockFrequency z v)) := by | |
| apply KMSKernelOrbitsFourier.coefficient_eq_of_ker_eq f hf | |
| rw [LinearMap.ker_comp_of_ker_eq_bot _ (LinearMap.ker_eq_bot.mpr hΞΉ), | |
| LinearMap.ker_comp_of_ker_eq_bot _ (LinearMap.ker_eq_bot.mpr hΞΉ), | |
| ker_blockFrequency, ker_blockFrequency] | |
| variable [FiniteDimensional F2 B] [FiniteDimensional F2 J] [Fintype J] | |
| [Fintype ((B Γ F2) ββ[F2] E)] [Fintype (B ββ[F2] J)] | |
| [Fintype ((J Γ F2) ββ[F2] (B Γ F2))] | |
| [Fintype ((B Γ F2) ββ[F2] (J Γ F2))] | |
| omit [FiniteDimensional F2 B] [FiniteDimensional F2 J] [Fintype (B Γ F2 ββ[F2] E)] [Fintype (J Γ F2 ββ[F2] B Γ F2)] in | |
| /-- Exact collapse of the new-coordinate fiber in the prescribed-frequency | |
| energy. The multiplier is the actual number of vectors in `ker Ο`. -/ | |
| theorem fixedFrequencyEnergy_block (ΞΉ : (J Γ F2) ββ[F2] E) | |
| (hΞΉ : Function.Injective ΞΉ) (f : (E ββ[F2] (B Γ F2)) β β) | |
| (hf : KMSBasisInvariant.IsBasisInvariant f) (Ο : J ββ[F2] K) (A : B ββ[F2] K) : | |
| fixedFrequencyEnergy ΞΉ f (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)) | |
| (A.prodMap (LinearMap.id : F2 ββ[F2] F2)) = | |
| (Fintype.card Ο.ker : β) * β z : CompatibleOldFrequency Ο A, | |
| linearCoeff f (ΞΉ.comp (blockFrequency z.val 0)) ^ 2 := by | |
| let e := compatibleBlockFrequencyEquiv Ο A | |
| calc | |
| _ = β T : CompatibleBlockFrequency Ο A, linearCoeff f (ΞΉ.comp T.val) ^ 2 := by | |
| unfold fixedFrequencyEnergy | |
| rw [β Finset.sum_subtype (Finset.univ.filter (fun T : (B Γ F2) ββ[F2] (J Γ F2) => | |
| Function.Surjective T β§ | |
| (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)).comp T = | |
| A.prodMap (LinearMap.id : F2 ββ[F2] F2))) (by simp) | |
| (fun T => linearCoeff f (ΞΉ.comp T) ^ 2), | |
| Finset.sum_filter, Finset.sum_filter] | |
| apply Finset.sum_congr rfl | |
| intro T _ | |
| by_cases hs : Function.Surjective T <;> | |
| by_cases hp : (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)).comp T = | |
| A.prodMap (LinearMap.id : F2 ββ[F2] F2) <;> simp [smallCoeff, hs, hp] | |
| _ = β p : CompatibleOldFrequency Ο A Γ Ο.ker, | |
| linearCoeff f (ΞΉ.comp (blockFrequency p.1.val p.2.val)) ^ 2 := by | |
| apply Fintype.sum_equiv e | |
| intro T | |
| exact congrArg (fun R : (B Γ F2) ββ[F2] (J Γ F2) => | |
| linearCoeff f (ΞΉ.comp R) ^ 2) (congrArg Subtype.val (e.symm_apply_apply T)).symm | |
| _ = _ := by | |
| rw [Fintype.sum_prod_type] | |
| simp_rw [coefficient_blockFrequency_eq ΞΉ hΞΉ f hf _ _ 0] | |
| simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul] | |
| rw [Finset.mul_sum] | |
| end | |
| /-! The complete product-coordinate fixed-character recurrence, with the | |
| actual new-coordinate multiplicity. This joins the block-frequency bijection | |
| to the genuine Fourier zoom-out energy inequality. -/ | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Fourier.MatrixFourier | |
| open MaxCutGames.Inverse.KMSBasisInvariant | |
| variable {E B J K : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup B] [Module F2 B] | |
| [AddCommGroup J] [Module F2 J] [AddCommGroup K] [Module F2 K] | |
| theorem comp_blockFrequency_zero (ΞΉ : (J Γ F2) ββ[F2] E) (z : B ββ[F2] J) : | |
| ΞΉ.comp (blockFrequency z 0) = | |
| hyperplaneExtend ((leftEmbedding ΞΉ).comp z) (ΞΉ (0, 1)) := by | |
| apply LinearMap.ext | |
| rintro β¨b, cβ© | |
| change ΞΉ (z b + c β’ 0, c) = ΞΉ (z b, 0) + c β’ ΞΉ (0, 1) | |
| simp only [smul_zero, add_zero] | |
| rw [β map_smul, β map_add] | |
| congr 1 | |
| simp | |
| variable [FiniteDimensional F2 E] [FiniteDimensional F2 B] [FiniteDimensional F2 J] | |
| [Fintype E] [Fintype J] | |
| [Fintype (E ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] E)] | |
| [Fintype (E ββ[F2] B)] [Fintype (B ββ[F2] E)] | |
| [Fintype (J ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] J)] | |
| [Fintype (J ββ[F2] B)] [Fintype (B ββ[F2] J)] | |
| [Fintype ((J Γ F2) ββ[F2] (B Γ F2))] | |
| [Fintype ((B Γ F2) ββ[F2] (J Γ F2))] | |
| omit [Fintype ((J Γ F2) ββ[F2] (B Γ F2))] [Fintype (J ββ[F2] B)] | |
| [FiniteDimensional F2 J] [Fintype (B ββ[F2] E)] [Fintype (J ββ[F2] (B Γ F2))] in | |
| /-- A genuine one-step recurrence in the actual restricted Fourier energy. | |
| Every term on the right has one fewer small-space dimension and one fewer | |
| fixed character. -/ | |
| theorem fixedFrequencyEnergy_product_step | |
| (ΞΉ : (J Γ F2) ββ[F2] E) (hΞΉ : Function.Injective ΞΉ) | |
| (f : (E ββ[F2] (B Γ F2)) β β) (hf : IsBasisInvariant f) | |
| (Ο : J ββ[F2] K) (A : B ββ[F2] K) : | |
| (((Fintype.card E - Fintype.card J : β) : β) ^ 2) * | |
| fixedFrequencyEnergy ΞΉ f (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)) | |
| (A.prodMap (LinearMap.id : F2 ββ[F2] F2)) β€ | |
| (Fintype.card Ο.ker : β) * (((Fintype.card J : β) + 1) * | |
| (fixedFrequencyEnergy (leftEmbedding ΞΉ) | |
| (fun X : E ββ[F2] B => f ((LinearMap.inl F2 B F2).comp X)) Ο A + | |
| β w : J, fixedFrequencyEnergy (leftEmbedding ΞΉ) f Ο (hyperplaneExtend A (Ο w)))) := by | |
| let P : Finset (B ββ[F2] J) := | |
| Finset.univ.filter fun z => Ο.comp z = A β§ Function.Surjective z | |
| have hsum : (β z : CompatibleOldFrequency Ο A, | |
| linearCoeff f (ΞΉ.comp (blockFrequency z.val 0)) ^ 2) = | |
| β z β P, | |
| linearCoeff f (hyperplaneExtend ((leftEmbedding ΞΉ).comp z) (ΞΉ (0, 1))) ^ 2 := by | |
| rw [β Finset.sum_subtype (p := fun z : B ββ[F2] J => | |
| Function.Surjective z β§ Ο.comp z = A) P (by intro z; simp [P, and_comm]) | |
| (fun z => linearCoeff f (ΞΉ.comp (blockFrequency z 0)) ^ 2)] | |
| apply Finset.sum_congr rfl | |
| intro z _ | |
| rw [comp_blockFrequency_zero] | |
| rw [fixedFrequencyEnergy_block ΞΉ hΞΉ f hf Ο A, hsum] | |
| calc | |
| _ = (Fintype.card Ο.ker : β) * | |
| ((((Fintype.card E - Fintype.card J : β) : β) ^ 2) * | |
| β z β P, linearCoeff f | |
| (hyperplaneExtend ((leftEmbedding ΞΉ).comp z) (ΞΉ (0, 1))) ^ 2) := by ring | |
| _ β€ _ := mul_le_mul_of_nonneg_left (fixedCharacter_step_sum ΞΉ hΞΉ f hf Ο A) | |
| (Nat.cast_nonneg _) | |
| end | |
| /-! Scalar closure of the genuine KMS fixed-character induction. The three | |
| combinatorial losses are absorbed by the explicit quadratic exponent; no | |
| Fourier estimate is asserted or assumed in this arithmetic lemma. -/ | |
| /-- The recurrence cost in Lemma 3.19 is absorbed by `2^(4 iΒ²)`. The proof only | |
| needs `n < ell`, weaker than the usual `2*(n+1) β€ ell` induction hypothesis. -/ | |
| theorem fixedCharacter_constant_step (n m ell : β) (hnell : n < ell) : | |
| (2 : β) ^ n * ((2 : β) ^ n + 1) ^ 2 * (2 : β) ^ (4 * n * n) / | |
| ((((2 : β) ^ ell - (2 : β) ^ n) ^ 2) * (2 : β) ^ ((n + m) * ell)) β€ | |
| (2 : β) ^ (4 * (n + 1) * (n + 1)) / | |
| (2 : β) ^ (((n + 1) + (m + 1)) * ell) := by | |
| let A : β := (2 : β) ^ ell | |
| let B : β := (2 : β) ^ n | |
| let C : β := (2 : β) ^ (4 * n * n) | |
| let C' : β := (2 : β) ^ (4 * (n + 1) * (n + 1)) | |
| let P : β := (2 : β) ^ ((n + m) * ell) | |
| have hA : 0 < A := by dsimp [A]; positivity | |
| have hB : 0 < B := by dsimp [B]; positivity | |
| have hC : 0 < C := by dsimp [C]; positivity | |
| have hP : 0 < P := by dsimp [P]; positivity | |
| have hB1 : 1 β€ B := one_le_powβ (by norm_num : (1 : β) β€ 2) | |
| have hAB : 2 * B β€ A := by | |
| have h := pow_le_pow_rightβ (by norm_num : (1 : β) β€ 2) hnell | |
| simpa only [pow_succ, mul_comm] using h | |
| have hdiff : 0 < A - B := by linarith | |
| have hplus : (B + 1) ^ 2 β€ 4 * B ^ 2 := by | |
| have hs := mul_self_le_mul_self (show 0 β€ B + 1 by positivity) | |
| (show B + 1 β€ 2 * B by linarith) | |
| nlinarith only [hs] | |
| have hsquare : A ^ 2 β€ 4 * (A - B) ^ 2 := by | |
| have hs := mul_self_le_mul_self (show 0 β€ A / 2 by positivity) | |
| (show A / 2 β€ A - B by linarith) | |
| nlinarith only [hs] | |
| have hcoeff : B * (B + 1) ^ 2 * C β€ 4 * B ^ 3 * C := by | |
| calc | |
| _ β€ B * (4 * B ^ 2) * C := mul_le_mul_of_nonneg_right | |
| (mul_le_mul_of_nonneg_left hplus hB.le) hC.le | |
| _ = _ := by ring | |
| have hconst : 16 * B ^ 3 * C β€ C' := by | |
| calc | |
| _ = (2 : β) ^ (4 + 3 * n + 4 * n * n) := by | |
| dsimp [B, C] | |
| rw [show (16 : β) = 2 ^ 4 by norm_num, β pow_mul, β pow_add, β pow_add] | |
| congr 1 | |
| ring | |
| _ β€ _ := pow_le_pow_rightβ (by norm_num) (by nlinarith) | |
| have hmain : B * (B + 1) ^ 2 * C * A ^ 2 β€ C' * (A - B) ^ 2 := by | |
| calc | |
| _ β€ (4 * B ^ 3 * C) * A ^ 2 := | |
| mul_le_mul_of_nonneg_right hcoeff (sq_nonneg A) | |
| _ β€ (4 * B ^ 3 * C) * (4 * (A - B) ^ 2) := | |
| mul_le_mul_of_nonneg_left hsquare (by positivity) | |
| _ = (16 * B ^ 3 * C) * (A - B) ^ 2 := by ring | |
| _ β€ _ := mul_le_mul_of_nonneg_right hconst (sq_nonneg _) | |
| have hpower : (2 : β) ^ (((n + 1) + (m + 1)) * ell) = A ^ 2 * P := by | |
| dsimp [A, P] | |
| rw [β pow_mul, β pow_add] | |
| congr 1 | |
| ring | |
| change B * (B + 1) ^ 2 * C / ((A - B) ^ 2 * P) β€ | |
| C' / (2 : β) ^ (((n + 1) + (m + 1)) * ell) | |
| apply (div_le_div_iffβ (by positivity) (by positivity)).mpr | |
| rw [hpower] | |
| calc | |
| _ = (B * (B + 1) ^ 2 * C * A ^ 2) * P := by ring | |
| _ β€ (C' * (A - B) ^ 2) * P := mul_le_mul_of_nonneg_right hmain hP.le | |
| _ = _ := by ring | |
| end MaxCutGames.Inverse.KMSAnalytic | |
| /-! Quantitative closure of the genuine fixed-character product recurrence. | |
| The hypotheses are the actual two smaller restricted energies. The proof | |
| accounts for the kernel multiplicity and all dependent extensions explicitly. | |
| -/ | |
| namespace MaxCutGames.Inverse.KMSAnalytic | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Inverse.KMSBasisInvariant | |
| variable {E B J K : Type*} | |
| [AddCommGroup E] [Module F2 E] [AddCommGroup B] [Module F2 B] | |
| [AddCommGroup J] [Module F2 J] [AddCommGroup K] [Module F2 K] | |
| [FiniteDimensional F2 E] [FiniteDimensional F2 B] | |
| [FiniteDimensional F2 J] [FiniteDimensional F2 K] | |
| [Fintype E] [Fintype J] | |
| [Fintype (E ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] E)] | |
| [Fintype (E ββ[F2] B)] [Fintype (B ββ[F2] E)] | |
| [Fintype (J ββ[F2] (B Γ F2))] [Fintype ((B Γ F2) ββ[F2] J)] | |
| [Fintype (J ββ[F2] B)] [Fintype (B ββ[F2] J)] | |
| [Fintype ((J Γ F2) ββ[F2] (B Γ F2))] | |
| [Fintype ((B Γ F2) ββ[F2] (J Γ F2))] | |
| omit [Fintype ((J Γ F2) ββ[F2] (B Γ F2))] [Fintype (J ββ[F2] B)] | |
| [Fintype (B ββ[F2] E)] [Fintype (J ββ[F2] (B Γ F2))] in | |
| /-- The fixed-character recurrence preserves the explicit quadratic constant. | |
| No local-density or Fourier bound is hidden in the scalar accounting. -/ | |
| theorem fixedFrequencyEnergy_product_bound | |
| (ΞΉ : (J Γ F2) ββ[F2] E) (hΞΉ : Function.Injective ΞΉ) | |
| (f : (E ββ[F2] (B Γ F2)) β β) (hf : IsBasisInvariant f) | |
| (Ο : J ββ[F2] K) (A : B ββ[F2] K) (Ξ΅ : β) (hΞ΅ : 0 β€ Ξ΅) | |
| (hfirst : (2 : β) ^ ((Module.finrank F2 J + Module.finrank F2 K) * | |
| Module.finrank F2 E) * fixedFrequencyEnergy (leftEmbedding ΞΉ) | |
| (fun X : E ββ[F2] B => f ((LinearMap.inl F2 B F2).comp X)) Ο A β€ | |
| (2 : β) ^ (4 * Module.finrank F2 J * Module.finrank F2 J) * Ξ΅) | |
| (hlower : β w : J, (2 : β) ^ ((Module.finrank F2 J + Module.finrank F2 K) * | |
| Module.finrank F2 E) * fixedFrequencyEnergy (leftEmbedding ΞΉ) f Ο | |
| (hyperplaneExtend A (Ο w)) β€ | |
| (2 : β) ^ (4 * Module.finrank F2 J * Module.finrank F2 J) * Ξ΅) : | |
| (2 : β) ^ ((Module.finrank F2 (J Γ F2) + Module.finrank F2 (K Γ F2)) * | |
| Module.finrank F2 E) * fixedFrequencyEnergy ΞΉ f | |
| (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)) | |
| (A.prodMap (LinearMap.id : F2 ββ[F2] F2)) β€ | |
| (2 : β) ^ (4 * Module.finrank F2 (J Γ F2) * Module.finrank F2 (J Γ F2)) * Ξ΅ := by | |
| let n := Module.finrank F2 J | |
| let m := Module.finrank F2 K | |
| let ell := Module.finrank F2 E | |
| let P : β := 2 ^ ((n + m) * ell) | |
| let C : β := 2 ^ (4 * n * n) | |
| let N : β := 2 ^ n | |
| let D : β := 2 ^ ell - 2 ^ n | |
| let a := fixedFrequencyEnergy (leftEmbedding ΞΉ) | |
| (fun X : E ββ[F2] B => f ((LinearMap.inl F2 B F2).comp X)) Ο A | |
| let b := fun w : J => fixedFrequencyEnergy (leftEmbedding ΞΉ) f Ο | |
| (hyperplaneExtend A (Ο w)) | |
| let t := fixedFrequencyEnergy ΞΉ f | |
| (Ο.prodMap (LinearMap.id : F2 ββ[F2] F2)) | |
| (A.prodMap (LinearMap.id : F2 ββ[F2] F2)) | |
| have hnell : n < ell := by | |
| have hdim := LinearMap.finrank_le_finrank_of_injective hΞΉ | |
| rw [Module.finrank_prod, Module.finrank_self] at hdim | |
| exact hdim | |
| have hcardE : Fintype.card E = 2 ^ ell := by | |
| rw [Module.card_eq_pow_finrank (K := F2)] | |
| simp only [F2, ZMod.card, ell] | |
| have hcardJ : Fintype.card J = 2 ^ n := by | |
| rw [Module.card_eq_pow_finrank (K := F2)] | |
| simp only [F2, ZMod.card, n] | |
| have hcardle : Fintype.card J β€ Fintype.card E := by | |
| rw [hcardJ, hcardE] | |
| exact Nat.pow_le_pow_right (by decide) hnell.le | |
| have hcardJR : (Fintype.card J : β) = N := by | |
| rw [hcardJ] | |
| simp only [Nat.cast_pow, Nat.cast_ofNat, N] | |
| have hdiff : ((Fintype.card E - Fintype.card J : β) : β) = D := by | |
| rw [Nat.cast_sub hcardle, hcardE, hcardJ] | |
| simp only [Nat.cast_pow, Nat.cast_ofNat, D] | |
| have hker : (Fintype.card Ο.ker : β) β€ N := by | |
| rw [β hcardJR] | |
| exact_mod_cast Fintype.card_le_of_injective (fun x : Ο.ker => (x : J)) | |
| Subtype.val_injective | |
| have hP : 0 < P := by dsimp [P]; positivity | |
| have hN : 0 β€ N := by dsimp [N]; positivity | |
| have hD : 0 < D := by | |
| dsimp [D] | |
| exact sub_pos.mpr (pow_lt_pow_rightβ (by norm_num : (1 : β) < 2) hnell) | |
| have ha : 0 β€ a := fixedFrequencyEnergy_nonneg _ _ _ _ | |
| have hb : 0 β€ β w : J, b w := | |
| Finset.sum_nonneg (fun w _ => fixedFrequencyEnergy_nonneg _ _ _ _) | |
| have hsum : P * (a + β w : J, b w) β€ (N + 1) * (C * Ξ΅) := by | |
| calc | |
| _ = P * a + β w : J, P * b w := by rw [mul_add, Finset.mul_sum] | |
| _ β€ C * Ξ΅ + β _w : J, C * Ξ΅ := | |
| add_le_add hfirst (Finset.sum_le_sum (fun w _ => hlower w)) | |
| _ = (N + 1) * (C * Ξ΅) := by simp only [Finset.sum_const, Finset.card_univ, | |
| nsmul_eq_mul, hcardJR]; ring | |
| have hrec : D ^ 2 * t β€ (Fintype.card Ο.ker : β) * ((N + 1) * (a + β w : J, b w)) := by | |
| simpa only [hdiff, hcardJR] using fixedFrequencyEnergy_product_step ΞΉ hΞΉ f hf Ο A | |
| have hweighted : (D ^ 2 * P) * t β€ N * (N + 1) ^ 2 * C * Ξ΅ := by | |
| calc | |
| _ = P * (D ^ 2 * t) := by ring | |
| _ β€ P * ((Fintype.card Ο.ker : β) * ((N + 1) * (a + β w : J, b w))) := | |
| mul_le_mul_of_nonneg_left hrec hP.le | |
| _ β€ P * (N * ((N + 1) * (a + β w : J, b w))) := by | |
| apply mul_le_mul_of_nonneg_left _ hP.le | |
| exact mul_le_mul_of_nonneg_right hker (mul_nonneg (by positivity) (add_nonneg ha hb)) | |
| _ = (N * (N + 1)) * (P * (a + β w : J, b w)) := by ring | |
| _ β€ (N * (N + 1)) * ((N + 1) * (C * Ξ΅)) := | |
| mul_le_mul_of_nonneg_left hsum (by positivity) | |
| _ = _ := by ring | |
| have ht : t β€ (N * (N + 1) ^ 2 * C / (D ^ 2 * P)) * Ξ΅ := by | |
| calc | |
| t β€ (N * (N + 1) ^ 2 * C * Ξ΅) / (D ^ 2 * P) := | |
| (le_div_iffβ (show 0 < D ^ 2 * P by positivity)).mpr | |
| (by simpa only [mul_comm] using hweighted) | |
| _ = _ := by ring | |
| have hc := fixedCharacter_constant_step n m ell hnell | |
| change N * (N + 1) ^ 2 * C / (D ^ 2 * P) β€ | |
| (2 : β) ^ (4 * (n + 1) * (n + 1)) / | |
| (2 : β) ^ (((n + 1) + (m + 1)) * ell) at hc | |
| have hfinal := ht.trans (mul_le_mul_of_nonneg_right hc hΞ΅) | |
| rw [Module.finrank_prod, Module.finrank_prod, Module.finrank_self] | |
| change (2 : β) ^ (((n + 1) + (m + 1)) * ell) * t β€ | |
| (2 : β) ^ (4 * (n + 1) * (n + 1)) * Ξ΅ | |
| have hresult := (le_div_iffβ | |
| (show 0 < (2 : β) ^ (((n + 1) + (m + 1)) * ell) by positivity)).mp | |
| (show t β€ ((2 : β) ^ (4 * (n + 1) * (n + 1)) * Ξ΅) / | |
| (2 : β) ^ (((n + 1) + (m + 1)) * ell) from hfinal.trans_eq (by ring)) | |
| simpa only [mul_comm] using hresult | |
| end | |
| /-! | |
| # Transport of the primal codomain | |
| An equivalence of primal codomains gives a unique frequency in the Fourier | |
| pullback fiber. The resulting exact coefficient identity transports both | |
| the small component and its prescribed-frequency energy. No invariance or | |
| analytic estimate is needed for these identities. | |
| -/ | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open MaxCutGames.Integration.BinaryLinear (F2) | |
| open MaxCutGames.Fourier.MatrixFourier | |
| variable {E F F' I J : Type*} | |
| [AddCommGroup E] [Module F2 E] | |
| [AddCommGroup F] [Module F2 F] [AddCommGroup F'] [Module F2 F'] | |
| [AddCommGroup I] [Module F2 I] [AddCommGroup J] [Module F2 J] | |
| def codomainTransport (e : F ββ[F2] F') (f : (E ββ[F2] F) β β) : | |
| (E ββ[F2] F') β β := fun X => f (e.symm.toLinearMap.comp X) | |
| /-- Actual dual frequencies are reindexed by precomposition with the inverse. -/ | |
| def codomainFrequencyEquiv (e : F ββ[F2] F') : (F ββ[F2] I) β (F' ββ[F2] I) where | |
| toFun T := T.comp e.symm.toLinearMap | |
| invFun T := T.comp e.toLinearMap | |
| left_inv T := by ext x; simp | |
| right_inv T := by ext x; simp | |
| @[simp] theorem codomainFrequencyEquiv_apply (e : F ββ[F2] F') (T : F ββ[F2] I) : | |
| codomainFrequencyEquiv e T = T.comp e.symm.toLinearMap := rfl | |
| @[simp] theorem codomainFrequency_cancel (e : F ββ[F2] F') (T : F ββ[F2] I) : | |
| (T.comp e.symm.toLinearMap).comp e.toLinearMap = T := by ext x; simp | |
| theorem surjective_comp_codomainEquiv_iff (e : F ββ[F2] F') (T : F' ββ[F2] I) : | |
| Function.Surjective (T.comp e.toLinearMap) β Function.Surjective T := by | |
| constructor | |
| Β· intro h y | |
| obtain β¨x, hxβ© := h y | |
| exact β¨e x, hxβ© | |
| Β· intro h y | |
| obtain β¨x, hxβ© := h y | |
| refine β¨e.symm x, ?_β© | |
| simpa using hx | |
| variable [FiniteDimensional F2 E] [FiniteDimensional F2 F] [FiniteDimensional F2 F'] | |
| [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] | |
| [Fintype (E ββ[F2] F')] [Fintype (F' ββ[F2] E)] | |
| omit [Fintype (F' ββ[F2] E)] in | |
| /-- The Fourier pullback fiber of a codomain equivalence has a single term. -/ | |
| theorem linearCoeff_codomainTransport (e : F ββ[F2] F') | |
| (f : (E ββ[F2] F) β β) (S' : F' ββ[F2] E) : | |
| linearCoeff (codomainTransport e f) S' = linearCoeff f (S'.comp e.toLinearMap) := by | |
| unfold codomainTransport | |
| rw [KMSFourthMoment.coefficient_codomain_pullback] | |
| have hc : (S'.comp e.toLinearMap).comp e.symm.toLinearMap = S' := by ext x; simp | |
| rw [Finset.sum_eq_single (S'.comp e.toLinearMap)] | |
| Β· rw [ite_eq_left hc] | |
| Β· intro S _ hS | |
| apply ite_eq_right | |
| intro h | |
| apply hS | |
| apply LinearMap.ext | |
| intro x | |
| simpa using congrArg (fun R : F' ββ[F2] E => R (e x)) h | |
| Β· intro h | |
| exact (h (Finset.mem_univ _)).elim | |
| omit [FiniteDimensional F2 E] [FiniteDimensional F2 F] [FiniteDimensional F2 F'] [Fintype (E ββ[F2] F)] [Fintype (F ββ[F2] E)] [Fintype (E ββ[F2] F')] [Fintype (F' ββ[F2] E)] in | |
| /-- Codomain transport preserves the original basis invariance. -/ | |
| theorem basisInvariant_codomainTransport (e : F ββ[F2] F') | |
| (f : (E ββ[F2] F) β β) (hf : KMSBasisInvariant.IsBasisInvariant f) : | |
| KMSBasisInvariant.IsBasisInvariant (codomainTransport e f) := by | |
| intro g X | |
| change f (e.symm.toLinearMap.comp (X.comp g.toLinearMap)) = | |
| f (e.symm.toLinearMap.comp X) | |
| rw [β LinearMap.comp_assoc] | |
| exact hf g (e.symm.toLinearMap.comp X) | |
| variable [FiniteDimensional F2 I] | |
| [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] | |
| [Fintype (I ββ[F2] F')] [Fintype (F' ββ[F2] I)] | |
| omit [FiniteDimensional F2 I] [Fintype (I ββ[F2] F)] [Fintype (F ββ[F2] I)] | |
| [Fintype (I ββ[F2] F')] [Fintype (F' ββ[F2] I)] [Fintype (F' ββ[F2] E)] in | |
| theorem smallCoeff_codomainTransport (e : F ββ[F2] F') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (T : F' ββ[F2] I) : | |
| smallCoeff ΞΉ (codomainTransport e f) T = | |
| smallCoeff ΞΉ f (T.comp e.toLinearMap) := by | |
| unfold smallCoeff | |
| rw [surjective_comp_codomainEquiv_iff] | |
| split_ifs | |
| Β· rw [linearCoeff_codomainTransport, LinearMap.comp_assoc] | |
| Β· rfl | |
| omit [Fintype (F' ββ[F2] E)] in | |
| /-- The synthesized small component itself commutes with codomain transport. -/ | |
| theorem smallComponent_codomainTransport (e : F ββ[F2] F') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) : | |
| smallComponent ΞΉ (codomainTransport e f) = | |
| codomainTransport e (smallComponent ΞΉ f) := by | |
| apply eq_of_coeff_eq | |
| intro T | |
| rw [coeff_smallComponent, linearCoeff_codomainTransport, coeff_smallComponent, | |
| smallCoeff_codomainTransport] | |
| omit [FiniteDimensional F2 I] [Fintype (I ββ[F2] F)] [Fintype (I ββ[F2] F')] | |
| [Fintype (F' ββ[F2] E)] in | |
| /-- Transport the prescribed partial frequency together with the primal | |
| codomain; the normalized energy remains exactly unchanged. -/ | |
| theorem fixedFrequencyEnergy_codomainTransport (e : F ββ[F2] F') (ΞΉ : I ββ[F2] E) | |
| (f : (E ββ[F2] F) β β) (Ο : I ββ[F2] J) (A : F ββ[F2] J) : | |
| fixedFrequencyEnergy ΞΉ (codomainTransport e f) Ο (A.comp e.symm.toLinearMap) = | |
| fixedFrequencyEnergy ΞΉ f Ο A := by | |
| unfold fixedFrequencyEnergy | |
| rw [Finset.sum_filter, Finset.sum_filter] | |
| symm | |
| apply Fintype.sum_equiv (codomainFrequencyEquiv (I := I) e) | |
| intro T | |
| have hp : Ο.comp (T.comp e.symm.toLinearMap) = A.comp e.symm.toLinearMap β | |
| Ο.comp T = A := by | |
| rw [β LinearMap.comp_assoc] | |
| exact (codomainFrequencyEquiv (I := J) e).injective.eq_iff | |
| simp only [codomainFrequencyEquiv_apply, smallCoeff_codomainTransport, | |
| codomainFrequency_cancel, hp] | |
| end | |
| end MaxCutGames.Inverse.KMSAnalytic | |
| end OAI | |