| import OAI.Combinatorics.FiniteCircle.MaskBranching |
|
|
| namespace OAI |
|
|
| namespace FiniteCircle |
|
|
| open scoped BigOperators List |
| open scoped ComplexConjugate |
| open RCLike Module |
|
|
| @[reducible] def TreeLeaf (J : ℕ → Type) : ℕ → Type |
| | 0 => PUnit |
| | l+1 => J (l+1) × TreeLeaf J l |
| |
| instance treeLeafFintype (J : ℕ → Type) [∀ l, Fintype (J l)] (l : ℕ) : |
| Fintype (TreeLeaf J l) := by |
| induction l with |
| | zero => exact inferInstanceAs (Fintype PUnit) |
| | succ l ih => exact @instFintypeProd _ _ inferInstance ih |
| |
| noncomputable instance treeLeafDecidableEq (J : ℕ → Type) (l : ℕ) : |
| DecidableEq (TreeLeaf J l) := Classical.decEq _ |
| |
| noncomputable def treeCheap (J Z : ℕ → Type) [∀ l, AddCommGroup (Z l)] {M : ℕ} |
| (σ : ∀ l, Z l →+ (J l → ZMod M)) : (l : ℕ) → AddSubgroup (TreeLeaf J l → ZMod M) |
| | 0 => ⊥ |
| | l+1 => { |
| carrier := {v | ∃ c : J (l+1) → TreeLeaf J l → ZMod M, |
| (∀ j, c j ∈ treeCheap J Z σ l) ∧ ∃ z : Z (l+1), ∀ j i, v (j,i) = c j i + σ (l+1) z j} |
| zero_mem' := by |
| refine ⟨0, fun j => (treeCheap J Z σ l).zero_mem, 0, ?_⟩ |
| intro j i |
| change (0:ZMod M) = 0 + σ (l+1) 0 j |
| simp |
| add_mem' := by |
| rintro v w ⟨c,hc,z,hz⟩ ⟨d,hd,u,hu⟩ |
| refine ⟨c+d, fun j => (treeCheap J Z σ l).add_mem (hc j) (hd j), z+u, ?_⟩ |
| intro j i |
| change v (j,i)+w (j,i) = c j i+d j i+σ (l+1) (z+u) j |
| simp only [hz, hu, map_add, Pi.add_apply] |
| abel |
| neg_mem' := by |
| rintro v ⟨c,hc,z,hz⟩ |
| refine ⟨-c, fun j => (treeCheap J Z σ l).neg_mem (hc j), -z, ?_⟩ |
| intro j i |
| change -v (j,i) = -c j i+σ (l+1) (-z) j |
| simp only [hz, map_neg, Pi.neg_apply] |
| abel } |
| |
| theorem treeCheap_generator (J Z : ℕ → Type) [∀ l, AddCommGroup (Z l)] {M : ℕ} |
| (σ : ∀ l, Z l →+ (J l → ZMod M)) (l : ℕ) (z : Z (l+1)) : |
| (fun i : TreeLeaf J (l+1) => σ (l+1) z i.1) ∈ treeCheap J Z σ (l+1) := by |
| exact ⟨0, fun _ => (treeCheap J Z σ l).zero_mem, z, fun _ _ => (zero_add _).symm⟩ |
| |
| theorem treeCheap_child (J Z : ℕ → Type) [∀ l, AddCommGroup (Z l)] {M : ℕ} |
| (σ : ∀ l, Z l →+ (J l → ZMod M)) (l : ℕ) [DecidableEq (J (l+1))] (j : J (l+1)) |
| (c : TreeLeaf J l → ZMod M) (hc : c ∈ treeCheap J Z σ l) : |
| (fun i : TreeLeaf J (l+1) => if i.1 = j then c i.2 else 0) ∈ treeCheap J Z σ (l+1) := by |
| classical |
| refine ⟨fun k => if k = j then c else 0, ?_, 0, ?_⟩ |
| · intro k |
| dsimp only |
| split_ifs |
| · exact hc |
| · exact (treeCheap J Z σ l).zero_mem |
| · intro k i |
| simp only [map_zero, Pi.zero_apply, add_zero] |
| split_ifs <;> rfl |
| |
| noncomputable def treeFrequency (J : ℕ → Type) : |
| (l : ℕ) → (TreeLeaf J l → ℤ) → FrequencyTree J l |
| | 0, ξ => ξ PUnit.unit |
| | l+1, ξ => fun j => treeFrequency J l (fun i => ξ (j,i)) |
| |
| theorem treeFrequency_sum (J : ℕ → Type) [∀ l, Fintype (J l)] (l : ℕ) |
| (ξ : TreeLeaf J l → ℤ) : frequencySum J l (treeFrequency J l ξ) = ∑ i, ξ i := by |
| induction l with |
| | zero => |
| change ξ PUnit.unit = ∑ i : PUnit, ξ i |
| exact (Fintype.sum_unique (fun i : PUnit => ξ i)).symm |
| | succ l ih => |
| change (∑ j, frequencySum J l (treeFrequency J l (fun i => ξ (j,i)))) = |
| ∑ i : J (l+1) × TreeLeaf J l, ξ i |
| simp only [ih] |
| exact (Fintype.sum_prod_type (fun i : J (l+1) × TreeLeaf J l => ξ i)).symm |
| |
| theorem treeFrequency_mass (J : ℕ → Type) [∀ l, Fintype (J l)] (l : ℕ) |
| (ξ : TreeLeaf J l → ℤ) : frequencyMass J l (treeFrequency J l ξ) = ∑ i, (ξ i).natAbs := by |
| induction l with |
| | zero => |
| change (ξ PUnit.unit).natAbs = ∑ i : PUnit, (ξ i).natAbs |
| exact (Fintype.sum_unique (fun i : PUnit => (ξ i).natAbs)).symm |
| | succ l ih => |
| change (∑ j, frequencyMass J l (treeFrequency J l (fun i => ξ (j,i)))) = |
| ∑ i : J (l+1) × TreeLeaf J l, (ξ i).natAbs |
| simp only [ih] |
| exact (Fintype.sum_prod_type (fun i : J (l+1) × TreeLeaf J l => (ξ i).natAbs)).symm |
| |
| noncomputable def flatMaskState (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ) : |
| (l : ℕ) → (TreeLeaf (MaskChildren h p) l → ZMod M) → MaskState h p M l |
| | 0, v => v PUnit.unit |
| | l+1, v => fun j => flatMaskState h p M l (fun i => v (j,i)) |
| |
| theorem flatMaskState_shift (h : ℕ) (p : ℕ → ℕ → ℕ) (M l : ℕ) |
| (v : TreeLeaf (MaskChildren h p) l → ZMod M) (θ : ZMod M) : |
| flatMaskState h p M l (fun i => v i+θ) = shiftMaskState h p M l (flatMaskState h p M l v) θ := by |
| induction l with |
| | zero => rfl |
| | succ l ih => |
| funext j |
| exact ih (fun i => v (j,i)) |
| |
| noncomputable def flatExcludedState (m M : ℕ) : |
| (l : ℕ) → (TreeLeaf (fun _ => Fin m) l → ZMod M) → ExcludedState m M l |
| | 0, v => v PUnit.unit |
| | l+1, v => fun j => flatExcludedState m M l (fun i => v (j,i)) |
| |
| theorem flatExcludedState_shift (m M l : ℕ) |
| (v : TreeLeaf (fun _ => Fin m) l → ZMod M) (θ : ZMod M) : |
| flatExcludedState m M l (fun i => v i+θ) = shiftExcludedState m M l (flatExcludedState m M l v) θ := by |
| induction l with |
| | zero => rfl |
| | succ l ih => |
| funext j |
| exact ih (fun i => v (j,i)) |
| |
| theorem char_sum {G : Type*} [AddCommMonoid G] {I : Type*} (χ : AddChar G ℂ) |
| (s : Finset I) (f : I → G) : χ (∑ i ∈ s, f i) = ∏ i ∈ s, χ (f i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi ih => simp only [Finset.sum_insert hi, Finset.prod_insert hi, |
| AddChar.map_add_eq_mul, ih] |
| |
| theorem character_dot {I : Type*} [Fintype I] [DecidableEq I] {M : ℕ} [NeZero M] |
| (χ : AddChar (I → ZMod M) ℂ) (v : I → ZMod M) : |
| χ v = AddChar.zmodAddEquiv (∑ i, coordinateFrequency χ i * v i) 1 := by |
| classical |
| have hv : v = ∑ i, Pi.single i (v i) := by |
| ext j |
| simp [Pi.single_apply] |
| conv_lhs => rw [hv] |
| rw [char_sum] |
| rw [map_sum, AddChar.sum_apply] |
| apply Finset.prod_congr rfl |
| intro i _ |
| rw [character_single, zmod_character_mul] |
| |
| theorem character_dot_eq_one {I : Type*} [Fintype I] [DecidableEq I] {M : ℕ} [NeZero M] |
| (χ : AddChar (I → ZMod M) ℂ) (v : I → ZMod M) : |
| χ v = 1 ↔ ∑ i, coordinateFrequency χ i * v i = 0 := by |
| rw [character_dot, zmod_character_eq_one, mul_one] |
| |
| theorem dot_restrict_child (J Z : ℕ → Type) [∀ l, Fintype (J l)] |
| [∀ l, AddCommGroup (Z l)] {M : ℕ} (σ : ∀ l, Z l →+ (J l → ZMod M)) |
| (l : ℕ) (ξ : TreeLeaf J (l+1) → ℤ) |
| (ha : ∀ c ∈ treeCheap J Z σ (l+1), ∑ i, (ξ i : ZMod M)*c i = 0) |
| (j : J (l+1)) (c : TreeLeaf J l → ZMod M) (hc : c ∈ treeCheap J Z σ l) : |
| ∑ i, (ξ (j,i):ZMod M)*c i = 0 := by |
| classical |
| have ht := ha _ (treeCheap_child J Z σ l j c hc) |
| change (∑ k : J (l+1) × TreeLeaf J l, (ξ k : ZMod M)*(if k.1=j then c k.2 else 0)) = 0 at ht |
| simpa only [Fintype.sum_prod_type, mul_ite, mul_zero, Finset.sum_ite_irrel, |
| Finset.sum_const_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true] using ht |
| |
| @[simp] theorem subcircle_intCast {M p : ℕ} (hp : p ∣ M) (a : ℤ) : |
| subcircle hp (a : ZMod p) = (M/p : ZMod M)*(a : ZMod M) := by |
| have h := map_zsmul (subcircle hp) a (1 : ZMod p) |
| have hc : subcircle hp 1 = (M/p : ZMod M) := by |
| simpa only [Nat.cast_one, mul_one] using subcircle_natCast hp 1 |
| rw [zsmul_eq_mul, mul_one, hc, zsmul_eq_mul] at h |
| simpa only [mul_comm] using h |
| |
| theorem mask_generator_apply {h M l : ℕ} {p : ℕ → ℕ → ℕ} |
| (hd : ∀ k : Fin h, p l k ∣ M) (k : Fin h) (j : MaskTag h p l) : |
| maskPhaseHom h p M l hd (Pi.single k 1) j = |
| subcircle (hd k) 1 + if j.1 = k then j.2.val • subcircle (hd k) 1 else 0 := by |
| classical |
| have hs : (∑ a : Fin h, subcircle (hd a) ((Pi.single k 1 : MaskResidues h p l) a)) = |
| subcircle (hd k) 1 := by |
| rw [Finset.sum_eq_single k] |
| · simp |
| · intro a _ ha |
| simp [Pi.single_eq_of_ne ha] |
| · simp |
| change (∑ a : Fin h, subcircle (hd a) ((Pi.single k 1 : MaskResidues h p l) a)) + |
| j.2.val • subcircle (hd j.1) ((Pi.single k 1 : MaskResidues h p l) j.1) = _ |
| rw [hs] |
| congr 1 |
| by_cases he : j.1 = k |
| · subst k |
| simp |
| · simp [he] |
| |
| noncomputable def maskCheap (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ) |
| (hd : ∀ l (k : Fin h), p l k ∣ M) (l : ℕ) : |
| AddSubgroup (TreeLeaf (MaskChildren h p) l → ZMod M) := |
| treeCheap (MaskChildren h p) (MaskResidues h p) (fun l => maskPhaseHom h p M l (hd l)) l |
| |
| theorem mask_dot_generator {h M l : ℕ} {p : ℕ → ℕ → ℕ} |
| (hd : ∀ k : Fin h, p (l+1) k ∣ M) (k : Fin h) |
| (ξ : TreeLeaf (MaskChildren h p) (l+1) → ℤ) : |
| (∑ i, (ξ i:ZMod M)*maskPhaseHom h p M (l+1) hd (Pi.single k 1) i.1) = |
| subcircle (hd k) (((∑ i, ξ i) + ∑ b : Fin (p (l+1) k), (b.val:ℤ)* |
| ∑ i : TreeLeaf (MaskChildren h p) l, ξ (⟨k,b⟩,i) : ℤ) : ZMod (p (l+1) k)) := by |
| classical |
| rw [subcircle_intCast] |
| let q : ZMod M := subcircle (hd k) 1 |
| have hq : q = (M/p (l+1) k : ZMod M) := by |
| simpa only [Nat.cast_one, mul_one] using subcircle_natCast (hd k) 1 |
| simp_rw [mask_generator_apply] |
| change (∑ i : MaskTag h p (l+1) × TreeLeaf (MaskChildren h p) l, |
| (ξ i:ZMod M)*(q+if i.1.1=k then i.1.2.val • q else 0)) = _ |
| simp_rw [mul_add, Finset.sum_add_distrib] |
| rw [← Finset.sum_mul] |
| have hs : (∑ i : MaskTag h p (l+1) × TreeLeaf (MaskChildren h p) l, |
| (ξ i:ZMod M)*(if i.1.1=k then i.1.2.val • q else 0)) = |
| (∑ b : Fin (p (l+1) k), (b.val:ZMod M)*∑ i : TreeLeaf (MaskChildren h p) l, |
| (ξ (⟨k,b⟩,i):ZMod M))*q := by |
| rw [Fintype.sum_prod_type, Fintype.sum_sigma] |
| simp only [mul_ite, mul_zero, Finset.sum_ite_irrel, Finset.sum_const_zero] |
| rw [Finset.sum_ite_eq', ite_eq_left (Finset.mem_univ k)] |
| simp_rw [nsmul_eq_mul, ← Finset.sum_mul] |
| conv_rhs => rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro b _ |
| ring |
| rw [hs, hq] |
| push_cast |
| ring |
| |
| theorem mask_annihilator_congruences {h M : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M] |
| (hd : ∀ l (k : Fin h), p l k ∣ M) (hn : ∀ l (k : Fin h), 0 < p l k) |
| (l : ℕ) (ξ : TreeLeaf (MaskChildren h p) l → ℤ) |
| (ha : ∀ c ∈ maskCheap h p M hd l, ∑ i, (ξ i:ZMod M)*c i = 0) : |
| MaskCongruences h p l (treeFrequency (MaskChildren h p) l ξ) := by |
| classical |
| induction l with |
| | zero => trivial |
| | succ l ih => |
| change (∀ k : Fin h, (p (l+1) k:ℤ) ∣ _ ) ∧ _ |
| constructor |
| · intro k |
| let : NeZero (p (l+1) k) := ⟨(hn _ k).ne'⟩ |
| have hg := treeCheap_generator (MaskChildren h p) (MaskResidues h p) |
| (fun l => maskPhaseHom h p M l (hd _)) l (Pi.single k 1) |
| have hz := ha _ hg |
| rw [mask_dot_generator (hd (l+1)) k ξ] at hz |
| have he : (((∑ i, ξ i) + ∑ b : Fin (p (l+1) k), (b.val:ℤ)* |
| ∑ i : TreeLeaf (MaskChildren h p) l, ξ (⟨k,b⟩,i) : ℤ) : ZMod (p (l+1) k)) = 0 := |
| subcircle_injective (hd _ k) (hz.trans (map_zero _).symm) |
| have he' := (ZMod.intCast_zmod_eq_zero_iff_dvd _ _).mp he |
| simp only [treeFrequency, frequencySum, treeFrequency_sum] |
| convert he' using 1 |
| congr 1 |
| exact (Fintype.sum_prod_type (fun i : MaskChildren h p (l+1) × TreeLeaf (MaskChildren h p) l => ξ i)).symm |
| · intro j |
| apply ih |
| intro c hc |
| exact dot_restrict_child (MaskChildren h p) (MaskResidues h p) |
| (fun l => maskPhaseHom h p M l (hd _)) l ξ ha j c hc |
| |
| theorem mask_character_branching {h M : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M] |
| (hh : 2 ≤ h) (hd : ∀ l (k : Fin h), p l k ∣ M) |
| (hn : ∀ l (k : Fin h), 0 < p l k) |
| (hp : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → Nat.Prime (p l k)) |
| (hinj : ∀ l, 1 ≤ l → l ≤ h → Function.Injective (fun k : Fin h => p l k)) |
| (hlarge : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → h ^ 3 ≤ p l k) |
| (χ : AddChar (TreeLeaf (MaskChildren h p) h → ZMod M) ℂ) |
| (ha : χ.compAddMonoidHom (maskCheap h p M hd h).subtype = 0) |
| (θ : ZMod M) (hw : χ (fun _ => θ) ≠ 1) : |
| ((h:ℝ)/2)^h ≤ ∑ i, ((coordinateFrequency χ i).valMinAbs.natAbs:ℝ) := by |
| classical |
| let ξ := fun i => (coordinateFrequency χ i).valMinAbs |
| have hc := mask_annihilator_congruences hd hn h ξ (fun c hc => by |
| have hv := congrArg (fun ψ : AddChar (maskCheap h p M hd h) ℂ => ψ ⟨c,hc⟩) ha |
| have he : χ c = 1 := hv |
| have hz := (character_dot_eq_one χ c).mp he |
| simpa only [ξ, ZMod.coe_valMinAbs] using hz) |
| have hroot : frequencySum (MaskChildren h p) h (treeFrequency (MaskChildren h p) h ξ) ≠ 0 := by |
| rw [treeFrequency_sum] |
| intro he |
| apply hw |
| rw [character_dot_eq_one, ← Finset.sum_mul] |
| have hz : ∑ i, coordinateFrequency χ i = 0 := by |
| have ht := congrArg (fun n : ℤ => (n : ZMod M)) he |
| simpa only [Int.cast_sum, ξ, ZMod.coe_valMinAbs, Int.cast_zero] using ht |
| rw [hz, zero_mul] |
| have hb := mask_frequency_branching hh p hp hinj hlarge _ hc hroot |
| rw [treeFrequency_mass] at hb |
| simp only [Nat.cast_sum, ξ] at hb |
| convert hb using 1 |
| congr 1 |
| |
| noncomputable def ExcludedCongruences (h : ℕ) (p : ℕ → ℕ → ℕ) : |
| (l : ℕ) → FrequencyTree (fun _ => Fin h) l → Prop |
| | 0, _ => True |
| | l+1, t => |
| (∀ k : Fin h, (p (l+1) k:ℤ) ∣ frequencySum (fun _ => Fin h) (l+1) t - |
| frequencySum (fun _ => Fin h) l (t k)) ∧ |
| ∀ j, ExcludedCongruences h p l (t j) |
| |
| theorem many_excluded_children {h : ℕ} (hh : 2 ≤ h) (p : Fin h → ℕ) |
| (hp : ∀ i, Nat.Prime (p i)) (hinj : Function.Injective p) |
| (hlarge : ∀ i, h ^ 3 ≤ p i) (f : Fin h → ℤ) |
| {β : ℤ} (hβ : β ≠ 0) (hsmall : β.natAbs < h ^ h) |
| (hc : ∀ k, (p k : ℤ) ∣ β - f k) : |
| h ≤ 2 * (Finset.univ.filter fun j => f j ≠ 0).card := by |
| classical |
| let s := Finset.univ.filter fun j => f j ≠ 0 |
| let t := Finset.univ.filter fun k => ¬ (p k : ℤ) ∣ β |
| let q := Finset.univ.filter fun k => (p k : ℤ) ∣ β |
| have hq : 3 * q.card < h := few_large_prime_divisors hh p hp hinj hlarge hβ hsmall |
| have ht : t ⊆ s := by |
| intro k hk |
| refine Finset.mem_filter.mpr ⟨Finset.mem_univ k, ?_⟩ |
| intro he |
| have hc' := hc k |
| rw [he, sub_zero] at hc' |
| exact (Finset.mem_filter.mp hk).2 hc' |
| have hcard : t.card ≤ s.card := Finset.card_le_card ht |
| have hcount : q.card + t.card = h := by |
| simpa [q, t] using (Finset.card_filter_add_card_filter_not |
| (s := (Finset.univ : Finset (Fin h))) (fun k => (p k : ℤ) ∣ β)) |
| change h ≤ 2 * s.card |
| omega |
| |
| theorem excluded_branching_induction {h : ℕ} (hh : 2 ≤ h) (p : ℕ → ℕ → ℕ) |
| (hp : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → Nat.Prime (p l k)) |
| (hinj : ∀ l, 1 ≤ l → l ≤ h → Function.Injective (fun k : Fin h => p l k)) |
| (hlarge : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → h ^ 3 ≤ p l k) |
| (l : ℕ) (hl : l ≤ h) (t : FrequencyTree (fun _ => Fin h) l) |
| (hc : ExcludedCongruences h p l t) |
| (hroot : frequencySum (fun _ => Fin h) l t ≠ 0) |
| (hsmall : frequencyMass (fun _ => Fin h) l t < h ^ h) : |
| ((h : ℝ) / 2) ^ l ≤ (frequencyMass (fun _ => Fin h) l t : ℝ) := by |
| classical |
| induction l with |
| | zero => |
| have : 1 ≤ frequencyMass (fun _ => Fin h) 0 t := |
| (Int.natAbs_pos.mpr hroot).trans_le (frequencySum_natAbs_le_mass _ _ _) |
| simpa using (show (1 : ℝ) ≤ frequencyMass (fun _ => Fin h) 0 t by exact_mod_cast this) |
| | succ l ih => |
| let f : Fin h → ℤ := fun j => frequencySum (fun _ => Fin h) l (t j) |
| let s := Finset.univ.filter fun j => f j ≠ 0 |
| have hsumSmall : (frequencySum (fun _ => Fin h) (l + 1) t).natAbs < h ^ h := |
| (frequencySum_natAbs_le_mass _ _ _).trans_lt hsmall |
| have hcard : h ≤ 2 * s.card := |
| many_excluded_children hh (fun k => p (l + 1) k) |
| (fun k => hp _ k (by omega) hl) (hinj _ (by omega) hl) |
| (fun k => hlarge _ k (by omega) hl) f hroot hsumSmall hc.1 |
| have hchild : ∀ j, frequencyMass (fun _ => Fin h) l (t j) < h ^ h := by |
| intro j |
| apply lt_of_le_of_lt _ hsmall |
| change frequencyMass (fun _ => Fin h) l (t j) ≤ ∑ j, frequencyMass (fun _ => Fin h) l (t j) |
| exact Finset.single_le_sum (f := fun j => frequencyMass (fun _ => Fin h) l (t j)) |
| (fun _ _ => Nat.zero_le _) (Finset.mem_univ j) |
| have hm : ∀ j ∈ s, ((h : ℝ) / 2) ^ l ≤ frequencyMass (fun _ => Fin h) l (t j) := by |
| intro j hj |
| exact ih (by omega) (t j) (hc.2 j) (Finset.mem_filter.mp hj).2 (hchild j) |
| have hcardR : (h : ℝ) / 2 ≤ s.card := by |
| have : (h : ℝ) ≤ 2 * (s.card : ℝ) := by exact_mod_cast hcard |
| linarith |
| calc |
| ((h : ℝ) / 2) ^ (l + 1) = ((h : ℝ) / 2) * ((h : ℝ) / 2) ^ l := by ring |
| _ ≤ s.card * ((h : ℝ) / 2) ^ l := mul_le_mul_of_nonneg_right hcardR (by positivity) |
| _ = ∑ j ∈ s, ((h : ℝ) / 2) ^ l := by simp |
| _ ≤ ∑ j ∈ s, (frequencyMass (fun _ => Fin h) l (t j) : ℝ) := Finset.sum_le_sum hm |
| _ ≤ ∑ j, (frequencyMass (fun _ => Fin h) l (t j) : ℝ) := |
| Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun _ _ _ => by positivity) |
| _ = (frequencyMass (fun _ => Fin h) (l + 1) t : ℝ) := by |
| simp only [frequencyMass, Nat.cast_sum] |
| |
| theorem excluded_frequency_branching {h : ℕ} (hh : 2 ≤ h) (p : ℕ → ℕ → ℕ) |
| (hp : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → Nat.Prime (p l k)) |
| (hinj : ∀ l, 1 ≤ l → l ≤ h → Function.Injective (fun k : Fin h => p l k)) |
| (hlarge : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → h ^ 3 ≤ p l k) |
| (t : FrequencyTree (fun _ => Fin h) h) (hc : ExcludedCongruences h p h t) |
| (hroot : frequencySum (fun _ => Fin h) h t ≠ 0) : |
| ((h : ℝ) / 2) ^ h ≤ (frequencyMass (fun _ => Fin h) h t : ℝ) := by |
| by_contra hn |
| have hlt := lt_of_not_ge hn |
| have hcap : ((h : ℝ) / 2) ^ h ≤ (h : ℝ) ^ h := by |
| apply pow_le_pow_left₀ (by positivity) |
| have : (0 : ℝ) ≤ h := Nat.cast_nonneg h |
| linarith |
| have hsmall : frequencyMass (fun _ => Fin h) h t < h ^ h := by |
| exact_mod_cast hlt.trans_le hcap |
| exact (not_lt_of_ge (excluded_branching_induction hh p hp hinj hlarge h le_rfl t hc hroot hsmall)) hlt |
| |
| theorem excluded_generator_apply {h M l : ℕ} {p : ℕ → ℕ → ℕ} |
| (hd : ∀ k : Fin h, p l k ∣ M) (k j : Fin h) : |
| excludedPhaseHom h p M l hd (Pi.single k 1) j = |
| subcircle (hd k) 1 - if j = k then subcircle (hd k) 1 else 0 := by |
| classical |
| rw [excludedPhaseHom_apply] |
| have hs : (∑ a : Fin h, subcircle (hd a) ((Pi.single k 1 : MaskResidues h p l) a)) = |
| subcircle (hd k) 1 := by |
| rw [Finset.sum_eq_single k] |
| · simp |
| · intro a _ ha |
| simp [Pi.single_eq_of_ne ha] |
| · simp |
| rw [hs] |
| congr 1 |
| by_cases he : j = k |
| · subst j |
| simp |
| · simp [he] |
| |
| noncomputable def excludedCheap (h : ℕ) (p : ℕ → ℕ → ℕ) (M : ℕ) |
| (hd : ∀ l (k : Fin h), p l k ∣ M) (l : ℕ) : |
| AddSubgroup (TreeLeaf (fun _ => Fin h) l → ZMod M) := |
| treeCheap (fun _ => Fin h) (MaskResidues h p) (fun l => excludedPhaseHom h p M l (hd l)) l |
| |
| theorem excluded_dot_generator {h M l : ℕ} {p : ℕ → ℕ → ℕ} |
| (hd : ∀ k : Fin h, p (l+1) k ∣ M) (k : Fin h) |
| (ξ : TreeLeaf (fun _ => Fin h) (l+1) → ℤ) : |
| (∑ i, (ξ i:ZMod M)*excludedPhaseHom h p M (l+1) hd (Pi.single k 1) i.1) = |
| subcircle (hd k) (((∑ i, ξ i) - |
| ∑ i : TreeLeaf (fun _ => Fin h) l, ξ (k,i) : ℤ) : ZMod (p (l+1) k)) := by |
| classical |
| rw [subcircle_intCast] |
| let q : ZMod M := subcircle (hd k) 1 |
| have hq : q = (M/p (l+1) k : ZMod M) := by |
| simpa only [Nat.cast_one, mul_one] using subcircle_natCast (hd k) 1 |
| simp_rw [excluded_generator_apply] |
| change (∑ i : Fin h × TreeLeaf (fun _ => Fin h) l, |
| (ξ i:ZMod M)*(q-if i.1=k then q else 0)) = _ |
| simp_rw [mul_sub, Finset.sum_sub_distrib] |
| rw [← Finset.sum_mul] |
| have hs : (∑ i : Fin h × TreeLeaf (fun _ => Fin h) l, |
| (ξ i:ZMod M)*(if i.1=k then q else 0)) = |
| (∑ i : TreeLeaf (fun _ => Fin h) l, (ξ (k,i):ZMod M))*q := by |
| simp only [Fintype.sum_prod_type, mul_ite, mul_zero] |
| rw [Finset.sum_comm] |
| simp only [Finset.sum_ite_eq', Finset.mem_univ, ite_true] |
| rw [← Finset.sum_mul] |
| rw [hs, hq] |
| push_cast |
| ring |
| |
| theorem excluded_annihilator_congruences {h M : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M] |
| (hd : ∀ l (k : Fin h), p l k ∣ M) (hn : ∀ l (k : Fin h), 0 < p l k) |
| (l : ℕ) (ξ : TreeLeaf (fun _ => Fin h) l → ℤ) |
| (ha : ∀ c ∈ excludedCheap h p M hd l, ∑ i, (ξ i:ZMod M)*c i = 0) : |
| ExcludedCongruences h p l (treeFrequency (fun _ => Fin h) l ξ) := by |
| classical |
| induction l with |
| | zero => trivial |
| | succ l ih => |
| change (∀ k : Fin h, (p (l+1) k:ℤ) ∣ _ ) ∧ _ |
| constructor |
| · intro k |
| let : NeZero (p (l+1) k) := ⟨(hn _ k).ne'⟩ |
| have hg := treeCheap_generator (fun _ => Fin h) (MaskResidues h p) |
| (fun l => excludedPhaseHom h p M l (hd _)) l (Pi.single k 1) |
| have hz := ha _ hg |
| rw [excluded_dot_generator (hd (l+1)) k ξ] at hz |
| have he : (((∑ i, ξ i) - |
| ∑ i : TreeLeaf (fun _ => Fin h) l, ξ (k,i) : ℤ) : ZMod (p (l+1) k)) = 0 := |
| subcircle_injective (hd _ k) (hz.trans (map_zero _).symm) |
| have he' := (ZMod.intCast_zmod_eq_zero_iff_dvd _ _).mp he |
| simp only [treeFrequency, frequencySum, treeFrequency_sum] |
| convert he' using 1 |
| congr 1 |
| exact (Fintype.sum_prod_type (fun i : Fin h × TreeLeaf (fun _ => Fin h) l => ξ i)).symm |
| · intro j |
| apply ih |
| intro c hc |
| exact dot_restrict_child (fun _ => Fin h) (MaskResidues h p) |
| (fun l => excludedPhaseHom h p M l (hd _)) l ξ ha j c hc |
| |
| theorem excluded_character_branching {h M : ℕ} {p : ℕ → ℕ → ℕ} [NeZero M] |
| (hh : 2 ≤ h) (hd : ∀ l (k : Fin h), p l k ∣ M) |
| (hn : ∀ l (k : Fin h), 0 < p l k) |
| (hp : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → Nat.Prime (p l k)) |
| (hinj : ∀ l, 1 ≤ l → l ≤ h → Function.Injective (fun k : Fin h => p l k)) |
| (hlarge : ∀ l (k : Fin h), 1 ≤ l → l ≤ h → h ^ 3 ≤ p l k) |
| (χ : AddChar (TreeLeaf (fun _ => Fin h) h → ZMod M) ℂ) |
| (ha : χ.compAddMonoidHom (excludedCheap h p M hd h).subtype = 0) |
| (θ : ZMod M) (hw : χ (fun _ => θ) ≠ 1) : |
| ((h:ℝ)/2)^h ≤ ∑ i, ((coordinateFrequency χ i).valMinAbs.natAbs:ℝ) := by |
| classical |
| let ξ := fun i => (coordinateFrequency χ i).valMinAbs |
| have hc := excluded_annihilator_congruences hd hn h ξ (fun c hc => by |
| have hv := congrArg (fun ψ : AddChar (excludedCheap h p M hd h) ℂ => ψ ⟨c,hc⟩) ha |
| have he : χ c = 1 := hv |
| have hz := (character_dot_eq_one χ c).mp he |
| simpa only [ξ, ZMod.coe_valMinAbs] using hz) |
| have hroot : frequencySum (fun _ => Fin h) h (treeFrequency (fun _ => Fin h) h ξ) ≠ 0 := by |
| rw [treeFrequency_sum] |
| intro he |
| apply hw |
| rw [character_dot_eq_one, ← Finset.sum_mul] |
| have hz : ∑ i, coordinateFrequency χ i = 0 := by |
| have ht := congrArg (fun n : ℤ => (n : ZMod M)) he |
| simpa only [Int.cast_sum, ξ, ZMod.coe_valMinAbs, Int.cast_zero] using ht |
| rw [hz, zero_mul] |
| have hb := excluded_frequency_branching hh p hp hinj hlarge _ hc hroot |
| rw [treeFrequency_mass] at hb |
| simp only [Nat.cast_sum, ξ] at hb |
| simpa only [Nat.cast_sum, ξ] using hb |
| |
| end FiniteCircle |
| |
| end OAI |
| |
