lean/OAI/Combinatorics/KServer/OutputDynamics.lean

import Mathlib
import OAI.Combinatorics.KServer.Allocation

namespace OAI

/- The two output formulas, finite-star algebra and static cap-proportion feasibility. -/


noncomputable section
open Finset
open scoped BigOperators
namespace KServer.OutputDynamics
variable {I : Type*} [Fintype I]

def variation (x y : I → ℝ) : ℝ := ∑ i, |x i - y i|
def excess (d : I → ℝ) (q : ℝ) : ℝ := max ((∑ i, d i) - q) 0

def holesI (R : ℝ) (a : I → ℝ) : I → ℝ := fun i => R * a i
def outputI (d : I → ℝ) (q : ℝ) (a : I → ℝ) : I → ℝ :=
  fun i => d i - holesI (excess d q) a i

lemma variation_nonneg (x y : I → ℝ) : 0 ≤ variation x y :=
  sum_nonneg fun _ _ => abs_nonneg _

lemma variation_triangle (x y z : I → ℝ) : variation x z ≤ variation x y + variation y z := by
  rw [variation, variation, variation, ← sum_add_distrib]
  exact sum_le_sum fun i _ => abs_sub_le (x i) (y i) (z i)

lemma variation_sum (x y : I → ℝ) : |(∑ i, x i) - ∑ i, y i| ≤ variation x y := by
  rw [← sum_sub_distrib]
  exact abs_sum_le_sum_abs _ _

lemma positive_part_lipschitz (x y : ℝ) : |max x 0 - max y 0| ≤ |x - y| := by
  exact abs_max_sub_max_le_abs x y 0

lemma excess_lipschitz (d e : I → ℝ) (q p : ℝ) :
    |excess d q - excess e p| ≤ variation d e + |q - p| := by
  apply (positive_part_lipschitz _ _).trans
  calc |((∑ i, d i) - q) - ((∑ i, e i) - p)| =
      |((∑ i, d i) - ∑ i, e i) + (p - q)| := by congr 1; ring
    _ ≤ |(∑ i, d i) - ∑ i, e i| + |p - q| := abs_add_le _ _
    _ ≤ variation d e + |q - p| := by rw [abs_sub_comm p q]; exact add_le_add (variation_sum d e) (le_refl _)

lemma excess_nonneg (d : I → ℝ) (q : ℝ) : 0 ≤ excess d q := le_max_right _ _

omit [Fintype I] in
lemma holesI_nonneg {R : ℝ} {a : I → ℝ} (hR : 0 ≤ R) (ha : ∀ i, 0 ≤ a i) :
    ∀ i, 0 ≤ holesI R a i := fun i => mul_nonneg hR (ha i)

lemma holesI_sum {a : I → ℝ} (ha : ∑ i, a i = 1) (R : ℝ) :
    ∑ i, holesI R a i = R := by simp [holesI, ← mul_sum, ha]

