import OAI.Geometry.PinnedDistances.FiberTransport

namespace OAI

universe u1 u2 u3 u4

section
noncomputable section
open NumberField
open scoped BigOperators
noncomputable section
open MeasureTheory
open scoped Topology
noncomputable section
open MeasureTheory
open scoped Topology ENNReal
noncomputable section
open MeasureTheory NumberField
open scoped BigOperators
noncomputable section
open scoped BigOperators
open MeasureTheory
noncomputable section
open Filter
open scoped Topology
noncomputable section
open scoped BigOperators
noncomputable section
open Filter
open scoped Topology
noncomputable section
open MeasureTheory
open scoped BigOperators
noncomputable section
noncomputable section
open scoped BigOperators
noncomputable section
noncomputable section
noncomputable section

namespace WeakPinned.Cuts
open MeasureTheory Hierarchy Variance
open scoped BigOperators
variable {P : Type u1} {I : Type u2} [Fintype P] [DecidableEq P] [Fintype I]

omit [Fintype P] [DecidableEq P] in
lemma cost_mixture (s : Finset (Finset P)) (l : Finset P → ℝ) (hl : ∀ C ∈ s, 0≤l C)
    (w : I → ℝ) (p : I → P → ℝ) (a : P → ℝ) (hw : ∀ i, 0≤w i) (hW : ∑ i, w i=1) :
    cost s l (fun y => ∑ i, w i*p i y) a≤∑ i, w i*cost s l (p i) a := by
  have hm (C : Finset P) : mass (fun y => ∑ i, w i*p i y) C-mass a C=
      ∑ i, w i*(mass (p i) C-mass a C) := by
    simp only [mass,mul_sub,Finset.sum_sub_distrib,← Finset.sum_mul,hW,one_mul]
    rw [Finset.sum_comm]
    simp only [Finset.mul_sum]
  unfold cost
  simp only [hm]
  calc
    _ ≤ ∑ C ∈ s, l C*∑ i, w i*|mass (p i) C-mass a C| := by
      apply Finset.sum_le_sum
      intro C hC
      apply mul_le_mul_of_nonneg_left _ (hl C hC)
      convert Finset.abs_sum_le_sum_abs (s:=Finset.univ) (fun i => w i*(mass (p i) C-mass a C)) using 1
      simp only [abs_mul,abs_of_nonneg (hw _)]
    _ = _ := by
      simp only [Finset.mul_sum]
      rw [Finset.sum_comm]
      exact Finset.sum_congr rfl (fun i _ => Finset.sum_congr rfl (fun C _ => by ring))

omit [DecidableEq P] in
lemma mass_upper (p : P → ℝ) (hp0 : ∀ x, 0≤p x) (hp : ∑ x, p x=1) (C : Finset P) : mass p C≤1 :=
  (Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun x _ _ => hp0 x)).trans_eq hp

omit [DecidableEq P] in
lemma cost_bound (s : Finset (Finset P)) (l : Finset P → ℝ) (hl : ∀ C ∈ s, 0≤l C)
    (p a : P → ℝ) (hp0 : ∀ x, 0≤p x) (ha0 : ∀ x, 0≤a x)
    (hp : ∑ x, p x=1) (ha : ∑ x, a x=1) : cost s l p a≤∑ C ∈ s, l C := by
  apply Finset.sum_le_sum
  intro C hC
  have hh : |mass p C-mass a C|≤1 := abs_le.mpr ⟨by linarith [mass_nonneg p hp0 C,mass_upper a ha0 ha C],
    by linarith [mass_nonneg a ha0 C,mass_upper p hp0 hp C]⟩
  simpa using mul_le_mul_of_nonneg_left hh (hl C hC)

