File size: 1,748 Bytes
ea76aac | 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 | import Mathlib
namespace OAI
section
namespace ExactFourier
/-- One charged scalar gate, referencing only available values. -/
inductive Gate (w : ℕ) where
| add (i j : Fin w)
| sub (i j : Fin w)
| scale (c : ℂ) (i : Fin w)
def Gate.eval {w : ℕ} (v : Fin w → ℂ) : Gate w → ℂ
| .add i j => v i + v j
| .sub i j => v i - v j
| .scale c i => c * v i
/-- A topologically ordered scalar DAG; available values are never consumed. -/
inductive Program (n : ℕ) : ℕ → Type where
| nil : Program n 0
| step {k : ℕ} (p : Program n k) (g : Gate (n + 1 + k)) : Program n (k + 1)
def Program.eval {n : ℕ} : {k : ℕ} → Program n k → (Fin n → ℂ) →
(Fin (n + 1 + k) → ℂ)
| 0, .nil, x => Fin.snoc x 0
| _ + 1, .step p g, x =>
let v := p.eval x
Fin.snoc v (g.eval v)
/-- Outputs name available values, so permutations and arbitrary fanout are uncharged. -/
structure Circuit (n : ℕ) where
size : ℕ
program : Program n size
outputs : Fin n → Fin (n + 1 + size)
def Circuit.eval {n : ℕ} (C : Circuit n) (x : Fin n → ℂ) : Fin n → ℂ :=
fun i => C.program.eval x (C.outputs i)
noncomputable def zeta (n : ℕ) : ℂ := Complex.exp (2 * Real.pi * Complex.I / (n : ℂ))
noncomputable def fourierMatrix (n : ℕ) : Matrix (Fin n) (Fin n) ℂ :=
fun j k => zeta n ^ (j.val * k.val)
def Circuit.Computes {n : ℕ} (C : Circuit n) (A : Matrix (Fin n) (Fin n) ℂ) : Prop :=
∀ x, C.eval x = A.mulVec x
def MainStatement : Prop :=
∀ c : ℝ, 0 < c → ∀ N₀ : ℕ, 2 ≤ N₀ → ∃ n : ℕ, N₀ ≤ n ∧
∃ C : Circuit n, C.Computes (fourierMatrix n) ∧
(C.size : ℝ) < c * (n : ℝ) * Real.logb 2 (n : ℝ)
end ExactFourier
end
end OAI
|