lean/OAI/Probability/Contingency/LawComposition.lean

import Mathlib
import OAI.Probability.Contingency.DyadicLaws

namespace OAI

/-! Law Composition. -/

noncomputable section

open scoped BigOperators
open scoped BigOperators
namespace Contingency.Law
noncomputable section
variable {α β γ : Type*} [Fintype α] [Fintype β] [Fintype γ]

theorem pure_bind (x : α) (f : α → Law β) : (pure x).bind f=f x := by
  classical
  apply Law.ext; funext y
  simp [bind,pure]

theorem bind_assoc (p : Law α) (f : α → Law β) (g : β → Law γ) :
    (p.bind f).bind g=p.bind (fun x => (f x).bind g) := by
  apply Law.ext; funext y
  simp only [bind,Finset.sum_mul,Finset.mul_sum,mul_assoc]
  exact Finset.sum_comm

theorem map_bind (p : Law α) (f : α → β) (g : β → Law γ) :
    (p.map f).bind g=p.bind (fun x => g (f x)) := by
  simp only [map,bind_assoc,pure_bind]

theorem map_map (p : Law α) (f : α → β) (g : β → γ) :
    (p.map f).map g=p.map (fun x => g (f x)) := by
  change (p.map f).bind _=_
  rw [map_bind]
  rfl

end
end Contingency.Law

 

 

open scoped BigOperators
open Filter

namespace Contingency

 
def Tables {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) :=
  {X : Fin m → Fin n → ℕ //
    (∀ i, ∑ j, X i j = r i) ∧ (∀ j, ∑ i, X i j = c j)}

instance tablesFinite {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) :
    Finite (Tables r c) := by
  let f : Tables r c → (i : Fin m) → Fin n → Fin (r i + 1) :=
    fun X i j => ⟨X.val i j, by
      have := Finset.single_le_sum (fun (j : Fin n) _ => Nat.zero_le (X.val i j))
        (Finset.mem_univ j)
      rw [X.property.1 i] at this
      omega⟩
  apply Finite.of_injective f
  intro X Y h
  apply Subtype.ext
  funext i j
  exact congrArg Fin.val (congrFun (congrFun h i) j)

 

def encodeNat (x : ℕ) : List Bool :=
  List.replicate x.bits.length true ++ false :: x.bits

def encodeList (xs : List ℕ) : List Bool := xs.flatMap encodeNat

def inputBits {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) (k : ℕ) : List Bool :=
  encodeList ([m, n, k] ++ List.ofFn r ++ List.ofFn c)

def outputBits {m n : ℕ} {r : Fin m → ℕ} {c : Fin n → ℕ}
    (X : Tables r c) : List Bool :=
  encodeList ((List.ofFn fun i => List.ofFn (X.val i)).flatten)

namespace BitModel

inductive Move | left | stay | right
  deriving DecidableEq

 

structure Tape where
  left : List (Option Bool)
  head : Option Bool
  right : List (Option Bool)
  deriving DecidableEq

def Tape.blank : Tape := ⟨[], none, []⟩

def Tape.ofInput (xs : List Bool) : Tape :=
  match xs with
  | [] => .blank
  | x :: xs => ⟨[], some x, xs.map some⟩

def Tape.move (d : Move) (a : Option Bool) (t : Tape) : Tape :=
  match d with
  | .stay => ⟨t.left, a, t.right⟩
  | .left => match t.left with
    | [] => ⟨[], none, a :: t.right⟩
    | x :: xs => ⟨xs, x, a :: t.right⟩
  | .right => match t.right with
    | [] => ⟨a :: t.left, none, []⟩
    | x :: xs => ⟨a :: t.left, x, xs⟩

 

structure Instruction (states tapes : ℕ) where
  next : Option (Fin states)
  write : Fin tapes → Option Bool
  move : Fin tapes → Move
  emit : Option Bool

 

structure Machine where
  states : ℕ
  tapes : ℕ
  start : Fin states
  inputTape : Fin tapes
  transition : Fin states → Bool → (Fin tapes → Option Bool) → Instruction states tapes