lemma projection_replacement (d d' : Depth P) (δ : ℝ) (hδ : 0≤δ) (p a : P → ℝ)
    (hp : ∑ x, p x=1) (ha : ∑ x, a x=1) (hps : ∀ x, p x≤δ) (has : ∀ x, a x≤δ) (x y : P) :
    |distance d.allCuts (d.cutLength (fun C => tent δ (mass a C))) x y-
        rootDistance d'.allCuts (d'.cutLength (fun C => tent δ (mass a C))) y|≤
      |distance d.allCuts (d.cutLength (fun C => tent δ (mass p C))) x y-
        rootDistance d'.allCuts (d'.cutLength (fun C => tent δ (mass p C))) y|+
      charge d δ p a+charge d' δ p a := by
  have h1 := distance_change_charge d δ hδ p a hp ha hps has x y
  have h2 := root_change_charge d' δ hδ p a hp ha hps has y
  let A := distance d.allCuts (d.cutLength (fun C => tent δ (mass a C))) x y
  let B := rootDistance d'.allCuts (d'.cutLength (fun C => tent δ (mass a C))) y
  let C := distance d.allCuts (d.cutLength (fun C => tent δ (mass p C))) x y
  let D := rootDistance d'.allCuts (d'.cutLength (fun C => tent δ (mass p C))) y
  change |C-A|≤charge d δ p a at h1
  change |D-B|≤charge d' δ p a at h2
  change |A-B|≤|C-D|+charge d δ p a+charge d' δ p a
  have hh1 : |A-B|≤|A-C|+|C-B| := abs_sub_le A C B
  have hh2 : |C-B|≤|C-D|+|D-B| := abs_sub_le C D B
  have hh3 : |A-C|=|C-A| := abs_sub_comm A C
  rw [hh3] at hh1
  linarith only [hh1,hh2,h1,h2]

lemma family_charge_occurrence (d : Depth P) (hn : 2≤Fintype.card P) (w : I → ℝ)
    (B : I → Finset P) (hB : ∀ i, (B i).Nonempty) (δ : ℝ) (hδ : 0≤δ)
    (hp : ∀ i x, prob (B i) x≤δ) (ha : ∀ x, prob (Finset.univ : Finset P) x≤δ) :
    (∑ i, w i*charge d δ (prob (B i)) (prob Finset.univ))=
      weightedIntegral d.mass (familyCutError w B δ) := by
  have ha1 : ∑ x, prob (Finset.univ : Finset P) x=1 := sum_prob _ (by
    apply Finset.univ_nonempty_iff.mpr
    exact Fintype.card_pos_iff.mp (by omega))
  simp only [charge_occurrence d hn δ hδ _ _ (sum_prob _ (hB _)) ha1 (hp _) ha]
  simp only [weightedIntegral,Finset.mul_sum,familyCutError]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro C _
  apply Finset.sum_congr rfl
  intro i _
  simp only [mass,sum_prob_cell]
  ring

