| import Mathlib |
| import OAI.Combinatorics.IndependentSets.Reduction.SimplexLaw |
| import OAI.Combinatorics.IndependentSets.Geometry.RationalSimplexApproximation |
| import OAI.Combinatorics.IndependentSets.Reduction.Small |
|
|
| namespace OAI |
|
|
| namespace LargeIndependentSets |
| open scoped Classical BigOperators |
|
|
| theorem rational_pattern_alignment (s d : ℕ) (η : ℝ) (hη : 0 < η) : |
| ∃ r ≥ s, ∃ p : (Fin s ↪o Fin r) → ℚ, ((∀ coordinate, 0 ≤ p coordinate) ∧ |
| ∑ coordinate, p coordinate = 1) ∧ |
| ∀ C : ListPattern s d (Fin r), |
| ∑ e, (p e : ℝ) * (if ¬GoodPatternOn (C.restrict e) Finset.univ then 1 else 0) ≤ η := by |
| obtain ⟨r, hr, q, hq, hqbound⟩ := real_pattern_alignment s d (η / 2) (half_pos hη) |
| have : Nonempty (Fin s ↪o Fin r) := ⟨Fin.castLEOrderEmb hr⟩ |
| obtain ⟨p, hp, happ⟩ := rational_simplex_approximation q hq (η / 2) (half_pos hη) |
| refine ⟨r, hr, p, hp, ?_⟩ |
| intro C |
| have ha := happ (fun e => if ¬GoodPatternOn (C.restrict e) Finset.univ then 1 else 0) |
| (fun e => by split_ifs <;> norm_num) |
| have hb := hqbound C |
| linarith |
|
|
| noncomputable def embeddingLayerLaw {r s : ℕ} |
| (p : (Fin s ↪o Fin r) → ℚ) |
| (hp : (∀ coordinate, 0 ≤ p coordinate) ∧ ∑ coordinate, p coordinate = 1) : LayerLaw r s where |
| weight B := ∑ e, if B = Finset.univ.map e.toEmbedding then p e else 0 |
| nonneg B := Finset.sum_nonneg (fun e _ => by split_ifs; exact hp.1 e; rfl) |
| total := by |
| rw [Finset.sum_comm] |
| simpa using hp.2 |
| support B hB := by |
| apply Finset.sum_eq_zero |
| intro e _ |
| apply ite_eq_right |
| intro h |
| apply hB |
| rw [h] |
| simp |
|
|
| lemma embeddingLayerLaw_badMass {r s : ℕ} {M : Type} |
| (p : (Fin s ↪o Fin r) → ℚ) |
| (hp : (∀ coordinate, 0 ≤ p coordinate) ∧ ∑ coordinate, p coordinate = 1) |
| (A : Finset (Fin r) → Finset M) : |
| (embeddingLayerLaw p hp).badMass A = |
| ∑ e, if Aligned A (Finset.univ.map e.toEmbedding) then 0 else p e := by |
| classical |
| unfold LayerLaw.badMass |
| change (∑ B, if Aligned A B then 0 else |
| ∑ e, if B = Finset.univ.map e.toEmbedding then p e else 0) = _ |
| have h (B : Finset (Fin r)) : |
| (if Aligned A B then 0 else ∑ e, if B = Finset.univ.map e.toEmbedding then p e else 0) = |
| ∑ e, if B = Finset.univ.map e.toEmbedding then |
| (if Aligned A (Finset.univ.map e.toEmbedding) then 0 else p e) else 0 := by |
| by_cases ha : Aligned A B |
| · rw [ite_eq_left ha] |
| symm |
| apply Finset.sum_eq_zero |
| intro e _ |
| by_cases he : B = Finset.univ.map e.toEmbedding |
| · simp [← he, ha] |
| · simp [he] |
| · rw [ite_eq_right ha] |
| apply Finset.sum_congr rfl |
| intro e _ |
| by_cases he : B = Finset.univ.map e.toEmbedding |
| · simp [← he, ha] |
| · simp [he] |
| simp_rw [h] |
| rw [Finset.sum_comm] |
| simp |
|
|
| theorem distributional_alignment : DistributionalAlignment := by |
| classical |
| intro s d hs hd η hη |
| obtain ⟨r, hr, p, hp, hbound⟩ := rational_pattern_alignment s d η hη |
| refine ⟨r, hr, embeddingLayerLaw p hp, ?_⟩ |
| intro M _ A hcard hsep |
| rw [embeddingLayerLaw_badMass, Rat.cast_sum] |
| apply le_trans ?_ (hbound (actualPattern (d := d) A hsep)) |
| apply Finset.sum_le_sum |
| intro e _ |
| have hnonneg : (0 : ℝ) ≤ p e := by exact_mod_cast hp.1 e |
| by_cases hg : GoodPatternOn ((actualPattern (d := d) A hsep).restrict e) Finset.univ |
| · have hBcard : (Finset.univ.map e.toEmbedding).card = s := by simp |
| have hB : (Finset.univ.map e.toEmbedding).Nonempty := |
| Finset.card_pos.mp (by omega) |
| have ha : Aligned A (Finset.univ.map e.toEmbedding) := |
| actualPattern_good_aligned A hcard hsep _ hB hBcard.le |
| (good_embedding_restrict_goodOn _ e hg) |
| simp [ha, hg] |
| · simp only [hg, not_false_eq_true, ite_true, mul_one] |
| split_ifs <;> simp_all |
|
|
| end LargeIndependentSets |
|
|
| end OAI |
|
|