structure Config (M : Machine) where
  state : Option (Fin M.states)
  tape : Fin M.tapes → Tape
  outputRev : List Bool

def Machine.initial (M : Machine) (xs : List Bool) : Config M :=
  ⟨some M.start, fun i => if i = M.inputTape then .ofInput xs else .blank, []⟩

def Machine.step (M : Machine) (coin : Bool) (c : Config M) : Config M :=
  match c.state with
  | none => c
  | some s =>
    let a := M.transition s coin (fun i => (c.tape i).head)
    ⟨a.next, fun i => (c.tape i).move (a.move i) (a.write i),
      match a.emit with | none => c.outputRev | some b => b :: c.outputRev⟩

def Machine.run (M : Machine) (xs : List Bool) {t : ℕ} (coins : Fin t → Bool) : Config M :=
  (List.ofFn coins).foldl (fun c b => M.step b c) (M.initial xs)

 

noncomputable def Machine.mass (M : Machine) (xs out : List Bool) (t : ℕ) : ℝ :=
  ((Finset.univ.filter fun coins : Fin t → Bool =>
    (M.run xs coins).state = none ∧ (M.run xs coins).outputRev.reverse = out).card : ℝ) /
    2 ^ t

 
noncomputable def Machine.tail (M : Machine) (xs : List Bool) (t : ℕ) : ℝ :=
  ((Finset.univ.filter fun coins : Fin t → Bool =>
    (M.run xs coins).state ≠ none).card : ℝ) / 2 ^ t

end BitModel

 

def inputSize (m n N : ℕ) : ℕ := m + n + Nat.log2 (N + 1) + 1

