Download data/lean/OAI/Algorithms/SubexponentialSAT/CeilingDivisionPrograms.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.71 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/CeilingDivisionPrograms.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algorithms/SubexponentialSAT/CeilingDivisionPrograms.lean
-
curl -L -o CeilingDivisionPrograms.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algorithms/SubexponentialSAT/CeilingDivisionPrograms.lean
5.71 kB
| import OAI.Algorithms.SubexponentialSAT.LeanCompat | |
| import OAI.Algorithms.SubexponentialSAT.CounterForPrograms | |
| import OAI.Algorithms.SubexponentialSAT.ChunkPartition | |
| namespace OAI.Algorithms | |
| /-! | |
| # Ceiling division by fixed finite bit programs | |
| The rounding suffix tests the actual remainder word and increments the actual | |
| quotient word precisely when that remainder is nonzero. Natural division is | |
| used only in the semantic statement of the full routine. | |
| -/ | |
| namespace SubexponentialSAT.CeilingDivisionPrograms | |
| open SubexponentialSAT.BitProgram SubexponentialSAT.StructuredProgram SubexponentialSAT.CounterPrograms | |
| abbrev Data := StructuredProgram.State 8 8 | |
| def registers : Fin 3 ↪ Fin 8 where | |
| toFun i := ⟨i.val, Nat.lt_trans i.isLt (by decide)⟩ | |
| inj' := by | |
| intro i j h | |
| exact Fin.ext (congrArg (fun k : Fin 8 => k.val) h) | |
| def remainderPorts : CounterForPrograms.Ports 8 8 := | |
| ⟨registers, 0, 1, by decide⟩ | |
| def quotientPorts : CounterForPrograms.Ports 8 8 := | |
| ⟨registers, 7, 1, by decide⟩ | |
| abbrev incrementCmd {R S : ℕ} (p : CounterForPrograms.Ports R S) : StructuredCalls.Cmd R S := | |
| .call (ProgramLinking.liftProgram (rippleProgram true) p.register | |
| (CounterForPrograms.stackPorts p)) | |
| noncomputable def incrementResult {R S : ℕ} (p : CounterForPrograms.Ports R S) | |
| (d : StructuredProgram.State R S) : StructuredProgram.State R S := | |
| CounterForPrograms.install p d false false (d.regs (p.register 2)) | |
| (ripple true (d.stacks p.counter)) [] | |
| theorem increment_eval {R S : ℕ} (p : CounterForPrograms.Ports R S) | |
| (d : StructuredProgram.State R S) (hs : d.stacks p.scratch = []) : | |
| StructuredCalls.Eval (incrementCmd p) (rippleCost true (d.stacks p.counter) + 1) | |
| d (incrementResult p d) := by | |
| have h := StructuredCalls.eval_call_lifted (rippleProgram true) p.register | |
| (CounterForPrograms.stackPorts p) d p.register.injective | |
| (CounterForPrograms.stackPorts p).injective | |
| (CounterForPrograms.ripple_local_trace true (d.regs (p.register 0)) | |
| (d.regs (p.register 1)) (d.regs (p.register 2)) (d.stacks p.counter)) | |
| change StructuredCalls.Eval (incrementCmd p) _ | |
| (CounterForPrograms.install p d _ _ _ _ []) (incrementResult p d) at h | |
| rw [← hs, CounterForPrograms.install_self] at h | |
| exact h | |
| theorem increment_counter {R S : ℕ} (p : CounterForPrograms.Ports R S) | |
| (d : StructuredProgram.State R S) : | |
| (incrementResult p d).stacks p.counter = ripple true (d.stacks p.counter) := | |
| CounterForPrograms.install_counter p d _ _ _ _ _ | |
| theorem increment_other {R S : ℕ} (p : CounterForPrograms.Ports R S) | |
| (d : StructuredProgram.State R S) (hs : d.stacks p.scratch = []) | |
| (j : Fin S) (hc : j ≠ p.counter) : | |
| (incrementResult p d).stacks j = d.stacks j := by | |
| by_cases hj : j = p.scratch | |
| · subst j | |
| exact (CounterForPrograms.install_scratch p d _ _ _ _ _).trans hs.symm | |
| · exact CounterForPrograms.install_other_stack p d _ _ _ _ _ j hc hj | |
| abbrev roundCmd : StructuredCalls.Cmd 8 8 := | |
| .seq (CounterForPrograms.zeroCmd remainderPorts) | |
| (.ite 2 (.base .skip) (incrementCmd quotientPorts)) | |
| def roundProgram := StructuredCalls.compiled roundCmd (0 : Fin 8) 7 | |
| theorem roundCmd_size : StructuredCalls.size roundCmd = 22 := rfl | |
| def RoundOutput (d e : Data) : Prop := | |
| e.stacks 7 = (if value (d.stacks 0) = 0 then d.stacks 7 else ripple true (d.stacks 7)) ∧ | |
| ∀ j : Fin 8, j ≠ 7 → e.stacks j = d.stacks j | |
| def roundBound (d : Data) : ℕ := 8 * ((d.stacks 0).length + (d.stacks 7).length) + 15 | |
| theorem round_eval (d : Data) (hs : d.stacks 1 = []) : | |
| ∃ n e, StructuredCalls.Eval roundCmd n d e ∧ RoundOutput d e ∧ n ≤ roundBound d := by | |
| let z := CounterForPrograms.zeroResult remainderPorts d | |
| have hz : StructuredCalls.Eval (CounterForPrograms.zeroCmd remainderPorts) | |
| (8 * (d.stacks 0).length + 6) d z := CounterForPrograms.zero_eval remainderPorts d hs | |
| have hzstacks : z.stacks = d.stacks := | |
| CounterForPrograms.install_stacks_self remainderPorts d _ _ _ hs | |
| have hzscratch : z.stacks 1 = [] := by rw [hzstacks]; exact hs | |
| have hzflag : z.regs 2 = isZero (d.stacks 0) := | |
| CounterForPrograms.install_register remainderPorts d _ _ _ _ _ 2 | |
| by_cases hv : value (d.stacks 0) = 0 | |
| · have hf : z.regs 2 = true := hzflag.trans ((isZero_eq_true_iff _).mpr hv) | |
| refine ⟨(8 * (d.stacks 0).length + 6) + (0 + 1), z, | |
| .seq hz (.ite_true hf (.base (.skip z))), ?_, ?_⟩ | |
| · constructor | |
| · simp only [hv, ite_eq_left, hzstacks] | |
| · intro j _; exact congrFun hzstacks j | |
| · dsimp [roundBound]; omega | |
| · have hf : z.regs 2 = false := | |
| hzflag.trans ((isZero_eq_false_iff _).mpr (by omega)) | |
| refine ⟨(8 * (d.stacks 0).length + 6) + | |
| ((rippleCost true (z.stacks 7) + 1) + 1), incrementResult quotientPorts z, | |
| .seq hz (.ite_false hf (increment_eval quotientPorts z hzscratch)), ?_, ?_⟩ | |
| · constructor | |
| · simpa only [quotientPorts, hv, ite_false, hzstacks] using | |
| increment_counter quotientPorts z | |
| · intro j hj | |
| exact (increment_other quotientPorts z hzscratch j hj).trans (congrFun hzstacks j) | |
| · have hb := rippleCost_le true (z.stacks 7) | |
| rw [hzstacks] at hb ⊢ | |
| dsimp [roundBound] | |
| omega | |
| theorem round_value (d e : Data) (h : RoundOutput d e) : | |
| value (e.stacks 7) = value (d.stacks 7) + if value (d.stacks 0) = 0 then 0 else 1 := by | |
| rw [h.1] | |
| by_cases hz : value (d.stacks 0) = 0 <;> simp [hz, value_increment] | |
| theorem round_length (d e : Data) (h : RoundOutput d e) : | |
| (e.stacks 7).length ≤ (d.stacks 7).length + 1 := by | |
| rw [h.1] | |
| split_ifs | |
| · omega | |
| · exact ripple_length_le true _ | |
| end SubexponentialSAT.CeilingDivisionPrograms | |
| end OAI.Algorithms | |