lean/OAI/Computability/BinPacking/CookLevin/Bounds.lean

import OAI.Computability.BinPacking.Computation.MachineUnaryLessAt
import OAI.Computability.BinPacking.CookLevin.ConfigIndex

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.Bounds

open Polynomial

noncomputable def pairLengthPolynomial (q : Polynomial ℕ) : Polynomial ℕ :=
  C 2 * X + q + 1

noncomputable def horizonPolynomial (p q : Polynomial ℕ) : Polynomial ℕ :=
  p.comp (pairLengthPolynomial q)

noncomputable def capacityPolynomial (p q : Polynomial ℕ) (pushes : ℕ) : Polynomial ℕ :=
  pairLengthPolynomial q + C pushes * horizonPolynomial p q

@[simp] theorem pairLengthPolynomial_eval (q : Polynomial ℕ) (n : ℕ) :
    (pairLengthPolynomial q).eval n = 2 * n + q.eval n + 1 := by
  simp [pairLengthPolynomial]

@[simp] theorem horizonPolynomial_eval (p q : Polynomial ℕ) (n : ℕ) :
    (horizonPolynomial p q).eval n = p.eval (2 * n + q.eval n + 1) := by
  simp [horizonPolynomial, Polynomial.eval_comp]

@[simp] theorem capacityPolynomial_eval (p q : Polynomial ℕ) (pushes n : ℕ) :
    (capacityPolynomial p q pushes).eval n =
      2 * n + q.eval n + 1 + pushes * p.eval (2 * n + q.eval n + 1) := by
  simp [capacityPolynomial]

theorem paired_length_le (q : Polynomial ℕ) (n witnessLength : ℕ)
    (hw : witnessLength ≤ q.eval n) :
    2 * n + witnessLength + 1 ≤ (pairLengthPolynomial q).eval n := by
  rw [pairLengthPolynomial_eval]
  omega

theorem one_le_pairLength (q : Polynomial ℕ) (n : ℕ) :
    1 ≤ (pairLengthPolynomial q).eval n := by
  rw [pairLengthPolynomial_eval]
  omega

theorem pairLength_le_capacity (p q : Polynomial ℕ) (pushes n : ℕ) :
    (pairLengthPolynomial q).eval n ≤ (capacityPolynomial p q pushes).eval n := by
  simp only [capacityPolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C]
  exact Nat.le_add_right _ _

theorem one_le_capacity (p q : Polynomial ℕ) (pushes n : ℕ) :
    1 ≤ (capacityPolynomial p q pushes).eval n :=
  (one_le_pairLength q n).trans (pairLength_le_capacity p q pushes n)

theorem transition_prefix_le_capacity (p q : Polynomial ℕ) (pushes n inputLength used extra : ℕ)
    (hi : inputLength ≤ (pairLengthPolynomial q).eval n)
    (ht : used < (horizonPolynomial p q).eval n) (he : extra ≤ pushes) :
    inputLength + used * pushes + extra ≤ (capacityPolynomial p q pushes).eval n := by
  have hu := Nat.mul_le_mul_right pushes (Nat.succ_le_of_lt ht)
  simp only [capacityPolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C]
  calc
    inputLength + used * pushes + extra ≤
        (pairLengthPolynomial q).eval n + (used + 1) * pushes := by
      rw [Nat.add_mul, Nat.one_mul]
      omega
    _ ≤ (pairLengthPolynomial q).eval n + (horizonPolynomial p q).eval n * pushes :=
      Nat.add_le_add_left hu _
    _ = _ := by rw [Nat.mul_comm ((horizonPolynomial p q).eval n) pushes]

theorem verifier_time_le_horizon (p q : Polynomial ℕ) (n witnessLength : ℕ)
    (hw : witnessLength ≤ q.eval n) :
    p.eval (2 * n + witnessLength + 1) ≤ (horizonPolynomial p q).eval n := by
  rw [horizonPolynomial, Polynomial.eval_comp]
  exact MachineComposition.natPolynomial_eval_mono p (paired_length_le q n witnessLength hw)

theorem horizon_monotone (p q : Polynomial ℕ) :
    Monotone (fun n => (horizonPolynomial p q).eval n) :=
  fun _ _ h => MachineComposition.natPolynomial_eval_mono _ h

theorem capacity_monotone (p q : Polynomial ℕ) (pushes : ℕ) :
    Monotone (fun n => (capacityPolynomial p q pushes).eval n) :=
  fun _ _ h => MachineComposition.natPolynomial_eval_mono _ h

