| import Mathlib.Data.List.OfFn |
| import OAI.Computability.UniqueGames.Games.SubdivisionTarget |
| import OAI.Computability.UniqueGames.Reduction.GameEncodingSizeLemmas |
|
|
| namespace OAI |
|
|
| section |
|
|
| /-! |
| Exact whole-output serialization of four-edge subdivision. The input occurrence |
| at index `e` produces the four adjacent rows at `4e,4e+1,4e+2,4e+3`. |
| The bit formula uses the same complete row output as the checked machine phase. |
| -/ |
|
|
| namespace UniqueGamesTheorem.Explicit.SubdivisionEncoding |
|
|
| open UniqueGamesTheorem.Foundations Target Complexity |
| open SubdivisionTarget |
|
|
| theorem subdivide_constraints {q : Nat} (H : Instance q) : |
| (subdivide H).constraints = |
| (List.ofFn (fun e : Fin H.constraints.length => |
| MachineSubdivisionRows.rows (vertexFields H e) |
| H.constraints[e].permutation)).flatten := by |
| change List.ofFn _ = _ |
| rw [List.ofFn_mul'] |
| congr 1 |
| apply congrArg List.ofFn |
| funext e |
| rw [← rows_eq H e] |
| apply congrArg List.ofFn |
| funext i |
| congr 1 |
| apply Fin.ext |
| simp only [numericEdgeEquiv_symm_val] |
|
|
| theorem subdivide_constraints_flatMap {q : Nat} (H : Instance q) : |
| (subdivide H).constraints = (List.finRange H.constraints.length).flatMap |
| (fun e => MachineSubdivisionRows.rows (vertexFields H e) |
| H.constraints[e].permutation) := by |
| rw [subdivide_constraints, List.ofFn_eq_map] |
| rfl |
|
|
| /-- Header and complete row words, in the original input occurrence order. -/ |
| theorem subdivide_gameWords {q : Nat} (H : Instance q) : |
| gameWords (subdivide H) = |
| [H.vertices + 3 * H.constraints.length, q, 4 * H.constraints.length] ++ |
| (List.finRange H.constraints.length).flatMap (fun e => |
| (MachineSubdivisionRows.rows (vertexFields H e) |
| H.constraints[e].permutation).flatMap constraintWords) := by |
| change [H.vertices + 3 * H.constraints.length, q, (subdivide H).constraints.length] ++ |
| (subdivide H).constraints.flatMap |
| (@constraintWords (H.vertices + 3 * H.constraints.length) q) = _ |
| rw [subdivide_length, subdivide_constraints_flatMap, List.flatMap_assoc] |
|
|
| private theorem encodeWords_flatMap {X : Type*} (xs : List X) (f : X → List Nat) : |
| encodeWords (xs.flatMap f) = xs.flatMap (fun x => encodeWords (f x)) := by |
| induction xs with |
| | nil => rfl |
| | cons x xs ih => simp [ih] |
|
|
| /-- Exact output bytes for the whole controller to emit: one header followed by |
| the verified four-row phase once per original occurrence. -/ |
| theorem subdivide_gameBits {q : Nat} (H : Instance q) : |
| gameBits (subdivide H) = |
| encodeWords [H.vertices + 3 * H.constraints.length, q, 4 * H.constraints.length] ++ |
| (List.finRange H.constraints.length).flatMap (fun e => |
| MachineSubdivisionRows.rowBits (vertexFields H e) H.constraints[e].permutation) := by |
| rw [gameBits, subdivide_gameWords, encodeWords_append, encodeWords_flatMap] |
| rfl |
|
|
| theorem subdivide_gameWords_length {q : Nat} (H : Instance q) : |
| (gameWords (subdivide H)).length = 3 + 4 * H.constraints.length * (q + 2) := by |
| rw [gameWords_length, subdivide_length] |
|
|
| /-- A polynomial output-size bound in the numeric parameters `n,Q,q`; the |
| controller separately supplies its raw-input execution-time bound. -/ |
| theorem subdivide_gameBits_length_le {q : Nat} (H : Instance q) : |
| (gameBits (subdivide H)).length ≤ |
| H.vertices + 3 * H.constraints.length + q + 4 * H.constraints.length + 3 + |
| (4 * H.constraints.length) * |
| (2 * (H.vertices + 3 * H.constraints.length) + q * (q + 1)) := by |
| have h := UniqueGamesTheorem.Reduction.GameEncodingSize.gameBits_length_le (subdivide H) |
| rw [subdivide_length] at h |
| exact h |
|
|
| end UniqueGamesTheorem.Explicit.SubdivisionEncoding |
|
|
| end |
|
|
| end OAI |
|
|
