import OAI.Dynamics.EntropyCounterexample.NormalizedPrediction
import OAI.Dynamics.EntropyCounterexample.SphereAngularInput
import OAI.Dynamics.EntropyCounterexample.LocalPredictionInput
import OAI.Dynamics.EntropyCounterexample.PredictionModelBridge

namespace OAI

noncomputable section

namespace Problem340.ConcreteInputRegularity

abbrev Ambient := AmbientPrediction.Ambient

def preparation (x : Ambient) : ℝ := preparationCoeff x.1

def predictedClock (n : ℕ) : Ambient → ℝ :=
  NormalizedPrediction.clock AmbientPrediction.predictor (n + 1)

def angular (n : ℕ) (x : Ambient) : ℂ :=
  SphereAngularInput.angularAmbient (2 ^ (n + 2)) x.2

def ambientInput (L : ℝ) (i : Fin 3) (x : Ambient) : ℂ :=
  ∑' n, predictionSummand preparation (readoutCoeff i) predictedClock angular L n x

theorem predictor_preserves_norm (x : Ambient) (hx : ‖x.2‖ = 1) :
    ‖(AmbientPrediction.predictor x).2‖ = 1 := by
  exact mem_sphere_zero_iff_norm.mp
    (SphereDoubling.ambientMap_mem_sphere ⟨x.2, mem_sphere_zero_iff_norm.mpr hx⟩)