theorem execution_stack_length_le_capacity (tm : Turing.FinTM2)
    (p q : Polynomial ℕ) (n : ℕ) (input : List (tm.Γ tm.k₀))
    (hi : input.length ≤ (pairLengthPolynomial q).eval n)
    (finish : tm.Cfg) (budget : ℕ)
    (ht : budget ≤ (horizonPolynomial p q).eval n)
    (run : StateTransition.EvalsToInTime tm.step (Turing.initList tm input)
      (some finish) budget) (k : tm.K) :
    (finish.stk k).length ≤ (capacityPolynomial p q (Runtime.programPushBound tm)).eval n := by
  have hs := Runtime.executionSizeBound tm.step (fun cfg => (cfg.stk k).length)
    (Runtime.programPushBound tm) (Runtime.stepStackLength tm k) run
  have hinit := (Runtime.initialStackLength tm input k).trans hi
  have hg := Nat.mul_le_mul_right (Runtime.programPushBound tm) ht
  calc
    (finish.stk k).length ≤ ((Turing.initList tm input).stk k).length +
        budget * Runtime.programPushBound tm := hs
    _ ≤ (pairLengthPolynomial q).eval n +
        (horizonPolynomial p q).eval n * Runtime.programPushBound tm :=
      Nat.add_le_add hinit hg
    _ = _ := by simp [capacityPolynomial, Nat.mul_comm]

theorem stackCapacity_le_polynomial (tm : Turing.FinTM2)
    (p q : Polynomial ℕ) (n : ℕ) (input : List (tm.Γ tm.k₀))
    (hi : input.length ≤ (pairLengthPolynomial q).eval n) :
    BoundedExecution.stackCapacity tm input ((horizonPolynomial p q).eval n) ≤
      (capacityPolynomial p q (Runtime.programPushBound tm)).eval n := by
  simpa only [BoundedExecution.stackCapacity, capacityPolynomial,
    Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, Nat.mul_comm] using
    Nat.add_le_add_right hi ((horizonPolynomial p q).eval n * Runtime.programPushBound tm)

theorem run_stack_length_le_capacity (tm : Turing.FinTM2)
    (p q : Polynomial ℕ) (n : ℕ) (input : List (tm.Γ tm.k₀))
    (hi : input.length ≤ (pairLengthPolynomial q).eval n)
    (time : ℕ) (ht : time ≤ (horizonPolynomial p q).eval n) (k : tm.K) :
    ((BoundedExecution.run tm input time).stk k).length ≤
      (capacityPolynomial p q (Runtime.programPushBound tm)).eval n :=
  (BoundedExecution.run_stack_le tm input _ time ht k).trans
    (stackCapacity_le_polynomial tm p q n input hi)

theorem run_statement_budget_le_capacity (tm : Turing.FinTM2)
    (p q : Polynomial ℕ) (n : ℕ) (input : List (tm.Γ tm.k₀))
    (hi : input.length ≤ (pairLengthPolynomial q).eval n)
    (time : ℕ) (ht : time < (horizonPolynomial p q).eval n)
    (label : tm.Λ) (k : tm.K) :
    ((BoundedExecution.run tm input time).stk k).length +
        Runtime.statementPushBound (tm.m label) ≤
      (capacityPolynomial p q (Runtime.programPushBound tm)).eval n :=
  (BoundedExecution.statement_budget tm input _ time ht label k).trans
    (stackCapacity_le_polynomial tm p q n input hi)

noncomputable def configurationWidthPolynomial (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits : ℕ) : Polynomial ℕ :=
  C controlBits + capacityPolynomial p q pushes * C alphabetBits

noncomputable def transitionGatesPolynomial (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits expressionCost : ℕ) : Polynomial ℕ :=
  C expressionCost * configurationWidthPolynomial p q pushes controlBits alphabetBits

noncomputable def tableauGatesPolynomial (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits expressionCost : ℕ) : Polynomial ℕ :=
  horizonPolynomial p q *
    transitionGatesPolynomial p q pushes controlBits alphabetBits expressionCost

@[simp] theorem configurationWidthPolynomial_eval (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits n : ℕ) :
    (configurationWidthPolynomial p q pushes controlBits alphabetBits).eval n =
      controlBits + (capacityPolynomial p q pushes).eval n * alphabetBits := by
  simp [configurationWidthPolynomial]

@[simp] theorem transitionGatesPolynomial_eval (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits expressionCost n : ℕ) :
    (transitionGatesPolynomial p q pushes controlBits alphabetBits expressionCost).eval n =
      expressionCost * (controlBits + (capacityPolynomial p q pushes).eval n * alphabetBits) := by
  simp [transitionGatesPolynomial]

@[simp] theorem tableauGatesPolynomial_eval (p q : Polynomial ℕ)
    (pushes controlBits alphabetBits expressionCost n : ℕ) :
    (tableauGatesPolynomial p q pushes controlBits alphabetBits expressionCost).eval n =
      (horizonPolynomial p q).eval n * expressionCost *
        (controlBits + (capacityPolynomial p q pushes).eval n * alphabetBits) := by
  simp only [tableauGatesPolynomial, Polynomial.eval_mul, transitionGatesPolynomial_eval]
  exact (Nat.mul_assoc _ _ _).symm

noncomputable def formulaBitsPolynomial (varBound clauseBound : Polynomial ℕ) : Polynomial ℕ :=
  varBound + clauseBound + C 2 + clauseBound * (C 3 * (varBound + C 2))

@[simp] theorem formulaBitsPolynomial_eval (varBound clauseBound : Polynomial ℕ) (n : ℕ) :
    (formulaBitsPolynomial varBound clauseBound).eval n =
      varBound.eval n + clauseBound.eval n + 2 +
        clauseBound.eval n * (3 * (varBound.eval n + 2)) := by
  simp [formulaBitsPolynomial]

