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
|