lean/OAI/Computability/MatchingCount/BinaryAlgorithm.lean

import OAI.Computability.MatchingCount.OddMincut

namespace OAI

section

namespace BinaryMatching.Algorithm
open Finset
variable {n : ℕ}

abbrev Table (n : ℕ) (α : Type) := Vector (Vector α n) n

def tabulate {α : Type} (f : Fin n → Fin n → α) : Table n α :=
  Vector.ofFn (fun i => Vector.ofFn (f i))

def entry {α : Type} (a : Table n α) (e : Pair n) : α := a[e.val.1][e.val.2]

@[simp] theorem at_tabulate {α : Type} (f : Fin n → Fin n → α) (e : Pair n) :
    entry (tabulate f) e=f e.val.1 e.val.2 := by simp [entry,tabulate]

def toTable {α : Type} [Zero α] (f : Pair n → α) : Table n α :=
  tabulate (fun i j => if h : i < j then f ⟨(i,j),h⟩ else 0)

@[simp] theorem at_toTable {α : Type} [Zero α] (f : Pair n → α) (e : Pair n) :
    entry (toTable f) e=f e := by simp [at_tabulate,toTable,e.property]

def capacities (a : Table n ℤ) (i j : Fin n) : ℕ :=
  if i < j then (a[i][j]).toNat else if j < i then (a[j][i]).toNat else 0

def q (n : ℕ) : ℕ := Fintype.card (Pair n)
def K (n : ℕ) : ℕ := Nat.clog 2 (q n)
def B (G : Input) : ℕ := (G.records.map (fun e => Nat.log2 e.multiplicity)).foldl max 0
def L (G : Input) : ℕ := 100*(G.n+B G+1)^3
def A₀ (n : ℕ) : ℕ := 10*n^2
def M₀ (G : Input) : ℕ := q G.n*(K G.n+L G)*(2+A₀ G.n)
def D₀ (G : Input) : ℕ := q G.n*(K G.n+L G+M₀ G)^2

def beta (G : Input) (e : Pair G.n) : ℤ :=
  if multiplicity G e=0 then -(L G:ℤ) else (Nat.log2 (multiplicity G e):ℤ)

structure Piece where
  slope : ℤ
  constant : ℚ
  deriving Inhabited, DecidableEq

def Piece.eval (p : Piece) (t : ℚ) : ℚ := p.slope*t+p.constant

def pieces (k : ℕ) : List Piece :=
  (List.range k).map (fun j => ⟨(j:ℤ)-1,(2:ℚ)⁻¹^j⟩) ++ [⟨k,0⟩]

def selectedPiece (k : ℕ) (t : ℚ) : Piece :=
  ((pieces k).argmin (fun p => p.eval t)).getD ⟨k,0⟩

def psi (k : ℕ) (t : ℚ) : ℚ := (selectedPiece k t).eval t

def slope (k : ℕ) (t : ℚ) : ℤ := (selectedPiece k t).slope

structure Affine (n : ℕ) where
  coeff : Pair n → ℤ
  constant : ℤ

def Affine.eval (a : Affine n) (x : Pair n → ℚ) : ℚ :=
  (∑ e, (a.coeff e:ℚ)*x e)+a.constant

def zeroRow : Affine n := ⟨fun _ => 0,0⟩
def degreeRow (v : Fin n) (positive : Bool) : Affine n :=
  ⟨fun e => if e.val.1=v ∨ e.val.2=v then (if positive then 1 else -1) else 0,
    if positive then -1 else 1⟩
def cutRow (S : Finset (Fin n)) : Affine n :=
  ⟨fun e => if (e.val.1∈S ∧ e.val.2∉S) ∨ (e.val.2∈S ∧ e.val.1∉S) then -1 else 0,1⟩

def activeRows (a : Table n ℤ) : List (Affine n) :=
  zeroRow :: ((List.finRange n).flatMap (fun v => [degreeRow v true,degreeRow v false])) ++
    [cutRow (OddMincut.oddCut (capacities a) univ)]

def coordinates (D : ℕ) (a : Table n ℤ) (e : Pair n) : ℚ := entry a e/(D:ℚ)

def activeRow (D : ℕ) (a : Table n ℤ) : Affine n :=
  ((activeRows a).argmax (fun r => r.eval (coordinates D a))).getD zeroRow

def trialValue (G : Input) (a : Table G.n ℤ) (r : Affine G.n) : ℚ :=
  (∑ e, (psi (K G.n) (coordinates (D₀ G) a e)+(beta G e:ℚ)*coordinates (D₀ G) a e)) -
    (M₀ G:ℚ)*r.eval (coordinates (D₀ G) a)

def gradient (G : Input) (a : Table G.n ℤ) (r : Affine G.n) (e : Pair G.n) : ℤ :=
  slope (K G.n) (coordinates (D₀ G) a e)+beta G e-(M₀ G:ℤ)*r.coeff e

def update (G : Input) (a : Table G.n ℤ) (r : Affine G.n) : Table G.n ℤ :=
  toTable (fun e => min (D₀ G:ℤ) (max 0 (entry a e+gradient G a r e)))

structure State (n : ℕ) where
  numerators : Table n ℤ
  best : Option ℚ

def step (G : Input) (s : State G.n) : State G.n :=
  let r := activeRow (D₀ G) s.numerators
  let value := trialValue G s.numerators r
  ⟨update G s.numerators r, some (s.best.elim value (max value))⟩

def initial (n : ℕ) : State n := ⟨tabulate (fun _ _ => 0),none⟩

def iterate (G : Input) : ℕ → State G.n
  | 0 => initial G.n
  | t+1 => step G (iterate G t)

def R (G : Input) : ℤ := ⌊((iterate G (q G.n*D₀ G)).best).getD 0⌋

def estimate (G : Input) : ℕ :=
  let r := R G
  if r < -10*(G.n:ℤ) then 0 else 2^(r-5*(G.n:ℤ)).toNat

def covered (G : Input) : Finset ℕ :=
  ((G.records.filter (fun e => 0<e.multiplicity)).flatMap (fun e => [e.left,e.right])).toFinset

def rawMultiplicity (G : Input) (i j : ℕ) : ℕ :=
  ((G.records.find? (fun r => r.left=i && r.right=j)).map Record.multiplicity).getD 0

def approximate (G : Input) : ℕ :=
  if G.n=0 then 1 else
  if Odd G.n then 0 else
  if G.n=2 then rawMultiplicity G 0 1 else
  if (covered G).card<G.n then 0 else estimate G

end BinaryMatching.Algorithm
end

end OAI