File size: 8,252 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
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
180
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorAssignmentProgram
import OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.QuerySourceReplay
import OAI.Algorithms.SubexponentialSAT.SqrtLog.ProgramTapeReplayMacros

/-! The actual assignment program neither reads nor writes collector tapes320
and322. Certificates include the cache constructor, dispatcher peeks, source
specialization, arithmetic, parser iterations and all cleanup instructions. -/
namespace OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorQueryReplay

open OAI BitProgram StructuredCalls SqrtLog.ProgramTapeReplay
open SqrtLog SqrtLog.LeafProgram
attribute [local simp] Fin.coe_ofNat_eq_mod

local notation "H" => (fun i : Fin 768 => Fin.val i = 320 ∨ Fin.val i = 322)
local notation "HW" => (fun i : Fin 896 => Fin.val i = 320 ∨ Fin.val i = 322)

private theorem lift_low_avoids (c : Cmd 40 768) (input output : Fin 768)
    (hc : AvoidsCmd H c) :
    AvoidsCmd HW (FactorAssignmentProgram.liftLow c input output) :=
  avoids_liftProgram _ _ _ _ (avoids_compiled H c hc input output)

private theorem cache_local_avoids : AvoidsCmd H LeafNodeCacheProgram.localCommand := by
  refine ⟨avoids_copyMany _ _ _ (by decide) ?_, ?_,
    avoids_copyMany _ _ _ (by decide) ?_, avoids_clearCmd _ _ (by decide)⟩
  · simp [LeafNodeCacheProgram.copies, LeafNodeCacheProgram.directCopies]
  · apply avoids_call_lift_of_range
    intro i
    change ¬ (340 + i.val = 320 ∨ 340 + i.val = 322)
    omega
  · simp

/-- The concrete constant encoder and every paid cache copy avoid the
collector words, including any temporary reads in their implementations. -/
theorem setup_avoids : AvoidsCmd HW FactorAssignmentProgram.setup := by
  apply avoids_liftProgram
  exact avoids_compiled H FactorAssignmentProgram.setupLocal
    ⟨avoids_clearMany _ _ (by
      simp [FactorAssignmentProgram.cachePorts, LeafNodeCacheProgram.cachePorts,
        LeafNodeCacheProgram.pocket]), cache_local_avoids⟩ 128 69

private theorem factor_copy_avoids (src dst : Fin 768)
    (hs : ¬ H src) (hd : ¬ H dst) : AvoidsCmd H (Factor.copy src dst) :=
  avoids_copyProgram H src dst 159 0 1 hs hd (by decide)

private theorem factor_clear_avoids (src : Fin 768) (hs : ¬ H src) :
    AvoidsCmd H (Factor.clear src) := avoids_clearProgram H src 0 1 hs

private theorem factor_move_avoids (src dst : Fin 768)
    (hs : ¬ H src) (hd : ¬ H dst) : AvoidsCmd H (Factor.move src dst) :=
  ⟨factor_copy_avoids src dst hs hd, factor_clear_avoids src hs⟩

private theorem multiply_avoids : AvoidsCmd H Factor.multiply := by
  apply avoids_call_lift_of_range
  intro i
  change ¬ (i.val = 320 ∨ i.val = 322)
  omega

private theorem accumulate_avoids : AvoidsCmd H Factor.accumulate :=
  ⟨factor_move_avoids _ _ (by decide) (by decide),
    factor_move_avoids _ _ (by decide) (by decide), multiply_avoids,
    factor_move_avoids _ _ (by decide) (by decide)⟩

private theorem indicator_avoids : AvoidsCmd H Factor.indicator := by
  refine ⟨⟨True.intro, True.intro, True.intro⟩, ?_⟩
  apply avoids_call_lift_of_range
  decide

private theorem clause_avoids : AvoidsCmd H Clause.caller := by
  apply avoids_call_lift_of_range
  intro i
  change ¬ (i.val = 320 ∨ i.val = 322)
  omega

private theorem hash_arithmetic_avoids : AvoidsCmd H FactorEvaluationSpace.hashArithmetic :=
  ⟨indicator_avoids, factor_clear_avoids _ (by decide),
    factor_clear_avoids _ (by decide), accumulate_avoids⟩

private theorem marked_arithmetic_avoids : AvoidsCmd H FactorEvaluationSpace.markedArithmetic :=
  ⟨clause_avoids, factor_clear_avoids _ (by decide), accumulate_avoids⟩

private theorem expansion_avoids : AvoidsCmd H Expansion.forwardCommand := by
  constructor
  · intro q
    fin_cases q <;> simp [AvoidsInstr]
  · apply avoids_call_lift_of_range
    decide

private theorem factor_id_avoids : AvoidsCmd H FactorID.command :=
  ⟨avoids_copyProgram H 149 556 359 0 1 (by decide) (by decide) (by decide),
    by change ¬ H 556; decide⟩

