File size: 7,973 Bytes
e320e82
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
import OAI.Combinatorics.FiniteCircle.OffsetRecovery

namespace OAI

namespace FiniteCircle

open scoped BigOperators List
open scoped ComplexConjugate
open RCLike Module

theorem exists_disjoint_pair_subfamily {ι J : Type*} [DecidableEq ι] [DecidableEq J]
    (f g : ι → J) (hf : Function.Injective f) (hg : Function.Injective g)
    (I : Finset ι) (hne : ∀ i ∈ I, f i ≠ g i) :
    ∃ S ⊆ I, I.card ≤ 3*S.card ∧ ∀ i ∈ S, ∀ j ∈ S, f i ≠ g j := by
  induction I using Finset.strongInductionOn
  rename_i I ih
  by_cases he : I.Nonempty
  · obtain ⟨k, hk⟩ := he
    let N := I.filter (fun i => i = k ∨ f i = g k ∨ g i = f k)
    let T := I \ N
    have hkN : k ∈ N := Finset.mem_filter.mpr ⟨hk, Or.inl rfl⟩
    have hN : N ⊆ I := Finset.filter_subset _ _
    have hT : T ⊂ I := Finset.ssubset_iff_subset_ne.mpr ⟨Finset.sdiff_subset, by
      intro heq
      have hmem : k ∈ T := heq.symm ▸ hk
      exact (Finset.mem_sdiff.mp hmem).2 hkN⟩
    have hca : (I.filter (fun i => f i = g k)).card ≤ 1 := by
      apply Finset.card_le_one.mpr
      intro i hi j hj
      exact hf ((Finset.mem_filter.mp hi).2.trans (Finset.mem_filter.mp hj).2.symm)
    have hcb : (I.filter (fun i => g i = f k)).card ≤ 1 := by
      apply Finset.card_le_one.mpr
      intro i hi j hj
      exact hg ((Finset.mem_filter.mp hi).2.trans (Finset.mem_filter.mp hj).2.symm)
    have hsub : N ⊆ {k} ∪ I.filter (fun i => f i = g k) ∪ I.filter (fun i => g i = f k) := by
      intro i hi
      obtain ⟨hi, hn⟩ := Finset.mem_filter.mp hi
      rcases hn with rfl | ha | hb
      · simp
      · exact Finset.mem_union_left _ (Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨hi, ha⟩))
      · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨hi, hb⟩)
    have hNc : N.card ≤ 3 := by
      have h1 := Finset.card_le_card hsub
      have h2 := Finset.card_union_le ({k} ∪ I.filter (fun i => f i = g k)) (I.filter (fun i => g i = f k))
      have h3 := Finset.card_union_le ({k} : Finset ι) (I.filter (fun i => f i = g k))
      simp only [Finset.card_singleton] at h3
      omega
    obtain ⟨S, hST, hc, hcross⟩ := ih T hT (fun i hi => hne i (Finset.sdiff_subset hi))
    have hkS : k ∉ S := fun hks => (Finset.mem_sdiff.mp (hST hks)).2 hkN
    refine ⟨insert k S, Finset.insert_subset_iff.mpr ⟨hk, hST.trans Finset.sdiff_subset⟩, ?_, ?_⟩
    · rw [Finset.card_insert_of_notMem hkS]
      have hIc : T.card = I.card - N.card := Finset.card_sdiff_of_subset hN
      have hNi := Finset.card_le_card hN
      omega
    · intro i hi j hj
      rcases Finset.mem_insert.mp hi with hi | hi
      · subst i
        rcases Finset.mem_insert.mp hj with hj | hj
        · subst j
          exact hne k hk
        · intro hh
          have hjI := (Finset.mem_sdiff.mp (hST hj)).1
          have hjN := (Finset.mem_sdiff.mp (hST hj)).2
          exact hjN (Finset.mem_filter.mpr ⟨hjI, Or.inr (Or.inr hh.symm)⟩)
      · rcases Finset.mem_insert.mp hj with hj | hj
        · subst j
          intro hh
          have hiI := (Finset.mem_sdiff.mp (hST hi)).1
          have hiN := (Finset.mem_sdiff.mp (hST hi)).2
          exact hiN (Finset.mem_filter.mpr ⟨hiI, Or.inr (Or.inl hh)⟩)
        · exact hcross i hi j hj
  · refine ⟨∅, Finset.empty_subset _, ?_, by simp⟩
    simp [Finset.not_nonempty_iff_eq_empty.mp he]

