openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Algebra /AffineLinearHeavyWitness.lean
| import OAI.Computability.PerfectCompleteness.Machines.BinaryDualCoordinates | |
| namespace OAI | |
| section | |
| namespace PerfectCompleteness.AffineLinearHeavyWitness | |
| open scoped BigOperators | |
| open QuarterBalance (F2) | |
| open BinaryDualCoordinates | |
| open UniqueGamesTheorem.Foundations.Games | |
| noncomputable section | |
| variable {U V K I J : Type*} | |
| [AddCommGroup U] [Module F2 U] [Fintype U] | |
| [AddCommGroup V] [Module F2 V] | |
| [AddCommGroup K] [Module F2 K] | |
| [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J] | |
| def conditionalMatch (μ : FiniteDistribution U) (R : U →ₗ[F2] V) (target : V) | |
| (G : U → K) (T : U →ₗ[F2] K) (offset : K) : ℝ := by | |
| classical | |
| exact μ.expectation (fun x => if R x = target then | |
| (if G x = offset + T x then 1 else 0) else 0) / | |
| μ.expectation (fun x => if R x = target then 1 else 0) | |
| omit [DecidableEq I] [DecidableEq J] in | |
| theorem conditionalEquality_coordinates (μ : FiniteDistribution U) | |
| (b : Module.Basis I F2 V) (c : Module.Basis J F2 K) | |
| (R : U →ₗ[F2] V) (target : V) (G : U → K) | |
| (T : U →ₗ[F2] K) (offset : K) : | |
| OutputCharacters.conditionalEquality μ (equations b R) (coordinates b target) | |
| (fun x => coordinates c (G x)) (fun x => coordinates c (offset + T x)) = | |
| conditionalMatch μ R target G T offset := by | |
| classical | |
| simp only [OutputCharacters.conditionalEquality, OutputCharacters.sliceCorrelation, | |
| SmallBiasSlice.sliceNumerator, SmallBiasSlice.sliceMass, conditionalMatch, | |
| equations_eq_iff, (coordinates_injective c).eq_iff] | |
| def badMasks (c : Module.Basis J F2 K) (bad : Finset (Module.Dual F2 K)) : | |
| Finset (J → Bool) := | |
| bad.map (frequencyEquiv c).symm.toEmbedding | |
| omit [DecidableEq J] in | |
| @[simp] theorem mem_badMasks (c : Module.Basis J F2 K) | |
| (bad : Finset (Module.Dual F2 K)) (s : J → Bool) : | |
| s ∈ badMasks c bad ↔ frequency c s ∈ bad := by | |
| classical | |
| constructor | |
| · rintro h | |
| obtain ⟨f, hf, heq⟩ := Finset.mem_map.mp h | |
| have heq' : frequency c s = f := by | |
| change (frequencyEquiv c) s = f | |
| rw [← heq] | |
| exact (frequencyEquiv c).apply_symm_apply f | |
| simpa only [heq'] using hf | |
| · intro h | |
| apply Finset.mem_map.mpr | |
| refine ⟨frequency c s, h, ?_⟩ | |
| exact (frequencyEquiv c).symm_apply_apply s | |
| omit [DecidableEq J] in | |
| @[simp] theorem card_badMasks (c : Module.Basis J F2 K) | |
| (bad : Finset (Module.Dual F2 K)) : | |
| (badMasks c bad).card = bad.card := Finset.card_map _ | |
| theorem exists_heavy_in_dual_coset [Fintype (Module.Dual F2 U)] | |
| [Fintype (Module.Dual F2 K)] | |
| (μ : FiniteDistribution U) | |
| (b : Module.Basis I F2 V) (c : Module.Basis J F2 K) | |
| (R : U →ₗ[F2] V) (hR : Function.Surjective R) (target : V) | |
| (G : U → K) (T : U →ₗ[F2] K) (offset : K) | |
| (bad : Finset (Module.Dual F2 K)) (rho h0 biasBound : ℝ) | |
| (hrho : 0 < rho) (hh0 : 0 < h0) | |
| (hsize : h0 ≤ 1 / (Fintype.card (I → Bool) : ℝ)) | |
| (hb : 0 ≤ biasBound) (hbsmall : biasBound ≤ h0 / 2) | |
| (hbias : ∀ f : Module.Dual F2 U, f ≠ 0 → | |
| |μ.expectation (character f)| ≤ biasBound) | |
| (hbad : (bad.card : ℝ) / (Fintype.card (Module.Dual F2 K) : ℝ) < rho / 8) | |
| (hmatch : rho ≤ conditionalMatch μ R target G T offset) : | |
| ∃ σ : Module.Dual F2 K, σ ∉ bad ∧ | |
| ∃ ψ ∈ LinearMap.range R.dualMap, | |
| σ.comp T + ψ ∈ SmallBias.heavySet μ character | |
| (fun x => character σ (G x)) (rho * h0 / 4) := by | |
| classical | |
| have hcard : Fintype.card (J → Bool) = Fintype.card (Module.Dual F2 K) := | |
| Fintype.card_congr (frequencyEquiv c) | |
| have hbad' : ((badMasks c bad).card : ℝ) / | |
| (Fintype.card (J → Bool) : ℝ) < rho / 8 := by | |
| simpa only [card_badMasks, hcard] using hbad | |
| have hmatch' : rho ≤ OutputCharacters.conditionalEquality μ (equations b R) | |
| (coordinates b target) (fun x => coordinates c (G x)) | |
| (fun x => coordinates c (offset + T x)) := by | |
| rwa [conditionalEquality_coordinates] | |
| obtain ⟨s, hs, mask, hmask⟩ := | |
| OutputCharacters.equality_implies_affine_heavy_witness μ | |
| character character_zero character_add (equationRows b R) (equations b R) | |
| (character_equationRows b R) (equationRows_independent b R hR) | |
| (coordinates b target) (fun x => coordinates c (G x)) | |
| (fun x => coordinates c (offset + T x)) | |
| (fun s => (frequency c s).comp T) (fun s => character (frequency c s) offset) | |
| (fun s => abs_character _ _) (character_affine_target c T offset) | |
| (badMasks c bad) rho h0 biasBound hrho hh0 hsize hb hbsmall hbias hbad' hmatch' | |
| refine ⟨frequency c s, (mem_badMasks c bad s).not.mp hs, | |
| SmallBiasSlice.rowCombination (equationRows b R) mask, | |
| rowCombination_mem_dualRange b R mask, ?_⟩ | |
| simpa only [← character_frequency] using hmask | |
| end | |
| end PerfectCompleteness.AffineLinearHeavyWitness | |
| end | |
| end OAI | |