private theorem dispatcher_avoids : AvoidsCmd H FactorDispatch.command := by
  refine ⟨⟨avoids_copyProgram H 149 152 359 0 1 (by decide) (by decide) (by decide),
    (by change ¬ H 706; decide)⟩, ?_⟩
  apply avoids_call_lift_of_range
  decide

private theorem callback_scratch_avoids :
    ∀ i ∈ FactorAssignmentProgram.callbackScratch, ¬ H i := by
  simp [FactorAssignmentProgram.callbackScratch, FactorServices.indicatorScratch,
    Factor.indicatorStacks, Factor.nativeStacks, FactorDispatch.scratch, Expansion.scratch,
    Equiv.swap_apply_def]

private theorem clear_callback_avoids : AvoidsCmd HW FactorAssignmentProgram.clearCallback := by
  apply avoids_liftProgram
  exact avoids_compiled H FactorAssignmentProgram.clearCallbackLocal
    (avoids_clearMany H _ callback_scratch_avoids) 149 149

private theorem prepare_incidence_avoids :
    AvoidsCmd HW FactorAssignmentProgram.prepareIncidence :=
  ⟨lift_low_avoids _ _ _ factor_id_avoids, QuerySourceReplay.caller_avoids⟩

private theorem choose_avoids : AvoidsCmd HW FactorAssignmentProgram.choose :=
  ⟨⟨prepare_incidence_avoids,
      lift_low_avoids _ _ _ ⟨expansion_avoids, hash_arithmetic_avoids⟩⟩,
    ⟨prepare_incidence_avoids,
      lift_low_avoids _ _ _
        ⟨factor_move_avoids _ _ (by decide) (by decide), marked_arithmetic_avoids⟩⟩,
    True.intro⟩

private theorem copy_avoids (src dst : Fin 896)
    (hs : ¬ HW src) (hd : ¬ HW dst) :
    AvoidsCmd HW (FactorAssignmentProgram.copy src dst) :=
  avoids_copyProgram HW src dst 159 0 1 hs hd (by decide)

private theorem clear_avoids (src : Fin 896) (hs : ¬ HW src) :
    AvoidsCmd HW (FactorAssignmentProgram.clear src) := avoids_clearProgram HW src 0 1 hs

private theorem move_avoids (src dst : Fin 896)
    (hs : ¬ HW src) (hd : ¬ HW dst) :
    AvoidsCmd HW (FactorAssignmentProgram.move src dst) :=
  ⟨copy_avoids src dst hs hd, clear_avoids src hs⟩

theorem callback_avoids : AvoidsCmd HW FactorAssignmentProgram.callback :=
  ⟨clear_callback_avoids, lift_low_avoids _ _ _ dispatcher_avoids,
    choose_avoids, clear_avoids _ (by decide), True.intro, True.intro, True.intro⟩

private theorem loop_avoids : AvoidsCmd HW FactorAssignmentProgram.loop :=
  avoids_record_iterate HW FactorAssignmentProgram.ports FactorAssignmentProgram.callback
    (by decide) (by decide) callback_avoids

private theorem product_avoids : AvoidsCmd HW FactorAssignmentProgram.product :=
  ⟨copy_avoids _ _ (by decide) (by decide), copy_avoids _ _ (by decide) (by decide),
    loop_avoids, move_avoids _ _ (by decide) (by decide)⟩

private theorem entry_ports_avoids : ∀ i ∈ FactorTableProgram.entryPorts, ¬ HW i := by
  intro i hi
  rcases List.mem_append.mp hi with hi | hi
  · obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hi
    have hj' := (Incidence.mem_workerPorts j).mp (List.mem_filter.mp hj).1
    have hh := QuerySourceReplay.Table.base_high j hj'.1
    omega
  · simp only [List.mem_cons, List.mem_nil_iff, or_false] at hi
    rcases hi with rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;> decide

private theorem entry_scratch_avoids :
    ∀ i ∈ FactorAssignmentProgram.entryScratch, ¬ HW i := by
  intro i hi
  simp only [FactorAssignmentProgram.entryScratch, List.mem_append] at hi
  rcases hi with (hi | hi) | hi
  · simp only [List.mem_cons, List.mem_nil_iff, or_false] at hi
    rcases hi with rfl | rfl | rfl | rfl | rfl <;> decide
  · obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hi
    exact callback_scratch_avoids j hj
  · exact entry_ports_avoids i hi

private theorem initialize_avoids : AvoidsCmd HW FactorAssignmentProgram.initialize := by
  apply avoids_liftProgram
  exact avoids_compiled HW _ (avoids_clearMany HW _ entry_scratch_avoids) 175 854

/-- No tape operation in the fixed accepted-assignment implementation touches
an outer collector tape. This includes reads, not only final-state framing. -/
theorem assignment_avoids : AvoidsCmd HW FactorAssignmentProgram.assignment :=
  ⟨initialize_avoids, setup_avoids, product_avoids⟩

theorem program_avoids : AvoidsProgram HW FactorAssignmentProgram.program :=
  avoids_compiled HW _ assignment_avoids 175 854

end OAI.Algorithms.SubexponentialSAT.SqrtLogSpace.FactorQueryReplay