| import OAI.NumberTheory.TwoPoint.Walks.ReversedSegments |
|
|
| namespace OAI |
|
|
| /-! Active numerical labels in minimal prohibited witnesses. -/ |
|
|
| namespace TwoPointCorrelations |
|
|
| open Finset |
|
|
| noncomputable def wordPrimeContribution (h : ℕ) (w : List SignedStep) (p a b : ℕ) : ℤ := by |
| classical |
| exact ∑ i ∈ Ico a b, if TuplePrimeAt w p i then wordStepDisplacement h w i else 0 |
|
|
| / |
| def ActivePrime (h : ℕ) (w : List SignedStep) (p : ℕ) : Prop := |
| ∃ c a b, a ≤ b ∧ b ≤ w.length ∧ (∃ i, TuplePrimeAt w c i) ∧ |
| (c : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) a b ∧ |
| ¬(c : ℤ) ∣ wordPrimeContribution h w p a b |
|
|
| lemma wordPrimeContribution_eq_interval (h : ℕ) (w : List SignedStep) (p a b : ℕ) |
| (hp : ∀ i ∈ Ico a b, TuplePrimeAt w p i) : |
| wordPrimeContribution h w p a b = intervalDisplacement (wordStepDisplacement h w) a b := by |
| classical |
| unfold wordPrimeContribution intervalDisplacement |
| apply sum_congr rfl |
| intro i hi |
| simp only [hp i hi, ite_true] |
|
|
| lemma wordPrimeContribution_eq_singleton (h : ℕ) (w : List SignedStep) (p a b j : ℕ) |
| (hj : j ∈ Ico a b) (hp : TuplePrimeAt w p j) |
| (hunique : ∀ i ∈ Ico a b, TuplePrimeAt w p i → i = j) : |
| wordPrimeContribution h w p a b = wordStepDisplacement h w j := by |
| classical |
| unfold wordPrimeContribution |
| rw [sum_eq_single j] |
| · simp only [hp, ite_true] |
| · intro i hi hne |
| have hnot : ¬TuplePrimeAt w p i := fun hpi => hne (hunique i hi hpi) |
| simp only [hnot, ite_false] |
| · exact fun h => False.elim (h hj) |
|
|
| / |
| prohibited suffix, because its contribution is exactly that last step. -/ |
| lemma ForwardProhibited.last_new_active {h s : ℕ} {supply : ℕ → ℕ → Prop} |
| {w : List SignedStep} (hw : ForwardProhibited h s supply w) {z : ℕ} |
| (hz : TuplePrimeAt w z (w.length - 1)) |
| (hearlier : ∀ i, i < w.length - 1 → ¬TuplePrimeAt w z i) |
| (hoff : ∀ p i, (∃ j, TuplePrimeAt w p j) → i < w.length → |
| ¬TuplePrimeAt w p i → ¬(p : ℤ) ∣ wordStepDisplacement h w i) : |
| ActivePrime h w z := by |
| rcases hw with ⟨hlen, _, _, _, _, c, hc, hclast, a, ha, halast, hdiv⟩ |
| refine ⟨c, a, w.length, by omega, le_rfl, ⟨0, hc⟩, ?_, ?_⟩ |
| · simpa only [wordSlice, Nat.sub_self, List.take_length, List.length_drop] using |
| (show (c : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) a w.length from by |
| rw [← wordSlice_displacement h w (by omega)] |
| simpa only [wordSlice, ← List.length_drop, List.take_length] using hdiv) |
| · rw [wordPrimeContribution_eq_singleton h w z a w.length (w.length - 1) |
| (by simp only [mem_Ico]; omega) hz] |
| · exact hoff c (w.length - 1) ⟨0, hc⟩ (by omega) hclast |
| · intro i hi hzi |
| have hi' := (mem_Ico.mp hi).2 |
| by_contra hne |
| exact hearlier i (by omega) hzi |
|
|
| lemma prime_dvd_wordPrimeContribution (h : ℕ) (w : List SignedStep) (p a b : ℕ) : |
| (p : ℤ) ∣ wordPrimeContribution h w p a b := by |
| classical |
| unfold wordPrimeContribution |
| apply Finset.dvd_sum |
| intro i _ |
| by_cases hpi : TuplePrimeAt w p i |
| · simpa only [hpi, ite_true] using (tuplePrime_dvd_step (h := h) hpi) |
| · simp only [hpi, ite_false, dvd_zero] |
|
|
| lemma ActivePrime.distinct_controller {h p : ℕ} {w : List SignedStep} |
| (hp : ActivePrime h w p) : |
| ∃ c a b, c ≠ p ∧ a ≤ b ∧ b ≤ w.length ∧ (∃ i, TuplePrimeAt w c i) ∧ |
| (c : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) a b ∧ |
| ¬(c : ℤ) ∣ wordPrimeContribution h w p a b := by |
| obtain ⟨c, a, b, hab, hb, hc, hd, hn⟩ := hp |
| refine ⟨c, a, b, ?_, hab, hb, hc, hd, hn⟩ |
| intro heq |
| subst c |
| exact hn (prime_dvd_wordPrimeContribution h w p a b) |
|
|
| / |
| explicit nonempty interval of indices. -/ |
| lemma TuplePrimeIntervals.prefix_occurrences {w : List SignedStep} |
| (hw : TuplePrimeIntervals w) (p n : ℕ) (hn : n ≤ w.length) |
| (hp : ∃ j, j < n ∧ TuplePrimeAt w p j) : |
| ∃ a b, a < b ∧ b ≤ n ∧ ∀ i, i < n → |
| (TuplePrimeAt w p i ↔ a ≤ i ∧ i < b) := by |
| classical |
| let S := (range n).filter (TuplePrimeAt w p) |
| have hS : S.Nonempty := by |
| obtain ⟨j, hj, hpj⟩ := hp |
| exact ⟨j, mem_filter.mpr ⟨mem_range.mpr hj, hpj⟩⟩ |
| let a := S.min' hS |
| let b := S.max' hS + 1 |
| have haS : a ∈ S := min'_mem S hS |
| have hbS : b - 1 ∈ S := by |
| simpa only [b, Nat.add_sub_cancel] using max'_mem S hS |
| have han := (mem_range.mp (mem_filter.mp haS).1) |
| have hbn := (mem_range.mp (mem_filter.mp hbS).1) |
| have hab : a < b := by |
| have h := min'_le S (S.max' hS) (max'_mem S hS) |
| dsimp [a, b] |
| omega |
| refine ⟨a, b, hab, by dsimp [b] at *; omega, ?_⟩ |
| intro i hi |
| constructor |
| · intro hpi |
| have hiS : i ∈ S := mem_filter.mpr ⟨mem_range.mpr hi, hpi⟩ |
| exact ⟨min'_le S i hiS, Nat.lt_succ_of_le (le_max' S i hiS)⟩ |
| · rintro ⟨hai, hib⟩ |
| exact hw p a i (b - 1) hai (by omega) (by omega) |
| (mem_filter.mp haS).2 (mem_filter.mp hbS).2 |
|
|
| lemma wordPrimeContribution_restrict (h : ℕ) (w : List SignedStep) (p n a b : ℕ) |
| (hbn : b ≤ n) |
| (hp : ∀ i, i < n → (TuplePrimeAt w p i ↔ a ≤ i ∧ i < b)) : |
| wordPrimeContribution h w p 0 n = intervalDisplacement (wordStepDisplacement h w) a b := by |
| classical |
| unfold wordPrimeContribution intervalDisplacement |
| calc |
| _ = ∑ i ∈ Ico a b, if TuplePrimeAt w p i then wordStepDisplacement h w i else 0 := by |
| symm |
| apply Finset.sum_subset (Ico_subset_Ico (Nat.zero_le a) hbn) |
| intro i hi hin |
| have hnot : ¬TuplePrimeAt w p i := by |
| intro hpi |
| exact hin (mem_Ico.mpr ((hp i (mem_Ico.mp hi).2).mp hpi)) |
| simp only [hnot, ite_false] |
| _ = _ := by |
| apply sum_congr rfl |
| intro i hi |
| simp only [(hp i (lt_of_lt_of_le (mem_Ico.mp hi).2 hbn)).mpr |
| ⟨(mem_Ico.mp hi).1, (mem_Ico.mp hi).2⟩, ite_true] |
|
|
| / |
| index, when an internal initial segment is divisible by its final prime. -/ |
| lemma MinimalWord.no_reversed_divisible_interval {h s : ℕ} {supply : ℕ → ℕ → Prop} |
| {w : List SignedStep} (hw : MinimalWord (ForwardProhibited h s supply) w) |
| {a c p : ℕ} (ha : 0 < a) (hac : a + 1 < c) (hc : c < w.length) |
| (hp : TuplePrimeAt w p (w.length - 1)) (hnot : ¬TuplePrimeAt w p a) : |
| ¬(p : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) a c := by |
| intro hdiv |
| have hpro := reversed_interval_forwardProhibited h s supply w hw.1.2.1 hw.1.2.2.1 |
| hw.1.2.2.2.1 hw.1.2.2.2.2.1 hac hc le_rfl hp hnot hdiv |
| apply hw.2 (reverseWord (wordSlice w a w.length)) |
| (Or.inr (reverseWord_infix (wordSlice_infix w a w.length))) ?_ hpro |
| rw [reverseWord_length, wordSlice_length w (by omega) le_rfl] |
| omega |
|
|
| / |
| prefix contribution modulo an active label used at that departure. -/ |
| theorem MinimalWord.active_dichotomy {h s : ℕ} {supply : ℕ → ℕ → Prop} |
| {w : List SignedStep} (hw : MinimalWord (ForwardProhibited h s supply) w) |
| (hnew : ∀ i, i + 1 < w.length → |
| ∃ p, TuplePrimeAt w p (i + 1) ∧ ¬TuplePrimeAt w p i) |
| (hoff : ∀ p i, (∃ j, TuplePrimeAt w p j) → i < w.length → |
| ¬TuplePrimeAt w p i → ¬(p : ℤ) ∣ wordStepDisplacement h w i) |
| (y : ℕ) (hy : ∃ j, TuplePrimeAt w y j) : |
| ActivePrime h w y ∨ ∃ z i, ActivePrime h w z ∧ TuplePrimeAt w z i ∧ |
| ¬(z : ℤ) ∣ wordPrimeContribution h w y 0 i := by |
| classical |
| have hlen : 3 ≤ w.length := hw.1.1 |
| have hinter : TuplePrimeIntervals w := hw.1.2.2.2.2.1 |
| obtain ⟨z, hzlast', hzprev⟩ := hnew (w.length - 2) (by omega) |
| have heqlast : w.length - 2 + 1 = w.length - 1 := by omega |
| have hzlast : TuplePrimeAt w z (w.length - 1) := heqlast ▸ hzlast' |
| have hzearly : ∀ i, i < w.length - 1 → ¬TuplePrimeAt w z i := by |
| intro i hi hzi |
| exact hzprev (hinter z i (w.length - 2) (w.length - 1) |
| (by omega) (by omega) (by omega) hzi hzlast) |
| have hzactive := hw.1.last_new_active hzlast hzearly hoff |
| by_cases hypre : ∃ j, j < w.length - 1 ∧ TuplePrimeAt w y j |
| · obtain ⟨a, b, hab, hbn, hyinterval⟩ := |
| hinter.prefix_occurrences y (w.length - 1) (by omega) hypre |
| have hyeq := wordPrimeContribution_restrict h w y (w.length - 1) a b hbn hyinterval |
| by_cases hzd : (z : ℤ) ∣ wordPrimeContribution h w y 0 (w.length - 1) |
| · have hdiv : (z : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) a b := by |
| rwa [hyeq] at hzd |
| have hab2 : a + 1 < b := by |
| by_contra hn |
| have hb : b = a + 1 := by omega |
| have hd := hoff z a ⟨w.length - 1, hzlast⟩ (by omega) (hzearly a (by omega)) |
| exact hd (by simpa only [hb, intervalDisplacement_singleton] using hdiv) |
| have ha : a = 0 := by |
| by_contra hn |
| exact hw.no_reversed_divisible_interval (by omega) hab2 (by omega) |
| hzlast (hzearly a (by omega)) hdiv |
| obtain ⟨z', hz'one, hz'zero⟩ := hnew 0 (by omega) |
| obtain ⟨a', b', hab', hb'b, hz'interval⟩ := |
| hinter.prefix_occurrences z' b (by omega) ⟨1, by omega, hz'one⟩ |
| have ha' : a' = 1 := by |
| have hle := ((hz'interval 1 (by omega)).mp hz'one).1 |
| have hne : a' ≠ 0 := by |
| intro heq |
| have hp := (hz'interval a' (by omega)).mpr ⟨le_rfl, hab'⟩ |
| exact hz'zero (by simpa only [heq] using hp) |
| omega |
| have hzeq := wordPrimeContribution_restrict h w z' b a' b' hb'b hz'interval |
| have hnonzero : ¬(z : ℤ) ∣ wordPrimeContribution h w z' 0 b := by |
| intro hzero |
| have hdiv' : (z : ℤ) ∣ intervalDisplacement (wordStepDisplacement h w) 1 b' := by |
| simpa only [hzeq, ha'] using hzero |
| have hb' : 2 < b' := by |
| by_contra hn |
| have hb'eq : b' = 1 + 1 := by omega |
| exact (hoff z 1 ⟨w.length - 1, hzlast⟩ (by omega) (hzearly 1 (by omega))) |
| (by simpa only [hb'eq, intervalDisplacement_singleton] using hdiv') |
| exact hw.no_reversed_divisible_interval (by omega) hb' (by omega) |
| hzlast (hzearly 1 (by omega)) hdiv' |
| have hz'active : ActivePrime h w z' := by |
| refine ⟨z, 0, b, by omega, by omega, ⟨w.length - 1, hzlast⟩, ?_, hnonzero⟩ |
| simpa only [ha] using hdiv |
| right |
| refine ⟨z', 1, hz'active, hz'one, ?_⟩ |
| have hyzero : TuplePrimeAt w y 0 := (hyinterval 0 (by omega)).mpr ⟨by omega, by omega⟩ |
| rw [wordPrimeContribution_eq_singleton h w y 0 1 0 (by simp) hyzero] |
| · exact hoff z' 0 ⟨1, hz'one⟩ (by omega) hz'zero |
| · intro i hi _ |
| have := mem_Ico.mp hi |
| omega |
| · exact Or.inr ⟨z, w.length - 1, hzactive, hzlast, hzd⟩ |
| · left |
| have hyearly : ∀ i, i < w.length - 1 → ¬TuplePrimeAt w y i := by |
| intro i hi hpi |
| exact hypre ⟨i, hi, hpi⟩ |
| obtain ⟨j, hyj⟩ := hy |
| have hj := hyj.index_lt |
| have hjeq : j = w.length - 1 := by |
| by_contra hn |
| exact hyearly j (by omega) hyj |
| exact hw.1.last_new_active (hjeq ▸ hyj) hyearly hoff |
|
|
| / |
| lemma adjacent_tuple_new_prime (w : List SignedStep) (J : ℕ) |
| (hsq : ∀ a ∈ w, Squarefree a.tuple) |
| (hcard : ∀ a ∈ w, a.tuple.primeFactors.card = J) |
| (hchain : w.IsChain (fun a b => a.tuple ≠ b.tuple)) : |
| ∀ i, i + 1 < w.length → ∃ p, TuplePrimeAt w p (i + 1) ∧ ¬TuplePrimeAt w p i := by |
| intro i hi |
| have hi0 : i < w.length := by omega |
| have ha := List.getElem_mem hi0 |
| have hb := List.getElem_mem hi |
| have hneq : w[i].tuple ≠ w[i + 1].tuple := (List.isChain_iff_getElem.mp hchain) i hi |
| have hsets : w[i + 1].tuple.primeFactors ≠ w[i].tuple.primeFactors := by |
| intro heq |
| apply hneq |
| calc |
| _ = ∏ p ∈ w[i].tuple.primeFactors, p := (Nat.prod_primeFactors_of_squarefree (hsq _ ha)).symm |
| _ = ∏ p ∈ w[i + 1].tuple.primeFactors, p := by rw [heq] |
| _ = _ := Nat.prod_primeFactors_of_squarefree (hsq _ hb) |
| have hnot : ¬w[i + 1].tuple.primeFactors ⊆ w[i].tuple.primeFactors := by |
| intro hsub |
| apply hsets |
| exact Finset.eq_of_subset_of_card_le hsub (by rw [hcard _ ha, hcard _ hb]) |
| obtain ⟨p, hpb, hpa⟩ := Finset.not_subset.mp hnot |
| have hp := Nat.mem_primeFactors.mp hpb |
| refine ⟨p, (tuplePrimeAt_iff_getElem w p (i + 1) hi).mpr ⟨hp.1, hp.2.1⟩, ?_⟩ |
| intro hpi |
| have hpai := (tuplePrimeAt_iff_getElem w p i hi0).mp hpi |
| exact hpa (Nat.mem_primeFactors.mpr ⟨hpai.1, hpai.2, (hsq _ ha).ne_zero⟩) |
|
|
| / |
| hypotheses: squarefree whole tuples of fixed prime-factor count, and prime |
| exclusion from the common multiplier and all padding factors. -/ |
| theorem MinimalWord.active_dichotomy_of_squarefree {h s J : ℕ} |
| {supply : ℕ → ℕ → Prop} {w : List SignedStep} |
| (hw : MinimalWord (ForwardProhibited h s supply) w) |
| (hsq : ∀ a ∈ w, Squarefree a.tuple) |
| (hcard : ∀ a ∈ w, a.tuple.primeFactors.card = J) |
| (hsupport : ∀ p j, TuplePrimeAt w p j → ¬p ∣ h ∧ ∀ a ∈ w, ¬p ∣ a.padding) |
| (y : ℕ) (hy : ∃ j, TuplePrimeAt w y j) : |
| ActivePrime h w y ∨ ∃ z i, ActivePrime h w z ∧ TuplePrimeAt w z i ∧ |
| ¬(z : ℤ) ∣ wordPrimeContribution h w y 0 i := by |
| apply hw.active_dichotomy (adjacent_tuple_new_prime w J hsq hcard hw.1.2.2.2.1) ?_ y hy |
| intro p i hseen hi hnot |
| apply word_prime_support hsupport p i ?_ hi hnot |
| obtain ⟨j, hj⟩ := hseen |
| exact ⟨j, hj.index_lt, hj⟩ |
|
|
| end TwoPointCorrelations |
|
|
| end OAI |
|
|