lemma holesI_movement {R R' : ℝ} {a a' : I → ℝ} (hR' : 0 ≤ R')
    (ha : ∀ i, 0 ≤ a i) (hsa : ∑ i, a i = 1) :
    variation (holesI R' a') (holesI R a) ≤ |R' - R| + R' * variation a' a := by
  calc variation (holesI R' a') (holesI R a) ≤
      ∑ i, (R' * |a' i - a i| + |R' - R| * a i) := by
        apply sum_le_sum
        intro i _
        change |R' * a' i - R * a i| ≤ _
        calc _ = |R' * (a' i - a i) + (R' - R) * a i| := by congr 1; ring
          _ ≤ |R' * (a' i - a i)| + |(R' - R) * a i| := abs_add_le _ _
          _ = _ := by rw [abs_mul, abs_mul, abs_of_nonneg hR', abs_of_nonneg (ha i)]
    _ = _ := by rw [sum_add_distrib, ← mul_sum, ← mul_sum, hsa, mul_one]; unfold variation; ring

lemma outputI_budget {a : I → ℝ} (ha : ∑ i, a i = 1) (d : I → ℝ) (q : ℝ) :
    ∑ i, outputI d q a i = min (∑ i, d i) q := by
  unfold outputI
  rw [sum_sub_distrib, holesI_sum ha]
  unfold excess
  by_cases h : (∑ i, d i) ≤ q
  · rw [max_eq_right (by linarith), min_eq_left h]; ring
  · rw [max_eq_left (by linarith), min_eq_right (le_of_not_ge h)]; ring

lemma hole_bound {n B f b : I → ℝ} {β e q : ℝ}
    (hp : (∑ i, (n i - β * B i + f i)) ≤ q)
    (hc : (∑ i, (b i - f i)) ≤ e) (hβ : 0 ≤ β) (he : 0 ≤ e)
    (hB : ∀ i, 0 ≤ B i) :
    excess (fun i => n i + b i) q ≤ β * (∑ i, B i) + e := by
  apply max_le
  · have hi : (∑ i, (n i + b i)) - q ≤
        β * (∑ i, B i) + ∑ i, (b i - f i) := by
      have hs : (∑ i, (n i + b i)) - (∑ i, (n i - β * B i + f i)) =
          β * (∑ i, B i) + ∑ i, (b i - f i) := by
        rw [← sum_sub_distrib, mul_sum, ← sum_add_distrib]
        apply sum_congr rfl; intro i _; ring
      linarith
    linarith
  · exact add_nonneg (mul_nonneg hβ (sum_nonneg fun i _ => hB i)) he

/-- Rule I at a regular coordinate. This includes S=0 without division. -/
lemma regular_hole {S R β βi e η B a : ℝ}
    (hS : 0 ≤ S) (hR : 0 ≤ R) (he : 0 ≤ e) (hB : 0 ≤ B)
    (ha : 0 ≤ a) (_hη : 0 ≤ 1 + η) (hβ : 0 ≤ β) (hβi : 0 ≤ βi)
    (hr : R ≤ β * S + e) (hp : S * a ≤ (1 + η) * B)
    (hroom : (β * S + e) * (1 + η) ≤ βi * S)
    (hzero : S = 0 → e = 0) : R * a ≤ βi * B := by
  by_cases hs : S = 0
  · have he0 := hzero hs
    have hr0 : R = 0 := by rw [hs, he0] at hr; nlinarith
    rw [hr0, zero_mul]
    exact mul_nonneg hβi hB
  · have hsp : 0 < S := lt_of_le_of_ne hS (Ne.symm hs)
    have h1 := mul_le_mul_of_nonneg_left hp (add_nonneg (mul_nonneg hβ hS) he)
    have h2 := mul_le_mul_of_nonneg_right hroom hB
    have h3 := mul_le_mul_of_nonneg_right hr ha
    nlinarith

lemma dominant_hole {S R β βi e η B a : ℝ}
    (he : 0 ≤ e) (hB : 0 ≤ B) (ha : 0 ≤ a) (ha1 : a ≤ 1) (hβ : 0 ≤ β)
    (hr : R ≤ β * S + e) (hp : S * a ≤ (1 + η) * B)
    (hroom : β * (1 + η) ≤ βi) : R * a ≤ βi * B + e := by
  have h1 := mul_le_mul_of_nonneg_right hr ha
  have h2 := mul_le_mul_of_nonneg_left hp hβ
  have h3 := mul_le_mul_of_nonneg_right hroom hB
  have h4 := mul_le_mul_of_nonneg_left ha1 he
  nlinarith

/-- The error margin used on regular children, including zero core mass. -/
lemma regular_parameter_room {S β βi e η g : ℝ}
    (hS : 0 ≤ S) (he : 0 ≤ e) (hη : η ≤ 1)
    (hgap : β + g ≤ βi) (hηgap : β * η ≤ g / 2)
    (herr : 4 * e ≤ g * S) : (β * S + e) * (1 + η) ≤ βi * S := by
  have hp := mul_le_mul_of_nonneg_right hηgap hS
  have hq := mul_le_mul_of_nonneg_right hgap hS
  have hr := mul_le_mul_of_nonneg_left hη he
  nlinarith

/-- Literal regular-coordinate lower bound for Rule I, and its upper cap. -/
lemma outputI_regular {n B f b a η βi : I → ℝ} {β e q : ℝ}
    (hp : (∑ i, (n i - β * B i + f i)) ≤ q)
    (hc : (∑ i, (b i - f i)) ≤ e) (hβ : 0 ≤ β) (he : 0 ≤ e)
    (hB : ∀ i, 0 ≤ B i) (ha : ∀ i, 0 ≤ a i)
    (hprop : ∀ i, (∑ j, B j) * a i ≤ (1 + η i) * B i)
    (hzero : (∑ i, B i) = 0 → e = 0)
    (i : I) (hβi : 0 ≤ βi i) (hη : 0 ≤ 1 + η i)
    (hroom : (β * (∑ j, B j) + e) * (1 + η i) ≤ βi i * (∑ j, B j))
    (fc : ℝ) (hfc : fc ≤ b i) :
    n i - βi i * B i + fc ≤ outputI (fun j => n j + b j) q a i ∧
      outputI (fun j => n j + b j) q a i ≤ n i + b i := by
  have hr := hole_bound hp hc hβ he hB
  have hh := regular_hole (sum_nonneg fun j _ => hB j) (excess_nonneg _ _)
    he (hB i) (ha i) hη hβ hβi hr (hprop i) hroom hzero
  have hn := holesI_nonneg (excess_nonneg (fun j => n j + b j) q) ha i
  unfold outputI holesI at *
  constructor <;> dsimp at * <;> linarith

lemma outputI_dominant {n B f b a η βi : I → ℝ} {β e q : ℝ}
    (hp : (∑ i, (n i - β * B i + f i)) ≤ q)
    (hc : (∑ i, (b i - f i)) ≤ e) (hβ : 0 ≤ β) (he : 0 ≤ e)
    (hB : ∀ i, 0 ≤ B i) (ha : ∀ i, 0 ≤ a i) (has : ∑ i, a i = 1)
    (hprop : ∀ i, (∑ j, B j) * a i ≤ (1 + η i) * B i)
    (o : I) (hroom : β * (1 + η o) ≤ βi o)
    (fc : ℝ) (hfc : fc ≤ b o - e) :
    n o - βi o * B o + fc ≤ outputI (fun j => n j + b j) q a o ∧
      outputI (fun j => n j + b j) q a o ≤ n o + b o := by
  have ha1 : a o ≤ 1 := by
    rw [← has]
    exact single_le_sum (fun j _ => ha j) (mem_univ o)
  have hh := dominant_hole he (hB o) (ha o) ha1 hβ
    (hole_bound hp hc hβ he hB) (hprop o) hroom
  have hn := holesI_nonneg (excess_nonneg (fun j => n j + b j) q) ha o
  unfold outputI holesI at *
  constructor <;> dsimp at * <;> linarith

/-! Rule II: the finite type I here indexes sides only, with the dominant
coordinate stored separately. Thus the formulation includes an empty side set. -/
def sideOutput (d w : I → ℝ) (D : ℝ) : I → ℝ := fun i => d i - D * w i
def dominantOutput (do_ q : ℝ) (d w : I → ℝ) (D : ℝ) : ℝ :=
  min do_ (q - ∑ i, sideOutput d w D i)
def dominantHole (R : ℝ) (ω : I → ℝ) : ℝ := max (R - ∑ i, ω i) 0

def totalExcess (do_ : ℝ) (d : I → ℝ) (q : ℝ) : ℝ :=
  max (do_ + (∑ i, d i) - q) 0

lemma dominant_hole_identity {do_ q D : ℝ} {d w : I → ℝ}
    (hD : 0 ≤ D) (hw : ∀ i, 0 ≤ w i) :
    do_ - dominantOutput do_ q d w D =
      dominantHole (totalExcess do_ d q) (fun i => D * w i) := by
  have hW : 0 ≤ ∑ i, D * w i := sum_nonneg fun i _ => mul_nonneg hD (hw i)
  have hs : (∑ i, sideOutput d w D i) = (∑ i, d i) - ∑ i, D * w i := by
    simp only [sideOutput, sum_sub_distrib]
  unfold dominantOutput dominantHole totalExcess
  rw [hs]
  have hsub (a b : ℝ) : a - min a b = max 0 (a - b) := by
    by_cases h : a ≤ b
    · rw [min_eq_left h, max_eq_left (by linarith)]; ring
    · rw [min_eq_right (le_of_not_ge h), max_eq_right (by linarith)]
  rw [hsub, max_comm (0 : ℝ)]
  by_cases hr : 0 ≤ do_ + (∑ i, d i) - q
  · rw [max_eq_left hr]
    congr 1
    ring
  · have he : do_ + (∑ i, d i) - q ≤ 0 := le_of_not_ge hr
    rw [max_eq_right he, max_eq_right (show do_ - (q - ((∑ i, d i) - ∑ i, D * w i)) ≤ 0 by linarith),
      max_eq_right (show (0 : ℝ) - (∑ i, D * w i) ≤ 0 by linarith)]

lemma holesII_sum {R : ℝ} {ω : I → ℝ} (_hω : ∀ i, 0 ≤ ω i) :
    dominantHole R ω + (∑ i, ω i) = max R (∑ i, ω i) := by
  unfold dominantHole
  rw [← max_add_add_right]
  congr 1 <;> ring

/-- Feasibility, with exactly the parent lower bound, regular flex caps,
side-proportion inequalities and dominant parameter slack used in §05. -/
lemma outputII_feasibility {n B f fc b w βi θ z : I → ℝ}
    {no Bo fo fco bo β βo D q : ℝ}
    (hD : 0 ≤ D) (hw : ∀ i, 0 ≤ w i) (_hB : ∀ i, 0 ≤ B i)
    (hβo : 0 ≤ βo) (hBo : 0 ≤ Bo)
    (hlcap : ∀ i, fc i ≤ b i) (hucap : ∀ i, b i ≤ f i)
    (hdomcap : fco ≤ bo)
    (hparent : no - β * Bo + fo + (∑ i, (n i - β * B i + f i)) ≤ q)
    (hupper : ∀ i, D * w i ≤ βi i * B i)
    (hlower : ∀ i, β * B i - D * θ i * z i ≤ D * w i)
    (hslack : D * (∑ i, θ i * z i) ≤
      (no - β * Bo + fo) - (no - βo * Bo + fco)) :
    (∀ i, n i - βi i * B i + fc i ≤ sideOutput (fun j => n j + b j) w D i ∧
       sideOutput (fun j => n j + b j) w D i ≤ n i + b i) ∧
    (no - βo * Bo + fco ≤ dominantOutput (no + bo) q (fun j => n j + b j) w D ∧
       dominantOutput (no + bo) q (fun j => n j + b j) w D ≤ no + bo) ∧
    dominantOutput (no + bo) q (fun j => n j + b j) w D +
       (∑ i, sideOutput (fun j => n j + b j) w D i) ≤ q := by
  have hside : ∀ i, n i - βi i * B i + fc i ≤ sideOutput (fun j => n j + b j) w D i ∧
       sideOutput (fun j => n j + b j) w D i ≤ n i + b i := by
    intro i
    have := hlcap i
    have := hupper i
    have := mul_nonneg hD (hw i)
    constructor <;> dsimp [sideOutput] <;> linarith
  have hs : (∑ i, sideOutput (fun j => n j + b j) w D i) ≤
        (∑ i, (n i - β * B i + f i)) + D * (∑ i, θ i * z i) := by
    rw [mul_sum, ← sum_add_distrib]
    apply sum_le_sum
    intro i _
    have := hucap i
    have := hlower i
    dsimp [sideOutput]
    nlinarith
  have hrem : no - βo * Bo + fco ≤
      q - (∑ i, sideOutput (fun j => n j + b j) w D i) := by linarith
  have hdc : no - βo * Bo + fco ≤ no + bo := by
    have := mul_nonneg hβo hBo
    linarith
  refine ⟨hside, ⟨le_min hdc hrem, min_le_left _ _⟩, ?_⟩
  have := min_le_right (no + bo) (q - ∑ i, sideOutput (fun j => n j + b j) w D i)
  unfold dominantOutput
  linarith

lemma dominantHole_lipschitz (R R' : ℝ) (ω ω' : I → ℝ) :
    |dominantHole R' ω' - dominantHole R ω| ≤ |R' - R| + variation ω' ω := by
  apply (positive_part_lipschitz _ _).trans
  calc |(R' - ∑ i, ω' i) - (R - ∑ i, ω i)| =
      |(R' - R) - ((∑ i, ω' i) - ∑ i, ω i)| := by congr 1; ring
    _ ≤ |R' - R| + |(∑ i, ω' i) - ∑ i, ω i| := abs_sub _ _
    _ ≤ _ := add_le_add (le_refl _) (variation_sum _ _)

