import OAI.Combinatorics.LowSpaceSubsetSum.Counting.BalancedPartitions
import OAI.Combinatorics.LowSpaceSubsetSum.Counting.PrimeHash
import Mathlib.Data.Nat.Log

namespace OAI

/-!
# Bounded rejection sampling

The executable sampler reads at most the supplied number of candidates. All
probability statements use the uniform law on the finite candidate tuples,
which is exactly independent sampling with replacement.
-/

namespace LowSpaceSubsetSum

open scoped BigOperators

variable {Ω : Type*}

theorem finiteUniformProbability_eq_cardRatio [Fintype Ω]
    (A : Ω → Prop) [DecidablePred A] :
    finiteUniformProbability A = (Fintype.card {x : Ω // A x} : ℝ) / Fintype.card Ω := by
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card]

/-- Read candidates in their given order and return the first eligible value. -/
def firstAccept (A : Ω → Prop) [DecidablePred A] :
    (N : ℕ) → (Fin N → Ω) → Option Ω
  | 0, _ => none
  | N + 1, f => if A (f 0) then some (f 0)
      else firstAccept A N (fun i => f i.succ)

theorem firstAccept_eq_none_iff (A : Ω → Prop) [DecidablePred A]
    (N : ℕ) (f : Fin N → Ω) : firstAccept A N f = none ↔ ∀ i, ¬A (f i) := by
  induction N with
  | zero => simp [firstAccept]
  | succ N ih =>
    simp only [firstAccept, Fin.forall_fin_succ]
    split_ifs with h
    · simp [h]
    · simpa [h] using ih (fun i => f i.succ)

theorem firstAccept_some_eligible (A : Ω → Prop) [DecidablePred A]
    (N : ℕ) (f : Fin N → Ω) {a : Ω} (h : firstAccept A N f = some a) : A a := by
  induction N with
  | zero => simp [firstAccept] at h
  | succ N ih =>
    simp only [firstAccept] at h
    split_ifs at h with ha
    · exact Option.some.inj h ▸ ha
    · exact ih (fun i => f i.succ) h

theorem firstAccept_failure [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) :
    finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f = none) =
      (1 - finiteUniformProbability A) ^ N := by
  have hpred : (fun f : Fin N → Ω => firstAccept A N f = none) =
      (fun f => ∀ i, ¬A (f i)) := by
    funext f
    exact propext (firstAccept_eq_none_iff A N f)
  rw [hpred, uniform_family_failure]

