| import OAI.Combinatorics.HalvingLines.PathLimits |
|
|
| namespace OAI |
|
|
| open Filter Topology |
|
|
| namespace PlanarHalving.Boundary |
| open Set Filter |
| open scoped Topology |
|
|
| lemma sum_cube_le {ι : Type*} (s : Finset ι) (f : ι → ℝ) |
| (hf : ∀ i ∈ s, 0 ≤ f i) : |
| (∑ i ∈ s, f i)^3 ≤ (s.card : ℝ)^2 * ∑ i ∈ s, (f i)^3 := by |
| have hh := Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg s (f := f) (p := 3) (by norm_num) hf |
| norm_num only [show (3 : ℝ)-1=2 by norm_num, Real.rpow_ofNat] at hh |
| exact hh |
|
|
| lemma sum_angular_power_le {ι : Type*} (s : Finset ι) (θ : ι → ℝ) |
| (hθ : ∀ i ∈ s, 0 ≤ θ i) {α : ℝ} (hα : 0 < α) (hα1 : α ≤ 1) : |
| (∑ i ∈ s, θ i ^ α) ≤ (s.card : ℝ)^(1-α) * (∑ i ∈ s, θ i)^α := by |
| by_cases hs : s.Nonempty |
| · have hc : 0 < (s.card : ℝ) := Nat.cast_pos.mpr hs.card_pos |
| have hh := Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg s |
| (f := fun i => θ i^α) (p := α⁻¹) ((one_le_inv₀ hα).mpr hα1) |
| (fun i hi => Real.rpow_nonneg (hθ i hi) α) |
| have hsum : 0 ≤ ∑ i ∈ s, θ i^α := Finset.sum_nonneg (fun i hi => Real.rpow_nonneg (hθ i hi) α) |
| have hsum' : 0 ≤ ∑ i ∈ s, θ i := Finset.sum_nonneg hθ |
| have hev (i : ι) (hi : i ∈ s) : (θ i^α)^α⁻¹ = θ i := Real.rpow_rpow_inv (hθ i hi) hα.ne' |
| simp_rw [Finset.sum_congr rfl hev] at hh |
| have hp := Real.rpow_le_rpow (Real.rpow_nonneg hsum _) hh hα.le |
| rw [← Real.rpow_mul hsum,inv_mul_cancel₀ hα.ne',Real.rpow_one, |
| Real.mul_rpow (Real.rpow_nonneg hc.le _) hsum',← Real.rpow_mul hc.le] at hp |
| have he : (α⁻¹-1)*α = 1-α := by |
| calc |
| (α⁻¹-1)*α = α⁻¹*α - α := by ring |
| _ = 1-α := by rw [inv_mul_cancel₀ hα.ne'] |
| rwa [he] at hp |
| · have he : s = ∅ := Finset.not_nonempty_iff_eq_empty.mp hs |
| simp only [he,Finset.sum_empty,Finset.card_empty,Nat.cast_zero] |
| rw [Real.zero_rpow hα.ne',mul_zero] |
|
|
| end PlanarHalving.Boundary |
|
|
| namespace PlanarHalving.Boundary |
| open Set Filter |
| open scoped Topology |
|
|
| lemma high_mass_bound {ι : Type*} (S : Finset ι) (lam s : ι → ℝ) |
| {q M H : ℝ} (hq : 0 < q) (hM : 0 < M) |
| (hlam : ∀ i ∈ S, lam i ≤ q⁻¹) |
| (htail : ∀ u > 0, ((S.filter fun i => u < s i).card : ℝ) ≤ H * u^(-(4:ℝ)/3)) : |
| ∑ i ∈ S with M*q^(-(3:ℝ)/4) < s i, lam i ≤ H*M^(-(4:ℝ)/3) := by |
| classical |
| let t := M*q^(-(3:ℝ)/4) |
| have ht : 0 < t := mul_pos hM (Real.rpow_pos_of_pos hq _) |
| have hpow : t^(-(4:ℝ)/3) = M^(-(4:ℝ)/3)*q := by |
| dsimp [t] |
| rw [Real.mul_rpow hM.le (Real.rpow_nonneg hq.le _),← Real.rpow_mul hq.le] |
| norm_num |
| have hp := mul_le_mul_of_nonneg_right (htail t ht) (inv_nonneg.mpr hq.le) |
| rw [hpow] at hp |
| have hbound := Finset.sum_le_sum (s := S.filter (fun i => t < s i)) |
| (f := lam) (g := fun _ => q⁻¹) (fun i hi => hlam i (Finset.mem_filter.mp hi).1) |
| simp only [Finset.sum_const, nsmul_eq_mul] at hbound |
| apply hbound.trans |
| convert hp using 1; field_simp |
|
|
| lemma activity_sum_bound {ι : Type*} (S : Finset ι) (μ b θ : ι → ℝ) |
| {q B B₀ T α : ℝ} (hq : 0 ≤ q) (hB : 0 ≤ B) (_hT : 0 ≤ T) |
| (hα : 0 < α) (hα1 : α ≤ 1) |
| (hcard : (S.card : ℝ) ≤ q) (hb : ∑ i ∈ S, b i ≤ B₀) |
| (hθ : ∀ i ∈ S, 0 ≤ θ i) (hθsum : ∑ i ∈ S, θ i ≤ T) |
| (hμ : ∀ i ∈ S, μ i ≤ 2*b i+B*θ i^α) : |
| ∑ i ∈ S, μ i ≤ 2*B₀+B*q^(1-α)*T^α := by |
| have hsum0 : 0 ≤ ∑ i ∈ S, θ i := Finset.sum_nonneg hθ |
| have hc := Real.rpow_le_rpow (Nat.cast_nonneg S.card) hcard (sub_nonneg.mpr hα1) |
| have hθp := Real.rpow_le_rpow hsum0 hθsum hα.le |
| have hpow := (sum_angular_power_le S θ hθ hα hα1).trans |
| (mul_le_mul hc hθp (Real.rpow_nonneg hsum0 _) (Real.rpow_nonneg hq _)) |
| have hsum := Finset.sum_le_sum hμ |
| simp only [Finset.sum_add_distrib, ← Finset.mul_sum] at hsum |
| have hm := mul_le_mul_of_nonneg_left hpow hB |
| nlinarith only [hsum,hb,hm] |
|
|
| lemma low_cube_bound {ι : Type*} (S : Finset ι) (lam μ s : ι → ℝ) |
| {q M A U : ℝ} (hq : 0 < q) (hM : 0 < M) (hA : 0 ≤ A) |
| (hcard : (S.card : ℝ) ≤ q) |
| (hlam : ∀ i ∈ S, 0 ≤ lam i) (hμ : ∀ i ∈ S, 0 ≤ μ i) (hs : ∀ i ∈ S, 0 ≤ s i) |
| (hmass : ∀ i ∈ S, (lam i)^3 ≤ A*(s i)^3*μ i) |
| (hμsum : ∑ i ∈ S, μ i ≤ U) : |
| (∑ i ∈ S with s i ≤ M*q^(-(3:ℝ)/4), lam i)^3 ≤ |
| A*M^3*q^(-(1:ℝ)/4)*U := by |
| classical |
| let t := M*q^(-(3:ℝ)/4) |
| let L := S.filter (fun i => s i ≤ t) |
| have ht : 0 < t := mul_pos hM (Real.rpow_pos_of_pos hq _) |
| have hL (i : ι) (hi : i ∈ L) : i ∈ S ∧ s i ≤ t := Finset.mem_filter.mp hi |
| have hμsumL : ∑ i ∈ L, μ i ≤ U := |
| (Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset ..) (fun i hi _ => hμ i hi)).trans hμsum |
| have hmassL : ∑ i ∈ L, (lam i)^3 ≤ A*t^3*U := by |
| calc |
| _ ≤ ∑ i ∈ L, A*t^3*μ i := by |
| apply Finset.sum_le_sum |
| intro i hi |
| apply (hmass i (hL i hi).1).trans |
| exact mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (hs i (hL i hi).1) (hL i hi).2 3) hA) |
| (hμ i (hL i hi).1) |
| _ = A*t^3 * ∑ i ∈ L, μ i := by rw [Finset.mul_sum] |
| _ ≤ A*t^3*U := mul_le_mul_of_nonneg_left hμsumL (by positivity) |
| have hc : (L.card : ℝ) ≤ q := (Nat.cast_le.mpr (Finset.card_filter_le ..)).trans hcard |
| have hcube := sum_cube_le L lam (fun i hi => hlam i (hL i hi).1) |
| have hsumlam : 0 ≤ ∑ i ∈ L, (lam i)^3 := by |
| exact Finset.sum_nonneg (fun i hi => pow_nonneg (hlam i (hL i hi).1) _) |
| have hc2 : (L.card : ℝ)^2 ≤ q^2 := by nlinarith [show (0:ℝ) ≤ L.card from Nat.cast_nonneg _] |
| have hbound := hcube.trans ((mul_le_mul_of_nonneg_right hc2 hsumlam).trans |
| (mul_le_mul_of_nonneg_left hmassL (sq_nonneg q))) |
| have he : q^2*t^3 = M^3*q^(-(1:ℝ)/4) := by |
| dsimp [t] |
| rw [mul_pow,← Real.rpow_mul_natCast hq.le] |
| simp only [Nat.cast_ofNat] |
| rw [← Real.rpow_ofNat q 2] |
| calc |
| q^(2:ℝ) * (M^3 * q^((-(3:ℝ)/4)*3)) = |
| M^3*(q^(2:ℝ)*q^((-(3:ℝ)/4)*3)) := by ring |
| _ = M^3*q^(-(1:ℝ)/4) := by rw [← Real.rpow_add hq]; congr 2; norm_num |
| change (∑ i ∈ L, lam i)^3 ≤ _ |
| calc |
| _ ≤ q^2*(A*t^3*U) := hbound |
| _ = A*(q^2*t^3)*U := by ring |
| _ = A*(M^3*q^(-(1:ℝ)/4))*U := by rw [he] |
| _ = A*M^3*q^(-(1:ℝ)/4)*U := by ring |
|
|
| end PlanarHalving.Boundary |
|
|
| namespace PlanarHalving.Boundary |
| open Set Filter |
| open scoped Topology |
|
|
| lemma low_bound_tendsto_zero {q : ℕ → ℝ} (hq : ∀ n, 0 < q n) |
| (hqtop : Tendsto q atTop atTop) {α : ℝ} (hα : (3:ℝ)/4 < α) |
| (A M B₀ B T : ℝ) : |
| Tendsto (fun n => A*M^3*(q n)^(-(1:ℝ)/4)* |
| (2*B₀+B*(q n)^(1-α)*T^α)) atTop (𝓝 0) := by |
| have h1 : Tendsto (fun n => (q n)^(-(1:ℝ)/4)) atTop (𝓝 0) := by |
| have hh := (tendsto_rpow_neg_atTop (show (0:ℝ)<1/4 by norm_num)).comp hqtop |
| convert hh using 1 |
| funext n |
| rw [Function.comp_apply,neg_div] |
| have h2 : Tendsto (fun n => (q n)^((3:ℝ)/4-α)) atTop (𝓝 0) := by |
| have hh := (tendsto_rpow_neg_atTop (sub_pos.mpr hα)).comp hqtop |
| convert hh using 1 |
| funext n |
| rw [Function.comp_apply,neg_sub] |
| have ht := (h1.const_mul (A*M^3*(2*B₀))).add |
| (h2.const_mul (A*M^3*B*T^α)) |
| simp only [mul_zero,add_zero] at ht |
| apply ht.congr |
| intro n |
| have he : (q n)^(-(1:ℝ)/4)*(q n)^(1-α) = (q n)^((3:ℝ)/4-α) := by |
| rw [← Real.rpow_add (hq n)] |
| congr 1 |
| ring |
| calc |
| _ = A*M^3*(2*B₀)*(q n)^(-(1:ℝ)/4) + |
| A*M^3*B*T^α*((q n)^(-(1:ℝ)/4)*(q n)^(1-α)) := by rw [he] |
| _ = _ := by ring |
|
|
| theorem mass_eq_zero {ι : Type*} (S : ℕ → Finset ι) |
| (lam μ s b θ : ℕ → ι → ℝ) (q : ℕ → ℝ) |
| {L A H B B₀ T α : ℝ} |
| (hL : 0 ≤ L) (hA : 0 ≤ A) (hB : 0 ≤ B) (hT : 0 ≤ T) |
| (hα : (3:ℝ)/4 < α) (hα1 : α ≤ 1) |
| (hq : ∀ n, 0 < q n) (hqtop : Tendsto q atTop atTop) |
| (hcard : ∀ n, ((S n).card : ℝ) ≤ q n) |
| (hlam0 : ∀ n i, i ∈ S n → 0 ≤ lam n i) |
| (hlam1 : ∀ n i, i ∈ S n → lam n i ≤ (q n)⁻¹) |
| (hμ0 : ∀ n i, i ∈ S n → 0 ≤ μ n i) |
| (hs0 : ∀ n i, i ∈ S n → 0 ≤ s n i) |
| (hθ0 : ∀ n i, i ∈ S n → 0 ≤ θ n i) |
| (hmass : ∀ n i, i ∈ S n → (lam n i)^3 ≤ A*(s n i)^3*μ n i) |
| (hactivity : ∀ n i, i ∈ S n → μ n i ≤ 2*b n i+B*(θ n i)^α) |
| (hbsum : ∀ n, ∑ i ∈ S n, b n i ≤ B₀) |
| (hθsum : ∀ n, ∑ i ∈ S n, θ n i ≤ T) |
| (htail : ∀ n u, 0 < u → ((S n |>.filter fun i => u < s n i).card : ℝ) ≤ |
| H*u^(-(4:ℝ)/3)) |
| (hpartition : ∀ n, L ≤ ∑ i ∈ S n, lam n i) : L = 0 := by |
| classical |
| by_contra hne |
| have hLp : 0 < L := lt_of_le_of_ne hL (Ne.symm hne) |
| have hdecay : Tendsto (fun M : ℝ => H*M^(-(4:ℝ)/3)) atTop (𝓝 0) := by |
| simpa only [neg_div,mul_zero] using |
| (tendsto_rpow_neg_atTop (show (0:ℝ)<4/3 by norm_num)).const_mul H |
| obtain ⟨M,hM,hMH⟩ : ∃ M : ℝ, 0 < M ∧ H*M^(-(4:ℝ)/3) < L/2 := by |
| have hev := (hdecay.eventually (eventually_lt_nhds (half_pos hLp))).and |
| (eventually_gt_atTop (0:ℝ)) |
| obtain ⟨M,h1,h2⟩ := hev.exists |
| exact ⟨M,h2,h1⟩ |
| have hμsum (n : ℕ) : ∑ i ∈ S n, μ n i ≤ |
| 2*B₀+B*(q n)^(1-α)*T^α := |
| activity_sum_bound (S n) (μ n) (b n) (θ n) (hq n).le hB hT |
| (by linarith) hα1 (hcard n) (hbsum n) (hθ0 n) (hθsum n) (hactivity n) |
| have hdecay2 := low_bound_tendsto_zero hq hqtop hα A M B₀ B T |
| have hthr : 0 < (L/2)^3 := pow_pos (half_pos hLp) _ |
| obtain ⟨n,hn⟩ := (hdecay2.eventually (eventually_lt_nhds hthr)).exists |
| have hhigh := high_mass_bound (S n) (lam n) (s n) (hq n) hM (hlam1 n) (htail n) |
| have hlow := low_cube_bound (S n) (lam n) (μ n) (s n) (hq n) hM hA |
| (hcard n) (hlam0 n) (hμ0 n) (hs0 n) (hmass n) (hμsum n) |
| have hlow' : (∑ i ∈ S n with s n i ≤ M*(q n)^(-(3:ℝ)/4), lam n i) < L/2 := by |
| by_contra hnot |
| have hlole : L/2 ≤ ∑ i ∈ S n with s n i ≤ M*(q n)^(-(3:ℝ)/4), lam n i := le_of_not_gt hnot |
| have hp := pow_le_pow_left₀ (half_pos hLp).le hlole 3 |
| exact (not_lt_of_ge (hp.trans hlow)) hn |
| have hsplit := Finset.sum_filter_add_sum_filter_not (S n) |
| (fun i => s n i ≤ M*(q n)^(-(3:ℝ)/4)) (lam n) |
| simp only [not_le] at hsplit |
| have htotal := hpartition n |
| linarith only [hhigh,hMH,hlow',hsplit,htotal] |
|
|
| end PlanarHalving.Boundary |
|
|
| namespace PlanarHalving.RankCoordinates |
| open Set |
|
|
| lemma exists_slope_avoiding (p : Point) (F : Finset Point) {l u : ℝ} |
| (hlu : l < u) (hp : p ∉ F) : |
| ∃ s ∈ Ioo l u, ∀ z ∈ F, z.2 ≠ p.2+s*(z.1-p.1) := by |
| classical |
| obtain ⟨s,hs,havoid⟩ := (Ioo_infinite hlu).exists_notMem_finset |
| (F.image (fun z => (z.2-p.2)/(z.1-p.1))) |
| refine ⟨s,hs,?_⟩ |
| intro z hz he |
| by_cases hx : z.1 = p.1 |
| · have heq : z = p := Prod.ext hx (by rw [hx,sub_self,mul_zero,add_zero] at he; exact he) |
| exact hp (heq ▸ hz) |
| · apply havoid |
| apply Finset.mem_image.mpr |
| refine ⟨z,hz,?_⟩ |
| apply (div_eq_iff (sub_ne_zero.mpr hx)).mpr |
| linarith only [he] |
|
|
| lemma exists_affine_avoiding (F : Finset Point) (s : ℝ) : |
| ∃ c : ℝ, ∀ z ∈ F, s*z.1+c ≠ z.2 := by |
| classical |
| obtain ⟨c,_,hc⟩ := (Set.infinite_univ : (Set.univ : Set ℝ).Infinite).exists_notMem_finset |
| (F.image (fun z => z.2-s*z.1)) |
| refine ⟨c,?_⟩ |
| intro z hz he |
| apply hc |
| exact Finset.mem_image.mpr ⟨z,hz,by linarith only [he]⟩ |
|
|
| end PlanarHalving.RankCoordinates |
|
|
| namespace PlanarHalving.Batches |
| open Set PlaneGraph RankCoordinates |
| variable {R : ℕ} |
|
|
| lemma ConvexPath.interior_slopes (C : ConvexPath R) {L U : ℝ} |
| (hLU : L < U) |
| (hedge : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → |
| L < slope (C.point b.castSucc) (C.point b.succ) ∧ |
| slope (C.point b.castSucc) (C.point b.succ) < U) : |
| ∃ l u : ℝ, L < l ∧ l ≤ u ∧ u < U ∧ |
| ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → |
| l < slope (C.point b.castSucc) (C.point b.succ) ∧ |
| slope (C.point b.castSucc) (C.point b.succ) < u := by |
| classical |
| let E := Finset.univ.filter (fun b : Fin R => C.point b.castSucc ≠ C.point b.succ) |
| by_cases he : E.Nonempty |
| · obtain ⟨b,hb,hbmin⟩ := Finset.exists_min_image E |
| (fun b => slope (C.point b.castSucc) (C.point b.succ)) he |
| obtain ⟨c,hc,hcmax⟩ := Finset.exists_max_image E |
| (fun b => slope (C.point b.castSucc) (C.point b.succ)) he |
| have hb' := (Finset.mem_filter.mp hb).2 |
| have hc' := (Finset.mem_filter.mp hc).2 |
| obtain ⟨l,hlL,hl⟩ := exists_between (hedge b hb').1 |
| obtain ⟨u,hu,huU⟩ := exists_between (hedge c hc').2 |
| refine ⟨l,u,hlL,((hl.trans_le (hbmin c hc)).trans hu).le,huU,?_⟩ |
| intro i hi |
| have hi' : i ∈ E := Finset.mem_filter.mpr ⟨Finset.mem_univ i,hi⟩ |
| exact ⟨hl.trans_le (hbmin i hi'),(hcmax i hi').trans_lt hu⟩ |
| · obtain ⟨l,hlL,hlU⟩ := exists_between hLU |
| refine ⟨l,l,hlL,le_rfl,hlU,?_⟩ |
| intro b hb |
| exact (he ⟨b,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb⟩⟩).elim |
| |
| lemma ConvexPath.exists_clean_extension (C : ConvexPath R) (F : Finset Point) |
| {L U : ℝ} (hLU : L < U) |
| (hp₀ : C.point 0 ∉ F) (hp₁ : C.point (Fin.last R) ∉ F) |
| (hedge : ∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → |
| L < slope (C.point b.castSucc) (C.point b.succ) ∧ |
| slope (C.point b.castSucc) (C.point b.succ) < U) : |
| ∃ l u : ℝ, L < l ∧ l ≤ u ∧ u < U ∧ |
| (∀ b : Fin R, C.point b.castSucc ≠ C.point b.succ → |
| l ≤ slope (C.point b.castSucc) (C.point b.succ) ∧ |
| slope (C.point b.castSucc) (C.point b.succ) ≤ u) ∧ |
| ∀ z ∈ F, C.extension l u z.1 = z.2 → |
| ∃ b : Fin R, C.point b.castSucc ≠ C.point b.succ ∧ |
| z ∈ segment ℝ (C.point b.castSucc) (C.point b.succ) := by |
| obtain ⟨l₀,u₀,hl₀,hlu₀,hu₀,hs₀⟩ := C.interior_slopes hLU hedge |
| obtain ⟨l,hl,hlavoid⟩ := exists_slope_avoiding (C.point 0) F hl₀ hp₀ |
| obtain ⟨u,hu,huavoid⟩ := exists_slope_avoiding (C.point (Fin.last R)) F hu₀ hp₁ |
| have hlu : l ≤ u := ((hl.2.trans_le hlu₀).trans hu.1).le |
| have hs (b : Fin R) (hb : C.point b.castSucc ≠ C.point b.succ) : |
| l ≤ slope (C.point b.castSucc) (C.point b.succ) ∧ |
| slope (C.point b.castSucc) (C.point b.succ) ≤ u := |
| ⟨(hl.2.trans (hs₀ b hb).1).le,((hs₀ b hb).2.trans hu.1).le⟩ |
| refine ⟨l,u,hl.1,hlu,hu.2,hs,?_⟩ |
| intro z hz hgraph |
| rcases C.extension_cases hlu hs hgraph with hleft | hright | hmiddle |
| · exact (hlavoid z hz hleft.2).elim |
| · exact (huavoid z hz hright.2).elim |
| · exact hmiddle |
| |
| end PlanarHalving.Batches |
| |
| namespace PlanarHalving.RankCoordinates |
| open Set |
| |
| noncomputable def slot {ι : Type*} [Fintype ι] (g : ι → ℝ → ℝ) (p : Point) : ℕ := |
| (Finset.univ.filter (fun i => g i p.1 < p.2)).card |
| |
| lemma slot_lt_of_le_imp_lt {ι : Type*} [Fintype ι] (g : ι → ℝ → ℝ) |
| {p q : Point} (h : ∀ i, g i p.1 ≤ p.2 → g i q.1 < q.2) |
| (hp : ∃ i, g i p.1 = p.2) : slot g p < slot g q := by |
| classical |
| apply Finset.card_lt_card |
| apply Finset.ssubset_iff_subset_ne.mpr |
| refine ⟨?_,?_⟩ |
| · intro i hi |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,h i (Finset.mem_filter.mp hi).2.le⟩ |
| · obtain ⟨i,hi⟩ := hp |
| intro he |
| have hiq : i ∈ Finset.univ.filter (fun i => g i q.1 < q.2) := |
| Finset.mem_filter.mpr ⟨Finset.mem_univ _,h i hi.le⟩ |
| rw [← he] at hiq |
| exact (lt_irrefl (p.2)) (hi ▸ (Finset.mem_filter.mp hiq).2) |
| |
| lemma slot_chord_bounds {ι : Type*} [Fintype ι] (g : ι → ℝ → ℝ) |
| {l u : ℝ} |
| (hs : ∀ i x y, x ≤ y → l*(y-x) ≤ g i y-g i x ∧ g i y-g i x ≤ u*(y-x)) |
| {p q : Point} (hx : p.1 ≤ q.1) (hp : ∃ i, g i p.1 = p.2) |
| (hq : ∃ i, g i q.1 = q.2) (he : slot g p = slot g q) : |
| l*(q.1-p.1) ≤ q.2-p.2 ∧ q.2-p.2 ≤ u*(q.1-p.1) := by |
| constructor |
| · by_contra hn |
| have ht := slot_lt_of_le_imp_lt g (p := q) (q := p) (fun i hi => by |
| have hh := (hs i p.1 q.1 hx).1 |
| linarith only [hh,hi,lt_of_not_ge hn]) hq |
| exact (ne_of_lt ht) he.symm |
| · by_contra hn |
| have ht := slot_lt_of_le_imp_lt g (p := p) (q := q) (fun i hi => by |
| have hh := (hs i p.1 q.1 hx).2 |
| linarith only [hh,hi,lt_of_not_ge hn]) hp |
| exact (ne_of_lt ht) he |
| |
| theorem pair_slots_injOn {ι κ : Type*} [Fintype ι] [Fintype κ] |
| (g : ι → ℝ → ℝ) (h : κ → ℝ → ℝ) {l u l' u' : ℝ} |
| (hg : ∀ i x y, x ≤ y → l*(y-x) ≤ g i y-g i x ∧ g i y-g i x ≤ u*(y-x)) |
| (hh : ∀ i x y, x ≤ y → l'*(y-x) ≤ h i y-h i x ∧ h i y-h i x ≤ u'*(y-x)) |
| (hgap : u < l') (S : Set Point) |
| (hS : ∀ p ∈ S, (∃ i, g i p.1 = p.2) ∧ ∃ j, h j p.1 = p.2) : |
| Set.InjOn (fun p => (slot g p,slot h p)) S := by |
| have horder {p q : Point} (hp : p ∈ S) (hq : q ∈ S) |
| (he : (slot g p,slot h p) = (slot g q,slot h q)) : ¬ p.1 < q.1 := by |
| intro hx |
| have hg' := (slot_chord_bounds g hg hx.le (hS p hp).1 (hS q hq).1 (congrArg Prod.fst he)).2 |
| have hh' := (slot_chord_bounds h hh hx.le (hS p hp).2 (hS q hq).2 (congrArg Prod.snd he)).1 |
| have hstrict := mul_lt_mul_of_pos_right hgap (sub_pos.mpr hx) |
| linarith only [hg',hh',hstrict] |
| intro p hp q hq he |
| have hx : p.1 = q.1 := le_antisymm (le_of_not_gt (horder hq hp he.symm)) (le_of_not_gt (horder hp hq he)) |
| have hy := slot_chord_bounds g hg hx.le (hS p hp).1 (hS q hq).1 (congrArg Prod.fst he) |
| rw [hx,sub_self,mul_zero,mul_zero] at hy |
| exact Prod.ext hx (by linarith only [hy.1,hy.2]) |
|
|
| lemma slot_lt_card {ι : Type*} [Fintype ι] (g : ι → ℝ → ℝ) {p : Point} |
| (hp : ∃ i, g i p.1 = p.2) : slot g p < Fintype.card ι := by |
| classical |
| apply lt_of_lt_of_eq (Finset.card_lt_card ?_) (Finset.card_univ : _ = Fintype.card ι) |
| apply Finset.ssubset_iff_subset_ne.mpr |
| refine ⟨Finset.filter_subset ..,?_⟩ |
| obtain ⟨i,hi⟩ := hp |
| intro he |
| have hmem := Finset.mem_univ i |
| rw [← he] at hmem |
| exact (lt_irrefl (p.2)) (hi ▸ (Finset.mem_filter.mp hmem).2) |
|
|
| end PlanarHalving.RankCoordinates |
|
|
| end OAI |
|
|
