File size: 5,025 Bytes
92416a2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | import OAI.Computability.UniqueGames.Quadratic.BlockKernelLemmas
import OAI.Computability.UniqueGames.Quadratic.GenericSeparationLemmas
namespace OAI
section
/-!
# Actual child restriction maps
A common-parent lift `g` gives a binary linear map from its logical character
space into the dual of each quadratic block. Its kernel is literal character
annihilation, so the trace calculation and the all-lifts genericity predicate
apply directly to this map.
-/
namespace UniqueGamesTheorem.Quadratic
noncomputable section
variable {F : Type*} [Field F] [Fintype F] [CharP F 2] [Algebra (ZMod 2) F]
omit [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] in
private theorem dot_add_first (x y z : Vec F) :
dot (x + y) z = dot x z + dot y z := by
simp only [dot, Pi.add_apply]
ring
/-- The actual trace character as a binary linear functional. -/
def blockCharacterLinear (g z : Vec F) :
(Vec F × Vec F) →ₗ[ZMod 2] ZMod 2 where
toFun := blockCharacter g z
map_add' := by
intro p q
simp only [blockCharacter, Prod.fst_add, Prod.snd_add, dot_add_right, map_add]
ring
map_smul' := by
intro c p
have hc : c = 0 ∨ c = 1 := by
fin_cases c
· exact Or.inl rfl
· exact Or.inr rfl
rcases hc with rfl | rfl <;> simp [blockCharacter]
/-- Restriction to one block, linear in the logical character `z`. -/
def blockRestriction (S : Submodule (ZMod 2) (Vec F))
(g : S →ₗ[ZMod 2] Vec F) (v : Vec F) :
S →ₗ[ZMod 2] ((U v) →ₗ[ZMod 2] ZMod 2) where
toFun z := (blockCharacterLinear (g z) z).comp (U v).subtype
map_add' := by
intro z w
ext p
simp only [LinearMap.comp_apply, blockCharacterLinear, LinearMap.coe_mk,
AddHom.coe_mk, LinearMap.add_apply, map_add, Submodule.coe_add,
blockCharacter, dot_add_first, map_add]
ring
map_smul' := by
intro c z
have hc : c = 0 ∨ c = 1 := by
fin_cases c
· exact Or.inl rfl
· exact Or.inr rfl
rcases hc with rfl | rfl <;> ext p <;>
simp [blockCharacterLinear, blockCharacter]
omit [Fintype F] in
@[simp] theorem blockRestriction_apply (S : Submodule (ZMod 2) (Vec F))
(g : S →ₗ[ZMod 2] Vec F) (v : Vec F) (z : S) (p : U v) :
blockRestriction S g v z p = blockCharacter (g z) z p := rfl
omit [Fintype F] in
/-- Equality to zero is exactly annihilation of the underlying block. -/
theorem blockRestriction_eq_zero_iff (S : Submodule (ZMod 2) (Vec F))
(g : S →ₗ[ZMod 2] Vec F) (v : Vec F) (z : S) :
blockRestriction S g v z = 0 ↔ BlockAnnihilates (g z) z v := by
constructor
· intro h p hp
exact LinearMap.congr_fun h ⟨p, hp⟩
· intro h
ext p
exact h p p.property
/-- The exact kernel formula for a nonzero logical character. -/
theorem mem_ker_blockRestriction_iff (S : Submodule (ZMod 2) (Vec F))
(g : S →ₗ[ZMod 2] Vec F) {v : Vec F} (hv : v ≠ 0)
{z : S} (hz : z ≠ 0) :
z ∈ (blockRestriction S g v).ker ↔
(z : Vec F) ∈ line v ∧
dot (g z) z = squareRoot (z.val 0 * z.val 1 * z.val 2) := by
have hz' : (z : Vec F) ≠ 0 := fun h => hz (Subtype.ext h)
rw [LinearMap.mem_ker, blockRestriction_eq_zero_iff, blockAnnihilates_iff hv hz']
/-- Nonproportionality of a generic space makes every actual block kernel
contain at most one nonzero character. -/
theorem blockRestriction_nonzero_kernel_unique
(S : Submodule (ZMod 2) (Vec F)) (g : S →ₗ[ZMod 2] Vec F)
{v : Vec F} (hv : v ≠ 0) (hS : IsGeneric S)
(z w : S) (hz : z ≠ 0) (hw : w ≠ 0)
(hgz : blockRestriction S g v z = 0)
(hgw : blockRestriction S g v w = 0) : z = w := by
have hzline := mem_line_of_blockAnnihilates hv
((blockRestriction_eq_zero_iff S g v z).mp hgz)
have hwline := mem_line_of_blockAnnihilates hv
((blockRestriction_eq_zero_iff S g v w).mp hgw)
obtain ⟨t, ht⟩ := (mem_line_iff v z).mp hzline
obtain ⟨s, hs⟩ := (mem_line_iff v w).mp hwline
have hsne : s ≠ 0 := by
intro hzero
apply hw
apply Subtype.ext
simpa [hzero] using hs.symm
apply hS.1 z w hz hw
refine ⟨t / s, ?_⟩
rw [← ht, ← hs, smul_smul, div_mul_cancel₀ _ hsne]
/-- Every actual child restriction map loses at most one binary dimension. -/
theorem finrank_ker_blockRestriction_le_one
(S : Submodule (ZMod 2) (Vec F)) (g : S →ₗ[ZMod 2] Vec F)
{v : Vec F} (hv : v ≠ 0) (hS : IsGeneric S) :
Module.finrank (ZMod 2) (blockRestriction S g v).ker ≤ 1 :=
finrank_ker_le_one_of_nonzero_unique (blockRestriction S g v)
(blockRestriction_nonzero_kernel_unique S g hv hS)
theorem finrank_blockRestriction_source_le_range_add_one
(S : Submodule (ZMod 2) (Vec F)) (g : S →ₗ[ZMod 2] Vec F)
{v : Vec F} (hv : v ≠ 0) (hS : IsGeneric S) :
Module.finrank (ZMod 2) S ≤
Module.finrank (ZMod 2) (blockRestriction S g v).range + 1 :=
finrank_source_le_range_add_one (blockRestriction S g v)
(blockRestriction_nonzero_kernel_unique S g hv hS)
end
end UniqueGamesTheorem.Quadratic
end
end OAI
|