math / data /lean /OAI /Algebra /FormulaHitting /BitModel.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
4.63 kB
import Mathlib.Data.Nat.Size
import Mathlib.Data.List.Range
import Mathlib.Algebra.BigOperators.Group.List.Basic
namespace OAI
namespace NCHitting.BitModel
def width (n : ℕ) : ℕ := n.size + 1
def addCost (a b : ℕ) : ℕ := 4 * (width a + width b)
def mulCost (a b : ℕ) : ℕ := 8 * width a * width b
def compareCost (a b : ℕ) : ℕ := 2 * (width a + width b)
def listBits (xs : List ℕ) : ℕ := (xs.map width).sum
structure NatResult where
value : ℕ
cost : ℕ
deriving DecidableEq, Repr
def powerRun (base : ℕ) : ℕ → NatResult
| 0 => ⟨1, width 1⟩
| k + 1 =>
let previous := powerRun base k
⟨previous.value * base,
previous.cost + mulCost previous.value base + addCost k 1 + 1⟩
@[simp] theorem powerRun_value (base k : ℕ) : (powerRun base k).value = base ^ k := by
induction k with
| zero => rfl
| succ k ih => simp [powerRun, ih, pow_succ]
inductive Expr where
| literal : ℕ → Expr
| read : ℕ → Expr
| add : Expr → Expr → Expr
| sub : Expr → Expr → Expr
| mul : Expr → Expr → Expr
| power : Expr → Expr → Expr
| less : Expr → Expr → Expr
| equal : Expr → Expr → Expr
| odd : Expr → Expr
deriving DecidableEq, Repr
def Expr.run (environment : List ℕ) : Expr → NatResult
| .literal n => ⟨n, width n + 1⟩
| .read index =>
⟨environment[index]?.getD 0,
width index + listBits (environment.take (index + 1)) + 1⟩
| .add a b =>
let x := a.run environment
let y := b.run environment
⟨x.value + y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
| .sub a b =>
let x := a.run environment
let y := b.run environment
⟨x.value - y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
| .mul a b =>
let x := a.run environment
let y := b.run environment
⟨x.value * y.value, x.cost + y.cost + mulCost x.value y.value + 1⟩
| .power a b =>
let x := a.run environment
let y := b.run environment
let z := powerRun x.value y.value
⟨z.value, x.cost + y.cost + z.cost + 1⟩
| .less a b =>
let x := a.run environment
let y := b.run environment
⟨if x.value < y.value then 1 else 0,
x.cost + y.cost + compareCost x.value y.value + 1⟩
| .equal a b =>
let x := a.run environment
let y := b.run environment
⟨if x.value = y.value then 1 else 0,
x.cost + y.cost + compareCost x.value y.value + 1⟩
| .odd a =>
let x := a.run environment
⟨x.value % 2, x.cost + 2⟩
structure RationalCode where
negative : Bool
numerator : ℕ
denominator : ℕ
deriving DecidableEq, Repr
def RationalCode.bits (entry : RationalCode) : ℕ :=
1 + width entry.numerator + width entry.denominator
def outputBits (entries : List RationalCode) : ℕ := (entries.map RationalCode.bits).sum
inductive Program where
| skip : Program
| emit : Expr → Expr → Expr → Program
| sequence : Program → Program → Program
| branch : Expr → Program → Program → Program
| loop : Expr → Program → Program
deriving DecidableEq, Repr
structure ProgramResult where
output : List RationalCode
cost : ℕ
deriving DecidableEq, Repr
def Program.run (environment : List ℕ) : Program → ProgramResult
| .skip => ⟨[], 1⟩
| .emit sign numerator denominator =>
let s := sign.run environment
let a := numerator.run environment
let b := denominator.run environment
let entry : RationalCode := ⟨decide (s.value % 2 = 1), a.value, b.value⟩
⟨[entry], s.cost + a.cost + b.cost + entry.bits + 2⟩
| .sequence p q =>
let x := p.run environment
let y := q.run environment
⟨x.output ++ y.output, x.cost + y.cost + outputBits x.output + 1⟩
| .branch test yes no =>
let t := test.run environment
let result := if t.value = 0 then no.run environment else yes.run environment
⟨result.output, t.cost + result.cost + 1⟩
| .loop bound body =>
let b := bound.run environment
let iterations := (List.range b.value).map fun index =>
let result := body.run (index :: environment)
(result, width index + addCost index 1 + 1)
⟨iterations.flatMap (fun result => result.1.output),
b.cost + 1 + (iterations.map fun result =>
result.1.cost + result.2 + outputBits result.1.output).sum⟩
def execute (program : Program) (inputs : List ℕ) : ProgramResult :=
let result := program.run inputs
⟨result.output, listBits inputs + result.cost⟩
end NCHitting.BitModel
end OAI