File size: 9,396 Bytes
2f887db
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
import OAI.Computability.PerfectCompleteness.Machines.EncodingLemmas
import OAI.Computability.PerfectCompleteness.Reduction.CanonicalNamedGame
import OAI.Computability.PerfectCompleteness.Reduction.CompletedVisitOrder
import OAI.Computability.PerfectCompleteness.Reduction.TargetGameLemmas

namespace OAI

section

namespace PerfectCompleteness.ExactPreliminaryTarget

open UniqueGamesTheorem.Foundations.Games
open CompletionSoundness CompletionSoundness.LegalProjectionGame
open scoped Classical

noncomputable section

variable {branch : Nat → Nat} {n t v m : Nat} [NeZero m]
    (clauses : Fin m → SourceClause.NormalizedClause v) (rows repeats : Nat → Nat)
    (hn : 0 < n) (hbranch : ∀ k < n, 0 < branch k) (hrows : ∀ k, 0 < rows (k + 1)) (δ : ℚ)

local notation "F" => FinitePreliminaryCompletion.blockFamily clauses branch n t rows repeats
local notation "q" => FinitePreliminaryCompletion.alphabet branch n t δ
local notation "family" => FinitePreliminaryCompletion.actualFamily
  (t := t) clauses rows repeats hn hbranch hrows δ
local notation "order" => CompletedVisitOrder.completedOrder
  (t := t) clauses rows repeats hn hbranch hrows δ
local notation "rawOrder" => CompletedVisitOrder.rawOrder
  (t := t) clauses rows repeats hn hbranch hrows δ
local notation "coverage" => CompletedVisitOrder.mem_rawOrder
  (t := t) clauses rows repeats hn hbranch hrows δ

local instance leftVertex_fintype : Fintype (CanonicalGame.LeftVertex F) := Fintype.ofFinite _
local instance rightVertex_fintype : Fintype (CanonicalGame.RightVertex F) := Fintype.ofFinite _
local instance leftLabel_fintype (x : CanonicalGame.LeftVertex F) :
    Fintype (CanonicalGame.LeftLabel F x) := Fintype.ofFinite _
local instance rightLabel_fintype (y : CanonicalGame.RightVertex F) :
    Fintype (CanonicalGame.RightLabel F y) := Fintype.ofFinite _
local instance rightAlphabet_nonempty : Nonempty (Fin q) :=
  ⟨⟨0, CanonicalLocalCompletion.alphabet_positive (TreeCanonical.locationCount branch n t) δ⟩⟩
local instance leftAlphabet_nonempty : Nonempty (Fin (2 * q)) :=
  ⟨⟨0, Nat.mul_pos (by decide)
    (CanonicalLocalCompletion.alphabet_positive (TreeCanonical.locationCount branch n t) δ)⟩⟩

def namedGame := CanonicalNamedGame.rename F rawOrder coverage (family).game

def entry (e : CompletedSignedLaw.Completed (t := t) clauses rows repeats hn hbranch hrows δ) :
    Edge (rawOrder).length (rawOrder).length q where
  left := (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).left e
  right := (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).right e
  projection := ProjectionTable.ofMap ((family).map e.1 e.2) (by
    intro b
    rw [Fintype.card_eq_nat_card]
    have h := (family).exact_two e.1 e.2 b
    rw [Fintype.card_eq_nat_card] at h
    exact h)

theorem entry_satisfied (e : CompletedSignedLaw.Completed (t := t) clauses rows repeats hn hbranch hrows δ)
    (a : Fin (rawOrder).length → Fin (2 * q)) (b : Fin (rawOrder).length → Fin q) :
    (entry (t := t) clauses rows repeats hn hbranch hrows δ e).satisfied a b =
      (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).wins (a, b) e := by
  simp only [Edge.satisfied, entry, ProjectionTable.ofMap_apply]
  exact decide_eq_decide.mpr Iff.rfl

def construct : Instance q where
  leftVertices := (rawOrder).length
  rightVertices := (rawOrder).length
  edges := (order).map (entry (t := t) clauses rows repeats hn hbranch hrows δ)
  nonempty := by
    intro hempty
    have h := List.map_eq_nil_iff.mp hempty
    exact CompletedVisitOrder.completedOrder_nonempty
      (t := t) clauses rows repeats hn hbranch hrows δ h

theorem edge_count :
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length =
      SignedMultiplicity.denominator branch n t rows repeats hn hbranch hrows q *
        m ^ TreeCanonical.locationCount branch n t := by
  change ((order).map (entry (t := t) clauses rows repeats hn hbranch hrows δ)).length = _
  rw [List.length_map]
  exact CompletedVisitOrder.completedOrder_length
    (t := t) clauses rows repeats hn hbranch hrows δ

