File size: 5,284 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 | import OAI.Algorithms.SubexponentialSAT.LeanCompat
import OAI.Algorithms.SubexponentialSAT.SqrtLog.BucketProgramRow
import OAI.Algorithms.SubexponentialSAT.CounterNormalizeProgram
namespace OAI.Algorithms
/-! Canonical, positive encodings for exact integer row signatures. The
added one is common to all assignments and makes the normalizer total on
all legitimate row results, including the empty head. -/
namespace SubexponentialSAT.SqrtLog.BucketProgram
open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredCalls
def canonical (n : ℕ) : List Bool :=
SubexponentialSAT.SubexpLiftRing.fixedBits (Nat.log2 n+1) n
def normalizeRegs : Fin 3 → Fin 8 := Fin.castAdd 5
def normalizePorts : Fin 3 → Fin 12 := fun i => ⟨i.val+2, by omega⟩
theorem normalizeRegs_injective : Function.Injective normalizeRegs := Fin.castAdd_injective _ _
theorem normalizePorts_injective : Function.Injective normalizePorts := by
intro i j h; apply Fin.ext; have := congrArg Fin.val h; simpa [normalizePorts] using this
def normalizeCall : DotCode := .call
(ProgramLinking.liftProgram SubexponentialSAT.CounterNormalizeProgram.program normalizeRegs normalizePorts)
theorem normalizeCall_eval (regs : Fin 8 → Bool) (W out : List Bool)
(hp : 0 < SubexponentialSAT.BinaryArithmetic.toNat out) :
∃ t ≤ 9*out.length+21, ∃ rf,
Eval normalizeCall t (dotState regs W [] [] out)
(dotState rf W [] [] (canonical (SubexponentialSAT.BinaryArithmetic.toNat out))) := by
have hp' : 0 < SubexponentialSAT.CounterPrograms.value out := by
simpa only [SubexponentialSAT.CounterPrograms.value_eq_toNat] using hp
obtain ⟨t, he, ht⟩ := SubexponentialSAT.CounterNormalizeProgram.normalize_eval
(regs ∘ normalizeRegs) out hp'
have ha : projectState normalizeRegs normalizePorts (dotState regs W [] [] out) =
SubexponentialSAT.CounterNormalizeProgram.state (regs ∘ normalizeRegs) out [] := by
apply congrArg (StructuredProgram.State.mk (regs ∘ normalizeRegs))
funext i; fin_cases i <;> rfl
rw [←ha] at he
have h := eval_call_from_state SubexponentialSAT.CounterNormalizeProgram.program normalizeRegs normalizePorts
(dotState regs W [] [] out) normalizeRegs_injective normalizePorts_injective
(compiled_halt_trace he 0 0)
let rf := (embedState normalizeRegs normalizePorts (dotState regs W [] [] out)
(SubexponentialSAT.CounterNormalizeProgram.state SubexponentialSAT.CounterNormalizeProgram.zeroRegs
(canonical (SubexponentialSAT.BinaryArithmetic.toNat out)) [])).regs
have hend : embedState normalizeRegs normalizePorts (dotState regs W [] [] out)
(SubexponentialSAT.CounterNormalizeProgram.state SubexponentialSAT.CounterNormalizeProgram.zeroRegs
(canonical (SubexponentialSAT.BinaryArithmetic.toNat out)) []) =
dotState rf W [] [] (canonical (SubexponentialSAT.BinaryArithmetic.toNat out)) := by
apply embedState_eq_of_ports normalizeRegs normalizePorts _ _ _
normalizeRegs_injective normalizePorts_injective
· intro i
exact (embedState_register normalizeRegs normalizePorts _ _ normalizeRegs_injective i)
· intro i hi
exact (embedState_register_frame normalizeRegs normalizePorts _ _ i hi)
· intro i; fin_cases i <;> rfl
· intro i hi
have h2 : i ≠ 2 := fun h => hi ⟨0, h.symm⟩
fin_cases i <;> simp_all [dotState]
simp only [SubexponentialSAT.CounterPrograms.value_eq_toNat] at h
change Eval normalizeCall (t+1) _
(embedState normalizeRegs normalizePorts _
(SubexponentialSAT.CounterNormalizeProgram.state _ (canonical _) [])) at h
rw [hend] at h
exact ⟨t+1, by omega, rf, h⟩
def canonicalRowCommand : DotCode := .seq rowCommand normalizeCall
def canonicalRowProgram := compiled canonicalRowCommand 9 2
def canonicalRowBudget (W : List Bool) (coeffs : List (List Bool)) : ℕ :=
rowBudget W coeffs [true] + 9*rowWidth W coeffs [true]+22
theorem canonicalRowCommand_eval (regs : Fin 8 → Bool) (W : List Bool)
(coeffs : List (List Bool)) (bits : List Bool) (hlen : coeffs.length=bits.length) :
∃ t ≤ canonicalRowBudget W coeffs, ∃ rf,
Eval canonicalRowCommand t (dotState regs W coeffs bits [true])
(dotState rf W [] [] (canonical (1+rowValue W coeffs bits))) := by
obtain ⟨t,ht,rm,out,he,hv,hl⟩ := rowCommand_eval regs W coeffs bits [true] hlen
have hv' : SubexponentialSAT.BinaryArithmetic.toNat out = 1+rowValue W coeffs bits := by
simpa [SubexponentialSAT.BinaryArithmetic.toNat] using hv
obtain ⟨u,hu,rf,hf⟩ := normalizeCall_eval rm W out (by omega)
rw [hv'] at hf
exact ⟨t+u, by dsimp [canonicalRowBudget]; omega, rf, he.seq hf⟩
theorem canonicalRow_runsIn (regs : Fin 8 → Bool) (W : List Bool)
(coeffs : List (List Bool)) (bits : List Bool) (hlen : coeffs.length=bits.length) :
∃ rf, RunsIn canonicalRowProgram (canonicalRowBudget W coeffs+1)
((dotState regs W coeffs bits [true]).withPC (some canonicalRowProgram.entry))
((dotState rf W [] [] (canonical (1+rowValue W coeffs bits))).withPC none) := by
obtain ⟨t,ht,rf,he⟩ := canonicalRowCommand_eval regs W coeffs bits hlen
exact ⟨rf,⟨t+1,by omega,compiled_halt_trace he 9 2⟩⟩
end SubexponentialSAT.SqrtLog.BucketProgram
end OAI.Algorithms
|