| import Mathlib.Data.Matrix.Basic |
| import Mathlib.Data.Rat.Cast.Order |
| import Mathlib.Algebra.BigOperators.Group.Finset.Basic |
| import OAI.Algebra.FormulaHitting.BitModel |
| import OAI.Algebra.FormulaHitting.BitRefinement |
|
|
| namespace OAI |
|
|
| namespace NCHittingSpecification |
|
|
| universe u |
|
|
| inductive Formula (F : Type*) (n : ℕ) where |
| | scalar : F → Formula F n |
| | variable : Fin n → Formula F n |
| | add : Formula F n → Formula F n → Formula F n |
| | multiply : Formula F n → Formula F n → Formula F n |
|
|
| namespace Formula |
|
|
| def gates {F : Type*} {n : ℕ} : Formula F n → ℕ |
| | .scalar _ => 1 |
| | .variable _ => 1 |
| | .add f g => gates f + gates g + 1 |
| | .multiply f g => gates f + gates g + 1 |
|
|
| noncomputable def coefficient {F : Type*} {n : ℕ} [Semiring F] : |
| Formula F n → List (Fin n) → F |
| | .scalar a, w => if w = [] then a else 0 |
| | .variable i, w => if w = [i] then 1 else 0 |
| | .add f g, w => coefficient f w + coefficient g w |
| | .multiply f g, w => |
| ∑ k ∈ Finset.range (w.length + 1), |
| coefficient f (w.take k) * coefficient g (w.drop k) |
|
|
| def evaluate {F : Type*} {n d : ℕ} [Field F] |
| (T : Fin n → Matrix (Fin d) (Fin d) F) : |
| Formula F n → Matrix (Fin d) (Fin d) F |
| | .scalar a => Matrix.scalar (Fin d) a |
| | .variable i => T i |
| | .add f g => evaluate T f + evaluate T g |
| | .multiply f g => evaluate T f * evaluate T g |
|
|
| end Formula |
|
|
| def dimension (n s : ℕ) : ℕ := |
| if n = 1 ∧ s = 1 then 1 else 2 * n * s ^ 2 |
|
|
| def expectedEntry (n s : ℕ) (i : Fin n) |
| (r q : Fin (dimension n s)) : ℚ := |
| if n = 1 ∧ s = 1 then 1 |
| else if q.val < r.val then |
| (-1 : ℚ) ^ (r.val - q.val - 1) / |
| ((r.val : ℚ) * ((i.val + 1 : ℕ) : ℚ) ^ (r.val - q.val)) |
| else 0 |
|
|
| def UniversalHitting (n s d : ℕ) |
| (T : Fin n → Matrix (Fin d) (Fin d) ℚ) : Prop := |
| ∀ (F : Type*) [Field F] [CharZero F], ∀ f : Formula F n, |
| f.gates ≤ s → (∃ w, f.coefficient w ≠ 0) → |
| f.evaluate (fun i r q => (T i r q : F)) ≠ 0 |
|
|
| open NCHitting.BitModel |
|
|
| def expectedProgram : Program := |
| .branch (.mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1))) |
| (.emit (.literal 0) (.literal 1) (.literal 1)) |
| (.loop (.read 0) |
| (.loop (.mul (.mul (.literal 2) (.read 1)) (.power (.read 2) (.literal 2))) |
| (.loop (.mul (.mul (.literal 2) (.read 2)) (.power (.read 3) (.literal 2))) |
| (.branch (.less (.read 0) (.read 1)) |
| (.emit (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1))) |
| (.literal 1) |
| (.mul (.read 1) (.power (.add (.read 2) (.literal 1)) |
| (.sub (.read 1) (.read 0))))) |
| (.emit (.literal 0) (.literal 0) (.literal 1)))))) |
|
|
| def expectedCode (i r q : ℕ) : NCHitting.BitModel.RationalCode := |
| if q < r then ⟨decide ((r - q - 1) % 2 = 1), 1, r * (i + 1) ^ (r - q)⟩ |
| else ⟨false, 0, 1⟩ |
|
|
| def expectedOutput (n s : ℕ) : List NCHitting.BitModel.RationalCode := |
| if n = 1 ∧ s = 1 then [⟨false, 1, 1⟩] |
| else (List.range n).flatMap fun i => |
| (List.range (2 * n * s ^ 2)).flatMap fun r => |
| (List.range (2 * n * s ^ 2)).map fun q => expectedCode i r q |
|
|
| def decode (entry : NCHitting.BitModel.RationalCode) : ℚ := |
| (if entry.negative then -(entry.numerator : ℚ) else entry.numerator) / entry.denominator |
|
|
| def entryBitBound (n d : ℕ) : ℕ := 3 + d.size + d * n.size |
|
|
| def costBound (n s : ℕ) : ℕ := |
| let d := 2 * n * s ^ 2 |
| let M := n + s + d + 3 |
| let B := M * M + 4 * M + 10 |
| let R := 5 * (M + 1) + 6 |
| let P := 8 * (M * M + 2) * (M + 1) + 4 * (M + 3) + 1 |
| let E := R + 8 * B * B + 8 * B + (2 + M * P) + 10 |
| let L := M + 1 + 4 * (M + 3) + 1 |
| let entryCost := 20 * E + B + 20 |
| let entryOutput := B + 3 |
| let rowCost := 7 * E + 1 + d * (entryCost + L + entryOutput) |
| let rowOutput := d * entryOutput |
| let variableCost := 7 * E + 1 + d * (rowCost + L + rowOutput) |
| let variableOutput := d * rowOutput |
| 2 * (M + 1) + 7 * E + 15 + (R + 1 + n * (variableCost + L + variableOutput)) + 1 |
|
|
| def primitiveBitBound (n s : ℕ) : ℕ := 1024 * costBound n s ^ 3 |
|
|
| def CompleteClaim (n s : ℕ) : Prop := |
| let d := dimension n s |
| let result := execute expectedProgram [n, s] |
| 0 < d ∧ d ≤ 2 * n * s ^ 2 ∧ |
| result.output = expectedOutput n s ∧ |
| result.output.length = n * d * d ∧ |
| (∀ entry ∈ result.output, |
| 0 < entry.denominator ∧ entry.numerator ≤ 1 ∧ |
| entry.denominator.size ≤ entryBitBound n d ∧ |
| entry.bits ≤ 4 + entryBitBound n d) ∧ |
| (∀ (i : Fin n) (r q : Fin d), |
| decode ((result.output[i.val * d * d + r.val * d + q.val]?).getD ⟨false, 0, 1⟩) = |
| expectedEntry n s i r q) ∧ |
| result.cost ≤ costBound n s ∧ |
| (NCHitting.BitRefinement.Exec expectedProgram [n, s] result.output |
| (NCHitting.BitRefinement.executionSteps expectedProgram [n, s]) ∧ |
| NCHitting.BitRefinement.executionSteps expectedProgram [n, s] ≤ primitiveBitBound n s) ∧ |
| UniversalHitting.{u} n s d (expectedEntry n s) |
|
|
| def CompleteTheorem : Prop := |
| ∀ n s : ℕ, 1 ≤ n → 1 ≤ s → CompleteClaim.{u} n s |
|
|
| end NCHittingSpecification |
|
|
| end OAI |
|
|