/-- One coordinate of the finite tree contradiction, before arithmetic
averaging. The incoming laws are arbitrary probabilities representing the
actual conditional source law, not an independence hypothesis. -/
lemma length_upper (d d' : Depth P) (δ : ℝ) (hδ : 0≤δ)
    (a t : P → ℝ) (ρ : P → P → ℝ) (w : I → ℝ) (p : I → P → ℝ) (src : I → P)
    (ha0 : ∀ x, 0≤a x) (ht0 : ∀ y, 0≤t y) (hρ0 : ∀ y x, 0≤ρ y x) (hw : ∀ i, 0≤w i)
    (ha : ∑ x, a x=1) (ht : ∑ y, t y=1) (hρ : ∀ y, ∑ x, ρ y x=1) (hW : ∑ i, w i=1)
    (hp : ∀ i, ∑ y, p i y=1) (hp0 : ∀ i y, 0≤p i y)
    (has : ∀ x, a x≤δ) (hps : ∀ i x, p i x≤δ)
    (htm : t=fun y => ∑ i, w i*p i y)
    (hedge : ∀ F : P → P → ℝ, (∑ y, t y*∑ x, ρ y x*F x y)=∑ i, w i*∑ y, p i y*F (src i) y) :
    δ^3*(∑ C ∈ d.allCuts, d.cutLength (fun B => tent δ (mass a B)) C)≤
      2*Global.fiberCutDiscrepancy w p src δ d d'+
      4*(∑ i, w i*charge d δ (p i) a)+2*(∑ i, w i*charge d' δ (p i) a)+
      2*(∑ y, t y*cost d.allCuts (d.cutLength (fun B => tent δ (mass a B))) (ρ y) a) := by
  let l := d.cutLength (fun B => tent δ (mass a B))
  have hl (C) (_ : C∈d.allCuts) : 0≤l C := d.cutLength_nonneg _ (fun C => tent_nonneg _ _) C
  have hlow := d.actual_cut_fluctuation a ha0 ha (tent δ) (tent_nonneg δ) δ hδ (fun u hn => by
    apply le_antisymm _ (tent_nonneg δ u)
    by_contra hh
    have hu := tent_positive (lt_of_not_ge hh)
    exact hn ⟨hu.1.le,by linarith [hu.2]⟩)
  have hupper := iid_transfer d.allCuts d.allCuts_laminar l hl a t ρ ha0 ht0 hρ0 ha ht hρ
    (rootDistance d'.allCuts (d'.cutLength (fun B => tent δ (mass a B))))
  rw [hedge] at hupper
  have hproj : (∑ i, w i*∑ y, p i y*
      |distance d.allCuts l (src i) y-rootDistance d'.allCuts (d'.cutLength (fun B => tent δ (mass a B))) y|)≤
      Global.fiberCutDiscrepancy w p src δ d d'+∑ i, w i*charge d δ (p i) a+∑ i, w i*charge d' δ (p i) a := by
    have hh := Finset.sum_le_sum (s:=Finset.univ) (fun i _ => mul_le_mul_of_nonneg_left
      (Finset.sum_le_sum (s:=Finset.univ) (fun y _ => mul_le_mul_of_nonneg_left
        (projection_replacement d d' δ hδ (p i) a (hp i) ha (hps i) has (src i) y) (hp0 i y))) (hw i))
    simpa only [Global.fiberCutDiscrepancy,mul_add,Finset.sum_add_distrib,← Finset.sum_mul,hp,one_mul,l] using hh
  have hcost : cost d.allCuts l t a≤∑ i, w i*charge d δ (p i) a := by
    rw [htm]
    exact (cost_mixture d.allCuts l hl w p a hw hW).trans (Finset.sum_le_sum (fun i _ =>
      mul_le_mul_of_nonneg_left (cost_le_charge d δ hδ (p i) a (hp i) ha (hps i) has) (hw i)))
  dsimp only [l] at hupper hproj hcost
  linarith
end WeakPinned.Cuts
noncomputable section
namespace WeakPinned.Core.Fibers
open MeasureTheory Hierarchy Variance Cuts
open scoped BigOperators
variable {V : Type u3} {I : Type u4} [Fintype V] [Fintype I] [DecidableEq V]
variable (G : Fibers V I)

omit [Fintype V] in
lemma prob_nn (B : Finset V) (x : V) : 0≤prob B x := by
  unfold prob
  split_ifs <;> positivity

def conditionalSource (y : V) : V → ℝ :=
  if (G.incoming y).Nonempty then prob (G.incoming y) else prob Finset.univ

omit [Fintype I] in
lemma conditionalSource_nonneg (y x : V) : 0≤G.conditionalSource y x := by
  unfold conditionalSource
  split_ifs <;> exact prob_nn _ _

omit [Fintype I] in
lemma conditionalSource_sum (hn : 2≤Fintype.card V) (y : V) : ∑ x, G.conditionalSource y x=1 := by
  unfold conditionalSource
  split_ifs with h
  · exact sum_prob _ h
  · exact sum_prob _ (Finset.univ_nonempty_iff.mpr (Fintype.card_pos_iff.mp (by omega)))

omit [Fintype I] in
lemma incomingWeight_nonneg (y : V) : 0≤G.incomingWeight y := by unfold incomingWeight edgeCount; positivity

omit [Fintype I] in
lemma sampling_conditional (y x : V) : G.incomingWeight y*G.conditionalSource y x=G.edgeLaw x y := by
  by_cases h : (G.incoming y).Nonempty
  · simpa only [conditionalSource,ite_eq_left h] using G.sampling_incoming x y
  · have he : G.incoming y=∅ := Finset.not_nonempty_iff_eq_empty.mp h
    have hh := G.sampling_incoming x y
    have hw : G.incomingWeight y=0 := by simp [incomingWeight,he]
    simp only [hw,zero_mul] at hh ⊢
    exact hh

lemma incoming_eval (F : V → V → ℝ) :
    (∑ y, G.incomingWeight y*∑ x, G.conditionalSource y x*F x y)=
      ∑ e, G.fiberWeight e*∑ y, prob (G.targets e) y*F (G.source e) y := by
  simp only [Finset.mul_sum,← mul_assoc,G.sampling_conditional,← G.sampling_fiber,Finset.sum_mul]
  conv_lhs =>
    arg 2
    ext y
    rw [Finset.sum_comm]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro e _
  apply Finset.sum_congr rfl
  intro y _
  simp only [ite_mul,zero_mul]
  simp

lemma incoming_repr : G.incomingWeight=fun y => ∑ e, G.fiberWeight e*prob (G.targets e) y := by
  funext y
  rw [G.fiber_marginal,G.incoming_marginal]

def omittedMass (T : ℝ) : ℝ := ∑ y, if ((G.incoming y).card:ℝ)<T then G.incomingWeight y else 0

omit [Fintype I] in
lemma omittedMass_nonneg (T : ℝ) : 0≤G.omittedMass T := by
  apply Finset.sum_nonneg
  intro y _
  split_ifs
  · exact G.incomingWeight_nonneg y
  · rfl

omit [Fintype I] in
lemma retained_cost (d : Depth V) (δ T : ℝ) (hδ : 0≤δ) (hT : 0<T)
    (has : ∀ x, prob (Finset.univ : Finset V) x≤δ)
    (hrs : ∀ y x, prob (G.retainedSet T y) x≤δ)
    (hrn : ∀ y, (G.retainedSet T y).Nonempty) (hn : 2≤Fintype.card V) :
    (∑ y, G.incomingWeight y*cost d.allCuts (d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)))
      (G.conditionalSource y) (prob Finset.univ))≤
      (∑ y, G.retainedWeight T y*charge d δ (prob (G.retainedSet T y)) (prob Finset.univ))+
      G.omittedMass T*(∑ C ∈ d.allCuts, d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)) C) := by
  have ha : ∑ x, prob (Finset.univ : Finset V) x=1 :=
    sum_prob _ (Finset.univ_nonempty_iff.mpr (Fintype.card_pos_iff.mp (by omega)))
  unfold omittedMass
  rw [Finset.sum_mul,← Finset.sum_add_distrib]
  apply Finset.sum_le_sum
  intro y _
  by_cases hs : T≤((G.incoming y).card:ℝ)
  · have hy : (G.incoming y).Nonempty := Finset.card_pos.mp (by exact_mod_cast hT.trans_le hs)
    have he : G.retainedSet T y=G.incoming y := by simp only [retainedSet,ite_eq_left hs]
    have hh := cost_le_charge d δ hδ (prob (G.retainedSet T y)) (prob Finset.univ)
      (sum_prob _ (hrn y)) ha (hrs y) has
    simp only [he] at hh
    simpa only [retainedWeight,ite_eq_left hs,conditionalSource,ite_eq_left hy,not_lt_of_ge hs,ite_false,zero_mul,add_zero,he]
      using mul_le_mul_of_nonneg_left hh (G.incomingWeight_nonneg y)
  · have hh := cost_bound d.allCuts (d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)))
      (fun C _ => d.cutLength_nonneg _ (fun B => tent_nonneg _ _) C)
      (G.conditionalSource y) (prob Finset.univ) (G.conditionalSource_nonneg y) (prob_nn _)
      (G.conditionalSource_sum hn y) ha
    simpa only [retainedWeight,ite_eq_right hs,lt_of_not_ge hs,ite_true,zero_mul,zero_add] using
      mul_le_mul_of_nonneg_left hh (G.incomingWeight_nonneg y)

