openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Numerical /AllFieldCertificatesReplayStatic.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Numerical.AllFieldCertificatesReplay | |
| namespace OAI | |
| /-! Exact rational intervals, logarithm bounds and arithmetic circuit soundness. -/ | |
| namespace MatrixMultiplication.AllFieldCertificates.Replay | |
| def Op.before (n : ℕ) : Op → Bool | |
| | .constant _ => true | |
| | .add i j => decide (i < n ∧ j < n) | |
| | .neg i => decide (i < n) | |
| | .mul i j => decide (i < n ∧ j < n) | |
| | .inv i => decide (i < n) | |
| | .log i => decide (i < n) | |
| def checkOp (two : Ball) (v : ℕ → Ball) (op : Op) (w : Witness) : Bool := | |
| match op with | |
| | .constant q => contains (.exact q) w.ball | |
| | .add i j => contains (Ball.add (v i) (v j)) w.ball | |
| | .neg i => contains (Ball.neg (v i)) w.ball | |
| | .mul i j => contains (Ball.mul (v i) (v j)) w.ball | |
| | .inv i => decide (0 < (v i).lower) && contains (Ball.inv (v i)) w.ball | |
| | .log i => match w.logarithm with | |
| | none => false | |
| | some lw => checkLog two (v i) w.ball lw | |
| theorem checkOp_sound {two : Ball} (htwo : two.Encloses (Real.log 2)) | |
| {bs : ℕ → Ball} {vs : ℕ → ℝ} {n : ℕ} | |
| (hr : ∀ i < n, (bs i).Encloses (vs i)) | |
| {op : Op} {w : Witness} (hw : op.before n = true) | |
| (hc : checkOp two bs op w = true) : w.ball.Encloses (op.value vs) := by | |
| cases op with | |
| | constant q => exact contains_sound (Ball.exact_sound q) hc | |
| | add i j => | |
| have h : i < n ∧ j < n := of_decide_eq_true hw | |
| exact contains_sound (Ball.add_sound (hr i h.1) (hr j h.2)) hc | |
| | neg i => | |
| exact contains_sound (Ball.neg_sound (hr i (of_decide_eq_true hw))) hc | |
| | mul i j => | |
| have h : i < n ∧ j < n := of_decide_eq_true hw | |
| exact contains_sound (Ball.mul_sound (hr i h.1) (hr j h.2)) hc | |
| | inv i => | |
| simp only [checkOp, Bool.and_eq_true] at hc | |
| exact contains_sound | |
| (Ball.inv_sound (hr i (of_decide_eq_true hw)) (of_decide_eq_true hc.1)) hc.2 | |
| | log i => | |
| cases hl : w.logarithm with | |
| | none => simp [checkOp, hl] at hc | |
| | some lw => | |
| simp only [checkOp, hl] at hc | |
| exact checkLog_sound htwo (hr i (of_decide_eq_true hw)) hc | |
| def checkAt (two : Ball) (ops : ℕ → Op) (bs : ℕ → Ball) (i : ℕ) (w : Witness) : Bool := | |
| decide (w.ball = bs i) && (ops i).before i && checkOp two bs (ops i) w | |
| def checkRange (two : Ball) (ops : ℕ → Op) (bs : ℕ → Ball) : ℕ → List Witness → Bool | |
| | _, [] => true | |
| | start, w :: ws => | |
| checkAt two ops bs start w && checkRange two ops bs (start + 1) ws | |
| theorem checkRange_at {two : Ball} {ops : ℕ → Op} {bs : ℕ → Ball} | |
| (ws : List Witness) (start : ℕ) | |
| (hc : checkRange two ops bs start ws = true) (j : ℕ) (hj : j < ws.length) : | |
| ∃ w, checkAt two ops bs (start + j) w = true := by | |
| induction ws generalizing start j with | |
| | nil => simp at hj | |
| | cons w ws ih => | |
| simp only [checkRange, Bool.and_eq_true] at hc | |
| cases j with | |
| | zero => exact ⟨w, by simpa using hc.1⟩ | |
| | succ j => | |
| obtain ⟨v, hv⟩ := ih (start + 1) hc.2 j (by simpa using hj) | |
| refine ⟨v, ?_⟩ | |
| have hi : start + Nat.succ j = start + 1 + j := by omega | |
| rw [hi] | |
| exact hv | |
| theorem checkRange_append (two : Ball) (ops : ℕ → Op) (bs : ℕ → Ball) | |
| (as cs : List Witness) (start : ℕ) : | |
| checkRange two ops bs start (as ++ cs) = | |
| (checkRange two ops bs start as && checkRange two ops bs (start + as.length) cs) := by | |
| induction as generalizing start with | |
| | nil => simp [checkRange] | |
| | cons a as ih => | |
| simp only [List.cons_append, checkRange, List.length_cons] | |
| rw [ih] | |
| have hi : start + 1 + as.length = start + (as.length + 1) := by omega | |
| rw [hi] | |
| exact (Bool.and_assoc _ _ _).symm | |
| theorem checkedValues_sound {two : Ball} (htwo : two.Encloses (Real.log 2)) | |
| (ops : ℕ → Op) (bs : ℕ → Ball) (vs : ℕ → ℝ) (count : ℕ) | |
| (heval : ∀ i < count, vs i = (ops i).value vs) | |
| (hc : ∀ i < count, ∃ w, checkAt two ops bs i w = true) : | |
| ∀ i < count, (bs i).Encloses (vs i) := by | |
| intro i | |
| induction i using Nat.strong_induction_on with | |
| | h i ih => | |
| intro hi | |
| obtain ⟨w, hw⟩ := hc i hi | |
| simp only [checkAt, Bool.and_eq_true] at hw | |
| have hb : w.ball = bs i := of_decide_eq_true hw.1.1 | |
| rw [heval i hi, ← hb] | |
| apply checkOp_sound htwo (n := i) _ hw.1.2 hw.2 | |
| intro j hj | |
| exact ih j hj (hj.trans hi) | |
| def RangeChecked (two : Ball) (ops : ℕ → Op) (bs : ℕ → Ball) (lo hi : ℕ) : Prop := | |
| ∀ i, lo ≤ i → i < hi → ∃ w, checkAt two ops bs i w = true | |
| theorem rangeChecked_of_checkRange {two : Ball} {ops : ℕ → Op} {bs : ℕ → Ball} | |
| (ws : List Witness) (start : ℕ) | |
| (hc : checkRange two ops bs start ws = true) : | |
| RangeChecked two ops bs start (start + ws.length) := by | |
| intro i hlo hhi | |
| have h := checkRange_at ws start hc (i - start) (by omega) | |
| simpa only [Nat.add_sub_of_le hlo] using h | |
| theorem RangeChecked.join {two : Ball} {ops : ℕ → Op} {bs : ℕ → Ball} | |
| {lo mid hi : ℕ} (hl : RangeChecked two ops bs lo mid) | |
| (hr : RangeChecked two ops bs mid hi) : RangeChecked two ops bs lo hi := by | |
| intro i hlo hhi | |
| by_cases hm : i < mid | |
| · exact hl i hlo hm | |
| · exact hr i (Nat.le_of_not_gt hm) hhi | |
| end MatrixMultiplication.AllFieldCertificates.Replay | |
| end OAI | |