import OAI.Combinatorics.HadwigerCounterexample.FiniteConditioning

namespace OAI

/-! # Conditional Product Laws -/

noncomputable section
namespace HadwigerCounterexample
open scoped BigOperators

variable {A B I : Type} [Fintype A] [Fintype B]

theorem subLaw_pair {w : Wgt A} {v : Wgt B} (hw : SubLaw w) (hv : SubLaw v) :
    SubLaw (pairW w v) := by
  refine ⟨fun x => mul_nonneg (hw.nz _) (hv.nz _),?_⟩
  rw [pairW_tot]
  exact (mul_le_mul hw.total hv.total (tot_nonneg hv.nz) (by norm_num)).trans_eq (one_mul _)

theorem pair_unif :
    unif (α:=A×B) = pairW unif unif := by
  funext x; simp [pairW,unif_apply,mul_comm]

theorem unifOn_slice (p : A × B → Prop) (x : A) (y : B) :
    unifOn p (x,y) =
      mapW (unifOn p) Prod.fst x * unifOn (fun y => p (x,y)) y := by
  classical
  have hm : mapW (unifOn p) Prod.fst x =
      nbr (fun y => p (x,y)) / nbr p := by
    simp only [mapW,pr,avg,Fintype.sum_prod_type,unifOn_val, nbr,tot]
    rw [Finset.sum_eq_single x]
    · simp [ind_true,div_eq_mul_inv,Finset.sum_mul]
    · intro b _ hb
      simp [ind,hb]
    · simp
  rw [hm,unifOn_val,unifOn_val]
  by_cases h : p (x,y)
  · have hh {A : Type} [Fintype A] (p : A → Prop) (x : A) (hx : p x) : 0 < nbr p := by
      have hp := weight_le_tot (fun y => ind_nonneg (p y)) x
      exact lt_of_lt_of_le (ind_one hx ▸ zero_lt_one) hp
    rw [ind_one h]
    have hv := hh _ _ h
    have hw := hh (fun y => p (x,y)) _ h
    field_simp
  · rw [ind_zero h]
    ring

theorem unifOn_and (p q : A → Prop) :
    onW (unifOn p) q = unifOn (fun x => p x ∧ q x) := by
  classical
  have hp : pr (unifOn p) q = nbr (fun x => p x ∧ q x) / nbr p := by
    simp only [pr,avg,unifOn_val,div_eq_mul_inv,ind_and,nbr,tot,Finset.sum_mul]
    refine Finset.sum_congr rfl fun i _ => ?_
    ring
  funext x
  rw [onW_val,hp,unifOn_val,unifOn_val,ind_and]
  by_cases h : p x
  · by_cases g : q x
    · have hl (p : A → Prop) (h : p x) : 0 < nbr p :=
        lt_of_lt_of_le (ind_one h ▸ zero_lt_one) (weight_le_tot (fun y => ind_nonneg (p y)) x)
      have hh := hl p h
      have hg := hl (fun x => p x ∧ q x) ⟨h,g⟩
      field_simp
    · rw [ind_zero g]
      ring
  · rw [ind_zero h]
    ring

theorem unifOn_and_prod (p : A → Prop) (q : B → Prop) :
    unifOn (fun x : A × B => p x.1 ∧ q x.2) = pairW (unifOn p) (unifOn q) := by
  have h :
      nbr (fun x : A × B => p x.1 ∧ q x.2) = nbr p * nbr q := by
    change tot _ = _ * _
    simp_rw [ind_and]
    exact pairW_tot (fun x => ind (p x)) (fun y => ind (q y))
  funext x
  simp only [pairW,unifOn_val,h,ind_and]
  ring_nf

theorem pr_cap {w v : Wgt A} {c : ℝ} (h : ∀ x, w x ≤ c*v x) (p : A → Prop) :
    pr w p ≤ c*pr v p := calc
  _ ≤ pr (fun x => c*v x) p := pr_mono_left (w:=w) (v:=fun x => c*v x) h _
  _ = _ := by simp only [pr,avg,Finset.mul_sum,mul_assoc]

def semi (w : Wgt A) (k : A → Wgt B) : Wgt (A × B) := fun x => w x.1 * k x.1 x.2

theorem semi_avg (w : Wgt A) (k : A → Wgt B) (f : A × B → ℝ) :
    avg (semi w k) f = avg w (fun x => avg (k x) (fun y => f (x,y))) := by
  simp only [avg,semi,Fintype.sum_prod_type,Finset.mul_sum,mul_assoc]

theorem pair_semi_avg (w w' : Wgt A) (k k' : A → Wgt B) (f : (A × B) × (A × B) → ℝ) :
    avg (pairW (semi w k) (semi w' k')) f =
      avg (pairW w w') (fun x =>
        avg (pairW (k x.1) (k' x.2)) (fun y => f ((x.1,y.1), (x.2,y.2)))) := by
  simp only [pairW_avg, semi_avg]
  refine avg_congr fun x _ => ?_
  exact avg_avg _ _ _

theorem pair_semi_pr (w w' : Wgt A) (k k' : A → Wgt B) (p : A × A → Prop) (q : B × B → Prop) :
    pr (pairW (semi w k) (semi w' k')) (fun x => p (x.1.1,x.2.1) ∧ q (x.1.2,x.2.2)) =
      avg (pairW w w') (fun x => ind (p x) * pr (pairW (k x.1) (k' x.2)) q) := by
  unfold pr
  rw [pair_semi_avg]
  simp_rw [ind_and]
  refine avg_congr fun x _ => ?_
  exact avg_mul' _ _ _

variable [Fintype I] [DecidableEq I]

/-- Reassociate two arrays of independent columns into componentwise independent pairs. -/
theorem prodW_pair_pr (w v : I → Wgt A) (p : I → A × A → Prop) :
    pr (pairW (prodW w) (prodW v)) (fun x => ∀ i, p i (x.1 i,x.2 i)) =
      ∏ i, pr (pairW (w i) (v i)) (p i) := by
  simp_rw [pr,ind_all,pairW_avg]
  have hx (x : I → A) :
      avg (prodW v) (fun y => ∏ i, ind (p i (x i,y i))) =
        ∏ i, avg (v i) (fun y => ind (p i (x i,y))) :=
    prodW_avg _ (fun i y => ind (p i (x i,y)))
  simp_rw [hx]
  exact prodW_avg w (fun i x => avg (v i) (fun y => ind (p i (x,y))))

end HadwigerCounterexample

end

end OAI