| import Mathlib.Tactic.Ring |
| import OAI.Computability.UniqueGames.Analysis.Identities |
| import OAI.Computability.UniqueGames.Analysis.MatrixSubspaceCount |
| import OAI.Computability.UniqueGames.Analysis.RestrictionLemmas |
|
|
| namespace OAI |
|
|
| section |
|
|
| /-! Frequency-conditioned counts of actual Hybrid pairs and derivative indices. -/ |
| namespace UniqueGamesTheorem.Appendix.HybridCounting |
|
|
| open Module |
| open UniqueGamesTheorem.Integration.BinaryLinear (F2) |
|
|
| private theorem comap_subtype_injective {K V : Type*} [Field K] [AddCommGroup V] |
| [Module K V] (I A B : Submodule K V) (hA : A ≤ I) (hB : B ≤ I) |
| (h : A.comap I.subtype = B.comap I.subtype) : A = B := by |
| apply le_antisymm |
| · intro x hx |
| have hv : (⟨x, hA hx⟩ : I) ∈ A.comap I.subtype := hx |
| rw [h] at hv |
| exact hv |
| · intro x hx |
| have hv : (⟨x, hB hx⟩ : I) ∈ B.comap I.subtype := hx |
| rw [← h] at hv |
| exact hv |
|
|
| private theorem map_quotient_injective {K V : Type*} [Field K] [AddCommGroup V] |
| [Module K V] (N A B : Submodule K V) (hA : N ≤ A) (hB : N ≤ B) |
| (h : A.map N.mkQ = B.map N.mkQ) : A = B := by |
| have aux (P Q : Submodule K V) (hQ : N ≤ Q) |
| (he : P.map N.mkQ = Q.map N.mkQ) : P ≤ Q := by |
| intro x hx |
| have hm : N.mkQ x ∈ P.map N.mkQ := Submodule.mem_map.mpr ⟨x, hx, rfl⟩ |
| rw [he] at hm |
| obtain ⟨y, hy, heq⟩ := Submodule.mem_map.mp hm |
| have hk : x - y ∈ N := by |
| have hzero : x - y ∈ LinearMap.ker N.mkQ := by |
| change N.mkQ (x - y) = 0 |
| rw [map_sub, heq, sub_self] |
| simpa only [Submodule.ker_mkQ] using hzero |
| have hz := Q.add_mem (hQ hk) hy |
| simpa only [sub_add_cancel] using hz |
| exact le_antisymm (aux A B hB h) (aux B A hA h.symm) |
|
|
| private theorem finite_submodules (V : Type*) [AddCommGroup V] [Module F2 V] |
| [FiniteDimensional F2 V] : Finite (Submodule F2 V) := by |
| let : Finite V := Finite.of_injective (Module.finBasis F2 V).equivFun |
| (Module.finBasis F2 V).equivFun.injective |
| exact Finite.of_injective (fun S : Submodule F2 V => (S : Set V)) SetLike.coe_injective |
|
|
| variable {E F : Type*} [AddCommGroup E] [AddCommGroup F] |
| [Module F2 E] [Module F2 F] [FiniteDimensional F2 F] |
|
|
| /-- All actual Hybrid pairs for this frequency, with no ambient-dimension factor. -/ |
| theorem card_hybrid_pairs_le (Y : F →ₗ[F2] E) (d : ℕ) |
| (hY : finrank F2 Y.range ≤ d) : |
| Nat.card {p : Submodule F2 E × Submodule F2 F |
| LinearIdentities.Hybrid Y p.1 p.2} ≤ 2 ^ (2 * d * d) := by |
| classical |
| let P := {p : Submodule F2 E × Submodule F2 F |
| LinearIdentities.Hybrid Y p.1 p.2} |
| let : Finite (Submodule F2 Y.range) := finite_submodules _ |
| let : Finite (Submodule F2 (F ⧸ Y.ker)) := finite_submodules _ |
| have hk (p : P) : Y.ker ≤ p.1.2 := by |
| intro x hx |
| apply p.2.2 |
| change Y x ∈ p.1.1 |
| rw [show Y x = 0 from hx] |
| exact Submodule.zero_mem _ |
| let code (p : P) : Submodule F2 Y.range × Submodule F2 (F ⧸ Y.ker) := |
| ((p.1.1).comap Y.range.subtype, (p.1.2).map Y.ker.mkQ) |
| have hi : Function.Injective code := by |
| intro p q h |
| apply Subtype.ext |
| apply Prod.ext |
| · exact comap_subtype_injective Y.range p.1.1 q.1.1 p.2.1 q.2.1 |
| (congrArg Prod.fst h) |
| · exact map_quotient_injective Y.ker p.1.2 q.1.2 (hk p) (hk q) |
| (congrArg Prod.snd h) |
| have hq : finrank F2 (F ⧸ Y.ker) = finrank F2 Y.range := by |
| have hquot := Y.ker.finrank_quotient_add_finrank |
| have hrank := Y.finrank_range_add_finrank_ker |
| omega |
| have hleft := UniqueGamesTheorem.Fourier.MatrixSubspaceCount.card_binary_subspaces_le_of_finrank_le |
| (C := Y.range) d hY |
| have hright := UniqueGamesTheorem.Fourier.MatrixSubspaceCount.card_binary_subspaces_le_of_finrank_le |
| (C := F ⧸ Y.ker) d (hq.trans_le hY) |
| calc |
| _ ≤ Nat.card (Submodule F2 Y.range × Submodule F2 (F ⧸ Y.ker)) := |
| Nat.card_le_card_of_injective code hi |
| _ = Nat.card (Submodule F2 Y.range) * Nat.card (Submodule F2 (F ⧸ Y.ker)) := |
| Nat.card_prod _ _ |
| _ ≤ 2 ^ (d * d) * 2 ^ (d * d) := Nat.mul_le_mul hleft hright |
| _ = _ := by rw [← pow_add]; congr 1; ring |
|
|
| variable [FiniteDimensional F2 E] |
|
|
| /-- The actual order-bounded index subtype injects into the conditioned pairs. -/ |
| theorem card_hybridIndex_le_two (Y : F →ₗ[F2] E) (d : ℕ) |
| (hY : finrank F2 Y.range ≤ d) : |
| Nat.card {s : Derivatives.HybridIndex (E := E) (F := F) d |
| LinearIdentities.Hybrid Y s.val.1 s.val.2} ≤ 2 ^ (2 * d * d) := by |
| classical |
| let : Finite (Submodule F2 E) := finite_submodules _ |
| let : Finite (Submodule F2 F) := finite_submodules _ |
| let code (s : {s : Derivatives.HybridIndex (E := E) (F := F) d |
| LinearIdentities.Hybrid Y s.val.1 s.val.2}) : |
| {p : Submodule F2 E × Submodule F2 F |
| ⟨s.1.1, s.2⟩ |
| have hi : Function.Injective code := by |
| intro s t h |
| apply Subtype.ext |
| apply Subtype.ext |
| change (code s).1 = (code t).1 |
| exact congrArg Subtype.val h |
| exact (Nat.card_le_card_of_injective code hi).trans (card_hybrid_pairs_le Y d hY) |
|
|
| theorem card_hybridIndex_le (Y : F →ₗ[F2] E) (d : ℕ) |
| (hY : finrank F2 Y.range ≤ d) : |
| Nat.card {s : Derivatives.HybridIndex (E := E) (F := F) d |
| LinearIdentities.Hybrid Y s.val.1 s.val.2} ≤ 2 ^ (3 * d * d) := by |
| apply (card_hybridIndex_le_two Y d hY).trans |
| apply Nat.pow_le_pow_right (by decide) |
| simpa only [Nat.mul_assoc] using Nat.mul_le_mul_right (d * d) (by decide : 2 ≤ 3) |
|
|
| end UniqueGamesTheorem.Appendix.HybridCounting |
|
|
| end |
|
|
| end OAI |
|
|
