File size: 3,666 Bytes
760f90e | 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 | 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
|