| import Mathlib.Data.Finset.Card |
| import Mathlib.Data.Fintype.BigOperators |
| import Mathlib.Algebra.Order.BigOperators.Group.Finset |
| import Mathlib.Data.Fintype.Card |
|
|
| namespace OAI |
|
|
| /-! Finite type counts, hierarchy separation and tensor execution bounds. -/ |
|
|
| open scoped BigOperators |
|
|
| namespace MatrixMultiplication.FiniteCover |
|
|
| variable {Ω M G : Type*} |
|
|
| theorem exists_avoiding [Fintype Ω] [DecidableEq Ω] [DecidableEq M] |
| (s : Finset M) (bad : M → Finset Ω) (t : ℕ) |
| (hbad : ∀ m ∈ s, (bad m).card ≤ t) |
| (hbudget : s.card * t < Fintype.card Ω) : |
| ∃ ω : Ω, ∀ m ∈ s, ω ∉ bad m := by |
| classical |
| have hcard : (s.biUnion bad).card ≤ s.card * t := by |
| calc |
| (s.biUnion bad).card ≤ ∑ m ∈ s, (bad m).card := Finset.card_biUnion_le |
| _ ≤ ∑ _m ∈ s, t := Finset.sum_le_sum fun m hm => hbad m hm |
| _ = s.card * t := by simp |
| by_contra hn |
| have hsub : (Finset.univ : Finset Ω) ⊆ s.biUnion bad := by |
| intro ω hω |
| by_contra hout |
| apply hn |
| refine ⟨ω, ?_⟩ |
| intro m hm hmem |
| exact hout (Finset.mem_biUnion.mpr ⟨m, hm, hmem⟩) |
| have := Finset.card_le_card hsub |
| simp only [Finset.card_univ] at this |
| exact (not_lt_of_ge (this.trans hcard)) hbudget |
|
|
| def avoidingWords [Fintype G] [DecidableEq G] (bad : Finset G) (L : ℕ) : |
| Finset (Fin L → G) := Finset.univ.filter fun f => ∀ i, f i ∈ bad |
|
|
| theorem card_avoidingWords [Fintype G] [DecidableEq G] (bad : Finset G) (L : ℕ) : |
| (avoidingWords bad L).card = bad.card ^ L := by |
| classical |
| let e : {f : Fin L → G |
| { toFun := fun f i => ⟨f.1 i, (Finset.mem_filter.mp f.2).2 i⟩ |
| invFun := fun f => ⟨fun i => (f i).1, by simp [avoidingWords]⟩ |
| left_inv := by intro f; rfl |
| right_inv := by intro f; rfl } |
| calc |
| (avoidingWords bad L).card = Fintype.card {f : Fin L → G |
| _ = Fintype.card (Fin L → {g |
| _ = bad.card ^ L := by simp |
|
|
| theorem exists_cover [Fintype G] [DecidableEq G] [DecidableEq M] |
| (s : Finset M) (good : G → M → Prop) [∀ g, DecidablePred (good g)] |
| (t L : ℕ) |
| (hbad : ∀ m ∈ s, (Finset.univ.filter fun g => ¬good g m).card ≤ t) |
| (hbudget : s.card * t ^ L < Fintype.card G ^ L) : |
| ∃ f : Fin L → G, ∀ m ∈ s, ∃ i, good (f i) m := by |
| classical |
| let bad : M → Finset G := fun m => Finset.univ.filter fun g => ¬good g m |
| have hb : ∀ m ∈ s, (avoidingWords (bad m) L).card ≤ t ^ L := by |
| intro m hm |
| rw [card_avoidingWords] |
| exact Nat.pow_le_pow_left (hbad m hm) L |
| obtain ⟨f, hf⟩ := exists_avoiding s (fun m => avoidingWords (bad m) L) (t ^ L) hb |
| (by simpa using hbudget) |
| refine ⟨f, ?_⟩ |
| intro m hm |
| by_contra hn |
| apply hf m hm |
| simp only [avoidingWords, Finset.mem_filter, Finset.mem_univ, true_and] |
| intro i |
| simp only [bad, Finset.mem_filter, Finset.mem_univ, true_and] |
| exact fun hi => hn ⟨i, hi⟩ |
|
|
| end MatrixMultiplication.FiniteCover |
|
|
| end OAI |
|
|
