import Mathlib
import OAI.Combinatorics.KServer.JointBudget
import OAI.Combinatorics.KServer.MetricService

namespace OAI

/-! Pushing the actual finite rounded law onto one fixed finite state space. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TreeRounding
attribute [local instance] Classical.propDecidable Classical.decEq
variable {α S:Type} [Fintype S]

def Law.mass (L:Law α) (f:α→S) (s:S):ℝ:=L.avg (fun a=>if f a=s then 1 else 0)
omit [Fintype S] in
lemma Law.mass_nonneg (L:Law α) (f:α→S) (s:S):0≤ L.mass f s:=by
  unfold Law.mass Law.avg
  exact sum_nonneg (fun ω _=>mul_nonneg (L.nonneg ω) (by dsimp only; split_ifs <;> norm_num))
lemma Law.mass_sum (L:Law α) (f:α→S):(∑ s,L.mass f s)=1:=by
  unfold Law.mass Law.avg
  rw [sum_comm]
  simp only [←mul_sum,sum_ite_eq,mem_univ,ite_true,mul_one,L.total]
lemma Law.mass_average (L:Law α) (f:α→S) (g:S→ℝ):
    (∑ s,L.mass f s*g s)=L.avg (fun a=>g (f a)):=by
  unfold Law.mass Law.avg
  simp only [sum_mul]
  rw [sum_comm]
  apply sum_congr rfl
  intro ω _
  simp only [mul_assoc,mul_ite,one_mul,zero_mul,ite_mul,mul_zero,sum_ite_eq,mem_univ,ite_true]
omit [Fintype S] in
lemma Law.mass_support (L:Law α) (f:α→S) {s:S} (hs:0<L.mass f s):∃ ω,f (L.point ω)=s:=by
  by_contra hn
  have he:∀ ω,f (L.point ω)≠s:=by simpa only [not_exists] using hn
  have hh:L.mass f s=0:=by simp only [Law.mass,Law.avg,he,ite_false,mul_zero,sum_const_zero]
  rw [hh] at hs
  exact lt_irrefl _ hs

def Law.distribution (L:Law α) (f:α→S):FiniteDistribution S:=
  ⟨L.mass f,L.mass_nonneg f,L.mass_sum f⟩

omit [Fintype S] in
lemma Law.mass_left {T:Type} [Fintype T] (L:Law α) (f:α→S) (g:α→T) (s:S):
    (∑ z:T,L.mass (fun a=>(f a,g a)) (s,z))=L.mass f s:=by
  unfold Law.mass Law.avg
  rw [sum_comm]
  apply sum_congr rfl
  intro ω _
  rw [←mul_sum]
  congr 1
  by_cases h:f (L.point ω)=s
  · simp only [Prod.mk.injEq,h,true_and,ite_true,sum_ite_eq,mem_univ,ite_true]
  · simp only [Prod.mk.injEq,h,false_and,ite_false,sum_const_zero]

lemma Law.mass_right {T:Type} [Fintype T] (L:Law α) (f:α→S) (g:α→T) (z:T):
    (∑ s:S,L.mass (fun a=>(f a,g a)) (s,z))=L.mass g z:=by
  unfold Law.mass Law.avg
  rw [sum_comm]
  apply sum_congr rfl
  intro ω _
  rw [←mul_sum]
  congr 1
  by_cases h:g (L.point ω)=z
  · simp only [Prod.mk.injEq,h,and_true,ite_true,sum_ite_eq,mem_univ,ite_true]
  · simp only [Prod.mk.injEq,h,and_false,ite_false,sum_const_zero]
end KServer.TreeRounding

end


/-! Explicit causal finite-state implementation of a family of consecutive
couplings. Only the two prescribed marginals are supplied, not a cost conclusion. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CausalCouplings
attribute [local instance] Classical.propDecidable Classical.decEq
variable {X S:Type} [Fintype S] [Nonempty S]

structure Family (X S:Type) [Fintype S] where
  marginal:List X→ S→ ℝ
  nonneg:∀ h s,0≤ marginal h s
  normalized:∀ h,∑ s,marginal h s=1
  joint:List X→ X→ S→ S→ ℝ
  joint_nonneg:∀ h r s z,0≤ joint h r s z
  left:∀ h r s,∑ z,joint h r s z=marginal h s
  right:∀ h r z,∑ s,joint h r s z=marginal (h++[r]) z

variable (F:Family X S)
def kernel (h:List X) (r:X) (s z:S):ℝ:=
  if 0<F.marginal h s then F.joint h r s z/F.marginal h s else if z=Classical.choice ‹Nonempty S› then 1 else 0

lemma kernel_nonneg (h:List X) (r:X) (s z:S):0≤ kernel F h r s z:=by
  unfold kernel
  split_ifs with hs hz
  · exact div_nonneg (F.joint_nonneg h r s z) hs.le
  · norm_num
  · norm_num