theorem exists_contDiffOn_ambientInput_product :
    ∃ (B : ℝ) (W : Set SphereAmbient), 1 ≤ B ∧ IsOpen W ∧
      Metric.sphere (0 : SphereAmbient) 1 ⊆ W ∧
      ∀ L : ℝ, B < L → 2 < L → ∀ i : Fin 3,
        ContDiffOn ℝ 1 (ambientInput L i) (Set.univ ×ˢ W) := by
  obtain ⟨B, hB, hBbound⟩ := AmbientPrediction.exists_derivative_bound
  obtain ⟨U, K, hU, hsU, hK, hangular, hangularBound⟩ :=
    SphereAngularInput.exists_uniform_angular_neighborhood
  obtain ⟨A, hA, hAbound⟩ := exists_preparationCoeff_fderiv_bound
  obtain ⟨D, hD, hDbound⟩ := exists_readoutCoeff_fderiv_bound
  let V : Set Ambient := AmbientRetraction.cylinderDomain ∩ Prod.snd ⁻¹' U
  have hV : IsOpen V := AmbientRetraction.isOpen_cylinderDomain.inter
    (hU.preimage continuous_snd)
  have hVsub : AmbientPrediction.cylinder ⊆ V := by
    intro x hx
    refine ⟨?_, hsU hx.2⟩
    change (1 / 2 : ℝ) < ‖x.2‖
    rw [mem_sphere_zero_iff_norm.mp hx.2]
    norm_num
  have hpred : ContDiff ℝ 1 AmbientPrediction.predictor :=
    AmbientPrediction.contDiff_predictor
  have hnormBound : ∀ x : Ambient, ‖x.2‖ = 1 →
      ‖fderiv ℝ AmbientPrediction.predictor x‖ ≤ B := by
    intro x hx
    exact hBbound x ⟨Set.mem_univ _, mem_sphere_zero_iff_norm.mpr hx⟩
  let W : Set SphereAmbient := {z | (0, z) ∈ V}
  have hW : IsOpen W := hV.preimage (continuous_const.prodMk continuous_id)
  have hsW : Metric.sphere (0 : SphereAmbient) 1 ⊆ W :=
    fun z hz => hVsub ⟨Set.mem_univ _, hz⟩
  have hVW : V = Set.univ ×ˢ W := by
    ext x
    simp [V, W, AmbientRetraction.cylinderDomain]
  refine ⟨B, W, hB, hW, hsW, ?_⟩
  intro L hBL hL i
  rw [← hVW]
  apply contDiffOn_predictionInput hV (A := A) (D := D) (J := 4) (K := K)
    (B := B) (by linarith) (by linarith) (by norm_num) (by linarith)
    (by linarith) hBL hL
  · exact (preparationCoeff_contDiff.comp contDiff_fst).contDiffOn
  · exact readoutCoeff_contDiff i
  · intro n
    exact (NormalizedPrediction.contDiffOn_clock hpred predictor_preserves_norm
      (n + 1)).mono (fun _ hx => hx.1)
  · intro n
    exact ((hangular (2 ^ (n + 2))).of_le (by norm_num)).comp
      contDiffOn_snd (fun _ hx => hx.2)
  · intro x _
    change ‖preparationCoeff x.1‖ ≤ 1
    rw [Real.norm_eq_abs, abs_of_nonneg (preparationCoeff_nonneg x.1)]
    exact preparationCoeff_le_one x.1
  · intro n x _
    rw [Real.norm_eq_abs, abs_of_nonneg (readoutCoeff_nonneg i _)]
    exact readoutCoeff_le_one i _
  · intro n x _
    exact SphereAngularInput.norm_angularAmbient_le_one _ _
  · intro x _
    have hh := norm_fderiv_comp_le
      ((preparationCoeff_contDiff (n := 1)).differentiable_one x.1)
      (differentiableAt_fst (p := x))
    change ‖fderiv ℝ preparation x‖ ≤ A
    apply hh.trans
    calc
      ‖fderiv ℝ preparationCoeff x.1‖ * ‖fderiv ℝ Prod.fst x‖
          ≤ A * 1 := mul_le_mul (hAbound x.1)
            (by rw [fderiv_fst]; exact ContinuousLinearMap.norm_fst_le ℝ ℝ SphereAmbient)
            (norm_nonneg _) (by linarith)
      _ = A := mul_one A
  · intro n x _
    exact hDbound i _
  · intro n x hx
    exact NormalizedPrediction.norm_fderiv_clock_le_scaled hpred predictor_preserves_norm
      (by linarith) hnormBound (n + 1) x hx.1
  · intro n x hx
    have hd : DifferentiableAt ℝ
        (SphereAngularInput.angularAmbient (2 ^ (n + 2))) x.2 :=
      (((hangular (2 ^ (n + 2))).of_le (by norm_num)).contDiffAt
        (hU.mem_nhds hx.2)).differentiableAt one_ne_zero
    have hh := norm_fderiv_comp_le hd (differentiableAt_snd (p := x))
    change ‖fderiv ℝ (angular n) x‖ ≤ K * (1 + 2 ^ (n + 2))
    apply hh.trans
    have hb : ‖fderiv ℝ (SphereAngularInput.angularAmbient (2 ^ (n + 2))) x.2‖ ≤
        K * (1 + (2 : ℝ) ^ (n + 2)) := by
      have := hangularBound (2 ^ (n + 2)) x.2 hx.2
      push_cast at this
      linarith [norm_nonneg (SphereAngularInput.angularAmbient (2 ^ (n + 2)) x.2)]
    calc
      _ ≤ (K * (1 + (2 : ℝ) ^ (n + 2))) * 1 := mul_le_mul hb
        (by rw [fderiv_snd]; exact ContinuousLinearMap.norm_snd_le ℝ ℝ SphereAmbient)
        (norm_nonneg _) (by positivity)
      _ = K * (1 + 2 ^ (n + 2)) := mul_one _

theorem exists_contDiffOn_ambientInput :
    ∃ (B : ℝ) (V : Set Ambient), 1 ≤ B ∧ IsOpen V ∧
      AmbientPrediction.cylinder ⊆ V ∧
      ∀ L : ℝ, B < L → 2 < L → ∀ i : Fin 3,
        ContDiffOn ℝ 1 (ambientInput L i) V := by
  obtain ⟨B, W, hB, hW, hsW, hreg⟩ := exists_contDiffOn_ambientInput_product
  exact ⟨B, Set.univ ×ˢ W, hB, isOpen_univ.prod hW,
    fun x hx => ⟨Set.mem_univ _, hsW hx.2⟩, hreg⟩

theorem ambientInput_eq_zero_of_preparation_eq_zero
    (L : ℝ) (i : Fin 3) (x : Ambient) (h : preparationCoeff x.1 = 0) :
    ambientInput L i x = 0 := by
  simp [ambientInput, predictionSummand, preparation, h]

