lean/OAI/Combinatorics/MatchingCount/Arithmetic/TreeAdaptiveArithmetic.lean

import Mathlib
import OAI.Combinatorics.MatchingCount.Algorithm.RationalEstimator
import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCount
import OAI.Combinatorics.MatchingCount.Algorithm.TreeEstimator
import OAI.Combinatorics.MatchingCount.Algorithm.TreeScalingCorrect
import OAI.Combinatorics.MatchingCount.Algorithm.TreeReweight

namespace OAI

namespace MatchingFPRAS.ExecutableAdaptive
open TreeTyped TreeFraction ExecutableBottleneck ExecutableScaling ExecutableEstimator ExecutableLadder

abbrev ProbeTable := List ((ℕ×ℕ)×Fraction)
abbrev MatrixData := (ℕ×Fraction)×ProbeTable

def orderedPair (x : ℕ×ℕ) : ℕ×ℕ := if x.1<x.2 then x else (x.2,x.1)
def orderedPairRealizer : Realizer orderedPair := (choose less identity (pair second first)).congr (by
  intro x; simp [orderedPair])
lemma polynomial_orderedPair : PolynomialTime orderedPairRealizer := by
  unfold orderedPairRealizer; apply polynomial_congr; tree_cost

def probeValue (x : ProbeTable×(ℕ×ℕ)) : Fraction :=
  if x.2.1=x.2.2 then (0,1) else lookup (0,1) (x.1,orderedPair x.2)
def probeValueRealizer : Realizer probeValue := (choose (composition second natEqual) (constant (0,1))
  (composition (pair first (composition second orderedPairRealizer))
     (lookupRealizer (0,1) (pairEqual natEqual natEqual)))).congr (by intro x; simp [probeValue])
lemma polynomial_probeValue : PolynomialTime probeValueRealizer := by
  unfold probeValueRealizer; apply polynomial_congr
  have := polynomial_orderedPair
  have := polynomial_lookup ((0,1) : Fraction) (polynomial_pairEqual polynomial_natEqual polynomial_natEqual)
  tree_cost

def estimateCell (x : MatrixData×(ℕ×ℕ)) : Fraction :=
  upper (x.1.1.1,(x.1.1.2,probeValue (x.1.2,x.2)))
def estimateCellRealizer : Realizer estimateCell := (composition
  (pair first.fst.fst (pair first.fst.snd (composition (pair first.snd second) probeValueRealizer))) upperRealizer).congr (fun _=>rfl)
lemma polynomial_estimateCell : PolynomialTime estimateCellRealizer := by
  unfold estimateCellRealizer Realizer.fst Realizer.snd; apply polynomial_congr
  have := polynomial_probeValue
  have := polynomial_upper
  tree_cost

def estimateRow (x : (MatrixData×List ℕ)×ℕ) : List Fraction :=
  x.1.2.map (fun j=>estimateCell (x.1.1,(x.2,j)))
def estimateRowRealizer : Realizer estimateRow := (composition
  (pair (pair first.fst second) first.snd)
  (mapWith (composition (pair first.fst (pair first.snd second)) estimateCellRealizer))).congr (fun _=>rfl)
lemma polynomial_estimateRow : PolynomialTime estimateRowRealizer := by
  unfold estimateRowRealizer Realizer.fst Realizer.snd; apply polynomial_congr
  have := polynomial_estimateCell
  tree_cost

def estimateMatrix (x : MatrixData×List ℕ) : Matrix := x.2.map (fun i=>estimateRow (x,i))
def estimateMatrixRealizer : Realizer estimateMatrix := composition (pair identity second) (mapWith estimateRowRealizer)
lemma polynomial_estimateMatrix : PolynomialTime estimateMatrixRealizer :=
  polynomial_composition (polynomial_pair polynomial_identity polynomial_second)
    (polynomial_mapWith polynomial_estimateRow)

def multiplyVector (x : Vector×Vector) : Vector :=
  x.1.map (fun z=>(z.1,mul (z.2,lookup (1,1) (x.2,z.1))))
def multiplyVectorRealizer : Realizer multiplyVector := (composition (pair second first)
  (mapWith (pair second.fst (composition (pair second.snd
    (composition (pair first second.fst) (lookupRealizer (1,1) natEqual))) mulRealizer)))).congr (fun _=>rfl)
lemma polynomial_multiplyVector : PolynomialTime multiplyVectorRealizer := by
  unfold multiplyVectorRealizer Realizer.fst Realizer.snd; apply polynomial_congr
  have := polynomial_lookup ((1,1) : Fraction) polynomial_natEqual
  have := polynomial_mul
  tree_cost