lemma graph_length_upper (d d' : Depth V) (δ T : ℝ) (hδ : 0≤δ) (hT : 0<T)
    (hn : 2≤Fintype.card V) (hG : 0<G.edgeCount)
    (has : ∀ x, prob (Finset.univ : Finset V) x≤δ)
    (hps : ∀ e x, prob (G.targets e) x≤δ) (hpn : ∀ e, (G.targets e).Nonempty)
    (hrs : ∀ y x, prob (G.retainedSet T y) x≤δ) (hrn : ∀ y, (G.retainedSet T y).Nonempty) :
    δ^3*(∑ C ∈ d.allCuts, d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)) C)≤
      2*Global.fiberCutDiscrepancy G.fiberWeight (fun e => prob (G.targets e)) G.source δ d d'+
      4*(∑ e, G.fiberWeight e*charge d δ (prob (G.targets e)) (prob Finset.univ))+
      2*(∑ e, G.fiberWeight e*charge d' δ (prob (G.targets e)) (prob Finset.univ))+
      2*(∑ y, G.retainedWeight T y*charge d δ (prob (G.retainedSet T y)) (prob Finset.univ))+
      2*G.omittedMass T*(∑ C ∈ d.allCuts, d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)) C) := by
  have ha : ∑ x, prob (Finset.univ : Finset V) x=1 :=
    sum_prob _ (Finset.univ_nonempty_iff.mpr (Fintype.card_pos_iff.mp (by omega)))
  have hh := length_upper d d' δ hδ (prob Finset.univ) G.incomingWeight G.conditionalSource G.fiberWeight
    (fun e => prob (G.targets e)) G.source (prob_nn _) G.incomingWeight_nonneg G.conditionalSource_nonneg
    G.fiberWeight_nonneg ha (G.sum_incomingWeight hG) (G.conditionalSource_sum hn) (G.sum_fiberWeight hG)
    (fun e => sum_prob _ (hpn e)) (fun e => prob_nn _) has hps G.incoming_repr G.incoming_eval
  have hc := G.retained_cost d δ T hδ hT has hrs hrn hn
  linarith
end WeakPinned.Core.Fibers

end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI