| import OAI.NumberTheory.TwoPoint.Walks.ColumnPatternRecovery |
| import OAI.NumberTheory.TwoPoint.Walks.ColumnBudget |
|
|
| namespace OAI |
|
|
| /-! A fixed finite universe for every column with the proved numerical budget. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Filter |
|
|
| noncomputable def columnBudgetCap (N : ℕ) (L : ℝ) : ℕ := |
| min N ⌊66 * L ^ (0.92 : ℝ)⌋₊ |
|
|
| noncomputable abbrev BudgetColumnCode (N : ℕ) (L : ℝ) := |
| BoundedColumnDecoderCode N (columnBudgetCap N L) (columnBudgetCap N L) (columnBudgetCap N L) |
|
|
| noncomputable def decodeBudgetColumnPattern {n N : ℕ} {L : ℝ} (hn : n ≤ N) |
| (code : BudgetColumnCode N L) : Fin n → Fin n → Bool := |
| decodeColumnPrefixPattern hn code.2.2.2 |
|
|
| / |
| numerical coefficients, the prime values, or the number of regular lines. -/ |
| theorem budget_column_code_of_counts {n N S O I : ℕ} {L : ℝ} |
| (hn : n ≤ N) (hS : S ≤ N) (hO : O ≤ N) (hI : I ≤ N) |
| (hcost : ((2 * S + O + I : ℕ) : ℝ) ≤ 66 * L ^ (0.92 : ℝ)) |
| (code : ColumnDecoderCode N S O I) : |
| ∃ full : BudgetColumnCode N L, |
| decodeBudgetColumnPattern hn full = decodeColumnPrefixPattern hn code := by |
| have htotal : 2 * S + O + I ≤ ⌊66 * L ^ (0.92 : ℝ)⌋₊ := Nat.le_floor hcost |
| have hs : S < columnBudgetCap N L + 1 := by |
| unfold columnBudgetCap |
| omega |
| have ho : O < columnBudgetCap N L + 1 := by |
| unfold columnBudgetCap |
| omega |
| have hi : I < columnBudgetCap N L + 1 := by |
| unfold columnBudgetCap |
| omega |
| exact ⟨⟨⟨S, hs⟩, ⟨O, ho⟩, ⟨I, hi⟩, code⟩, rfl⟩ |
|
|
| / |
| absorbed only into the large-scale threshold; the exponential constant 64 |
| is the same for every column and every choice of numerical coefficients. -/ |
| theorem eventually_budget_column_code_card : |
| ∀ᶠ L : ℝ in atTop, ∀ k N : ℕ, |
| L / 2 ≤ (k : ℝ) → (k : ℝ) ≤ L → 1 ≤ N → N ≤ 4 * k → |
| (Fintype.card (BudgetColumnCode N L) : ℝ) ≤ Real.exp (64 * k) := by |
| filter_upwards [eventually_bounded_column_code_exponential 264 (by norm_num), |
| eventually_ge_atTop (0 : ℝ)] with L h hL |
| intro k N hklo hkhi hN hNk |
| have hc : columnBudgetCap N L ≤ N := Nat.min_le_left _ _ |
| have hfloor : (columnBudgetCap N L : ℝ) ≤ 66 * L ^ (0.92 : ℝ) := by |
| have hf := Nat.floor_le (show 0 ≤ 66 * L ^ (0.92 : ℝ) by positivity) |
| have hm : (columnBudgetCap N L : ℝ) ≤ ⌊66 * L ^ (0.92 : ℝ)⌋₊ := by |
| exact_mod_cast (Nat.min_le_right N ⌊66 * L ^ (0.92 : ℝ)⌋₊) |
| exact hm.trans hf |
| apply h k N _ _ _ hklo hkhi hN hNk hc hc hc |
| push_cast |
| nlinarith |
|
|
| theorem card_budget_column_patterns {n N : ℕ} {L : ℝ} (hn : n ≤ N) : |
| Nat.card (Set.range (@decodeBudgetColumnPattern n N L hn)) ≤ |
| Fintype.card (BudgetColumnCode N L) := by |
| let f := @decodeBudgetColumnPattern n N L hn |
| have hr := Nat.card_le_card_of_surjective |
| (fun c => (⟨f c, c, rfl⟩ : Set.range f)) (by |
| rintro ⟨_, c, rfl⟩ |
| exact ⟨c, rfl⟩) |
| simpa only [Nat.card_eq_fintype_card] using hr |
|
|
| noncomputable abbrev BudgetColumnArrayCode (J N : ℕ) (L : ℝ) := |
| Fin J → BudgetColumnCode N L |
|
|
| noncomputable instance budgetColumnArrayFintype (J N : ℕ) (L : ℝ) : |
| Fintype (BudgetColumnArrayCode J N L) := by |
| classical |
| letI : Fintype (BudgetColumnCode N L) := inferInstance |
| exact Pi.instFintype |
|
|
| noncomputable def decodeBudgetColumnArray {n J N : ℕ} {L : ℝ} (hn : n ≤ N) |
| (code : BudgetColumnArrayCode J N L) : Fin J → Fin n → Fin n → Bool := |
| fun j => decodeBudgetColumnPattern hn (code j) |
|
|
| theorem budget_column_array_cover {n J N : ℕ} {L : ℝ} (hn : n ≤ N) |
| (pattern : Fin J → Fin n → Fin n → Bool) |
| (h : ∀ j, ∃ code : BudgetColumnCode N L, decodeBudgetColumnPattern hn code = pattern j) : |
| ∃ code : BudgetColumnArrayCode J N L, decodeBudgetColumnArray hn code = pattern := by |
| classical |
| choose code hc using h |
| exact ⟨code, funext hc⟩ |
|
|
| / |
| one universal finite set for all numerical assignments. -/ |
| theorem eventually_budget_column_array_card : |
| ∀ᶠ L : ℝ in atTop, ∀ k J N : ℕ, |
| L / 2 ≤ (k : ℝ) → (k : ℝ) ≤ L → 1 ≤ N → N ≤ 4 * k → |
| (Fintype.card (BudgetColumnArrayCode J N L) : ℝ) ≤ Real.exp (64 * k * J) := by |
| filter_upwards [eventually_budget_column_code_card] with L h |
| intro k J N hklo hkhi hN hNk |
| let : Fintype (BudgetColumnCode N L) := inferInstance |
| have hc := h k N hklo hkhi hN hNk |
| calc |
| _ = (Fintype.card (BudgetColumnCode N L) : ℝ) ^ J := by |
| simp only [BudgetColumnArrayCode, Fintype.card_fun, Fintype.card_fin, Nat.cast_pow] |
| _ ≤ (Real.exp (64 * k)) ^ J := pow_le_pow_left₀ (by positivity) hc J |
| _ = Real.exp (64 * k * J) := by |
| rw [← Real.exp_nat_mul] |
| congr 1 |
| ring |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
