File size: 8,820 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
import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramSignature
import OAI.Algorithms.SubexponentialSAT.SqrtLog.HeadScatterProgramRun

namespace OAI.Algorithms

/-! Physical production of a labelled full ambient assignment. -/
namespace SubexponentialSAT.SqrtLog.BucketProgram
open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls SubexponentialSAT.Subexp.MatrixProgramSupport
namespace Label
abbrev Data := State 8 22
abbrev Code := Cmd 8 22

def state (regs : Fin 8 → Bool) (W : List Bool) (rows : List (List (List Bool)))
    (js : List ℕ) (n : ℕ) (pending : List (List Bool)) (records keys : List Bool) : Data :=
  ⟨regs, ![W,[],[],[],[],[],[],[],[],[],[],[],[],[],[],
    ProgramEncoding.encodeRecords pending,words (rows.map words),
    HeadScatterProgram.indices js,HeadScatterProgram.unary n,records,keys,[]]⟩

def signaturePorts : Fin 15 → Fin 22 := Fin.castAdd 7
def signatureCall : Code := .call (ProgramLinking.liftProgram signatureProgram id signaturePorts)
def scatterPorts : Fin 13 → Fin 22 := ![21,1,2,3,4,5,6,7,8,9,17,12,18]
theorem scatterPorts_injective : Function.Injective scatterPorts := by decide

def scatterCall : Code := .call
  (ProgramLinking.liftProgram HeadScatterProgram.program id scatterPorts)
def popTag : Code := .base (.atom (.pop 15 0 1))
def keyTag : Code := .base (.seq (.atom (.set 0 true)) (.atom (.push 20 0)))

def step : Code :=
  .seq popTag (.seq (readWord 15 12 11 (by decide))
    (.seq (copy 16 13 11) (.seq signatureCall (.seq scatterCall
      (.seq (copy 14 2 11) (.seq (emitFrame 2 20 11 (by decide))
        (.seq keyTag (.seq (emitFrame 21 19 11 (by decide))
          (.seq (emitFrame 14 19 11 (by decide))
            (WorkspaceCleanupProgram.command 0 1 [12]))))))))))

def key (W bits : List Bool) (rows : List (List (List Bool))) := signatureValue W bits rows

def stepCost (W bits : List Bool) (rows : List (List (List Bool)))
    (js : List ℕ) (n : ℕ) : ℕ :=
  1+(9*bits.length+7)+(7*(words (rows.map words)).length+5)+
  (signatureCost W bits rows+2)+HeadScatterProgram.totalCost n js bits+
  (7*(key W bits rows).length+5)+(8*(key W bits rows).length+8)+2+
  (8*n+8)+(8*(key W bits rows).length+8)+(2*bits.length+3)