noncomputable def variationBy {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
    (M : BitModel.Machine) (k t : ℕ) : ℝ := by
  letI := Fintype.ofFinite (Tables r c)
  exact (∑ X : Tables r c,
    |M.mass (inputBits r c k) (outputBits X) t - 1 / Fintype.card (Tables r c)|) / 2

 

def BoundedMain : Prop :=
  ∃ (M : BitModel.Machine) (A q : ℕ),
    ∀ (m n : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ),
      (∑ i, r i) = (∑ j, c j) → ∀ k : ℕ, 1 ≤ k →
      ∃ t : ℕ, t ≤ A * (inputSize m n (∑ i, r i) + k) ^ q ∧
        (∀ coins : Fin t → Bool,
          (M.run (inputBits r c k) coins).state = none ∧
          ∃ X : Tables r c,
            (M.run (inputBits r c k) coins).outputRev.reverse = outputBits X) ∧
        variationBy r c M k t ≤ (2 : ℝ) ^ (-(k : ℤ))

 

def ExactMain : Prop :=
  ∃ (M : BitModel.Machine) (A q : ℕ),
    ∀ (m n : ℕ) (r : Fin m → ℕ) (c : Fin n → ℕ),
      (∑ i, r i) = (∑ j, c j) →
      (∀ (t : ℕ) (coins : Fin t → Bool),
        (M.run (inputBits r c 0) coins).state = none → ∃ X : Tables r c,
          (M.run (inputBits r c 0) coins).outputRev.reverse = outputBits X) ∧
      Tendsto (M.tail (inputBits r c 0)) atTop (nhds 0) ∧
      (∀ X : Tables r c, Tendsto (M.mass (inputBits r c 0) (outputBits X))
        atTop (nhds (1 / (Nat.card (Tables r c) : ℝ)))) ∧
      Summable (M.tail (inputBits r c 0)) ∧
      (∑' t, M.tail (inputBits r c 0) t) ≤
        (A * (inputSize m n (∑ i, r i)) ^ q : ℕ)

 

def MainTheorem : Prop := BoundedMain ∧ ExactMain

end Contingency

 

 

open scoped BigOperators

namespace Contingency

 

theorem tables_nonempty {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
    (hrc : (∑ i, r i) = ∑ j, c j) : Nonempty (Tables r c) := by
  classical
  let e : (Σ i, Fin (r i)) ≃ (Σ j, Fin (c j)) :=
    Fintype.equivOfCardEq (by simpa [Fintype.card_sigma] using hrc)
  let X (i : Fin m) (j : Fin n) : ℕ := ∑ z : (Σ i, Fin (r i)),
    (if z.1=i then 1 else 0)*(if (e z).1=j then 1 else 0)
  refine ⟨⟨X,?_,?_⟩⟩
  · intro i
    change (∑ j, ∑ z : (Σ i, Fin (r i)),
      (if z.1=i then 1 else 0)*(if (e z).1=j then 1 else 0)) = r i
    rw [Finset.sum_comm]
    simp only [← Finset.mul_sum]
    have hz (z : Σ i, Fin (r i)) : (∑ j, if (e z).1=j then (1:ℕ) else 0)=1 := by simp
    simp only [hz,mul_one]
    rw [Fintype.sum_sigma]
    change (∑ a, ∑ _t : Fin (r a), if a=i then (1:ℕ) else 0)=r i
    simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,mul_ite,mul_one,mul_zero]
    simp
  · intro j
    change (∑ i, ∑ z : (Σ i, Fin (r i)),
      (if z.1=i then 1 else 0)*(if (e z).1=j then 1 else 0)) = c j
    rw [Finset.sum_comm]
    simp only [← Finset.sum_mul]
    have hz (z : Σ i, Fin (r i)) : (∑ i, if z.1=i then (1:ℕ) else 0)=1 := by simp
    simp only [hz,one_mul]
    calc
      _ = ∑ z : (Σ j, Fin (c j)), if z.1=j then (1:ℕ) else 0 :=
        e.sum_comp (fun z : (Σ j, Fin (c j)) => if z.1=j then (1:ℕ) else 0)
      _ = _ := by
        rw [Fintype.sum_sigma]
        change (∑ a, ∑ _t : Fin (c a), if a=j then (1:ℕ) else 0)=c j
        simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,mul_ite,mul_one,mul_zero]
        simp

end Contingency

 

 

open scoped BigOperators
namespace Contingency
noncomputable section

lemma sum_dite_subtype {α M : Type*} [Fintype α] [AddCommMonoid M]
    (p : α → Prop) [DecidablePred p] (f : {x // p x} → M) :
    (∑ x, if h : p x then f ⟨x,h⟩ else 0)=∑ x,f x := by
  symm
  apply Fintype.sum_of_injective Subtype.val Subtype.val_injective
  · intro i hi
    split_ifs with h
    · exact (hi ⟨⟨i,h⟩,rfl⟩).elim
    · rfl
  · intro i; simp [i.property]

variable {m n a b : ℕ} {r : Fin m → ℕ} {c : Fin n → ℕ}

theorem table_cell_le_row (X : Tables r c) (i : Fin m) (j : Fin n) : X.val i j≤r i := by
  rw [← X.property.1 i]
  exact Finset.single_le_sum (fun j _ => Nat.zero_le (X.val i j)) (Finset.mem_univ j)

theorem table_cell_le_col (X : Tables r c) (i : Fin m) (j : Fin n) : X.val i j≤c j := by
  rw [← X.property.2 j]
  exact Finset.single_le_sum (fun i _ => Nat.zero_le (X.val i j)) (Finset.mem_univ i)

variable (p : Fin m → Prop) (q : Fin n → Prop) [DecidablePred p] [DecidablePred q]
    (er : Fin a ≃ {i // p i}) (ec : Fin b ≃ {j // q j})
    (hr : ∀ i,¬p i → r i=0) (hc : ∀ j,¬q j → c j=0)

def restrictTable (X : Tables r c) :
    Tables (fun i => r (er i).val) (fun j => c (ec j).val) := by
  refine ⟨fun i j => X.val (er i).val (ec j).val,?_,?_⟩
  · intro i
    rw [ec.sum_comp (fun j => X.val (er i).val j.val)]
    calc
      _ = ∑ j,X.val (er i).val j := by
        apply Fintype.sum_of_injective Subtype.val Subtype.val_injective
        · intro j hj
          have hn : ¬q j := fun h => hj ⟨⟨j,h⟩,rfl⟩
          have h := table_cell_le_col X (er i).val j
          rw [hc j hn] at h
          omega
        · intro j; rfl
      _ = _ := X.property.1 _
  · intro j
    rw [er.sum_comp (fun i => X.val i.val (ec j).val)]
    calc
      _ = ∑ i,X.val i (ec j).val := by
        apply Fintype.sum_of_injective Subtype.val Subtype.val_injective
        · intro i hi
          have hn : ¬p i := fun h => hi ⟨⟨i,h⟩,rfl⟩
          have h := table_cell_le_row X i (ec j).val
          rw [hr i hn] at h
          omega
        · intro i; rfl
      _ = _ := X.property.2 _

def expandTable (X : Tables (fun i => r (er i).val) (fun j => c (ec j).val)) : Tables r c := by
  refine ⟨fun i j => if hi : p i then if hj : q j then X.val (er.symm ⟨i,hi⟩) (ec.symm ⟨j,hj⟩) else 0 else 0,?_,?_⟩
  · intro i
    by_cases hi : p i
    · simp only [dite_eq_left hi]
      rw [sum_dite_subtype q (fun j => X.val (er.symm ⟨i,hi⟩) (ec.symm j))]
      rw [← ec.sum_comp (fun j => X.val (er.symm ⟨i,hi⟩) (ec.symm j))]
      simp only [Equiv.symm_apply_apply]
      simp only [X.property.1,Equiv.apply_symm_apply]
    · simp [hi,hr i hi]
  · intro j
    by_cases hj : q j
    · simp only [dite_eq_left hj]
      rw [sum_dite_subtype p (fun i => X.val (er.symm i) (ec.symm ⟨j,hj⟩))]
      rw [← er.sum_comp (fun i => X.val (er.symm i) (ec.symm ⟨j,hj⟩))]
      simp only [Equiv.symm_apply_apply]
      simp only [X.property.2,Equiv.apply_symm_apply]
    · simp [hj,hc j hj]

 

def restrictTableEquiv : Tables r c ≃ Tables (fun i => r (er i).val) (fun j => c (ec j).val) where
  toFun := restrictTable p q er ec hr hc
  invFun := expandTable p q er ec hr hc
  left_inv X := by
    apply Subtype.ext; funext i j
    by_cases hi : p i
    · by_cases hj : q j
      · simp [expandTable,restrictTable,hi,hj]
      · have hz : X.val i j=0 := by have h := table_cell_le_col X i j; rw [hc j hj] at h; omega
        simp [expandTable,hi,hj,hz]
    · have hz : X.val i j=0 := by have h := table_cell_le_row X i j; rw [hr i hi] at h; omega
      simp [expandTable,hi,hz]
  right_inv X := by
    apply Subtype.ext; funext i j
    simp [restrictTable,expandTable,(er i).property,(ec j).property]

end
end Contingency

 

 

open scoped BigOperators
namespace Contingency
noncomputable section

def maximizers {a : ℕ} (R : Fin (a+1) → ℕ) : Finset (Fin (a+1)) :=
  Finset.univ.filter (fun i => ∀ j,R j≤R i)

theorem maximizers_nonempty {a : ℕ} (R : Fin (a+1) → ℕ) : (maximizers R).Nonempty := by
  obtain ⟨i,_,hi⟩ := Finset.exists_max_image Finset.univ R Finset.univ_nonempty
  exact ⟨i,by simpa [maximizers] using hi⟩

 
def maximumIndex {a : ℕ} (R : Fin (a+1) → ℕ) : Fin (a+1) := (maximizers R).min' (maximizers_nonempty R)

theorem maximumIndex_max {a : ℕ} (R : Fin (a+1) → ℕ) (i : Fin (a+1)) : R i≤R (maximumIndex R) := by
  have hh := Finset.min'_mem (maximizers R) (maximizers_nonempty R)
  exact (Finset.mem_filter.mp hh).2 i

theorem maximumIndex_first {a : ℕ} (R : Fin (a+1) → ℕ) (i : Fin (a+1))
    (hi : ∀ j,R j≤R i) : maximumIndex R ≤ i := Finset.min'_le _ i (by simp [maximizers,hi])

def marginOrder {a : ℕ} (R : Fin (a+1) → ℕ) : Fin (a+1) ≃ Fin (a+1) :=
  Equiv.swap (maximumIndex R) (Fin.last a)

theorem marginOrder_max {a : ℕ} (R : Fin (a+1) → ℕ) (i : Fin (a+1)) :
    R (marginOrder R i)≤R (marginOrder R (Fin.last a)) := by
  rw [marginOrder,Equiv.swap_apply_right]
  exact maximumIndex_max _ _

variable {m n a b : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) (er : Fin a ≃ Fin m) (ec : Fin b ≃ Fin n)

def permuteTable (X : Tables r c) : Tables (fun i => r (er i)) (fun j => c (ec j)) :=
  ⟨fun i j => X.val (er i) (ec j),fun row => (ec.sum_comp _).trans (X.property.1 (er row)),
    fun column => (er.sum_comp _).trans (X.property.2 (ec column))⟩

def permuteTableEquiv : Tables r c ≃ Tables (fun i => r (er i)) (fun j => c (ec j)) where
  toFun := permuteTable r c er ec
  invFun X := ⟨fun i j => X.val (er.symm i) (ec.symm j),by
    constructor
    · intro i
      rw [ec.symm.sum_comp (fun j => X.val (er.symm i) j),X.property.1]
      simp
    · intro j
      rw [er.symm.sum_comp (fun i => X.val i (ec.symm j)),X.property.2]
      simp⟩
  left_inv X := by apply Subtype.ext; funext i j; simp [permuteTable]
  right_inv X := by apply Subtype.ext; funext i j; simp [permuteTable]

namespace Law
variable {α β : Type*} [Fintype α] [Fintype β] [Nonempty α] [Nonempty β]

theorem uniform_map_equiv (e : α ≃ β) : (uniform α).map e=uniform β := by
  classical
  apply Law.ext; funext y
  have he (x : α) : e x=y ↔ x=e.symm y := e.eq_symm_apply.symm
  simp only [map,bind,pure,mul_ite,mul_one,mul_zero,he]
  simp only [Finset.sum_ite_eq',Finset.mem_univ,ite_true,uniform,Fintype.card_congr e]

end Law
end
end Contingency

 

 

open scoped BigOperators
namespace Contingency.Dense
noncomputable section
variable {a c : ℕ}

 

def complete (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (x : Fin a → Fin c → ℝ) :
    Fin (a+1) → Fin (c+1) → ℝ :=
  Fin.lastCases
    (Fin.lastCases (R (Fin.last a)-(∑ j : Fin c,P j.castSucc)+(∑ i,∑ j,x i j))
      (fun j => P j.castSucc-∑ i,x i j))
    (fun i => Fin.lastCases (R i.castSucc-∑ j,x i j) (fun j => x i j))

@[simp] theorem complete_free (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) (i : Fin a) (j : Fin c) :
    complete R P x i.castSucc j.castSucc=x i j := by simp [complete]

@[simp] theorem complete_right (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) (i : Fin a) :
    complete R P x i.castSucc (Fin.last c)=R i.castSucc-∑ j,x i j := by simp [complete]

@[simp] theorem complete_bottom (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) (j : Fin c) :
    complete R P x (Fin.last a) j.castSucc=P j.castSucc-∑ i,x i j := by simp [complete]

@[simp] theorem complete_corner (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) :
    complete R P x (Fin.last a) (Fin.last c)=
      R (Fin.last a)-(∑ j : Fin c,P j.castSucc)+(∑ i,∑ j,x i j) := by simp [complete]

@[simp] theorem complete_row (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) (i : Fin (a+1)) : ∑ j,complete R P x i j=R i := by
  refine Fin.lastCases ?_ (fun i => ?_) i
  · rw [Fin.sum_univ_castSucc]
    simp only [complete_bottom,complete_corner,Finset.sum_sub_distrib]
    rw [Finset.sum_comm (f:=fun i j => x i j)]
    ring
  · rw [Fin.sum_univ_castSucc]
    simp only [complete_free,complete_right]
    ring

@[simp] theorem complete_col (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (x : Fin a → Fin c → ℝ) (h : (∑ i,R i)=∑ j,P j) (j : Fin (c+1)) :
    ∑ i,complete R P x i j=P j := by
  refine Fin.lastCases ?_ (fun j => ?_) j
  · rw [Fin.sum_univ_castSucc]
    simp only [complete_right,complete_corner,Finset.sum_sub_distrib]
    rw [Fin.sum_univ_castSucc,Fin.sum_univ_castSucc] at h
    linarith
  · rw [Fin.sum_univ_castSucc]
    simp only [complete_free,complete_bottom]
    ring

 
theorem complete_represents (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (X : Fin (a+1) → Fin (c+1) → ℝ)
    (hR : ∀ i,∑ j,X i j=R i) (hP : ∀ j,∑ i,X i j=P j) :
    complete R P (fun i j => X i.castSucc j.castSucc)=X := by
  funext i j
  refine Fin.lastCases ?_ (fun i => ?_) i
  · refine Fin.lastCases ?_ (fun j => ?_) j
    · have hr := hR (Fin.last a)
      rw [Fin.sum_univ_castSucc] at hr
      have hp (j : Fin c) := hP j.castSucc
      simp only [Fin.sum_univ_castSucc] at hp
      have he : (∑ j : Fin c,X (Fin.last a) j.castSucc)=
          (∑ j : Fin c,P j.castSucc)-(∑ i : Fin a,∑ j : Fin c,X i.castSucc j.castSucc) := by
        rw [Finset.sum_comm (f:=fun (i : Fin a) (j : Fin c) => X i.castSucc j.castSucc),← Finset.sum_sub_distrib]
        apply Finset.sum_congr rfl; intro j _; linarith [hp j]
      rw [he] at hr
      rw [complete_corner]
      linarith
    · rw [complete_bottom]
      have hp := hP j.castSucc
      rw [Fin.sum_univ_castSucc] at hp
      linarith
  · refine Fin.lastCases ?_ (fun j => ?_) j
    · rw [complete_right]
      have hr := hR i.castSucc
      rw [Fin.sum_univ_castSucc] at hr
      linarith
    · exact complete_free R P _ i j

def scale (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (i : Fin (a+1)) (j : Fin (c+1)) : ℝ :=
  min (R i) (P j)

def scaled (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) (u : Fin a×Fin c → ℝ) :=
  complete R P (fun i j => w i j*u (i,j))

def normalized (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) (u : Fin a×Fin c → ℝ) (i : Fin (a+1)) (j : Fin (c+1)) : ℝ :=
  scaled R P w u i j/scale R P i j

def polytope (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) : Set (Fin a×Fin c → ℝ) :=
  {u | ∀ i j, 0 ≤ normalized R P w u i j}

 
theorem width_bounds (s B : ℕ) (hB : 0<B) (h : 2*B ≤ s) :
    (s:ℝ)/(2*B) ≤ ((s/B:ℕ):ℝ) ∧ ((s/B:ℕ):ℝ) ≤ (s:ℝ)/B := by
  have hq : 1 ≤ s/B := Nat.div_pos (by omega) hB
  have hu := Nat.div_mul_le_self s B
  have hl := Nat.lt_mul_div_succ s hB
  have hb : (0:ℝ)<B := by exact_mod_cast hB
  constructor
  · apply (div_le_iff₀ (by positivity : (0:ℝ)<2*B)).mpr
    have hi : s ≤ (s/B)*(2*B) := by nlinarith only [hq,hl]
    exact_mod_cast hi
  · apply (le_div_iff₀ hb).mpr
    exact_mod_cast hu

 
theorem entry_le_scale (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (X : Fin (a+1) → Fin (c+1) → ℝ) (hX : ∀ i j,0 ≤ X i j)
    (hR : ∀ i,∑ j,X i j=R i) (hP : ∀ j,∑ i,X i j=P j) (i j) : X i j ≤  scale R P i j := by
  apply le_min
  · simpa only [hR] using Finset.single_le_sum (fun j _ => hX i j) (Finset.mem_univ j)
  · simpa only [hP] using Finset.single_le_sum (fun i _ => hX i j) (Finset.mem_univ i)

 
theorem polytope_bounded (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) (B : ℝ) (hB : 0<B)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j) (heq : (∑ i,R i)=∑ j,P j)
    (hw : ∀ i j,scale R P i.castSucc j.castSucc/(2*B) ≤ w i j)
    (u : Fin a×Fin c → ℝ) (hu : u∈polytope R P w) :
    ∀ s,0 ≤ u s ∧ u s ≤ 2*B := by
  have hs (i j) : 0<scale R P i j := lt_min (hR i) (hP j)
  have hpos (i j) : 0<w i j := (div_pos (hs i.castSucc j.castSucc) (by positivity)).trans_le (hw i j)
  have hX (i j) : 0 ≤  scaled R P w u i j := by
    have h := hu i j
    change 0 ≤ scaled R P w u i j/scale R P i j at h
    simpa only [zero_mul] using (le_div_iff₀ (hs i j)).mp h
  rintro ⟨i,j⟩
  have he : scaled R P w u i.castSucc j.castSucc=w i j*u (i,j) := complete_free R P _ i j
  have h0 := hX i.castSucc j.castSucc
  rw [he] at h0
  have hl := entry_le_scale R P (scaled R P w u) hX
    (fun i => complete_row R P _ i) (fun j => complete_col R P _ heq j) i.castSucc j.castSucc
  rw [he] at hl
  constructor
  · exact nonneg_of_mul_nonneg_right h0 (hpos i j)
  · have hw' : scale R P i.castSucc j.castSucc ≤ w i j*(2*B) :=
      (div_le_iff₀ (by positivity)).mp (hw i j)
    exact (mul_le_mul_iff_right₀ (hpos i j)).mp (hl.trans hw')

end
end Contingency.Dense

 

 

open scoped BigOperators
namespace Contingency.Dense
noncomputable section
variable {a c : ℕ}

 

theorem real_completion {I J : Type*} [Fintype I] [Fintype J]
    (R : I → ℝ) (P : J → ℝ) (hR : ∀ i,0 ≤ R i) (hP : ∀ j,0 ≤ P j)
    (heq : (∑ i,R i)=∑ j,P j) :
    ∃ X : I → J → ℝ, (∀ i j,0 ≤ X i j) ∧ (∀ i,∑ j,X i j=R i) ∧ (∀ j,∑ i,X i j=P j) := by
  classical
  by_cases h0 : (∑ i,R i)=0
  · have hR0 (i) : R i=0 := by
      have := Finset.single_le_sum (fun i _ => hR i) (Finset.mem_univ i)
      rw [h0] at this; linarith [hR i]
    have hP0 (j) : P j=0 := by
      have := Finset.single_le_sum (fun j _ => hP j) (Finset.mem_univ j)
      rw [← heq,h0] at this; linarith [hP j]
    refine ⟨fun _ _ => 0,fun _ _ => le_rfl,?_,?_⟩
    · intro i; simp [hR0]
    · intro j; simp [hP0]
  · have hS : 0<(∑ i,R i) := lt_of_le_of_ne (Finset.sum_nonneg (fun i _ => hR i)) (Ne.symm h0)
    refine ⟨fun i j => R i*P j/(∑ i,R i),?_,?_,?_⟩
    · intro i j; exact div_nonneg (mul_nonneg (hR i) (hP j)) hS.le
    · intro i
      rw [← Finset.sum_div,← Finset.mul_sum,← heq]
      field_simp
    · intro j
      rw [← Finset.sum_div,← Finset.sum_mul]
      field_simp

 

theorem interior_table (d : ℝ) (hd : 0<d)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j) (heq : (∑ i,R i)=∑ j,P j)
    (ha : (a+1:ℕ) ≤ d) (hc : (c+1:ℕ) ≤ d) :
    ∃ X : Fin (a+1) → Fin (c+1) → ℝ,
      (∀ i j,scale R P i j/(2*d) ≤ X i j) ∧
      (∀ i,∑ j,X i j=R i) ∧ (∀ j,∑ i,X i j=P j) := by
  let B := fun i j => scale R P i j/(2*d)
  have hBn (i j) : 0 ≤ B i j := div_nonneg (le_min (hR i).le (hP j).le) (by positivity)
  have hrow (i) : (∑ j,B i j) ≤ R i/2 := by
    calc
      _  ≤  ∑ j : Fin (c+1), R i/(2*d) := by
        apply Finset.sum_le_sum; intro j _
        exact div_le_div_of_nonneg_right (min_le_left _ _) (by positivity)
      _ = (c+1:ℕ)*(R i/(2*d)) := by simp
      _  ≤  d*(R i/(2*d)) := mul_le_mul_of_nonneg_right hc (div_nonneg (hR i).le (by positivity))
      _ = R i/2 := by field_simp
  have hcol (j) : (∑ i,B i j) ≤ P j/2 := by
    calc
      _  ≤  ∑ i : Fin (a+1), P j/(2*d) := by
        apply Finset.sum_le_sum; intro i _
        exact div_le_div_of_nonneg_right (min_le_right _ _) (by positivity)
      _ = (a+1:ℕ)*(P j/(2*d)) := by simp
      _  ≤  d*(P j/(2*d)) := mul_le_mul_of_nonneg_right ha (div_nonneg (hP j).le (by positivity))
      _ = P j/2 := by field_simp
  let R' := fun i => R i-∑ j,B i j
  let P' := fun j => P j-∑ i,B i j
  have hR' (i) : 0 ≤ R' i := by dsimp [R']; linarith [hrow i,hR i]
  have hP' (j) : 0 ≤ P' j := by dsimp [P']; linarith [hcol j,hP j]
  have heq' : (∑ i,R' i)=∑ j,P' j := by
    simp only [R',P',Finset.sum_sub_distrib,heq]
    rw [Finset.sum_comm]
  obtain ⟨Y,hY,hYR,hYP⟩ := real_completion R' P' hR' hP' heq'
  refine ⟨fun i j => B i j+Y i j,?_,?_,?_⟩
  · intro i j; exact le_add_of_nonneg_right (hY i j)
  · intro i; rw [Finset.sum_add_distrib,hYR]; dsimp [R']; ring
  · intro j; rw [Finset.sum_add_distrib,hYP]; dsimp [P']; ring

 
theorem interior_point (d : ℝ) (hd : 0<d)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j) (heq : (∑ i,R i)=∑ j,P j)
    (ha : (a+1:ℕ) ≤ d) (hc : (c+1:ℕ) ≤ d) (hw : ∀ i j,0<w i j) :
    ∃ u : Fin a×Fin c → ℝ, ∀ i j, 1/(2*d) ≤ normalized R P w u i j := by
  obtain ⟨X,hX,hXR,hXP⟩ := interior_table d hd R P hR hP heq ha hc
  let u := fun s : Fin a×Fin c => X s.1.castSucc s.2.castSucc/w s.1 s.2
  have he : scaled R P w u=X := by
    unfold scaled
    have hx : (fun i j => w i j*u (i,j))=fun i j => X i.castSucc j.castSucc := by
      funext i j
      dsimp [u]
      field_simp [(hw i j).ne']
    rw [hx]
    exact complete_represents R P X hXR hXP
  refine ⟨u,fun i j => ?_⟩
  unfold normalized
  rw [he]
  have hs : 0<scale R P i j := lt_min (hR i) (hP j)
  apply (le_div_iff₀ hs).mpr
  calc
    _ = scale R P i j/(2*d) := by ring
    _ ≤ _ := hX i j

end
end Contingency.Dense

end

end OAI