| import OAI.Analysis.DiskMaximal.GreenBounds |
|
|
| namespace OAI |
|
|
| open MeasureTheory Set |
| open scoped ENNReal NNReal Topology ContDiff |
| open scoped RealInnerProductSpace |
| open MeasureTheory Set Filter |
| open scoped Topology ENNReal |
| open scoped Real RealInnerProductSpace |
| open MeasureTheory Set Filter |
| open scoped Topology RealInnerProductSpace ContDiff |
| open MeasureTheory Set Filter |
| open scoped Topology Interval NNReal |
| open MeasureTheory Set Filter |
| open scoped Topology NNReal Real |
| open MeasureTheory Set Metric |
| open scoped ENNReal NNReal Topology |
| open MeasureTheory Set |
| open scoped ENNReal NNReal |
| open MeasureTheory Set |
| open scoped ENNReal NNReal |
| open MeasureTheory Set |
| open scoped ENNReal NNReal Topology |
| open MeasureTheory Set Metric |
| open scoped ENNReal NNReal |
| open MeasureTheory Set |
| open scoped ENNReal NNReal |
| open Finset |
| open scoped RealInnerProductSpace |
| open MeasureTheory Set Metric |
| open scoped ENNReal NNReal Topology |
| open MeasureTheory Set |
| open scoped ENNReal NNReal RealInnerProductSpace |
| open MeasureTheory Set |
| open scoped ENNReal NNReal Topology |
| open MeasureTheory Set Metric |
| open scoped ENNReal NNReal RealInnerProductSpace |
| open scoped RealInnerProductSpace |
| open scoped RealInnerProductSpace |
|
|
| noncomputable section |
|
|
| namespace IntrinsicMarks |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
|
|
| def direction (e v : E) : E := by |
| classical |
| exact if v = 0 then e else ‖v‖⁻¹ • v |
|
|
| lemma norm_direction {e : E} (he : ‖e‖ = 1) (v : E) : ‖direction e v‖ = 1 := by |
| by_cases hv : v = 0 |
| · simp [direction,hv,he] |
| · rw [direction,ite_eq_right hv,norm_smul,Real.norm_eq_abs,abs_of_nonneg (inv_nonneg.mpr (norm_nonneg _))] |
| exact inv_mul_cancel₀ (norm_ne_zero_iff.mpr hv) |
|
|
| lemma mass_direction (e v : E) : ‖v‖ • direction e v = v := by |
| by_cases hv : v = 0 |
| · simp [hv] |
| · simp [direction,hv,smul_smul,norm_ne_zero_iff.mpr hv] |
|
|
| lemma debt_identity {e n : E} (he : ‖e‖ = 1) (hn : ‖n‖ = 1) (v : E) : |
| 2*(‖v‖-⟪v,n⟫) = ‖v‖*‖direction e v-n‖^2 := by |
| have hi : ‖v‖*⟪direction e v,n⟫ = ⟪v,n⟫ := by |
| rw [← real_inner_smul_left,mass_direction] |
| rw [norm_sub_sq_real,norm_direction he,hn] |
| nlinarith |
|
|
| lemma marked_mass_le {e n : E} (he : ‖e‖ = 1) (hn : ‖n‖ = 1) |
| (v : E) {δ : ℝ} (hδ : 0 < δ) (hmark : δ < ‖direction e v-n‖) : |
| ‖v‖ ≤ (2/δ^2)*(‖v‖-⟪v,n⟫) := by |
| have hs : δ^2 ≤ ‖direction e v-n‖^2 := |
| (sq_le_sq₀ hδ.le (norm_nonneg _)).mpr hmark.le |
| have hm := mul_le_mul_of_nonneg_left hs (norm_nonneg v) |
| have hid := debt_identity he hn v |
| have hd : 0 < δ^2 := sq_pos_of_pos hδ |
| rw [div_mul_eq_mul_div,le_div_iff₀ hd] |
| nlinarith |
|
|
| /-- Finite uniform branching includes each finite positive-refinement path forest |
| by padding absent children with zero vectors. No triangle defect is assumed. -/ |
| inductive Tree (ι : Type*) (E : Type*) where |
| | leaf : E → Tree ι E |
| | branch : (ι → Tree ι E) → Tree ι E |
|
|
| variable {ι : Type*} [Fintype ι] |
|
|
| def vector : Tree ι E → E |
| | .leaf v => v |
| | .branch t => ∑ i, vector (t i) |
|
|
| def terminalMass : Tree ι E → ℝ |
| | .leaf v => ‖v‖ |
| | .branch t => ∑ i, terminalMass (t i) |
|
|
| omit [InnerProductSpace ℝ E] in |
| lemma norm_vector_le_terminalMass (t : Tree ι E) : ‖vector t‖ ≤ terminalMass t := by |
| induction t with |
| | leaf v => exact le_rfl |
| | branch t ih => |
| exact (norm_sum_le _ _).trans (Finset.sum_le_sum fun i _ => ih i) |
|
|
| /-- Only the first crossing from the most recent marked direction is counted; |
| a crossing resets the anchor before descending further. -/ |
| def markedCost (e : E) (δ : ℝ) : Tree ι E → E → ℝ |
| | .leaf v, n => if δ < ‖direction e v-n‖ then ‖v‖ else 0 |
| | .branch t, n => |
| let v := ∑ i, vector (t i) |
| if δ < ‖direction e v-n‖ then |
| ‖v‖ + ∑ i, markedCost e δ (t i) (direction e v) |
| else ∑ i, markedCost e δ (t i) n |
|
|
| theorem markedCost_le {e : E} (he : ‖e‖ = 1) {δ : ℝ} (hδ : 0 < δ) |
| (t : Tree ι E) {n : E} (hn : ‖n‖ = 1) : |
| markedCost e δ t n ≤ (2/δ^2)*(terminalMass t-⟪vector t,n⟫) := by |
| induction t generalizing n with |
| | leaf v => |
| dsimp [markedCost,terminalMass,vector] |
| split_ifs with hm |
| · exact marked_mass_le he hn v hδ hm |
| · have hi : ⟪v,n⟫ ≤ ‖v‖ := by simpa only [hn,mul_one] using real_inner_le_norm v n |
| exact mul_nonneg (by positivity) (sub_nonneg.mpr hi) |
| | branch t ih => |
| let v := ∑ i, vector (t i) |
| have hs (u : E) (hu : ‖u‖ = 1) : |
| (∑ i, markedCost e δ (t i) u) ≤ |
| (2/δ^2)*((∑ i, terminalMass (t i))-⟪v,u⟫) := by |
| calc |
| _ ≤ ∑ i, (2/δ^2)*(terminalMass (t i)-⟪vector (t i),u⟫) := |
| Finset.sum_le_sum (fun i _ => ih i hu) |
| _ = _ := by simp only [Finset.mul_sum,Finset.sum_sub_distrib,sum_inner,v,mul_sub] |
| have hv := norm_direction he v |
| change (if δ < ‖direction e v-n‖ then |
| ‖v‖ + ∑ i, markedCost e δ (t i) (direction e v) |
| else ∑ i, markedCost e δ (t i) n) ≤ _ |
| split_ifs with hm |
| · have hms := marked_mass_le he hn v hδ hm |
| have hss := hs (direction e v) hv |
| have hinner : ⟪v,direction e v⟫ = ‖v‖ := by |
| calc |
| _ = ⟪‖v‖ • direction e v,direction e v⟫ := congrArg (fun w => ⟪w,direction e v⟫) (mass_direction e v).symm |
| _ = _ := by rw [real_inner_smul_left,real_inner_self_eq_norm_sq,hv]; ring |
| rw [hinner] at hss |
| change _ ≤ (2/δ^2)*((∑ i, terminalMass (t i))-⟪v,n⟫) |
| nlinarith |
| · exact hs n hn |
|
|
| def costWithRoot (e : E) (δ : ℝ) : Tree ι E → ℝ |
| | .leaf v => ‖v‖ |
| | .branch t => |
| let v := ∑ i, vector (t i) |
| ‖v‖+∑ i, markedCost e δ (t i) (direction e v) |
|
|
| theorem costWithRoot_le {e : E} (he : ‖e‖ = 1) {δ : ℝ} (hδ : 0 < δ) |
| (t : Tree ι E) : costWithRoot e δ t ≤ (1+2/δ^2)*terminalMass t := by |
| cases t with |
| | leaf v => |
| change ‖v‖ ≤ (1+2/δ^2)*‖v‖ |
| nlinarith [mul_nonneg (show 0 ≤ 2/δ^2 by positivity) (norm_nonneg v)] |
| | branch t => |
| let v := ∑ i, vector (t i) |
| have hv := norm_direction he v |
| have hinner : ⟪v,direction e v⟫ = ‖v‖ := by |
| calc |
| _ = ⟪‖v‖ • direction e v,direction e v⟫ := congrArg (fun w => ⟪w,direction e v⟫) (mass_direction e v).symm |
| _ = _ := by rw [real_inner_smul_left,real_inner_self_eq_norm_sq,hv]; ring |
| have hs : (∑ i, markedCost e δ (t i) (direction e v)) ≤ |
| (2/δ^2)*((∑ i, terminalMass (t i))-‖v‖) := by |
| calc |
| _ ≤ ∑ i, (2/δ^2)*(terminalMass (t i)-⟪vector (t i),direction e v⟫) := |
| Finset.sum_le_sum (fun i _ => markedCost_le he hδ (t i) hv) |
| _ = _ := by rw [← Finset.mul_sum,Finset.sum_sub_distrib,← sum_inner,hinner] |
| have hn : ‖v‖ ≤ ∑ i, terminalMass (t i) := norm_vector_le_terminalMass (.branch t) |
| change ‖v‖+∑ i, markedCost e δ (t i) (direction e v) ≤ |
| (1+2/δ^2)*(∑ i, terminalMass (t i)) |
| nlinarith [mul_nonneg (show 0 ≤ 2/δ^2 by positivity) (norm_nonneg v)] |
|
|
| end IntrinsicMarks |
|
|
| namespace IntrinsicMarks |
| variable {ι E : Type*} [Fintype ι] [NormedAddCommGroup E] |
|
|
| /-- The fraction of the child capacity occupied by particles already alive. -/ |
| def survival (t : ι → Tree ι E) : ℝ := |
| ‖∑ i, vector (t i)‖ / ∑ i, ‖vector (t i)‖ |
|
|
| lemma survival_nonneg (t : ι → Tree ι E) : 0 ≤ survival t := by |
| unfold survival |
| positivity |
|
|
| lemma survival_le_one (t : ι → Tree ι E) : survival t ≤ 1 := by |
| unfold survival |
| exact div_le_one_of_le₀ (norm_sum_le _ _) (Finset.sum_nonneg (fun _ _ => norm_nonneg _)) |
|
|
| lemma survival_capacity (t : ι → Tree ι E) : |
| survival t * (∑ i, ‖vector (t i)‖) = ‖∑ i, vector (t i)‖ := by |
| unfold survival |
| by_cases h : (∑ i, ‖vector (t i)‖) = 0 |
| · have hn : ‖∑ i, vector (t i)‖ = 0 := by |
| apply le_antisymm _ (norm_nonneg _) |
| simpa only [h] using norm_sum_le Finset.univ (fun i => vector (t i)) |
| simp [h,hn] |
| · exact div_mul_cancel₀ _ h |
|
|
| /-- Explicit finite weighted evaluation on terminal paths, for the population |
| born at the current root. Every branching has its true capacity ratio. -/ |
| def rootEval : Tree ι E → (List ι → ℝ) → ℝ |
| | .leaf v, F => ‖v‖ * F [] |
| | .branch t, F => survival t * ∑ i, rootEval (t i) (fun p => F (i::p)) |
|
|
| /-- Explicit finite evaluation of populations born strictly below this root. |
| The complete prefix is retained, including the part before birth. -/ |
| def lateEval : Tree ι E → (List ι → ℕ → ℝ) → ℝ |
| | .leaf _, _ => 0 |
| | .branch t, F => |
| (1-survival t) * (∑ i, rootEval (t i) (fun p => F (i::p) 1)) + |
| ∑ i, lateEval (t i) (fun p b => F (i::p) (b+1)) |
|
|
| def particleEval (t : Tree ι E) (F : List ι → ℕ → ℝ) : ℝ := |
| rootEval t (fun p => F p 0) + lateEval t F |
|
|
| lemma rootEval_nonneg (t : Tree ι E) {F : List ι → ℝ} (hF : ∀ p, 0 ≤ F p) : |
| 0 ≤ rootEval t F := by |
| induction t generalizing F with |
| | leaf v => exact mul_nonneg (norm_nonneg _) (hF _) |
| | branch t ih => |
| exact mul_nonneg (survival_nonneg t) (Finset.sum_nonneg fun i _ => ih i (fun p => hF (i::p))) |
|
|
| lemma lateEval_nonneg (t : Tree ι E) {F : List ι → ℕ → ℝ} (hF : ∀ p b, 0 ≤ F p b) : |
| 0 ≤ lateEval t F := by |
| induction t generalizing F with |
| | leaf v => exact le_rfl |
| | branch t ih => |
| exact add_nonneg (mul_nonneg (sub_nonneg.mpr (survival_le_one t)) |
| (Finset.sum_nonneg (fun i _ => rootEval_nonneg (t i) (fun p => hF (i::p) 1)))) |
| (Finset.sum_nonneg (fun i _ => ih i (fun p b => hF (i::p) (b+1)))) |
|
|
| lemma particleEval_nonneg (t : Tree ι E) {F : List ι → ℕ → ℝ} (hF : ∀ p b, 0 ≤ F p b) : |
| 0 ≤ particleEval t F := add_nonneg (rootEval_nonneg t (fun p => hF p 0)) (lateEval_nonneg t hF) |
|
|
| lemma rootEval_const (t : Tree ι E) (c : ℝ) : |
| rootEval t (fun _ => c) = ‖vector t‖*c := by |
| induction t with |
| | leaf _ => rfl |
| | branch t ih => |
| change survival t * (∑ i, rootEval (t i) (fun _ => c)) = _ |
| simp only [ih,← Finset.sum_mul] |
| rw [← mul_assoc,survival_capacity] |
| rfl |
|
|
| lemma rootEval_add (t : Tree ι E) (F G : List ι → ℝ) : |
| rootEval t (fun p => F p+G p) = rootEval t F+rootEval t G := by |
| induction t generalizing F G with |
| | leaf _ => exact mul_add _ _ _ |
| | branch t ih => simp only [rootEval,ih,Finset.sum_add_distrib,mul_add] |
|
|
| lemma rootEval_smul (t : Tree ι E) (c : ℝ) (F : List ι → ℝ) : |
| rootEval t (fun p => c*F p) = c*rootEval t F := by |
| induction t generalizing F with |
| | leaf _ => dsimp [rootEval]; ring |
| | branch t ih => simp only [rootEval,ih,← Finset.mul_sum]; ring |
|
|
| lemma lateEval_const (t : Tree ι E) (c : ℝ) : |
| lateEval t (fun _ _ => c) = (terminalMass t-‖vector t‖)*c := by |
| induction t with |
| | leaf _ => simp [lateEval,terminalMass,vector] |
| | branch t ih => |
| change (1-survival t)*(∑ i, rootEval (t i) (fun _ => c)) + |
| (∑ i, lateEval (t i) (fun _ _ => c)) = _ |
| simp only [ih,rootEval_const,← Finset.sum_mul,Finset.sum_sub_distrib] |
| rw [sub_mul,one_mul,← mul_assoc,survival_capacity] |
| simp only [terminalMass,vector] |
| ring |
|
|
| lemma particleEval_const (t : Tree ι E) (c : ℝ) : |
| particleEval t (fun _ _ => c) = terminalMass t*c := by |
| rw [particleEval,rootEval_const,lateEval_const] |
| ring |
|
|
| lemma lateEval_add (t : Tree ι E) (F G : List ι → ℕ → ℝ) : |
| lateEval t (fun p b => F p b+G p b) = lateEval t F+lateEval t G := by |
| induction t generalizing F G with |
| | leaf _ => simp [lateEval] |
| | branch t ih => simp only [lateEval,rootEval_add,ih,Finset.sum_add_distrib,mul_add]; ring |
|
|
| lemma lateEval_smul (t : Tree ι E) (c : ℝ) (F : List ι → ℕ → ℝ) : |
| lateEval t (fun p b => c*F p b) = c*lateEval t F := by |
| induction t generalizing F with |
| | leaf _ => simp [lateEval] |
| | branch t ih => simp only [lateEval,rootEval_smul,ih,← Finset.mul_sum]; ring |
|
|
| lemma particleEval_add (t : Tree ι E) (F G : List ι → ℕ → ℝ) : |
| particleEval t (fun p b => F p b+G p b) = particleEval t F+particleEval t G := by |
| simp only [particleEval,rootEval_add,lateEval_add] |
| ring |
|
|
| lemma particleEval_smul (t : Tree ι E) (c : ℝ) (F : List ι → ℕ → ℝ) : |
| particleEval t (fun p b => c*F p b) = c*particleEval t F := by |
| simp only [particleEval,rootEval_smul,lateEval_smul,mul_add] |
|
|
| lemma particleEval_mono (t : Tree ι E) {F G : List ι → ℕ → ℝ} |
| (hFG : ∀ p b, F p b ≤ G p b) : particleEval t F ≤ particleEval t G := by |
| have hn := particleEval_nonneg t (F := fun p b => G p b-F p b) (fun p b => sub_nonneg.mpr (hFG p b)) |
| have h := particleEval_add t G (fun p b => -1*F p b) |
| simp only [neg_one_mul] at h |
| have hn' : particleEval t (fun p b => G p b-F p b) = particleEval t G-particleEval t F := by |
| calc |
| _ = particleEval t G+particleEval t (fun p b => -1*F p b) := by simpa only [neg_one_mul,sub_eq_add_neg] using h |
| _ = _ := by rw [particleEval_smul]; ring |
| rw [hn'] at hn |
| linarith |
|
|
| /-- Sum a node charge only at and after the particle's birth. -/ |
| def pathCharge (C : List ι → ℝ) : List ι → ℕ → ℝ |
| | [], 0 => C [] |
| | [], _+1 => 0 |
| | i::p, 0 => C [] + pathCharge (fun q => C (i::q)) p 0 |
| | i::p, b+1 => pathCharge (fun q => C (i::q)) p b |
| |
| def nodeCharge : Tree ι E → (List ι → ℝ) → ℝ |
| | .leaf v, C => ‖v‖*C [] |
| | .branch t, C => ‖∑ i, vector (t i)‖*C [] + ∑ i, nodeCharge (t i) (fun p => C (i::p)) |
| |
| /-- Exact occupancy identity for every node charge. This includes all levels, |
| not only the terminal mass; populations created later are not charged earlier. -/ |
| theorem particle_occupancy (t : Tree ι E) (C : List ι → ℝ) : |
| particleEval t (pathCharge C) = nodeCharge t C := by |
| induction t generalizing C with |
| | leaf v => simp [particleEval,rootEval,lateEval,pathCharge,nodeCharge] |
| | branch t ih => |
| simp only [particleEval,rootEval,lateEval,pathCharge,rootEval_add,rootEval_const, |
| Finset.sum_add_distrib] |
| have hs : (∑ i, particleEval (t i) (pathCharge (fun q => C (i::q)))) = |
| ∑ i, nodeCharge (t i) (fun q => C (i::q)) := |
| Finset.sum_congr rfl (fun i _ => ih i _) |
| simp only [particleEval,Finset.sum_add_distrib] at hs |
| rw [← Finset.sum_mul,mul_add,← mul_assoc,survival_capacity] |
| change _ = ‖∑ i, vector (t i)‖*C []+∑ i, nodeCharge (t i) (fun q => C (i::q)) |
| linarith |
| |
| end IntrinsicMarks |
| |
| namespace IntrinsicMarks |
| open Finset |
| variable {E ι : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [Fintype ι] |
| |
| def validPath : Tree ι E → List ι → Prop |
| | .leaf _, p => p = [] |
| | .branch _, [] => False |
| | .branch t, i::p => validPath (t i) p |
| |
| omit [InnerProductSpace ℝ E] in |
| lemma rootEval_mono_on (t : Tree ι E) {F G : List ι → ℝ} |
| (h : ∀ p, validPath t p → F p ≤ G p) : rootEval t F ≤ rootEval t G := by |
| induction t generalizing F G with |
| | leaf v => exact mul_le_mul_of_nonneg_left (h [] rfl) (norm_nonneg _) |
| | branch t ih => |
| apply mul_le_mul_of_nonneg_left _ (survival_nonneg t) |
| exact sum_le_sum fun i _ => ih i (fun p hp => h (i::p) hp) |
| |
| omit [InnerProductSpace ℝ E] in |
| lemma lateEval_mono_on (t : Tree ι E) {F G : List ι → ℕ → ℝ} |
| (h : ∀ p b, validPath t p → b ≤ p.length → F p b ≤ G p b) : |
| lateEval t F ≤ lateEval t G := by |
| induction t generalizing F G with |
| | leaf v => rfl |
| | branch t ih => |
| unfold lateEval |
| apply add_le_add |
| · apply mul_le_mul_of_nonneg_left _ (sub_nonneg.mpr (survival_le_one t)) |
| exact sum_le_sum fun i _ => rootEval_mono_on (t i) (fun p hp => h (i::p) 1 hp (by simp)) |
| · exact sum_le_sum fun i _ => ih i (fun p b hp hb => h (i::p) (b+1) hp (by simpa using Nat.succ_le_succ hb)) |
| |
| omit [InnerProductSpace ℝ E] in |
| /-- Particle monotonicity requires bounds only on genuine terminal paths and |
| legal birth times; the explicit construction has no mass elsewhere. -/ |
| theorem particleEval_mono_on (t : Tree ι E) {F G : List ι → ℕ → ℝ} |
| (h : ∀ p b, validPath t p → b ≤ p.length → F p b ≤ G p b) : |
| particleEval t F ≤ particleEval t G := by |
| exact add_le_add (rootEval_mono_on t (fun p hp => h p 0 hp (Nat.zero_le _))) |
| (lateEval_mono_on t h) |
| |
| /-- Intrinsic marks as an actual function on prefixes, with first-crossing |
| reset. Prefixes outside the tree have zero charge. -/ |
| def markIndicator (e : E) (δ : ℝ) : Tree ι E → E → List ι → ℝ |
| | .leaf v, n, [] => if δ < ‖direction e v-n‖ then 1 else 0 |
| | .leaf _, _, _::_ => 0 |
| | .branch t, n, [] => if δ < ‖direction e (∑ i, vector (t i))-n‖ then 1 else 0 |
| | .branch t, n, i::p => |
| let v := ∑ j, vector (t j) |
| markIndicator e δ (t i) (if δ < ‖direction e v-n‖ then direction e v else n) p |
| |
| def rootMarkIndicator (e : E) (δ : ℝ) : Tree ι E → List ι → ℝ |
| | _, [] => 1 |
| | .leaf _, _::_ => 0 |
| | .branch t, i::p => markIndicator e δ (t i) (direction e (∑ j, vector (t j))) p |
| |
| lemma marked_occupancy (e : E) (δ : ℝ) (t : Tree ι E) (n : E) : |
| nodeCharge t (markIndicator e δ t n) = markedCost e δ t n := by |
| induction t generalizing n with |
| | leaf v => simp only [nodeCharge,markIndicator,markedCost]; split_ifs <;> simp |
| | branch t ih => |
| simp only [nodeCharge,markIndicator,markedCost] |
| split_ifs with h |
| · simp only [mul_one] |
| congr 1 |
| exact sum_congr rfl (fun i _ => ih i _) |
| · simp only [mul_zero,zero_add] |
| exact sum_congr rfl (fun i _ => ih i _) |
| |
| lemma root_marked_occupancy (e : E) (δ : ℝ) (t : Tree ι E) : |
| nodeCharge t (rootMarkIndicator e δ t) = costWithRoot e δ t := by |
| cases t with |
| | leaf v => simp [nodeCharge,rootMarkIndicator,costWithRoot] |
| | branch t => simp only [nodeCharge,rootMarkIndicator,costWithRoot,mul_one,marked_occupancy] |
| |
| theorem particle_mark_budget {e : E} (he : ‖e‖ = 1) {δ : ℝ} (hδ : 0 < δ) |
| (t : Tree ι E) : |
| particleEval t (pathCharge (rootMarkIndicator e δ t)) ≤ |
| (1+2/δ^2)*terminalMass t := by |
| rw [particle_occupancy,root_marked_occupancy] |
| exact costWithRoot_le he hδ t |
| |
| /-- Turning a genuine pathwise switch bound into the global budget uses exact |
| occupancy, rather than a false assumption that every particle is born at a root. -/ |
| theorem particle_switch_budget {e : E} (he : ‖e‖ = 1) {δ c : ℝ} (hδ : 0 < δ) |
| (t : Tree ι E) (energy : List ι → ℝ) (switches : List ι → ℕ → ℝ) |
| (hpath : ∀ p b, validPath t p → b ≤ p.length → switches p b ≤ |
| 1+2*pathCharge (rootMarkIndicator e δ t) p b+c*pathCharge energy p b) : |
| particleEval t switches ≤ (3+4/δ^2)*terminalMass t+c*nodeCharge t energy := by |
| have h := particleEval_mono_on t hpath |
| simp only [particleEval_add,particleEval_smul,particleEval_const,particle_occupancy, |
| root_marked_occupancy] at h |
| have hm := costWithRoot_le he hδ t |
| calc |
| _ ≤ terminalMass t*1 + 2*((1+2/δ^2)*terminalMass t)+c*nodeCharge t energy := |
| h.trans (by gcongr) |
| _ = _ := by ring |
| |
| end IntrinsicMarks |
| |
| namespace SignedAssembly |
| open Finset |
| open scoped RealInnerProductSpace |
| variable {ι E : Type*} [Fintype ι] [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
| |
| structure RowJet (ι E : Type*) [Fintype ι] [NormedAddCommGroup E] [InnerProductSpace ℝ E] where |
| law : FiniteLabels.Law ι |
| grad : ι → E |
| total_grad : ∑ i, grad i = 0 |
| |
| inductive JetTree (ι E : Type*) [Fintype ι] [NormedAddCommGroup E] [InnerProductSpace ℝ E] where |
| | leaf : E → JetTree ι E |
| | branch : RowJet ι E → E → ℝ → (ι → JetTree ι E) → JetTree ι E |
| |
| def mean : JetTree ι E → E |
| | .leaf v => v |
| | .branch row _ _ t => ∑ i, row.law i • mean (t i) |
| |
| def flux : JetTree ι E → ℝ |
| | .leaf _ => 0 |
| | .branch row _ _ t => ∑ i, ⟪row.grad i,mean (t i)⟫ + ∑ i, row.law i*flux (t i) |
| |
| /-- Product-rule expansion over all terminal label histories. The carried mass |
| and its derivative are updated by the exact Leibniz rule. -/ |
| def pathFlux : JetTree ι E → ℝ → E → ℝ |
| | .leaf v, _, G => ⟪G,v⟫ |
| | .branch row _ _ t, q, G => |
| ∑ i, pathFlux (t i) (q*row.law i) (q • row.grad i+row.law i • G) |
| |
| lemma pathFlux_eq (t : JetTree ι E) (q : ℝ) (G : E) : |
| pathFlux t q G = ⟪G,mean t⟫+q*flux t := by |
| induction t generalizing q G with |
| | leaf v => simp [pathFlux,mean,flux] |
| | branch row c B t ih => |
| simp only [pathFlux,ih,inner_add_left,real_inner_smul_left,sum_add_distrib, |
| ← mul_sum,mean,flux,inner_sum,real_inner_smul_right] |
| simp only [mul_assoc, ← mul_sum] |
| ring |
| |
| lemma terminal_flux (t : JetTree ι E) : pathFlux t 1 0 = flux t := by |
| rw [pathFlux_eq,inner_zero_left,one_mul,zero_add] |
| |
| /-- Every terminal continuation is within B of the same closed-prefix value. -/ |
| def TerminalBound : JetTree ι E → E → ℝ → Prop |
| | .leaf v, c, B => ‖v-c‖ ≤ B |
| | .branch _ _ _ t, c, B => ∀ i, TerminalBound (t i) c B |
| |
| lemma mean_bound (t : JetTree ι E) (c : E) (B : ℝ) (h : TerminalBound t c B) : |
| ‖mean t-c‖ ≤ B := by |
| induction t with |
| | leaf v => exact h |
| | branch row _ _ t ih => |
| have he : mean (.branch row (0:E) 0 t)-c = ∑ i, row.law i • (mean (t i)-c) := by |
| simp only [mean,smul_sub,sum_sub_distrib,← sum_smul,row.law.total,one_smul] |
| change ‖mean (.branch row (0:E) 0 t)-c‖ ≤ B |
| rw [he] |
| calc |
| _ ≤ ∑ i, ‖row.law i • (mean (t i)-c)‖ := norm_sum_le _ _ |
| _ = ∑ i, row.law i*‖mean (t i)-c‖ := by |
| simp only [norm_smul,Real.norm_eq_abs,abs_of_nonneg (row.law.nonneg _)] |
| _ ≤ ∑ i, row.law i*B := sum_le_sum fun i _ => |
| mul_le_mul_of_nonneg_left (ih i (h i)) (row.law.nonneg i) |
| _ = B := by rw [← sum_mul,row.law.total,one_mul] |
| |
| /-- This is the exact zero-row-sum cancellation. No unsigned path-potential |
| bound is used and the parent prefix may be arbitrarily large. -/ |
| lemma prefix_cancellation (row : RowJet ι E) (v : ι → E) (c : E) : |
| (∑ i, ⟪row.grad i,v i⟫) = ∑ i, ⟪row.grad i,v i-c⟫ := by |
| simp only [inner_sub_right,sum_sub_distrib,← sum_inner,row.total_grad,inner_zero_left,sub_zero] |
| |
| lemma row_flux_bound (row : RowJet ι E) (v : ι → E) (c : E) (B : ℝ) |
| (h : ∀ i, ‖v i-c‖ ≤ B) : |
| |∑ i, ⟪row.grad i,v i⟫| ≤ (∑ i, ‖row.grad i‖)*B := by |
| rw [prefix_cancellation row v c] |
| calc |
| _ ≤ ∑ i, |⟪row.grad i,v i-c⟫| := abs_sum_le_sum_abs _ _ |
| _ ≤ ∑ i, ‖row.grad i‖*B := sum_le_sum fun i _ => |
| (abs_real_inner_le_norm _ _).trans (mul_le_mul_of_nonneg_left (h i) (norm_nonneg _)) |
| _ = _ := by rw [← sum_mul] |
| |
| def Controlled : JetTree ι E → Prop |
| | .leaf _ => True |
| | .branch _ c B t => (∀ i, TerminalBound (t i) c B) ∧ ∀ i, Controlled (t i) |
| |
| def cost : JetTree ι E → ℝ |
| | .leaf _ => 0 |
| | .branch row _ B t => (∑ i, ‖row.grad i‖)*B+∑ i, row.law i*cost (t i) |
| |
| /-- Full finite-history signed flux estimate, with all stochastic prefix |
| weights kept. The node bound is the tail oscillation, not the old envelope. -/ |
| theorem signed_flux_bound (t : JetTree ι E) (ht : Controlled t) : |
| |pathFlux t 1 0| ≤ cost t := by |
| rw [terminal_flux] |
| induction t with |
| | leaf v => simp [flux,cost] |
| | branch row c B t ih => |
| change |(∑ i, ⟪row.grad i,mean (t i)⟫)+∑ i, row.law i*flux (t i)| ≤ _ |
| calc |
| _ ≤ |∑ i, ⟪row.grad i,mean (t i)⟫|+|∑ i, row.law i*flux (t i)| := abs_add_le _ _ |
| _ ≤ (∑ i, ‖row.grad i‖)*B+∑ i, row.law i*cost (t i) := by |
| apply add_le_add (row_flux_bound row (fun i => mean (t i)) c B |
| (fun i => mean_bound (t i) c B (ht.1 i))) |
| calc |
| _ ≤ ∑ i, |row.law i*flux (t i)| := abs_sum_le_sum_abs _ _ |
| _ = ∑ i, row.law i*|flux (t i)| := by |
| simp only [abs_mul,abs_of_nonneg (row.law.nonneg _)] |
| _ ≤ _ := sum_le_sum fun i _ => mul_le_mul_of_nonneg_left (ih i (ht.2 i)) (row.law.nonneg i) |
| _ = _ := rfl |
| |
| end SignedAssembly |
| |
| open scoped ContDiff |
| namespace PlanePotential |
| lemma potential_norm_lintegral {L : ℂ → ℂ} (hL : Measurable L) {b : ℂ → ℂ} |
| (hb : Integrable b) : |
| (∫⁻ y, ‖⟪L y,b y⟫‖ₑ) ≤ |
| ∫⁻ y, ENNReal.ofReal ‖L y‖ ∂volume.withDensity (fun y => ENNReal.ofReal ‖b y‖) := by |
| rw [lintegral_withDensity_eq_lintegral_mul₀' hb.aestronglyMeasurable.norm.aemeasurable.ennreal_ofReal |
| hL.norm.ennreal_ofReal.aemeasurable] |
| apply lintegral_mono |
| intro y |
| dsimp only [Pi.mul_apply] |
| rw [← ofReal_norm] |
| change ENNReal.ofReal ‖⟪L y,b y⟫‖ ≤ ENNReal.ofReal ‖b y‖ * ENNReal.ofReal ‖L y‖ |
| rw [← ENNReal.ofReal_mul (norm_nonneg _)] |
| exact ENNReal.ofReal_le_ofReal ((norm_inner_le_norm _ _).trans_eq (mul_comm _ _)) |
|
|
| lemma potential_integrable_of_density {L : ℂ → ℂ} (hL : Measurable L) {b : ℂ → ℂ} |
| (hb : Integrable b) |
| (hfinite : (∫⁻ y, ENNReal.ofReal ‖L y‖ ∂volume.withDensity (fun y => ENNReal.ofReal ‖b y‖)) < ⊤) : |
| Integrable (fun y => ⟪L y,b y⟫) := by |
| refine ⟨hL.aestronglyMeasurable.inner hb.aestronglyMeasurable,?_⟩ |
| rw [hasFiniteIntegral_iff_enorm] |
| exact (potential_norm_lintegral hL hb).trans_lt hfinite |
|
|
| /-- Finiteness of the genuine singular integrals, obtained from the column |
| estimate itself. This justifies insertion of the finite vector decomposition. -/ |
| theorem kernel_potential_ae_integrable (μ : Measure ℂ) [SFinite μ] |
| {K : ℂ × ℂ → ℂ} (hK : Measurable K) {b : ℂ → ℂ} (hb : Integrable b) |
| {C : ℝ≥0∞} (hC : C < ⊤) |
| (hcol : ∀ᵐ y ∂volume.withDensity (fun y => ENNReal.ofReal ‖b y‖), |
| (∫⁻ x, (ENNReal.ofReal ‖K (x,y)‖)^(3/2:ℝ) ∂μ) ≤ C) : |
| ∀ᵐ x ∂μ, Integrable (fun y => ⟪K (x,y),b y⟫) := by |
| let ν := volume.withDensity (fun y => ENNReal.ofReal ‖b y‖) |
| have hm : ν univ = ENNReal.ofReal (∫ y, ‖b y‖) := by |
| dsimp only [ν] |
| rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] |
| exact (ofReal_integral_eq_lintegral_ofReal hb.norm |
| (ae_of_all _ (fun _ => norm_nonneg _))).symm |
| have hν : ν univ < ⊤ := by rw [hm]; exact ENNReal.ofReal_lt_top |
| have : IsFiniteMeasure ν := ⟨hν⟩ |
| have hlp := kernel_column_lp μ ν hK.norm.ennreal_ofReal hcol |
| have hfinite : (∫⁻ x, (∫⁻ y, ENNReal.ofReal ‖K (x,y)‖ ∂ν)^(3/2:ℝ) ∂μ) ≠ ⊤ := |
| ne_of_lt (hlp.trans_lt (ENNReal.mul_lt_top hC (ENNReal.rpow_lt_top_of_nonneg (by norm_num) hν.ne))) |
| have hae := ae_lt_top (hK.norm.ennreal_ofReal.lintegral_prod_right.pow_const _) hfinite |
| filter_upwards [hae] with x hx |
| apply potential_integrable_of_density (hK.comp (measurable_const.prodMk measurable_id)) hb |
| apply lt_top_iff_ne_top.mpr |
| intro htop |
| change (∫⁻ y, ENNReal.ofReal ‖K (x,y)‖ ∂ν) = ⊤ at htop |
| rw [htop,ENNReal.top_rpow_of_pos (by norm_num : (0:ℝ) < 3/2)] at hx |
| exact (lt_irrefl _ hx) |
|
|
| lemma green_root_column {ψ : ℂ → ℝ} (hψm : Measurable ψ) {R X Y B : ℝ} |
| (hψs : ∀ z, ψ z ≠ 0 → ‖z‖ ≤ R) (hψB : ∀ z, |ψ z| ≤ B) |
| (hM : 0 < R+X) (hB : 0 ≤ B) (hXY : 0 < X+Y) {y : ℂ} (hy : ‖y‖ ≤ Y) : |
| (∫⁻ x in {x : ℂ | ‖x‖ ≤ X}, (ENNReal.ofReal ‖green ψ x y‖)^(3/2:ℝ)) ≤ |
| ENNReal.ofReal ((2*B*(R+X)^2)^(3/2:ℝ)*(4*Real.pi*(2*(X+Y))^(1/2:ℝ))) := by |
| apply kernel_near_three_halves (by positivity) (by positivity : 0 < 2*(X+Y)) y |
| · intro x hx |
| rw [mem_ball,dist_eq_norm] |
| have hn := norm_sub_le x y |
| change ‖x‖ ≤ X at hx |
| linarith |
| · intro x hx |
| exact green_size_all hψm hψs hψB hM hB hx |
|
|
| lemma green_ae_integrable {ψ : ℂ → ℝ} {β : ℂ → ℂ} |
| (hψm : Measurable ψ) {R X Y B : ℝ} |
| (hψs : ∀ z, ψ z ≠ 0 → ‖z‖ ≤ R) (hψB : ∀ z, |ψ z| ≤ B) |
| (hM : 0 < R+X) (hB : 0 ≤ B) (hXY : 0 < X+Y) |
| (hβ : Integrable β) (hβs : ∀ y, β y ≠ 0 → ‖y‖ ≤ Y) : |
| ∀ᵐ x ∂volume.restrict {x : ℂ | ‖x‖ ≤ X}, Integrable (fun y => ⟪green ψ x y,β y⟫) := by |
| apply kernel_potential_ae_integrable _ (green_measurable ψ hψm) hβ ENNReal.ofReal_lt_top |
| rw [ae_withDensity_iff' hβ.aestronglyMeasurable.norm.aemeasurable.ennreal_ofReal] |
| filter_upwards with y hy |
| apply green_root_column hψm hψs hψB hM hB hXY |
| apply hβs y |
| intro hy0 |
| simp [hy0] at hy |
| |
| lemma green_root_lp {ψ : ℂ → ℝ} {β : ℂ → ℂ} |
| (hψm : Measurable ψ) {R X Y B : ℝ} |
| (hψs : ∀ z, ψ z ≠ 0 → ‖z‖ ≤ R) (hψB : ∀ z, |ψ z| ≤ B) |
| (hM : 0 < R+X) (hB : 0 ≤ B) (hXY : 0 < X+Y) |
| (hβ : Integrable β) (hβs : ∀ y, β y ≠ 0 → ‖y‖ ≤ Y) : |
| (∫⁻ x in {x : ℂ | ‖x‖ ≤ X}, (ENNReal.ofReal |∫ y, ⟪green ψ x y,β y⟫|)^(3/2:ℝ)) ≤ |
| ENNReal.ofReal ((2*B*(R+X)^2)^(3/2:ℝ)*(4*Real.pi*(2*(X+Y))^(1/2:ℝ))) * |
| (ENNReal.ofReal (∫ y, ‖β y‖))^(3/2:ℝ) := by |
| let ν := volume.withDensity (fun y => ENNReal.ofReal ‖β y‖) |
| have hν : ν univ = ENNReal.ofReal (∫ y, ‖β y‖) := by |
| dsimp only [ν] |
| rw [withDensity_apply _ MeasurableSet.univ,Measure.restrict_univ] |
| exact (ofReal_integral_eq_lintegral_ofReal hβ.norm |
| (ae_of_all _ (fun _ => norm_nonneg _))).symm |
| have : IsFiniteMeasure ν := ⟨by rw [hν]; exact ENNReal.ofReal_lt_top⟩ |
| have hm := green_measurable ψ hψm |
| have hcol := kernel_column_lp (volume.restrict {x : ℂ | ‖x‖ ≤ X}) ν hm.norm.ennreal_ofReal |
| (C := ENNReal.ofReal ((2*B*(R+X)^2)^(3/2:ℝ)*(4*Real.pi*(2*(X+Y))^(1/2:ℝ)))) (by |
| rw [ae_withDensity_iff' hβ.aestronglyMeasurable.norm.aemeasurable.ennreal_ofReal] |
| filter_upwards with y hy |
| apply green_root_column hψm hψs hψB hM hB hXY |
| apply hβs y |
| intro hy0 |
| simp [hy0] at hy) |
| rw [hν] at hcol |
| apply le_trans _ hcol |
| apply lintegral_mono |
| intro x |
| exact ENNReal.rpow_le_rpow (potential_domination |
| (hm.comp (measurable_const.prodMk measurable_id)) hβ) (by norm_num) |
|
|
| end PlanePotential |
|
|
| namespace PlanePotential |
| lemma eLpNorm_three_halves_bound (μ : Measure ℂ) {F : ℂ → ℝ} {K m : ℝ≥0∞} |
| (h : (∫⁻ x, (ENNReal.ofReal |F x|)^(3/2:ℝ) ∂μ) ≤ K*m^(3/2:ℝ)) : |
| eLpNorm' F (3/2) μ ≤ K^(2/3:ℝ)*m := by |
| rw [eLpNorm'_eq_lintegral_enorm] |
| norm_num only [one_div_div] |
| have hpow := ENNReal.rpow_le_rpow h (by norm_num : (0:ℝ) ≤ 2/3) |
| rw [ENNReal.mul_rpow_of_nonneg _ _ (by norm_num : (0:ℝ) ≤ 2/3),← ENNReal.rpow_mul] at hpow |
| norm_num only [show (3/2:ℝ)*(2/3)=1 by norm_num,ENNReal.rpow_one] at hpow |
| simpa only [← ofReal_norm,Real.norm_eq_abs] using hpow |
|
|
| lemma potential_aestronglyMeasurable (μ : Measure ℂ) {K : ℂ × ℂ → ℂ} |
| (hK : Measurable K) {β : ℂ → ℂ} (hβ : Integrable β) : |
| AEStronglyMeasurable (fun x => ∫ y, ⟪K (x,y),β y⟫) μ := by |
| have h : AEStronglyMeasurable (fun z : ℂ × ℂ => @inner ℝ ℂ _ (K z) (β z.2)) (μ.prod volume) := |
| hK.aestronglyMeasurable.inner hβ.aestronglyMeasurable.comp_snd |
| exact h.integral_prod_right' |
| |
| lemma potential_memLp_of_bound (μ : Measure ℂ) {K : ℂ × ℂ → ℂ} |
| (hK : Measurable K) {β : ℂ → ℂ} (hβ : Integrable β) {C m : ℝ≥0∞} |
| (hC : C < ⊤) (hm : m < ⊤) |
| (h : (∫⁻ x, (ENNReal.ofReal |∫ y, ⟪K (x,y),β y⟫|)^(3/2:ℝ) ∂μ) ≤ C*m^(3/2:ℝ)) : |
| MemLp (fun x => ∫ y, ⟪K (x,y),β y⟫) (3/2) μ := by |
| rw [memLp_iff, eLpNorm_eq_eLpNorm' (by norm_num : (3/2:ℝ≥0∞) ≠ 0) |
| (ENNReal.div_ne_top (by norm_num) (by norm_num)) (potential_aestronglyMeasurable μ hK hβ)] |
| norm_num only [ENNReal.toReal_div, ENNReal.toReal_ofNat] |
| exact (eLpNorm_three_halves_bound μ h).trans_lt |
| (ENNReal.mul_lt_top (ENNReal.rpow_lt_top_of_nonneg (by norm_num) hC.ne) hm) |
|
|
| /-- A genuine fixed smooth probability cutoff. Its finite size and Lipschitz |
| constants depend on no input, no dyadic level and no number of scales. -/ |
| theorem exists_kernel_cutoff : ∃ (ψ : ℂ → ℝ) (B L : ℝ), |
| 0 ≤ B ∧ 0 ≤ L ∧ ContDiff ℝ ∞ ψ ∧ HasCompactSupport ψ ∧ |
| (∫ x, ψ x) = 1 ∧ (∀ x, ψ x ≠ 0 → ‖x‖ ≤ 1) ∧ |
| (∀ x, |ψ x| ≤ B) ∧ (∀ x y, |ψ x-ψ y| ≤ L*‖x-y‖) := by |
| let φ : ContDiffBump (0:ℂ) := ⟨1/2,1,by norm_num,by norm_num⟩ |
| let ψ := φ.normed volume |
| have hc : HasCompactSupport ψ := φ.hasCompactSupport_normed |
| have hd : ContDiff ℝ ∞ ψ := φ.contDiff_normed |
| obtain ⟨B,hB⟩ := hc.exists_bound_of_continuous hd.continuous |
| obtain ⟨L,hL⟩ := hd.lipschitzWith_of_hasCompactSupport hc (by simp) |
| refine ⟨ψ,B,L,le_trans (norm_nonneg (ψ 0)) (hB 0),L.coe_nonneg,hd,hc, |
| φ.integral_normed,?_,?_,?_⟩ |
| · intro x hx |
| have hs : x ∈ Function.support ψ := hx |
| rw [φ.support_normed_eq] at hs |
| exact (show ‖x‖ < 1 by simpa only [mem_ball,dist_zero_right] using hs).le |
| · intro x |
| simpa only [Real.norm_eq_abs] using hB x |
| · intro x y |
| simpa only [Real.norm_eq_abs] using hL.norm_sub_le x y |
|
|
| end PlanePotential |
|
|
| open Finset |
| noncomputable section |
|
|
| end |
| end |
|
|
| end OAI |
|
|
