import OAI.NumberTheory.DukePrimeDegree.Geometry.CountableCutNeighborhoods
import OAI.NumberTheory.DukePrimeDegree.Geometry.ExponentialCutFamily
import OAI.NumberTheory.DukePrimeDegree.Entropy.UpperRootCutItineraries

namespace OAI

/-! # Controlled countable observations with upper-root future neighborhoods

The chosen distance cuts have exponentially controlled cardinalities and
boundary constants. Their countable height-selected observation has
small lifts and is constant on an upper-root neighborhood in almost
every whole-future fiber.
-/

noncomputable section
open Set MeasureTheory Filter
open scoped Topology BigOperators ENNReal
namespace DukePrimeDegree
open PrimeDegreePackets

theorem exists_controlled_root_future_observation (d : ℕ)
    (ell : Fin (d+1) → ℝ) (hell : ∑ i, ell i=0)
    (hgap : ∀ p : allPositiveRoots (d+1), Real.log 4 ≤ ell p.val.2-ell p.val.1)
    (μ : Measure (X (d+1))) [IsProbabilityMeasure μ]
    (hA : ∀ u : LogCoordinates d, μ.map (fun x => rightAction x (diagonalFlow u))=μ)
    (B : ℝ) (hB : 0 < B) (H : X (d+1) → ℕ) (hH : Measurable H)
    (t : ℕ → ℝ)
    (ht : ∀ m, t m ≤ 2*B*(m:ℝ)+B)
    (hlevel : ∀ x m, H x ≤ m ↔
      quotientLogDistance (Quotient.mk _ (1 : G (d+1))) x ≤ t m)
    (hstep : ∀ x, H (rightAction x (diagonalOneParameter ell hell (-1))) ≤ H x+1)
    (hnull : ∀ m, μ {x | quotientLogDistance (Quotient.mk _ (1 : G (d+1))) x=t m}=0)
    {D₀ : ℝ} (hD₀ : 0 ≤ D₀)
    (hbound : ∀ m k, μ (realBoundaryStrip
      (quotientLogDistance (Quotient.mk _ (1 : G (d+1)))) (t m) ((1/4:ℝ)^k)) ≤
        ENNReal.ofReal (D₀*(1/2:ℝ)^k))
    {r₀ : ℝ} (hr₀ : 0 < r₀) (hr₀1 : r₀ ≤ 1) :
    ∃ Q : X (d+1) → ℕ, Measurable Q ∧
      (∀ m, (Q '' {x | H x ≤ m}).Finite) ∧
      (∀ x y, Q y=Q x → H y=H x ∧
        ∃ g ∈ matrixBall (d+1) (r₀*Real.exp (-(4*B)*(H x:ℝ))), rightAction x g=y) ∧
      ∀ᵐ x ∂μ, ∀ᶠ s in 𝓝 (completeRootChain (d+1)).zeroTime, ∀ k : ℕ,
        Q ((fun y => rightAction y (diagonalOneParameter ell hell (-1)))^[k]
          (rightAction x ((completeRootChain (d+1)).word s))) =
        Q ((fun y => rightAction y (diagonalOneParameter ell hell (-1)))^[k] x) := by
  classical
  let T : X (d+1) → X (d+1) := fun x => rightAction x (diagonalOneParameter ell hell (-1))
  have hT : MeasurePreserving T μ μ := by
    refine ⟨(continuous_rightAction _).measurable,?_⟩
    change μ.map (fun x => rightAction x (diagonalOneParameter ell hell (-1)))=μ
    rw [diagonalOneParameter_eq_diagonalFlow]
    exact hA _
  let r := fun m : ℕ => r₀*Real.exp (-(4*B)*(m:ℝ))
  let τ := fun m => Real.log (1+r m)
  have hτ (m : ℕ) : 0 < τ m := by
    have hr : 0 < r m := by dsimp [r]; positivity
    exact Real.log_pos (by linarith)
  obtain ⟨N,z,c,K,C,hK,hC,hfamily⟩ := exists_exponential_distance_cut_family
    (Nat.succ_pos d) μ (A := 2*B) (B := 4*B) (R₀ := B)
    (by positivity) (by positivity) hB.le hr₀ hr₀1
  let f : ∀ m, Fin (N m) → X (d+1) → ℝ := fun m i => quotientLogDistance (z m i)
  let P := fun m => finiteCutCode (f m) (c m)
  let Q := layeredObservation H P
  have hP (m : ℕ) : Measurable (P m) :=
    finiteCutCode_measurable (fun i => (continuous_quotientLogDistance (d+1) _).measurable) _
  refine ⟨Q,layeredObservation_measurable hH hP,layeredObservation_finite_levels H P,?_,?_⟩
  · intro x y hxy
    have he := layeredObservation_eq H P hxy
    refine ⟨he.1,?_⟩
    have hx : quotientLogDistance (Quotient.mk _ (1 : G (d+1))) x ≤ 2*B*(H x:ℝ)+B :=
      ((hlevel x (H x)).mp le_rfl).trans (ht (H x))
    obtain ⟨i,hi⟩ := (hfamily (H x)).2.2.1 x hx
    have hy := (finiteCutCode_eq_imp_iff (f (H x)) (c (H x)) he.2 i).mpr hi
    exact (hfamily (H x)).2.2.2 i x hi y hy
  · have hneigh := ae_layered_cut_future_neighborhoods (V := UpperRootTime (d+1)) μ hT
      (continuous_rightAction _) H hH hstep
      (quotientLogDistance (Quotient.mk _ (1 : G (d+1))))
      (continuous_quotientLogDistance (d+1) _) t hlevel hnull
      hD₀ hbound N f
      (fun m i => continuous_quotientLogDistance (d+1) _) c
      (fun m i => ((hfamily m).2.1 i).2.2.1)
      (fun m => 48/τ m) (fun m => div_nonneg (by norm_num) (hτ m).le)
      (fun m i k => ((hfamily m).2.1 i).2.2.2 k) hC hK.le (fun m => (hfamily m).1)
    filter_upwards [hneigh] with x hx
    let F : UpperRootTime (d+1) → X (d+1) :=
      fun s => rightAction x ((completeRootChain (d+1)).word s)
    have hbase : F (completeRootChain (d+1)).zeroTime=x := by
      simp only [F,EliminationChain.word_zeroTime,rightAction_one]
    have hF : ContinuousAt F (completeRootChain (d+1)).zeroTime :=
      ((continuous_rightOrbit (d+1) x).comp (upperRootWord_isEmbedding (d+1)).continuous).continuousAt
    let R : ℝ := 1/(6*(d+1:ℝ))
    have hR : 0 < R := by dsimp [R]; positivity
    have hsmall : 3*(d+1:ℝ)*R ≤ 1 := by
      dsimp [R]
      have hn : (d+1:ℝ) ≠ 0 := by positivity
      field_simp
      nlinarith
    have hlog : 0 < Real.log 4 := Real.log_pos (by norm_num)
    have he (k : ℕ) : Real.exp (-Real.log 4*(k:ℝ))=(1/4:ℝ)^k := by
      rw [mul_comm (-Real.log 4) (k:ℝ),Real.exp_nat_mul,
        Real.exp_neg,Real.exp_log (by norm_num : (0:ℝ)<4)]
      simp only [one_div]
    have hc (w : X (d+1)) (k : ℕ) (s : UpperRootTime (d+1))
        (hs : s ∈ (completeRootChain (d+1)).cube R) :
        |quotientLogDistance w (T^[k] (F s))-quotientLogDistance w (T^[k] x)| ≤ (1/4:ℝ)^k := by
      exact (quotientLogDistance_upperRoot_iterate_bound ell hell (Real.log 4)
        hlog hgap hR hsmall w x k hs).trans_eq (he k)
    exact hx F (completeRootChain (d+1)).zeroTime hbase hF _
      (((completeRootChain (d+1)).cube_open R).mem_nhds
        ((completeRootChain (d+1)).zeroTime_mem_cube hR))
      (fun k s hs => hc _ k s hs) (fun k m i s hs => hc _ k s hs)

end DukePrimeDegree

end

end OAI