theorem leftVertices_eq_edges :
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).leftVertices =
      (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length := by
  exact (CompletedVisitOrder.rawOrder_length
    (t := t) clauses rows repeats hn hbranch hrows δ).trans
    (edge_count (t := t) clauses rows repeats hn hbranch hrows δ).symm

theorem rightVertices_eq_edges :
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).rightVertices =
      (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length :=
  leftVertices_eq_edges (t := t) clauses rows repeats hn hbranch hrows δ

theorem rate_eq (a : Fin (rawOrder).length → Fin (2 * q)) (b : Fin (rawOrder).length → Fin q) :
    (countSatisfied a b (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges : ℝ) /
        (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length =
      (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).success (a, b) := by
  change (countSatisfied a b
      ((order).map (entry (t := t) clauses rows repeats hn hbranch hrows δ)) : ℝ) /
    ((order).map (entry (t := t) clauses rows repeats hn hbranch hrows δ)).length = _
  rw [RoundedTarget.countSatisfied_eq_filter]
  simp only [List.filter_map, List.length_map, Function.comp_def]
  have h := CompletedVisitOrder.completedOrder_probability
    (t := t) clauses rows repeats hn hbranch hrows δ
    (fun e => (entry (t := t) clauses rows repeats hn hbranch hrows δ e).satisfied a b)
  simpa only [Function.comp_def, entry_satisfied, OccurrenceGame.success,
    namedGame, CanonicalNamedGame.rename_occurrences] using h

theorem value_eq :
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).value =
      FinitePreliminaryCompletion.actualValue
        (t := t) clauses rows repeats hn hbranch hrows δ := by
  have hq : 0 < q :=
    CanonicalLocalCompletion.alphabet_positive (TreeCanonical.locationCount branch n t) δ
  have hnamed : (construct (t := t) clauses rows repeats hn hbranch hrows δ).value =
      (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).value := by
    apply le_antisymm
    · obtain ⟨s, hs⟩ :=
        (construct (t := t) clauses rows repeats hn hbranch hrows δ).maxSatisfied_attained hq
      unfold Instance.value
      rw [← hs]
      exact (rate_eq (t := t) clauses rows repeats hn hbranch hrows δ s.1 s.2).le.trans
        ((namedGame (t := t) clauses rows repeats hn hbranch hrows δ).success_le_value s)
    · obtain ⟨s, hs⟩ :=
        (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).exists_optimal_strategy
      calc
        (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).value =
            (namedGame (t := t) clauses rows repeats hn hbranch hrows δ).success s := hs.symm
        _ = (countSatisfied s.1 s.2
            (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges : ℝ) /
              (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length :=
          (rate_eq (t := t) clauses rows repeats hn hbranch hrows δ s.1 s.2).symm
        _ ≤ (construct (t := t) clauses rows repeats hn hbranch hrows δ).value :=
          (construct (t := t) clauses rows repeats hn hbranch hrows δ).rate_le_value s
  exact hnamed.trans (CanonicalNamedGame.rename_value_eq F rawOrder coverage (family).game)

theorem value_le (hδ : 0 < δ) :
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).value ≤
      (PreliminarySampler.game clauses branch n t rows repeats hn hbranch hrows).value +
        (δ : ℝ) / 3 := by
  rw [value_eq]
  exact FinitePreliminaryCompletion.actualValue_le
    (t := t) clauses rows repeats hn hbranch hrows δ hδ

theorem perfectlyComplete (assignment : Fin v → Bool)
    (hsat : ∀ c, (clauses c).clause.eval assignment = true) :
    PerfectlyComplete (construct (t := t) clauses rows repeats hn hbranch hrows δ) := by
  apply ((construct (t := t) clauses rows repeats hn hbranch hrows δ).perfectlyComplete_iff_value_eq_one
    (CanonicalLocalCompletion.alphabet_positive (TreeCanonical.locationCount branch n t) δ)).2
  rw [value_eq]
  exact FinitePreliminaryCompletion.actualValue_of_satisfying
    (t := t) clauses rows repeats hn hbranch hrows δ assignment hsat

theorem encoding_length_le :
    let target := construct (t := t) clauses rows repeats hn hbranch hrows δ
    let N := target.edges.length
    (Encoding.gameBits target).length ≤
      2 * N + q + N + 4 + N * (2 * N + 2 * q * q + 2 * q + 2) := by
  dsimp only
  have h := Encoding.gameBits_length_le_of_edge_count
    (construct (t := t) clauses rows repeats hn hbranch hrows δ)
    (construct (t := t) clauses rows repeats hn hbranch hrows δ).edges.length le_rfl
  have arithmetic (l r N : Nat) (hl : l = N) (hr : r = N) :
      l + r + q + N + 4 + N * (l + r + 2 * q * q + 2 * q + 2) =
        2 * N + q + N + 4 + N * (2 * N + 2 * q * q + 2 * q + 2) := by
    simp only [hl, hr, two_mul]
  exact h.trans_eq (arithmetic _ _ _
    (leftVertices_eq_edges (t := t) clauses rows repeats hn hbranch hrows δ)
    (rightVertices_eq_edges (t := t) clauses rows repeats hn hbranch hrows δ))

end
end PerfectCompleteness.ExactPreliminaryTarget

end

end OAI