theorem formulaBits_length_le_polynomial (F : Target.Formula)
    (varBound clauseBound : Polynomial ℕ) (n : ℕ)
    (hv : F.variables ≤ varBound.eval n)
    (hc : F.clauses.length ≤ clauseBound.eval n) :
    (formulaBits F).length ≤ (formulaBitsPolynomial varBound clauseBound).eval n := by
  refine (formulaBits_length_le F).trans ?_
  rw [formulaBitsPolynomial_eval]
  exact Nat.add_le_add
    (Nat.add_le_add_right (Nat.add_le_add hv hc) 2)
    (Nat.mul_le_mul hc (Nat.mul_le_mul_left 3 (Nat.add_le_add_right hv 2)))

noncomputable def circuitVariablesPolynomial (inputs gates : Polynomial ℕ) : Polynomial ℕ :=
  inputs + gates

noncomputable def circuitClausesPolynomial (gates : Polynomial ℕ) : Polynomial ℕ :=
  C 3 * gates + 1

noncomputable def circuitBitsPolynomial (inputs gates : Polynomial ℕ) : Polynomial ℕ :=
  formulaBitsPolynomial (circuitVariablesPolynomial inputs gates)
    (circuitClausesPolynomial gates)

@[simp] theorem circuitVariablesPolynomial_eval (inputs gates : Polynomial ℕ) (n : ℕ) :
    (circuitVariablesPolynomial inputs gates).eval n = inputs.eval n + gates.eval n := by
  simp [circuitVariablesPolynomial]

@[simp] theorem circuitClausesPolynomial_eval (gates : Polynomial ℕ) (n : ℕ) :
    (circuitClausesPolynomial gates).eval n = 3 * gates.eval n + 1 := by
  simp [circuitClausesPolynomial]

@[simp] theorem circuitBitsPolynomial_eval (inputs gates : Polynomial ℕ) (n : ℕ) :
    (circuitBitsPolynomial inputs gates).eval n =
      (inputs.eval n + gates.eval n) + (3 * gates.eval n + 1) + 2 +
        (3 * gates.eval n + 1) * (3 * ((inputs.eval n + gates.eval n) + 2)) := by
  simp [circuitBitsPolynomial]

theorem circuit_formulaBits_length_le (F : Target.Formula) (inputCount gateCount : ℕ)
    (hv : F.variables ≤ inputCount + gateCount)
    (hc : F.clauses.length ≤ 3 * gateCount + 1) :
    (formulaBits F).length ≤
      (inputCount + gateCount) + (3 * gateCount + 1) + 2 +
        (3 * gateCount + 1) * (3 * ((inputCount + gateCount) + 2)) := by
  exact (formulaBits_length_le F).trans
    (Nat.add_le_add (Nat.add_le_add_right (Nat.add_le_add hv hc) 2)
      (Nat.mul_le_mul hc (Nat.mul_le_mul_left 3 (Nat.add_le_add_right hv 2))))

theorem circuit_formulaBits_length_le_polynomial (F : Target.Formula)
    (inputCount gateCount : ℕ) (inputs gates : Polynomial ℕ) (n : ℕ)
    (hi : inputCount ≤ inputs.eval n) (hg : gateCount ≤ gates.eval n)
    (hv : F.variables ≤ inputCount + gateCount)
    (hc : F.clauses.length ≤ 3 * gateCount + 1) :
    (formulaBits F).length ≤ (circuitBitsPolynomial inputs gates).eval n := by
  apply formulaBits_length_le_polynomial
  · simpa using hv.trans (Nat.add_le_add hi hg)
  · simpa using hc.trans (Nat.add_le_add_right (Nat.mul_le_mul_left 3 hg) 1)

theorem toFormula_bits_length_le (circuit : Circuit) :
    (formulaBits circuit.toFormula).length ≤
      (circuit.inputs + circuit.gates.length) + (3 * circuit.gates.length + 1) + 2 +
        (3 * circuit.gates.length + 1) *
          (3 * ((circuit.inputs + circuit.gates.length) + 2)) :=
  circuit_formulaBits_length_le circuit.toFormula circuit.inputs circuit.gates.length
    (Circuit.toFormula_variables circuit).le (Circuit.toFormula_clause_count circuit).le

theorem toFormula_bits_length_le_polynomial (circuit : Circuit)
    (inputs gates : Polynomial ℕ) (n : ℕ)
    (hi : circuit.inputs ≤ inputs.eval n) (hg : circuit.gates.length ≤ gates.eval n) :
    (formulaBits circuit.toFormula).length ≤ (circuitBitsPolynomial inputs gates).eval n :=
  circuit_formulaBits_length_le_polynomial circuit.toFormula circuit.inputs circuit.gates.length
    inputs gates n hi hg
    (Circuit.toFormula_variables circuit).le (Circuit.toFormula_clause_count circuit).le

end BinPackingGames.Foundations.Complexity.CookLevin.Bounds

end OAI