theorem step_eval (regs : Fin 8 → Bool) (W bits : List Bool)
    (rows : List (List (List Bool))) (js : List ℕ) (n : ℕ)
    (pending : List (List Bool)) (records keys : List Bool)
    (hrows : ∀ row∈rows,row.length=bits.length)
    (hlen : js.length=bits.length) (hjs : ∀ j∈js,j < n) :
    ∃ t ≤ stepCost W bits rows js n, ∃ rf,
      Eval step t (state regs W rows js n (bits::pending) records keys)
        (state rf W rows js n pending
          (Encoding.frame (key W bits rows)++Encoding.frame (HeadScatterProgram.mask n js bits)++records)
          (true::(Encoding.frame (key W bits rows)++keys))) := by
  let d := state regs W rows js n (bits::pending) records keys
  let a : Data := ⟨readRegs regs 0 1 (some true),Function.update d.stacks 15
    (Encoding.frame bits++ProgramEncoding.encodeRecords pending)⟩
  have hea : Eval popTag 1 d a := by
    simpa [popTag,a,d,state,ProgramEncoding.encodeRecords,Encoding.encodeList,
      StructuredProgram.Atom.eval,StructuredProgram.Atom.instr,
      StructuredProgram.State.ofCfg,StructuredProgram.State.withPC,execInstr] using
      (Eval.base (StructuredProgram.Eval.atom (.pop (15 : Fin 22) (0 : Fin 8) 1) d))
  obtain ⟨b,heb,hsb⟩ := readWord_eval (15 : Fin 22) 12 11
    (by decide) (by decide) (by decide) a bits (ProgramEncoding.encodeRecords pending)
    (by simp [a]) (by simp [a,d,state]) (by simp [a,d,state])
  obtain ⟨c,hec,hsc⟩ := copy_eval (16 : Fin 22) 13 11
    (by decide) (by decide) (by decide) b (by simp [hsb,a,d,state])
  have hcproj : projectState id signaturePorts c = signatureState c.regs W bits rows [] := by
    apply congrArg (StructuredProgram.State.mk c.regs)
    funext i; fin_cases i <;>
      simp [signaturePorts,hsc,hsb,a,d,state,StackRoutines.copyStacks]
  obtain ⟨ts,hts,rs,hes⟩ := signatureCommand_eval c.regs W bits rows [] hrows
  simp only [List.append_nil] at hes
  rw [←hcproj] at hes
  have hesig := eval_call_from_state signatureProgram id signaturePorts c
    Function.injective_id (Fin.castAdd_injective _ _) (compiled_halt_trace hes 13 14)
  let e : Data := ⟨rs,Function.update (Function.update c.stacks 13 []) 14 (key W bits rows)⟩
  have hse : embedState id signaturePorts c (signatureState rs W bits [] (key W bits rows))=e := by
    apply embedState_eq_of_ports id signaturePorts c _ _ Function.injective_id (Fin.castAdd_injective _ _)
    · intro i; rfl
    · intro i hi; exact (hi ⟨i,rfl⟩).elim
    · intro i; fin_cases i <;>
        simp [e,key,signaturePorts,signatureState,words,hsc,hsb,a,d,state,StackRoutines.copyStacks]
    · intro i hi
      have h13 : i≠13 := fun h => hi ⟨13,h.symm⟩
      have h14 : i≠14 := fun h => hi ⟨14,h.symm⟩
      simp [e,h13,h14]
  change Eval signatureCall (ts+1) c (embedState id signaturePorts c
    (signatureState rs W bits [] (key W bits rows))) at hesig
  rw [hse] at hesig
  have heproj : projectState id scatterPorts e = HeadScatterProgram.input e.regs js bits n := by
    apply congrArg (StructuredProgram.State.mk e.regs)
    funext i; fin_cases i <;>
      simp [scatterPorts,e,hsc,hsb,a,d,state,StackRoutines.copyStacks
        ]
  obtain ⟨rt,het⟩ := HeadScatterProgram.command_eval e.regs n js bits hlen hjs
  rw [←heproj] at het
  have hescatter := eval_call_from_state HeadScatterProgram.program id scatterPorts e
    Function.injective_id scatterPorts_injective (compiled_halt_trace het 10 0)
  let f : Data := ⟨rt,Function.update e.stacks 21 (HeadScatterProgram.mask n js bits)⟩
  have hsf : embedState id scatterPorts e (HeadScatterProgram.result rt js bits n)=f := by
    apply embedState_eq_of_ports id scatterPorts e _ _ Function.injective_id scatterPorts_injective
    · intro i; rfl
    · intro i hi; exact (hi ⟨i,rfl⟩).elim
    · intro i; fin_cases i <;>
        simp [f,scatterPorts,HeadScatterProgram.result,e,hsc,hsb,a,d,state,StackRoutines.copyStacks]
    · intro i hi
      have h21 : i≠21 := fun h => hi ⟨0,h.symm⟩
      simp [f,h21]
  change Eval scatterCall (HeadScatterProgram.totalCost n js bits-1+1) e
    (embedState id scatterPorts e (HeadScatterProgram.result rt js bits n)) at hescatter
  rw [hsf] at hescatter
  obtain ⟨g,heg,hsg⟩ := copy_eval (14 : Fin 22) 2 11
    (by decide) (by decide) (by decide) f (by simp [f,e,hsc,hsb,a,d,state,StackRoutines.copyStacks])
  obtain ⟨h,heh,hsh⟩ := emitFrame_eval (2 : Fin 22) 20 11
    (by decide) (by decide) (by decide) g
    (by simp [hsg,f,e,hsc,hsb,a,d,state,StackRoutines.copyStacks])
  let k : Data := ⟨Function.update h.regs 0 true,Function.update h.stacks 20 (true::h.stacks 20)⟩
  have hek : Eval keyTag 2 h k := by
    have hx := (StructuredProgram.Eval.atom (.set (0 : Fin 8) true) h).seq
      (StructuredProgram.Eval.atom (.push (20 : Fin 22) 0) _)
    exact .base (by simpa [k,StructuredProgram.Atom.eval,StructuredProgram.Atom.instr,
      StructuredProgram.State.ofCfg,StructuredProgram.State.withPC,execInstr] using hx)
  obtain ⟨l,hel,hsl⟩ := emitFrame_eval (21 : Fin 22) 19 11
    (by decide) (by decide) (by decide) k
    (by simp [k,hsh,hsg,f,e,hsc,hsb,a,d,state,StackRoutines.copyStacks])
  obtain ⟨m,hem,hsm⟩ := emitFrame_eval (14 : Fin 22) 19 11
    (by decide) (by decide) (by decide) l
    (by simp [hsl,k,hsh,hsg,f,e,hsc,hsb,a,d,state,StackRoutines.copyStacks])
  let q := WorkspaceCleanupProgram.finish (0 : Fin 8) 1 ([12] : List (Fin 22)) m
  have heq := WorkspaceCleanupProgram.command_eval (0 : Fin 8) 1
    ([12] : List (Fin 22)) (by decide) m
  have hq : q = state q.regs W rows js n pending
      (Encoding.frame (key W bits rows)++Encoding.frame (HeadScatterProgram.mask n js bits)++records)
      (true::(Encoding.frame (key W bits rows)++keys)) := by
    apply congrArg (StructuredProgram.State.mk q.regs)
    funext i; fin_cases i <;>
      simp [BankRoutines.clearBankStacks,hsm,hsl,k,hsh,hsg,f,e,hsc,hsb,a,d,state,StackRoutines.copyStacks,List.append_assoc]
  have hrun := hea.seq (heb.seq (hec.seq (hesig.seq (hescatter.seq
    (heg.seq (heh.seq (hek.seq (hel.seq (hem.seq heq)))))))))
  change Eval step _ d q at hrun
  rw [hq] at hrun
  refine ⟨_,?_,q.regs,hrun⟩
  have hp : 1 ≤ HeadScatterProgram.totalCost n js bits := by
    unfold HeadScatterProgram.totalCost; omega
  have hm := HeadScatterProgram.mask_length n js bits hjs
  simp only [Nat.sub_add_cancel hp]
  simp [WorkspaceCleanupProgram.cost,hsm,hsl,k,hsh,hsg,f,e,hsc,hsb,a,d,state,
    StackRoutines.copyStacks,hm,stepCost]
  omega

end Label
end SubexponentialSAT.SqrtLog.BucketProgram

end OAI.Algorithms