lean/OAI/Computability/QuantumFactoring/Basic.lean

import Mathlib

namespace OAI



namespace ExactQuantumFactoring

open scoped BigOperators

/-- The five primitive gates exactly as in Section 2. -/
inductive Primitive where
  | not | cnot | toffoli | hadamard | phase
  deriving DecidableEq

def Primitive.arity : Primitive → ℕ
  | .not | .hadamard | .phase => 1
  | .cnot => 2
  | .toffoli => 3

def Primitive.code : Primitive → ℕ
  | .not => 0 | .cnot => 1 | .toffoli => 2 | .hadamard => 3 | .phase => 4

/-- An inverse and/or one added control. This is a fixed set of 20 gate names,
not an unbounded-control or arbitrary-angle gate model. -/
structure Gate where
  primitive : Primitive
  inverse : Bool
  controlled : Bool
  deriving DecidableEq

def Gate.arity (g : Gate) : ℕ := g.primitive.arity + if g.controlled then 1 else 0

/-- Matrix entries are indexed by lists in wire order (row first, column second).
Entries on ill-sized lists are irrelevant and set to zero. -/
noncomputable def Primitive.matrix : Primitive → List Bool → List Bool → ℂ
  | .not, [a], [b] => if a = !b then 1 else 0
  | .cnot, [a,b], [c,d] => if a = c ∧ b = Bool.xor c d then 1 else 0
  | .toffoli, [a,b,c], [d,e,f] =>
      if a = d ∧ b = e ∧ c = Bool.xor f (d && e) then 1 else 0
  | .hadamard, [a], [b] =>
      (if a && b then -1 else 1) / (Real.sqrt 2 : ℂ)
  | .phase, [a], [b] => if a = b then (if b then Complex.I else 1) else 0
  | _, _, _ => 0

noncomputable def Gate.baseMatrix (g : Gate) (a b : List Bool) : ℂ :=
  if g.inverse then star (g.primitive.matrix b a) else g.primitive.matrix a b

noncomputable def Gate.matrix (g : Gate) (a b : List Bool) : ℂ :=
  if g.controlled then
    match a, b with
    | false :: a', false :: b' => if a' = b' then 1 else 0
    | true :: a', true :: b' => g.baseMatrix a' b'
    | _, _ => 0
  else g.baseMatrix a b

/-- A primitive is placed on distinct actual wires, with no operation of
unbounded arity hidden in a circuit instruction. -/
structure Instruction (q : ℕ) where
  gate : Gate
  wire : Fin gate.arity → Fin q
  distinct : Function.Injective wire

abbrev Basis (q : ℕ) := Fin q → Bool
abbrev State (q : ℕ) := Basis q → ℂ

noncomputable def Instruction.matrix {q : ℕ} (o : Instruction q) :
    Matrix (Basis q) (Basis q) ℂ := by
  classical
  exact fun a b =>
    if ∀ i : Fin q, (∀ j, o.wire j ≠ i) → a i = b i then
      o.gate.matrix (List.ofFn (a ∘ o.wire)) (List.ofFn (b ∘ o.wire))
    else 0

structure Circuit where
  qubits : ℕ
  instructions : List (Instruction qubits)

noncomputable def Circuit.apply (c : Circuit) (ψ : State c.qubits) : State c.qubits :=
  c.instructions.foldl (fun v o => o.matrix.mulVec v) ψ

/-- Input wires are first, least significant bit first; all other wires start zero. -/
def inputBasis (q ℓ N : ℕ) : Basis q :=
  fun i => if i.val < ℓ then N.testBit i.val else false

noncomputable def Circuit.outputState (c : Circuit) (ℓ N : ℕ) : State c.qubits := by
  classical
  exact c.apply (fun x => if x = inputBasis c.qubits ℓ N then 1 else 0)

/-- The cutoff and padding are the standing parameters in Section 2. -/
def paddedLength (ℓ : ℕ) : ℕ := max 128 ℓ

def readBit {q : ℕ} (x : Basis q) (i : ℕ) : Bool :=
  if h : i < q then x ⟨i,h⟩ else false

/-- n entries of n bits each, in the n² wires immediately after the input. -/
def outputList {q : ℕ} (ℓ : ℕ) (x : Basis q) : List ℕ :=
  let n := paddedLength ℓ
  List.ofFn (fun a : Fin n =>
    ∑ j ∈ Finset.range n, if readBit x (ℓ + a.val * n + j) then 2^j else 0)

/-- Complete nondecreasing prime factorization, multiplicities included,
padded by zeros, as in Section 6. There is no primality oracle in the circuit. -/
def CorrectEncoding (N n : ℕ) (xs : List ℕ) : Prop :=
  ∃ ps : List ℕ, (∀ p ∈ ps, Nat.Prime p) ∧ ps.Pairwise (· ≤ ·) ∧
    ps.prod = N ∧ ps.length ≤ n ∧ xs = ps ++ List.replicate (n - ps.length) 0

/-- Unnormalized Born sum on correct outputs; success is exactly one,
not positivity, postselection, or a limiting high probability. -/
noncomputable def Circuit.correctProbability (c : Circuit) (ℓ N : ℕ) : ℝ := by
  classical
  exact ∑ x : Basis c.qubits,
    if CorrectEncoding N (paddedLength ℓ) (outputList ℓ x) then
      Complex.normSq (c.outputState ℓ N x) else 0

/-- Unary natural words with delimiters make the circuit description explicit.
Unary wire addresses cause at most polynomial overhead when width is polynomial. -/
def natWord (k : ℕ) : List Bool := List.replicate k true ++ [false]

def Instruction.encode {q : ℕ} (o : Instruction q) : List Bool :=
  natWord o.gate.primitive.code ++ [o.gate.inverse, o.gate.controlled] ++
    (List.ofFn (fun i => o.wire i |>.val)).flatMap natWord

def Circuit.encode (c : Circuit) : List Bool :=
  natWord c.qubits ++ natWord c.instructions.length ++
    c.instructions.flatMap Instruction.encode

/-- A single finite-alphabet classical generator receives only the INPUT LENGTH.
All stack alphabets, states and labels are finite: no large-integer unit-cost
oracle is hidden in TM2 push/branch functions. -/
def Uniform (family : ℕ → Circuit) : Prop :=
  ∃ generator : Turing.TM2ComputableInPolyTime
      (fun ℓ => List.replicate ℓ true) Circuit.encode family,
    ∀ k, Finite (generator.tm.Γ k)

def PolynomialResources (family : ℕ → Circuit) : Prop :=
  ∃ bound : Polynomial ℕ, ∀ ℓ,
    (family ℓ).qubits ≤ bound.eval ℓ ∧
    (family ℓ).instructions.length ≤ bound.eval ℓ

/-- Literal main endpoint: one length-uniform family, exact output for EVERY
binary integer N≥2, and worst-case polynomial gates AND qubits. -/
def MainTheorem : Prop :=
  ∃ family : ℕ → Circuit, Uniform family ∧ PolynomialResources family ∧
    ∀ (ℓ N : ℕ), 2 ≤ N → N.size = ℓ →
      ℓ + (paddedLength ℓ)^2 ≤ (family ℓ).qubits ∧
      (family ℓ).correctProbability ℓ N = 1

end ExactQuantumFactoring

end OAI