noncomputable def firstAcceptCount [Fintype Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) : ℕ := by
  classical
  exact Fintype.card {f : Fin N → Ω // firstAccept A N f = some a}

private def firstAcceptFiberSuccEquiv (A : Ω → Prop) [DecidablePred A]
    (N : ℕ) (a : Ω) (ha : A a) :
    {f : Fin (N + 1) → Ω // firstAccept A (N + 1) f = some a} ≃
      (Fin N → Ω) ⊕
        ({b : Ω // ¬A b} × {f : Fin N → Ω // firstAccept A N f = some a}) := by
  let forward : {f : Fin (N + 1) → Ω // firstAccept A (N + 1) f = some a} →
      (Fin N → Ω) ⊕
        ({b : Ω // ¬A b} × {f : Fin N → Ω // firstAccept A N f = some a}) :=
    fun f => if h : A (f.1 0) then Sum.inl (fun i => f.1 i.succ)
      else Sum.inr (⟨f.1 0, h⟩, ⟨fun i => f.1 i.succ, by
        simpa [firstAccept, h] using f.2⟩)
  let backward : (Fin N → Ω) ⊕
      ({b : Ω // ¬A b} × {f : Fin N → Ω // firstAccept A N f = some a}) →
      {f : Fin (N + 1) → Ω // firstAccept A (N + 1) f = some a} :=
    Sum.elim
      (fun f => ⟨Fin.cons a f, by simp [firstAccept, ha]⟩)
      (fun z => ⟨Fin.cons z.1.1 z.2.1, by simpa [firstAccept, z.1.2] using z.2.2⟩)
  refine ⟨forward, backward, ?_, ?_⟩
  · intro f
    apply Subtype.ext
    by_cases h : A (f.1 0)
    · have he : f.1 0 = a := Option.some.inj (by
        simpa [firstAccept, h] using f.2)
      change (backward (forward f)).val = f.val
      simp only [forward, dite_eq_left h, backward, Sum.elim_inl]
      funext i
      refine Fin.cases ?_ (fun _ => rfl) i
      simpa using he.symm
    · change (backward (forward f)).val = f.val
      simp only [forward, dite_eq_right h, backward, Sum.elim_inr]
      exact Fin.cons_self_tail _
  · intro z
    rcases z with f | ⟨⟨b, hb⟩, ⟨f, hf⟩⟩
    · simp [forward, backward, ha]
    · simp [forward, backward, hb]

theorem firstAcceptCount_succ [Fintype Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) (ha : A a) :
    firstAcceptCount A (N + 1) a = Fintype.card Ω ^ N +
      Fintype.card {b : Ω // ¬A b} * firstAcceptCount A N a := by
  classical
  unfold firstAcceptCount
  rw [Fintype.card_congr (firstAcceptFiberSuccEquiv A N a ha)]
  simp only [Fintype.card_sum, Fintype.card_prod, Fintype.card_fun, Fintype.card_fin]

theorem firstAcceptCount_conservation [Fintype Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) (ha : A a) :
    Fintype.card {b : Ω // A b} * firstAcceptCount A N a +
      Fintype.card {b : Ω // ¬A b} ^ N = Fintype.card Ω ^ N := by
  classical
  induction N with
  | zero => simp [firstAcceptCount, firstAccept]
  | succ N ih =>
    rw [firstAcceptCount_succ A N a ha, pow_succ, pow_succ]
    have hsum : Fintype.card {b : Ω // A b} + Fintype.card {b : Ω // ¬A b} =
        Fintype.card Ω := by
      rw [Fintype.card_subtype_compl]
      exact Nat.add_sub_of_le (Fintype.card_subtype_le A)
    calc
      _ = Fintype.card {b : Ω // A b} * Fintype.card Ω ^ N +
          Fintype.card {b : Ω // ¬A b} *
            (Fintype.card {b : Ω // A b} * firstAcceptCount A N a +
              Fintype.card {b : Ω // ¬A b} ^ N) := by ring
      _ = _ := by rw [ih, ← add_mul, hsum, mul_comm]

/-- The exact subprobability of every eligible return value. -/
theorem firstAccept_value_probability [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) (ha : A a) :
    finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f = some a) =
      (1 - (1 - finiteUniformProbability A) ^ N) / Fintype.card {b : Ω // A b} := by
  classical
  have hc : (Fintype.card {b : Ω // A b} : ℝ) * firstAcceptCount A N a +
      (Fintype.card {b : Ω // ¬A b} : ℝ) ^ N = (Fintype.card Ω : ℝ) ^ N := by
    exact_mod_cast firstAcceptCount_conservation A N a ha
  have hΩ : (Fintype.card Ω : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
  have hA : (Fintype.card {b : Ω // A b} : ℝ) ≠ 0 := by
    have : Nonempty {b : Ω // A b} := ⟨⟨a, ha⟩⟩
    exact_mod_cast Fintype.card_ne_zero
  have hvalue : finiteUniformProbability
      (fun f : Fin N → Ω => firstAccept A N f = some a) =
      (firstAcceptCount A N a : ℝ) / (Fintype.card Ω : ℝ) ^ N := by
    simp only [finiteUniformProbability, firstAcceptCount, ← Nat.card_eq_fintype_card,
      Nat.card_fun, Nat.card_fin, Nat.cast_pow]
  rw [hvalue, ← finiteUniformProbability_compl A, finiteUniformProbability_eq_cardRatio]
  rw [div_pow]
  field_simp [hΩ, hA]
  nlinarith [hc]

theorem firstAccept_acceptance [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) :
    finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f ≠ none) =
      1 - (1 - finiteUniformProbability A) ^ N := by
  rw [finiteUniformProbability_compl, firstAccept_failure]

/-- Conditioning only this call on acceptance gives the uniform eligible law. -/
theorem firstAccept_conditional_uniform [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (hN : 0 < N) (a : Ω) (ha : A a) :
    finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f = some a) /
        finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f ≠ none) =
      1 / Fintype.card {b : Ω // A b} := by
  classical
  have hA : 0 < finiteUniformProbability A := by
    have : Nonempty {b : Ω // A b} := ⟨⟨a, ha⟩⟩
    rw [finiteUniformProbability_eq_cardRatio]
    exact div_pos (by exact_mod_cast Fintype.card_pos) (by exact_mod_cast Fintype.card_pos)
  have hA1 := finiteUniformProbability_le_one A
  have hpow : (1 - finiteUniformProbability A) ^ N < 1 :=
    pow_lt_one₀ (by linarith) (by linarith) (by omega)
  rw [firstAccept_value_probability A N a ha, firstAccept_acceptance]
  have hnz : 1 - (1 - finiteUniformProbability A) ^ N ≠ 0 := by linarith
  field_simp

theorem firstAccept_failure_le_exp [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) {ρ : ℝ}
    (hρ : ρ ≤ finiteUniformProbability A) :
    finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f = none) ≤
      Real.exp (-(N : ℝ) * ρ) := by
  rw [firstAccept_failure]
  have hA1 := finiteUniformProbability_le_one A
  have hbase : 1 - finiteUniformProbability A ≤ Real.exp (-ρ) := by
    linarith [Real.add_one_le_exp (-ρ)]
  have h := pow_le_pow_left₀ (by linarith : 0 ≤ 1 - finiteUniformProbability A) hbase N
  rw [← Real.exp_nat_mul] at h
  convert h using 1
  congr 1
  ring

private theorem card_fin_lt (D B : ℕ) (hDB : D ≤ B) :
    Fintype.card {x : Fin B // x.val < D} = D := by
  let e : {x : Fin B // x.val < D} ≃ Fin D :=
    { toFun := fun x => ⟨x.1.1, x.2⟩
      invFun := fun x => ⟨⟨x.1, x.2.trans_le hDB⟩, x.2⟩
      left_inv := fun _ => rfl
      right_inv := fun _ => rfl }
  exact (Fintype.card_congr e).trans (Fintype.card_fin D)

/-- Rejection predicate for the `clog₂ D` fresh low bits. -/
def rangeEligible (D : ℕ) (x : Fin (2 ^ Nat.clog 2 D)) : Prop := x.val < D

instance (D : ℕ) : DecidablePred (rangeEligible D) := fun _ => inferInstanceAs (Decidable (_ < _))

theorem rangeEligible_probability (D : ℕ) :
    finiteUniformProbability (rangeEligible D) = (D : ℝ) / (2 : ℝ) ^ Nat.clog 2 D := by
  have hc : Fintype.card {x : Fin (2 ^ Nat.clog 2 D) // rangeEligible D x} = D := by
    calc
      _ = Nat.card {x : Fin (2 ^ Nat.clog 2 D) // rangeEligible D x} :=
        Nat.card_eq_fintype_card.symm
      _ = Nat.card {x : Fin (2 ^ Nat.clog 2 D) // x.val < D} := rfl
      _ = Fintype.card {x : Fin (2 ^ Nat.clog 2 D) // x.val < D} :=
        Nat.card_eq_fintype_card
      _ = D := card_fin_lt D (2 ^ Nat.clog 2 D) (Nat.le_pow_clog (by decide : 1 < 2) D)
  rw [finiteUniformProbability_eq_cardRatio]
  rw [hc, Fintype.card_fin]
  norm_cast

theorem rangeEligible_probability_lower {D : ℕ} (hD : 1 < D) :
    (1 : ℝ) / 2 ≤ finiteUniformProbability (rangeEligible D) := by
  rw [rangeEligible_probability]
  have hp := Nat.pow_pred_clog_lt_self (by decide : 1 < 2) hD
  have hpos := Nat.clog_pos (by decide : 1 < 2) hD
  have hbits : 2 ^ Nat.clog 2 D ≤ 2 * D := by
    rw [show Nat.clog 2 D = (Nat.clog 2 D).pred + 1 from
      (Nat.succ_pred_eq_of_pos hpos).symm, pow_succ]
    omega
  have hb : (2 : ℝ) ^ Nat.clog 2 D ≤ 2 * D := by exact_mod_cast hbits
  apply (le_div_iff₀ (by positivity : (0 : ℝ) < 2 ^ Nat.clog 2 D)).mpr
  linarith

theorem rangeSampler_failure {D : ℕ} (hD : 1 < D) (n : ℕ) :
    finiteUniformProbability (fun f : Fin (n ^ 3) → Fin (2 ^ Nat.clog 2 D) =>
      firstAccept (rangeEligible D) (n ^ 3) f = none) ≤ 1 / (2 : ℝ) ^ (n ^ 3) := by
  rw [firstAccept_failure]
  have hlow := rangeEligible_probability_lower hD
  have hupp := finiteUniformProbability_le_one (rangeEligible D)
  have h := pow_le_pow_left₀ (by linarith : 0 ≤ 1 - finiteUniformProbability (rangeEligible D))
    (by linarith : 1 - finiteUniformProbability (rangeEligible D) ≤ 1 / 2) (n ^ 3)
  simpa only [one_div_pow] using h

/-- Exactly the prime test performed on an `ell`-bit candidate. -/
def primeEligible (ell : ℕ) (x : Fin (2 ^ ell)) : Prop := x.val ∈ primeRange ell

instance (ell : ℕ) : DecidablePred (primeEligible ell) := fun _ => inferInstanceAs (Decidable (_ ∈ _))

theorem primeEligible_probability {ell : ℕ} (hell : 4 ≤ ell) :
    finiteUniformProbability (primeEligible ell) =
      ((primeRange ell).card : ℝ) / (2 : ℝ) ^ ell := by
  classical
  let e : {x : Fin (2 ^ ell) // primeEligible ell x} ≃ {p : ℕ // p ∈ primeRange ell} :=
    { toFun := fun x => ⟨x.1.1, x.2⟩
      invFun := fun p => ⟨⟨p.1, primeRange_lt hell p.2⟩, p.2⟩
      left_inv := fun _ => rfl
      right_inv := fun _ => rfl }
  rw [finiteUniformProbability_eq_cardRatio]
  rw [Fintype.card_congr e, Fintype.card_coe, Fintype.card_fin, Nat.cast_pow, Nat.cast_ofNat]

theorem primeEligible_probability_lower {ell : ℕ} (hell : 4 ≤ ell) :
    1 / (4 * (ell : ℝ)) ≤ finiteUniformProbability (primeEligible ell) := by
  rw [primeEligible_probability hell]
  have h : (2 : ℝ) ^ ell ≤ 4 * ell * (primeRange ell).card := by
    exact_mod_cast primeRange_card_lower hell
  have he : (0 : ℝ) < ell := by exact_mod_cast (by omega : 0 < ell)
  apply (div_le_div_iff₀ (by positivity : (0 : ℝ) < 4 * ell) (by positivity)).mpr
  simpa only [one_mul, mul_comm] using h

theorem primeSampler_failure {ell n : ℕ} (hell : 4 ≤ ell) (hen : ell ≤ n) :
    finiteUniformProbability (fun f : Fin (n ^ 3) → Fin (2 ^ ell) =>
      firstAccept (primeEligible ell) (n ^ 3) f = none) ≤
      Real.exp (-((n : ℝ) ^ 2 / 4)) := by
  apply (firstAccept_failure_le_exp (primeEligible ell) (n ^ 3)
    (primeEligible_probability_lower hell)).trans
  apply Real.exp_le_exp.mpr
  have he : (0 : ℝ) < ell := by exact_mod_cast (by omega : 0 < ell)
  have hen' : (ell : ℝ) ≤ n := by exact_mod_cast hen
  push_cast
  rw [neg_mul, mul_one_div, neg_le_neg_iff]
  apply (le_div_iff₀ (by positivity : (0 : ℝ) < 4 * ell)).mpr
  nlinarith [mul_nonneg (sq_nonneg (n : ℝ)) (sub_nonneg.mpr hen')]

/-- Complete an exhausted bounded call with an independent eligible backup.
This is the ideal marginal in the explicit one-call coupling. -/
def completedFirstAccept (A : Ω → Prop) [DecidablePred A] (N : ℕ)
    (f : Fin N → Ω) (backup : {a : Ω // A a}) : Ω :=
  (firstAccept A N f).getD backup.val

theorem completedFirstAccept_eligible (A : Ω → Prop) [DecidablePred A] (N : ℕ)
    (f : Fin N → Ω) (backup : {a : Ω // A a}) : A (completedFirstAccept A N f backup) := by
  cases h : firstAccept A N f with
  | none => simpa [completedFirstAccept, h] using backup.property
  | some a => simpa [completedFirstAccept, h] using firstAccept_some_eligible A N f h

theorem completedFirstAccept_mismatch_iff (A : Ω → Prop) [DecidablePred A] (N : ℕ)
    (f : Fin N → Ω) (backup : {a : Ω // A a}) :
    some (completedFirstAccept A N f backup) ≠ firstAccept A N f ↔
      firstAccept A N f = none := by
  cases h : firstAccept A N f <;> simp [completedFirstAccept, h]

private def firstAcceptNoneEquiv (A : Ω → Prop) [DecidablePred A] (N : ℕ) :
    {f : Fin N → Ω // firstAccept A N f = none} ≃ (Fin N → {a : Ω // ¬A a}) where
  toFun f i := ⟨f.val i, (firstAccept_eq_none_iff A N f.val).mp f.property i⟩
  invFun f := ⟨fun i => (f i).val,
    (firstAccept_eq_none_iff A N _).mpr (fun i => (f i).property)⟩
  left_inv := fun _ => rfl
  right_inv := fun _ => rfl

private theorem firstAccept_none_card [Fintype Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) :
    Nat.card {f : Fin N → Ω // firstAccept A N f = none} =
      Fintype.card {a : Ω // ¬A a} ^ N := by
  rw [Nat.card_congr (firstAcceptNoneEquiv A N), Nat.card_fun]
  simp only [Nat.card_eq_fintype_card, Fintype.card_fin]

private noncomputable def completedFirstAcceptFiberEquiv
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) (ha : A a) :
    {z : (Fin N → Ω) × {b : Ω // A b} // completedFirstAccept A N z.1 z.2 = a} ≃
      ({f : Fin N → Ω // firstAccept A N f = some a} × {b : Ω // A b}) ⊕
        {f : Fin N → Ω // firstAccept A N f = none} := by
  classical
  let forward :
      {z : (Fin N → Ω) × {b : Ω // A b} // completedFirstAccept A N z.1 z.2 = a} →
      ({f : Fin N → Ω // firstAccept A N f = some a} × {b : Ω // A b}) ⊕
        {f : Fin N → Ω // firstAccept A N f = none} := fun z =>
    if h : firstAccept A N z.1.1 = none then Sum.inr ⟨z.1.1, h⟩ else
      Sum.inl (⟨z.1.1, by
        cases hf : firstAccept A N z.1.1 with
        | none => exact (h hf).elim
        | some b =>
          have hb : b = a := by simpa [completedFirstAccept, hf] using z.2
          simp only [hb]⟩, z.1.2)
  let backward :
      ({f : Fin N → Ω // firstAccept A N f = some a} × {b : Ω // A b}) ⊕
        {f : Fin N → Ω // firstAccept A N f = none} →
      {z : (Fin N → Ω) × {b : Ω // A b} // completedFirstAccept A N z.1 z.2 = a} :=
    Sum.elim
      (fun z => ⟨(z.1.val, z.2), by simp [completedFirstAccept, z.1.property]⟩)
      (fun f => ⟨(f.val, ⟨a, ha⟩), by simp [completedFirstAccept, f.property]⟩)
  refine ⟨forward, backward, ?_, ?_⟩
  · intro z
    apply Subtype.ext
    by_cases h : firstAccept A N z.1.1 = none
    · simp only [forward, dite_eq_left h, backward, Sum.elim_inr]
      apply Prod.ext
      · rfl
      · apply Subtype.ext
        have hb : z.1.2.val = a := by simpa [completedFirstAccept, h] using z.2
        exact hb.symm
    · simp only [forward, dite_eq_right h, backward, Sum.elim_inl]
  · intro z
    rcases z with ⟨f, backup⟩ | f
    · simp [forward, backward, f.property]
    · simp [forward, backward, f.property]

/-- The ideal marginal is exactly uniform; the backup introduces no bias. -/
theorem completedFirstAccept_uniform [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] (N : ℕ) (a : Ω) (ha : A a) :
    finiteUniformProbability
      (fun z : (Fin N → Ω) × {b : Ω // A b} => completedFirstAccept A N z.1 z.2 = a) =
        1 / Fintype.card {b : Ω // A b} := by
  classical
  have hc : Nat.card
      {z : (Fin N → Ω) × {b : Ω // A b} // completedFirstAccept A N z.1 z.2 = a} =
        Fintype.card Ω ^ N := by
    rw [Nat.card_congr (completedFirstAcceptFiberEquiv A N a ha), Nat.card_sum,
      Nat.card_prod, firstAccept_none_card]
    have he : Nat.card {f : Fin N → Ω // firstAccept A N f = some a} =
        firstAcceptCount A N a := by
      simp only [firstAcceptCount, ← Nat.card_eq_fintype_card]
    rw [he, Nat.card_eq_fintype_card]
    simpa only [Nat.mul_comm] using firstAcceptCount_conservation A N a ha
  have hΩ : (Fintype.card Ω : ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero
  have hA : (Fintype.card {b : Ω // A b} : ℝ) ≠ 0 := by
    have : Nonempty {b : Ω // A b} := ⟨⟨a, ha⟩⟩
    exact_mod_cast Fintype.card_ne_zero
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card, Nat.card_prod,
    Nat.card_fun, Nat.card_fin, Nat.cast_mul, Nat.cast_pow]
  rw [hc, Nat.cast_pow]
  simp only [Nat.card_eq_fintype_card]
  field_simp [hΩ, hA]

theorem finiteUniformProbability_fst [Fintype Ω] {Ψ : Type*} [Fintype Ψ] [Nonempty Ψ]
    (P : Ω → Prop) :
    finiteUniformProbability (fun z : Ω × Ψ => P z.1) = finiteUniformProbability P := by
  classical
  let e : {z : Ω × Ψ // P z.1} ≃ {x : Ω // P x} × Ψ :=
    { toFun := fun z => (⟨z.1.1, z.2⟩, z.1.2)
      invFun := fun z => ⟨(z.1.val, z.2), z.1.property⟩
      left_inv := fun _ => rfl
      right_inv := fun _ => rfl }
  have hc : Nat.card {z : Ω × Ψ // P z.1} = Nat.card {x : Ω // P x} * Nat.card Ψ := by
    rw [Nat.card_congr e, Nat.card_prod]
  have hΨ : (Nat.card Ψ : ℝ) ≠ 0 := by
    rw [Nat.card_eq_fintype_card]
    exact_mod_cast Fintype.card_ne_zero
  simp only [finiteUniformProbability, ← Nat.card_eq_fintype_card, Nat.card_prod,
    Nat.cast_mul]
  rw [hc, Nat.cast_mul]
  exact mul_div_mul_right _ _ hΨ

/-- In the explicit finite coupling, disagreement is exactly exhaustion of the
bounded call. The first marginal is the original independent candidate tuple. -/
theorem firstAccept_coupling_mismatch [Fintype Ω] [Nonempty Ω]
    (A : Ω → Prop) [DecidablePred A] [Nonempty {a : Ω // A a}] (N : ℕ) :
    finiteUniformProbability
      (fun z : (Fin N → Ω) × {a : Ω // A a} =>
        some (completedFirstAccept A N z.1 z.2) ≠ firstAccept A N z.1) =
      (1 - finiteUniformProbability A) ^ N := by
  have hpred : (fun z : (Fin N → Ω) × {a : Ω // A a} =>
      some (completedFirstAccept A N z.1 z.2) ≠ firstAccept A N z.1) =
      (fun z => firstAccept A N z.1 = none) := by
    funext z
    exact propext (completedFirstAccept_mismatch_iff A N z.1 z.2)
  rw [hpred]
  calc
    _ = finiteUniformProbability (fun f : Fin N → Ω => firstAccept A N f = none) :=
      finiteUniformProbability_fst (Ψ := {a : Ω // A a})
        (fun f : Fin N → Ω => firstAccept A N f = none)
    _ = _ := firstAccept_failure A N

end LowSpaceSubsetSum

end OAI