Datasets:

roseking
/

openAI-math-dataset

import OAI.LinearAlgebra.MatrixMultiplication.Recovery.InheritedMaskMargins
import OAI.LinearAlgebra.MatrixMultiplication.Tensor.CompleteWordPair
import Mathlib.Algebra.Group.Equiv.Basic

namespace OAI

/-! Finite orbit symmetries, masks and exact recovery operations. -/

namespace MatrixMultiplication.PermutationMatching

open scoped BigOperators
open MatrixMultiplication.InheritedMasks
open Classical

noncomputable section

variable {C : Type*} {P X Y : C → Type*}
variable [Fintype C] [DecidableEq C]
  [∀ c, Fintype (P c)] [∀ c, DecidableEq (P c)]
variable {S T : C → Type*}

def wordPairLeftPositions (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (s : ∀ c, S c) : ∀ c, Finset (P c) :=
  fun c => statisticPositions (w.left c) (sl c) (s c)

def wordPairRightPositions (w : CompleteWordPair P X Y)
    (sr : ∀ c, Y c → T c) (t : ∀ c, T c) : ∀ c, Finset (P c) :=
  fun c => statisticPositions (w.right c) (sr c) (t c)

def wordPairCount (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) : ℝ :=
  ∑ c, ∑ i : P c,
    if sl c (w.left c i) = s c ∧ sr c (w.right c i) = t c then 1 else 0

omit [DecidableEq C] in
theorem wordPairCount_smul (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (g : HalfClassPermutations P) :
    wordPairCount (g • w) sl sr s t =
      totalTwoHalfCount (wordPairLeftPositions w sl s)
        (wordPairRightPositions w sr t) g⁻¹ := by
  unfold wordPairCount totalTwoHalfCount wordPairLeftPositions wordPairRightPositions
  apply Finset.sum_congr rfl
  intro c _
  rw [twoHalfCount_statisticPositions]
  rfl

theorem average_wordPairCount_shift (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (f : ℝ → ℝ) :
    average (fun g : HalfClassPermutations P => f (wordPairCount (g • w) sl sr s t)) =
      average (fun g : HalfClassPermutations P =>
        f (totalTwoHalfCount (wordPairLeftPositions w sl s)
          (wordPairRightPositions w sr t) g)) := by
  simp_rw [wordPairCount_smul]
  exact average_equiv (Equiv.inv (HalfClassPermutations P))
    (fun g => f (totalTwoHalfCount (wordPairLeftPositions w sl s)
      (wordPairRightPositions w sr t) g))

def wordPairMaskBad (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ)
    (w : CompleteWordPair P X Y) : Prop :=
  η < |wordPairCount w sl sr s t / populationSize P - ν|

theorem wordPair_orbit_fraction_eq (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (wordPairMaskBad sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card =
        average (fun g : HalfClassPermutations P =>
          if η < |totalTwoHalfCount (wordPairLeftPositions w sl s)
              (wordPairRightPositions w sr t) g / populationSize P - ν|
            then 1 else 0) := by
  rw [← average_bad_shift_eq_orbit_fraction]
  exact average_wordPairCount_shift w sl sr s t
    (fun k => if η < |k / populationSize P - ν| then 1 else 0)

theorem wordPair_orbit_rejection_le (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c)
    (hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P)
    (η ν : ℝ) (hη : 0 < η)
    (hmargin : |totalMatchingMean (wordPairLeftPositions w sl s)
        (wordPairRightPositions w sr t) / populationSize P - ν| ≤ η / 2) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (wordPairMaskBad sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        1 / (2 * populationSize P * η ^ 2) := by
  rw [wordPair_orbit_fraction_eq]
  exact twoHalf_inheritedMask_rejection_le _ _ hn hm η ν hη hmargin

theorem wordPair_orbit_rejection_of_windows_le [∀ c, Nonempty (P c)]
    (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c)
    (hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P)
    (left right : C → ℝ) (η τ α ν : ℝ) (hη : 0 < η)
    (hright0 : ∀ c, 0 ≤ right c) (hright1 : ∀ c, right c ≤ 1)
    (hleft : ∀ c, |classDensity (wordPairLeftPositions w sl s) c - left c| ≤ τ)
    (hright : ∀ c, |classDensity (wordPairRightPositions w sr t) c - right c| ≤ τ)
    (happrox : |classProductMixture P left right - ν| ≤ α)
    (hτ : τ ≤ η / 8) (hα : α ≤ η / 4) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (wordPairMaskBad sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        1 / (2 * populationSize P * η ^ 2) := by
  exact wordPair_orbit_rejection_le w sl sr s t hn hm η ν hη
    (totalMatchingMean_inherited_margin _ _ hm left right η τ α ν
      hright0 hright1 hleft hright happrox hτ hα)

def selectedWordPairCount (D : Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) : ℝ :=
  ∑ c : D, ∑ i : P c,
    if sl c (w.left c i) = s c ∧ sr c (w.right c i) = t c then 1 else 0

omit [Fintype C] [DecidableEq C] in
theorem selectedWordPairCount_smul (D : Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (g : HalfClassPermutations P) :
    selectedWordPairCount D (g • w) sl sr s t =
      selectedTwoHalfCount D (wordPairLeftPositions w sl s)
        (wordPairRightPositions w sr t) g⁻¹ := by
  unfold selectedWordPairCount selectedTwoHalfCount totalTwoHalfCount
    wordPairLeftPositions wordPairRightPositions
  apply Finset.sum_congr rfl
  intro c _
  rw [twoHalfCount_statisticPositions]
  rfl

theorem average_selectedWordPairCount_shift (D : Finset C)
    (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (f : ℝ → ℝ) :
    average (fun g : HalfClassPermutations P =>
      f (selectedWordPairCount D (g • w) sl sr s t)) =
      average (fun g : HalfClassPermutations P =>
        f (selectedTwoHalfCount D (wordPairLeftPositions w sl s)
          (wordPairRightPositions w sr t) g)) := by
  simp_rw [selectedWordPairCount_smul]
  exact average_equiv (Equiv.inv (HalfClassPermutations P))
    (fun g => f (selectedTwoHalfCount D (wordPairLeftPositions w sl s)
      (wordPairRightPositions w sr t) g))

def selectedWordPairMaskBad (D : Finset C)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ)
    (w : CompleteWordPair P X Y) : Prop :=
  η < |selectedWordPairCount D w sl sr s t /
    populationSize (fun c : D => P c) - ν|

theorem selectedWordPair_orbit_fraction_eq (D : Finset C)
    (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card =
        average (fun g : HalfClassPermutations P =>
          if η < |selectedTwoHalfCount D (wordPairLeftPositions w sl s)
              (wordPairRightPositions w sr t) g /
                populationSize (fun c : D => P c) - ν| then 1 else 0) := by
  rw [← average_bad_shift_eq_orbit_fraction]
  exact average_selectedWordPairCount_shift D w sl sr s t
    (fun k => if η < |k / populationSize (fun c : D => P c) - ν| then 1 else 0)

theorem selectedWordPair_orbit_rejection_le (D : Finset C)
    (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c)
    (hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
    (hm : 0 < populationSize (fun c : D => P c)) (η ν : ℝ) (hη : 0 < η)
    (hmargin : |totalMatchingMean
        (fun c : D => wordPairLeftPositions w sl s c)
        (fun c : D => wordPairRightPositions w sr t c) /
          populationSize (fun c : D => P c) - ν| ≤ η / 2) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
  rw [selectedWordPair_orbit_fraction_eq]
  exact selectedTwoHalfMask_rejection_le D _ _ hn hm η ν hη hmargin

theorem selectedWordPair_orbit_rejection_of_windows_le (D : Finset C)
    (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c)
    (hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
    (hm : 0 < populationSize (fun c : D => P c))
    (left right : C → ℝ) (η τ α ν : ℝ) (hη : 0 < η)
    (hright0 : ∀ c ∈ D, 0 ≤ right c) (hright1 : ∀ c ∈ D, right c ≤ 1)
    (hleft : ∀ c ∈ D, |classDensity (wordPairLeftPositions w sl s) c - left c| ≤ τ)
    (hright : ∀ c ∈ D, |classDensity (wordPairRightPositions w sr t) c - right c| ≤ τ)
    (happrox : |classProductMixture (fun c : D => P c)
      (fun c => left c) (fun c => right c) - ν| ≤ α)
    (hτ : τ ≤ η / 8) (hα : α ≤ η / 4) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
  rw [selectedWordPair_orbit_fraction_eq]
  exact selectedTwoHalfMask_rejection_of_windows_le D _ _ hn hm left right
    η τ α ν hη hright0 hright1 hleft hright happrox hτ hα

theorem selectedWordPair_orbit_rejection_of_completeWindows_le
    [∀ c, Fintype (X c)] [∀ c, DecidableEq (X c)]
    [∀ c, Fintype (Y c)] [∀ c, DecidableEq (Y c)]
    [∀ c, Fintype (S c)] [∀ c, DecidableEq (S c)]
    [∀ c, Fintype (T c)] [∀ c, DecidableEq (T c)]
    (D : Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
    (s : ∀ c, S c) (t : ∀ c, T c)
    (hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
    (hm : 0 < populationSize (fun c : D => P c))
    (leftLaw : ∀ c, X c → ℝ) (rightLaw : ∀ c, Y c → ℝ)
    (leftε rightε : C → ℝ) (η α ν : ℝ) (hη : 0 < η)
    (hright0 : ∀ c ∈ D, ∀ y, 0 ≤ rightLaw c y)
    (hrightSum : ∀ c ∈ D, ∑ y, rightLaw c y = 1)
    (hleftε : ∀ c ∈ D, 0 ≤ leftε c) (hrightε : ∀ c ∈ D, 0 ≤ rightε c)
    (hleft : ∀ c ∈ D, typeWindow (leftLaw c) (leftε c) (w.left c))
    (hright : ∀ c ∈ D, typeWindow (rightLaw c) (rightε c) (w.right c))
    (hleftFactor : ∀ c ∈ D, (Fintype.card (X c) : ℝ) * leftε c ≤ η / 8)
    (hrightFactor : ∀ c ∈ D, (Fintype.card (Y c) : ℝ) * rightε c ≤ η / 8)
    (happrox : |classProductMixture (fun c : D => P c)
      (fun c => pushforwardLaw (sl c) (leftLaw c) (s c))
      (fun c => pushforwardLaw (sr c) (rightLaw c) (t c)) - ν| ≤ α)
    (hα : α ≤ η / 4) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
  rw [selectedWordPair_orbit_fraction_eq]
  exact selectedTwoHalf_statistic_rejection_of_completeWindows_le D w.left w.right
    sl sr s t hn hm leftLaw rightLaw leftε rightε η α ν hη hright0 hrightSum
    hleftε hrightε hleft hright hleftFactor hrightFactor happrox hα

section FiniteMasks

variable {I : Type*} [Fintype I] {SL SR : I → C → Type*}

theorem finite_selectedWordPair_sum_orbit_fraction_le
    (D : I → Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
    (s : ∀ i c, SL i c) (t : ∀ i c, SR i c) (η : ℝ) (ν : I → ℝ)
    (hη : 0 ≤ η) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (fun v => η < |(∑ i, selectedWordPairCount (D i) v
          (sl i) (sr i) (s i) (t i) / populationSize (fun c : D i => P c)) -
            ∑ i, ν i|)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
          (s i) (t i) (η / Fintype.card I) (ν i) v)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card := by
  by_cases hI : Fintype.card I = 0
  · have : IsEmpty I := Fintype.card_eq_zero_iff.mp hI
    simp [not_lt_of_ge hη]
  have : Nonempty I := Fintype.card_pos_iff.mp (Nat.pos_of_ne_zero hI)
  have hcard : (0 : ℝ) < Fintype.card I := by
    exact_mod_cast (Fintype.card_pos (α := I))
  let z (v : CompleteWordPair P X Y) (i : I) : ℝ :=
    selectedWordPairCount (D i) v (sl i) (sr i) (s i) (t i) /
      populationSize (fun c : D i => P c)
  let R := OrbitCounting.orbitSet (G := HalfClassPermutations P) w
  let sumBad (v : CompleteWordPair P X Y) : Prop :=
    η < |(∑ i, z v i) - ∑ i, ν i|
  let unionBad (v : CompleteWordPair P X Y) : Prop :=
    ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
      (s i) (t i) (η / Fintype.card I) (ν i) v
  have hEvent (v) (hv : sumBad v) : unionBad v := by
    change ∃ i, η / Fintype.card I < |z v i - ν i|
    change η < |(∑ i, z v i) - ∑ i, ν i| at hv
    by_contra h
    push Not at h
    have he : |(∑ i, z v i) - ∑ i, ν i| ≤ η := by
      rw [← Finset.sum_sub_distrib]
      calc
        _ ≤ ∑ i, |z v i - ν i| := Finset.abs_sum_le_sum_abs _ _
        _ ≤ ∑ _i : I, η / Fintype.card I := Finset.sum_le_sum fun i _ => h i
        _ = η := by
          simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
          field_simp [ne_of_gt hcard]
    linarith
  have hsub : R.filter sumBad ⊆ R.filter unionBad :=
    Finset.monotone_filter_right R (fun v _ => hEvent v)
  have hcards : ((R.filter sumBad).card : ℝ) ≤ (R.filter unionBad).card := by
    exact_mod_cast Finset.card_le_card hsub
  exact div_le_div_of_nonneg_right hcards (Nat.cast_nonneg R.card)

theorem finite_selectedWordPair_orbit_rejection_of_windows_le
    (D : I → Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
    (s : ∀ i c, SL i c) (t : ∀ i c, SR i c)
    (hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c))
    (hm : ∀ i, 0 < populationSize (fun c : D i => P c))
    (left right : I → C → ℝ) (η τ α ν : I → ℝ) (hη : ∀ i, 0 < η i)
    (hright0 : ∀ i c, c ∈ D i → 0 ≤ right i c)
    (hright1 : ∀ i c, c ∈ D i → right i c ≤ 1)
    (hleft : ∀ i c, c ∈ D i →
      |classDensity (wordPairLeftPositions w (sl i) (s i)) c - left i c| ≤ τ i)
    (hright : ∀ i c, c ∈ D i →
      |classDensity (wordPairRightPositions w (sr i) (t i)) c - right i c| ≤ τ i)
    (happrox : ∀ i, |classProductMixture (fun c : D i => P c)
      (fun c => left i c) (fun c => right i c) - ν i| ≤ α i)
    (hτ : ∀ i, τ i ≤ η i / 8) (hα : ∀ i, α i ≤ η i / 4) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
          (s i) (t i) (η i) (ν i) v)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        ∑ i, 1 / (2 * populationSize (fun c : D i => P c) * (η i) ^ 2) := by
  rw [← average_bad_shift_eq_orbit_fraction]
  refine le_trans (average_indicator_exists_le_sum _) ?_
  apply Finset.sum_le_sum
  intro i _
  change average (fun g : HalfClassPermutations P =>
    if η i < |selectedWordPairCount (D i) (g • w) (sl i) (sr i) (s i) (t i) /
      populationSize (fun c : D i => P c) - ν i| then 1 else 0) ≤ _
  rw [average_selectedWordPairCount_shift (D i) w (sl i) (sr i) (s i) (t i)
    (fun k => if η i < |k / populationSize (fun c : D i => P c) - ν i|
      then 1 else 0)]
  exact selectedTwoHalfMask_rejection_of_windows_le (D i) _ _ (hn i) (hm i)
    (left i) (right i) (η i) (τ i) (α i) (ν i) (hη i)
    (hright0 i) (hright1 i) (hleft i) (hright i) (happrox i) (hτ i) (hα i)

theorem finite_selectedWordPair_orbit_inverse_linear_of_windows
    (D : I → Finset C) (w : CompleteWordPair P X Y)
    (sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
    (s : ∀ i c, SL i c) (t : ∀ i c, SR i c)
    (hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c))
    (mass : I → ℝ) (N : ℝ) (hN : 0 < N) (hmass : ∀ i, 0 < mass i)
    (hsize : ∀ i, populationSize (fun c : D i => P c) = mass i * N)
    (left right : I → C → ℝ) (η τ α ν : I → ℝ) (hη : ∀ i, 0 < η i)
    (hright0 : ∀ i c, c ∈ D i → 0 ≤ right i c)
    (hright1 : ∀ i c, c ∈ D i → right i c ≤ 1)
    (hleft : ∀ i c, c ∈ D i →
      |classDensity (wordPairLeftPositions w (sl i) (s i)) c - left i c| ≤ τ i)
    (hright : ∀ i c, c ∈ D i →
      |classDensity (wordPairRightPositions w (sr i) (t i)) c - right i c| ≤ τ i)
    (happrox : ∀ i, |classProductMixture (fun c : D i => P c)
      (fun c => left i c) (fun c => right i c) - ν i| ≤ α i)
    (hτ : ∀ i, τ i ≤ η i / 8) (hα : ∀ i, α i ≤ η i / 4) :
    (((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
        (fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
          (s i) (t i) (η i) (ν i) v)).card : ℝ) /
      (OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
        (∑ i, 1 / (2 * mass i * (η i) ^ 2)) / N := by
  have hm (i : I) : 0 < populationSize (fun c : D i => P c) := by
    rw [hsize]
    exact mul_pos (hmass i) hN
  have h := finite_selectedWordPair_orbit_rejection_of_windows_le D w sl sr s t hn hm
    left right η τ α ν hη hright0 hright1 hleft hright happrox hτ hα
  simpa only [hsize, inverse_linear_mask_constant] using h

end FiniteMasks

end

end MatrixMultiplication.PermutationMatching

end OAI

	import OAI.LinearAlgebra.MatrixMultiplication.Recovery.InheritedMaskMargins
	import OAI.LinearAlgebra.MatrixMultiplication.Tensor.CompleteWordPair
	import Mathlib.Algebra.Group.Equiv.Basic

	namespace OAI

	/-! Finite orbit symmetries, masks and exact recovery operations. -/

	namespace MatrixMultiplication.PermutationMatching

	open scoped BigOperators
	open MatrixMultiplication.InheritedMasks
	open Classical

	noncomputable section

	variable {C : Type} {P X Y : C → Type}
	variable [Fintype C] [DecidableEq C]
	[∀ c, Fintype (P c)] [∀ c, DecidableEq (P c)]
	variable {S T : C → Type*}

	def wordPairLeftPositions (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (s : ∀ c, S c) : ∀ c, Finset (P c) :=
	fun c => statisticPositions (w.left c) (sl c) (s c)

	def wordPairRightPositions (w : CompleteWordPair P X Y)
	(sr : ∀ c, Y c → T c) (t : ∀ c, T c) : ∀ c, Finset (P c) :=
	fun c => statisticPositions (w.right c) (sr c) (t c)

	def wordPairCount (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) : ℝ :=
	∑ c, ∑ i : P c,
	if sl c (w.left c i) = s c ∧ sr c (w.right c i) = t c then 1 else 0

	omit [DecidableEq C] in
	theorem wordPairCount_smul (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (g : HalfClassPermutations P) :
	wordPairCount (g • w) sl sr s t =
	totalTwoHalfCount (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g⁻¹ := by
	unfold wordPairCount totalTwoHalfCount wordPairLeftPositions wordPairRightPositions
	apply Finset.sum_congr rfl
	intro c _
	rw [twoHalfCount_statisticPositions]
	rfl

	theorem average_wordPairCount_shift (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (f : ℝ → ℝ) :
	average (fun g : HalfClassPermutations P => f (wordPairCount (g • w) sl sr s t)) =
	average (fun g : HalfClassPermutations P =>
	f (totalTwoHalfCount (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g)) := by
	simp_rw [wordPairCount_smul]
	exact average_equiv (Equiv.inv (HalfClassPermutations P))
	(fun g => f (totalTwoHalfCount (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g))

	def wordPairMaskBad (sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ)
	(w : CompleteWordPair P X Y) : Prop :=
	η < \|wordPairCount w sl sr s t / populationSize P - ν\|

	theorem wordPair_orbit_fraction_eq (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(wordPairMaskBad sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card =
	average (fun g : HalfClassPermutations P =>
	if η < \|totalTwoHalfCount (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g / populationSize P - ν\|
	then 1 else 0) := by
	rw [← average_bad_shift_eq_orbit_fraction]
	exact average_wordPairCount_shift w sl sr s t
	(fun k => if η < \|k / populationSize P - ν\| then 1 else 0)

	theorem wordPair_orbit_rejection_le (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c)
	(hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P)
	(η ν : ℝ) (hη : 0 < η)
	(hmargin : \|totalMatchingMean (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) / populationSize P - ν\| ≤ η / 2) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(wordPairMaskBad sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	1 / (2 * populationSize P * η ^ 2) := by
	rw [wordPair_orbit_fraction_eq]
	exact twoHalf_inheritedMask_rejection_le _ _ hn hm η ν hη hmargin

	theorem wordPair_orbit_rejection_of_windows_le [∀ c, Nonempty (P c)]
	(w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c)
	(hn : ∀ c, 2 ≤ Fintype.card (P c)) (hm : 0 < populationSize P)
	(left right : C → ℝ) (η τ α ν : ℝ) (hη : 0 < η)
	(hright0 : ∀ c, 0 ≤ right c) (hright1 : ∀ c, right c ≤ 1)
	(hleft : ∀ c, \|classDensity (wordPairLeftPositions w sl s) c - left c\| ≤ τ)
	(hright : ∀ c, \|classDensity (wordPairRightPositions w sr t) c - right c\| ≤ τ)
	(happrox : \|classProductMixture P left right - ν\| ≤ α)
	(hτ : τ ≤ η / 8) (hα : α ≤ η / 4) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(wordPairMaskBad sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	1 / (2 * populationSize P * η ^ 2) := by
	exact wordPair_orbit_rejection_le w sl sr s t hn hm η ν hη
	(totalMatchingMean_inherited_margin _ _ hm left right η τ α ν
	hright0 hright1 hleft hright happrox hτ hα)

	def selectedWordPairCount (D : Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) : ℝ :=
	∑ c : D, ∑ i : P c,
	if sl c (w.left c i) = s c ∧ sr c (w.right c i) = t c then 1 else 0

	omit [Fintype C] [DecidableEq C] in
	theorem selectedWordPairCount_smul (D : Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (g : HalfClassPermutations P) :
	selectedWordPairCount D (g • w) sl sr s t =
	selectedTwoHalfCount D (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g⁻¹ := by
	unfold selectedWordPairCount selectedTwoHalfCount totalTwoHalfCount
	wordPairLeftPositions wordPairRightPositions
	apply Finset.sum_congr rfl
	intro c _
	rw [twoHalfCount_statisticPositions]
	rfl

	theorem average_selectedWordPairCount_shift (D : Finset C)
	(w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (f : ℝ → ℝ) :
	average (fun g : HalfClassPermutations P =>
	f (selectedWordPairCount D (g • w) sl sr s t)) =
	average (fun g : HalfClassPermutations P =>
	f (selectedTwoHalfCount D (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g)) := by
	simp_rw [selectedWordPairCount_smul]
	exact average_equiv (Equiv.inv (HalfClassPermutations P))
	(fun g => f (selectedTwoHalfCount D (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g))

	def selectedWordPairMaskBad (D : Finset C)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ)
	(w : CompleteWordPair P X Y) : Prop :=
	η < \|selectedWordPairCount D w sl sr s t /
	populationSize (fun c : D => P c) - ν\|

	theorem selectedWordPair_orbit_fraction_eq (D : Finset C)
	(w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c) (η ν : ℝ) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card =
	average (fun g : HalfClassPermutations P =>
	if η < \|selectedTwoHalfCount D (wordPairLeftPositions w sl s)
	(wordPairRightPositions w sr t) g /
	populationSize (fun c : D => P c) - ν\| then 1 else 0) := by
	rw [← average_bad_shift_eq_orbit_fraction]
	exact average_selectedWordPairCount_shift D w sl sr s t
	(fun k => if η < \|k / populationSize (fun c : D => P c) - ν\| then 1 else 0)

	theorem selectedWordPair_orbit_rejection_le (D : Finset C)
	(w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c)
	(hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
	(hm : 0 < populationSize (fun c : D => P c)) (η ν : ℝ) (hη : 0 < η)
	(hmargin : \|totalMatchingMean
	(fun c : D => wordPairLeftPositions w sl s c)
	(fun c : D => wordPairRightPositions w sr t c) /
	populationSize (fun c : D => P c) - ν\| ≤ η / 2) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
	rw [selectedWordPair_orbit_fraction_eq]
	exact selectedTwoHalfMask_rejection_le D _ _ hn hm η ν hη hmargin

	theorem selectedWordPair_orbit_rejection_of_windows_le (D : Finset C)
	(w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c)
	(hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
	(hm : 0 < populationSize (fun c : D => P c))
	(left right : C → ℝ) (η τ α ν : ℝ) (hη : 0 < η)
	(hright0 : ∀ c ∈ D, 0 ≤ right c) (hright1 : ∀ c ∈ D, right c ≤ 1)
	(hleft : ∀ c ∈ D, \|classDensity (wordPairLeftPositions w sl s) c - left c\| ≤ τ)
	(hright : ∀ c ∈ D, \|classDensity (wordPairRightPositions w sr t) c - right c\| ≤ τ)
	(happrox : \|classProductMixture (fun c : D => P c)
	(fun c => left c) (fun c => right c) - ν\| ≤ α)
	(hτ : τ ≤ η / 8) (hα : α ≤ η / 4) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
	rw [selectedWordPair_orbit_fraction_eq]
	exact selectedTwoHalfMask_rejection_of_windows_le D _ _ hn hm left right
	η τ α ν hη hright0 hright1 hleft hright happrox hτ hα

	theorem selectedWordPair_orbit_rejection_of_completeWindows_le
	[∀ c, Fintype (X c)] [∀ c, DecidableEq (X c)]
	[∀ c, Fintype (Y c)] [∀ c, DecidableEq (Y c)]
	[∀ c, Fintype (S c)] [∀ c, DecidableEq (S c)]
	[∀ c, Fintype (T c)] [∀ c, DecidableEq (T c)]
	(D : Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ c, X c → S c) (sr : ∀ c, Y c → T c)
	(s : ∀ c, S c) (t : ∀ c, T c)
	(hn : ∀ c ∈ D, 2 ≤ Fintype.card (P c))
	(hm : 0 < populationSize (fun c : D => P c))
	(leftLaw : ∀ c, X c → ℝ) (rightLaw : ∀ c, Y c → ℝ)
	(leftε rightε : C → ℝ) (η α ν : ℝ) (hη : 0 < η)
	(hright0 : ∀ c ∈ D, ∀ y, 0 ≤ rightLaw c y)
	(hrightSum : ∀ c ∈ D, ∑ y, rightLaw c y = 1)
	(hleftε : ∀ c ∈ D, 0 ≤ leftε c) (hrightε : ∀ c ∈ D, 0 ≤ rightε c)
	(hleft : ∀ c ∈ D, typeWindow (leftLaw c) (leftε c) (w.left c))
	(hright : ∀ c ∈ D, typeWindow (rightLaw c) (rightε c) (w.right c))
	(hleftFactor : ∀ c ∈ D, (Fintype.card (X c) : ℝ) * leftε c ≤ η / 8)
	(hrightFactor : ∀ c ∈ D, (Fintype.card (Y c) : ℝ) * rightε c ≤ η / 8)
	(happrox : \|classProductMixture (fun c : D => P c)
	(fun c => pushforwardLaw (sl c) (leftLaw c) (s c))
	(fun c => pushforwardLaw (sr c) (rightLaw c) (t c)) - ν\| ≤ α)
	(hα : α ≤ η / 4) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(selectedWordPairMaskBad D sl sr s t η ν)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	1 / (2 * populationSize (fun c : D => P c) * η ^ 2) := by
	rw [selectedWordPair_orbit_fraction_eq]
	exact selectedTwoHalf_statistic_rejection_of_completeWindows_le D w.left w.right
	sl sr s t hn hm leftLaw rightLaw leftε rightε η α ν hη hright0 hrightSum
	hleftε hrightε hleft hright hleftFactor hrightFactor happrox hα

	section FiniteMasks

	variable {I : Type} [Fintype I] {SL SR : I → C → Type}

	theorem finite_selectedWordPair_sum_orbit_fraction_le
	(D : I → Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
	(s : ∀ i c, SL i c) (t : ∀ i c, SR i c) (η : ℝ) (ν : I → ℝ)
	(hη : 0 ≤ η) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(fun v => η < \|(∑ i, selectedWordPairCount (D i) v
	(sl i) (sr i) (s i) (t i) / populationSize (fun c : D i => P c)) -
	∑ i, ν i\|)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
	(s i) (t i) (η / Fintype.card I) (ν i) v)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card := by
	by_cases hI : Fintype.card I = 0
	· have : IsEmpty I := Fintype.card_eq_zero_iff.mp hI
	simp [not_lt_of_ge hη]
	have : Nonempty I := Fintype.card_pos_iff.mp (Nat.pos_of_ne_zero hI)
	have hcard : (0 : ℝ) < Fintype.card I := by
	exact_mod_cast (Fintype.card_pos (α := I))
	let z (v : CompleteWordPair P X Y) (i : I) : ℝ :=
	selectedWordPairCount (D i) v (sl i) (sr i) (s i) (t i) /
	populationSize (fun c : D i => P c)
	let R := OrbitCounting.orbitSet (G := HalfClassPermutations P) w
	let sumBad (v : CompleteWordPair P X Y) : Prop :=
	η < \|(∑ i, z v i) - ∑ i, ν i\|
	let unionBad (v : CompleteWordPair P X Y) : Prop :=
	∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
	(s i) (t i) (η / Fintype.card I) (ν i) v
	have hEvent (v) (hv : sumBad v) : unionBad v := by
	change ∃ i, η / Fintype.card I < \|z v i - ν i\|
	change η < \|(∑ i, z v i) - ∑ i, ν i\| at hv
	by_contra h
	push Not at h
	have he : \|(∑ i, z v i) - ∑ i, ν i\| ≤ η := by
	rw [← Finset.sum_sub_distrib]
	calc
	_ ≤ ∑ i, \|z v i - ν i\| := Finset.abs_sum_le_sum_abs _ _
	_ ≤ ∑ _i : I, η / Fintype.card I := Finset.sum_le_sum fun i _ => h i
	_ = η := by
	simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
	field_simp [ne_of_gt hcard]
	linarith
	have hsub : R.filter sumBad ⊆ R.filter unionBad :=
	Finset.monotone_filter_right R (fun v _ => hEvent v)
	have hcards : ((R.filter sumBad).card : ℝ) ≤ (R.filter unionBad).card := by
	exact_mod_cast Finset.card_le_card hsub
	exact div_le_div_of_nonneg_right hcards (Nat.cast_nonneg R.card)

	theorem finite_selectedWordPair_orbit_rejection_of_windows_le
	(D : I → Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
	(s : ∀ i c, SL i c) (t : ∀ i c, SR i c)
	(hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c))
	(hm : ∀ i, 0 < populationSize (fun c : D i => P c))
	(left right : I → C → ℝ) (η τ α ν : I → ℝ) (hη : ∀ i, 0 < η i)
	(hright0 : ∀ i c, c ∈ D i → 0 ≤ right i c)
	(hright1 : ∀ i c, c ∈ D i → right i c ≤ 1)
	(hleft : ∀ i c, c ∈ D i →
	\|classDensity (wordPairLeftPositions w (sl i) (s i)) c - left i c\| ≤ τ i)
	(hright : ∀ i c, c ∈ D i →
	\|classDensity (wordPairRightPositions w (sr i) (t i)) c - right i c\| ≤ τ i)
	(happrox : ∀ i, \|classProductMixture (fun c : D i => P c)
	(fun c => left i c) (fun c => right i c) - ν i\| ≤ α i)
	(hτ : ∀ i, τ i ≤ η i / 8) (hα : ∀ i, α i ≤ η i / 4) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
	(s i) (t i) (η i) (ν i) v)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	∑ i, 1 / (2 * populationSize (fun c : D i => P c) * (η i) ^ 2) := by
	rw [← average_bad_shift_eq_orbit_fraction]
	refine le_trans (average_indicator_exists_le_sum _) ?_
	apply Finset.sum_le_sum
	intro i _
	change average (fun g : HalfClassPermutations P =>
	if η i < \|selectedWordPairCount (D i) (g • w) (sl i) (sr i) (s i) (t i) /
	populationSize (fun c : D i => P c) - ν i\| then 1 else 0) ≤ _
	rw [average_selectedWordPairCount_shift (D i) w (sl i) (sr i) (s i) (t i)
	(fun k => if η i < \|k / populationSize (fun c : D i => P c) - ν i\|
	then 1 else 0)]
	exact selectedTwoHalfMask_rejection_of_windows_le (D i) _ _ (hn i) (hm i)
	(left i) (right i) (η i) (τ i) (α i) (ν i) (hη i)
	(hright0 i) (hright1 i) (hleft i) (hright i) (happrox i) (hτ i) (hα i)

	theorem finite_selectedWordPair_orbit_inverse_linear_of_windows
	(D : I → Finset C) (w : CompleteWordPair P X Y)
	(sl : ∀ i c, X c → SL i c) (sr : ∀ i c, Y c → SR i c)
	(s : ∀ i c, SL i c) (t : ∀ i c, SR i c)
	(hn : ∀ i c, c ∈ D i → 2 ≤ Fintype.card (P c))
	(mass : I → ℝ) (N : ℝ) (hN : 0 < N) (hmass : ∀ i, 0 < mass i)
	(hsize : ∀ i, populationSize (fun c : D i => P c) = mass i * N)
	(left right : I → C → ℝ) (η τ α ν : I → ℝ) (hη : ∀ i, 0 < η i)
	(hright0 : ∀ i c, c ∈ D i → 0 ≤ right i c)
	(hright1 : ∀ i c, c ∈ D i → right i c ≤ 1)
	(hleft : ∀ i c, c ∈ D i →
	\|classDensity (wordPairLeftPositions w (sl i) (s i)) c - left i c\| ≤ τ i)
	(hright : ∀ i c, c ∈ D i →
	\|classDensity (wordPairRightPositions w (sr i) (t i)) c - right i c\| ≤ τ i)
	(happrox : ∀ i, \|classProductMixture (fun c : D i => P c)
	(fun c => left i c) (fun c => right i c) - ν i\| ≤ α i)
	(hτ : ∀ i, τ i ≤ η i / 8) (hα : ∀ i, α i ≤ η i / 4) :
	(((OrbitCounting.orbitSet (G := HalfClassPermutations P) w).filter
	(fun v => ∃ i, selectedWordPairMaskBad (D i) (sl i) (sr i)
	(s i) (t i) (η i) (ν i) v)).card : ℝ) /
	(OrbitCounting.orbitSet (G := HalfClassPermutations P) w).card ≤
	(∑ i, 1 / (2 * mass i * (η i) ^ 2)) / N := by
	have hm (i : I) : 0 < populationSize (fun c : D i => P c) := by
	rw [hsize]
	exact mul_pos (hmass i) hN
	have h := finite_selectedWordPair_orbit_rejection_of_windows_le D w sl sr s t hn hm
	left right η τ α ν hη hright0 hright1 hleft hright happrox hτ hα
	simpa only [hsize, inverse_linear_mask_constant] using h

	end FiniteMasks

	end

	end MatrixMultiplication.PermutationMatching

	end OAI