| import OAI.Dynamics.StandardMap.ArrayGrid |
|
|
| namespace OAI |
|
|
| open MeasureTheory Set |
| open scoped ENNReal BigOperators |
|
|
| open Set Filter |
| open scoped Topology |
| namespace StandardMapEntropy |
| noncomputable def dyadicUnit (n : ℕ) : DyadicTime := ⟨(1:ℝ)/(2:ℝ)^n,n,1,by simp⟩ |
| @[simp] lemma dyadicUnit_val (n : ℕ) : (dyadicUnit n:ℝ)=(1:ℝ)/(2:ℝ)^n := rfl |
| lemma dyadicUnit_pos (n : ℕ) : 0<(dyadicUnit n:ℝ) := by change 0<(1:ℝ)/(2:ℝ)^n; positivity |
| lemma dyadic_common_grid (s t : DyadicTime) : |
| ∃ m : ℕ, ∃ a b : ℤ,s=a • dyadicUnit m ∧ t=b • dyadicUnit m := by |
| obtain ⟨n,a,hs⟩ := dyadicTime_mem s |
| obtain ⟨m,b,ht⟩ := dyadicTime_mem t |
| refine ⟨n+m,a*2^m,b*2^n,?_,?_⟩ |
| · apply Subtype.ext |
| rw [dyadic_zsmul_val,dyadicUnit_val,hs,pow_add] |
| push_cast |
| field_simp |
| · apply Subtype.ext |
| rw [dyadic_zsmul_val,dyadicUnit_val,ht,pow_add] |
| push_cast |
| field_simp |
| lemma dyadic_unit_power (n : ℕ) : (2:ℤ)^n • dyadicUnit n=dyadicInt 1 := by |
| apply Subtype.ext |
| simp only [dyadic_zsmul_val,dyadicUnit_val,dyadicInt_val,Int.cast_pow,Int.cast_ofNat,Int.cast_one] |
| field_simp |
| lemma array_affine_values_of_zero (d : DistanceArray) |
| (hz : ∀ s t : DyadicTime, (s:ℝ)<(t:ℝ) → arrayJ s t d+arrayV s t d=0) |
| (s t : DyadicTime) : d.val s t=d.val 0 (dyadicInt 1)*|(t:ℝ)-(s:ℝ)| := by |
| obtain ⟨m,a,b,rfl,rfl⟩ := dyadic_common_grid s t |
| have hpow : (0:ℝ)<(2:ℝ)^m := by positivity |
| have hc := array_grid_distance d hz (dyadicUnit m) (dyadicUnit_pos m) 0 ((2:ℤ)^m) |
| simp only [zero_smul,dyadic_unit_power,Int.cast_pow,Int.cast_ofNat,Int.cast_zero,sub_zero,abs_of_pos hpow] at hc |
| have he := array_grid_distance d hz (dyadicUnit m) (dyadicUnit_pos m) a b |
| rw [he,dyadic_zsmul_val,dyadic_zsmul_val,dyadicUnit_val] |
| rw [show (b:ℝ)*((1:ℝ)/2^m)-(a:ℝ)*((1:ℝ)/2^m)=((b:ℝ)-(a:ℝ))*((1:ℝ)/2^m) by ring,abs_mul, |
| abs_of_pos (by positivity : (0:ℝ)<1/(2:ℝ)^m),hc] |
| field_simp |
| lemma array_affine_of_zero_tests (d : DistanceArray) |
| (hz : ∀ s t : DyadicTime, (s:ℝ)<(t:ℝ) → arrayJ s t d+arrayV s t d=0) : d∈affineLocus := by |
| let w := d.val 0 (dyadicInt 1) |
| have hw0 : 0 ≤ w := d.property.1 _ _ |
| have hw1 : w ≤ 1 := by |
| by_contra hn |
| have hp : 0<w-1 := by linarith |
| obtain ⟨n,hn⟩ := exists_nat_gt (2/(w-1)) |
| have hbig : 2<(n:ℝ)*(w-1) := (div_lt_iff₀ hp).mp hn |
| have hb := d.property.2.2.2.2 0 (dyadicInt (n:ℤ)) |
| rw [array_affine_values_of_zero d hz] at hb |
| simp only [dyadicInt_val,Int.cast_natCast,ZeroMemClass.coe_zero,sub_zero,Nat.abs_cast] at hb |
| change w*(n:ℝ) ≤ (n:ℝ)+2 at hb |
| nlinarith |
| refine ⟨⟨w,hw0,hw1⟩,?_⟩ |
| apply Subtype.ext |
| funext s t |
| exact (array_affine_values_of_zero d hz s t).symm |
| abbrev ArrayTestIndex := {p : DyadicTime × DyadicTime // (p.1:ℝ)<(p.2:ℝ)} |
| noncomputable def arrayTest (i : ArrayTestIndex) (d : DistanceArray) : ℝ := arrayJ i.val.1 i.val.2 d+arrayV i.val.1 i.val.2 d |
| lemma continuous_arrayTest (i : ArrayTestIndex) : Continuous (arrayTest i) := |
| (continuous_arrayJ _ _).add (continuous_arrayV _ _) |
| lemma arrayTest_nonneg (i : ArrayTestIndex) (d : DistanceArray) : 0 ≤ arrayTest i d := |
| add_nonneg (arrayJ_nonneg _ _ i.property d) (arrayV_nonneg _ _ d) |
| lemma arrayTest_affine_zero (i : ArrayTestIndex) (w : Icc (0:ℝ) 1) : arrayTest i (affineArray w)=0 := by |
| obtain ⟨⟨s,t⟩,hst⟩ := i |
| have hmid := dyadicMid_val s t |
| have h1 : 0<(t:ℝ)-(s:ℝ) := sub_pos.mpr hst |
| have h2 : 0<((s:ℝ)+(t:ℝ))/2-(s:ℝ) := by linarith |
| have h3 : 0<(t:ℝ)-((s:ℝ)+(t:ℝ))/2 := by linarith |
| have hs (u v : DyadicTime) (huv : (u:ℝ)<(v:ℝ)) : |
| arrayShortfall u v (affineArray w)=1-w.val := by |
| unfold arrayShortfall affineArray |
| dsimp only |
| rw [abs_of_pos (sub_pos.mpr huv),mul_div_cancel_right₀ _ (sub_ne_zero.mpr huv.ne')] |
| unfold arrayTest arrayJ arrayV |
| dsimp only |
| rw [hs s t hst,hs s (dyadicMid s t) (by rw [dyadicMid_val]; linarith), |
| hs (dyadicMid s t) t (by rw [dyadicMid_val]; linarith)] |
| ring |
| lemma nonaffine_iff_positive_test (d : DistanceArray) : d∉affineLocus ↔ ∃ i : ArrayTestIndex,0<arrayTest i d := by |
| constructor |
| · intro hd |
| by_contra hn |
| push Not at hn |
| apply hd |
| apply array_affine_of_zero_tests d |
| intro s t hst |
| exact le_antisymm (hn ⟨(s,t),hst⟩) (arrayTest_nonneg ⟨(s,t),hst⟩ d) |
| · rintro ⟨i,hi⟩ ⟨w,rfl⟩ |
| rw [arrayTest_affine_zero] at hi |
| exact lt_irrefl _ hi |
| end StandardMapEntropy |
|
|
| end OAI |
|
|
