File size: 6,910 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 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramPreprocessMatrix
namespace OAI.Algorithms
/-! Integer semantics and explicit polynomial bounds for the concrete
signed-coefficient preprocessing machine. -/
namespace SubexponentialSAT.SqrtLog.BucketProgram
open SubexponentialSAT.BitProgram SubexponentialSAT.Subexp.MatrixProgramSupport
def preWordsBounded (L : ℕ) (xs : List SignedWord) : Prop :=
∀ a∈xs, a.1.length ≤ L ∧ a.2.length ≤ L
theorem shiftedWords_length_bound {W : List Bool} {xs : List SignedWord}
{ys : List (List Bool)} (h : List.Forall₂ (shiftedWord W) xs ys)
(L : ℕ) (hW : W.length ≤ L) (hb : preWordsBounded L xs) :
∀ y∈ys, y.length ≤ 3*L+1 := by
induction h with
| nil => simp
| @cons a y xs ys hy hys ih =>
intro z hz
rcases List.mem_cons.mp hz with rfl | hz
· have ha := hb a (by simp)
have hh := hy.2
omega
· exact ih (fun a ha => hb a (by simp [ha])) z hz
theorem shiftedMatrix_rowWidth {W : List Bool} {xs : List (List SignedWord)}
{ys : List (List (List Bool))} (h : List.Forall₂ (List.Forall₂ (shiftedWord W)) xs ys)
(width : ℕ) (hw : ∀ row∈xs, row.length=width) :
∀ row∈ys, row.length=width := by
induction h with
| nil => simp
| @cons a y xs ys hy hys ih =>
intro z hz
rcases List.mem_cons.mp hz with rfl | hz
· exact (shiftedWords_length hy).symm.trans (hw a (by simp))
· exact ih (fun a ha => hw a (by simp [ha])) z hz
theorem shiftedWords_integer {W : List Bool} {xs : List SignedWord} {ys : List (List Bool)}
(h : List.Forall₂ (shiftedWord W) xs ys)
(hb : ∀ a∈xs, SubexponentialSAT.BinaryArithmetic.toNat a.2 ≤ SubexponentialSAT.BinaryArithmetic.toNat W) :
List.Forall₂ (fun a y => (SubexponentialSAT.BinaryArithmetic.toNat y : ℤ) =
(SubexponentialSAT.BinaryArithmetic.toNat W : ℤ)+
((SubexponentialSAT.BinaryArithmetic.toNat a.1 : ℤ)-(SubexponentialSAT.BinaryArithmetic.toNat a.2 : ℤ))) xs ys := by
induction h with
| nil => exact .nil
| @cons a y xs ys h hs ih =>
exact .cons (shiftedWord_integer W a y h (hb a (by simp)))
(ih (fun z hz => hb z (by simp [hz])))
theorem preStepCost_le (W : List Bool) (a : SignedWord) (L : ℕ)
(hW : W.length ≤ L) (hP : a.1.length ≤ L) (hN : a.2.length ≤ L) :
preStepCost W a ≤ 6000*(L+1)^2 := by
have hsum : W.length+a.2.length+a.1.length+1 ≤ 3*L+1 := by omega
have hsq := Nat.pow_le_pow_left hsum 2
dsimp [preStepCost]
nlinarith
theorem preRow_inputs (W : List Bool) (xs : List SignedWord) (L : ℕ)
(hW : W.length ≤ L) (hb : preWordsBounded L xs) :
preScanCost W xs ≤ (xs.length+1)*(6000*(L+1)^2+2) ∧
preOutputLength W xs ≤ xs.length*(3*L+1) ∧
(signedWords xs).length ≤ xs.length*(4*L+2) := by
induction xs with
| nil => simp [preScanCost,preOutputLength,signedWords]
| cons a xs ih =>
have ha := hb a (by simp)
have ht := ih (fun x hx => hb x (by simp [hx]))
have hc := preStepCost_le W a L hW ha.1 ha.2
rcases a with ⟨P,N⟩
simp only [preScanCost,preOutputLength,List.map_cons,List.sum_cons,
List.length_cons,signedWords,List.length_append,Encoding.length_frame] at *
constructor
· nlinarith [ht.1]
constructor
· nlinarith [ht.2.1]
· nlinarith [ht.2.2]
theorem preRowCost_le (W : List Bool) (xs : List SignedWord) (L : ℕ)
(hW : W.length ≤ L) (hb : preWordsBounded L xs) :
preRowCost W xs ≤ 7000*(xs.length+1)*(L+1)^2 := by
have h := preRow_inputs W xs L hW hb
have hlin : 3*L+1 ≤ 3*(L+1)^2 := by nlinarith
have hh := Nat.mul_le_mul_left xs.length hlin
have hs : 1 ≤ (L+1)^2 := by nlinarith
have hn := Nat.mul_le_mul_left xs.length hs
dsimp [preRowCost]
nlinarith [h.1,h.2.1]
theorem preMatrixStepCost_le (W : List Bool) (row : List SignedWord) (L : ℕ)
(hW : W.length ≤ L) (hb : preWordsBounded L row) :
preMatrixStepCost W row ≤ 8000*(row.length+1)*(L+1)^2 := by
have h := preRow_inputs W row L hW hb
have hr := preRowCost_le W row L hW hb
have hlin : 4*L+2 ≤ 4*(L+1)^2 := by nlinarith
have hlin' : 3*L+1 ≤ 3*(L+1)^2 := by nlinarith
have hh := Nat.mul_le_mul_left row.length hlin
have hh' := Nat.mul_le_mul_left row.length hlin'
have hs : 1 ≤ (L+1)^2 := by nlinarith
have hn := Nat.mul_le_mul_left row.length hs
dsimp [preMatrixStepCost]
nlinarith [h.2.1,h.2.2]
theorem preMatrix_inputs (W : List Bool) (rows : List (List SignedWord)) (L h : ℕ)
(hW : W.length ≤ L)
(hb : ∀ row∈rows, preWordsBounded L row ∧ row.length ≤ h) :
preMatrixScanCost W rows ≤ (rows.length+1)*(8000*(h+1)*(L+1)^2+2) ∧
preMatrixPayload W rows ≤ rows.length*(2*h*(3*L+1)+h) := by
induction rows with
| nil => simp [preMatrixScanCost,preMatrixPayload]
| cons row rows ih =>
have hr := hb row (by simp)
have ht := ih (fun r hr' => hb r (by simp [hr']))
have hc := preMatrixStepCost_le W row L hW hr.1
have hc' : preMatrixStepCost W row ≤ 8000*(h+1)*(L+1)^2 :=
hc.trans (Nat.mul_le_mul_right _ (Nat.mul_le_mul_left _ (by omega)))
have hl := (preRow_inputs W row L hW hr.1).2.1
have hl' := Nat.mul_le_mul_right (3*L+1) hr.2
simp only [preMatrixScanCost,preMatrixPayload,List.map_cons,List.sum_cons,List.length_cons] at *
constructor
· nlinarith [ht.1]
· nlinarith [ht.2]
theorem preMatrixCost_polynomial (W : List Bool) (rows : List (List SignedWord)) (L h : ℕ)
(hW : W.length ≤ L)
(hb : ∀ row∈rows, preWordsBounded L row ∧ row.length ≤ h) :
preMatrixCost W rows+1 ≤ 10000*(rows.length+1)*(h+1)*(L+1)^2 := by
have hi := preMatrix_inputs W rows L h hW hb
have hlin : 3*L+1 ≤ 3*(L+1)^2 := by nlinarith
have hp := Nat.mul_le_mul_left (rows.length*(2*h)) hlin
have hs : 1 ≤ (L+1)^2 := by nlinarith
have hh := Nat.mul_le_mul_left (rows.length*h) hs
have hn := Nat.mul_le_mul_left rows.length hs
have hz := Nat.mul_le_mul_left h hs
dsimp [preMatrixCost]
nlinarith [hi.1,hi.2]
theorem preMatrixProgram_runsIn_polynomial (regs : Fin 8 → Bool) (W : List Bool)
(rows : List (List SignedWord)) (L h : ℕ) (hW : W.length ≤ L)
(hb : ∀ row∈rows, preWordsBounded L row ∧ row.length ≤ h) :
∃ rf ys, RunsIn preMatrixProgram (10000*(rows.length+1)*(h+1)*(L+1)^2)
((preMatrixState regs W rows []).withPC (some preMatrixProgram.entry))
((preMatrixState rf W [] (words (ys.map words))).withPC none) ∧
List.Forall₂ (List.Forall₂ (shiftedWord W)) rows ys := by
obtain ⟨rf,ys,⟨t,ht,he⟩,hy⟩ := preMatrixProgram_runsIn regs W rows
exact ⟨rf,ys,⟨t,ht.trans (preMatrixCost_polynomial W rows L h hW hb),he⟩,hy⟩
end SubexponentialSAT.SqrtLog.BucketProgram
end OAI.Algorithms
|