Download data/lean/OAI/Computability/DirectedFeedback/Games/Genericity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 24.4 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/Genericity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/DirectedFeedback/Games/Genericity.lean
-
curl -L -o Genericity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/DirectedFeedback/Games/Genericity.lean
24.4 kB
| import Mathlib | |
| import OAI.Computability.DirectedFeedback.Games.BlockOrientations | |
| namespace OAI | |
| namespace DFVSGames.Quadratic | |
| open Module | |
| open scoped BigOperators | |
| noncomputable section | |
| section AlignmentEvents | |
| variable {R F V ΞΉ n : Type*} | |
| variable [Field R] [Field F] [Algebra R F] | |
| variable [AddCommGroup V] [Module R V] | |
| variable [Fintype V] [Fintype ΞΉ] [Fintype n] | |
| def alignmentEvent (z : V β n β F) (g : V ββ[R] (n β F)) (c : V β F) : | |
| Finset V := by | |
| classical | |
| exact Finset.univ.filter (fun v => v β 0 β§ (β i, z v i * g v i) = c v) | |
| theorem all_lifts_bound_iff_subsets (b : Basis ΞΉ R V) (z : V β n β F) | |
| (c : V β F) (k : β) : | |
| (β g : V ββ[R] (n β F), (alignmentEvent z g c).card β€ k) β | |
| β E : Finset V, 0 β E β E.card = k + 1 β | |
| (fun e : E => c e) β | |
| LinearMap.range (alignmentMatrix b (fun e : E => (e : V)) z).mulVecLin := by | |
| classical | |
| constructor | |
| Β· intro h E hzero hcard hmem | |
| obtain β¨g, hgβ© := (exists_lift_alignment_iff_mem_range b | |
| (fun e : E => (e : V)) z (fun e : E => c e)).mpr hmem | |
| have hsubset : E β alignmentEvent z g c := by | |
| intro v hv | |
| refine Finset.mem_filter.mpr β¨Finset.mem_univ _, ?_, hg β¨v, hvβ©β© | |
| intro hvzero | |
| exact hzero (hvzero βΈ hv) | |
| have hle := (Finset.card_le_card hsubset).trans (h g) | |
| omega | |
| Β· intro h g | |
| by_contra hbad | |
| have hlarge : k + 1 β€ (alignmentEvent z g c).card := by omega | |
| obtain β¨E, hsub, hcardβ© := Finset.exists_subset_card_eq hlarge | |
| have hzero : (0 : V) β E := by | |
| intro hz | |
| have hh := (Finset.mem_filter.mp (hsub hz)).2.1 | |
| exact hh rfl | |
| apply h E hzero hcard | |
| apply (exists_lift_alignment_iff_mem_range b | |
| (fun e : E => (e : V)) z (fun e : E => c e)).mp | |
| refine β¨g, ?_β© | |
| intro e | |
| exact (Finset.mem_filter.mp (hsub e.property)).2.2 | |
| theorem all_lifts_bound_of_card_le (z : V β n β F) (c : V β F) (k : β) | |
| (hcard : Fintype.card V - 1 β€ k) (g : V ββ[R] (n β F)) : | |
| (alignmentEvent z g c).card β€ k := by | |
| classical | |
| have hsub : alignmentEvent z g c β Finset.univ.erase (0 : V) := by | |
| intro v hv | |
| exact Finset.mem_erase.mpr β¨(Finset.mem_filter.mp hv).2.1, Finset.mem_univ _β© | |
| have hle := Finset.card_le_card hsub | |
| simpa using hle.trans (by simpa using hcard) | |
| end AlignmentEvents | |
| variable {F : Type*} [Field F] [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] | |
| def alignmentRightHandSide (z : Fin 3 β F) : F := squareRoot (z 0 * z 1 * z 2) | |
| def IsGeneric (S : Submodule (ZMod 2) (Fin 3 β F)) : Prop := by | |
| classical | |
| exact | |
| (β z w : S, z β 0 β w β 0 β | |
| (β t : F, (z : Fin 3 β F) = t β’ (w : Fin 3 β F)) β z = w) β§ | |
| (β g : S ββ[ZMod 2] (Fin 3 β F), | |
| (alignmentEvent (R := ZMod 2) (fun z : S => (z : Fin 3 β F)) g | |
| (fun z : S => alignmentRightHandSide (z : Fin 3 β F))).card β€ | |
| 3 * Module.finrank (ZMod 2) S) | |
| end | |
| end DFVSGames.Quadratic | |
| namespace DFVSGames.Quadratic | |
| noncomputable section | |
| variable {R V W I : Type*} [Field R] | |
| variable [AddCommGroup V] [Module R V] | |
| variable [AddCommGroup W] [Module R W] | |
| theorem finrank_le_one_of_nonzero_unique | |
| (h : β v w : V, v β 0 β w β 0 β v = w) : | |
| Module.finrank R V β€ 1 := by | |
| classical | |
| by_cases hex : β v : V, v β 0 | |
| Β· obtain β¨v, hvβ© := hex | |
| apply finrank_le_one v | |
| intro w | |
| by_cases hw : w = 0 | |
| Β· exact β¨0, by simp [hw]β© | |
| Β· exact β¨1, by simpa using h v w hv hwβ© | |
| Β· apply finrank_le_one (0 : V) | |
| intro w | |
| have hw : w = 0 := by | |
| by_contra hw | |
| exact hex β¨w, hwβ© | |
| exact β¨0, by simp [hw]β© | |
| theorem finrank_ker_le_one_of_nonzero_unique (f : V ββ[R] W) | |
| (h : β v w : V, v β 0 β w β 0 β f v = 0 β f w = 0 β v = w) : | |
| Module.finrank R f.ker β€ 1 := by | |
| apply finrank_le_one_of_nonzero_unique | |
| intro v w hv hw | |
| apply Subtype.ext | |
| apply h v w | |
| Β· intro hv0 | |
| apply hv | |
| exact Subtype.ext hv0 | |
| Β· intro hw0 | |
| apply hw | |
| exact Subtype.ext hw0 | |
| Β· exact v.property | |
| Β· exact w.property | |
| theorem finrank_source_le_range_add_one [FiniteDimensional R V] | |
| (f : V ββ[R] W) | |
| (h : β v w : V, v β 0 β w β 0 β f v = 0 β f w = 0 β v = w) : | |
| Module.finrank R V β€ Module.finrank R f.range + 1 := by | |
| have hk := finrank_ker_le_one_of_nonzero_unique f h | |
| have hr := f.finrank_range_add_finrank_ker | |
| omega | |
| variable [Fintype V] [Fintype I] [DecidableEq I] | |
| def lossIndices (f : I β V ββ[R] W) : Finset I := by | |
| classical | |
| exact Finset.univ.filter (fun i => β v : V, v β 0 β§ f i v = 0) | |
| def alignedCharacters (aligned : V β Prop) : Finset V := by | |
| classical | |
| exact Finset.univ.filter (fun v => v β 0 β§ aligned v) | |
| theorem lossIndices_subset_image (f : I β V ββ[R] W) | |
| (aligned : V β Prop) (lineOf : V β I) | |
| (hkernel : β i v, v β 0 β f i v = 0 β aligned v β§ lineOf v = i) : | |
| lossIndices f β (alignedCharacters aligned).image lineOf := by | |
| classical | |
| intro i hi | |
| obtain β¨v, hv, hfvβ© := (Finset.mem_filter.mp hi).2 | |
| obtain β¨halign, hlineβ© := hkernel i v hv hfv | |
| apply Finset.mem_image.mpr | |
| exact β¨v, Finset.mem_filter.mpr β¨Finset.mem_univ _, hv, halignβ©, hlineβ© | |
| theorem card_lossIndices_le_card_aligned (f : I β V ββ[R] W) | |
| (aligned : V β Prop) (lineOf : V β I) | |
| (hkernel : β i v, v β 0 β f i v = 0 β aligned v β§ lineOf v = i) : | |
| (lossIndices f).card β€ (alignedCharacters aligned).card := by | |
| classical | |
| exact (Finset.card_le_card (lossIndices_subset_image f aligned lineOf hkernel)).trans | |
| (Finset.card_image_le (s := alignedCharacters aligned) (f := lineOf)) | |
| theorem card_lossIndices_le (f : I β V ββ[R] W) | |
| (aligned : V β Prop) (lineOf : V β I) (r : β) | |
| (hkernel : β i v, v β 0 β f i v = 0 β aligned v β§ lineOf v = i) | |
| (hgeneric : (alignedCharacters aligned).card β€ 3 * r) : | |
| (lossIndices f).card β€ 3 * r := | |
| (card_lossIndices_le_card_aligned f aligned lineOf hkernel).trans hgeneric | |
| theorem card_lossIndices_le_nonzero (f : I β V ββ[R] W) | |
| (lineOf : V β I) | |
| (hkernel : β i v, v β 0 β f i v = 0 β lineOf v = i) : | |
| (lossIndices f).card β€ Fintype.card V - 1 := by | |
| classical | |
| have h := card_lossIndices_le_card_aligned f (fun _ => True) lineOf | |
| (fun i v hv hfv => β¨trivial, hkernel i v hv hfvβ©) | |
| simpa [alignedCharacters, Finset.filter_ne'] using h | |
| end | |
| end DFVSGames.Quadratic | |
| namespace DFVSGames.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_inline_BlockRestriction (x y z : Vec F) : | |
| dot (x + y) z = dot x z + dot y z := by | |
| simp only [dot, Pi.add_apply] | |
| ring | |
| 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] | |
| 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_inline_BlockRestriction, 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 | |
| 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 | |
| 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'] | |
| 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] | |
| 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 DFVSGames.Quadratic | |
| namespace DFVSGames.Quadratic | |
| noncomputable section | |
| variable {F B : Type*} [Field F] [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] | |
| variable [AddCommGroup B] [Module (ZMod 2) B] | |
| def orientedBlockRestriction (S : Submodule (ZMod 2) (Vec F)) | |
| (g : S ββ[ZMod 2] Vec F) (v : Vec F) (J : B ββ[ZMod 2] U v) : | |
| S ββ[ZMod 2] (B ββ[ZMod 2] ZMod 2) := | |
| J.dualMap.toLinearMap.comp (blockRestriction S g v) | |
| omit [Fintype F] in | |
| @[simp] theorem orientedBlockRestriction_apply | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (v : Vec F) (J : B ββ[ZMod 2] U v) (z : S) (b : B) : | |
| orientedBlockRestriction S g v J z b = blockCharacter (g z) z (J b) := rfl | |
| omit [Fintype F] in | |
| theorem orientedBlockRestriction_eq_zero_iff | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (v : Vec F) (J : B ββ[ZMod 2] U v) (z : S) : | |
| orientedBlockRestriction S g v J z = 0 β blockRestriction S g v z = 0 := by | |
| change J.dualMap (blockRestriction S g v z) = 0 β _ | |
| constructor | |
| Β· intro h | |
| apply J.dualMap.injective | |
| simpa only [map_zero] using h | |
| Β· intro h | |
| rw [h, map_zero] | |
| omit [Fintype F] in | |
| theorem ker_orientedBlockRestriction | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (v : Vec F) (J : B ββ[ZMod 2] U v) : | |
| (orientedBlockRestriction S g v J).ker = (blockRestriction S g v).ker := by | |
| ext z | |
| simp only [LinearMap.mem_ker, orientedBlockRestriction_eq_zero_iff] | |
| omit [Fintype F] in | |
| theorem ker_orientedBlockRestriction_independent | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (v : Vec F) (J J' : B ββ[ZMod 2] U v) : | |
| (orientedBlockRestriction S g v J).ker = | |
| (orientedBlockRestriction S g v J').ker := by | |
| rw [ker_orientedBlockRestriction, ker_orientedBlockRestriction] | |
| theorem mem_ker_orientedBlockRestriction_iff | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| {v : Vec F} (hv : v β 0) (J : B ββ[ZMod 2] U v) | |
| {z : S} (hz : z β 0) : | |
| z β (orientedBlockRestriction S g v J).ker β | |
| (z : Vec F) β line v β§ | |
| dot (g z) z = squareRoot (z.val 0 * z.val 1 * z.val 2) := by | |
| rw [ker_orientedBlockRestriction] | |
| exact mem_ker_blockRestriction_iff S g hv hz | |
| theorem finrank_ker_orientedBlockRestriction_le_one | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| {v : Vec F} (hv : v β 0) (hS : IsGeneric S) (J : B ββ[ZMod 2] U v) : | |
| Module.finrank (ZMod 2) (orientedBlockRestriction S g v J).ker β€ 1 := by | |
| rw [ker_orientedBlockRestriction] | |
| exact finrank_ker_blockRestriction_le_one S g hv hS | |
| end | |
| end DFVSGames.Quadratic | |
| namespace DFVSGames.Gadget.BlockDescent | |
| open Quadratic OrientedBlockKernel | |
| noncomputable section | |
| variable {F : Type*} [Field F] [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] | |
| abbrev BinaryDual := Vec F ββ[ZMod 2] ZMod 2 | |
| def traceSpace (S : Submodule (ZMod 2) (BinaryDual (F := F))) : | |
| Submodule (ZMod 2) (Vec F) := S.map traceDualEquiv.symm.toLinearMap | |
| def traceSpaceEquiv (S : Submodule (ZMod 2) (BinaryDual (F := F))) : | |
| S ββ[ZMod 2] traceSpace S := | |
| Submodule.equivMapOfInjective traceDualEquiv.symm.toLinearMap | |
| traceDualEquiv.symm.injective S | |
| omit [CharP F 2] in | |
| theorem traceSpace_finrank (S : Submodule (ZMod 2) (BinaryDual (F := F))) : | |
| Module.finrank (ZMod 2) (traceSpace S) = Module.finrank (ZMod 2) S := | |
| (traceSpaceEquiv S).finrank_eq.symm | |
| omit [CharP F 2] in | |
| @[simp] theorem traceSpaceEquiv_apply_val | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) (z : S) : | |
| (traceSpaceEquiv S z).val = traceDualEquiv.symm z.val := rfl | |
| omit [CharP F 2] in | |
| theorem traceSpaceEquiv_symm_val | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) (z : traceSpace S) : | |
| ((traceSpaceEquiv S).symm z).val = traceDualEquiv z.val := by | |
| apply traceDualEquiv.symm.injective | |
| have h := congrArg Subtype.val ((traceSpaceEquiv S).apply_symm_apply z) | |
| simpa only [traceSpaceEquiv_apply_val, LinearEquiv.symm_apply_apply] using h | |
| def traceLift (S : Submodule (ZMod 2) (BinaryDual (F := F))) | |
| (Ξ³ : S ββ[ZMod 2] BinaryDual (F := F)) : traceSpace S ββ[ZMod 2] Vec F := | |
| representTraceFamily (Ξ³.comp (traceSpaceEquiv S).symm.toLinearMap) | |
| theorem childCharacter_comp_traceSpaceEquiv | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) | |
| (Ξ³ : S ββ[ZMod 2] BinaryDual (F := F)) (i : BlockOrientationIndex F) : | |
| (childCharacter orientedBlockLinear Ξ³ i).comp (traceSpaceEquiv S).symm.toLinearMap = | |
| orientedBlockRestriction (traceSpace S) (traceLift S Ξ³) (lineGenerator i.1) i.2 := by | |
| apply LinearMap.ext | |
| intro z | |
| apply LinearMap.ext | |
| intro b | |
| change Ξ³ ((traceSpaceEquiv S).symm z) (i.2 b).val.1 + | |
| ((traceSpaceEquiv S).symm z).val (i.2 b).val.2 = | |
| traceBinary (dot (traceLift S Ξ³ z) (i.2 b).val.1 + dot z.val (i.2 b).val.2) | |
| rw [map_add] | |
| rw [show traceBinary (dot (traceLift S Ξ³ z) (i.2 b).val.1) = | |
| Ξ³ ((traceSpaceEquiv S).symm z) (i.2 b).val.1 from | |
| representTraceFamily_spec (Ξ³.comp (traceSpaceEquiv S).symm.toLinearMap) z _] | |
| rw [traceSpaceEquiv_symm_val, traceDualEquiv_apply] | |
| theorem childCharacter_range_eq | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) | |
| (Ξ³ : S ββ[ZMod 2] BinaryDual (F := F)) (i : BlockOrientationIndex F) : | |
| (childCharacter orientedBlockLinear Ξ³ i).range = | |
| (orientedBlockRestriction (traceSpace S) (traceLift S Ξ³) | |
| (lineGenerator i.1) i.2).range := by | |
| rw [β childCharacter_comp_traceSpaceEquiv] | |
| exact (LinearMap.range_comp_of_range_eq_top _ (LinearEquiv.range _)).symm | |
| theorem childCharacter_range_eq_dual_pullback | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) | |
| (Ξ³ : S ββ[ZMod 2] BinaryDual (F := F)) (i : BlockOrientationIndex F) : | |
| (childCharacter orientedBlockLinear Ξ³ i).range = | |
| ((blockRestriction (traceSpace S) (traceLift S Ξ³) (lineGenerator i.1)).range).map | |
| i.2.dualMap.toLinearMap := by | |
| rw [childCharacter_range_eq] | |
| exact LinearMap.range_comp _ _ | |
| theorem childCharacter_rank_independent | |
| (S : Submodule (ZMod 2) (BinaryDual (F := F))) | |
| (Ξ³ : S ββ[ZMod 2] BinaryDual (F := F)) (A : FieldLine F) | |
| (J J' : BlockOrientation A) : | |
| Module.finrank (ZMod 2) (childCharacter orientedBlockLinear Ξ³ β¨A, Jβ©).range = | |
| Module.finrank (ZMod 2) (childCharacter orientedBlockLinear Ξ³ β¨A, J'β©).range := by | |
| rw [childCharacter_range_eq_dual_pullback, childCharacter_range_eq_dual_pullback] | |
| rw [J.dualMap.finrank_map_eq, J'.dualMap.finrank_map_eq] | |
| end | |
| end DFVSGames.Gadget.BlockDescent | |
| namespace DFVSGames.Gadget.Descent | |
| universe u v | |
| variable {k : Type u} {B I X : Type v} [Field k] | |
| variable [AddCommGroup B] [Module k B] [Finite B] [FiniteDimensional k B] | |
| variable [Fintype I] [DecidableEq I] [Nonempty I] | |
| variable [AddCommGroup X] [Module k X] | |
| variable (J : I β B ββ[k] X Γ B) (hJ : Function.Surjective (aggregate J)) (Q : X β B) | |
| noncomputable def commonGamma (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) : S ββ[k] (X ββ[k] k) := | |
| Classical.choose (exists_common_child_character J hJ Q s S L) | |
| omit [FiniteDimensional k B] in | |
| omit [Finite B] in | |
| theorem commonGamma_spec (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) (z : S) (h : s.Shift) : | |
| L.family z (Pi.single i (s.embed h)) = | |
| childCharacter J (commonGamma J hJ Q s S L) i z (s.logical h) := | |
| Classical.choose_spec (exists_common_child_character J hJ Q s S L) i z h | |
| noncomputable def childDomain (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) : Submodule k (B ββ[k] k) := | |
| LinearMap.range (childCharacter J (commonGamma J hJ Q s S L) i) | |
| noncomputable def childLift (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) : | |
| Lift s (childDomain J hJ Q s S L i) := | |
| Classical.choose (exists_descendant_lift J hJ Q s S L | |
| (commonGamma J hJ Q s S L) (commonGamma_spec J hJ Q s S L) i) | |
| noncomputable def childSection (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) : | |
| childDomain J hJ Q s S L i ββ[k] S := | |
| Classical.choose (Classical.choose_spec (exists_descendant_lift J hJ Q s S L | |
| (commonGamma J hJ Q s S L) (commonGamma_spec J hJ Q s S L) i)) | |
| omit [FiniteDimensional k B] [Finite B] in | |
| theorem childSection_rightInverse (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) | |
| (z : childDomain J hJ Q s S L i) : | |
| childCharacter J (commonGamma J hJ Q s S L) i | |
| (childSection J hJ Q s S L i z) = z.val := | |
| (Classical.choose_spec (Classical.choose_spec (exists_descendant_lift J hJ Q s S L | |
| (commonGamma J hJ Q s S L) (commonGamma_spec J hJ Q s S L) i))).1 z | |
| omit [FiniteDimensional k B] [Finite B] in | |
| theorem childLift_spec (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) | |
| (z : childDomain J hJ Q s S L i) (p : s.Input) : | |
| (childLift J hJ Q s S L i).family z p = | |
| L.family (childSection J hJ Q s S L i z) (Pi.single i p) := | |
| (Classical.choose_spec (Classical.choose_spec (exists_descendant_lift J hJ Q s S L | |
| (commonGamma J hJ Q s S L) (commonGamma_spec J hJ Q s S L) i))).2 z p | |
| omit [FiniteDimensional k B] [Finite B] in | |
| theorem child_detection (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) (n : s.Noise) | |
| (hdetect : β z, (childLift J hJ Q s S L i).family z (s.noise n) β 0) : | |
| β z, L.family z ((Stage.next J hJ Q s).noise (i, n)) β 0 := | |
| descendant_detection_implies_parent J hJ Q s S L _ _ i | |
| (childLift_spec J hJ Q s S L i) n hdetect | |
| omit [Finite B] in | |
| theorem child_rank_le (s : Stage k B) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.next J hJ Q s) S) (i : I) : | |
| Module.finrank k (childDomain J hJ Q s S L i) β€ Module.finrank k S := | |
| LinearMap.finrank_range_le _ | |
| noncomputable def leafRank | |
| (J : I β B ββ[k] X Γ B) (hJ : Function.Surjective (aggregate J)) (Q : X β B) : | |
| (n : β) β (S : Submodule k (B ββ[k] k)) β | |
| Lift (Stage.iterate J hJ Q n) S β (Stage.iterate J hJ Q n).Noise β β | |
| | 0, S, _, _ => Module.finrank k S | |
| | n + 1, S, L, t => leafRank J hJ Q n | |
| (childDomain J hJ Q (Stage.iterate J hJ Q n) S L t.1) | |
| (childLift J hJ Q (Stage.iterate J hJ Q n) S L t.1) t.2 | |
| theorem leafRank_le (n : β) (S : Submodule k (B ββ[k] k)) | |
| (L : Lift (Stage.iterate J hJ Q n) S) (t : (Stage.iterate J hJ Q n).Noise) : | |
| leafRank J hJ Q n S L t β€ Module.finrank k S := by | |
| induction n generalizing S with | |
| | zero => exact le_rfl | |
| | succ n ih => | |
| exact (ih _ _ _).trans (child_rank_le J hJ Q _ S L t.1) | |
| end DFVSGames.Gadget.Descent | |
| namespace DFVSGames.Quadratic | |
| noncomputable section | |
| variable {F : Type*} [Field F] [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] | |
| local instance : Fintype (FieldLine F) := Fintype.ofFinite _ | |
| local instance (S : Submodule (ZMod 2) (Vec F)) : Fintype S := by | |
| classical | |
| exact Subtype.fintype (Membership.mem S) | |
| def characterFieldLine (Aβ : FieldLine F) (z : Vec F) : FieldLine F := by | |
| classical | |
| exact if hz : z = 0 then Aβ else Projectivization.mk F z hz | |
| omit [Fintype F] [CharP F 2] [Algebra (ZMod 2) F] in | |
| theorem characterFieldLine_eq_of_mem {Aβ A : FieldLine F} {z : Vec F} | |
| (hz : z β 0) (hm : z β line (lineGenerator A)) : | |
| characterFieldLine Aβ z = A := by | |
| classical | |
| rw [characterFieldLine, dite_eq_right hz, β Projectivization.mk_rep A] | |
| apply (Projectivization.mk_eq_mk_iff' F _ _ _ _).mpr | |
| exact (mem_line_iff (lineGenerator A) z).mp hm | |
| def fieldLineRestrictions (S : Submodule (ZMod 2) (Vec F)) | |
| (g : S ββ[ZMod 2] Vec F) (J : β A : FieldLine F, BlockOrientation A) : | |
| FieldLine F β S ββ[ZMod 2] (Vec F ββ[ZMod 2] ZMod 2) := | |
| fun A => orientedBlockRestriction S g (lineGenerator A) (J A) | |
| theorem alignedCharacters_eq_alignmentEvent | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) : | |
| alignedCharacters (fun z : S => | |
| dot (g z) z = squareRoot (z.val 0 * z.val 1 * z.val 2)) = | |
| alignmentEvent (fun z : S => (z : Vec F)) g | |
| (fun z : S => alignmentRightHandSide (z : Vec F)) := by | |
| classical | |
| ext z | |
| simp [alignedCharacters, alignmentEvent, alignmentRightHandSide, | |
| Fin.sum_univ_three, dot, mul_comm] | |
| theorem card_loss_fieldLineRestrictions_le | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (J : β A : FieldLine F, BlockOrientation A) (hS : IsGeneric S) | |
| (Aβ : FieldLine F) : | |
| (lossIndices (fieldLineRestrictions S g J)).card β€ | |
| 3 * Module.finrank (ZMod 2) S := by | |
| classical | |
| apply card_lossIndices_le (fieldLineRestrictions S g J) | |
| (fun z : S => dot (g z) z = squareRoot (z.val 0 * z.val 1 * z.val 2)) | |
| (fun z : S => characterFieldLine Aβ (z : Vec F)) (Module.finrank (ZMod 2) S) | |
| Β· intro A z hz hzero | |
| have hk := (mem_ker_orientedBlockRestriction_iff S g | |
| (lineGenerator_ne_zero A) (J A) hz).mp hzero | |
| refine β¨hk.2, characterFieldLine_eq_of_mem ?_ hk.1β© | |
| exact fun h => hz (Subtype.ext h) | |
| Β· rw [alignedCharacters_eq_alignmentEvent] | |
| exact hS.2 g | |
| theorem card_loss_fieldLineRestrictions_le_three_rank | |
| (S : Submodule (ZMod 2) (Vec F)) (g : S ββ[ZMod 2] Vec F) | |
| (J : β A : FieldLine F, BlockOrientation A) (hS : IsGeneric S) : | |
| (lossIndices (fieldLineRestrictions S g J)).card β€ | |
| 3 * Module.finrank (ZMod 2) S := by | |
| let Aβ : FieldLine F := Projectivization.mk F (fun _ : Fin 3 => (1 : F)) (by | |
| intro h | |
| have h0 := congrFun h 0 | |
| exact one_ne_zero h0) | |
| exact card_loss_fieldLineRestrictions_le S g J hS Aβ | |
| end | |
| end DFVSGames.Quadratic | |
| end OAI | |