import OAI.Combinatorics.ContingencyTables.Transport.RationalMapProducts

namespace OAI

/-! # Reserving a common word length for adaptive bounded draws -/

namespace ContingencyTables.FirstSuccess

open scoped BigOperators Classical
open ResidualMixture FairBits

noncomputable section

variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq A]

lemma mapLaw_product_fst (p : RationalLaw A) (q : RationalLaw B) :
    mapLaw (productLaw p q) Prod.fst=p := by
  apply RationalLaw.ext
  funext x
  simp only [mapLaw, productLaw, Fintype.sum_prod_type]
  change (∑ a,∑ b,if a=x then p.mass a*q.mass b else 0)=p.mass x
  have hs (a : A) : (∑ b,if a=x then p.mass a*q.mass b else 0)=if a=x then p.mass a else 0 := by
    by_cases ha : a=x
    · simp only [ha,ite_true,←Finset.mul_sum,q.total,mul_one]
    · simp only [ha,ite_false,Finset.sum_const_zero]
  simp_rw [hs]
  simp

def prefixWord {k N : ℕ} (hk : k ≤ N) (bits : Fin N → Bool) : Fin k → Bool :=
  fun i => bits (Fin.castLE hk i)

def paddingWordEquiv {k N : ℕ} (hk : k ≤ N) :
    (Fin N → Bool) ≃ ((Fin k → Bool) × (Fin (N-k) → Bool)) :=
  (Equiv.arrowCongr (finCongr (Nat.add_sub_of_le hk)).symm (Equiv.refl Bool)).trans
    (splitWordEquiv k (N-k))

lemma paddingWordEquiv_fst {k N : ℕ} (hk : k ≤ N) (bits : Fin N → Bool) :
    (paddingWordEquiv hk bits).1=prefixWord hk bits := by
  funext i
  change bits _=bits _
  apply congrArg bits
  apply Fin.ext
  rfl

/-- Taking the needed prefix of a larger uniform word preserves the exact
law, so unused bits can be reserved even after the current state is known. -/
theorem prefixWord_uniform {k N : ℕ} (hk : k ≤ N) :
    mapLaw (uniformLaw (α := Fin N → Bool)) (prefixWord hk)=uniformLaw (α := Fin k → Bool) := by
  have hf : prefixWord hk=fun bits => (paddingWordEquiv hk bits).1 := by
    funext bits
    exact (paddingWordEquiv_fst hk bits).symm
  rw [hf,←map_equiv (paddingWordEquiv hk),uniform_equiv,←uniform_product,mapLaw_product_fst]

variable {Y : Type*} [Fintype Y] [DecidableEq Y]

/-- An arbitrary finite draw keeps its law when padded to the common
bound; this applies separately at every state of an adaptive walk. -/
theorem padded_draw_law {k N : ℕ} (hk : k ≤ N) (draw : (Fin k → Bool) → Y) :
    mapLaw (uniformLaw (α := Fin N → Bool)) (fun bits => draw (prefixWord hk bits))=
      mapLaw (uniformLaw (α := Fin k → Bool)) draw := by
  rw [←mapLaw_comp,prefixWord_uniform]

end
end ContingencyTables.FirstSuccess

end OAI