File size: 5,819 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.SqrtLog.BinaryArgmin
import OAI.Algorithms.SubexponentialSAT.SqrtLog.HashSelectArgmin

namespace OAI.Algorithms

/-!
# A measured binary argmin scan with a paid loader

`LoaderSpec` is a refinement obligation on a fixed, executable command. It
requires an actual `StructuredCalls.Eval` for every callback, including the
final empty callback; it is not an oracle or an instruction for evaluating a
mathematical score. A caller may satisfy it by parsing prepared records or by
enumerating candidates and executing a score program. The incumbent score is
cached. Its first evaluation and the preparation of the initial incumbent are
outside this scan and must be charged by the caller.
-/

namespace SubexponentialSAT.SqrtLog.BinaryArgmin

open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls

def Fits (B C : ℕ) (a : Entry) : Prop :=
  a.score.length = B ∧ a.payload.length ≤ C

theorem pick_fits {B C : ℕ} {best next : Entry}
    (hb : Fits B C best) (hn : Fits B C next) : Fits B C (pick best next) := by
  unfold pick
  split_ifs <;> assumption

/-- This supplies both the callback implementation and its paid trace. The
single queue stack can encode arbitrary loader context. All other ports are
explicitly framed. The callback must work with every incumbent and register
contents satisfying the bit bounds. -/
structure LoaderSpec (load : Cmd 8 9) (encode : List Entry → List Bool)
    (B C cost : ℕ) : Prop where
  nil : ∀ best regs, Fits B C best →
    ∃ n ≤ cost, ∃ regs', regs' 7 = false ∧
      Eval load n (data regs empty best (encode []))
        (data regs' empty best (encode []))
  cons : ∀ next rest best regs,
    Fits B C best → Fits B C next → (∀ a ∈ rest, Fits B C a) →
    ∃ n ≤ cost, ∃ regs', regs' 7 = true ∧
      Eval load n (data regs empty best (encode (next :: rest)))
        (data regs' next best (encode rest))

/-- The command is fixed independently of score widths and candidate counts. -/
abbrev scanCommand (load : Cmd 8 9) : Cmd 8 9 :=
  .seq load (.while 7 (.seq update load))

def scanBudget (B C cost count : ℕ) : ℕ :=
  cost * (count + 1) + (100 * (B + C + 1) + 1) * count + 1

/-- Exact semantic refinement of the numerical argmin of `HashSelect`. The
cost includes all losing candidates, all score copies, and the terminal load. -/
theorem scan_eval (load : Cmd 8 9) (encode : List Entry → List Bool)
    (B C cost : ℕ) (hload : LoaderSpec load encode B C cost)
    (seed : Entry) (entries : List Entry) (regs : Fin 8 → Bool)
    (hs : Fits B C seed) (hentries : ∀ a ∈ entries, Fits B C a) :
    ∃ n ≤ scanBudget B C cost entries.length, ∃ regs', regs' 7 = false ∧
      Eval (scanCommand load) n (data regs empty seed (encode entries))
        (data regs' empty (HashSelect.best value seed entries) (encode [])) := by
  induction entries generalizing seed regs with
  | nil =>
    obtain ⟨n, hn, regs', hf, ht⟩ := hload.nil seed regs hs
    refine ⟨n + 1, ?_, regs', hf, ?_⟩
    · simp [scanBudget]; omega
    · exact Eval.seq ht (Eval.while_false hf)
  | cons next rest ih =>
    have hn : Fits B C next := hentries next (by simp)
    have hr : ∀ a ∈ rest, Fits B C a := fun a ha => hentries a (by simp [ha])
    obtain ⟨l, hl, r₁, htrue, hread⟩ := hload.cons next rest seed regs hs hn hr
    obtain ⟨u, hu, r₂, hupdate⟩ := update_eval B C next seed (encode rest) r₁
      hn.1 hs.1 hn.2 hs.2
    obtain ⟨t, ht, r₃, hfalse, htail⟩ := ih (pick seed next) r₂ (pick_fits hs hn) hr
    cases htail with
    | seq hnext hloop =>
      rename_i n m middle
      refine ⟨l + (u + n + m + 1), ?_, r₃, hfalse, ?_⟩
      · simp only [scanBudget, List.length_cons] at ht ⊢
        nlinarith
      · change Eval (.seq load (.while 7 (.seq update load))) _ _ _
        simpa only [HashSelect.best, pick] using
          Eval.seq hread (Eval.while_true htrue (Eval.seq hupdate hnext) hloop)

theorem scanBudget_linear (B C cost count : ℕ) :
    scanBudget B C cost count ≤ (count + 1) * (cost + 100 * (B + C + 1) + 1) := by
  unfold scanBudget
  nlinarith

/-- One fixed finite instruction table for each supplied loader command. -/
abbrev program (load : Cmd 8 9) := compiled (scanCommand load) 8 2

/-- The refinement above gives a genuine halted `BitProgram` trace. -/
theorem program_trace (load : Cmd 8 9) (encode : List Entry → List Bool)
    (B C cost : ℕ) (hload : LoaderSpec load encode B C cost)
    (seed : Entry) (entries : List Entry) (regs : Fin 8 → Bool)
    (hs : Fits B C seed) (hentries : ∀ a ∈ entries, Fits B C a) :
    ∃ n ≤ scanBudget B C cost entries.length + 1, ∃ regs',
      Trace (program load) n
        ((data regs empty seed (encode entries)).withPC (some (program load).entry))
        ((data regs' empty (HashSelect.best value seed entries) (encode [])).withPC none) := by
  obtain ⟨n, hn, regs', _, ht⟩ := scan_eval load encode B C cost hload seed entries regs hs hentries
  exact ⟨n + 1, Nat.add_le_add_right hn 1, regs', compiled_halt_trace ht 8 2⟩

/-- The returned payload belongs to the supplied list, and its binary numeric
score is at most the score of every supplied candidate. -/
theorem selected_spec (seed : Entry) (entries : List Entry) :
    HashSelect.best value seed entries ∈ seed :: entries ∧
      ∀ a ∈ seed :: entries, value (HashSelect.best value seed entries) ≤ value a := by
  refine ⟨HashSelect.best_mem value seed entries, ?_⟩
  intro a ha
  rcases List.mem_cons.mp ha with h | ha
  · subst a
    exact HashSelect.best_le_seed value seed entries
  · exact HashSelect.best_le_member value seed entries a ha

end SubexponentialSAT.SqrtLog.BinaryArgmin

end OAI.Algorithms