openAI-math-dataset / lean /OAI /GroupTheory /SimpleAmenable /Arithmetic /PropagationArithmetic.lean
| import Mathlib | |
| import OAI.GroupTheory.SimpleAmenable.Arithmetic.PolygonArithmetic | |
| namespace OAI | |
| section | |
| section | |
| open scoped symmDiff | |
| namespace SimpleAmenable | |
| open scoped commutatorElement | |
| open scoped commutatorElement | |
| section PropagationArithmetic | |
| @[simp] theorem endpointLabel_add (z w : CutRing) : | |
| endpointLabel (z+w) = endpointLabel z + endpointLabel w := rfl | |
| @[simp] theorem endpointLabel_sub (z w : CutRing) : | |
| endpointLabel (z-w) = endpointLabel z - endpointLabel w := rfl | |
| @[simp] theorem endpointLabel_intCast (k : ℤ) : endpointLabel (k : CutRing) = 0 := rfl | |
| theorem endpointLabel_mul (l d : CutRing) : | |
| (endpointLabel (l*d) : ℝ) = conjugate l * (endpointLabel d : ℝ) + | |
| (endpointLabel l : ℝ) * ordinary d := by | |
| simp only [endpointLabel, QuadraticAlgebra.im_mul, Int.cast_add, Int.cast_mul, | |
| Int.cast_one, ordinary_apply, conjugate_apply] | |
| rw [← Real.one_sub_goldenConj] | |
| ring | |
| theorem endpointLabel_mul_bound (l d : CutRing) {N D : ℝ} | |
| (hq : |(endpointLabel d : ℝ)| ≤ N) (hd : |ordinary d| ≤ D) : | |
| |(endpointLabel (l*d) : ℝ)| ≤ |conjugate l| * N + |(endpointLabel l : ℝ)| * D := by | |
| rw [endpointLabel_mul] | |
| calc | |
| _ ≤ |conjugate l * (endpointLabel d : ℝ)| + | |
| |(endpointLabel l : ℝ) * ordinary d| := abs_add_le _ _ | |
| _ = |conjugate l| * |(endpointLabel d : ℝ)| + | |
| |(endpointLabel l : ℝ)| * |ordinary d| := by rw [abs_mul, abs_mul] | |
| _ ≤ _ := by gcongr | |
| theorem exists_source_slope (c C : ℝ) (hc : 0 < c) : | |
| ∃ a : ℕ, 0 < a ∧ | |
| ordinary (cutTau^a)*c > 1000*(C+1) ∧ | |
| |conjugate (cutTau^a)| < 1/1000 := by | |
| obtain ⟨a,ha⟩ := pow_unbounded_of_one_lt (1000*(C+1)/c) Real.one_lt_goldenRatio | |
| have hconj : |Real.goldenConj| < 1 := by | |
| rw [abs_of_neg Real.goldenConj_neg] | |
| linarith [Real.neg_one_lt_goldenConj] | |
| obtain ⟨b,hb⟩ := exists_pow_lt_of_lt_one (by norm_num : (0:ℝ) < 1/1000) hconj | |
| refine ⟨max a b + 1, by omega, ?_, ?_⟩ | |
| · have hp : Real.goldenRatio^a ≤ Real.goldenRatio^(max a b + 1) := | |
| pow_le_pow_right₀ Real.one_lt_goldenRatio.le (by omega) | |
| simpa only [map_pow, ordinary_cutTau] using | |
| (div_lt_iff₀ hc).mp (lt_of_lt_of_le ha hp) | |
| · simp only [map_pow, conjugate_cutTau, abs_pow] | |
| exact lt_of_le_of_lt (pow_le_pow_of_le_one (abs_nonneg _) hconj.le (by omega)) hb | |
| theorem exists_source_slope_explicit : | |
| ∃ a : ℕ, 0 < a ∧ ordinary (cutTau^a)*(1/4) > 1000*(100+1) ∧ | |
| |conjugate (cutTau^a)| < 1/1000 := | |
| exists_source_slope (1/4) 100 (by norm_num) | |
| end PropagationArithmetic | |
| section BoundedOneDimensionalOrdering | |
| variable {α : Type*} | |
| private theorem real_list_sum_nonpos {l : List ℝ} (h : ∀ x ∈ l, x ≤ 0) : l.sum ≤ 0 := by | |
| induction l with | |
| | nil => simp | |
| | cons x l ih => | |
| exact add_nonpos (h x (by simp)) (ih (fun y hy => h y (by simp [hy]))) | |
| theorem exists_bounded_step_order (v : α → ℝ) (xs : List α) | |
| {L U δ x : ℝ} (hLU : L ≤ U) (_hδ : 0 ≤ δ) | |
| (hstep : ∀ t ∈ xs, |v t| ≤ δ) | |
| (hx : L-δ ≤ x ∧ x ≤ U+δ) | |
| (hy : L ≤ x+(xs.map v).sum ∧ x+(xs.map v).sum ≤ U) : | |
| ∃ ys : List α, ys.Perm xs ∧ | |
| ∀ n : ℕ, L-δ ≤ x+((ys.take n).map v).sum ∧ | |
| x+((ys.take n).map v).sum ≤ U+δ := by | |
| classical | |
| induction hn : xs.length using Nat.strong_induction_on generalizing xs x with | |
| | h n ih => | |
| by_cases hnil : xs = [] | |
| · subst xs | |
| exact ⟨[],List.Perm.refl _,fun _ => by simpa using hx⟩ | |
| have hcons : ∃ t, t ∈ xs := List.exists_mem_of_ne_nil xs hnil | |
| have hchoose : ∃ t ∈ xs, L-δ ≤ x+v t ∧ x+v t ≤ U+δ := by | |
| by_cases hlow : x < L | |
| · have hp : ∃ t ∈ xs, 0 < v t := by | |
| by_contra! hp | |
| have hz : (xs.map v).sum ≤ 0 := real_list_sum_nonpos (by | |
| intro r hr | |
| obtain ⟨t,ht,rfl⟩ := List.mem_map.mp hr | |
| exact hp t ht) | |
| linarith [hy.1] | |
| obtain ⟨t,ht,hpos⟩ := hp | |
| refine ⟨t,ht,by linarith [hx.1],?_⟩ | |
| linarith [(abs_le.mp (hstep t ht)).2] | |
| · by_cases hhigh : U < x | |
| · have hp : ∃ t ∈ xs, v t < 0 := by | |
| by_contra! hp | |
| have hz : 0 ≤ (xs.map v).sum := List.sum_nonneg (by | |
| intro r hr | |
| obtain ⟨t,ht,rfl⟩ := List.mem_map.mp hr | |
| exact hp t ht) | |
| linarith [hy.2] | |
| obtain ⟨t,ht,hneg⟩ := hp | |
| refine ⟨t,ht,?_,by linarith [hx.2]⟩ | |
| linarith [(abs_le.mp (hstep t ht)).1] | |
| · obtain ⟨t,ht⟩ := hcons | |
| refine ⟨t,ht,?_,?_⟩ <;> linarith [abs_le.mp (hstep t ht)] | |
| obtain ⟨t,ht,htx⟩ := hchoose | |
| have hperm : (t :: xs.erase t).Perm xs := (List.perm_cons_erase ht).symm | |
| have he : v t + ((xs.erase t).map v).sum = (xs.map v).sum := by | |
| have := (hperm.map v).sum_eq | |
| simpa using this | |
| have hlen : (xs.erase t).length < n := by | |
| rw [← hn] | |
| rw [List.length_erase_of_mem ht] | |
| have : 0 < xs.length := List.length_pos_iff.mpr hnil | |
| omega | |
| obtain ⟨ys,hys,hbounds⟩ := ih _ hlen (xs.erase t) (x := x+v t) | |
| (fun s hs => hstep s (List.mem_of_mem_erase hs)) htx | |
| (by constructor <;> linarith [hy.1,hy.2]) rfl | |
| refine ⟨t::ys,(List.Perm.cons t hys).trans hperm,?_⟩ | |
| intro k | |
| cases k with | |
| | zero => simpa using hx | |
| | succ k => simpa only [List.take_succ_cons,List.map_cons,List.sum_cons,add_assoc] | |
| using hbounds k | |
| theorem exists_step_order_near_segment (v : α → ℝ) (xs : List α) {δ : ℝ} | |
| (hδ : 0 ≤ δ) (hstep : ∀ t ∈ xs, |v t| ≤ δ) : | |
| ∃ ys : List α, ys.Perm xs ∧ ∀ n : ℕ, | |
| min 0 (xs.map v).sum - δ ≤ ((ys.take n).map v).sum ∧ | |
| ((ys.take n).map v).sum ≤ max 0 (xs.map v).sum + δ := by | |
| obtain ⟨ys,hy,hb⟩ := exists_bounded_step_order v xs | |
| (L := min 0 (xs.map v).sum) (U := max 0 (xs.map v).sum) (x := 0) | |
| min_le_max hδ hstep | |
| ⟨by linarith [min_le_left 0 (xs.map v).sum], | |
| by linarith [le_max_left 0 (xs.map v).sum]⟩ | |
| ⟨by simp, by simp⟩ | |
| exact ⟨ys,hy,fun n => by simpa using hb n⟩ | |
| end BoundedOneDimensionalOrdering | |
| end SimpleAmenable | |
| end | |
| end | |
| end OAI | |