import Mathlib
import OAI.Combinatorics.MatchingCount.Machines.TreeReach
import OAI.Combinatorics.MatchingCount.Machines.TreeStateTable

namespace OAI

namespace MatchingFPRAS.ExecutableLadder
open TreeTyped Polynomial

variable {I E : Type} [Codec I] [Codec E] [DecidableEq I] [Inhabited I] [LinearOrder E]
abbrev StateEnvelope (I E : Type) := List I×Finset E

def normalizeState (x : StateEnvelope I E×StateTable I (Finset E)) : StateTable I (Finset E) :=
  x.1.1.map (fun i=>(i,lookup ∅ (x.2,i)∩x.1.2))
def normalizeStateRealizer (Eq : Realizer (fun x : I×I=>decide (x.1=x.2)))
    (EqE : Realizer (fun x : E×E=>decide (x.1=x.2))) : Realizer (normalizeState (I:=I) (E:=E)) :=
  (composition (pair identity first.fst) (mapWith (pair second
    (composition (pair (composition (pair first.snd second) (lookupRealizer ∅ Eq)) first.fst.snd)
      (finsetInter EqE))))).congr (fun _=>rfl)
lemma polynomial_normalizeState {Eq : Realizer (fun x : I×I=>decide (x.1=x.2))}
    {EqE : Realizer (fun x : E×E=>decide (x.1=x.2))}
    (hEq : PolynomialTime Eq) (hE : PolynomialTime EqE) : PolynomialTime (normalizeStateRealizer Eq EqE) := by
  unfold normalizeStateRealizer Realizer.fst Realizer.snd
  apply polynomial_congr
  have := polynomial_lookup (∅ : Finset E) hEq
  tree_cost

omit [Inhabited I] in
lemma normalizeState_weight (keys : List I) (univ : Finset E) (s : StateTable I (Finset E)) :
    weight (normalizeState ((keys,univ),s))≤(weight keys+1)*(weight univ+3) := by
  induction keys with
  | nil=>simp only [normalizeState,List.map_nil,weight_nil]; omega
  | cons i keys ih=>
    have hu : weight (lookup ∅ (s,i)∩univ)≤weight univ := weight_finset_subset Finset.inter_subset_right
    change weight ((i,lookup ∅ (s,i)∩univ)::normalizeState ((keys,univ),s))≤_
    rw [weight_cons,weight_prod,weight_cons]
    nlinarith

omit [Codec I] [Codec E] [Inhabited I] in
lemma normalizeState_rep {Ω : Type} (keys : List I) (univ : Finset E) (e : Ω→Finset E)
    (he : ∀ a,e a⊆univ) (s : I→Ω) :
    normalizeState ((keys,univ),stateRep keys (e ∘ s))=stateRep keys (e ∘ s) := by
  unfold normalizeState stateRep
  apply List.map_congr_left
  intro i hi
  change (i,lookup ∅ (stateRep keys (e ∘ s),i)∩univ)=(i,e (s i))
  rw [lookup_stateRep ∅ keys (e ∘ s) i hi]
  simp only [Function.comp_apply,Finset.inter_eq_left.mpr (he (s i))]
end MatchingFPRAS.ExecutableLadder

end OAI