| import Mathlib |
|
|
| namespace OAI |
|
|
| section |
| open scoped BigOperators |
|
|
|
|
| /-! Occurrence-preserving bounds for the canonical p−1 auxiliary tree in |
| Section5. Equal labels under different parents remain separate list entries. -/ |
| namespace ExactQuantumFactoring.AuxiliaryTree |
| open scoped BigOperators |
|
|
| def children (M : ℕ) : List ℕ := |
| ((M.primeFactors.filter (fun p => 2<p)).sort (·≤·)).map (·-1) |
|
|
| lemma mem_children {M d : ℕ} : d ∈ children M ↔ |
| ∃ p, p.Prime ∧ p ∣ M ∧ M≠0 ∧ 2<p ∧ d=p-1 := by |
| simp only [children,List.mem_map,Finset.mem_sort,Finset.mem_filter,Nat.mem_primeFactors] |
| constructor |
| · rintro ⟨p,⟨⟨hp,hpm,hM⟩,hp2⟩,hd⟩ |
| exact ⟨p,hp,hpm,hM,hp2,hd.symm⟩ |
| · rintro ⟨p,hp,hpm,hM,hp2,rfl⟩ |
| exact ⟨p,⟨⟨hp,hpm,hM⟩,hp2⟩,rfl⟩ |
|
|
| lemma child_bounds {M d : ℕ} (hd : d ∈ children M) : 2≤d ∧ d<M := by |
| obtain ⟨p,hp,hpm,hM,hp2,rfl⟩ := mem_children.mp hd |
| have hpM := Nat.le_of_dvd (Nat.pos_of_ne_zero hM) hpm |
| omega |
|
|
| lemma child_even {M d : ℕ} (hd : d ∈ children M) : Even d := by |
| obtain ⟨p,hp,_,_,hp2,rfl⟩ := mem_children.mp hd |
| have ho := hp.odd_of_ne_two (by omega) |
| exact (Nat.even_sub (by omega : 1≤p)).mpr (by simpa using ho) |
|
|
| lemma grandchild_half {M d e : ℕ} (hd : d ∈ children M) (he : e ∈ children d) : |
| 2*e<M := by |
| obtain ⟨p,hp,hpd,hd0,hp2,rfl⟩ := mem_children.mp he |
| have hopen := hp.odd_of_ne_two (by omega) |
| have hcop : Nat.Coprime 2 p := (Nat.coprime_two_left).mpr hopen |
| have hdiv := hcop.mul_dvd_of_dvd_of_dvd (even_iff_two_dvd.mp (child_even hd)) hpd |
| have hle := Nat.le_of_dvd (Nat.pos_of_ne_zero hd0) hdiv |
| have hdm := (child_bounds hd).2 |
| omega |
|
|
| lemma children_prod_le {M : ℕ} (hM : 0<M) : (children M).prod≤M := by |
| unfold children |
| rw [← List.prod_toFinset _ (Finset.sort_nodup _ _),Finset.sort_toFinset] |
| calc |
| (∏ p ∈ M.primeFactors.filter (fun p => 2<p), (p-1)) ≤ |
| ∏ p ∈ M.primeFactors.filter (fun p => 2<p), p := |
| Finset.prod_le_prod (fun _ _ => Nat.sub_le _ _) |
| _ ≤ ∏ p ∈ M.primeFactors, p := Finset.prod_le_prod_of_subset_of_one_le |
| (Finset.filter_subset _ _) |
| (fun p hp _ => (Nat.prime_of_mem_primeFactors hp).one_lt.le) |
| _ ≤ M := Nat.le_of_dvd hM (Nat.prod_primeFactors_dvd M) |
|
|
| /-- A level is a list, not a set: multiplicities of occurrences are retained. -/ |
| def level (M : ℕ) : ℕ → List ℕ |
| | 0 => [M] |
| | k+1 => (children M).flatMap (fun d => level d k) |
|
|
| lemma level_bounds {M d k : ℕ} (hM : 2≤M) (hd : d ∈ level M k) : 2≤d ∧ d≤M := by |
| induction k generalizing M with |
| | zero => |
| have he : d=M := by simpa [level] using hd |
| subst d |
| exact ⟨hM,le_rfl⟩ |
| | succ k ih => |
| obtain ⟨e,he,hd⟩ := List.mem_flatMap.mp hd |
| have hb := child_bounds he |
| have hh := ih hb.1 hd |
| exact ⟨hh.1,hh.2.trans hb.2.le⟩ |
|
|
| lemma level_two_step {M d k : ℕ} (hd : d ∈ level M (2*k)) : 2^k*d≤M := by |
| induction k generalizing M with |
| | zero => |
| have he : d=M := by simpa [level] using hd |
| simpa using he.le |
| | succ k ih => |
| have heq : 2*(k+1)=2*k+1+1 := by omega |
| rw [heq,level] at hd |
| obtain ⟨e,he,hd⟩ := List.mem_flatMap.mp hd |
| rw [level] at hd |
| obtain ⟨f,hf,hd⟩ := List.mem_flatMap.mp hd |
| have hx := ih hd |
| have hh := grandchild_half he hf |
| rw [pow_succ] |
| nlinarith |
|
|
| lemma level_empty {M n : ℕ} (hM : 2≤M) (hbound : M<2^n) : level M (2*n)=[] := by |
| apply List.eq_nil_iff_forall_not_mem.mpr |
| intro d hd |
| have hx := level_two_step hd |
| have hy := (level_bounds hM hd).1 |
| have hp : 0<2^n := by positivity |
| nlinarith |
|
|
| lemma prod_flatMap (f : ℕ→List ℕ) (xs : List ℕ) : |
| (xs.flatMap f).prod=(xs.map (fun x => (f x).prod)).prod := by |
| induction xs with |
| | nil => rfl |
| | cons x xs ih => simp [ih] |
|
|
| lemma level_prod_le {M k : ℕ} (hM : 2≤M) : (level M k).prod≤M := by |
| induction k generalizing M with |
| | zero => simp [level] |
| | succ k ih => |
| rw [level,prod_flatMap] |
| calc |
| ((children M).map (fun d => (level d k).prod)).prod ≤ |
| ((children M).map id).prod := List.prod_map_le_prod_map₀ _ _ |
| (fun _ _ => Nat.zero_le _) (fun d hd => ih (child_bounds hd).1) |
| _ = (children M).prod := by simp |
| _ ≤ M := children_prod_le (by omega) |
|
|
| lemma pow_length_le_prod (xs : List ℕ) (hxs : ∀ x ∈ xs, 2≤x) : 2^xs.length≤xs.prod := by |
| induction xs with |
| | nil => simp |
| | cons x xs ih => |
| have hx := hxs x (by simp) |
| have hi := ih (fun y hy => hxs y (by simp [hy])) |
| simp only [List.length_cons,List.prod_cons,pow_succ] |
| exact (Nat.mul_le_mul hi hx).trans_eq (Nat.mul_comm _ _) |
|
|
| lemma level_length_lt {M n k : ℕ} (hM : 2≤M) (hbound : M<2^n) : |
| (level M k).length<n := by |
| apply (Nat.pow_lt_pow_iff_right (by decide : 1<2)).mp |
| exact (pow_length_le_prod _ (fun _ hd => (level_bounds hM hd).1)).trans_lt |
| ((level_prod_le hM).trans_lt hbound) |
|
|
| def splitWeight (M : ℕ) : ℕ := M.primeFactorsList.length |
|
|
| lemma splitWeight_bound {M n : ℕ} (hM : 0<M) (hbound : M<2^n) : splitWeight M<n := by |
| apply (Nat.pow_lt_pow_iff_right (by decide : 1<2)).mp |
| have hh := pow_length_le_prod M.primeFactorsList |
| (fun p hp => (Nat.prime_of_mem_primeFactorsList hp).two_le) |
| rw [Nat.prod_primeFactorsList hM.ne'] at hh |
| exact hh.trans_lt hbound |
|
|
| lemma level_weight_lt {M n k : ℕ} (hM : 2≤M) (hbound : M<2^n) : |
| ((level M k).map splitWeight).sum<n := by |
| let ps := (level M k).flatMap Nat.primeFactorsList |
| have he : ps.prod=(level M k).prod := by |
| rw [prod_flatMap] |
| congr 1 |
| conv_rhs => rw [← List.map_id (level M k)] |
| apply List.map_congr_left |
| intro d hd |
| exact Nat.prod_primeFactorsList (by have := (level_bounds hM hd).1; omega) |
| have hlen : ps.length=((level M k).map splitWeight).sum := by |
| change (List.flatMap Nat.primeFactorsList (level M k)).length = _ |
| rw [List.length_flatMap] |
| rfl |
| have hp : 2^ps.length≤ps.prod := pow_length_le_prod ps (by |
| intro p hp |
| obtain ⟨d,_,hp⟩ := List.mem_flatMap.mp hp |
| exact (Nat.prime_of_mem_primeFactorsList hp).two_le) |
| rw [he,hlen] at hp |
| exact (Nat.pow_lt_pow_iff_right (by decide : 1<2)).mp |
| (hp.trans_lt ((level_prod_le hM).trans_lt hbound)) |
|
|
| /-- The source's whole-tree task cap, expressed without real logarithms. -/ |
| def taskBound (M n : ℕ) : ℕ := |
| ∑ k ∈ Finset.range (2*n+2), ((level M k).map splitWeight).sum |
|
|
| lemma taskBound_le {M n : ℕ} (hM : 2≤M) (hbound : M<2^n) : |
| taskBound M n ≤ (2*n+2)*n := by |
| unfold taskBound |
| calc |
| _ ≤ ∑ _k ∈ Finset.range (2*n+2), n := Finset.sum_le_sum |
| (fun k _ => (level_weight_lt (k:=k) hM hbound).le) |
| _ = _ := by simp |
|
|
| lemma transitions_bound {n : ℕ} (hn : 2≤n) : (2*n+2)*n*(n^5+1)≤6*n^7 := by |
| have hnpos : 0<n := by omega |
| have hp : 1≤n^5 := Nat.one_le_pow _ _ hnpos |
| have h₁ : 2*n+2≤3*n := by omega |
| have h₂ : n^5+1≤2*n^5 := by omega |
| calc |
| _ ≤ (3*n)*n*(2*n^5) := Nat.mul_le_mul (Nat.mul_le_mul_right n h₁) h₂ |
| _ = 6*n^7 := by ring |
|
|
| lemma transitions_lt_slots {n : ℕ} (hn : 128≤n) : (2*n+2)*n*(n^5+1)<n^10 := by |
| have hp : 6<n^3 := by |
| have hh := Nat.pow_le_pow_left hn 3 |
| norm_num at hh |
| omega |
| have hnpos : 0<n^7 := pow_pos (by omega) _ |
| calc |
| _ ≤ 6*n^7 := transitions_bound (by omega) |
| _ < n^3*n^7 := Nat.mul_lt_mul_of_pos_right hp hnpos |
| _ = n^10 := by ring |
|
|
| end ExactQuantumFactoring.AuxiliaryTree |
|
|
|
|
| end |
|
|
| end OAI |
|
|