lemma kernel_sum (h:List X) (r:X) (s:S):(∑ z,kernel F h r s z)=1:=by
  unfold kernel
  by_cases hs:0<F.marginal h s
  · simp only [ite_eq_left hs,←sum_div,F.left,div_self hs.ne']
  · simp [hs]

lemma disintegration (h:List X) (r:X) (s z:S):F.marginal h s*kernel F h r s z=F.joint h r s z:=by
  by_cases hs:0<F.marginal h s
  · simp only [kernel,ite_eq_left hs]
    field_simp
  · have hz:F.marginal h s=0:=le_antisymm (le_of_not_gt hs) (F.nonneg h s)
    have hj:F.joint h r s z=0:=by
      apply le_antisymm _ (F.joint_nonneg h r s z)
      calc _≤ ∑ z,F.joint h r s z:=single_le_sum (fun z _=>F.joint_nonneg h r s z) (mem_univ z)
           _ = 0:=by rw [F.left,hz]
    rw [hz,hj,zero_mul]

lemma push (h:List X) (r:X) (z:S):(∑ s,F.marginal h s*kernel F h r s z)=F.marginal (h++[r]) z:=by
  simp only [disintegration,F.right]

variable {k:ℕ} [NeZero k]
def machine : HiddenMachine.Data k X S where
  initial:=F.marginal []
  initial_nonneg:=F.nonneg []
  initial_sum:=F.normalized []
  transition h r:=kernel F (h.map Prod.fst) r
  transition_nonneg h r:=kernel_nonneg F (h.map Prod.fst) r
  transition_sum h r:=kernel_sum F (h.map Prod.fst) r
  output _ _ _ _:=0
  nullOutput _ _:=0

lemma machine_transition (h:List (X×Fin k)) (r:X):
    (machine (k:=k) F).transition h r=kernel F (h.map Prod.fst) r:=rfl

variable [MetricSpace X] (start:Configuration k X) (V:List X→ S→ Configuration k X)
variable (hc:∀ h r s,∃ i,V (h++[r]) s i=r)

def cost (h:List X) (s:S):List X→ ℝ
  | []=>0
  | r::σ=>∑ z,kernel F h r s z*(matching (V h s) (V (h++[r]) z)+cost (h++[r]) z σ)

def transport (h:List X) (r:X):ℝ:=∑ s,∑ z,F.joint h r s z*matching (V h s) (V (h++[r]) z)

def pathCost (h:List X):List X→ ℝ
  | []=>0
  | r::σ=>transport F V h r+pathCost (h++[r]) σ

lemma virtual_eq (h:List (X×Fin k)) (s:S) (σ:List X):
    HiddenMachine.virtualCost (machine F) start V hc h s σ=cost F V (h.map Prod.fst) s σ:=by
  induction σ generalizing h s with
  | nil=>rfl
  | cons r σ ih=>
    simp only [HiddenMachine.virtualCost,cost,machine_transition]
    apply sum_congr rfl
    intro z _
    rw [ih]
    simp only [List.map_append,List.map_cons,List.map_nil]

omit [NeZero k] in
lemma mean_path (h:List X) (σ:List X):
    (∑ s,F.marginal h s*cost F V h s σ)=pathCost F V h σ:=by
  induction σ generalizing h with
  | nil=>simp [cost,pathCost]
  | cons r σ ih=>
    simp only [cost,pathCost,mul_sum,mul_add,←mul_assoc,disintegration,sum_add_distrib]
    congr 1
    rw [sum_comm]
    simp only [←sum_mul,F.right]
    exact ih (h++[r])

include hc in
lemma exists_policy:
    ∃ A:Policy k X,StronglyLazy start A ∧ ∀ σ:List X,
      expectedCost A start σ≤ (∑ s,F.marginal [] s*matching start (V [] s))+pathCost F V [] σ:=by
  obtain ⟨A,hA,hB⟩:=HiddenMachine.causal_random_lazy_simulation (machine F) start V hc
  refine ⟨A,hA,fun σ=>?_⟩
  have hh:=hB σ
  change expectedCost A start σ ≤ (∑ s,F.marginal [] s*matching start (V [] s))+
    ∑ s,F.marginal [] s*HiddenMachine.virtualCost (machine F) start V hc [] s σ at hh
  simpa only [virtual_eq,List.map_nil,mean_path] using hh
end KServer.CausalCouplings

end


/-! Sequential balanced count sampling on one fixed finite tree. The full
old marginal is retained at every request, so one causal machine works at all
horizons. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TreeRounding
attribute [local instance] Classical.propDecidable Classical.decEq
variable {X:Type} {n k:ℕ} [NeZero n]
variable (T:Tree n) {τ:ℝ} (hτ:22≤τ) (w:Fin n→ℝ) (hw:∀ u,0≤w u)
  (hscale:∀ u,u≠0→w (T.parent u)=τ*w u)
  (q:List X→Fin n→ℝ) (hq:∀ h v,0≤q h v) (hp:∀ h v,0≤T.park (q h) v)
  (hr:∀ h,q h 0=(k:ℝ))

structure CountState (T:Tree n) (k:ℕ) (a:Fin n→ℝ) where
  law:Law (Counts n)
  valid:∀ ω,T.Valid a (law.point ω)
  root:∀ ω,(law.point ω).subtree 0=(k:ℤ)
  mean:T.Means a law

include hq hp hr in
lemma count_initial:Nonempty (CountState T k (q [])):=by
  obtain ⟨L,hL,hm⟩:=tree_initialization T (q []) (Int.natCast_nonneg k)
    (hq []) (hp []) (by exact_mod_cast hr [])
  exact ⟨⟨L,fun ω=>(hL ω).1,fun ω=>(hL ω).2,hm⟩⟩

def initialCount:CountState T k (q []):=Classical.choice (count_initial T q hq hp hr)

include hτ hw hscale hq hp hr in
lemma count_step_exists (h:List X) (x:X) (S:CountState T k (q h)):
    ∃ L:Law (PairState n),
      (∀ f:Counts n→ℝ,L.avg (fun s=>f s.old)=S.law.avg f) ∧
      (∀ ω,T.Valid (q h) (L.point ω).old ∧ T.Valid (q (h++[x])) (L.point ω).new ∧
        (L.point ω).new.subtree 0=(k:ℤ)) ∧
      T.Means (q (h++[x])) (L.map PairState.new) ∧
      L.avg (fun s=>∑ u,w (T.parent u)*|(s.new.subtree u:ℝ)-(s.old.subtree u:ℝ)|)≤
        132*(∑ u,w (T.parent u)*|q h u-q (h++[x]) u|):=by
  exact rounded_step T hτ w (q h) (q (h++[x])) hw hscale (Int.natCast_nonneg k)
    (by exact_mod_cast hr h) (by exact_mod_cast hr (h++[x])) (hq h) (hp h)
    (hq (h++[x])) (hp (h++[x])) S.law S.valid S.mean

def countStepLaw (h:List X) (x:X) (S:CountState T k (q h)):Law (PairState n):=
  Classical.choose (count_step_exists T hτ w hw hscale q hq hp hr h x S)

theorem countStep_spec (h:List X) (x:X) (S:CountState T k (q h)) :
    (∀ f:Counts n→ℝ,(countStepLaw T hτ w hw hscale q hq hp hr h x S).avg (fun s=>f s.old)=S.law.avg f) ∧
    (∀ ω,T.Valid (q h) ((countStepLaw T hτ w hw hscale q hq hp hr h x S).point ω).old ∧
      T.Valid (q (h++[x])) ((countStepLaw T hτ w hw hscale q hq hp hr h x S).point ω).new ∧
      ((countStepLaw T hτ w hw hscale q hq hp hr h x S).point ω).new.subtree 0=(k:ℤ)) ∧
    T.Means (q (h++[x])) ((countStepLaw T hτ w hw hscale q hq hp hr h x S).map PairState.new) ∧
    (countStepLaw T hτ w hw hscale q hq hp hr h x S).avg
      (fun s=>∑ u,w (T.parent u)*|(s.new.subtree u:ℝ)-(s.old.subtree u:ℝ)|)≤
        132*(∑ u,w (T.parent u)*|q h u-q (h++[x]) u|) :=
  Classical.choose_spec (count_step_exists T hτ w hw hscale q hq hp hr h x S)

def nextCount (h:List X) (x:X) (S:CountState T k (q h)):CountState T k (q (h++[x])) where
  law:=(countStepLaw T hτ w hw hscale q hq hp hr h x S).map PairState.new
  valid ω:=(countStep_spec T hτ w hw hscale q hq hp hr h x S).2.1 ω |>.2.1
  root ω:=(countStep_spec T hτ w hw hscale q hq hp hr h x S).2.1 ω |>.2.2
  mean:=(countStep_spec T hτ w hw hscale q hq hp hr h x S).2.2.1

def countState (h:List X):CountState T k (q h):=
  List.reverseRecOn h (initialCount T q hq hp hr)
    (fun h x S=>nextCount T hτ w hw hscale q hq hp hr h x S)

lemma countState_nil:countState T hτ w hw hscale q hq hp hr []=initialCount T q hq hp hr:=by
  simp only [countState,List.reverseRecOn_nil]
lemma countState_snoc (h:List X) (x:X):
    countState T hτ w hw hscale q hq hp hr (h++[x])=
      nextCount T hτ w hw hscale q hq hp hr h x (countState T hτ w hw hscale q hq hp hr h):=by
  simp only [countState,List.reverseRecOn_concat]

def pairLaw (h:List X) (x:X):Law (PairState n):=
  countStepLaw T hτ w hw hscale q hq hp hr h x (countState T hτ w hw hscale q hq hp hr h)

def countFamily:CausalCouplings.Family X (Inventory T k) where
  marginal h:=(countState T hτ w hw hscale q hq hp hr h).law.mass (pack T)
  nonneg h:=(countState T hτ w hw hscale q hq hp hr h).law.mass_nonneg (pack T)
  normalized h:=(countState T hτ w hw hscale q hq hp hr h).law.mass_sum (pack T)
  joint h x s z:=(pairLaw T hτ w hw hscale q hq hp hr h x).mass
    (fun p=>(pack T p.old,pack T p.new)) (s,z)
  joint_nonneg h x s z:=(pairLaw T hτ w hw hscale q hq hp hr h x).mass_nonneg _ _
  left h x s:=by
    rw [Law.mass_left]
    unfold Law.mass pairLaw countStepLaw
    exact (countStep_spec T hτ w hw hscale q hq hp hr h x
      (countState T hτ w hw hscale q hq hp hr h)).1 (fun c=>@ite ℝ (pack T c=s) (Classical.decEq _ _ _) 1 0)
  right h x z:=by
    rw [Law.mass_right,countState_snoc]
    rfl

end KServer.TreeRounding

end


/-! The sequential family keeps exact new park means and the factor-132
weighted subtree transport estimate. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.TreeRounding
attribute [local instance] Classical.propDecidable Classical.decEq
variable {X:Type} {n k:ℕ} [NeZero n]
variable (T:Tree n) {τ:ℝ} (hτ:22≤τ) (w:Fin n→ℝ) (hw:∀ u,0≤w u)
  (hscale:∀ u,u≠0→w (T.parent u)=τ*w u)
  (q:List X→Fin n→ℝ) (hq:∀ h v,0≤q h v) (hp:∀ h v,0≤T.park (q h) v)
  (hr:∀ h,q h 0=(k:ℝ))

lemma marginal_valid (h:List X) (c:Inventory T k)
    (hc:0<(countFamily T hτ w hw hscale q hq hp hr).marginal h c):T.Valid (q h) c.val:=by
  obtain ⟨ω,he⟩:=(countState T hτ w hw hscale q hq hp hr h).law.mass_support (pack T) hc
  rw [←he,pack_val T _ (good_of_valid T _ (hr h) _ ((countState T hτ w hw hscale q hq hp hr h).valid ω))]
  exact (countState T hτ w hw hscale q hq hp hr h).valid ω

lemma pair_old_valid (h:List X) (x:X) (ω:(pairLaw T hτ w hw hscale q hq hp hr h x).Ω):
    T.Valid (q h) ((pairLaw T hτ w hw hscale q hq hp hr h x).point ω).old:=
  (countStep_spec T hτ w hw hscale q hq hp hr h x (countState T hτ w hw hscale q hq hp hr h)).2.1 ω |>.1
lemma pair_new_valid (h:List X) (x:X) (ω:(pairLaw T hτ w hw hscale q hq hp hr h x).Ω):
    T.Valid (q (h++[x])) ((pairLaw T hτ w hw hscale q hq hp hr h x).point ω).new:=
  (countStep_spec T hτ w hw hscale q hq hp hr h x (countState T hτ w hw hscale q hq hp hr h)).2.1 ω |>.2.1

lemma joint_average (h:List X) (x:X) (g:Inventory T k→Inventory T k→ℝ):
    (∑ c,∑ e,(countFamily T hτ w hw hscale q hq hp hr).joint h x c e*g c e)=
      (pairLaw T hτ w hw hscale q hq hp hr h x).avg (fun p=>g (pack T p.old) (pack T p.new)):=by
  exact (Fintype.sum_prod_type _).symm.trans
    ((pairLaw T hτ w hw hscale q hq hp hr h x).mass_average (fun p=>(pack T p.old,pack T p.new)) (fun p=>g p.1 p.2))

lemma expected_bound (h:List X) (x:X) (g:Inventory T k→Inventory T k→ℝ) (m:Fin n→ℝ)
    {a b:ℝ} (ha:0≤a)
    (hg:∀ c e:Inventory T k,T.Valid (q h) c.val→T.Valid (q (h++[x])) e.val→
      g c e≤a*(∑ u,w (T.parent u)*|(c.val.subtree u:ℝ)-(e.val.subtree u:ℝ)|)+
        b*(∑ u,(e.val.park u:ℝ)*m u)):
    (∑ c,∑ e,(countFamily T hτ w hw hscale q hq hp hr).joint h x c e*g c e)≤
      a*132*(∑ u,w (T.parent u)*|q h u-q (h++[x]) u|)+b*(∑ u,T.park (q (h++[x])) u*m u):=by
  rw [joint_average]
  let P:=pairLaw T hτ w hw hscale q hq hp hr h x
  have hbound:P.avg (fun p=>g (pack T p.old) (pack T p.new))≤
      P.avg (fun p=>a*(∑ u,w (T.parent u)*|(p.new.subtree u:ℝ)-(p.old.subtree u:ℝ)|)+
        b*(∑ u,(p.new.park u:ℝ)*m u)):=by
    apply Law.avg_le_of_support
    intro ω
    have ho:=pair_old_valid T hτ w hw hscale q hq hp hr h x ω
    have hn:=pair_new_valid T hτ w hw hscale q hq hp hr h x ω
    have hgo:=good_of_valid T _ (hr h) _ ho
    have hgn:=good_of_valid T _ (hr (h++[x])) _ hn
    have hh:=hg (pack T (P.point ω).old) (pack T (P.point ω).new)
      (by rwa [pack_val T _ hgo]) (by rwa [pack_val T _ hgn])
    have heo:(pack T (P.point ω).old:Inventory T k).val=(P.point ω).old:=pack_val T _ hgo
    have hen:(pack T (P.point ω).new:Inventory T k).val=(P.point ω).new:=pack_val T _ hgn
    rw [heo,hen] at hh
    simpa only [abs_sub_comm] using hh
  have hmean:(P.map PairState.new).avg (fun c=>∑ u,(c.park u:ℝ)*m u)=
      ∑ u,T.park (q (h++[x])) u*m u:=by
    rw [Law.avg_sum]
    apply sum_congr rfl
    intro u _
    have hh:=(countStep_spec T hτ w hw hscale q hq hp hr h x
      (countState T hτ w hw hscale q hq hp hr h)).2.2.1.2 u
    change (P.map PairState.new).avg (fun c=>(c.park u:ℝ))=T.park (q (h++[x])) u at hh
    calc
      _=m u*(P.map PairState.new).avg (fun c=>(c.park u:ℝ)):=by
        simpa only [mul_comm] using (P.map PairState.new).avg_mul (m u) (fun c=>(c.park u:ℝ))
      _=T.park (q (h++[x])) u*m u:=by rw [hh,mul_comm]
  have hm:= (countStep_spec T hτ w hw hscale q hq hp hr h x
      (countState T hτ w hw hscale q hq hp hr h)).2.2.2
  rw [Law.avg_add,Law.avg_mul,Law.avg_mul] at hbound
  rw [Law.map_avg] at hmean
  change P.avg (fun p=>∑ u,(p.new.park u:ℝ)*m u)=_ at hmean
  rw [hmean] at hbound
  exact hbound.trans (by simpa only [P,pairLaw,mul_assoc,add_comm] using add_le_add_right (mul_le_mul_of_nonneg_left hm ha) (b*∑ u,T.park (q (h++[x])) u*m u))
end KServer.TreeRounding

end


/-! An independent permanent finite tape, sampled once before the requests. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CausalCouplings
attribute [local instance] Classical.propDecidable Classical.decEq
variable {X I S:Type} [Fintype I] [Fintype S]
variable (w:I→ℝ) (hw:∀ i,0≤w i) (h1:∑ i,w i=1) (F:I→Family X S)

def mixture:Family X (I×S) where
  marginal h s:=w s.1*(F s.1).marginal h s.2
  nonneg h s:=mul_nonneg (hw s.1) ((F s.1).nonneg h s.2)
  normalized h:=by simp only [Fintype.sum_prod_type,←mul_sum,Family.normalized,mul_one,h1]
  joint h r s z:=if s.1=z.1 then w s.1*(F s.1).joint h r s.2 z.2 else 0
  joint_nonneg h r s z:=by split_ifs; exact mul_nonneg (hw _) ((F _).joint_nonneg _ _ _ _); rfl
  left h r s:=by
    simp only [Fintype.sum_prod_type]
    rw [sum_eq_single s.1]
    · simp only [ite_true,←mul_sum,Family.left]
    · intro i _ hi
      simp only [Ne.symm hi,ite_false,sum_const_zero]
    · simp only [mem_univ,not_true_eq_false,false_implies]
  right h r z:=by
    simp only [Fintype.sum_prod_type]
    rw [sum_eq_single z.1]
    · simp only [ite_true,←mul_sum,Family.right]
    · intro i _ hi
      simp only [hi,ite_false,sum_const_zero]
    · simp only [mem_univ,not_true_eq_false,false_implies]

lemma mixture_transport [MetricSpace X] {k:ℕ} (V:I→List X→S→ Configuration k X) (h:List X) (r:X):
    transport (mixture w hw h1 F) (fun h s=>V s.1 h s.2) h r=
      ∑ i,w i*transport (F i) (V i) h r:=by
  unfold transport mixture
  simp only [Fintype.sum_prod_type]
  apply sum_congr rfl
  intro i _
  rw [mul_sum]
  apply sum_congr rfl
  intro s _
  rw [sum_eq_single i]
  · simp only [ite_true,mul_assoc,mul_sum]
  · intro j _ hj
    simp only [Ne.symm hj,ite_false,zero_mul,sum_const_zero]
  · simp only [mem_univ,not_true_eq_false,false_implies]

lemma mixture_path [MetricSpace X] {k:ℕ} (V:I→List X→S→ Configuration k X) (h σ:List X):
    pathCost (mixture w hw h1 F) (fun h s=>V s.1 h s.2) h σ=
      ∑ i,w i*pathCost (F i) (V i) h σ:=by
  induction σ generalizing h with
  | nil=>simp only [pathCost,mul_zero,sum_const_zero]
  | cons r σ ih=>simp only [pathCost,mixture_transport,ih,mul_add,sum_add_distrib]

variable [Nonempty S] [MetricSpace X] {k:ℕ} [NeZero k]

def safeConfig (z:X) (V:List X→S→ Configuration k X) (h:List X) (s:S):Configuration k X:=
  if h=[] then V h s else if ∃ i,V h s i=h.getLastD z then V h s else fun _=>h.getLastD z

omit [Fintype S] [Nonempty S] [MetricSpace X] in
lemma safeConfig_serves (z:X) (V:List X→S→ Configuration k X) (h:List X) (r:X) (s:S):
    ∃ i,safeConfig z V (h++[r]) s i=r:=by
  have hn:h++[r]≠[]:=by simp
  have he:(h++[r]).getLastD z=r:=by simp
  unfold safeConfig
  rw [ite_eq_right hn,he]
  split_ifs with hs
  · exact hs
  · exact ⟨0,rfl⟩

omit [Fintype S] [Nonempty S] [MetricSpace X] [NeZero k] in
lemma safeConfig_eq_nil (z:X) (V:List X→S→ Configuration k X) (s:S):
    safeConfig z V [] s=V [] s:=by simp only [safeConfig,ite_true]

omit [Fintype S] [Nonempty S] [MetricSpace X] [NeZero k] in
lemma safeConfig_eq (z:X) (V:List X→S→ Configuration k X) (h:List X) (s:S)
    (hc:∃ i,V h s i=h.getLastD z):safeConfig z V h s=V h s:=by
  unfold safeConfig
  split_ifs <;> rfl
end KServer.CausalCouplings

end


/-! Explicit finite-horizon cost of the same causal machine. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CausalCouplings
variable {X S:Type} [Fintype S] [Nonempty S] [MetricSpace X] {k:ℕ}

omit [Nonempty S] in
lemma path_ofFn (F:Family X S) (V:List X→ S→ Configuration k X) (h:List X)
    {H:ℕ} (σ:Fin H→X):
    pathCost F V h (List.ofFn σ)=∑ t:Fin H,transport F V (h++(List.ofFn σ).take t.val) (σ t):=by
  induction H generalizing h with
  | zero=>simp only [List.ofFn_zero,pathCost,Fin.sum_univ_zero]
  | succ H ih=>
    rw [List.ofFn_succ,pathCost,ih,Fin.sum_univ_succ]
    simp only [Fin.val_zero,List.take_zero,List.append_nil,Fin.val_succ,List.take_succ_cons]
    congr 1
    apply sum_congr rfl
    intro t _
    congr 1
    simp only [List.append_assoc,List.singleton_append]
end KServer.CausalCouplings

end


/-! Actual history-indexed count laws and their rendered labeled configurations.
Impossible histories are completed by a service-safe output, whereas every
positive experimental prefix uses the genuine allocated occupied anchors. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.JointRounded
open JointExperiment JointAllocation JointHistory CausalCouplings
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type} [MetricSpace Y] [Fintype Y] {k H L:ℕ} [NeZero k]
variable (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
variable {r:Fin L→ℝ} (hr:∀ d,0<r d) (hk:1≤(k:ℝ))

abbrev T:=PrefixTree.tree (LevelKeys.Key Y k) L
abbrev State:=TreeRounding.Inventory (T (Y:=Y) (k:=k) (L:=L)) k

def family {R τ:ℝ} (hR:0≤R) (hτ:22≤τ) (tape:Tape Y k H L r):Family Y (State (Y:=Y) (k:=k) (L:=L)):=
  TreeRounding.countFamily T hτ (PrefixTree.weight (LevelKeys.Key Y k) L R τ)
    (PrefixTree.weight_nonneg _ L hR (by linarith)) (PrefixTree.parent_weight _ L (by linarith))
    (q s law hr hk tape) (q_nonneg s law hr hk tape) (q_park_nonneg s law hr hk tape) (q_root s law hr hk tape)

def rawConfig (tape:Tape Y k H L r) (h:List Y) (c:State (Y:=Y) (k:=k) (L:=L)):Configuration k Y:=
  PrefixTree.countConfig (LevelKeys.Key Y k) L (s 0) (a s law hr tape h) c

def config (tape:Tape Y k H L r):List Y→ State (Y:=Y) (k:=k) (L:=L)→ Configuration k Y:=
  safeConfig (s 0) (rawConfig s law hr tape)

lemma config_serves (tape:Tape Y k H L r) (h:List Y) (x:Y) (c:State (Y:=Y) (k:=k) (L:=L)):
    ∃ i,config s law hr tape (h++[x]) c i=x:=safeConfig_serves _ _ _ _ _

lemma q_take (t:ℕ) (ht:t≤H) (ω:Atom (k:=k) law hr):
    q s law hr hk ω.val.2 ((List.ofFn ω.val.1).take t)=quota s law hr hk t ω:=by
  rw [q_eq s law hr hk _ _ ω (observed_true law hr ω t ht)]
  simp only [List.length_take,List.length_ofFn,Nat.min_eq_left ht]
lemma a_take (t:ℕ) (ht:t≤H) (ω:Atom (k:=k) law hr):
    a s law hr ω.val.2 ((List.ofFn ω.val.1).take t)=anchors s law hr t ω:=by
  rw [a_eq s law hr _ _ ω (observed_true law hr ω t ht)]
  simp only [List.length_take,List.length_ofFn,Nat.min_eq_left ht]

omit [MetricSpace Y] [Fintype Y] in
lemma take_succ (t:Fin H) (σ:Fin H→Y):
    (List.ofFn σ).take (t.val+1)=(List.ofFn σ).take t.val++[σ t]:=by
  rw [List.take_succ_eq_append_getElem (by simpa only [List.length_ofFn] using t.isLt)]
  rw [List.getElem_ofFn]


lemma raw_take (t:ℕ) (ht:t≤H) (ω:Atom (k:=k) law hr) (c:State (Y:=Y) (k:=k) (L:=L)):
    rawConfig s law hr ω.val.2 ((List.ofFn ω.val.1).take t) c=
      PrefixTree.countConfig _ L (s 0) (anchors s law hr t ω) c:=by
  unfold rawConfig
  rw [a_take s law hr t ht ω]

lemma config_take (hL:0<L) (hf:∀ x y:Y,dist x y≤20*r ⟨L-1,by omega⟩→x=y)
    (t:ℕ) (ht:t≤H) (ω:Atom (k:=k) law hr) (c:State (Y:=Y) (k:=k) (L:=L))
    (hc:T.Valid (quota s law hr hk t ω) c.val):
    config s law hr ω.val.2 ((List.ofFn ω.val.1).take t) c=
      PrefixTree.countConfig _ L (s 0) (anchors s law hr t ω) c:=by
  unfold config
  have he:safeConfig (s 0) (rawConfig s law hr ω.val.2) ((List.ofFn ω.val.1).take t) c=
      rawConfig s law hr ω.val.2 ((List.ofFn ω.val.1).take t) c:=by
    cases t with
    | zero=>simp only [List.take_zero,safeConfig_eq_nil]
    | succ t=>
      apply safeConfig_eq
      obtain ⟨i,hi⟩:=JointService.count_serves s law hr hk hL hf ⟨t,by omega⟩ ω c hc
      refine ⟨i,?_⟩
      rw [raw_take s law hr (t+1) ht ω c,hi,take_succ ⟨t,by omega⟩]
      simp only [List.getLastD_concat]
  rw [he]
  exact raw_take s law hr t ht ω c

lemma step_bound {R τ:ℝ} (hR:0≤R) (hτ:22≤τ) (hdia:∀ x y:Y,dist x y≤R)
    (hrad:∀ d,r d=R/τ^(d.val+1)) (hL:0<L)
    (hf:∀ x y:Y,dist x y≤20*r ⟨L-1,by omega⟩→x=y)
    (t:Fin H) (ω:Atom (k:=k) law hr):
    transport (family s law hr hk hR hτ ω.val.2) (config s law hr ω.val.2)
      ((List.ofFn ω.val.1).take t.val) (ω.val.1 t)≤
      15840*JointBudget.stepQuota s law hr hk R τ t.val ω+40*JointHeavy.travel s law hr hk t.val ω:=by
  have hold:=q_take s law hr hk t.val (Nat.le_of_lt t.isLt) ω
  have hnew:q s law hr hk ω.val.2 ((List.ofFn ω.val.1).take t.val++[ω.val.1 t])=
      quota s law hr hk (t.val+1) ω:=by
    rw [←take_succ t ω.val.1]
    exact q_take s law hr hk _ (by omega) ω
  have hh:=TreeRounding.expected_bound T hτ (PrefixTree.weight (LevelKeys.Key Y k) L R τ)
    (PrefixTree.weight_nonneg _ L hR (by linarith)) (PrefixTree.parent_weight _ L (by linarith))
    (q s law hr hk ω.val.2) (q_nonneg s law hr hk ω.val.2) (q_park_nonneg s law hr hk ω.val.2)
    (q_root s law hr hk ω.val.2) ((List.ofFn ω.val.1).take t.val) (ω.val.1 t)
    (fun c e=>matching (config s law hr ω.val.2 ((List.ofFn ω.val.1).take t.val) c)
      (config s law hr ω.val.2 ((List.ofFn ω.val.1).take t.val++[ω.val.1 t]) e))
    (PrefixTree.nodeMotion _ L (JointMetric.motion s law hr t.val ω)) (a:=120) (b:=40) (by norm_num)
    (fun c e hc he=>by
      rw [hold] at hc
      rw [hnew] at he
      rw [←take_succ t ω.val.1,config_take s law hr hk hL hf _ (by omega) ω c hc,
        config_take s law hr hk hL hf _ (by omega) ω e he]
      exact JointMetric.count_matching s law hr hk hR (by linarith) hdia hrad t ω c e hc he)
  change transport (family s law hr hk hR hτ ω.val.2) (config s law hr ω.val.2) _ _≤_ at hh
  rw [hold,hnew] at hh
  have hm:(∑ v,T.park (quota s law hr hk (t.val+1) ω) v*
      PrefixTree.nodeMotion _ L (JointMetric.motion s law hr t.val ω) v)=JointHeavy.travel s law hr hk t.val ω:=
    JointMetric.motion_sum s law hr hk t.val ω
  rw [hm] at hh
  simpa only [JointBudget.stepQuota,abs_sub_comm,show (120:ℝ)*132=15840 by norm_num] using hh
end KServer.JointRounded

end


/-! The actual permanent-tape sequentially rounded experiment returns a causal
strongly lazy policy. All impossible histories were already service-completed. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.JointPolicy
open JointExperiment JointRounded CausalCouplings RankTracking ActualCharges
attribute [local instance] Classical.propDecidable Classical.decEq
variable {Y:Type} [MetricSpace Y] [Fintype Y] {k H L:ℕ} [NeZero k]
variable (s:Configuration k Y) (law:FiniteDistribution (Fin H→Y))
variable {r:Fin L→ℝ} (hr:∀ d,0<r d) (hk:1≤(k:ℝ))

omit [NeZero k] in
include hr in
lemma tape_nonempty : Nonempty (Tape Y k H L r):=by
  by_contra h
  have : IsEmpty (Tape Y k H L r):=not_nonempty_iff.mp h
  have hh:=tapeWeight_sum (Y:=Y) (k:=k) (H:=H) hr
  simp only [sum_of_isEmpty,zero_ne_one] at hh

abbrev MixState:=Tape Y k H L r × State (Y:=Y) (k:=k) (L:=L)

def mixed {R τ:ℝ} (hR:0≤R) (hτ:22≤τ):Family Y (MixState (Y:=Y) (k:=k) (H:=H) (r:=r)):=
  mixture (tapeWeight r) (tapeWeight_nonneg hr) (tapeWeight_sum hr) (family s law hr hk hR hτ)

def rendered (h:List Y) (z:MixState (Y:=Y) (k:=k) (H:=H) (r:=r)):Configuration k Y:=
  config s law hr z.1 h z.2

lemma rendered_serves (h:List Y) (x:Y) (z:MixState (Y:=Y) (k:=k) (H:=H) (r:=r)):
    ∃ i,rendered s law hr (h++[x]) z i=x:=
  safeConfig_serves (s 0) (rawConfig s law hr z.1) h x z.2

lemma mean_path {R τ:ℝ} (hR:0≤R) (hτ:22≤τ):
    (∑ σ,law.val σ*pathCost (mixed s law hr hk hR hτ) (rendered s law hr) [] (List.ofFn σ))=
      ∑ t:Fin H,avg (weight law hr) (fun ω=>
        transport (family s law hr hk hR hτ ω.val.2) (config s law hr ω.val.2)
          ((List.ofFn ω.val.1).take t.val) (ω.val.1 t)):=by
  have := tape_nonempty (Y:=Y) (k:=k) (H:=H) hr
  simp_rw [path_ofFn,List.nil_append]
  unfold mixed rendered
  simp_rw [mixture_transport]
  have hav (t:Fin H):avg (weight law hr) (fun ω=>
        transport (family s law hr hk hR hτ ω.val.2) (config s law hr ω.val.2)
          ((List.ofFn ω.val.1).take t.val) (ω.val.1 t))=
      ∑ σ,law.val σ*(∑ a:Tape Y k H L r,tapeWeight r a*
        transport (family s law hr hk hR hτ a) (config s law hr a)
          ((List.ofFn σ).take t.val) (σ t)):=by
    rw [avg_raw law hr (fun z:Raw Y k H L r =>
      transport (family s law hr hk hR hτ z.2) (config s law hr z.2)
        ((List.ofFn z.1).take t.val) (z.1 t))]
    simp only [avg,rawWeight,FiniteExperiment.weight,tapeLaw,Fintype.sum_prod_type,mul_sum,mul_assoc]
  simp_rw [hav,mul_sum]
  rw [sum_comm]

lemma path_bound {R τ:ℝ} (hR:0≤R) (hτ:22≤τ) (hdia:∀ x y:Y,dist x y≤R)
    (hrad:∀ d,r d=R/τ^(d.val+1)) (hL:0<L)
    (hf:∀ x y:Y,dist x y≤20*r ⟨L-1,by omega⟩→x=y):
    (∑ σ,law.val σ*pathCost (mixed s law hr hk hR hτ) (rendered s law hr) [] (List.ofFn σ))≤
      15840*total (weight law hr) H (JointBudget.stepQuota s law hr hk R τ)+
        40*total (weight law hr) H (JointHeavy.travel s law hr hk):=by
  rw [mean_path]
  have hb:=sum_le_sum (s:=univ) (fun t (_:t∈univ)=>
    avg_mono (weight_nonneg law hr) (fun ω=>step_bound s law hr hk hR hτ hdia hrad hL hf t ω))
  simp only [avg_add,avg_mul,sum_add_distrib,←mul_sum] at hb
  unfold total
  rw [←Fin.sum_univ_eq_sum_range (fun t=>avg (weight law hr) (JointBudget.stepQuota s law hr hk R τ t)) H,
    ←Fin.sum_univ_eq_sum_range (fun t=>avg (weight law hr) (JointHeavy.travel s law hr hk t)) H]
  exact hb

lemma exists_policy {R τ:ℝ} (hR:0≤R) (hτ:22≤τ) (hdia:∀ x y:Y,dist x y≤R)
    (hrad:∀ d,r d=R/τ^(d.val+1)) (hL:0<L)
    (hf:∀ x y:Y,dist x y≤20*r ⟨L-1,by omega⟩→x=y):
    ∃ A:Policy k Y,StronglyLazy s A ∧
      (∑ σ,law.val σ*expectedCost A s (List.ofFn σ))≤
        15840*total (weight law hr) H (JointBudget.stepQuota s law hr hk R τ)+
        40*total (weight law hr) H (JointHeavy.travel s law hr hk)+(k:ℝ)*R:=by
  have := tape_nonempty (Y:=Y) (k:=k) (H:=H) hr
  obtain ⟨A,hA,hcost⟩:=CausalCouplings.exists_policy (mixed s law hr hk hR hτ) s
    (rendered s law hr) (rendered_serves s law hr)
  refine ⟨A,hA,?_⟩
  have hi:(∑ z,(mixed s law hr hk hR hτ).marginal [] z*matching s (rendered s law hr [] z))≤(k:ℝ)*R:=by
    have hh:=sum_le_sum (s:=univ) (fun z (_:z∈univ)=>mul_le_mul_of_nonneg_left
      (Episode.matching_le_diameter s (rendered s law hr [] z) R hdia)
      ((mixed s law hr hk hR hτ).nonneg [] z))
    simpa only [←sum_mul,Family.normalized,one_mul] using hh
  have he:=sum_le_sum (s:=univ) (fun σ (_:σ∈univ)=>mul_le_mul_of_nonneg_left (hcost (List.ofFn σ)) (law.property.1 σ))
  simp only [mul_add,sum_add_distrib,←sum_mul,law.property.2,one_mul] at he
  have hp:=path_bound s law hr hk hR hτ hdia hrad hL hf
  linarith
end KServer.JointPolicy

end

end OAI