lemma holesII_movement (R R' : ℝ) (ω ω' : I → ℝ) :
    |dominantHole R' ω' - dominantHole R ω| + variation ω' ω ≤
      |R' - R| + 2 * variation ω' ω := by
  have := dominantHole_lipschitz R R' ω ω'
  linarith

lemma scaled_movement {D D' Cw : ℝ} {w w' : I → ℝ} (hD' : 0 ≤ D')
    (hw : ∀ i, 0 ≤ w i) (hws : (∑ i, w i) ≤ Cw) :
    variation (fun i => D' * w' i) (fun i => D * w i) ≤
      D' * variation w' w + Cw * |D' - D| := by
  calc variation (fun i => D' * w' i) (fun i => D * w i) ≤
      (∑ i, (D' * |w' i - w i| + |D' - D| * w i)) := by
        apply sum_le_sum
        intro i _
        calc |D' * w' i - D * w i| = |D' * (w' i - w i) + (D' - D) * w i| := by congr 1; ring
          _ ≤ |D' * (w' i - w i)| + |(D' - D) * w i| := abs_add_le _ _
          _ = _ := by rw [abs_mul, abs_mul, abs_of_nonneg hD', abs_of_nonneg (hw i)]
    _ = D' * variation w' w + |D' - D| * (∑ i, w i) := by
      rw [sum_add_distrib, ← mul_sum, ← mul_sum]; rfl
    _ ≤ _ := by have := mul_le_mul_of_nonneg_left hws (abs_nonneg (D' - D)); nlinarith

lemma output_from_holes_movement (d d' ζ ζ' : I → ℝ) :
    variation (fun i => d' i - ζ' i) (fun i => d i - ζ i) ≤
      variation d' d + variation ζ' ζ := by
  rw [variation, variation, variation, ← sum_add_distrib]
  apply sum_le_sum
  intro i _
  calc |(d' i - ζ' i) - (d i - ζ i)| = |(d' i - d i) - (ζ' i - ζ i)| := by congr 1; ring
    _ ≤ _ := abs_sub _ _

/-- The parent coefficient is genuinely one, independent of degree. -/
lemma outputI_movement {d d' a a' : I → ℝ} {q q' : ℝ}
    (ha : ∀ i, 0 ≤ a i) (hsa : ∑ i, a i = 1) :
    variation (outputI d' q' a') (outputI d q a) ≤
      |q' - q| + 2 * variation d' d + excess d' q' * variation a' a := by
  have ho := output_from_holes_movement d d' (holesI (excess d q) a) (holesI (excess d' q') a')
  have hh := holesI_movement (R := excess d q) (a' := a') (excess_nonneg d' q') ha hsa
  have he := excess_lipschitz d' d q' q
  change variation (outputI d' q' a') (outputI d q a) ≤ _ at ho
  linarith


/-- A star as one dominant coordinate and a (possibly empty) finite side set. -/
def withDominant (x : ℝ) (xs : I → ℝ) : Option I → ℝ
  | none => x
  | some i => xs i

def holesII (R : ℝ) (ω : I → ℝ) : Option I → ℝ :=
  withDominant (dominantHole R ω) ω

def outputII (do_ q : ℝ) (d w : I → ℝ) (D : ℝ) : Option I → ℝ :=
  withDominant (dominantOutput do_ q d w D) (sideOutput d w D)

lemma variation_dominant (x x' : ℝ) (xs xs' : I → ℝ) :
    variation (withDominant x' xs') (withDominant x xs) = |x'-x|+variation xs' xs := by
  simp only [variation,Fintype.sum_option,withDominant]

lemma holesII_vector_sum {R : ℝ} {ω : I → ℝ} (hω : ∀ i, 0 ≤ ω i) :
    (∑ i, holesII R ω i)=max R (∑ i, ω i) := by
  simp only [holesII,Fintype.sum_option,withDominant]
  exact holesII_sum hω

lemma holesII_nonneg (R : ℝ) {ω : I → ℝ} (hω : ∀ i, 0 ≤ ω i) :
    ∀ i, 0 ≤ holesII R ω i := by
  intro i
  cases i with
  | none => exact le_max_right _ _
  | some i => exact hω i

lemma outputII_is_holes {do_ q D : ℝ} {d w : I → ℝ}
    (hD : 0 ≤ D) (hw : ∀ i, 0 ≤ w i) :
    outputII do_ q d w D = fun i => withDominant do_ d i -
      holesII (excess (withDominant do_ d) q) (fun i => D*w i) i := by
  have hr : excess (withDominant do_ d) q=totalExcess do_ d q := by
    simp only [excess,totalExcess,Fintype.sum_option,withDominant]
  funext i
  cases i with
  | none =>
    have hh := dominant_hole_identity (do_ := do_) (q := q) (d := d) hD hw
    simp only [outputII,withDominant,holesII,hr]
    linarith
  | some i => rfl

/-- Literal Rule II, not merely an assumed hole formula; coefficient of parent
movement is exactly one, also for inserted/deleted zero side coordinates. -/
lemma outputII_movement {do_ do' q q' D D' Cw : ℝ} {d d' w w' : I → ℝ}
    (hD : 0 ≤ D) (hD' : 0 ≤ D') (hw : ∀ i, 0 ≤ w i) (hw' : ∀ i, 0 ≤ w' i)
    (hws : (∑ i, w i) ≤ Cw) :
    variation (outputII do' q' d' w' D') (outputII do_ q d w D) ≤
      |q'-q|+2*variation (withDominant do' d') (withDominant do_ d)+
      2*D'*variation w' w+2*Cw*|D'-D| := by
  rw [outputII_is_holes hD' hw',outputII_is_holes hD hw]
  have hh := holesII_movement (excess (withDominant do_ d) q)
    (excess (withDominant do' d') q') (fun i => D*w i) (fun i => D'*w' i)
  have he := excess_lipschitz (withDominant do' d') (withDominant do_ d) q' q
  have hwv := scaled_movement hD' hw hws (w' := w') (D := D)
  have hv : variation (fun i => withDominant do' d' i -
        holesII (excess (withDominant do' d') q') (fun i => D'*w' i) i)
      (fun i => withDominant do_ d i -
        holesII (excess (withDominant do_ d) q) (fun i => D*w i) i) ≤
      variation (withDominant do' d') (withDominant do_ d) +
      |dominantHole (excess (withDominant do' d') q') (fun i => D'*w' i)-
        dominantHole (excess (withDominant do_ d) q) (fun i => D*w i)|+
      variation (fun i => D'*w' i) (fun i => D*w i) := by
    have h := output_from_holes_movement (withDominant do_ d) (withDominant do' d')
      (holesII (excess (withDominant do_ d) q) (fun i => D*w i))
      (holesII (excess (withDominant do' d') q') (fun i => D'*w' i))
    simpa only [holesII,variation_dominant,add_assoc] using h
  linarith

lemma variation_le_mass {z z' : I → ℝ} (hz : ∀ i, 0 ≤ z i) (hz' : ∀ i, 0 ≤ z' i) :
    variation z' z ≤ (∑ i, z' i)+(∑ i, z i) := by
  rw [←sum_add_distrib]
  apply sum_le_sum
  intro i _
  apply abs_sub_le_iff.mpr
  constructor <;> linarith [hz i,hz' i]

/-- A switch uses the actual old rule, without evaluating the unused rule at the
old inputs. These are the full downcrossing/upcrossing estimates of §05. -/
lemma downcross_movement {R R' D' Cr Cw : ℝ} {a : Option I → ℝ} {w' : I → ℝ}
    (hR : 0 ≤ R) (hR' : 0 ≤ R') (hD' : 0 ≤ D') (ha : ∀ i, 0 ≤ a i)
    (hsa : ∑ i, a i=1) (hw' : ∀ i, 0 ≤ w' i) (hws : (∑ i, w' i) ≤ Cw)
    (hr : R' ≤ Cr*D') :
    variation (holesII R' (fun i => D'*w' i)) (holesI R a) ≤
      |R'-R|+(2*Cr+Cw)*D' := by
  have hws' : (∑ i, D'*w' i) ≤ Cw*D' := by
    rw [←mul_sum]; nlinarith [mul_le_mul_of_nonneg_left hws hD']
  have hmax : max R' (∑ i, D'*w' i) ≤ R'+Cw*D' := by
    apply max_le
    · have hnn : 0 ≤ Cw := le_trans (sum_nonneg fun i _ => hw' i) hws
      nlinarith
    · linarith
  have hv := variation_le_mass (holesI_nonneg hR ha)
    (holesII_nonneg R' (fun i => mul_nonneg hD' (hw' i)))
  rw [holesI_sum hsa,holesII_vector_sum (fun i => mul_nonneg hD' (hw' i))] at hv
  have h1 := neg_le_abs (R'-R)
  nlinarith

lemma upcross_movement {R R' D D' S' Cr Cw : ℝ} {a' : Option I → ℝ} {w : I → ℝ}
    (hR : 0 ≤ R) (hR' : 0 ≤ R') (hD : 0 ≤ D) (_hD' : 0 ≤ D')
    (ha' : ∀ i, 0 ≤ a' i) (hsa : ∑ i, a' i=1)
    (hw : ∀ i, 0 ≤ w i) (hws : (∑ i, w i) ≤ Cw)
    (hr : R' ≤ Cr*S') (hreg : D' ≤ S'/2) :
    variation (holesI R' a') (holesII R (fun i => D*w i)) ≤
      |R'-R|+(2*Cr+Cw/2)*S'+Cw*|D'-D| := by
  have hc : 0 ≤ Cw := le_trans (sum_nonneg fun i _ => hw i) hws
  have hws' : (∑ i, D*w i) ≤ Cw*D := by
    rw [←mul_sum]; nlinarith [mul_le_mul_of_nonneg_left hws hD]
  have hmax : max R (∑ i, D*w i) ≤ R+Cw*D := by
    apply max_le
    · nlinarith
    · linarith
  have hv := variation_le_mass (holesII_nonneg R (fun i => mul_nonneg hD (hw i)))
    (holesI_nonneg hR' ha')
  rw [holesI_sum hsa,holesII_vector_sum (fun i => mul_nonneg hD (hw i))] at hv
  have h1 := neg_le_abs (R'-R)
  have h2 := mul_le_mul_of_nonneg_left (neg_le_abs (D'-D)) hc
  have h3 := mul_le_mul_of_nonneg_left hreg hc
  nlinarith

end KServer.OutputDynamics
end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.HeldWeights

/-- Literal regular gap weight; zero coordinates are harmless placeholders. -/
def regular (A a : ℝ) : ℝ := 1+max 0 (Real.log (A/a))

lemma regular_one (A a : ℝ) : 1 ≤ regular A a := by
  unfold regular; linarith [le_max_left (0:ℝ) (Real.log (A/a))]

lemma regular_log (A a : ℝ) : 1+Real.log (A/a) ≤ regular A a := by
  unfold regular; exact add_le_add le_rfl (le_max_right (0:ℝ) (Real.log (A/a)))

lemma regular_eq {A a : ℝ} (ha : 0<a) (hA : a≤A) :
    regular A a=1+Real.log (A/a) := by
  exact congrArg (fun x : ℝ => 1+x) (max_eq_right (Real.log_nonneg ((one_le_div ha).mpr hA)))

lemma regular_exp {A a : ℝ} (hA : 0<A) (ha : 0<a) :
    Real.exp (-regular A a) ≤ a/A := by
  have h : Real.log (A/a) ≤ regular A a := by linarith [regular_log A a]
  have he := Real.exp_le_exp.mpr (neg_le_neg h)
  rw [Real.exp_neg (Real.log (A/a)),Real.exp_log (div_pos hA ha)] at he
  simpa only [inv_div] using he

lemma regular_upper {A a k : ℝ} (hk : 1≤k) (hA : 0≤A)
    (hAk : A≤(11/10)*k) (ha : (9/100000:ℝ)≤a) :
    regular A a ≤ 20002*(1+Real.log (k+1)) := by
  have hk0 : 0<k := by linarith
  have ha0 : 0<a := by linarith
  have he : 0≤Real.log (k+1) := Real.log_nonneg (by linarith)
  have hlog : Real.log (A/a) ≤ 20000+Real.log (k+1) := by
    by_cases hAz : A=0
    · simp [hAz]; linarith
    have hA0 : 0<A := lt_of_le_of_ne hA (Ne.symm hAz)
    have hx : A/a ≤ 20000*(k+1) := by
      apply (div_le_iff₀ ha0).mpr
      have hm := mul_le_mul_of_nonneg_left ha (show 0≤20000*(k+1) by positivity)
      nlinarith
    have hl := Real.log_le_log (div_pos hA0 ha0) hx
    rw [Real.log_mul (by norm_num : (20000:ℝ)≠0) (by positivity : k+1≠0)] at hl
    have hc := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<20000)
    linarith
  have hm : max 0 (Real.log (A/a)) ≤ 20000+Real.log (k+1) := max_le (by linarith) hlog
  unfold regular
  nlinarith

lemma log_reciprocal_lower {u : ℝ} (hu : 0<u) (hu1 : u≤1/4) :
    1 ≤ Real.log (1/u) := by
  have h2 := Real.one_sub_inv_le_log_of_pos (by norm_num : (0:ℝ)<2)
  have hr : (4:ℝ)≤1/u := (le_div_iff₀ hu).mpr (by linarith)
  have hl := Real.log_le_log (by norm_num : (0:ℝ)<4) hr
  have he : Real.log (4:ℝ)=2*Real.log 2 := by
    rw [show (4:ℝ)=2^2 by norm_num,Real.log_pow]; norm_num
  rw [he] at hl
  norm_num at h2
  linarith

lemma side_lower {A a u : ℝ} (_hA : 0<A) (ha : 0<a) (hu : 0<u)
    (hu1 : u≤1/4) (has : a≤2*u*A) :
    (1/2:ℝ)*(1+Real.log (1/u)) ≤ regular A a := by
  have hx : 1/(2*u)≤A/a := by
    apply (div_le_div_iff₀ (show 0<2*u by positivity) ha).mpr
    nlinarith
  have hl := Real.log_le_log (by positivity : 0<1/(2*u)) hx
  rw [Real.log_div (by norm_num) (by positivity),Real.log_one,
    Real.log_mul (by norm_num) hu.ne'] at hl
  have hr : Real.log (1/u) = -Real.log u := by simp
  have h2 := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<2)
  have hrec := log_reciprocal_lower hu hu1
  have hr2 : (1/2:ℝ) ≤ Real.log 2 := by
    have hh := Real.one_sub_inv_le_log_of_pos (by norm_num : (0:ℝ)<2)
    norm_num at hh; exact hh
  -- The sharper logarithm relation avoids any numerical estimate of e.
  have hrec2 : 2*Real.log 2≤Real.log (1/u) := by
    have hh := Real.log_le_log (by norm_num : (0:ℝ)<4)
      ((le_div_iff₀ hu).mpr (by linarith) : (4:ℝ)≤1/u)
    rw [show (4:ℝ)=2^2 by norm_num,Real.log_pow] at hh
    norm_num only [Nat.cast_ofNat] at hh
    exact hh
  have hw := regular_log A a
  rw [hr] at hrec2 ⊢
  linarith

variable {J : Type} [Fintype J]

omit [Fintype J] in
lemma exp_sum {A : ℝ} {a : J → ℝ} (S : Finset J) (hA : 0<A)
    (ha : ∀ i∈S, 0<a i) (hS : (∑ i∈S,a i)≤(101/100)*A) :
    (∑ i∈S, Real.exp (-regular A (a i))) ≤ 2 := by
  have h := sum_le_sum (s:=S) (fun i hi => regular_exp hA (ha i hi))
  rw [←sum_div] at h
  have hh := (div_le_iff₀ hA).mpr hS
  linarith

omit [Fintype J] in
lemma side_exp_sum {A U : ℝ} {a : J → ℝ} (S : Finset J) (hA : 0<A)
    (ha : ∀ i∈S, 0<a i) (hS : (∑ i∈S,a i)≤2*U) :
    (∑ i∈S, Real.exp (-regular A (a i))) ≤ 2*(U/A) := by
  have h := sum_le_sum (s:=S) (fun i hi => regular_exp hA (ha i hi))
  rw [←sum_div] at h
  have hh := div_le_div_of_nonneg_right hS hA.le
  simpa only [mul_div_assoc] using h.trans hh

end KServer.HeldWeights

end


noncomputable section
open scoped BigOperators
open Finset
namespace KServer.CausalSimplex
open AdaptiveMinimization SimplexFamilies AdaptiveAllocation
variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R]

/-- Current held parameters and raw ranks. The latter are used only for the
initial minimizing selection, never substituted for the affine rank input. -/
structure Input (J R : Type) [Fintype J] where
  data : SimplexFamilies.Data J R
  ranks : J × R → ℝ
  epoch : ℕ

def prepared (old new : SimplexFamilies.Data J R) : SimplexFamilies.Data J R :=
  { old with flags := preparedFlags old.active new.active new.flags }

def prepare (C ell : ℝ) (old new : SimplexFamilies.Data J R)
    (p : J × R → ℝ) (a : J → ℝ) : J → ℝ :=
  (SimplexFamilies.family C ell).update (prepared old new) p
    (∑ i, core (prepared old new) p i) a

def candidate (C ell : ℝ) (old new : SimplexFamilies.Data J R)
    (p : J × R → ℝ) (a : J → ℝ) : J → ℝ :=
  ChangingDomains.transposeSimplex new.active (∑ i, core (prepared old new) p i) (prepare C ell old new p a)

/-- The membership branch totalizes the mathematical rule off its admitted
rank/parameter domain. The ordinary regular/marked lemmas below prove it is
never used on genuine source data. Wholesale steps use the canonical base. -/
def move (C ell : ℝ) (old new : Input J R) (p : J × R → ℝ) (a : J → ℝ) : J → ℝ := by
  classical
  exact if old.epoch = new.epoch then
    if candidate C ell old.data new.data p a ∈ ChangingDomains.simplex new.data.active
      then candidate C ell old.data new.data p a else ChangingDomains.canonical new.data.active
  else ChangingDomains.canonical new.data.active

lemma move_mem (C ell : ℝ) (old new : Input J R) (p : J × R → ℝ) (a : J → ℝ) :
    move C ell old new p a ∈ ChangingDomains.simplex new.data.active := by
  classical
  unfold move
  split_ifs with he hm
  · exact hm
  · exact ChangingDomains.canonical_mem _
  · exact ChangingDomains.canonical_mem _

/-- Only initialization changes the seed; the potential and coefficient are
the exact source primitives already proved affine in the raw ranks. -/
def model (C ell : ℝ) : Family (Input J R) (J × R) J where
  domain d := ChangingDomains.simplex d.data.active
  compact _data := ChangingDomains.simplex_compact _
  seed d := ⟨(SimplexFamilies.family C ell).update d.data d.ranks
    (∑ i, core d.data d.ranks i) (ChangingDomains.canonical d.data.active),
    (SimplexFamilies.family C ell).update_mem _ _ _ _⟩
  offset _ _ := 0
  coefficient d := SimplexFamilies.coefficient C ell d.data
  offset_continuous _ := continuousOn_const
  coefficient_continuous d := SimplexFamilies.coefficient_continuous C ell d.data

lemma model_value (C ell : ℝ) (d : Input J R) (p : J × R → ℝ) (a : J → ℝ) :
    (model C ell).value d p a = (SimplexFamilies.family C ell).value d.data p a := rfl

lemma model_update (C ell : ℝ) (d : Input J R) (p : J × R → ℝ) (c : ℝ) (a : J → ℝ) :
    (model C ell).update d p c a = (SimplexFamilies.family C ell).update d.data p c a := rfl

def transport (C ell : ℝ) : Transport (model (J:=J) (R:=R) C ell) where
  map := move C ell
  mem old new p a _ := move_mem C ell old new p a

variable {Ω : Type} [Fintype Ω]

def mass (d : Input J R) : ℝ := ∑ i, core d.data d.ranks i

def run (C ell : ℝ) (d : ℕ → Ω → Input J R) : ℕ → Ω → J → ℝ :=
  state (model C ell) (transport C ell) d (fun t ω => (d t ω).ranks)
    (fun t ω => mass (d t ω))

omit [Fintype Ω] in
lemma run_mem (C ell : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω) :
    run C ell d t ω ∈ ChangingDomains.simplex (d t ω).data.active :=
  state_mem (model C ell) (transport C ell) d (fun t ω => (d t ω).ranks)
    (fun t ω => mass (d t ω)) t ω

omit [Fintype Ω] in
lemma run_initial (C ell : ℝ) (d : ℕ → Ω → Input J R) (ω : Ω) :
    run C ell d 0 ω=(SimplexFamilies.family C ell).update (d 0 ω).data (d 0 ω).ranks
      (mass (d 0 ω)) (ChangingDomains.canonical (d 0 ω).data.active) := rfl

omit [Fintype Ω] in
lemma run_successor (C ell : ℝ) (d : ℕ → Ω → Input J R) (t : ℕ) (ω : Ω) :
    run C ell d (t+1) ω=(SimplexFamilies.family C ell).update (d (t+1) ω).data (d (t+1) ω).ranks
      (mass (d (t+1) ω)) (move C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks (run C ell d t ω)) := rfl

omit [Fintype Ω] in
lemma run_adapted (C ell : ℝ) (d : ℕ → Ω → Input J R) (H : ℕ → Ω → ℕ)
    (href : ∀ t ω z, H (t+1) ω=H (t+1) z → H t ω=H t z)
    (hd : ∀ t ω z, H t ω=H t z → d t ω=d t z) (t : ℕ) (ω z : Ω)
    (he : H t ω=H t z) : run C ell d t ω=run C ell d t z := by
  exact state_adapted _ _ _ _ _ H href hd
    (fun t ω z h => congrArg Input.ranks (hd t ω z h))
    (fun t ω z h => congrArg mass (hd t ω z h)) t ω z he

end KServer.CausalSimplex

namespace KServer.CausalSimplex
open AdaptiveMinimization SimplexFamilies AdaptiveAllocation
variable {J R : Type} [Fintype J] [DecidableEq J] [Fintype R]

lemma candidate_regular (A B : Finset J) (f g : J → R → Bool) (h h' : J → ℝ)
    (hh : ∀ i, 1≤h i) (hh' : ∀ i, 1≤h' i) (C ell ct : ℝ)
    (p : J × R → ℝ) (a : J → ℝ) :
    candidate C ell (regular A f h (fun i => ct*h i/ell) hh)
      (regular B g h' (fun i => ct*h' i/ell) hh') p a=
      regularTransport C ell ct A B g h hh p a := rfl

lemma move_regular {A B : Finset J} (hA : A.Nonempty) (hB : B.Nonempty)
    (f g : J → R → Bool) (h h' : J → ℝ)
    (hh : ∀ i, 1≤h i) (hh' : ∀ i, 1≤h' i)
    {C ell ct ηmax Cexp : ℝ} (hC : 0<C) (hl : 0<ell) (hc : 0<ct)
    (hmax : ∀ i∈A, ct*h i/ell≤ηmax) (hCexp : 0≤Cexp)
    (htail : ∑ i∈A, Real.exp (-h i)≤Cexp)
    (hgap : 2*(25+32*Cexp)*(1+ηmax)<C*ct)
    (p : J × R → ℝ) (hp : ∀ ir, 0≤p ir) (a : J → ℝ)
    (ha : a∈ChangingDomains.simplex A) (r r' : J × R → ℝ) (e : ℕ) :
    move C ell ⟨regular A f h (fun i => ct*h i/ell) hh,r,e⟩
      ⟨regular B g h' (fun i => ct*h' i/ell) hh',r',e⟩ p a=
      regularTransport C ell ct A B g h hh p a := by
  classical
  have hm := regular_transport_mem hA hB g h hh hC hl hc hmax hCexp htail hgap p hp a ha
  unfold move
  dsimp only
  rw [ite_eq_left rfl, candidate_regular]
  exact ite_eq_left hm

/-- The fully specified causal successor is the source's prepared/deleted/
minimized successor on an ordinary unmarked epoch. No policy-existence or
expected drift statement is an assumption. -/
lemma regular_successor {Ω : Type} [Fintype Ω] (d : ℕ → Ω → Input J R)
    (t : ℕ) (ω : Ω) {A B : Finset J} (hA : A.Nonempty) (hB : B.Nonempty)
    (f g : J → R → Bool) (h h' : J → ℝ)
    (hh : ∀ i, 1≤h i) (hh' : ∀ i, 1≤h' i)
    {C ell ct ηmax Cexp : ℝ} (hC : 0<C) (hl : 0<ell) (hc : 0<ct)
    (hmax : ∀ i∈A, ct*h i/ell≤ηmax) (hCexp : 0≤Cexp)
    (htail : ∑ i∈A, Real.exp (-h i)≤Cexp)
    (hgap : 2*(25+32*Cexp)*(1+ηmax)<C*ct)
    (hp : ∀ ir, 0≤(d (t+1) ω).ranks ir)
    (hold : (d t ω).data=regular A f h (fun i => ct*h i/ell) hh)
    (hnew : (d (t+1) ω).data=regular B g h' (fun i => ct*h' i/ell) hh')
    (he : (d t ω).epoch=(d (t+1) ω).epoch) :
    run C ell d (t+1) ω = regularStep C ell ct A B g h h' hh hh'
      (d (t+1) ω).ranks (run C ell d t ω) := by
  have ha := run_mem C ell d t ω
  rw [hold] at ha
  change run C ell d t ω∈ChangingDomains.simplex A at ha
  have hm := move_regular hA hB f g h h' hh hh' hC hl hc hmax hCexp htail hgap
    (d (t+1) ω).ranks hp (run C ell d t ω) ha (d t ω).ranks (d (t+1) ω).ranks (d t ω).epoch
  have eo : d t ω=⟨regular A f h (fun i => ct*h i/ell) hh,(d t ω).ranks,(d t ω).epoch⟩ :=
    congrArg (fun v => (⟨v,(d t ω).ranks,(d t ω).epoch⟩ : Input J R)) hold
  have en : d (t+1) ω=⟨regular B g h' (fun i => ct*h' i/ell) hh',(d (t+1) ω).ranks,(d t ω).epoch⟩ := by
    calc
      d (t+1) ω = ⟨regular B g h' (fun i => ct*h' i/ell) hh',
          (d (t+1) ω).ranks,(d (t+1) ω).epoch⟩ :=
        congrArg (fun v => (⟨v,(d (t+1) ω).ranks,(d (t+1) ω).epoch⟩ : Input J R)) hnew
      _ = _ := by rw [he]
  have hm' : move C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks (run C ell d t ω)=
      regularTransport C ell ct A B g h hh (d (t+1) ω).ranks (run C ell d t ω) :=
    (congrArg₂ (fun old new : Input J R => move C ell old new
      (d (t+1) ω).ranks (run C ell d t ω)) eo en).trans hm
  rw [run_successor,hm']
  unfold mass
  rw [hnew]
  rfl

lemma candidate_marked (A B : Finset J) (f g : J → R → Bool) (o : J)
    (h h' : J → ℝ) (u u' : ℝ) (hu : 0<u) (hu1 : u≤1)
    (hu' : 0<u') (hu1' : u'≤1) (hh : ∀ i≠o, 1≤h i) (hh' : ∀ i≠o, 1≤h' i)
    (C ell ct : ℝ) (p : J × R → ℝ) (a : J → ℝ) :
    candidate C ell (marked A f o h (fun i => ct*h i/ell) u hu hu1 hh)
      (marked B g o h' (fun i => ct*h' i/ell) u' hu' hu1' hh') p a=
      markedTransport C ell ct A B g o h u hu hu1 hh p a := rfl

lemma move_marked {A B : Finset J} {o : J} (hoA : o∈A) (hB : B.Nonempty)
    (f g : J → R → Bool) (h h' : J → ℝ) {u u' : ℝ}
    (hu : 0<u) (hu1 : u≤1) (hu' : 0<u') (hu1' : u'≤1)
    (ho : h o=u) (hh : ∀ i≠o, 1≤h i) (hh' : ∀ i≠o, 1≤h' i)
    {C ell ct ηmax Cexp c : ℝ} (hC : 0<C) (hl : 0<ell) (hc : 0<ct)
    (hmax : ∀ i∈A, ct*h i/ell≤ηmax) (hCexp : 0≤Cexp)
    (hsideC : 0<c) (hsideC1 : c≤1)
    (hside : ∀ i∈A, i≠o → c*(1+Real.log (1/u))≤h i)
    (htail : ∑ i∈A.erase o, Real.exp (-h i)≤Cexp*u)
    (hgap : 2*((25*c+2+32*Cexp)/c)*(1+ηmax)<C*ct)
    (p : J × R → ℝ) (hp : ∀ ir, 0≤p ir) (a : J → ℝ)
    (ha : a∈ChangingDomains.simplex A) (r r' : J × R → ℝ) (e : ℕ) :
    move C ell ⟨marked A f o h (fun i => ct*h i/ell) u hu hu1 hh,r,e⟩
      ⟨marked B g o h' (fun i => ct*h' i/ell) u' hu' hu1' hh',r',e⟩ p a=
      markedTransport C ell ct A B g o h u hu hu1 hh p a := by
  classical
  have hm := marked_transport_mem hoA hB g h hu hu1 ho hh hC hl hc hmax hCexp
    hsideC hsideC1 hside htail hgap p hp a ha
  unfold move
  dsimp only
  rw [ite_eq_left rfl, candidate_marked]
  exact ite_eq_left hm

lemma move_wholesale (C ell : ℝ) (old new : Input J R) (p : J × R → ℝ)
    (a : J → ℝ) (he : old.epoch≠new.epoch) :
    move C ell old new p a=ChangingDomains.canonical new.data.active := by
  simp only [move,ite_eq_right he]

lemma marked_successor {Ω : Type} [Fintype Ω] (d : ℕ → Ω → Input J R)
    (t : ℕ) (ω : Ω) {A B : Finset J} {o : J} (hoA : o∈A) (hB : B.Nonempty)
    (f g : J → R → Bool) (h h' : J → ℝ) {u u' : ℝ}
    (hu : 0<u) (hu1 : u≤1) (hu' : 0<u') (hu1' : u'≤1)
    (ho : h o=u) (hh : ∀ i≠o, 1≤h i) (hh' : ∀ i≠o, 1≤h' i)
    {C ell ct ηmax Cexp c : ℝ} (hC : 0<C) (hl : 0<ell) (hc : 0<ct)
    (hmax : ∀ i∈A, ct*h i/ell≤ηmax) (hCexp : 0≤Cexp)
    (hsideC : 0<c) (hsideC1 : c≤1)
    (hside : ∀ i∈A, i≠o → c*(1+Real.log (1/u))≤h i)
    (htail : ∑ i∈A.erase o, Real.exp (-h i)≤Cexp*u)
    (hgap : 2*((25*c+2+32*Cexp)/c)*(1+ηmax)<C*ct)
    (hp : ∀ ir, 0≤(d (t+1) ω).ranks ir)
    (hold : (d t ω).data=marked A f o h (fun i => ct*h i/ell) u hu hu1 hh)
    (hnew : (d (t+1) ω).data=marked B g o h' (fun i => ct*h' i/ell) u' hu' hu1' hh')
    (he : (d t ω).epoch=(d (t+1) ω).epoch) :
    run C ell d (t+1) ω = markedStep C ell ct A B g o h h' u u' hu hu1 hu' hu1' hh hh'
      (d (t+1) ω).ranks (run C ell d t ω) := by
  have ha := run_mem C ell d t ω
  rw [hold] at ha
  change run C ell d t ω∈ChangingDomains.simplex A at ha
  have hm := move_marked hoA hB f g h h' hu hu1 hu' hu1' ho hh hh' hC hl hc hmax hCexp
    hsideC hsideC1 hside htail hgap (d (t+1) ω).ranks hp (run C ell d t ω) ha
    (d t ω).ranks (d (t+1) ω).ranks (d t ω).epoch
  have eo : d t ω=⟨marked A f o h (fun i => ct*h i/ell) u hu hu1 hh,
      (d t ω).ranks,(d t ω).epoch⟩ :=
    congrArg (fun v => (⟨v,(d t ω).ranks,(d t ω).epoch⟩ : Input J R)) hold
  have en : d (t+1) ω=⟨marked B g o h' (fun i => ct*h' i/ell) u' hu' hu1' hh',
      (d (t+1) ω).ranks,(d t ω).epoch⟩ := by
    calc
      d (t+1) ω = ⟨marked B g o h' (fun i => ct*h' i/ell) u' hu' hu1' hh',
          (d (t+1) ω).ranks,(d (t+1) ω).epoch⟩ :=
        congrArg (fun v => (⟨v,(d (t+1) ω).ranks,(d (t+1) ω).epoch⟩ : Input J R)) hnew
      _ = _ := by rw [he]
  have hm' : move C ell (d t ω) (d (t+1) ω) (d (t+1) ω).ranks (run C ell d t ω)=
      markedTransport C ell ct A B g o h u hu hu1 hh (d (t+1) ω).ranks (run C ell d t ω) :=
    (congrArg₂ (fun old new : Input J R => move C ell old new
      (d (t+1) ω).ranks (run C ell d t ω)) eo en).trans hm
  rw [run_successor,hm']
  unfold mass
  rw [hnew]
  rfl

end KServer.CausalSimplex

end

end OAI