File size: 5,405 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 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 | import OAI.Computability.UniqueGames.Machines.MachineSubroutineLemmas
import OAI.Computability.UniqueGames.Machines.MachineUniformCopyOrder
import OAI.Computability.UniqueGames.Machines.MachineUniformRounding
import OAI.Computability.UniqueGames.Reduction.RealTargetLemmas
namespace OAI
namespace UniqueGamesTheorem.Explicit.UniformTarget
open UniqueGamesTheorem.Foundations Target Complexity
open UniqueGamesTheorem.Integration
open MachineUniformCopyOrder
theorem copy_length {α : Type*} (C : Nat) (xs : List α) :
(copyMajor C xs).length = C * xs.length := by
induction C with
| zero => simp [copyMajor]
| succ C ih =>
simp [copyMajor, List.replicate_succ, List.flatten_cons, Nat.add_mul,
Nat.add_comm]
def construct {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) : Instance q where
vertices := g.vertices
constraints := copyMajor C g.constraints
nonempty := by
apply List.length_pos_iff.mp
rw [copy_length]
exact Nat.mul_pos hC g.constraintCount_positive
@[simp] theorem vertices {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) :
(construct C hC g).vertices = g.vertices := rfl
@[simp] theorem edge_count {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) :
(construct C hC g).constraints.length = C * g.constraints.length :=
copy_length C g.constraints
private theorem count_append {n q : Nat} (a : Fin n → Fin q)
(xs ys : List (Constraint n q)) :
countSatisfied a (xs ++ ys) = countSatisfied a xs + countSatisfied a ys := by
simp [GapSemantics.countSatisfied_eq_sum]
theorem count_copies {n q : Nat} (C : Nat) (es : List (Constraint n q))
(a : Fin n → Fin q) :
countSatisfied a (copyMajor C es) = C * countSatisfied a es := by
induction C with
| zero => simp [copyMajor, countSatisfied]
| succ C ih =>
change countSatisfied a (es ++ copyMajor C es) = _
rw [count_append, ih, Nat.add_mul, Nat.one_mul]
omega
theorem count {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q)
(a : Fin g.vertices → Fin q) :
countSatisfied a (construct C hC g).constraints = C * countSatisfied a g.constraints :=
count_copies C g.constraints a
theorem maxSatisfied {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) (hq : 0 < q) :
InstanceValue.maxSatisfied (construct C hC g) = C * InstanceValue.maxSatisfied g := by
classical
apply Nat.le_antisymm
· unfold InstanceValue.maxSatisfied
apply Finset.sup_le
intro a _
change countSatisfied a (copyMajor C g.constraints) ≤ C * InstanceValue.maxSatisfied g
erw [count_copies]
exact Nat.mul_le_mul_left C (InstanceValue.countSatisfied_le_maxSatisfied g a)
· obtain ⟨a, ha⟩ := InstanceValue.maxSatisfied_attained g hq
rw [← ha, ← count C hC g a]
exact InstanceValue.countSatisfied_le_maxSatisfied (construct C hC g) a
theorem value {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) (hq : 0 < q) :
InstanceValue.value (construct C hC g) = InstanceValue.value g := by
have hc : (C : ℝ) ≠ 0 := by exact_mod_cast hC.ne'
have hm : (g.constraints.length : ℝ) ≠ 0 := by
exact_mod_cast g.constraintCount_positive.ne'
unfold InstanceValue.value
rw [maxSatisfied C hC g hq, edge_count]
push_cast
field_simp
theorem mem_original {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q)
(c : Constraint g.vertices q) (hc : c ∈ (construct C hC g).constraints) :
c ∈ g.constraints := by
obtain ⟨es, hes, hc⟩ := List.mem_flatten.mp hc
have he : es = g.constraints := List.eq_of_mem_replicate hes
simpa [he] using hc
theorem translations {q s : Nat} (C : Nat) (hC : 0 < C) (g : Instance q)
(coordinates : Fin q ≃ BinaryLinear.Vector s)
(hg : TranslationTarget.IsTranslationInstance coordinates g) :
TranslationTarget.IsTranslationInstance coordinates (construct C hC g) := by
intro c hc
exact hg c (mem_original C hC g c hc)
theorem flatMap_copies {α β : Type*} (C : Nat) (xs : List α) (f : α → List β) :
(copyMajor C xs).flatMap f = copyMajor C (xs.flatMap f) := by
induction C with
| zero => simp [copyMajor]
| succ C ih =>
simpa only [copyMajor, List.replicate_succ, List.flatten_cons,
List.flatMap_append] using congrArg (fun ys => xs.flatMap f ++ ys) ih
theorem encode_copies (C : Nat) (words : List Nat) :
encodeWords (copyMajor C words) = copyMajor C (encodeWords words) := by
induction C with
| zero => rfl
| succ C ih =>
simpa only [copyMajor, List.replicate_succ, List.flatten_cons,
encodeWords_append] using congrArg (fun xs => encodeWords words ++ xs) ih
/-- The complete output keeps the two first headers and scales the edge count. -/
theorem gameWords_construct {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) :
gameWords (construct C hC g) =
[g.vertices, q, C * g.constraints.length] ++
copyMajor C (g.constraints.flatMap constraintWords) := by
simp only [gameWords, vertices]
rw [show (construct C hC g).constraints = copyMajor C g.constraints from rfl,
flatMap_copies, copy_length]
theorem gameBits_construct {q : Nat} (C : Nat) (hC : 0 < C) (g : Instance q) :
gameBits (construct C hC g) =
encodeWords [g.vertices, q, C * g.constraints.length] ++
copyMajor C (encodeWords (g.constraints.flatMap constraintWords)) := by
rw [gameBits, gameWords_construct, encodeWords_append, encode_copies]
end UniqueGamesTheorem.Explicit.UniformTarget
end OAI
|