lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/MixerBalance.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Counting.BoundedSampling
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.PermutationSampling
import Mathlib.Data.Fintype.Powerset
import Mathlib.Data.Nat.Choose.Sum

namespace OAI

/-!
# Balanced random signs and conditional mixer halves

The three mixers are disjoint. Uniform global sign subsets therefore induce
independent uniform subsets on them. Conditioning each restriction to have
half the mixer size gives the exact balance probability and uniform halves.
-/

namespace LowSpaceSubsetSum

open scoped BigOperators

variable {ι K : Type*} [DecidableEq ι] [Fintype K] [DecidableEq K]

/-- Split a finite set into its restrictions to the fibers of a finite coloring. -/
def partitionFinsetEquiv (c : ι → K) :
    Finset ι ≃ ((k : K) → Finset {x : ι // c x = k}) where
  toFun S k := S.subtype (fun x => c x = k)
  invFun S := Finset.univ.biUnion (fun k => (S k).map (Function.Embedding.subtype _))
  left_inv S := by
    ext x
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_map,
      Function.Embedding.coe_subtype, Finset.mem_subtype]
    constructor
    · rintro ⟨k, y, hy, rfl⟩
      exact hy
    · intro hx
      exact ⟨c x, ⟨x, rfl⟩, hx, rfl⟩
  right_inv S := by
    funext k
    ext x
    simp only [Finset.mem_subtype, Finset.mem_biUnion, Finset.mem_univ,
      true_and, Finset.mem_map, Function.Embedding.coe_subtype]
    constructor
    · rintro ⟨j, y, hy, he⟩
      have hj : j = k := y.property.symm.trans ((congrArg c he).trans x.property)
      subst j
      have hyx : y = x := Subtype.ext he
      simpa only [hyx] using hy
    · intro hx
      exact ⟨k, x, hx, rfl⟩

theorem card_partition_profile [Fintype ι] (c : ι → K)
    (P : (k : K) → Finset {x : ι // c x = k} → Prop) :
    Nat.card {S : Finset ι // ∀ k, P k (S.subtype (fun x => c x = k))} =
      ∏ k, Nat.card {S : Finset {x : ι // c x = k} // P k S} := by
  classical
  let e := (partitionFinsetEquiv c).subtypeEquivOfSubtype
    (p := fun S => ∀ k, P k (S k))
  change Nat.card {S : Finset ι // ∀ k, P k ((partitionFinsetEquiv c) S k)} = _
  rw [Nat.card_congr e, Nat.card_congr Equiv.subtypePiEquivPi, Nat.card_pi]

/-- Balance of the three non-outside color classes. -/
def ColorBalanced (c : ι → Option (Fin 3)) (s : ℕ) (S : Finset ι) : Prop :=
  ∀ i, (S.subtype (fun x => c x = some i)).card = s

theorem colorBalanced_card [Fintype ι] (c : ι → Option (Fin 3)) (s : ℕ)
    (hsize : ∀ i, Fintype.card {x : ι // c x = some i} = 2 * s) :
    Nat.card {S : Finset ι // ColorBalanced c s S} =
      2 ^ Fintype.card {x : ι // c x = none} * ((2 * s).choose s) ^ 3 := by
  classical
  let P : (k : Option (Fin 3)) → Finset {x : ι // c x = k} → Prop :=
    fun k S => match k with
      | none => True
      | some _ => S.card = s
  have hp : (fun S : Finset ι => ColorBalanced c s S) =
      (fun S => ∀ k, P k (S.subtype (fun x => c x = k))) := by
    funext S
    apply propext
    constructor
    · intro h k
      cases k with
      | none => trivial
      | some i => exact h i
    · intro h i
      exact h (some i)
  rw [hp, card_partition_profile, Fintype.prod_option]
  simp only [P, Nat.card_eq_fintype_card, Fintype.card_subtype_true,
    Fintype.card_finset, Fintype.card_finset_len, hsize, Finset.prod_const,
    Finset.card_univ, Fintype.card_fin]

theorem central_binomial_lower (s : ℕ) :
    (2 : ℝ) ^ (2 * s) ≤ (2 * s + 1 : ℝ) * (2 * s).choose s := by
  have h : 2 ^ (2 * s) ≤ (2 * s + 1) * (2 * s).choose s := by
    rw [← Nat.sum_range_choose]
    calc
      _ ≤ ∑ _k ∈ Finset.range (2 * s + 1), (2 * s).choose s := by
        apply Finset.sum_le_sum
        intro k _
        simpa only [Nat.mul_div_cancel_left _ (by decide : 0 < 2)] using
          Nat.choose_le_middle k (2 * s)
      _ = _ := by simp
  exact_mod_cast h

theorem colorBalanced_probability [Fintype ι] (c : ι → Option (Fin 3)) (s : ℕ)
    (hsize : ∀ i, Fintype.card {x : ι // c x = some i} = 2 * s) :
    finiteUniformProbability (ColorBalanced c s) =
      (((2 * s).choose s : ℝ) / (2 : ℝ) ^ (2 * s)) ^ 3 := by
  classical
  have htotal : Fintype.card ι = Fintype.card {x : ι // c x = none} + (2 * s) * 3 := by
    rw [← Fintype.card_congr (Equiv.sigmaFiberEquiv c), Fintype.card_sigma,
      Fintype.sum_option]
    simp only [hsize, Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul]
    omega
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card]
  rw [colorBalanced_card c s hsize, Nat.card_eq_fintype_card, Fintype.card_finset,
    htotal, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, Nat.cast_pow,
    Nat.cast_pow, Nat.cast_ofNat, pow_add, pow_mul]
  field_simp

theorem colorBalanced_probability_lower [Fintype ι] (c : ι → Option (Fin 3)) (s : ℕ)
    (hsize : ∀ i, Fintype.card {x : ι // c x = some i} = 2 * s) :
    1 / (2 * s + 1 : ℝ) ^ 3 ≤ finiteUniformProbability (ColorBalanced c s) := by
  rw [colorBalanced_probability c s hsize, ← one_div_pow]
  apply pow_le_pow_left₀ (by positivity)
  apply (div_le_div_iff₀ (by positivity : (0 : ℝ) < 2 * s + 1) (by positivity)).mpr
  simpa only [one_mul, mul_comm] using central_binomial_lower s

/-- The index of a mixer containing an input position, or the outside category. -/
noncomputable def mixerColor (M : Fin 3 → Finset ι) (x : ι) : Option (Fin 3) :=
  if h : ∃ i, x ∈ M i then some (Classical.choose h) else none

theorem mixerColor_eq_some_iff (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (x : ι) (i : Fin 3) :
    mixerColor M x = some i ↔ x ∈ M i := by
  classical
  unfold mixerColor
  split_ifs with h
  · have hm := Classical.choose_spec h
    constructor
    · intro he
      have hi := Option.some.inj he
      simpa only [hi] using hm
    · intro hi
      have he : Classical.choose h = i := by
        by_contra hn
        exact Finset.disjoint_left.mp (hdisj _ _ hn) hm hi
      simp only [he]
  · constructor
    · intro he
      cases he
    · intro hi
      exact (h ⟨i, hi⟩).elim

def MixerBalanced (M : Fin 3 → Finset ι) (s : ℕ) (S : Finset ι) : Prop :=
  ∀ i, (S ∩ M i).card = s

theorem mixerColor_restriction_card (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (S : Finset ι) (i : Fin 3) :
    (S.subtype (fun x => mixerColor M x = some i)).card = (S ∩ M i).card := by
  classical
  rw [Finset.card_subtype]
  congr 1
  ext x
  simp only [Finset.mem_filter, Finset.mem_inter, mixerColor_eq_some_iff M hdisj]

theorem colorBalanced_mixerColor_iff (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ) (S : Finset ι) :
    ColorBalanced (mixerColor M) s S ↔ MixerBalanced M s S := by
  classical
  simp only [ColorBalanced, MixerBalanced, mixerColor_restriction_card M hdisj]

theorem mixerColor_card [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (i : Fin 3) :
    Fintype.card {x : ι // mixerColor M x = some i} = (M i).card := by
  classical
  let e : {x : ι // mixerColor M x = some i} ≃ (M i) :=
    Equiv.subtypeEquivRight (fun x => mixerColor_eq_some_iff M hdisj x i)
  exact (Fintype.card_congr e).trans (Fintype.card_coe (M i))

/-- Exact balance probability, independent of the locations of the three mixers. -/
theorem mixer_balance_probability [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ)
    (hsize : ∀ i, (M i).card = 2 * s) :
    finiteUniformProbability (MixerBalanced M s) =
      (((2 * s).choose s : ℝ) / (2 : ℝ) ^ (2 * s)) ^ 3 := by
  have hp : MixerBalanced M s = ColorBalanced (mixerColor M) s := by
    funext S
    exact propext (colorBalanced_mixerColor_iff M hdisj s S).symm
  rw [hp]
  apply colorBalanced_probability
  intro i
  rw [mixerColor_card M hdisj i, hsize]

/-- The inverse-cubic balance bound used before the deficiency estimates. -/
theorem mixer_balance_probability_lower [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ)
    (hsize : ∀ i, (M i).card = 2 * s) :
    1 / (2 * s + 1 : ℝ) ^ 3 ≤ finiteUniformProbability (MixerBalanced M s) := by
  have hp : MixerBalanced M s = ColorBalanced (mixerColor M) s := by
    funext S
    exact propext (colorBalanced_mixerColor_iff M hdisj s S).symm
  rw [hp]
  apply colorBalanced_probability_lower
  intro i
  rw [mixerColor_card M hdisj i, hsize]

theorem finiteUniformProbability_equiv {Ω Ψ : Type*} [Fintype Ω] [Fintype Ψ]
    (e : Ω ≃ Ψ) (P : Ψ → Prop) :
    finiteUniformProbability (fun x => P (e x)) = finiteUniformProbability P := by
  classical
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card]
  rw [Nat.card_congr (e.subtypeEquivOfSubtype (p := P)), Nat.card_congr e]

/-- Randomly permuting any independently chosen size-`s` set gives the same
uniform marginal, even when the choice of that set has additional constraints. -/
theorem permuted_family_uniform [Fintype ι] {Ξ : Type*} [Fintype Ξ] [Nonempty Ξ]
    (B : Ξ → Finset ι) (s : ℕ) (hB : ∀ ξ, (B ξ).card = s) (P : Finset ι → Prop) :
    finiteUniformProbability (fun z : Equiv.Perm ι × Ξ => P (permuteSubset z.1 (B z.2))) =
      finiteUniformProbability (fun S : ↥((Finset.univ : Finset ι).powersetCard s) => P S.val) := by
  classical
  let ξ₀ : Ξ := Classical.choice inferInstance
  let T₀ : ↥((Finset.univ : Finset ι).powersetCard s) :=
    ⟨B ξ₀, Finset.mem_powersetCard.mpr ⟨Finset.subset_univ _, hB ξ₀⟩⟩
  let : Nonempty ↥((Finset.univ : Finset ι).powersetCard s) := ⟨T₀⟩
  let f : Equiv.Perm ι × Ξ → ↥((Finset.univ : Finset ι).powersetCard s) :=
    fun z => ⟨permuteSubset z.1 (B z.2),
      Finset.mem_powersetCard.mpr ⟨Finset.subset_univ _, (permuteSubset_card _ _).trans (hB _)⟩⟩
  have hf (T : ↥((Finset.univ : Finset ι).powersetCard s)) :
      Fintype.card {z // f z = T} = Fintype.card {z // f z = T₀} := by
    obtain ⟨τ, hτ⟩ := exists_permutation_of_card_eq T.val T₀.val
      ((Finset.mem_powersetCard.mp T.property).2.trans
        (Finset.mem_powersetCard.mp T₀.property).2.symm)
    have hτinv : permuteSubset τ.symm T₀.val = T.val := by
      rw [← hτ, ← permuteSubset_trans]
      simp
    let e : {z // f z = T} ≃ {z // f z = T₀} :=
      { toFun := fun z => ⟨(z.1.1.trans τ, z.1.2), by
          apply Subtype.ext
          change permuteSubset (z.1.1.trans τ) (B z.1.2) = T₀.val
          rw [permuteSubset_trans]
          have hz : permuteSubset z.1.1 (B z.1.2) = T.val := congrArg Subtype.val z.2
          rw [hz, hτ]⟩
        invFun := fun z => ⟨(z.1.1.trans τ.symm, z.1.2), by
          apply Subtype.ext
          change permuteSubset (z.1.1.trans τ.symm) (B z.1.2) = T.val
          rw [permuteSubset_trans]
          have hz : permuteSubset z.1.1 (B z.1.2) = T₀.val := congrArg Subtype.val z.2
          rw [hz, hτinv]⟩
        left_inv := fun z => by
          apply Subtype.ext
          apply Prod.ext
          · ext x
            simp
          · rfl
        right_inv := fun z => by
          apply Subtype.ext
          apply Prod.ext
          · ext x
            simp
          · rfl }
    exact Fintype.card_congr e
  exact finiteUniformProbability_map_of_constant_fibers f hf (fun S => P S.val)

@[simp] theorem permuteSubset_inter [Fintype ι] (e : Equiv.Perm ι) (S T : Finset ι) :
    permuteSubset e (S ∩ T) = permuteSubset e S ∩ permuteSubset e T :=
  Finset.map_inter S T

@[simp] theorem permuteSubset_sdiff [Fintype ι] (e : Equiv.Perm ι) (S T : Finset ι) :
    permuteSubset e (S \ T) = permuteSubset e S \ permuteSubset e T :=
  Finset.map_sdiff S T

theorem mixerBalanced_permute [Fintype ι] (M : Fin 3 → Finset ι) (s : ℕ)
    (e : Equiv.Perm ι) (F : Finset ι) :
    MixerBalanced (fun i => permuteSubset e (M i)) s (permuteSubset e F) ↔
      MixerBalanced M s F := by
  simp only [MixerBalanced, ← permuteSubset_inter, permuteSubset_card]

abbrev BalancedSignSubsets (M : Fin 3 → Finset ι) (s : ℕ) :=
  {F : Finset ι // MixerBalanced M s F}

noncomputable instance balancedSignSubsetsFintype [Fintype ι]
    (M : Fin 3 → Finset ι) (s : ℕ) : Fintype (BalancedSignSubsets M s) := Fintype.ofFinite _

abbrev BalancedMixerJoint [Fintype ι] (M : Fin 3 → Finset ι) (s : ℕ) :=
  {z : Equiv.Perm ι × Finset ι //
    MixerBalanced (fun i => permuteSubset z.1 (M i)) s z.2}

noncomputable instance balancedMixerJointFintype [Fintype ι]
    (M : Fin 3 → Finset ι) (s : ℕ) : Fintype (BalancedMixerJoint M s) := Fintype.ofFinite _

/-- Conditioning the global sign subset on mixer balance leaves the permutation
uniform and independent of the balanced sign subset in the original coordinates. -/
def balancedMixerJointEquiv [Fintype ι] (M : Fin 3 → Finset ι) (s : ℕ) :
    BalancedMixerJoint M s ≃ Equiv.Perm ι × BalancedSignSubsets M s where
  toFun z := (z.1.1, ⟨permuteSubset z.1.1.symm z.1.2, by
    apply (mixerBalanced_permute M s z.1.1 _).mp
    have he : permuteSubset z.1.1 (permuteSubset z.1.1.symm z.1.2) = z.1.2 := by
      rw [← permuteSubset_trans]
      simp
    simpa only [he] using z.2⟩)
  invFun z := ⟨(z.1, permuteSubset z.1 z.2.val),
    (mixerBalanced_permute M s z.1 z.2.val).mpr z.2.property⟩
  left_inv z := by
    apply Subtype.ext
    apply Prod.ext
    · rfl
    · change permuteSubset z.1.1 (permuteSubset z.1.1.symm z.1.2) = z.1.2
      rw [← permuteSubset_trans]
      simp
  right_inv z := by
    apply Prod.ext
    · rfl
    · apply Subtype.ext
      change permuteSubset z.1.symm (permuteSubset z.1 z.2.val) = z.2.val
      rw [← permuteSubset_trans]
      simp

theorem balancedSignSubsets_nonempty [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ)
    (hsize : ∀ i, (M i).card = 2 * s) : Nonempty (BalancedSignSubsets M s) := by
  have hp : 0 < finiteUniformProbability (MixerBalanced M s) :=
    lt_of_lt_of_le (by positivity) (mixer_balance_probability_lower M hdisj s hsize)
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card] at hp
  have hden : (0 : ℝ) < Nat.card (Finset ι) := by exact_mod_cast Nat.card_pos
  have hn : 0 < Nat.card (BalancedSignSubsets M s) := by
    exact_mod_cast (div_pos_iff_of_pos_right hden).mp hp
  exact (Nat.card_pos_iff.mp hn).1

theorem conditioned_mixer_permutation_uniform [Fintype ι]
    (M : Fin 3 → Finset ι) (s : ℕ) [Nonempty (BalancedSignSubsets M s)]
    (P : Equiv.Perm ι → Prop) :
    finiteUniformProbability (fun z : BalancedMixerJoint M s => P z.val.1) =
      finiteUniformProbability P := by
  let e := balancedMixerJointEquiv M s
  calc
    _ = finiteUniformProbability (fun z : Equiv.Perm ι × BalancedSignSubsets M s => P z.1) :=
      finiteUniformProbability_equiv e (fun z => P z.1)
    _ = _ := finiteUniformProbability_fst P

theorem conditioned_selected_half_uniform [Fintype ι]
    (M : Fin 3 → Finset ι) (s : ℕ) [Nonempty (BalancedSignSubsets M s)]
    (i : Fin 3) (P : Finset ι → Prop) :
    finiteUniformProbability (fun z : BalancedMixerJoint M s =>
      P (z.val.2 ∩ permuteSubset z.val.1 (M i))) =
      finiteUniformProbability (fun S : ↥((Finset.univ : Finset ι).powersetCard s) => P S.val) := by
  let B : BalancedSignSubsets M s → Finset ι := fun F => F.val ∩ M i
  have hB : ∀ F, (B F).card = s := fun F => F.property i
  calc
    _ = finiteUniformProbability (fun z : Equiv.Perm ι × BalancedSignSubsets M s =>
        P (permuteSubset z.1 (B z.2))) := by
      have h := finiteUniformProbability_equiv (balancedMixerJointEquiv M s)
        (fun z : Equiv.Perm ι × BalancedSignSubsets M s => P (permuteSubset z.1 (B z.2)))
      convert h using 1
      congr 1
      funext z
      change P (z.val.2 ∩ permuteSubset z.val.1 (M i)) =
        P (permuteSubset z.val.1 (permuteSubset z.val.1.symm z.val.2 ∩ M i))
      rw [permuteSubset_inter]
      rw [← permuteSubset_trans]
      simp
    _ = _ := permuted_family_uniform B s hB P

theorem conditioned_complement_half_uniform [Fintype ι]
    (M : Fin 3 → Finset ι) (s : ℕ) [Nonempty (BalancedSignSubsets M s)]
    (hsize : ∀ i, (M i).card = 2 * s) (i : Fin 3) (P : Finset ι → Prop) :
    finiteUniformProbability (fun z : BalancedMixerJoint M s =>
      P (permuteSubset z.val.1 (M i) \ z.val.2)) =
      finiteUniformProbability (fun S : ↥((Finset.univ : Finset ι).powersetCard s) => P S.val) := by
  let B : BalancedSignSubsets M s → Finset ι := fun F => M i \ F.val
  have hB : ∀ F, (B F).card = s := by
    intro F
    dsimp [B]
    rw [Finset.card_sdiff, F.property i, hsize]
    omega
  calc
    _ = finiteUniformProbability (fun z : Equiv.Perm ι × BalancedSignSubsets M s =>
        P (permuteSubset z.1 (B z.2))) := by
      have h := finiteUniformProbability_equiv (balancedMixerJointEquiv M s)
        (fun z : Equiv.Perm ι × BalancedSignSubsets M s => P (permuteSubset z.1 (B z.2)))
      convert h using 1
      congr 1
      funext z
      change P (permuteSubset z.val.1 (M i) \ z.val.2) =
        P (permuteSubset z.val.1 (M i \ permuteSubset z.val.1.symm z.val.2))
      rw [permuteSubset_sdiff]
      rw [← permuteSubset_trans]
      simp
    _ = _ := permuted_family_uniform B s hB P

/-- A restriction in a mixer must have size `s`; the outside restriction is free. -/
abbrev BalancedColorRestriction (c : ι → Option (Fin 3)) (s : ℕ)
    (k : Option (Fin 3)) :=
  {S : Finset {x : ι // c x = k} // match k with
    | none => True
    | some _ => S.card = s}

noncomputable instance balancedColorRestrictionFintype [Fintype ι]
    (c : ι → Option (Fin 3)) (s : ℕ) (k : Option (Fin 3)) :
    Fintype (BalancedColorRestriction c s k) := Fintype.ofFinite _

def colorBalancedRestrictionEquiv (c : ι → Option (Fin 3)) (s : ℕ) :
    {F : Finset ι // ColorBalanced c s F} ≃
      ((k : Option (Fin 3)) → BalancedColorRestriction c s k) where
  toFun F k := ⟨F.val.subtype (fun x => c x = k), by
    cases k with
    | none => trivial
    | some i => exact F.property i⟩
  invFun f := ⟨(partitionFinsetEquiv c).symm (fun k => (f k).val), by
    intro i
    have hi := congrFun ((partitionFinsetEquiv c).apply_symm_apply
      (fun k => (f k).val)) (some i)
    change ((partitionFinsetEquiv c)
      ((partitionFinsetEquiv c).symm (fun k => (f k).val)) (some i)).card = s
    rw [hi]
    exact (f (some i)).property⟩
  left_inv F := by
    apply Subtype.ext
    exact (partitionFinsetEquiv c).symm_apply_apply F.val
  right_inv f := by
    funext k
    apply Subtype.ext
    exact congrFun ((partitionFinsetEquiv c).apply_symm_apply (fun k => (f k).val)) k

/-- The full conditional sign law is the product of the three uniform halves
and the unrestricted outside signs. -/
noncomputable def balancedMixerRestrictionEquiv (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ) :
    BalancedSignSubsets M s ≃
      ((k : Option (Fin 3)) → BalancedColorRestriction (mixerColor M) s k) :=
  (Equiv.subtypeEquivRight (fun F => (colorBalanced_mixerColor_iff M hdisj s F).symm)).trans
    (colorBalancedRestrictionEquiv (mixerColor M) s)

theorem conditioned_mixer_restrictions_uniform [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ)
    (P : ((k : Option (Fin 3)) → BalancedColorRestriction (mixerColor M) s k) → Prop) :
    finiteUniformProbability (fun F : BalancedSignSubsets M s =>
      P (balancedMixerRestrictionEquiv M hdisj s F)) = finiteUniformProbability P :=
  finiteUniformProbability_equiv (balancedMixerRestrictionEquiv M hdisj s) P

theorem conditioned_mixer_restrictions_point [Fintype ι] (M : Fin 3 → Finset ι)
    (hdisj : ∀ i j, i ≠ j → Disjoint (M i) (M j)) (s : ℕ)
    (r : (k : Option (Fin 3)) → BalancedColorRestriction (mixerColor M) s k) :
    finiteUniformProbability (fun F : BalancedSignSubsets M s =>
      balancedMixerRestrictionEquiv M hdisj s F = r) =
        ∏ k, 1 / (Fintype.card (BalancedColorRestriction (mixerColor M) s k) : ℝ) := by
  classical
  rw [conditioned_mixer_restrictions_uniform M hdisj s (fun f => f = r),
    finiteUniformProbability_eq_cardRatio]
  simp only [Fintype.card_subtype_eq, Fintype.card_pi, Nat.cast_prod,
    Finset.prod_div_distrib, Finset.prod_const_one, Nat.cast_one]

end LowSpaceSubsetSum

end OAI