theorem card_bit_equalities_le {ι J : Type*} [Fintype J] [DecidableEq J] [DecidableEq ι]
    (I : Finset ι) (f g : ι → J) (hg : Function.Injective g)
    (hcross : ∀ i ∈ I, ∀ j ∈ I, f i ≠ g j) :
    (Finset.univ.filter (fun ω : J → Bool => ∀ i ∈ I, ω (f i) = ω (g i))).card ≤
      2 ^ (Fintype.card J - I.card) := by
  classical
  let T := I.image g
  let π : (J → Bool) → (↥(Tᶜ : Finset J) → Bool) := fun ω j => ω j.val
  have hinj : Set.InjOn π (↑(Finset.univ.filter (fun ω : J → Bool => ∀ i ∈ I, ω (f i) = ω (g i))) : Set (J → Bool)) := by
    intro ω hω η hη he
    have hω := (Finset.mem_filter.mp hω).2
    have hη := (Finset.mem_filter.mp hη).2
    funext j
    by_cases hj : j ∈ T
    · obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp hj
      have hf : f i ∈ Tᶜ := by
        apply Finset.mem_compl.mpr
        intro hh
        obtain ⟨k, hk, heq⟩ := Finset.mem_image.mp hh
        exact hcross i hi k hk heq.symm
      have heq : ω (f i) = η (f i) := congrFun he ⟨f i, hf⟩
      exact (hω i hi).symm.trans (heq.trans (hη i hi))
    · exact congrFun he ⟨j, Finset.mem_compl.mpr hj⟩
  have hc := Finset.card_le_card_of_injOn π (fun _ _ => Finset.mem_univ _) hinj
  simpa only [Finset.card_univ, Fintype.card_fun, Fintype.card_bool, Fintype.card_coe,
    Finset.card_compl, Finset.card_image_of_injective I hg, T] using hc

theorem card_matching_equalities_le {ι J : Type*} [Fintype J] [DecidableEq J] [DecidableEq ι]
    (I : Finset ι) (f g : ι → J) (hf : Function.Injective f) (hg : Function.Injective g)
    (hne : ∀ i ∈ I, f i ≠ g i) (w : ℕ) (hw : w ≤ 16*I.card) :
    (Finset.univ.filter (fun ω : J → Bool => ∀ i ∈ I, ω (f i) = ω (g i))).card ≤
      2 ^ (Fintype.card J - w/64) := by
  classical
  obtain ⟨S, hSI, hcard, hcross⟩ := exists_disjoint_pair_subfamily f g hf hg I hne
  have hsub : (Finset.univ.filter (fun ω : J → Bool => ∀ i ∈ I, ω (f i) = ω (g i))) ⊆
      Finset.univ.filter (fun ω : J → Bool => ∀ i ∈ S, ω (f i) = ω (g i)) := by
    intro ω hω
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, fun i hi => (Finset.mem_filter.mp hω).2 i (hSI hi)⟩
  have hh : w/64 ≤ S.card := by omega
  exact (Finset.card_le_card hsub).trans ((card_bit_equalities_le S f g hg hcross).trans
    (Nat.pow_le_pow_right (by omega) (Nat.sub_le_sub_left hh _)))

theorem card_small_subsets_le (w : ℕ) :
    ((Finset.univ.filter (fun S : Finset (Fin w) => (S.card : ℝ) ≤ (w : ℝ)/1048576)).card : ℝ) ≤
      Real.exp ((w : ℝ)/512) := by
  classical
  let K := Finset.univ.filter (fun S : Finset (Fin w) => (S.card : ℝ) ≤ (w : ℝ)/1048576)
  let z : ℝ := 1/1024
  have hz : 0 < z := by norm_num [z]
  have hlog : -1024 ≤ Real.log z := by
    have h := Real.log_le_sub_one_of_pos (x := 1024) (by norm_num)
    simp only [z, one_div, Real.log_inv]
    linarith
  have hlow (S : Finset (Fin w)) (hS : S ∈ K) : Real.exp (-(w : ℝ)/1024) ≤ z^S.card := by
    have hs := (Finset.mem_filter.mp hS).2
    have hmul := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg S.card)
    have he : -(w : ℝ)/1024 ≤ (S.card : ℝ)*Real.log z := by nlinarith
    have h := Real.exp_le_exp.mpr he
    simpa only [Real.exp_nat_mul, Real.exp_log hz] using h
  have htotal : ∑ S : Finset (Fin w), z^S.card = (z+1)^w := by
    simpa using Finset.sum_pow_mul_eq_add_pow z (1 : ℝ) (Finset.univ : Finset (Fin w))
  have hsum : (K.card : ℝ) * Real.exp (-(w : ℝ)/1024) ≤ (z+1)^w := calc
    _ = ∑ _S ∈ K, Real.exp (-(w : ℝ)/1024) := by simp
    _ ≤ ∑ S ∈ K, z^S.card := Finset.sum_le_sum hlow
    _ ≤ ∑ S : Finset (Fin w), z^S.card := Finset.sum_le_sum_of_subset_of_nonneg
      (Finset.subset_univ _) (fun _ _ _ => pow_nonneg hz.le _)
    _ = _ := htotal
  have hupper : (z+1)^w ≤ Real.exp ((w : ℝ)/1024) := by
    have hl := Real.log_le_sub_one_of_pos (x := z+1) (by positivity)
    have hm := mul_le_mul_of_nonneg_left hl (Nat.cast_nonneg w)
    have hh : (w : ℝ)*Real.log (z+1) ≤ (w : ℝ)/1024 := by dsimp [z] at *; nlinarith
    have hh := Real.exp_le_exp.mpr hh
    simpa only [Real.exp_nat_mul, Real.exp_log (show 0 < z+1 by positivity)] using hh
  calc
    (K.card : ℝ) ≤ (z+1)^w / Real.exp (-(w : ℝ)/1024) := (le_div_iff₀ (Real.exp_pos _)).mpr hsum
    _ ≤ Real.exp ((w : ℝ)/1024) / Real.exp (-(w : ℝ)/1024) := div_le_div_of_nonneg_right hupper (Real.exp_pos _).le
    _ = Real.exp ((w : ℝ)/512) := by rw [← Real.exp_sub]; congr 1; ring

end FiniteCircle

end OAI