lean/OAI/Computability/MeanPayoff/Model.lean

import Mathlib

namespace OAI

namespace MeanPayoff
structure Game where
  n : ℕ
  positive : 0 < n
  m : ℕ
  tail : Fin m → Fin n
  head : Fin m → Fin n
  maxOwner : Fin n → Bool
  weight : Fin m → ℤ
  total : ∀ v : Fin n, ∃ e : Fin m, tail e = v

def Strategy (G : Game) :=
  List (Fin G.m) → (v : Fin G.n) → {e : Fin G.m // G.tail e = v}

def move (G : Game) (σ τ : Strategy G) (v : Fin G.n)
    (history : List (Fin G.m)) : Fin G.m :=
  if G.maxOwner v then (σ history v).val else (τ history v).val

def position (G : Game) (σ τ : Strategy G) (start : Fin G.n) :
    ℕ → Fin G.n × List (Fin G.m)
  | 0 => (start, [])
  | t + 1 =>
    let p := position G σ τ start t
    let e := move G σ τ p.1 p.2
    (G.head e, p.2 ++ [e])

def play (G : Game) (σ τ : Strategy G) (start : Fin G.n) (t : ℕ) : Fin G.m :=
  let p := position G σ τ start t
  move G σ τ p.1 p.2

noncomputable def meanPayoff (G : Game) (π : ℕ → Fin G.m) : ℝ :=
  Filter.liminf (fun T : ℕ =>
    (∑ j ∈ Finset.range T, (G.weight (π j) : ℝ)) / (T : ℝ)) Filter.atTop

def Winning (G : Game) (v : Fin G.n) : Prop :=
  ∃ σ : Strategy G, ∀ τ : Strategy G, 0 ≤ meanPayoff G (play G σ τ v)

def encodeNat (n : ℕ) : List Bool :=
  let bits := Nat.bits (n + 1)
  List.replicate bits.length true ++ [false] ++ bits

def encodeInt (z : ℤ) : List Bool :=
  decide (z < 0) :: encodeNat z.natAbs

def input (G : Game) : List Bool :=
  encodeNat G.n ++ encodeNat G.m ++ List.ofFn G.maxOwner ++
    (List.ofFn (fun e : Fin G.m =>
      encodeNat ((G.tail e).val + 1) ++ encodeNat ((G.head e).val + 1) ++
        encodeInt (G.weight e))).flatten

abbrev Symbol := Option Bool

inductive Direction where
  | left | stay | right
  deriving DecidableEq

def Direction.offset : Direction → ℤ
  | .left => -1
  | .stay => 0
  | .right => 1

structure Action (q : ℕ) where
  next : Fin q
  write : Fin 3 → Symbol
  shift : Fin 3 → Direction

structure Machine where
  states : ℕ
  start : Fin states
  transition : Fin states → (Fin 3 → Symbol) → Bool → Option (Action states)

structure Configuration (M : Machine) where
  control : Option (Fin M.states)
  head : Fin 3 → ℤ
  tape : Fin 3 → ℤ → Symbol

def initial (M : Machine) (code : List Bool) : Configuration M where
  control := some M.start
  head := fun _ => 0
  tape := fun k j => if k = 0 ∧ 0 ≤ j then code[j.toNat]? else none

def step (M : Machine) (c : Configuration M) (bit : Bool) : Configuration M :=
  match c.control with
  | none => c
  | some s =>
    match M.transition s (fun k => c.tape k (c.head k)) bit with
    | none => { c with control := none }
    | some a =>
      { control := some a.next
        head := fun k => c.head k + (a.shift k).offset
        tape := fun k => Function.update (c.tape k) (c.head k) (a.write k) }

def run (M : Machine) (code : List Bool) (random : ℕ → Bool) : ℕ → Configuration M
  | 0 => initial M code
  | t + 1 => step M (run M code random t) (random t)

def padBits {T : ℕ} (bits : Fin T → Bool) (j : ℕ) : Bool :=
  if h : j < T then bits ⟨j, h⟩ else false

def result (M : Machine) (G : Game) (T : ℕ) (bits : Fin T → Bool) : Configuration M :=
  run M (input G) (padBits bits) T

def CorrectOutput (G : Game) {M : Machine} (c : Configuration M) : Prop :=
  c.control = none ∧
  (∀ v : Fin G.n, c.tape 2 (v.val : ℤ) = some true ↔ Winning G v) ∧
  (∀ v : Fin G.n, c.tape 2 (v.val : ℤ) = some false ↔ ¬ Winning G v) ∧
  ∀ j : ℤ, (j < 0 ∨ (G.n : ℤ) ≤ j) → c.tape 2 j = none

noncomputable def MainClaim : Prop := by
  classical
  exact ∃ M : Machine, ∃ C : ℝ, 0 < C ∧ ∀ G : Game, ∃ T : ℕ,
    (T : ℝ) ≤ (2 : ℝ) ^ (C * (Real.logb 2 ((input G).length + 2)) ^ 2) ∧
    (∀ bits : Fin T → Bool, (result M G T bits).control = none) ∧
    7 * 2 ^ T ≤ 8 * (Finset.univ.filter
      (fun bits : Fin T → Bool => CorrectOutput G (result M G T bits))).card


def Deterministic (M : Machine) : Prop :=
  ∀ s cells, M.transition s cells true = M.transition s cells false
def DeterministicMainClaim : Prop :=
  ∃ M : Machine, Deterministic M ∧ ∃ C : ℝ, 0 < C ∧ ∀ G : Game, ∃ T : ℕ,
    (T : ℝ) ≤ (2 : ℝ) ^ (C * (Real.logb 2 ((input G).length + 2)) ^ 2) ∧
    CorrectOutput G (run M (input G) (fun _ => false) T)
end MeanPayoff

end OAI