lean/OAI/Probability/BinarySweep/FiniteLaws/OneCard.lean

import Mathlib
import OAI.Probability.BinarySweep.FiniteLaws.UniformFiniteProbability

namespace OAI

noncomputable section

section

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
attribute [local instance] Classical.propDecidable

lemma coordinateLayer_apply_at (d : ℕ) (j : Fin d)
    (c : ({i : Fin d // i≠j} → Bool) → Bool) (x : Slot d) :
    coordinateLayer d j c x j = (x j ^^ c (fun i => x i)) := by
  simp [coordinateLayer,Equiv.piSplitAt_symm_apply]

lemma coordinateLayer_apply_other (d : ℕ) (j i : Fin d) (hi : i≠j)
    (c : ({i : Fin d // i≠j} → Bool) → Bool) (x : Slot d) :
    coordinateLayer d j c x i = x i := by
  simp [coordinateLayer,Equiv.piSplitAt_symm_apply,hi]

def binaryPosition {d : ℕ} (x y : Slot d) (t : Fin (d+1)) : Slot d :=
  fun i => if i.val<t.val then y i else x i

def binaryPartialSweep (d : ℕ) (c : SweepCoins d) (t : Fin (d+1)) : Equiv.Perm (Slot d) :=
  ((List.ofFn (fun j => coordinateLayer d j (c j))).take t.val).reverse.prod

@[simp] lemma binaryPartialSweep_zero (d : ℕ) (c : SweepCoins d) : binaryPartialSweep d c 0=1 := by
  simp [binaryPartialSweep]

@[simp] lemma binaryPartialSweep_last (d : ℕ) (c : SweepCoins d) :
    binaryPartialSweep d c (Fin.last d)=binarySweep d c := by
  unfold binaryPartialSweep binarySweep
  rw [List.take_of_length_le (by simp)]

lemma binaryPartialSweep_succ (d : ℕ) (c : SweepCoins d) (j : Fin d) :
    binaryPartialSweep d c j.succ=coordinateLayer d j (c j)*binaryPartialSweep d c j.castSucc := by
  unfold binaryPartialSweep
  simp only [Fin.val_succ,Fin.val_castSucc]
  rw [List.take_succ_eq_append_getElem (by simp)]
  simp only [List.reverse_append,List.reverse_singleton,List.prod_append,
    List.prod_singleton,List.getElem_ofFn,Fin.eta]

lemma singleCoordinate_trajectory {d : ℕ} {β : Fin d → Type*}
    (x : Fin (d+1) → ∀i, β i)
    (hmov : ∀j i : Fin d, i≠j → x j.succ i=x j.castSucc i)
    (t : Fin (d+1)) (i : Fin d) :
    x t i = if i.val<t.val then x (Fin.last d) i else x 0 i := by
  have hbefore : ∀t : Fin (d+1), t.val ≤ i.val → x t i=x 0 i := by
    intro t
    induction t using Fin.induction with
    | zero => intro _; rfl
    | succ j ih =>
      intro ht
      have hij : i≠j := by intro h; subst j; simp at ht
      rw [hmov j i hij,ih]
      exact Nat.le_trans (Nat.le_succ j.val) ht
  have hafter : ∀t : Fin (d+1), i.val<t.val → x t i=x (Fin.last d) i := by
    intro t
    induction t using Fin.reverseInduction with
    | last => intro _; rfl
    | cast j ih =>
      intro ht
      have hij : i≠j := by intro h; subst j; simp at ht
      rw [← hmov j i hij,ih]
      exact Nat.lt_succ_of_lt ht
  split_ifs with h
  · exact hafter t h
  · exact hbefore t (Nat.le_of_not_lt h)

lemma binarySweep_endpoint_iff (d : ℕ) (c : SweepCoins d) (x y : Slot d) :
    binarySweep d c x=y ↔ ∀j, c j (fun i => binaryPosition x y j.castSucc i)= (x j ^^ y j) := by
  constructor
  · intro he j
    have hp (t : Fin (d+1)) : binaryPartialSweep d c t x=binaryPosition x y t := by
      funext i
      rw [singleCoordinate_trajectory (fun t => binaryPartialSweep d c t x)
        (by intro j i hi; rw [binaryPartialSweep_succ,Equiv.Perm.mul_apply,
          coordinateLayer_apply_other d j i hi])]
      simp only [binaryPartialSweep_last,binaryPartialSweep_zero,Equiv.Perm.one_apply,he,binaryPosition]
    have hj := congrFun (hp j.succ) j
    rw [binaryPartialSweep_succ,Equiv.Perm.mul_apply,hp j.castSucc,coordinateLayer_apply_at] at hj
    simp only [binaryPosition,Fin.val_succ,Fin.val_castSucc,lt_self_iff_false,ite_false,
      Nat.lt_succ_self,ite_true] at hj
    cases hx : x j <;> cases hy : y j <;> cases hc : c j (fun i => binaryPosition x y j.castSucc i) <;>
      simp_all [binaryPosition]
  · intro he
    have hp (t : Fin (d+1)) : binaryPartialSweep d c t x=binaryPosition x y t := by
      induction t using Fin.induction with
      | zero => ext i; simp [binaryPosition]
      | succ j ih =>
        rw [binaryPartialSweep_succ,Equiv.Perm.mul_apply,ih]
        funext i
        by_cases hi : i=j
        · subst i
          rw [coordinateLayer_apply_at,he j]
          simp [binaryPosition]
        · rw [coordinateLayer_apply_other d j i hi]
          dsimp [binaryPosition]
          congr 1
          exact propext (by have hij : i.val≠j.val := fun h => hi (Fin.ext h); omega)
    have hy : binaryPosition x y (Fin.last d)=y := by ext i; simp [binaryPosition]
    simpa only [binaryPartialSweep_last,hy] using hp (Fin.last d)

lemma uniform_coin_evaluation {I : Type*} [Fintype I] [DecidableEq I] (i : I) (b : Bool) :
    (∑c : I → Bool, if c i=b then (Fintype.card (I → Bool):ℝ)⁻¹ else 0) = (1/2:ℝ) := by
  have h := Sparse.uniform_projection_probability (Equiv.piSplitAt i (fun _ : I => Bool)) b
  simpa only [Sparse.finiteProbability,Sparse.uniformWeight,Equiv.piSplitAt_apply,
    Fintype.card_bool,Nat.cast_ofNat,one_div,mul_ite,mul_one,mul_zero] using h

lemma uniform_independent_event {J : Type*} [Fintype J] [DecidableEq J] {X : J → Type*}
    [∀j, Fintype (X j)] (P : ∀j, X j → Prop) :
    (∑x : ∀j, X j, if ∀j, P j (x j) then (Fintype.card (∀j, X j):ℝ)⁻¹ else 0) =
      ∏j, ∑a : X j, if P j a then (Fintype.card (X j):ℝ)⁻¹ else 0 := by
  have h := independent_event_weight (fun j (_ : X j) => (Fintype.card (X j):ℝ)⁻¹) P
  have hc : (∏j, (Fintype.card (X j):ℝ)⁻¹) = (Fintype.card (∀j, X j):ℝ)⁻¹ := by
    rw [Finset.prod_inv_distrib,← Nat.cast_prod,Fintype.card_pi]
  refine Eq.trans ?_ h
  apply Finset.sum_congr
  · ext x; simp only [Finset.mem_univ]
  intro x _
  split_ifs <;> simp only [hc]

lemma uniform_pi_coin_evaluation {J : Type*} [Fintype J] [DecidableEq J] {I : J → Type*}
    [∀j,Fintype (I j)] [∀j,DecidableEq (I j)] (i : ∀j,I j) (b : J → Bool) :
    (∑c : ∀j,I j → Bool, if ∀j,c j (i j)=b j then
      (Fintype.card (∀j,I j → Bool):ℝ)⁻¹ else 0) = (1/2:ℝ)^Fintype.card J := by
  have h := uniform_independent_event (X:=fun j => I j → Bool) (fun j a => a (i j)=b j)
  refine Eq.trans ?_ (Eq.trans h ?_)
  · apply Finset.sum_congr rfl
    intro c _
    by_cases hc : ∀j,c j (i j)=b j <;> simp [hc]
  · calc
      _ = ∏j, (1/2:ℝ) := by
        apply Finset.prod_congr rfl
        intro j _
        refine Eq.trans ?_ (uniform_coin_evaluation (i j) (b j))
        apply Finset.sum_congr rfl
        intro c _
        by_cases hc : c (i j)=b j <;> simp [hc]
      _ = _ := by simp only [Finset.prod_const,Finset.card_univ]

lemma binary_one_card (d : ℕ) (x y : Slot d) :
    ∑σ, binaryLaw d σ * (if σ x=y then (1:ℝ) else 0) = (Fintype.card (Slot d):ℝ)⁻¹ := by
  rw [binaryLaw,finiteLaw_expectation]
  simp_rw [binarySweep_endpoint_iff]
  rw [Finset.mul_sum]
  simp only [mul_ite,mul_one,mul_zero]
  have h := uniform_pi_coin_evaluation (J:=Fin d)
    (I:=fun j => {i : Fin d // i≠j} → Bool)
    (fun j i => binaryPosition x y j.castSucc i) (fun j => (x j ^^ y j))
  have hc : (1/2:ℝ)^Fintype.card (Fin d) = (Fintype.card (Slot d):ℝ)⁻¹ := by
    simp [Slot,inv_pow,one_div]
  refine Eq.trans ?_ (h.trans hc)
  apply Finset.sum_congr
  · ext c; simp only [Finset.mem_univ]
  intro c _
  by_cases hh : ∀j, c j (fun i => binaryPosition x y j.castSucc i)= (x j ^^ y j)
  · simp only [hh]
  · simp only [hh,ite_false]

end BinaryCoordinateSweeps

end

open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
attribute [local instance] Classical.propDecidable

lemma uniform_one_card {X : Type*} [Fintype X] [DecidableEq X] (x y : X) :
    (∑σ : Equiv.Perm X, uniformLaw (Equiv.Perm X) σ * (if σ x=y then (1:ℝ) else 0)) =
      (Fintype.card X:ℝ)⁻¹ := by
  let A : Unit ↪ X := ⟨fun _ => x,fun _ _ _ => Subsingleton.elim _ _⟩
  let B : Unit ↪ X := ⟨fun _ => y,fun _ _ _ => Subsingleton.elim _ _⟩
  have h := assignmentWeight_uniform A B
  have he (σ : Equiv.Perm X) : Assigns A B σ ↔ σ x=y := by
    change (∀u : Unit, σ x=y) ↔ σ x=y
    simp only [forall_const]
  simp only [assignmentWeight,he,uniformLaw,mul_ite,mul_one,mul_zero,
    Fintype.card_unique,Nat.descFactorial_one] at h ⊢
  refine Eq.trans ?_ h
  apply Finset.sum_congr
  · ext σ; simp only [Finset.mem_univ]
  intro σ _
  split_ifs <;> simp only [Fintype.card_perm]

lemma line_one_card (d : ℕ) (z : ℝ) (x y : Slot d) :
    (∑σ, lineLaw d z σ * (if σ x=y then (1:ℝ) else 0)) = (Fintype.card (Slot d):ℝ)⁻¹ := by
  simp only [lineLaw,add_mul,mul_assoc,Finset.sum_add_distrib,← Finset.mul_sum]
  rw [uniform_one_card (X:=Slot d) x y,binary_one_card d x y]
  ring

lemma line_one_card_ite (d : ℕ) (z : ℝ) (x y : Slot d) :
    (∑σ, if σ x=y then lineLaw d z σ else 0) = (Fintype.card (Slot d):ℝ)⁻¹ := by
  simpa only [mul_ite,mul_one,mul_zero] using line_one_card d z x y

end BinaryCoordinateSweeps

end

end OAI