def updateVector (x : Matrix×Vector) : Vector := multiplyVector (x.2,scale x.1)
def updateVectorRealizer : Realizer updateVector := (composition
  (pair (second : Realizer (Prod.snd : Matrix×Vector→Vector))
    (composition (first : Realizer (Prod.fst : Matrix×Vector→Matrix)) scaleRealizer)) multiplyVectorRealizer).congr (fun _=>rfl)
lemma polynomial_updateVector : PolynomialTime updateVectorRealizer := by
  unfold updateVectorRealizer
  apply polynomial_congr
  exact polynomial_composition (polynomial_pair polynomial_second
    (polynomial_composition polynomial_first polynomial_scale)) polynomial_multiplyVector

lemma orderedPair_fin {n : ℕ} (i j : Fin n) (h : i≠j) :
    orderedPair (i.val,j.val)=ExecutableSource.logicalRepr (Enlargement.pairEdge i j h) := by
  unfold orderedPair Enlargement.pairEdge ExecutableSource.logicalRepr
  by_cases hij : i<j
  · simp [show i.val<j.val from hij,min_eq_left hij.le,max_eq_right hij.le]
  · have hji : j ≤ i :=le_of_not_gt hij
    simp [show ¬ i.val<j.val from hij,min_eq_right hji,max_eq_left hji]
lemma probeValue_rep {n : ℕ} (z : Enlargement.LogicalEdge (Fin n)→ℚ) (tab : ProbeTable)
    (ht : ∀ e,lookup (0,1) (tab,ExecutableSource.logicalRepr e)=TreeFraction.repr (z e))
    (i j : Fin n) :
    probeValue (tab,(i.val,j.val))=TreeFraction.repr (FiniteTrial.probeMatrix z i j) := by
  unfold probeValue FiniteTrial.probeMatrix
  by_cases he : i=j
  · subst j; simp; rfl
  · have hv : i.val≠j.val:=fun h=>he (Fin.ext h)
    simp only [ite_eq_right hv,dite_eq_right he]
    rw [orderedPair_fin i j he,ht]

lemma estimateMatrix_rep {n : ℕ} (D : ℕ) (d : ℚ) (hd : 0≤d)
    (z : Enlargement.LogicalEdge (Fin n)→ℚ) (hz : ∀ e,0≤z e) (tab : ProbeTable)
    (ht : ∀ e,lookup (0,1) (tab,ExecutableSource.logicalRepr e)=TreeFraction.repr (z e)) :
    estimateMatrix (((D,TreeFraction.repr d),tab),List.range n)=
      matrixRep (FiniteTrial.estimateMatrix D d z) := by
  unfold estimateMatrix estimateRow matrixRep
  simp only [ExecutableDP.map_range_ofFn]
  congr 1
  funext i
  congr 1
  funext j
  unfold estimateCell
  rw [probeValue_rep z tab ht i j]
  apply upper_rep _ _ _ hd
  unfold FiniteTrial.probeMatrix
  split_ifs
  · exact le_rfl
  · exact hz _

lemma multiplyVector_rep {n : ℕ} (a b : Fin n→ℚ) (ha : ∀ i,0≤a i) (hb : ∀ i,0≤b i) :
    multiplyVector (vectorRep a,vectorRep b)=vectorRep (fun i=>a i*b i) := by
  unfold multiplyVector vectorRep
  rw [List.map_ofFn]
  congr 1
  funext i
  dsimp only [Function.comp_def]
  congr 1
  rw [List.ofFn_eq_map,lookup_image (1,1) (List.finRange n) Fin.val
    (fun j=>TreeFraction.repr (b j)) Fin.val_injective i (by simp),mul_repr (ha i) (hb i)]

lemma updateVector_rep {n : ℕ} (hn : 2≤n) (G : Fin n→Fin n→ℚ)
    (hsym : ∀ i j,G i j=G j i)
    (hG : ∀ i j,i≠j→ Counting.alpha≤G i j ∧ G i j≤3)
    (a : Fin n→ℚ) (ha : ∀ i,0≤a i) :
    updateVector (matrixRep G,vectorRep a)=vectorRep (fun i=>a i*Counting.scalingTrace hn G n i) := by
  unfold updateVector
  rw [scale_rep hn G hsym hG]
  apply multiplyVector_rep a _ ha
  intro i
  exact ((Counting.scalingTrace_invariant hn G hsym hG n).1.pos i).le
end MatchingFPRAS.ExecutableAdaptive

end OAI