theorem ambientInput_eq_zero_of_not_mem (L : ℝ) (i : Fin 3) (x : Ambient)
    (hx : x.1 ∉ Set.Ioo (8 : ℝ) 12) : ambientInput L i x = 0 := by
  apply ambientInput_eq_zero_of_preparation_eq_zero
  by_contra h
  exact hx (preparationCoeff_support ▸ h)

open scoped OnePoint

theorem horizontal_sphereOfComplex (z : ℂ) :
    SphereAngularInput.horizontal (sphereOfComplex z).val =
      (2 / (‖z‖ ^ 2 + 1) : ℝ) • z := by
  calc
    _ = (2 / (‖z‖ ^ 2 + 1) : ℝ) • ((z.re : ℂ) + (z.im : ℂ) * Complex.I) := by
      simp only [SphereAngularInput.horizontal, sphereOfComplex_val_zero,
        sphereOfComplex_val_one, Complex.real_smul]
      push_cast
      ring
    _ = _ := by rw [Complex.re_add_im]

theorem phase_complexSphereHomeomorph (z : OnePoint ℂ) :
    SphereAngularInput.phase (complexSphereHomeomorph z).val = Construction.phase z := by
  induction z using OnePoint.rec with
  | infty =>
      simp [SphereAngularInput.phase, SphereAngularInput.horizontal,
        chartNorthPole, chartNorthVector, Fin.ext_iff]
  | coe z =>
      rw [complexSphereHomeomorph_coe,
        SphereAngularInput.phase_eq_of_positive_scale
          (by positivity : (0 : ℝ) < 2 / (‖z‖ ^ 2 + 1))
          (horizontal_sphereOfComplex z)]
      simp [NormedSpace.normalize, Construction.phase_coe, Complex.real_smul,
        div_eq_mul_inv, mul_comm]

theorem cutoff_complexSphereHomeomorph (z : OnePoint ℂ) :
    SphereCutoffs.preparationCutoffAmbient (complexSphereHomeomorph z).val =
      SphereCutoffs.onePointPreparationCutoff z := by
  induction z using OnePoint.rec with
  | infty =>
      change SphereCutoffs.preparationCutoffAmbient chartNorthPole.val = 0
      apply SphereCutoffs.preparationCutoffAmbient_eq_zero_of_high
      norm_num [chartNorthPole, chartNorthVector, PiLp.single_apply, Fin.ext_iff]
  | coe z =>
      simp [SphereCutoffs.preparationCutoffAmbient,
        SphereCutoffs.affinePreparationCutoff, SphereCutoffs.affineHeight]

theorem angular_modelEmbedding (n : ℕ) (t : ℝ) (z : OnePoint ℂ) :
    angular n (PredictionModelBridge.modelEmbedding (t, z)) =
      (SphereCutoffs.onePointPreparationCutoff z : ℂ) *
        Construction.phase z ^ (2 ^ (n + 2)) := by
  change SphereAngularInput.angularAmbient _ (complexSphereHomeomorph z).val = _
  rw [SphereAngularInput.angularAmbient, phase_complexSphereHomeomorph,
    cutoff_complexSphereHomeomorph]

theorem predictedClock_modelEmbedding (D : Construction.SphereData)
    (hgate : D.gate = SphereCutoffs.onePointClockGate)
    (n : ℕ) (t : ℝ) (z : OnePoint ℂ) :
    predictedClock n (PredictionModelBridge.modelEmbedding (t, z)) =
      Construction.predictedClock D (n + 1) t z := by
  have hx : ‖(PredictionModelBridge.modelEmbedding (t, z)).2‖ = 1 :=
    mem_sphere_zero_iff_norm.mp (complexSphereHomeomorph z).property
  have hn := NormalizedPrediction.clock_eq_original_on_sphere
    (G := AmbientPrediction.predictor) predictor_preserves_norm hx (n + 1)
  exact hn.trans (PredictionModelBridge.predictedClock_eq D hgate (n + 1) t z).symm

