| import Mathlib.LinearAlgebra.Basis.Defs |
| import Mathlib.LinearAlgebra.Matrix.Rank |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace UniqueGamesTheorem.Quadratic |
|
|
| open Module |
| open scoped BigOperators Matrix |
|
|
| noncomputable section |
|
|
| variable {R F V ι n E : Type*} |
| variable [Field R] [Field F] [Algebra R F] |
| variable [AddCommGroup V] [Module R V] |
| variable [Fintype ι] [Fintype n] |
|
|
| / |
| The input set is represented by any map `point : E → V`; no injectivity is |
| needed for the exact algebraic equivalence. -/ |
| def alignmentMatrix (b : Basis ι R V) (point : E → V) (z : V → n → F) : |
| Matrix E (n × ι) F := |
| fun e ij => algebraMap R F (b.repr (point e) ij.2) * z (point e) ij.1 |
|
|
| / |
| column combination. The identity holds for every lift, without selecting |
| one in advance of the parametrization. -/ |
| theorem dot_lift_eq_alignment_mulVec (b : Basis ι R V) |
| (point : E → V) (z : V → n → F) (g : V →ₗ[R] (n → F)) (e : E) : |
| (∑ i, z (point e) i * g (point e) i) = |
| (alignmentMatrix b point z *ᵥ (fun ij => g (b ij.2) ij.1)) e := by |
| have hg : g (point e) = ∑ j, b.repr (point e) j • g (b j) := by |
| calc |
| g (point e) = g (∑ j, b.repr (point e) j • b j) := |
| congrArg g (b.sum_repr (point e)).symm |
| _ = ∑ j, b.repr (point e) j • g (b j) := by simp only [map_sum, map_smul] |
| rw [hg] |
| simp only [Matrix.mulVec, dotProduct, alignmentMatrix, |
| Finset.sum_apply, Algebra.smul_def, Pi.mul_apply, |
| Pi.algebraMap_apply, Finset.mul_sum, |
| Fintype.sum_prod_type] |
| apply Finset.sum_congr rfl |
| intro i hi |
| apply Finset.sum_congr rfl |
| intro j hj |
| ring |
|
|
| / |
| column-membership event. In particular there is no field-size-dependent |
| union bound over the possible lifts. -/ |
| theorem exists_lift_alignment_iff_mem_range (b : Basis ι R V) |
| (point : E → V) (z : V → n → F) (c : E → F) : |
| (∃ g : V →ₗ[R] (n → F), ∀ e, |
| (∑ i, z (point e) i * g (point e) i) = c e) ↔ |
| c ∈ LinearMap.range (alignmentMatrix b point z).mulVecLin := by |
| constructor |
| · rintro ⟨g, hg⟩ |
| refine ⟨fun ij => g (b ij.2) ij.1, ?_⟩ |
| ext e |
| change (alignmentMatrix b point z *ᵥ (fun ij => g (b ij.2) ij.1)) e = c e |
| rw [← dot_lift_eq_alignment_mulVec] |
| exact hg e |
| · rintro ⟨u, hu⟩ |
| let g : V →ₗ[R] (n → F) := b.constr R (fun j i => u (i, j)) |
| refine ⟨g, ?_⟩ |
| intro e |
| rw [dot_lift_eq_alignment_mulVec b point z g e] |
| have hg : (fun ij : n × ι => g (b ij.2) ij.1) = u := by |
| funext ij |
| exact congrFun (b.constr_basis R (fun j i => u (i, j)) ij.2) ij.1 |
| rw [hg] |
| exact congrFun hu e |
|
|
| / |
| For three field coordinates and a binary basis of size `r`, this is `3r`. -/ |
| theorem finrank_alignment_range_le (b : Basis ι R V) |
| (point : E → V) (z : V → n → F) [Fintype E] : |
| Module.finrank F (LinearMap.range (alignmentMatrix b point z).mulVecLin) ≤ |
| Fintype.card n * Fintype.card ι := by |
| simpa only [Module.finrank_fintype_fun_eq_card, Fintype.card_prod] using |
| (LinearMap.finrank_range_le (alignmentMatrix b point z).mulVecLin) |
|
|
| end |
|
|
| end UniqueGamesTheorem.Quadratic |
|
|
| end |
|
|
| end OAI |
|
|
