| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Honeycomb triangle chords, visit sums and positive finite means. -/ |
|
|
| noncomputable section |
|
|
| open scoped ENNReal Topology |
| open Filter MeasureTheory |
|
|
| namespace DiskBoundary |
|
|
| structure Vertex where |
| j : ℤ |
| k : ℤ |
| b : Bool |
| deriving DecidableEq, Countable |
|
|
| structure Port where |
| j : ℤ |
| k : ℤ |
| dir : Fin 3 |
| deriving DecidableEq, Countable |
|
|
| def direction : Fin 3 → ℂ |
| | 0 => ⟨Real.sqrt 3 / 2, 1 / 2⟩ |
| | 1 => ⟨-(Real.sqrt 3 / 2), 1 / 2⟩ |
| | 2 => ⟨0, -1⟩ |
|
|
| def U : ℂ := direction 0 - direction 1 |
|
|
| def V : ℂ := direction 0 - direction 2 |
|
|
| def position (v : Vertex) : ℂ := |
| (v.j : ℂ) * U + (v.k : ℂ) * V + if v.b then direction 0 else 0 |
|
|
| def edgeA (p : Port) : Vertex := ⟨p.j, p.k, false⟩ |
|
|
| def edgeB (p : Port) : Vertex := |
| match p.dir with |
| | 0 => ⟨p.j, p.k, true⟩ |
| | 1 => ⟨p.j - 1, p.k, true⟩ |
| | 2 => ⟨p.j, p.k - 1, true⟩ |
|
|
| def portPosition (p : Port) : ℂ := (position (edgeA p) + position (edgeB p)) / 2 |
|
|
| def Incident (p : Port) (v : Vertex) : Prop := v = edgeA p ∨ v = edgeB p |
|
|
| def Adj (v w : Vertex) : Prop := |
| ∃ p : Port, (v = edgeA p ∧ w = edgeB p) ∨ (v = edgeB p ∧ w = edgeA p) |
|
|
| def BoundaryPort (D : Set Vertex) (p : Port) : Prop := |
| (edgeA p ∈ D ∧ edgeB p ∉ D) ∨ (edgeB p ∈ D ∧ edgeA p ∉ D) |
|
|
| structure PortPath where |
| source : Port |
| target : Port |
| vertices : List Vertex |
| nonempty : vertices ≠ [] |
| nodup : vertices.Nodup |
| chain : vertices.IsChain Adj |
| first_incident : Incident source (vertices.head nonempty) |
| last_incident : Incident target (vertices.getLast nonempty) |
| distinct_ports : source ≠ target |
|
|
| namespace PortPath |
|
|
| def length (γ : PortPath) : ℕ := γ.vertices.length |
|
|
| def joints (γ : PortPath) : List ℂ := |
| portPosition γ.source :: (γ.vertices.map position ++ [portPosition γ.target]) |
|
|
| def trace (γ : PortPath) : Set ℂ := |
| {z | z ∈ γ.joints} ∪ |
| {z | ∃ p ∈ γ.joints.zip γ.joints.tail, z ∈ segment ℝ p.1 p.2} |
|
|
| def diameter (γ : PortPath) : ℝ := Metric.diam γ.trace |
|
|
| def height (γ : PortPath) : ℝ := |
| sSup ((fun z : ℂ => |z.im + 1 / 2|) '' γ.trace) |
|
|
| end PortPath |
|
|
| instance : MeasurableSpace PortPath := ⊤ |
| instance : MeasurableSingletonClass PortPath := ⟨fun _ => trivial⟩ |
|
|
| def IsChord (D : Set Vertex) (γ : PortPath) : Prop := |
| (∀ v ∈ γ.vertices, v ∈ D) ∧ BoundaryPort D γ.source ∧ BoundaryPort D γ.target |
|
|
| abbrev Chord (D : Set Vertex) := {γ : PortPath // IsChord D γ} |
|
|
| def criticalPoint : ℝ := (Real.sqrt (2 + Real.sqrt 2))⁻¹ |
|
|
| def weight (γ : PortPath) : ℝ≥0∞ := ENNReal.ofReal (criticalPoint ^ γ.length) |
|
|
| def pathMeasure {Ω : Type*} [MeasurableSpace Ω] (path : Ω → PortPath) : Measure Ω := |
| Measure.sum (fun γ => weight (path γ) • Measure.dirac γ) |
|
|
| def Normalizable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) (E : Set Ω) : Prop := |
| 0 < μ E ∧ μ E < ∞ |
|
|
| def normalize {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) (E : Set Ω) : Measure Ω := |
| (μ E)⁻¹ • μ.restrict E |
|
|
| def dot (z w : ℂ) : ℝ := z.re * w.re + z.im * w.im |
|
|
| def halfPlane : Set Vertex := {v | dot (direction 2) (position v) < 1 / 2} |
|
|
| def wallPort (m : ℤ) : Port := ⟨m, 0, 2⟩ |
|
|
| abbrev Arch := {γ : Chord halfPlane // |
| γ.val.source = wallPort 0 ∧ ∃ m : ℤ, m ≠ 0 ∧ γ.val.target = wallPort m} |
|
|
| def Arch.path (γ : Arch) : PortPath := γ.val.val |
|
|
| def μ : Measure Arch := pathMeasure Arch.path |
|
|
| def archKernel (m : ℕ) : ℝ≥0∞ := |
| μ {γ | γ.path.target = wallPort (m : ℤ)} |
|
|
| def heightTail (R : ℝ) : ℝ≥0∞ := μ {γ | R < γ.path.height} |
|
|
| def diameterTail (R : ℝ) : ℝ≥0∞ := μ {γ | R < γ.path.diameter} |
|
|
| def diameterWindow (C R : ℝ) : Set Arch := |
| {γ | R ≤ γ.path.diameter ∧ γ.path.diameter ≤ C * R} |
|
|
| def heightWindow (C R : ℝ) : Set Arch := |
| {γ | R ≤ γ.path.height ∧ γ.path.diameter ≤ C * R} |
|
|
| def archMean (E : Set Arch) : ℝ≥0∞ := |
| ∫⁻ γ, (γ.path.length : ℝ≥0∞) ∂normalize μ E |
|
|
| def triangle (R : ℝ) : Set ℂ := {z | ∀ i : Fin 3, dot (direction i) z < R} |
|
|
| def triangleVertices (R : ℝ) : Set Vertex := position ⁻¹' triangle R |
|
|
| def innerVertices (ε R : ℝ) : Set Vertex := triangleVertices ((1 - ε) * R) |
|
|
| def triangleMeasure (R : ℝ) : Measure (Chord (triangleVertices R)) := |
| pathMeasure Subtype.val |
|
|
| def hitsInner (ε R : ℝ) : Set (Chord (triangleVertices R)) := |
| {γ | ∃ v ∈ γ.val.vertices, v ∈ innerVertices ε R} |
|
|
| def triangleLaw (ε R : ℝ) : Measure (Chord (triangleVertices R)) := |
| normalize (triangleMeasure R) (hitsInner ε R) |
|
|
| def visitProbability (ε R : ℝ) (v : Vertex) : ℝ≥0∞ := |
| triangleLaw ε R {γ | v ∈ γ.val.vertices} |
|
|
| def triangleMean (ε R : ℝ) : ℝ≥0∞ := |
| ∫⁻ γ, (γ.val.length : ℝ≥0∞) ∂triangleLaw ε R |
|
|
| def innerCount (ε R : ℝ) (γ : PortPath) : ℕ := by |
| classical |
| exact (γ.vertices.toFinset.filter (fun v => v ∈ innerVertices ε R)).card |
|
|
| def triangleInnerMean (ε R : ℝ) : ℝ≥0∞ := |
| ∫⁻ γ, (innerCount ε R γ.val : ℝ≥0∞) ∂triangleLaw ε R |
|
|
| def admissibleLevels : Set ℝ := {R | ∃ n : ℤ, R = 1 / 2 + (3 / 2) * n} |
|
|
| def wallFilter : Filter ℝ := atTop ⊓ Filter.principal admissibleLevels |
|
|
| def ComparablePower {ι : Type*} (L : Filter ι) (scale : ι → ℝ) |
| (f : ι → ℝ≥0∞) (a : ℝ) : Prop := |
| ∃ c : ℝ, 0 < c ∧ ∃ C : ℝ, 0 < C ∧ |
| ∀ᶠ t in L, ENNReal.ofReal (c * (scale t) ^ a) ≤ f t ∧ |
| f t ≤ ENNReal.ofReal (C * (scale t) ^ a) |
|
|
| def HasExponent {ι : Type*} (L : Filter ι) (scale : ι → ℝ) |
| (f : ι → ℝ≥0∞) (a : ℝ) : Prop := |
| (∀ᶠ t in L, 0 < f t ∧ f t < ∞) ∧ |
| Tendsto (fun t => Real.log (f t).toReal / Real.log (scale t)) L (𝓝 a) |
|
|
| def UniformVisitExponent (ε a : ℝ) : Prop := |
| ∀ δ : ℝ, 0 < δ → ∀ᶠ R in wallFilter, ∀ v ∈ innerVertices ε R, |
| 0 < visitProbability ε R v ∧ visitProbability ε R v < ∞ ∧ |
| |Real.log (visitProbability ε R v).toReal / Real.log R - a| < δ |
|
|
| def SharpBoundaryMassAndAnnealedChordLaws : Prop := |
| (AntitoneOn archKernel (Set.Ici 1) ∧ |
| ComparablePower atTop (fun m : ℕ => (m : ℝ)) archKernel (-(5 / 4 : ℝ)) ∧ |
| ComparablePower atTop id heightTail (-(1 / 4 : ℝ)) ∧ |
| ComparablePower atTop id diameterTail (-(1 / 4 : ℝ))) ∧ |
| (∃ C₀ : ℝ, 1 < C₀ ∧ ∀ C : ℝ, C₀ ≤ C → |
| (∀ᶠ R : ℝ in atTop, |
| Normalizable μ (diameterWindow C R) ∧ Normalizable μ (heightWindow C R)) ∧ |
| HasExponent atTop id (fun R => archMean (diameterWindow C R)) (4 / 3) ∧ |
| HasExponent atTop id (fun R => archMean (heightWindow C R)) (4 / 3)) ∧ |
| (∃ ε₀ : ℝ, 0 < ε₀ ∧ ε₀ < 1 ∧ ∀ ε : ℝ, 0 < ε → ε ≤ ε₀ → |
| (∀ᶠ R in wallFilter, Normalizable (triangleMeasure R) (hitsInner ε R)) ∧ |
| UniformVisitExponent ε (-(2 / 3 : ℝ)) ∧ |
| HasExponent wallFilter id (triangleMean ε) (4 / 3) ∧ |
| HasExponent wallFilter id (triangleInnerMean ε) (4 / 3)) |
|
|
| @[ext] |
| theorem Vertex.ext {v w : Vertex} (hj : v.j = w.j) |
| (hk : v.k = w.k) (hb : v.b = w.b) : v = w := by |
| cases v |
| cases w |
| cases hj |
| cases hk |
| cases hb |
| rfl |
|
|
| @[ext] |
| theorem PortPath.ext {γ η : PortPath} (hs : γ.source = η.source) |
| (ht : γ.target = η.target) (hv : γ.vertices = η.vertices) : γ = η := by |
| cases γ |
| cases η |
| cases hs |
| cases ht |
| cases hv |
| rfl |
|
|
| instance : Countable PortPath := by |
| apply Function.Injective.countable |
| (f := fun γ : PortPath => (γ.source, γ.target, γ.vertices)) |
| intro γ η h |
| exact PortPath.ext (congrArg (fun x => x.1) h) |
| (congrArg (fun x => x.2.1) h) (congrArg (fun x => x.2.2) h) |
|
|
| theorem PortPath.length_pos (γ : PortPath) : 0 < γ.length := by |
| exact List.length_pos_iff.mpr γ.nonempty |
|
|
| theorem criticalPoint_pos : 0 < criticalPoint := by |
| unfold criticalPoint |
| positivity |
|
|
| theorem criticalPoint_lt_one : criticalPoint < 1 := by |
| unfold criticalPoint |
| have h : 1 < Real.sqrt (2 + Real.sqrt 2) := by |
| apply (Real.lt_sqrt (by norm_num)).mpr |
| have := Real.sqrt_nonneg 2 |
| linarith |
| exact (inv_lt_one₀ (by positivity)).mpr h |
|
|
| theorem weight_pos (γ : PortPath) : 0 < weight γ := by |
| exact ENNReal.ofReal_pos.mpr (pow_pos criticalPoint_pos _) |
|
|
| theorem weight_lt_top (γ : PortPath) : weight γ < ∞ := ENNReal.ofReal_lt_top |
|
|
| theorem weight_le_one (γ : PortPath) : weight γ ≤ 1 := by |
| unfold weight |
| rw [ENNReal.ofReal_le_one] |
| exact pow_le_one₀ criticalPoint_pos.le criticalPoint_lt_one.le |
|
|
| theorem pathMeasure_apply {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] (path : Ω → PortPath) (E : Set Ω) : |
| pathMeasure path E = ∑' γ, E.indicator (fun γ => weight (path γ)) γ := by |
| classical |
| rw [pathMeasure, Measure.sum_apply_of_countable] |
| apply tsum_congr |
| intro γ |
| by_cases h : γ ∈ E <;> simp [Measure.smul_apply, Measure.dirac_apply, h] |
|
|
| theorem pathMeasure_singleton {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] (path : Ω → PortPath) (γ : Ω) : |
| pathMeasure path {γ} = weight (path γ) := by |
| classical |
| rw [pathMeasure_apply] |
| simp |
|
|
| theorem lintegral_pathMeasure {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] (path : Ω → PortPath) (f : Ω → ℝ≥0∞) : |
| ∫⁻ γ, f γ ∂pathMeasure path = ∑' γ, weight (path γ) * f γ := by |
| simp [pathMeasure, lintegral_sum_measure, lintegral_smul_measure, lintegral_dirac] |
|
|
| theorem normalize_apply {Ω : Type*} [MeasurableSpace Ω] |
| (ν : Measure Ω) (E F : Set Ω) (hF : MeasurableSet F) : |
| normalize ν E F = (ν E)⁻¹ * ν (F ∩ E) := by |
| simp [normalize, Measure.restrict_apply hF, smul_eq_mul] |
|
|
| theorem normalize_univ {Ω : Type*} [MeasurableSpace Ω] |
| (ν : Measure Ω) (E : Set Ω) (hE : Normalizable ν E) : |
| normalize ν E Set.univ = 1 := by |
| rw [normalize_apply _ _ _ MeasurableSet.univ, Set.univ_inter] |
| exact ENNReal.inv_mul_cancel hE.1.ne' hE.2.ne |
|
|
| theorem normalize_isProbabilityMeasure {Ω : Type*} [MeasurableSpace Ω] |
| (ν : Measure Ω) (E : Set Ω) (hE : Normalizable ν E) : |
| IsProbabilityMeasure (normalize ν E) := ⟨normalize_univ ν E hE⟩ |
|
|
| theorem normalized_atom {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] (path : Ω → PortPath) |
| (E : Set Ω) {γ : Ω} (hγ : γ ∈ E) : |
| normalize (pathMeasure path) E {γ} = |
| (pathMeasure path E)⁻¹ * weight (path γ) := by |
| rw [normalize_apply _ _ _ (measurableSet_singleton γ), |
| Set.inter_eq_left.mpr (Set.singleton_subset_iff.mpr hγ), pathMeasure_singleton] |
|
|
| theorem position_re (v : Vertex) : |
| (position v).re = (v.j : ℝ) * Real.sqrt 3 + |
| (v.k : ℝ) * (Real.sqrt 3 / 2) + if v.b then Real.sqrt 3 / 2 else 0 := by |
| cases v with |
| | mk j k b => |
| cases b <;> simp [position, U, V, direction, Complex.mul_re] |
|
|
| theorem position_im (v : Vertex) : |
| (position v).im = (v.k : ℝ) * (3 / 2) + if v.b then 1 / 2 else 0 := by |
| cases v with |
| | mk j k b => |
| cases b <;> norm_num [position, U, V, direction, Complex.mul_im] |
|
|
| theorem edge_displacement (p : Port) : |
| position (edgeB p) - position (edgeA p) = direction p.dir := by |
| rcases p with ⟨j, k, d⟩ |
| fin_cases d <;> simp [edgeA, edgeB, position, U, V, direction] <;> ring |
|
|
| theorem direction_normSq (i : Fin 3) : Complex.normSq (direction i) = 1 := by |
| have h : Real.sqrt 3 ^ 2 = 3 := Real.sq_sqrt (by norm_num) |
| fin_cases i <;> norm_num [direction, Complex.normSq_apply] <;> nlinarith |
|
|
| theorem direction_norm (i : Fin 3) : ‖direction i‖ = 1 := by |
| have := direction_normSq i |
| rw [← Complex.sq_norm] at this |
| have := norm_nonneg (direction i) |
| nlinarith |
|
|
| theorem edge_length (p : Port) : dist (position (edgeA p)) (position (edgeB p)) = 1 := by |
| rw [dist_comm, dist_eq_norm, edge_displacement, direction_norm] |
|
|
| theorem position_injective : Function.Injective position := by |
| intro v w h |
| rcases v with ⟨j, k, b⟩ |
| rcases w with ⟨j', k', b'⟩ |
| have hi := congrArg Complex.im h |
| have hr := congrArg Complex.re h |
| rw [position_im, position_im] at hi |
| rw [position_re, position_re] at hr |
| have hs : 0 < Real.sqrt 3 := Real.sqrt_pos.mpr (by norm_num) |
| cases b <;> cases b' <;> simp only [Bool.false_eq_true, ↓reduceIte, add_zero] at hi hr ⊢ |
| · have hk : k = k' := by exact_mod_cast (show (k : ℝ) = k' by linarith) |
| subst k' |
| have hj : j = j' := by |
| exact_mod_cast (show (j : ℝ) = j' by nlinarith) |
| subst j' |
| rfl |
| · have hk : 3 * k = 3 * k' + 1 := by |
| exact_mod_cast (show (3 : ℝ) * k = 3 * k' + 1 by linarith) |
| omega |
| · have hk : 3 * k + 1 = 3 * k' := by |
| exact_mod_cast (show (3 : ℝ) * k + 1 = 3 * k' by linarith) |
| omega |
| · have hk : k = k' := by exact_mod_cast (show (k : ℝ) = k' by linarith) |
| subst k' |
| have hj : j = j' := by |
| exact_mod_cast (show (j : ℝ) = j' by nlinarith) |
| subst j' |
| rfl |
|
|
| theorem mem_halfPlane_iff (v : Vertex) : v ∈ halfPlane ↔ -1 / 2 < (position v).im := by |
| simp only [halfPlane, Set.mem_ofPred_eq, dot, direction, zero_mul, neg_mul, |
| one_mul, zero_add] |
| constructor <;> intro h <;> linarith |
|
|
| theorem wallPort_position (m : ℤ) : |
| portPosition (wallPort m) = ⟨(m : ℝ) * Real.sqrt 3, -1 / 2⟩ := by |
| apply Complex.ext <;> |
| simp [portPosition, wallPort, edgeA, edgeB, position_re, position_im] |
| ring |
|
|
| theorem wallPort_boundary (m : ℤ) : BoundaryPort halfPlane (wallPort m) := by |
| left |
| norm_num [wallPort, edgeA, edgeB, mem_halfPlane_iff, position_im] |
|
|
| theorem PortPath.source_mem_trace (γ : PortPath) : portPosition γ.source ∈ γ.trace := by |
| left |
| simp [joints] |
|
|
| theorem PortPath.target_mem_trace (γ : PortPath) : portPosition γ.target ∈ γ.trace := by |
| left |
| simp [joints] |
|
|
| theorem PortPath.vertex_mem_trace (γ : PortPath) {v : Vertex} (hv : v ∈ γ.vertices) : |
| position v ∈ γ.trace := by |
| left |
| simp only [joints, List.mem_cons, List.mem_append, List.mem_map] |
| exact Or.inr (Or.inl ⟨v, hv, rfl⟩) |
|
|
| theorem PortPath.trace_isCompact (γ : PortPath) : IsCompact γ.trace := by |
| refine γ.joints.finite_toSet.isCompact.union ?_ |
| have h := (γ.joints.zip γ.joints.tail).finite_toSet.isCompact_biUnion |
| (fun p _ => ?_ : ∀ p ∈ γ.joints.zip γ.joints.tail, IsCompact (segment ℝ p.1 p.2)) |
| · convert h using 1 |
| ext z |
| simp |
| · rw [segment_eq_image_lineMap] |
| exact isCompact_Icc.image AffineMap.lineMap_continuous |
|
|
| theorem PortPath.trace_nonempty (γ : PortPath) : γ.trace.Nonempty := |
| ⟨_, γ.source_mem_trace⟩ |
|
|
| theorem Arch.height_le_diameter (γ : Arch) : γ.path.height ≤ γ.path.diameter := by |
| have hs : (portPosition γ.path.source).im = -1 / 2 := by |
| rw [show γ.path.source = wallPort 0 from γ.property.1, wallPort_position] |
| apply csSup_le (γ.path.trace_nonempty.image _) |
| rintro _ ⟨z, hz, rfl⟩ |
| calc |
| |z.im + 1 / 2| = |(z - portPosition γ.path.source).im| := by |
| congr 1 |
| simp only [Complex.sub_im, hs] |
| ring |
| _ ≤ ‖z - portPosition γ.path.source‖ := Complex.abs_im_le_norm _ |
| _ = dist z (portPosition γ.path.source) := (dist_eq_norm _ _).symm |
| _ ≤ γ.path.diameter := Metric.dist_le_diam_of_mem γ.path.trace_isCompact.isBounded |
| hz γ.path.source_mem_trace |
|
|
| theorem heightTail_le_diameterTail (R : ℝ) : heightTail R ≤ diameterTail R := by |
| apply measure_mono |
| intro γ h |
| exact lt_of_lt_of_le h (Arch.height_le_diameter γ) |
|
|
| theorem heightTail_antitone : Antitone heightTail := by |
| intro R S hRS |
| exact measure_mono (fun _ h => lt_of_le_of_lt hRS h) |
|
|
| theorem diameterTail_antitone : Antitone diameterTail := by |
| intro R S hRS |
| exact measure_mono (fun _ h => lt_of_le_of_lt hRS h) |
|
|
| theorem dot_zero_position (v : Vertex) : |
| dot (direction 0) (position v) = |
| (3 / 2 : ℝ) * ((v.j : ℝ) + (v.k : ℝ)) + if v.b then 1 else 0 := by |
| have hs : Real.sqrt 3 ^ 2 = 3 := Real.sq_sqrt (by norm_num) |
| rcases v with ⟨j, k, b⟩ |
| cases b <;> simp [dot, direction, position_re, position_im] <;> ring_nf <;> |
| simp [hs] <;> ring |
|
|
| theorem dot_one_position (v : Vertex) : |
| dot (direction 1) (position v) = |
| -((3 / 2 : ℝ) * (v.j : ℝ) + if v.b then 1 / 2 else 0) := by |
| have hs : Real.sqrt 3 ^ 2 = 3 := Real.sq_sqrt (by norm_num) |
| rcases v with ⟨j, k, b⟩ |
| cases b <;> simp [dot, direction, position_re, position_im] <;> ring_nf <;> |
| simp [hs] <;> ring |
|
|
| theorem dot_two_position (v : Vertex) : |
| dot (direction 2) (position v) = |
| -((3 / 2 : ℝ) * (v.k : ℝ) + if v.b then 1 / 2 else 0) := by |
| simp [dot, direction, position_im, mul_comm] |
|
|
| theorem triangle_coordinate_bounds {R : ℝ} {v : Vertex} |
| (hv : v ∈ triangleVertices R) : |
| -(⌈2 * |R| + 2⌉ : ℤ) ≤ v.j ∧ v.j ≤ ⌈2 * |R| + 2⌉ ∧ |
| -(⌈2 * |R| + 2⌉ : ℤ) ≤ v.k ∧ v.k ≤ ⌈2 * |R| + 2⌉ := by |
| have h0 := hv (0 : Fin 3) |
| have h1 := hv (1 : Fin 3) |
| have h2 := hv (2 : Fin 3) |
| rw [dot_zero_position] at h0 |
| rw [dot_one_position] at h1 |
| rw [dot_two_position] at h2 |
| have hN := Int.le_ceil (2 * |R| + 2) |
| have hR := le_abs_self R |
| have ha := abs_nonneg R |
| have hb : -(⌈2 * |R| + 2⌉ : ℝ) ≤ (v.j : ℝ) ∧ |
| (v.j : ℝ) ≤ (⌈2 * |R| + 2⌉ : ℤ) ∧ |
| -(⌈2 * |R| + 2⌉ : ℝ) ≤ (v.k : ℝ) ∧ |
| (v.k : ℝ) ≤ (⌈2 * |R| + 2⌉ : ℤ) := by |
| cases h : v.b <;> simp only [h, Bool.false_eq_true, ↓reduceIte, add_zero] at h0 h1 h2 |
| all_goals repeat' constructor |
| all_goals linarith |
| exact_mod_cast hb |
|
|
| theorem triangleVertices_finite (R : ℝ) : (triangleVertices R).Finite := by |
| let N : ℤ := ⌈2 * |R| + 2⌉ |
| let f : triangleVertices R → Set.Icc (-N) N × Set.Icc (-N) N × Bool := fun v => |
| let h := triangle_coordinate_bounds v.property |
| (⟨v.val.j, h.1, h.2.1⟩, ⟨v.val.k, h.2.2.1, h.2.2.2⟩, v.val.b) |
| have hf : Function.Injective f := by |
| intro v w h |
| apply Subtype.ext |
| have hj : v.val.j = w.val.j := congrArg (fun x => x.1.val) h |
| have hk : v.val.k = w.val.k := congrArg (fun x => x.2.1.val) h |
| have hb : v.val.b = w.val.b := congrArg (fun x => x.2.2) h |
| exact Vertex.ext hj hk hb |
| have : Finite (triangleVertices R) := Finite.of_injective f hf |
| exact Set.toFinite _ |
|
|
| def incidentPorts (v : Vertex) : Finset Port := |
| if v.b then {⟨v.j, v.k, 0⟩, ⟨v.j + 1, v.k, 1⟩, ⟨v.j, v.k + 1, 2⟩} |
| else {⟨v.j, v.k, 0⟩, ⟨v.j, v.k, 1⟩, ⟨v.j, v.k, 2⟩} |
|
|
| theorem incident_iff_mem (p : Port) (v : Vertex) : |
| Incident p v ↔ p ∈ incidentPorts v := by |
| rcases v with ⟨j, k, b⟩ |
| rcases p with ⟨j', k', d⟩ |
| cases b <;> fin_cases d <;> |
| simp [Incident, edgeA, edgeB, incidentPorts, Vertex.mk.injEq, Port.mk.injEq] <;> omega |
|
|
| theorem boundaryPorts_finite {D : Set Vertex} (hD : D.Finite) : |
| {p | BoundaryPort D p}.Finite := by |
| apply (hD.biUnion (fun v _ => (incidentPorts v).finite_toSet)).subset |
| intro p hp |
| rcases hp with ⟨hA, _⟩ | ⟨hB, _⟩ |
| · simp only [Set.mem_iUnion] |
| exact ⟨edgeA p, hA, (incident_iff_mem p _).mp (Or.inl rfl)⟩ |
| · simp only [Set.mem_iUnion] |
| exact ⟨edgeB p, hB, (incident_iff_mem p _).mp (Or.inr rfl)⟩ |
|
|
| def Chord.domainList {D : Set Vertex} (γ : Chord D) : List D := |
| γ.val.vertices.attach.map (fun v => ⟨v.val, γ.property.1 v.val v.property⟩) |
|
|
| theorem Chord.domainList_map_val {D : Set Vertex} (γ : Chord D) : |
| γ.domainList.map Subtype.val = γ.val.vertices := by |
| simp [Chord.domainList, List.map_map] |
|
|
| theorem Chord.domainList_nodup {D : Set Vertex} (γ : Chord D) : |
| γ.domainList.Nodup := by |
| apply List.Nodup.of_map Subtype.val |
| rw [γ.domainList_map_val] |
| exact γ.val.nodup |
|
|
| theorem finite_chord {D : Set Vertex} (hD : D.Finite) : Finite (Chord D) := by |
| let := hD.fintype |
| let : Fintype {p // BoundaryPort D p} := (boundaryPorts_finite hD).fintype |
| let f : Chord D → {p // BoundaryPort D p} × {p // BoundaryPort D p} × |
| {l : List D // l.Nodup} := fun γ => |
| (⟨γ.val.source, γ.property.2.1⟩, ⟨γ.val.target, γ.property.2.2⟩, |
| ⟨γ.domainList, γ.domainList_nodup⟩) |
| apply Finite.of_injective f |
| intro γ η h |
| apply Subtype.ext |
| apply PortPath.ext |
| · exact congrArg (fun x => x.1.val) h |
| · exact congrArg (fun x => x.2.1.val) h |
| · have hL : γ.domainList = η.domainList := congrArg (fun x => x.2.2.val) h |
| rw [← γ.domainList_map_val, ← η.domainList_map_val, hL] |
|
|
| theorem Chord.length_le_card {D : Set Vertex} (hD : D.Finite) (γ : Chord D) : |
| γ.val.length ≤ hD.toFinset.card := by |
| rw [PortPath.length, ← List.toFinset_card_of_nodup γ.val.nodup] |
| apply Finset.card_le_card |
| intro v hv |
| exact hD.mem_toFinset.mpr (γ.property.1 v (List.mem_toFinset.mp hv)) |
|
|
| theorem finite_pathMeasure {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Finite Ω] (path : Ω → PortPath) : |
| IsFiniteMeasure (pathMeasure path) := by |
| classical |
| let := Fintype.ofFinite Ω |
| constructor |
| rw [pathMeasure_apply] |
| simp only [Set.indicator_univ, tsum_fintype] |
| exact ENNReal.sum_lt_top.mpr (fun γ _ => weight_lt_top (path γ)) |
|
|
| theorem triangleMeasure_finite (R : ℝ) : IsFiniteMeasure (triangleMeasure R) := by |
| have := finite_chord (triangleVertices_finite R) |
| exact finite_pathMeasure _ |
|
|
| theorem admissibleLevels_tendsto : |
| Tendsto (fun n : ℕ => (1 / 2 : ℝ) + (3 / 2) * n) atTop wallFilter := by |
| apply tendsto_inf.mpr |
| constructor |
| · have h : Tendsto (fun n : ℕ => (3 / 2 : ℝ) * n) atTop atTop := |
| tendsto_natCast_atTop_atTop.const_mul_atTop (by norm_num) |
| simpa [add_comm] using tendsto_atTop_add_const_right atTop (1 / 2 : ℝ) h |
| · apply tendsto_principal.mpr |
| exact Eventually.of_forall (fun n => ⟨(n : ℤ), by norm_cast⟩) |
|
|
| instance : NeBot wallFilter := admissibleLevels_tendsto.neBot |
|
|
| theorem PortPath.length_eq_tsum_visits (γ : PortPath) : |
| (γ.length : ℝ≥0∞) = ∑' v : Vertex, if v ∈ γ.vertices then 1 else 0 := by |
| classical |
| symm |
| rw [tsum_eq_sum (s := γ.vertices.toFinset) (fun v hv => by simpa using hv)] |
| calc |
| _ = ∑ _v ∈ γ.vertices.toFinset, (1 : ℝ≥0∞) := by |
| apply Finset.sum_congr rfl |
| intro v hv |
| rw [ite_eq_left (List.mem_toFinset.mp hv)] |
| _ = _ := by simp [List.toFinset_card_of_nodup γ.nodup, PortPath.length] |
|
|
| theorem innerCount_eq_tsum_visits (ε R : ℝ) (γ : PortPath) : |
| (innerCount ε R γ : ℝ≥0∞) = |
| ∑' v : Vertex, (innerVertices ε R).indicator |
| (fun v => if v ∈ γ.vertices then (1 : ℝ≥0∞) else 0) v := by |
| classical |
| let S := γ.vertices.toFinset.filter (fun v => v ∈ innerVertices ε R) |
| symm |
| rw [tsum_eq_sum (s := S) (fun v hv => ?_)] |
| · calc |
| _ = ∑ _v ∈ S, (1 : ℝ≥0∞) := by |
| apply Finset.sum_congr rfl |
| intro v hv |
| obtain ⟨hγ, hI⟩ := Finset.mem_filter.mp hv |
| simp [Set.indicator_of_mem hI, List.mem_toFinset.mp hγ] |
| _ = _ := by simp [S, innerCount] |
| · by_cases hI : v ∈ innerVertices ε R |
| · have hγ : v ∉ γ.vertices := by |
| intro hγ |
| exact hv (Finset.mem_filter.mpr ⟨List.mem_toFinset.mpr hγ, hI⟩) |
| simp [hI, hγ] |
| · simp [hI] |
|
|
| theorem lintegral_length_eq_tsum_visits {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] |
| (path : Ω → PortPath) (ν : Measure Ω) : |
| (∫⁻ γ, ((path γ).length : ℝ≥0∞) ∂ν) = ∑' v : Vertex, |
| ν {γ | v ∈ (path γ).vertices} := by |
| classical |
| calc |
| _ = ∫⁻ γ, ∑' v : Vertex, if v ∈ (path γ).vertices then (1 : ℝ≥0∞) else 0 ∂ν := |
| lintegral_congr (fun γ => (path γ).length_eq_tsum_visits) |
| _ = ∑' v : Vertex, ∫⁻ γ, if v ∈ (path γ).vertices then (1 : ℝ≥0∞) else 0 ∂ν := |
| lintegral_tsum (fun _ => (measurable_of_countable _).aemeasurable) |
| _ = _ := by |
| apply tsum_congr |
| intro v |
| simpa only [Set.indicator_apply, Set.mem_ofPred_eq, one_mul] using |
| lintegral_indicator_const |
| (MeasurableSet.of_discrete : MeasurableSet {γ | v ∈ (path γ).vertices}) (1 : ℝ≥0∞) |
|
|
| theorem lintegral_innerCount_eq_tsum_visits {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] |
| (path : Ω → PortPath) (ν : Measure Ω) (ε R : ℝ) : |
| (∫⁻ γ, (innerCount ε R (path γ) : ℝ≥0∞) ∂ν) = |
| ∑' v : Vertex, (innerVertices ε R).indicator |
| (fun v => ν {γ | v ∈ (path γ).vertices}) v := by |
| classical |
| calc |
| _ = ∫⁻ γ, ∑' v : Vertex, (innerVertices ε R).indicator |
| (fun v => if v ∈ (path γ).vertices then (1 : ℝ≥0∞) else 0) v ∂ν := |
| lintegral_congr (fun γ => innerCount_eq_tsum_visits ε R (path γ)) |
| _ = ∑' v : Vertex, ∫⁻ γ, (innerVertices ε R).indicator |
| (fun v => if v ∈ (path γ).vertices then (1 : ℝ≥0∞) else 0) v ∂ν := |
| lintegral_tsum (fun _ => (measurable_of_countable _).aemeasurable) |
| _ = _ := by |
| apply tsum_congr |
| intro v |
| by_cases h : v ∈ innerVertices ε R |
| · simp only [Set.indicator_of_mem h] |
| simpa only [Set.indicator_apply, Set.mem_ofPred_eq, one_mul] using |
| lintegral_indicator_const |
| (MeasurableSet.of_discrete : MeasurableSet {γ | v ∈ (path γ).vertices}) (1 : ℝ≥0∞) |
| · simp [h] |
|
|
| theorem triangleMean_eq_sum_visitProbability (ε R : ℝ) : |
| triangleMean ε R = ∑' v : Vertex, visitProbability ε R v := |
| lintegral_length_eq_tsum_visits Subtype.val (triangleLaw ε R) |
|
|
| theorem triangleInnerMean_eq_sum_visitProbability (ε R : ℝ) : |
| triangleInnerMean ε R = ∑' v : Vertex, |
| (innerVertices ε R).indicator (visitProbability ε R) v := |
| lintegral_innerCount_eq_tsum_visits Subtype.val (triangleLaw ε R) ε R |
|
|
| theorem innerCount_le_length (ε R : ℝ) (γ : PortPath) : innerCount ε R γ ≤ γ.length := by |
| classical |
| unfold innerCount PortPath.length |
| rw [← List.toFinset_card_of_nodup γ.nodup] |
| exact Finset.card_filter_le _ _ |
|
|
| theorem triangleInnerMean_le_triangleMean (ε R : ℝ) : |
| triangleInnerMean ε R ≤ triangleMean ε R := by |
| apply lintegral_mono |
| intro γ |
| exact Nat.cast_le.mpr (innerCount_le_length ε R γ.val) |
|
|
| theorem finite_chord_event_normalizable {D : Set Vertex} (hD : D.Finite) |
| (E : Set (Chord D)) (hE : E.Nonempty) : Normalizable (pathMeasure Subtype.val) E := by |
| have := finite_chord hD |
| have := finite_pathMeasure (Subtype.val : Chord D → PortPath) |
| constructor |
| · obtain ⟨γ, hγ⟩ := hE |
| calc |
| 0 < weight γ.val := weight_pos _ |
| _ = pathMeasure Subtype.val {γ} := (pathMeasure_singleton _ _).symm |
| _ ≤ pathMeasure Subtype.val E := measure_mono (Set.singleton_subset_iff.mpr hγ) |
| · exact measure_lt_top _ _ |
|
|
| theorem triangleMean_le_card (ε R : ℝ) |
| (hN : Normalizable (triangleMeasure R) (hitsInner ε R)) : |
| triangleMean ε R ≤ (triangleVertices_finite R).toFinset.card := by |
| calc |
| _ ≤ ∫⁻ _γ : Chord (triangleVertices R), |
| ((triangleVertices_finite R).toFinset.card : ℝ≥0∞) ∂triangleLaw ε R := by |
| apply lintegral_mono |
| intro γ |
| exact Nat.cast_le.mpr (γ.length_le_card (triangleVertices_finite R)) |
| _ = _ := by rw [lintegral_const, triangleLaw, normalize_univ _ _ hN, mul_one] |
|
|
| theorem triangleMean_lt_top (ε R : ℝ) |
| (hN : Normalizable (triangleMeasure R) (hitsInner ε R)) : |
| triangleMean ε R < ∞ := |
| (triangleMean_le_card ε R hN).trans_lt (ENNReal.natCast_lt_top _) |
|
|
| theorem mem_halfPlane_iff_k_nonneg (v : Vertex) : v ∈ halfPlane ↔ 0 ≤ v.k := by |
| rw [mem_halfPlane_iff, position_im] |
| cases v.b <;> simp only [Bool.false_eq_true, ↓reduceIte, add_zero] |
| all_goals constructor |
| all_goals intro h |
| · have h' : (-1 : ℝ) < (v.k : ℝ) := by linarith |
| have : (-1 : ℤ) < v.k := by exact_mod_cast h' |
| omega |
| · have : (0 : ℝ) ≤ (v.k : ℝ) := by exact_mod_cast h |
| linarith |
| · have h' : (-1 : ℝ) < (v.k : ℝ) := by linarith |
| have : (-1 : ℤ) < v.k := by exact_mod_cast h' |
| omega |
| · have : (0 : ℝ) ≤ (v.k : ℝ) := by exact_mod_cast h |
| linarith |
|
|
| theorem boundaryPort_halfPlane_coords (p : Port) : |
| BoundaryPort halfPlane p ↔ p.k = 0 ∧ p.dir = 2 := by |
| rcases p with ⟨j, k, d⟩ |
| fin_cases d <;> simp [BoundaryPort, edgeA, edgeB, mem_halfPlane_iff_k_nonneg] |
| omega |
|
|
| theorem boundaryPort_halfPlane_iff (p : Port) : |
| BoundaryPort halfPlane p ↔ ∃ m : ℤ, p = wallPort m := by |
| constructor |
| · rw [boundaryPort_halfPlane_coords] |
| rintro ⟨hk, hd⟩ |
| refine ⟨p.j, ?_⟩ |
| cases p |
| simp_all [wallPort] |
| · rintro ⟨m, rfl⟩ |
| exact wallPort_boundary m |
|
|
| theorem lintegral_normalized_pathMeasure {Ω : Type*} [MeasurableSpace Ω] |
| [MeasurableSingletonClass Ω] [Countable Ω] |
| (path : Ω → PortPath) (E : Set Ω) (f : Ω → ℝ≥0∞) : |
| (∫⁻ γ, f γ ∂normalize (pathMeasure path) E) = |
| (pathMeasure path E)⁻¹ * |
| ∑' γ, E.indicator (fun γ => weight (path γ) * f γ) γ := by |
| classical |
| rw [normalize, lintegral_smul_measure, smul_eq_mul, |
| ← lintegral_indicator MeasurableSet.of_discrete, lintegral_pathMeasure] |
| congr 1 |
| apply tsum_congr |
| intro γ |
| by_cases h : γ ∈ E <;> simp [h] |
|
|
| theorem archMean_eq_weighted_ratio (E : Set Arch) : |
| archMean E = (μ E)⁻¹ * |
| ∑' γ : Arch, E.indicator (fun γ => weight γ.path * γ.path.length) γ := |
| lintegral_normalized_pathMeasure Arch.path E _ |
|
|
| theorem triangleMean_eq_weighted_ratio (ε R : ℝ) : |
| triangleMean ε R = (triangleMeasure R (hitsInner ε R))⁻¹ * |
| ∑' γ : Chord (triangleVertices R), (hitsInner ε R).indicator |
| (fun γ => weight γ.val * γ.val.length) γ := |
| lintegral_normalized_pathMeasure Subtype.val (hitsInner ε R) _ |
|
|
| def row (a k : ℤ) : ℕ → List Vertex |
| | 0 => [⟨a, k, false⟩] |
| | n + 1 => ⟨a, k, false⟩ :: ⟨a, k, true⟩ :: row (a + 1) k n |
|
|
| theorem row_ne_nil (a k : ℤ) (n : ℕ) : row a k n ≠ [] := by |
| cases n <;> simp [row] |
|
|
| theorem row_head (a k : ℤ) (n : ℕ) : |
| (row a k n).head (row_ne_nil a k n) = ⟨a, k, false⟩ := by |
| cases n <;> rfl |
|
|
| theorem row_head? (a k : ℤ) (n : ℕ) : |
| (row a k n).head? = some ⟨a, k, false⟩ := by |
| rw [List.head?_eq_some_head (row_ne_nil a k n), row_head] |
|
|
| theorem row_last (a k : ℤ) (n : ℕ) : |
| (row a k n).getLast (row_ne_nil a k n) = ⟨a + n, k, false⟩ := by |
| induction n generalizing a with |
| | zero => simp [row] |
| | succ n ih => |
| simp only [row, List.getLast_cons_cons, List.getLast_cons (row_ne_nil _ _ _), ih] |
| congr 1 |
| push_cast |
| omega |
|
|
| theorem mem_row (a k : ℤ) (n : ℕ) (v : Vertex) : |
| v ∈ row a k n ↔ |
| v.k = k ∧ a ≤ v.j ∧ v.j ≤ a + n ∧ (v.b = true → v.j < a + n) := by |
| rcases v with ⟨j, k', b⟩ |
| induction n generalizing a with |
| | zero => cases b <;> simp [row, Vertex.mk.injEq] <;> omega |
| | succ n ih => cases b <;> simp [row, ih, Vertex.mk.injEq] <;> omega |
|
|
| theorem row_nodup (a k : ℤ) (n : ℕ) : (row a k n).Nodup := by |
| induction n generalizing a with |
| | zero => simp [row] |
| | succ n ih => simp [row, List.nodup_cons, mem_row, Vertex.mk.injEq, ih] |
|
|
| theorem row_chain (a k : ℤ) (n : ℕ) : (row a k n).IsChain Adj := by |
| induction n generalizing a with |
| | zero => simp [row] |
| | succ n ih => |
| rw [row, List.isChain_cons_cons] |
| constructor |
| · exact ⟨⟨a, k, 0⟩, Or.inl ⟨rfl, rfl⟩⟩ |
| · apply List.IsChain.cons (ih (a + 1)) |
| intro v hv |
| rw [row_head?] at hv |
| have hv' : v = ⟨a + 1, k, false⟩ := (Option.mem_some_iff.mp hv).symm |
| subst v |
| refine ⟨⟨a + 1, k, 1⟩, Or.inr ⟨?_, rfl⟩⟩ |
| simp [edgeB] |
|
|
| def rowPath (a k : ℤ) (n : ℕ) : PortPath where |
| source := ⟨a, k, 1⟩ |
| target := ⟨a + n, k, 0⟩ |
| vertices := row a k n |
| nonempty := row_ne_nil a k n |
| nodup := row_nodup a k n |
| chain := row_chain a k n |
| first_incident := by rw [row_head]; exact Or.inl rfl |
| last_incident := by rw [row_last]; exact Or.inl rfl |
| distinct_ports := by simp [Port.mk.injEq] |
|
|
| theorem a_mem_triangle_level (N j k : ℤ) : |
| (⟨j, k, false⟩ : Vertex) ∈ triangleVertices (1 / 2 + (3 / 2) * N) ↔ |
| -N ≤ j ∧ -N ≤ k ∧ j + k ≤ N := by |
| constructor |
| · intro h |
| have h0 := h (0 : Fin 3) |
| have h1 := h (1 : Fin 3) |
| have h2 := h (2 : Fin 3) |
| rw [dot_zero_position] at h0 |
| rw [dot_one_position] at h1 |
| rw [dot_two_position] at h2 |
| simp only [Bool.false_eq_true, ↓reduceIte, add_zero] at h0 h1 h2 |
| have h0' : (3 : ℤ) * (j + k) < 1 + 3 * N := by |
| exact_mod_cast (show (3 : ℝ) * ((j : ℝ) + (k : ℝ)) < 1 + 3 * (N : ℝ) by linarith) |
| have h1' : -(3 : ℤ) * j < 1 + 3 * N := by |
| exact_mod_cast (show -(3 : ℝ) * (j : ℝ) < 1 + 3 * (N : ℝ) by linarith) |
| have h2' : -(3 : ℤ) * k < 1 + 3 * N := by |
| exact_mod_cast (show -(3 : ℝ) * (k : ℝ) < 1 + 3 * (N : ℝ) by linarith) |
| omega |
| · rintro ⟨hj, hk, hjk⟩ |
| have hj' : -(N : ℝ) ≤ (j : ℝ) := by exact_mod_cast hj |
| have hk' : -(N : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk |
| have hjk' : (j : ℝ) + (k : ℝ) ≤ (N : ℝ) := by exact_mod_cast hjk |
| intro i |
| fin_cases i |
| · change dot (direction 0) (position ⟨j, k, false⟩) < _ |
| rw [dot_zero_position]; norm_num; linarith |
| · change dot (direction 1) (position ⟨j, k, false⟩) < _ |
| rw [dot_one_position]; norm_num; linarith |
| · change dot (direction 2) (position ⟨j, k, false⟩) < _ |
| rw [dot_two_position]; norm_num; linarith |
|
|
| theorem b_mem_triangle_level (N j k : ℤ) : |
| (⟨j, k, true⟩ : Vertex) ∈ triangleVertices (1 / 2 + (3 / 2) * N) ↔ |
| -N ≤ j ∧ -N ≤ k ∧ j + k < N := by |
| constructor |
| · intro h |
| have h0 := h (0 : Fin 3) |
| have h1 := h (1 : Fin 3) |
| have h2 := h (2 : Fin 3) |
| rw [dot_zero_position] at h0 |
| rw [dot_one_position] at h1 |
| rw [dot_two_position] at h2 |
| simp only [↓reduceIte] at h0 h1 h2 |
| have h0' : (3 : ℤ) * (j + k) + 2 < 1 + 3 * N := by |
| exact_mod_cast (show (3 : ℝ) * ((j : ℝ) + (k : ℝ)) + 2 < 1 + 3 * (N : ℝ) by linarith) |
| have h1' : -(3 : ℤ) * j - 1 < 1 + 3 * N := by |
| exact_mod_cast (show -(3 : ℝ) * (j : ℝ) - 1 < 1 + 3 * (N : ℝ) by linarith) |
| have h2' : -(3 : ℤ) * k - 1 < 1 + 3 * N := by |
| exact_mod_cast (show -(3 : ℝ) * (k : ℝ) - 1 < 1 + 3 * (N : ℝ) by linarith) |
| omega |
| · rintro ⟨hj, hk, hjk⟩ |
| have hj' : -(N : ℝ) ≤ (j : ℝ) := by exact_mod_cast hj |
| have hk' : -(N : ℝ) ≤ (k : ℝ) := by exact_mod_cast hk |
| have hjk' : (j : ℝ) + (k : ℝ) + 1 ≤ (N : ℝ) := by |
| exact_mod_cast (show j + k + 1 ≤ N by omega) |
| intro i |
| fin_cases i |
| · change dot (direction 0) (position ⟨j, k, true⟩) < _ |
| rw [dot_zero_position]; norm_num; linarith |
| · change dot (direction 1) (position ⟨j, k, true⟩) < _ |
| rw [dot_one_position]; norm_num; linarith |
| · change dot (direction 2) (position ⟨j, k, true⟩) < _ |
| rw [dot_two_position]; norm_num; linarith |
|
|
| theorem mem_triangle_level (N : ℤ) (v : Vertex) : |
| v ∈ triangleVertices (1 / 2 + (3 / 2) * N) ↔ |
| -N ≤ v.j ∧ -N ≤ v.k ∧ v.j + v.k ≤ N ∧ |
| (v.b = true → v.j + v.k < N) := by |
| rcases v with ⟨j, k, b⟩ |
| cases b <;> simp only [a_mem_triangle_level, b_mem_triangle_level, |
| Bool.false_eq_true, false_implies, and_true, true_implies] |
| omega |
|
|
| def triangleRow (N k : ℤ) (hlo : -N ≤ k) (hhi : k ≤ 2 * N) : |
| Chord (triangleVertices (1 / 2 + (3 / 2) * N)) := by |
| have hn : ((2 * N - k).toNat : ℤ) = 2 * N - k := |
| Int.toNat_of_nonneg (by omega) |
| refine ⟨rowPath (-N) k (2 * N - k).toNat, ?_, ?_, ?_⟩ |
| · intro v hv |
| have h := (mem_row (-N) k (2 * N - k).toNat v).mp hv |
| apply (mem_triangle_level N v).mpr |
| refine ⟨h.2.1, ?_, ?_, ?_⟩ |
| · omega |
| · omega |
| · intro hb |
| have := h.2.2.2 hb |
| omega |
| · left |
| change (⟨-N, k, false⟩ : Vertex) ∈ _ ∧ (⟨-N - 1, k, true⟩ : Vertex) ∉ _ |
| simp only [a_mem_triangle_level, b_mem_triangle_level] |
| omega |
| · left |
| change (⟨-N + (2 * N - k).toNat, k, false⟩ : Vertex) ∈ _ ∧ |
| (⟨-N + (2 * N - k).toNat, k, true⟩ : Vertex) ∉ _ |
| simp only [a_mem_triangle_level, b_mem_triangle_level, hn] |
| omega |
|
|
| theorem exists_chord_through {R : ℝ} (hR : R ∈ admissibleLevels) |
| (v : Vertex) (hv : v ∈ triangleVertices R) : |
| ∃ γ : Chord (triangleVertices R), v ∈ γ.val.vertices := by |
| obtain ⟨N, rfl⟩ := hR |
| have h := (mem_triangle_level N v).mp hv |
| have hk : v.k ≤ 2 * N := by omega |
| refine ⟨triangleRow N v.k h.2.1 hk, ?_⟩ |
| have hn : ((2 * N - v.k).toNat : ℤ) = 2 * N - v.k := |
| Int.toNat_of_nonneg (by omega) |
| apply (mem_row (-N) v.k (2 * N - v.k).toNat v).mpr |
| refine ⟨rfl, h.1, ?_, ?_⟩ |
| · omega |
| · intro hb |
| have := h.2.2.2 hb |
| omega |
|
|
| theorem origin_mem_triangle {R : ℝ} (hR : 0 < R) : |
| (⟨0, 0, false⟩ : Vertex) ∈ triangleVertices R := by |
| intro i |
| simpa [dot, position] using hR |
|
|
| theorem innerVertices_subset {ε R : ℝ} (hε : 0 ≤ ε) (hR : 0 ≤ R) : |
| innerVertices ε R ⊆ triangleVertices R := by |
| intro v hv i |
| exact (hv i).trans_le (by nlinarith) |
|
|
| theorem hitsInner_nonempty {ε R : ℝ} (hε : ε < 1) (hR : 0 < R) |
| (hg : R ∈ admissibleLevels) : (hitsInner ε R).Nonempty := by |
| have hI : (⟨0, 0, false⟩ : Vertex) ∈ innerVertices ε R := |
| origin_mem_triangle (mul_pos (sub_pos.mpr hε) hR) |
| obtain ⟨γ, hγ⟩ := exists_chord_through hg ⟨0, 0, false⟩ (origin_mem_triangle hR) |
| exact ⟨γ, ⟨_, hγ, hI⟩⟩ |
|
|
| theorem triangle_normalizable {ε R : ℝ} (hε : ε < 1) (hR : 0 < R) |
| (hg : R ∈ admissibleLevels) : Normalizable (triangleMeasure R) (hitsInner ε R) := |
| finite_chord_event_normalizable (triangleVertices_finite R) _ |
| (hitsInner_nonempty hε hR hg) |
|
|
| theorem eventually_triangle_normalizable {ε : ℝ} (hε : ε < 1) : |
| ∀ᶠ R in wallFilter, Normalizable (triangleMeasure R) (hitsInner ε R) := by |
| rw [wallFilter, eventually_inf_principal] |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hR hg |
| exact triangle_normalizable hε hR hg |
|
|
| theorem triangleLaw_isProbabilityMeasure {ε R : ℝ} (hε : ε < 1) (hR : 0 < R) |
| (hg : R ∈ admissibleLevels) : IsProbabilityMeasure (triangleLaw ε R) := |
| normalize_isProbabilityMeasure _ _ (triangle_normalizable hε hR hg) |
|
|
| theorem visitProbability_pos {ε R : ℝ} (hε₀ : 0 ≤ ε) (hε₁ : ε < 1) |
| (hR : 0 < R) (hg : R ∈ admissibleLevels) (v : Vertex) |
| (hv : v ∈ innerVertices ε R) : 0 < visitProbability ε R v := by |
| obtain ⟨γ, hγ⟩ := exists_chord_through hg v (innerVertices_subset hε₀ hR.le hv) |
| have hE : γ ∈ hitsInner ε R := ⟨v, hγ, hv⟩ |
| have hn := triangle_normalizable hε₁ hR hg |
| calc |
| 0 < (triangleMeasure R (hitsInner ε R))⁻¹ * weight γ.val := |
| ENNReal.mul_pos_iff.mpr ⟨ENNReal.inv_pos.mpr hn.2.ne, weight_pos _⟩ |
| _ = triangleLaw ε R {γ} := (normalized_atom Subtype.val _ hE).symm |
| _ ≤ visitProbability ε R v := measure_mono (Set.singleton_subset_iff.mpr hγ) |
|
|
| theorem visitProbability_le_one {ε R : ℝ} (hε : ε < 1) (hR : 0 < R) |
| (hg : R ∈ admissibleLevels) (v : Vertex) : visitProbability ε R v ≤ 1 := by |
| have : IsProbabilityMeasure (triangleLaw ε R) := triangleLaw_isProbabilityMeasure hε hR hg |
| exact prob_le_one |
|
|
| theorem triangleMean_pos {ε R : ℝ} (hε : ε < 1) (hR : 0 < R) |
| (hg : R ∈ admissibleLevels) : 0 < triangleMean ε R := by |
| have hn := triangle_normalizable hε hR hg |
| have hm : (1 : ℝ≥0∞) ≤ triangleMean ε R := by |
| calc |
| 1 = ∫⁻ _γ : Chord (triangleVertices R), (1 : ℝ≥0∞) ∂triangleLaw ε R := by |
| rw [lintegral_const, triangleLaw, normalize_univ _ _ hn, mul_one] |
| _ ≤ triangleMean ε R := by |
| apply lintegral_mono |
| intro γ |
| change (1 : ℝ≥0∞) ≤ (γ.val.length : ℝ≥0∞) |
| exact_mod_cast (show 1 ≤ γ.val.length from Nat.succ_le_of_lt γ.val.length_pos) |
| exact zero_lt_one.trans_le hm |
|
|
| theorem eventually_triangleMean_pos_finite {ε : ℝ} (hε : ε < 1) : |
| ∀ᶠ R in wallFilter, 0 < triangleMean ε R ∧ triangleMean ε R < ∞ := by |
| rw [wallFilter, eventually_inf_principal] |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hR hg |
| exact ⟨triangleMean_pos hε hR hg, |
| triangleMean_lt_top ε R (triangle_normalizable hε hR hg)⟩ |
|
|
| theorem triangleInnerMean_pos {ε R : ℝ} (hε₀ : 0 ≤ ε) (hε₁ : ε < 1) |
| (hR : 0 < R) (hg : R ∈ admissibleLevels) : 0 < triangleInnerMean ε R := by |
| have hv : (⟨0, 0, false⟩ : Vertex) ∈ innerVertices ε R := |
| origin_mem_triangle (mul_pos (sub_pos.mpr hε₁) hR) |
| rw [triangleInnerMean_eq_sum_visitProbability] |
| calc |
| 0 < visitProbability ε R ⟨0, 0, false⟩ := |
| visitProbability_pos hε₀ hε₁ hR hg _ hv |
| _ = (innerVertices ε R).indicator (visitProbability ε R) ⟨0, 0, false⟩ := |
| (Set.indicator_of_mem hv _).symm |
| _ ≤ _ := ENNReal.le_tsum _ |
|
|
| theorem eventually_triangleInnerMean_pos_finite {ε : ℝ} |
| (hε₀ : 0 ≤ ε) (hε₁ : ε < 1) : |
| ∀ᶠ R in wallFilter, 0 < triangleInnerMean ε R ∧ triangleInnerMean ε R < ∞ := by |
| rw [wallFilter, eventually_inf_principal] |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with R hR hg |
| exact ⟨triangleInnerMean_pos hε₀ hε₁ hR hg, |
| (triangleInnerMean_le_triangleMean ε R).trans_lt |
| (triangleMean_lt_top ε R (triangle_normalizable hε₁ hR hg))⟩ |
|
|
| end DiskBoundary |
|
|
| end |
|
|
| end OAI |
|
|