theorem summand_modelEmbedding (D : Construction.SphereData)
    (hgate : D.gate = SphereCutoffs.onePointClockGate)
    (hcutoff : D.cutoff = SphereCutoffs.onePointPreparationCutoff)
    (i : Fin 3) (n : ℕ) (t : ℝ) (z : OnePoint ℂ) :
    predictionSummand preparation (readoutCoeff i) predictedClock angular D.L n
        (PredictionModelBridge.modelEmbedding (t, z)) =
      ((preparationCoeff t / 10 : ℝ) : ℂ) * Construction.inputTerm D i n t z := by
  rw [predictionSummand, predictedClock_modelEmbedding D hgate,
    angular_modelEmbedding]
  simp only [preparation, PredictionModelBridge.modelEmbedding, Construction.inputTerm,
    hcutoff, Complex.real_smul, Complex.ofReal_mul, Complex.ofReal_div,
    Complex.ofReal_pow, Complex.ofReal_inv, Complex.ofReal_ofNat]
  ring

theorem ambientInput_modelEmbedding (D : Construction.SphereData)
    (hgate : D.gate = SphereCutoffs.onePointClockGate)
    (hcutoff : D.cutoff = SphereCutoffs.onePointPreparationCutoff)
    (i : Fin 3) (t : ℝ) (z : OnePoint ℂ) :
    ambientInput D.L i (PredictionModelBridge.modelEmbedding (t, z)) =
      Construction.baseInput D i t z := by
  unfold ambientInput Construction.baseInput
  rw [← tsum_mul_left]
  exact tsum_congr (fun n => summand_modelEmbedding D hgate hcutoff i n t z)

theorem continuous_modelEmbedding : Continuous PredictionModelBridge.modelEmbedding :=
  continuous_fst.prodMk (continuous_subtype_val.comp
    (complexSphereHomeomorph.continuous.comp continuous_snd))

theorem exists_regular_baseInput :
    ∃ B : ℝ, 1 ≤ B ∧ ∀ D : Construction.SphereData,
      D.gate = SphereCutoffs.onePointClockGate →
      D.cutoff = SphereCutoffs.onePointPreparationCutoff →
      B < D.L → 2 < D.L → ∀ i : Fin 3,
      ContDiff ℝ 1 (fun x : ℝ × ℂ =>
        Construction.baseInput D i x.1 (x.2 : OnePoint ℂ)) ∧
      Continuous (fun x : ℝ × OnePoint ℂ => Construction.baseInput D i x.1 x.2) := by
  obtain ⟨B, V, hB, hV, hsub, hreg⟩ := exists_contDiffOn_ambientInput
  refine ⟨B, hB, ?_⟩
  intro D hgate hcutoff hBL hL i
  have hinput := hreg D.L hBL hL i
  constructor
  · have hc : ContDiffOn ℝ 1
        (ambientInput D.L i ∘ PredictionModelBridge.affineEmbedding) Set.univ :=
      hinput.comp PredictionModelBridge.contDiff_affineEmbedding.contDiffOn
        (fun x _ => hsub (PredictionModelBridge.affineEmbedding_mem_cylinder x))
    have heq : (ambientInput D.L i ∘ PredictionModelBridge.affineEmbedding) =
        (fun x : ℝ × ℂ => Construction.baseInput D i x.1 (x.2 : OnePoint ℂ)) := by
      funext x
      exact ambientInput_modelEmbedding D hgate hcutoff i x.1 (x.2 : OnePoint ℂ)
    rw [heq, contDiffOn_univ] at hc
    exact hc
  · have hc : Continuous (ambientInput D.L i ∘ PredictionModelBridge.modelEmbedding) :=
      hinput.continuousOn.comp_continuous continuous_modelEmbedding
        (fun x => hsub (PredictionModelBridge.modelEmbedding_mem_cylinder x))
    have heq : (ambientInput D.L i ∘ PredictionModelBridge.modelEmbedding) =
        (fun x : ℝ × OnePoint ℂ => Construction.baseInput D i x.1 x.2) := by
      funext x
      exact ambientInput_modelEmbedding D hgate hcutoff i x.1 x.2
    rwa [heq] at hc

end Problem340.ConcreteInputRegularity

end

end OAI