import Mathlib
import OAI.Probability.Contingency.DenseDyadic

namespace OAI

/-! Completions. -/

noncomputable section

open scoped BigOperators
open scoped BigOperators

namespace Contingency.PaddedGraph
variable {m n : ℕ}

def rowPadding (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (i : Fin m) : ℤ :=
  ∑ j, if IsLarge U r c (i,j) then (L:ℤ) else 0

def colPadding (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (j : Fin n) : ℤ :=
  ∑ i, if IsLarge U r c (i,j) then (L:ℤ) else 0

 

def Completion (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (X : State m n) :=
  { A : Cell m n → ℤ // (∀ w, 0 ≤ A w) ∧
    (∀ w, IsSmall U r c w → A w = 0) ∧
    (∀ i, rowSum A i = r i - rowSum X.x i + rowPadding U L r c i) ∧
    (∀ j, colSum A j = c j - colSum X.q j + colPadding U L r c j) }

instance completionFinite (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (X : State m n) :
    Finite (Completion U L r c X) := by
  let f : Completion U L r c X → (w : Cell m n) →
      Fin ((r w.1 - rowSum X.x w.1 + rowPadding U L r c w.1).toNat + 1) :=
    fun A w => ⟨(A.val w).toNat, by
      have h := coordinate_le_rowSum A.val A.property.1 w
      rw [A.property.2.2.1 w.1] at h
      have hh := Int.toNat_le_toNat h
      omega⟩
  apply Finite.of_injective f
  intro A B he
  apply Subtype.ext
  funext w
  have h := congrArg (fun g => (g w).val) he
  dsimp [f] at h
  have hA := A.property.1 w
  have hB := B.property.1 w
  omega

def completionRepair (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (X : State m n) (hd : DefectAt U r c s t X)
    (A : Completion U L r c X) : Completion U L r c (repair U r c s t X) := by
  let B := fun w => A.val w + if IsLarge U r c (receiver s t) then unit (receiver s t) w else 0
  refine ⟨B, ?_, ?_, ?_, ?_⟩
  · intro w
    have h := A.property.1 w
    dsimp [B,unit]
    split_ifs <;> omega
  · intro w hw
    dsimp [B]
    rw [A.property.2.1 w hw]
    by_cases hv : IsLarge U r c (receiver s t)
    · have he : w ≠ receiver s t := by intro he; exact hw (he ▸ hv)
      simp [hv,unit,he]
    · simp [hv]
  · intro i
    rw [repair_rowSum U r c s t X i]
    by_cases hv : IsLarge U r c (receiver s t)
    · have hb : B = fun w => A.val w - 0 + unit (receiver s t) w := by
        funext w; simp [B,hv]
      rw [hb,rowSum_sub_add,rowSum_unit,A.property.2.2.1 i]
      simp only [hv,true_and]
      have hz : rowSum (fun _ : Cell m n => (0:ℤ)) i = 0 := by simp [rowSum]
      rw [hz]
      dsimp [receiver]
      omega
    · have hb : B = A.val := by funext w; simp [B,hv]
      rw [hb,A.property.2.2.1 i]
      simp [hv]
  · intro j
    rw [repair_colSum U r c s t X hd j]
    by_cases hv : IsLarge U r c (receiver s t)
    · have hb : B = fun w => A.val w - 0 + unit (receiver s t) w := by
        funext w; simp [B,hv]
      rw [hb,colSum_sub_add,colSum_unit,A.property.2.2.2 j]
      simp only [hv,true_and]
      have hz : colSum (fun _ : Cell m n => (0:ℤ)) j = 0 := by simp [colSum]
      rw [hz]
      dsimp [receiver]
      omega
    · have hb : B = A.val := by funext w; simp [B,hv]
      rw [hb,A.property.2.2.2 j]
      simp [hv]

theorem completionRepair_injective (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (X : State m n) (hd : DefectAt U r c s t X) :
    Function.Injective (completionRepair U L r c s t X hd) := by
  intro A B he
  apply Subtype.ext
  funext w
  have h := congrArg (fun A : Completion U L r c (repair U r c s t X) => A.val w) he
  dsimp [completionRepair] at h
  linarith

 
noncomputable def weight (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (X : State m n) : ℕ := by
  classical
  exact if Feasible U r c X then Nat.card (Completion U L r c X) else 0

theorem weight_repair_le (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (X : State m n) (hd : DefectAt U r c s t X) :
    weight U L r c X ≤ weight U L r c (repair U r c s t X) := by
  classical
  by_cases hx : Feasible U r c X
  · rw [weight,ite_eq_left hx,weight,ite_eq_left (repair_feasible U r c s t X hx hd)]
    exact Nat.card_le_card_of_injective _ (completionRepair_injective U L r c s t X hd)
  · simp [weight,hx]

 

theorem joint_repair_injective (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) :
    Function.Injective (fun Z : Σ X : {X : State m n // DefectAt U r c s t X},
      Completion U L r c X.val =>
      (⟨repair U r c s t Z.1.val,
        completionRepair U L r c s t Z.1.val Z.1.property Z.2⟩ :
         Σ Y : State m n, Completion U L r c Y)) := by
  rintro ⟨⟨X,hX⟩,A⟩ ⟨⟨Y,hY⟩,B⟩ he
  have hs := congrArg Sigma.fst he
  have hxy := repair_injective U r c s t X Y hX hY hs
  subst Y
  have ha : completionRepair U L r c s t X hX A = completionRepair U L r c s t X hY B := by
    exact (Sigma.mk.inj he).2.eq
  have hab := completionRepair_injective U L r c s t X hX ha
  subst B
  rfl

end Contingency.PaddedGraph

 

 

open scoped BigOperators

namespace Contingency.PaddedGraph
variable {m n : ℕ}

instance feasibleFinite (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) :
    Finite {X : State m n // Feasible U r c X} := by
  let f : {X : State m n // Feasible U r c X} → Cell m n → Fin (U+1) × Fin (U+1) :=
    fun X w => (⟨(X.val.x w).toNat, by have h := X.property.1 w; omega⟩,
      ⟨(X.val.q w).toNat, by have h := X.property.1 w; omega⟩)
  apply Finite.of_injective f
  intro X Y he
  apply Subtype.ext
  have hx : X.val.x=Y.val.x := by
    funext w
    have h := congrArg (fun g => (g w).1.val) he
    dsimp [f] at h
    have hX := (X.property.1 w).1
    have hY := (Y.property.1 w).1
    omega
  have hq : X.val.q=Y.val.q := by
    funext w
    have h := congrArg (fun g => (g w).2.val) he
    dsimp [f] at h
    have hX := (X.property.1 w).2.2.1
    have hY := (Y.property.1 w).2.2.1
    omega
  cases X with | mk X hX =>
    cases Y with | mk Y hY =>
      cases X; cases Y
      simp_all

def Prefix (s : Cell m n) (σ : Cell m n → ℤ) (X : State m n) : Prop :=
  ∀ w, Before w s → X.x w = σ w ∧ X.q w = σ w

def ChildStates (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) :=
  {X : {X : State m n // Feasible U r c X} //
    Transversal X.val ∧ Prefix s σ X.val ∧ X.val.x s = l}

def DefectStates (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) :=
  {X : {X : State m n // Feasible U r c X} //
    DefectAt U r c s t X.val ∧ Prefix s σ X.val ∧ X.val.x s = l-1}

instance (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : Finite (ChildStates U r c s σ l) :=
  by unfold ChildStates; infer_instance
instance (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : Finite (DefectStates U r c s t σ l) :=
  by unfold DefectStates; infer_instance

noncomputable def conditionalRepair (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) (hst : Before s t)
    (X : DefectStates U r c s t σ l) :
    ChildStates U r c s σ (if t.1=s.1 then l else l-1) := by
  refine ⟨⟨repair U r c s t X.val.val,
    repair_feasible U r c s t X.val.val X.val.property X.property.1⟩,
    repair_transversal U r c s t X.val.val,?_,
    repair_special U r c s t X.val.val X.property.1 l X.property.2.2⟩
  intro w hw
  have h := repair_prefix U r c s t X.val.val X.property.1 hst w hw
  have h' := X.property.2.1 w hw
  exact ⟨h.1.trans h'.1,h.2.trans h'.2⟩

def childFiber (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) :=
  Σ X : ChildStates U r c s σ l, Completion U L r c X.val.val

def defectFiber (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) :=
  Σ X : DefectStates U r c s t σ l, Completion U L r c X.val.val

instance (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : Finite (childFiber U L r c s σ l) :=
  inferInstanceAs (Finite (Sigma _))
instance (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : Finite (defectFiber U L r c s t σ l) :=
  inferInstanceAs (Finite (Sigma _))

noncomputable def conditionalCompletionRepair (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) (hst : Before s t)
    (Z : defectFiber U L r c s t σ l) : childFiber U L r c s σ (if t.1=s.1 then l else l-1) :=
  ⟨conditionalRepair U r c s t σ l hst Z.1,
    completionRepair U L r c s t Z.1.val.val Z.1.property.1 Z.2⟩

theorem conditionalCompletionRepair_injective (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) (hst : Before s t) :
    Function.Injective (conditionalCompletionRepair U L r c s t σ l hst) := by
  rintro ⟨⟨⟨X,hfX⟩,hX⟩,A⟩ ⟨⟨⟨Y,hfY⟩,hY⟩,B⟩ he
  have hxy : repair U r c s t X = repair U r c s t Y :=
    congrArg (fun Z => Z.1.val.val) he
  have hxy' := repair_injective U r c s t X Y hX.1 hY.1 hxy
  subst Y
  have ha : completionRepair U L r c s t X hX.1 A = completionRepair U L r c s t X hY.1 B :=
    (Sigma.mk.inj he).2.eq
  have hab := completionRepair_injective U L r c s t X hX.1 ha
  subst B
  rfl

noncomputable def childMass (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : ℕ :=
  Nat.card (childFiber U L r c s σ l)

noncomputable def defectMass (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) : ℕ :=
  Nat.card (defectFiber U L r c s t σ l)

 

theorem conditional_repair_bound (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) (hst : Before s t) :
    defectMass U L r c s t σ l ≤
      if t.1=s.1 then childMass U L r c s σ l else childMass U L r c s σ (l-1) := by
  have h := Nat.card_le_card_of_injective _
    (conditionalCompletionRepair_injective U L r c s t σ l hst)
  change defectMass U L r c s t σ l ≤ childMass U L r c s σ (if t.1=s.1 then l else l-1) at h
  split_ifs at * <;> exact h

theorem conditional_repair_max (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (s t : Cell m n) (σ : Cell m n → ℤ) (l : ℤ) (hst : Before s t) :
    defectMass U L r c s t σ l ≤ max (childMass U L r c s σ (l-1)) (childMass U L r c s σ l) := by
  have h := conditional_repair_bound U L r c s t σ l hst
  split_ifs at h
  · exact h.trans (le_max_right _ _)
  · exact h.trans (le_max_left _ _)

end Contingency.PaddedGraph

 

 

open scoped BigOperators

namespace Contingency

 

theorem softPenalty_zero_iff {m n : ℕ}
    (r rb : Fin m → ℤ) (c cb : Fin n → ℤ) (B : Cell m n → ℤ)
    (small : Finset (Cell m n)) (p : Coordinate m n → ℤ) :
    softPenalty r rb c cb B small p = 0 ↔
      (∀ i : Fin m, (∑ j : Fin n, p (true,(i,j))) = rb i) ∧
      (∀ j : Fin n, (∑ i : Fin m, (B (i,j) - p (false,(i,j)))) = cb j) ∧
      (∀ i : Fin m, (∑ j : Fin n, if (i,j) ∈ small then p (true,(i,j)) else 0) ≤ r i) ∧
      (∀ j : Fin n, (∑ i : Fin m, if (i,j) ∈ small then B (i,j)-p (false,(i,j)) else 0) ≤ c j) := by
  classical
  rw [softPenalty_expansion]
  simp only [Nat.add_eq_zero_iff,Finset.sum_eq_zero_iff,Finset.mem_univ,true_implies,
    Int.natAbs_eq_zero,sub_eq_zero,Int.toNat_eq_zero,sub_nonpos]
  tauto

namespace PaddedGraph
variable {m n : ℕ}

def smallSet (U : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) : Finset (Cell m n) :=
  Finset.univ.filter (IsSmall U r c)

def capacity (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (w : Cell m n) : ℤ :=
  if IsLarge U r c w then C else U

def paddedRow (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (i : Fin m) : ℤ :=
  r i + rowPadding U L r c i

def paddedCol (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) (j : Fin n) : ℤ :=
  c j + colPadding U L r c j

 

def fullCoordinates (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (A : Cell m n → ℤ) : Coordinate m n → ℤ :=
  fun w => if w.1 then X.x w.2 + A w.2 else capacity U C r c w.2 - (X.q w.2 + A w.2)

theorem fullCoordinates_x (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (A : Cell m n → ℤ) (w : Cell m n) :
    fullCoordinates U C r c X A (true,w) = X.x w + A w := rfl

theorem fullCoordinates_q (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (A : Cell m n → ℤ) (w : Cell m n) :
    capacity U C r c w - fullCoordinates U C r c X A (false,w) = X.q w + A w := by
  simp [fullCoordinates]

theorem completion_cell_le (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (hf : Feasible U r c X) (A : Completion U L r c X)
    (w : Cell m n) : A.val w ≤ paddedRow U L r c w.1 := by
  have h := coordinate_le_rowSum A.val A.property.1 w
  rw [A.property.2.2.1 w.1] at h
  have hrow : 0 ≤ rowSum X.x w.1 := by
    apply Finset.sum_nonneg; intro j hj; exact (hf.1 (w.1,j)).1
  dsimp [paddedRow]
  omega

theorem fullCoordinates_inBox (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (hf : Feasible U r c X) (A : Completion U L r c X)
    (hC : ∀ i, paddedRow U L r c i ≤ C) :
    InBox (fun w => capacity U C r c w.2) (fullCoordinates U C r c X A.val) := by
  rintro ⟨b,w⟩
  have hX := hf.1 w
  by_cases hw : IsLarge U r c w
  · have hx0 := hf.2.1 w hw
    have hA := A.property.1 w
    have hAc := (completion_cell_le U L r c X hf A w).trans (hC w.1)
    cases b <;> simp [fullCoordinates,capacity,hw,hx0] <;> omega
  · have hA := A.property.2.1 w hw
    cases b <;> simp [fullCoordinates,capacity,hw,hA] <;> omega

theorem fullCoordinates_penalty_zero (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (hf : Feasible U r c X) (A : Completion U L r c X) :
    softPenalty (fun i => r i) (paddedRow U L r c) (fun j => c j) (paddedCol U L r c)
      (capacity U C r c) (smallSet U r c) (fullCoordinates U C r c X A.val) = 0 := by
  rw [softPenalty_zero_iff]
  have hsx (w : Cell m n) :
      (if w ∈ smallSet U r c then fullCoordinates U C r c X A.val (true,w) else 0) = X.x w := by
    by_cases hw : IsSmall U r c w
    · simp [smallSet,hw,fullCoordinates,A.property.2.1 w hw]
    · have hx := hf.2.1 w (Classical.not_not.mp hw)
      simp [smallSet,hw,hx]
  have hsq (w : Cell m n) :
      (if w ∈ smallSet U r c then capacity U C r c w -
          fullCoordinates U C r c X A.val (false,w) else 0) = X.q w := by
    rw [fullCoordinates_q]
    by_cases hw : IsSmall U r c w
    · simp [smallSet,hw,A.property.2.1 w hw]
    · have hx := hf.2.1 w (Classical.not_not.mp hw)
      simp [smallSet,hw,hx]
  refine ⟨?_,?_,?_,?_⟩
  · intro i
    simp only [fullCoordinates_x,Finset.sum_add_distrib]
    change rowSum X.x i + rowSum A.val i = _
    rw [A.property.2.2.1 i]
    dsimp [paddedRow]
    ring
  · intro j
    simp only [fullCoordinates_q,Finset.sum_add_distrib]
    change colSum X.q j + colSum A.val j = _
    rw [A.property.2.2.2 j]
    dsimp [paddedCol]
    ring
  · intro i; simp only [hsx]; exact (hf.2.2.1 i).1
  · intro j; simp only [hsq]; exact (hf.2.2.2 j).1

theorem sum_rowSum (x : Cell m n → ℤ) : (∑ i, rowSum x i) = ∑ w, x w := by
  simp [rowSum,Fintype.sum_prod_type]

theorem sum_colSum (x : Cell m n → ℤ) : (∑ j, colSum x j) = ∑ w, x w := by
  rw [← sum_rowSum]
  exact Finset.sum_comm

theorem padding_totals (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) :
    (∑ i, rowPadding U L r c i) = ∑ j, colPadding U L r c j := by
  exact Finset.sum_comm

theorem completion_small_totals (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) (X : State m n) (A : Completion U L r c X) :
    (∑ w, X.x w) = ∑ w, X.q w := by
  have hrow := congrArg (fun f : Fin m → ℤ => ∑ i, f i) (funext A.property.2.2.1)
  have hcol := congrArg (fun f : Fin n → ℤ => ∑ j, f j) (funext A.property.2.2.2)
  simp only [Finset.sum_add_distrib,Finset.sum_sub_distrib,sum_rowSum,sum_colSum] at hrow hcol
  have he : (∑ i, (r i:ℤ)) = ∑ j, (c j:ℤ) := by exact_mod_cast hrc
  have hpad := padding_totals U L r c
  omega

theorem fullCoordinates_total (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) (X : State m n) (A : Completion U L r c X) :
    (∑ w, fullCoordinates U C r c X A.val w) = ∑ w, capacity U C r c w := by
  simp only [Fintype.sum_prod_type,Fintype.sum_bool,fullCoordinates,ite_true,Bool.false_eq_true,ite_false]
  simp only [← Finset.sum_add_distrib]
  have he := completion_small_totals U L r c hrc X A
  simp only [Fintype.sum_prod_type] at he
  have hs : (∑ i, ∑ j, (X.x (i,j)+A.val (i,j) +
      (capacity U C r c (i,j)-(X.q (i,j)+A.val (i,j))))) =
      (∑ i, ∑ j, capacity U C r c (i,j)) +
      (∑ i, ∑ j, X.x (i,j)) - (∑ i, ∑ j, X.q (i,j)) := by
    simp only [← Finset.sum_add_distrib,← Finset.sum_sub_distrib]
    apply Finset.sum_congr rfl; intro i hi
    apply Finset.sum_congr rfl; intro j hj
    ring
  rw [hs,he]
  ring

 

theorem completion_softWeight_one (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) (X : State m n) (hf : Feasible U r c X)
    (A : Completion U L r c X) (hC : ∀ i, paddedRow U L r c i ≤ C) :
    softWeight 0 (fun i => r i) (paddedRow U L r c) (fun j => c j) (paddedCol U L r c)
      (capacity U C r c) (smallSet U r c) (fullCoordinates U C r c X A.val) = 1 := by
  rw [softWeight_zero,ite_eq_left]
  exact ⟨fullCoordinates_inBox U L C r c X hf A hC,
    fullCoordinates_total U L C r c hrc X A,
    fullCoordinates_penalty_zero U L C r c X hf A⟩

 
def LargeChoices (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) :=
  {A : Cell m n → ℤ // ∀ w, 0 ≤ A w ∧ A w ≤ C ∧ (IsSmall U r c w → A w=0)}

instance (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) : Finite (LargeChoices U C r c) := by
  let f : LargeChoices U C r c → Cell m n → Fin (C+1) :=
    fun A w => ⟨(A.val w).toNat,by have h := A.property w; omega⟩
  apply Finite.of_injective f
  intro A B h
  apply Subtype.ext; funext w
  have he := congrArg (fun z => (z w).val) h
  have hA := (A.property w).1
  have hB := (B.property w).1
  dsimp [f] at he
  omega

noncomputable instance (U C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ) :
    Fintype (LargeChoices U C r c) := Fintype.ofFinite _

def CompletionEquations (U L : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (A : Cell m n → ℤ) : Prop :=
  (∀ i, rowSum A i = r i-rowSum X.x i+rowPadding U L r c i) ∧
  (∀ j, colSum A j = c j-colSum X.q j+colPadding U L r c j)

def choiceCompletion (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (A : LargeChoices U C r c)
    (he : CompletionEquations U L r c X A.val) : Completion U L r c X :=
  ⟨A.val,fun w => (A.property w).1,fun w => (A.property w).2.2,he⟩

def completionChoice (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (hf : Feasible U r c X)
    (hC : ∀ i, paddedRow U L r c i ≤ C) (A : Completion U L r c X) :
    LargeChoices U C r c :=
  ⟨A.val,fun w => ⟨A.property.1 w,(completion_cell_le U L r c X hf A w).trans (hC w.1),
    A.property.2.1 w⟩⟩

def completionChoiceEquiv (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (X : State m n) (hf : Feasible U r c X) (hC : ∀ i, paddedRow U L r c i ≤ C) :
    Completion U L r c X ≃ {A : LargeChoices U C r c // CompletionEquations U L r c X A.val} where
  toFun A := ⟨completionChoice U L C r c X hf hC A,A.property.2.2⟩
  invFun A := choiceCompletion U L C r c X A.val A.property
  left_inv _ := rfl
  right_inv _ := rfl

theorem choice_softWeight (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) (X : State m n) (hf : Feasible U r c X)
    (A : LargeChoices U C r c) (hC : ∀ i, paddedRow U L r c i ≤ C) :
    softWeight 0 (fun i => r i) (paddedRow U L r c) (fun j => c j) (paddedCol U L r c)
      (capacity U C r c) (smallSet U r c) (fullCoordinates U C r c X A.val) =
    (by classical exact if CompletionEquations U L r c X A.val then (1:ℝ) else 0) := by
  classical
  by_cases he : CompletionEquations U L r c X A.val
  · exact (completion_softWeight_one U L C r c hrc X hf
      (choiceCompletion U L C r c X A he) hC).trans (ite_eq_left he).symm
  · rw [ite_eq_right he,softWeight_zero,ite_eq_right]
    rintro ⟨_,_,hp⟩
    apply he
    rw [softPenalty_zero_iff] at hp
    constructor
    · intro i
      have h := hp.1 i
      simp only [fullCoordinates_x,Finset.sum_add_distrib] at h
      change rowSum X.x i + rowSum A.val i = r i + rowPadding U L r c i at h
      omega
    · intro j
      have h := hp.2.1 j
      simp only [fullCoordinates_q,Finset.sum_add_distrib] at h
      change colSum X.q j + colSum A.val j = c j + colPadding U L r c j at h
      omega

 

theorem sum_choice_softWeight (U L C : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) (X : State m n) (hf : Feasible U r c X)
    (hC : ∀ i, paddedRow U L r c i ≤ C) :
    (∑ A : LargeChoices U C r c,
      softWeight 0 (fun i => r i) (paddedRow U L r c) (fun j => c j) (paddedCol U L r c)
        (capacity U C r c) (smallSet U r c) (fullCoordinates U C r c X A.val)) =
      (Nat.card (Completion U L r c X) : ℝ) := by
  classical
  simp_rw [choice_softWeight U L C r c hrc X hf _ hC]
  rw [Nat.card_congr (completionChoiceEquiv U L C r c X hf hC)]
  rw [Nat.card_eq_fintype_card,Fintype.card_subtype]
  simp

end PaddedGraph
end Contingency

end

end OAI