File size: 4,933 Bytes
785c727 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | import OAI.Geometry.CoveringDensity.EuclideanTransport
import OAI.Geometry.TranslativeCovering.Main
namespace OAI
namespace CoveringOrder
open Set MeasureTheory
open scoped ENNReal
theorem euclideanVolume_eq_volume (n : ℕ) : euclideanVolume n = volume :=
(PiLp.volume_preserving_toLp (Fin n)).map_eq
theorem euclideanCovolume_eq_ofReal {n : ℕ} (lattice : Submodule ℤ (Space n))
[DiscreteTopology lattice] [IsZLattice ℝ lattice] :
euclideanCovolume lattice = ENNReal.ofReal (ZLattice.covolume lattice volume) := by
rw [euclideanCovolume, euclideanVolume_eq_volume, ZLattice.covolume]
apply (ENNReal.ofReal_toReal ?_).symm
intro htop
apply ZLattice.covolume_ne_zero lattice volume
simp only [ZLattice.covolume, htop, ENNReal.toReal_top]
theorem latticeDensity_eq_volume_div_covolume {n : ℕ} {K : Set (Space n)}
(cover : LatticeCover K) :
latticeDensity cover = volume K / ENNReal.ofReal (ZLattice.covolume cover.lattice volume) := by
let := cover.discrete
let := cover.fullrank
simp only [latticeDensity, euclideanVolume_eq_volume, euclideanCovolume_eq_ofReal]
/-- The infimum of actual lattice densities agrees with indexing by bundled covers. -/
theorem thetaL_eq_iInf_latticeCover {n : ℕ} (K : Set (Space n)) :
thetaL K = ⨅ P : LatticeCover K,
volume K / ENNReal.ofReal (ZLattice.covolume P.lattice volume) := by
unfold thetaL
exact iInf_congr latticeDensity_eq_volume_div_covolume
/-- A single lattice is a one-coset periodic covering. -/
def LatticeCover.toPeriodic {n : ℕ} {K : Set (Space n)} (P : LatticeCover K) :
TranslativeCovering.PeriodicCover K where
lattice := P.lattice
discrete := P.discrete
fullrank := P.fullrank
m := 1
offsets := fun _ => 0
covers := by
intro y
obtain ⟨l, hl⟩ := P.covers y
exact ⟨0, l, by simpa using hl⟩
/-- Full periodization, followed by restriction to one-coset coverings. -/
theorem thetaT_le_thetaL {n : ℕ} {K : Set (Space n)}
(hK : TranslativeCovering.ConvexBody K) :
TranslativeCovering.thetaT K ≤ thetaL K := by
rw [thetaL_eq_iInf_latticeCover, TranslativeCovering.periodization_exact hK,
← TranslativeCovering.listed_eq_distinct K]
apply le_iInf
intro P
have h := iInf_le
(fun Q : TranslativeCovering.PeriodicCover K => volume K * Q.intensity)
P.toPeriodic
simpa only [TranslativeCovering.thetaPerListed,
TranslativeCovering.PeriodicCover.intensity, LatticeCover.toPeriodic,
Nat.cast_one, one_div, div_eq_mul_inv, one_mul] using h
/-- The transported upper theorem bounds the actual lattice-density infimum. -/
theorem uniform_lattice_density_upper :
∃ C : ℝ, 0 < C ∧ ∀ n : ℕ, 2 ≤ n → ∀ K : Set (Space n),
TranslativeCovering.ConvexBody K →
thetaL K ≤ ENNReal.ofReal (C * (n : ℝ) * Real.log (n : ℝ)) := by
obtain ⟨C, hC, h⟩ := euclidean_lattice_upper
refine ⟨C, hC, ?_⟩
intro n hn K hK
obtain ⟨L, hd, hf, hc, hb⟩ := h n hn K hK
let P : LatticeCover K := ⟨L, hd, hf, hc⟩
rw [thetaL_eq_iInf_latticeCover]
exact (iInf_le (fun Q : LatticeCover K =>
volume K / ENNReal.ofReal (ZLattice.covolume Q.lattice volume)) P).trans hb
/-- All four density suprema have order `n * log n` with common absolute constants. -/
theorem optimal_order : OptimalOrder := by
obtain ⟨c, hc, n₀, hlower⟩ := TranslativeCovering.main
obtain ⟨C, hC, hupper⟩ := uniform_lattice_density_upper
refine ⟨c, C, hc, hC, max n₀ 2, ?_⟩
intro n hn
have hn₀ : n₀ ≤ n := (le_max_left _ _).trans hn
have hn₂ : 2 ≤ n := (le_max_right _ _).trans hn
obtain ⟨K, hK, hsym, hlow⟩ := hlower n hn₀
let B : Body n := ⟨K, hK⟩
let S : SymmetricBody n := ⟨B, hsym⟩
have t_upper (A : Body n) :
TranslativeCovering.thetaT A.val ≤
ENNReal.ofReal (C * (n : ℝ) * Real.log (n : ℝ)) :=
(thetaT_le_thetaL A.property).trans (hupper n hn₂ A.val A.property)
have l_upper (A : Body n) :
thetaL A.val ≤ ENNReal.ofReal (C * (n : ℝ) * Real.log (n : ℝ)) :=
hupper n hn₂ A.val A.property
have tl : ENNReal.ofReal (c * (n : ℝ) * Real.log (n : ℝ)) ≤
TranslativeCovering.thetaT K := hlow.le
have ll : ENNReal.ofReal (c * (n : ℝ) * Real.log (n : ℝ)) ≤ thetaL K :=
tl.trans (thetaT_le_thetaL hK)
refine ⟨⟨?_, ?_⟩, ⟨?_, ?_⟩, ⟨?_, ?_⟩, ⟨?_, ?_⟩⟩
· exact tl.trans (le_iSup (fun A : Body n => TranslativeCovering.thetaT A.val) B)
· exact iSup_le t_upper
· exact tl.trans (le_iSup
(fun A : SymmetricBody n => TranslativeCovering.thetaT A.val.val) S)
· exact iSup_le (fun A : SymmetricBody n => t_upper A.val)
· exact ll.trans (le_iSup (fun A : Body n => thetaL A.val) B)
· exact iSup_le l_upper
· exact ll.trans (le_iSup (fun A : SymmetricBody n => thetaL A.val.val) S)
· exact iSup_le (fun A : SymmetricBody n => l_upper A.val)
end CoveringOrder
end OAI
|