import Mathlib

namespace OAI

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]

/-- The exact Peano--Baker iterates, with oriented integrals on the entire real line. -/
def term (A : ℝ → E →L[ℝ] E) (x : E) : ℕ → ℝ → E
  | 0, _ => x
  | n+1, t => ∫ s in (0:ℝ)..t, A s (term A x n s)

lemma term_continuous {A : ℝ → E →L[ℝ] E} (hA : Continuous A) (x : E) (n : ℕ) :
    Continuous (term A x n) := by
  induction n with
  | zero => exact continuous_const
  | succ n ih =>
    have hc := hA.clm_apply ih
    apply continuous_iff_continuousAt.2
    intro t
    exact (intervalIntegral.integral_hasDerivAt_right (hc.intervalIntegrable 0 t)
      hc.stronglyMeasurable.stronglyMeasurableAtFilter hc.continuousAt).continuousAt

lemma term_succ_hasDerivAt {A : ℝ → E →L[ℝ] E} (hA : Continuous A)
    (x : E) (n : ℕ) (t : ℝ) :
    HasDerivAt (term A x (n+1)) (A t (term A x n t)) t := by
  have hc := hA.clm_apply (term_continuous hA x n)
  exact intervalIntegral.integral_hasDerivAt_right (hc.intervalIntegrable 0 t)
    hc.stronglyMeasurable.stronglyMeasurableAtFilter hc.continuousAt

lemma term_bound {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x : E) (n : ℕ) (t : ℝ) :
    ‖term A x n t‖ ≤ ‖x‖ * M^n * |t|^n / (n.factorial:ℝ) := by
  induction n generalizing t with
  | zero => simp [term]
  | succ n ih =>
    have hc := hA.clm_apply (term_continuous hA x n)
    have hcf (s : ℝ) : ‖A s (term A x n s)‖ ≤
        (‖x‖*M^(n+1)/(n.factorial:ℝ)) * |s|^n := by
      calc
        _ ≤ ‖A s‖ * ‖term A x n s‖ := (A s).le_opNorm _
        _ ≤ M * (‖x‖*M^n*|s|^n/(n.factorial:ℝ)) :=
          mul_le_mul (hb s) (ih s) (norm_nonneg _) hM
        _ = _ := by rw [pow_succ]; ring
    change ‖∫ s in (0:ℝ)..t, A s (term A x n s)‖ ≤ _
    calc
      _ ≤ ∫ s in Set.uIoc 0 t, ‖A s (term A x n s)‖ :=
        intervalIntegral.norm_integral_le_integral_norm_uIoc
      _ ≤ ∫ s in Set.uIoc 0 t,
          (‖x‖*M^(n+1)/(n.factorial:ℝ)) * |s|^n := by
        apply integral_mono_ae
        · exact (hc.intervalIntegrable 0 t).def'.norm
        · exact ((continuous_const.mul (continuous_abs.pow n)).intervalIntegrable 0 t).def'
        · exact Filter.Eventually.of_forall hcf
      _ = ‖x‖ * M^(n+1) * |t|^(n+1) / ((n+1).factorial:ℝ) := by
        rw [integral_const_mul]
        have hi := integral_pow_abs_sub_uIoc (a := (0:ℝ)) (b := t) (n := n)
        simp only [sub_zero] at hi
        rw [hi, Nat.factorial_succ]
        push_cast
        field_simp

def flow (A : ℝ → E →L[ℝ] E) (x : E) (t : ℝ) : E := ∑' n, term A x n t



lemma term_summable {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x : E) (t : ℝ) :
    Summable (fun n => term A x n t) := by
  have hs := (Real.summable_pow_div_factorial (M*|t|)).mul_left ‖x‖
  apply hs.of_norm_bounded
  intro n
  simpa only [mul_pow, mul_div_assoc, mul_assoc] using term_bound hA hM hb x n t

lemma flow_eq {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x : E) (t : ℝ) :
    flow A x t = x + ∑' n, term A x (n+1) t := by
  exact (term_summable hA hM hb x t).tsum_eq_zero_add

omit [CompleteSpace E] in
lemma term_zero (A : ℝ → E →L[ℝ] E) (x : E) :
    ∀ n, term A x (n+1) 0 = 0 := by intros; simp [term]

omit [CompleteSpace E] in
lemma flow_initial (A : ℝ → E →L[ℝ] E) (x : E) : flow A x 0 = x := by
  unfold flow
  rw [tsum_eq_single 0]
  · rfl
  · intro n hn
    cases n with
    | zero => contradiction
    | succ n => exact term_zero A x n

/-- A global actual solution, before any positivity, transmission or growth estimates. -/
theorem flow_hasDerivAt {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x : E) (t : ℝ) :
    HasDerivAt (flow A x) (A t (flow A x t)) t := by
  let R : ℝ := |t|+1
  have hR : 0 < R := by dsimp [R]; positivity
  have hu : Summable (fun n => (‖x‖*M)*(M*R)^n/(n.factorial:ℝ)) := by
    simpa only [mul_div_assoc] using
      (Real.summable_pow_div_factorial (M*R)).mul_left (‖x‖*M)
  have hbound (n : ℕ) (y : ℝ) (hy : y ∈ Set.Ioo (-R) R) :
      ‖A y (term A x n y)‖ ≤ (‖x‖*M)*(M*R)^n/(n.factorial:ℝ) := by
    have hay : |y| ≤ R := abs_le.2 ⟨hy.1.le, hy.2.le⟩
    calc
      _ ≤ ‖A y‖ * ‖term A x n y‖ := (A y).le_opNorm _
      _ ≤ M * (‖x‖*M^n*|y|^n/(n.factorial:ℝ)) :=
        mul_le_mul (hb y) (term_bound hA hM hb x n y) (norm_nonneg _) hM
      _ ≤ M * (‖x‖*M^n*R^n/(n.factorial:ℝ)) := by
        gcongr
      _ = _ := by rw [mul_pow]; ring
  have hzero : Summable (fun n => term A x (n+1) 0) := by simp only [term_zero]; exact summable_zero
  have ht : t ∈ Set.Ioo (-R) R := by
    dsimp [R]
    constructor <;> linarith [le_abs_self t, neg_abs_le t]
  have hd := hasDerivAt_tsum_of_isPreconnected hu isOpen_Ioo isPreconnected_Ioo
    (fun n y _ => term_succ_hasDerivAt hA x n y) hbound
    (show (0:ℝ) ∈ Set.Ioo (-R) R by constructor <;> linarith) hzero ht
  have hmap := (A t).map_tsum (term_summable hA hM hb x t)
  change A t (flow A x t) = _ at hmap
  rw [← hmap] at hd
  have he : flow A x = fun y => x + ∑' n, term A x (n+1) y :=
    funext (flow_eq hA hM hb x)
  have hh := hd.const_add x
  rw [← he] at hh
  exact hh

lemma flow_smooth {A : ℝ → E →L[ℝ] E} (hA : ContDiff ℝ ∞ A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x : E) : ContDiff ℝ ∞ (flow A x) := by
  have hd := flow_hasDerivAt hA.continuous hM hb x
  have hder : deriv (flow A x) = fun t => A t (flow A x t) := funext fun t => (hd t).deriv
  apply contDiff_infty.2
  intro n
  induction n with
  | zero => exact contDiff_zero.2 (continuous_iff_continuousAt.2 fun t => (hd t).continuousAt)
  | succ n ih =>
    rw [show ((n+1:ℕ) : WithTop ℕ∞) = (n:WithTop ℕ∞)+1 by simp, contDiff_succ_iff_deriv]
    refine ⟨fun t => (hd t).differentiableAt, by simp, ?_⟩
    rw [hder]
    exact ((contDiff_infty.1 hA) n).clm_apply ih


omit [CompleteSpace E] in
lemma solution_unique {A : ℝ → E →L[ℝ] E} {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) {f g : ℝ → E} {t₀ : ℝ}
    (hf : ∀ t, HasDerivAt f (A t (f t)) t)
    (hg : ∀ t, HasDerivAt g (A t (g t)) t) (he : f t₀ = g t₀) : f = g := by
  apply ODE_solution_unique_univ (s := fun _ => Set.univ) (K := ⟨M,hM⟩)
    (fun t => ((A t).lipschitzWith.weaken (hb t)).lipschitzOnWith)
    (fun t => ⟨hf t, Set.mem_univ _⟩) (fun t => ⟨hg t, Set.mem_univ _⟩) he

lemma flow_injective {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (t : ℝ) :
    Function.Injective (fun x => flow A x t) := by
  intro x y he
  have hh := solution_unique hM hb (flow_hasDerivAt hA hM hb x)
    (flow_hasDerivAt hA hM hb y) he
  have hzero := congrFun hh 0
  simpa only [flow_initial] using hzero

lemma flow_add {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (x y : E) (t : ℝ) :
    flow A (x+y) t = flow A x t + flow A y t := by
  have hd (s : ℝ) : HasDerivAt (fun s => flow A x s + flow A y s)
      (A s (flow A x s + flow A y s)) s := by
    simpa only [map_add, Pi.add_def] using (flow_hasDerivAt hA hM hb x s).add
      (flow_hasDerivAt hA hM hb y s)
  have hh := solution_unique hM hb (flow_hasDerivAt hA hM hb (x+y)) hd
    (t₀ := 0) (by simp only [flow_initial])
  exact congrFun hh t

lemma flow_smul {A : ℝ → E →L[ℝ] E} (hA : Continuous A) {M : ℝ}
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (c : ℝ) (x : E) (t : ℝ) :
    flow A (c • x) t = c • flow A x t := by
  have hd (s : ℝ) : HasDerivAt (fun s => c • flow A x s)
      (A s (c • flow A x s)) s := by
    simpa only [map_smul, Pi.smul_def] using (flow_hasDerivAt hA hM hb x s).const_smul c
  have hh := solution_unique hM hb (flow_hasDerivAt hA hM hb (c • x)) hd
    (t₀ := 0) (by simp only [flow_initial])
  exact congrFun hh t

/-- Actual initial-data linearity, later used for independence of harmonic columns. -/
def flowLinear (A : ℝ → E →L[ℝ] E) (hA : Continuous A) (M : ℝ)
    (hM : 0 ≤ M) (hb : ∀ s, ‖A s‖ ≤ M) (t : ℝ) : E →ₗ[ℝ] E where
  toFun x := flow A x t
  map_add' x y := flow_add hA hM hb x y t
  map_smul' c x := flow_smul hA hM hb c x t

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

def block (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (t : ℝ) : E×E →L[ℝ] E×E :=
  (ContinuousLinearMap.snd ℝ E E).prod
    ((A t).comp (ContinuousLinearMap.fst ℝ E E) - b t • ContinuousLinearMap.snd ℝ E E)

lemma block_apply (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (t : ℝ) (v : E×E) :
    block A b t v = (v.2, A t v.1 - b t • v.2) := rfl

lemma block_eq (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (t : ℝ) :
    block A b t = (ContinuousLinearMap.inl ℝ E E).comp (ContinuousLinearMap.snd ℝ E E) +
      (ContinuousLinearMap.inr ℝ E E).comp
        ((A t).comp (ContinuousLinearMap.fst ℝ E E) - b t • ContinuousLinearMap.snd ℝ E E) := by
  ext v <;> simp [block]

lemma block_continuous {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) : Continuous (block A b) := by
  simp only [funext (block_eq A b)]
  exact continuous_const.add (continuous_const.clm_comp
    ((hA.clm_comp continuous_const).sub (hb.smul continuous_const)))

lemma block_smooth {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : ContDiff ℝ ∞ A) (hb : ContDiff ℝ ∞ b) : ContDiff ℝ ∞ (block A b) := by
  simp only [funext (block_eq A b)]
  exact contDiff_const.add (contDiff_const.clm_comp
    ((hA.clm_comp contDiff_const).sub (hb.smul contDiff_const)))

lemma block_bound {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ} {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hA : ∀ t, ‖A t‖ ≤ MA) (hb : ∀ t, |b t| ≤ Mb) (t : ℝ) :
    ‖block A b t‖ ≤ 1+MA+Mb := by
  rw [block, ContinuousLinearMap.opNorm_prod, Prod.norm_def]
  apply max_le
  · exact (ContinuousLinearMap.norm_snd_le ℝ E E).trans (by linarith)
  · calc
      _ ≤ ‖(A t).comp (ContinuousLinearMap.fst ℝ E E)‖ +
            ‖b t • ContinuousLinearMap.snd ℝ E E‖ := norm_sub_le _ _
      _ ≤ ‖A t‖ * ‖ContinuousLinearMap.fst ℝ E E‖ +
            |b t| * ‖ContinuousLinearMap.snd ℝ E E‖ := by
          rw [norm_smul, Real.norm_eq_abs]
          exact add_le_add (ContinuousLinearMap.opNorm_comp_le (A t) (ContinuousLinearMap.fst ℝ E E)) le_rfl
      _ ≤ MA*1+Mb*1 := by
        exact add_le_add
          (mul_le_mul (hA t) (ContinuousLinearMap.norm_fst_le ℝ E E) (norm_nonneg _) hMA)
          (mul_le_mul (hb t) (ContinuousLinearMap.norm_snd_le ℝ E E) (norm_nonneg _) hMb)
      _ ≤ _ := by linarith

def phase (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) (t : ℝ) : E×E :=
  flow (block A b) (x,l • x) t

def value (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) (t : ℝ) : E :=
  (phase A b l x t).1

def velocity (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) (t : ℝ) : E :=
  (phase A b l x t).2

lemma value_initial (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) :
    value A b l x 0 = x := by simp [value, phase, flow_initial]

lemma velocity_initial (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) :
    velocity A b l x 0 = l • x := by simp [velocity, phase, flow_initial]

variable [CompleteSpace E]

lemma value_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (t : ℝ) :
    HasDerivAt (value A b l x) (velocity A b l x t) t := by
  have hd := flow_hasDerivAt (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
    (block_bound hMA hMb hAn hbn) (x,l • x) t
  exact (ContinuousLinearMap.fst ℝ E E).hasFDerivAt.comp_hasDerivAt t hd

lemma velocity_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (t : ℝ) :
    HasDerivAt (velocity A b l x)
      (A t (value A b l x t) - b t • velocity A b l x t) t := by
  have hd := flow_hasDerivAt (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
    (block_bound hMA hMb hAn hbn) (x,l • x) t
  exact (ContinuousLinearMap.snd ℝ E E).hasFDerivAt.comp_hasDerivAt t hd

lemma value_smooth {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : ContDiff ℝ ∞ A) (hb : ContDiff ℝ ∞ b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) :
    ContDiff ℝ ∞ (value A b l x) := by
  exact (ContinuousLinearMap.fst ℝ E E).contDiff.comp
    (flow_smooth (block_smooth hA hb) (by positivity : 0 ≤ 1+MA+Mb)
      (block_bound hMA hMb hAn hbn) (x,l • x))

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]

/-- Exact matching to the regular Euclidean solution on the entire negative
logarithmic half-line, obtained by uniqueness rather than an asymptotic ansatz. -/
theorem phase_euclidean_tail {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    {l B : ℝ} (hAi : ∀ t ≤ 0, ∀ v, A t v = (l*(l+B)) • v)
    (hbi : ∀ t ≤ 0, b t = B) (x : E) {t : ℝ} (ht : t ≤ 0) :
    phase A b l x t = Real.exp (l*t) • (x,l • x) := by
  let f : ℝ → E×E := fun s => Real.exp (l*s) • (x,l • x)
  have hd (s : ℝ) : HasDerivAt (phase A b l x)
      (block A b s (phase A b l x s)) s :=
    flow_hasDerivAt (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
      (block_bound hMA hMb hAn hbn) (x,l • x) s
  have hf (s : ℝ) : HasDerivAt f ((Real.exp (l*s)*l) • (x,l • x)) s := by
    change HasDerivAt (fun s => Real.exp (l*s) • (x,l • x)) _ s
    convert (((hasDerivAt_id s).const_mul l).exp).smul_const (x,l • x) using 1 <;> first | rfl | simp only [id_eq, mul_one]
  have hfode (s : ℝ) (hs : s ≤ 0) : HasDerivAt f (block A b s (f s)) s := by
    convert hf s using 1
    rw [block_apply]
    dsimp only [f, Prod.smul_fst, Prod.smul_snd]
    rw [hAi s hs, hbi s hs]
    apply Prod.ext
    · simp only [Prod.smul_fst, smul_smul]
    · simp only [Prod.smul_snd, smul_smul]
      module
  have hunique := ODE_solution_unique_of_mem_Icc_left
    (s := fun _ => Set.univ) (K := ⟨1+MA+Mb, by positivity⟩)
    (a := t) (b := 0)
    (fun s _ => ((block A b s).lipschitzWith.weaken (block_bound hMA hMb hAn hbn s)).lipschitzOnWith)
    (continuous_iff_continuousAt.2 (fun s => (hd s).continuousAt)).continuousOn
    (fun s _ => (hd s).hasDerivWithinAt) (fun _ _ => Set.mem_univ _)
    (continuous_iff_continuousAt.2 (fun s => (hf s).continuousAt)).continuousOn
    (fun s hs => (hfode s hs.2).hasDerivWithinAt) (fun _ _ => Set.mem_univ _)
    (show phase A b l x 0 = f 0 by simp [phase, f, flow_initial])
  exact hunique ⟨le_rfl,ht⟩

lemma value_euclidean_tail {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    {l B : ℝ} (hAi : ∀ t ≤ 0, ∀ v, A t v = (l*(l+B)) • v)
    (hbi : ∀ t ≤ 0, b t = B) (x : E) {t : ℝ} (ht : t ≤ 0) :
    value A b l x t = Real.exp (l*t) • x := by
  exact congrArg Prod.fst (phase_euclidean_tail hA hb hMA hMb hAn hbn hAi hbi x ht)

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE

def integratingWeight (b : ℝ → ℝ) (t : ℝ) : ℝ :=
  Real.exp (∫ s in (0:ℝ)..t, b s)

lemma integratingWeight_pos (b : ℝ → ℝ) (t : ℝ) : 0 < integratingWeight b t :=
  Real.exp_pos _

lemma integratingWeight_initial (b : ℝ → ℝ) : integratingWeight b 0 = 1 := by
  simp [integratingWeight]

lemma integratingWeight_deriv {b : ℝ → ℝ} (hb : Continuous b) (t : ℝ) :
    HasDerivAt (integratingWeight b) (integratingWeight b t*b t) t := by
  exact (intervalIntegral.integral_hasDerivAt_right (hb.intervalIntegrable 0 t)
    hb.stronglyMeasurable.stronglyMeasurableAtFilter hb.continuousAt).exp

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
open scoped InnerProductSpace

/-- Exact weighted energy identity; no invertibility of the value block is assumed. -/
lemma weighted_energy_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) {y z : ℝ → E} {t : ℝ}
    (hy : HasDerivAt y (z t) t)
    (hz : HasDerivAt z (A t (y t)-b t • z t) t) :
    HasDerivAt (fun t => integratingWeight b t * ⟪y t,z t⟫_ℝ)
      (integratingWeight b t*(⟪y t,A t (y t)⟫_ℝ+‖z t‖^2)) t := by
  have hd := (integratingWeight_deriv hb t).fun_mul (hy.inner ℝ hz)
  convert hd using 1; first | rfl |
    (simp only [inner_sub_right, inner_smul_right, real_inner_self_eq_norm_sq]; ring)

lemma weighted_energy_monotone {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {y z : ℝ → E}
    (hy : ∀ t, HasDerivAt y (z t) t)
    (hz : ∀ t, HasDerivAt z (A t (y t)-b t • z t) t) :
    Monotone (fun t => integratingWeight b t * ⟪y t,z t⟫_ℝ) := by
  exact monotone_of_hasDerivAt_nonneg (fun t => weighted_energy_deriv hb (hy t) (hz t))
    (fun t => mul_nonneg (integratingWeight_pos b t).le (add_nonneg (hAp t _) (sq_nonneg _)))

/-- Center-regular initial data have a strictly positive pairing for all t≥0.
This rules out conjugate zeros and produces the value-block injectivity. -/
lemma regular_pairing_positive {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {y z : ℝ → E}
    (hy : ∀ t, HasDerivAt y (z t) t)
    (hz : ∀ t, HasDerivAt z (A t (y t)-b t • z t) t)
    {l : ℝ} (hl : 0 < l) (hinit : z 0 = l • y 0) (hne : y 0 ≠ 0)
    {t : ℝ} (ht : 0 ≤ t) : 0 < ⟪y t,z t⟫_ℝ := by
  have hm := weighted_energy_monotone hb hAp hy hz ht
  dsimp only at hm
  rw [integratingWeight_initial, one_mul, hinit, inner_smul_right,
    real_inner_self_eq_norm_sq] at hm
  have hnorm : 0 < ‖y 0‖^2 := sq_pos_of_pos (norm_pos_iff.2 hne)
  exact (mul_pos_iff_of_pos_left (integratingWeight_pos b t)).1 ((mul_pos hl hnorm).trans_le hm)

variable [CompleteSpace E]

lemma value_nonzero_of_nonnegative {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {l : ℝ} (hl : 0 < l)
    {x : E} (hx : x ≠ 0) {t : ℝ} (ht : 0 ≤ t) : value A b l x t ≠ 0 := by
  have he := regular_pairing_positive hb hAp
    (value_deriv hA hb hMA hMb hAn hbn l x)
    (velocity_deriv hA hb hMA hMb hAn hbn l x) hl
    (by simp only [value_initial, velocity_initial])
    (by simpa only [value_initial] using hx) ht
  intro hh
  rw [hh, inner_zero_left] at he
  exact lt_irrefl _ he

lemma value_linear {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l t : ℝ) :
    IsLinearMap ℝ (fun x => value A b l x t) := by
  refine ⟨?_, ?_⟩
  · intro x y
    change (flow (block A b) (x+y,l • (x+y)) t).1 = _
    rw [show (x+y,l • (x+y)) = (x,l • x)+(y,l • y) by simp [smul_add],
      flow_add (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
        (block_bound hMA hMb hAn hbn)]
    rfl
  · intro c x
    change (flow (block A b) (c • x,l • (c • x)) t).1 = _
    rw [show (c • x,l • (c • x)) = c • (x,l • x) by simp [smul_comm l c],
      flow_smul (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
        (block_bound hMA hMb hAn hbn)]
    rfl

lemma value_injective_of_nonnegative {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {l : ℝ} (hl : 0 < l)
    {t : ℝ} (ht : 0 ≤ t) : Function.Injective (fun x => value A b l x t) := by
  let F : E →ₗ[ℝ] E := (value_linear hA hb hMA hMb hAn hbn l t).mk'
  apply F.ker_eq_bot.1
  rw [LinearMap.ker_eq_bot']
  intro x hx
  by_contra hne
  exact value_nonzero_of_nonnegative hA hb hMA hMb hAn hbn hAp hl hne ht hx

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
open scoped InnerProductSpace

/-- Symplectic flux cancellation for two actual center-regular solutions. -/
lemma weighted_wronskian_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) {u v p q : ℝ → E} {t : ℝ}
    (hA : ∀ x y, ⟪A t x,y⟫_ℝ = ⟪x,A t y⟫_ℝ)
    (hu : HasDerivAt u (v t) t) (hv : HasDerivAt v (A t (u t)-b t • v t) t)
    (hp : HasDerivAt p (q t) t) (hq : HasDerivAt q (A t (p t)-b t • q t) t) :
    HasDerivAt (fun t => integratingWeight b t*(⟪u t,q t⟫_ℝ-⟪v t,p t⟫_ℝ)) 0 t := by
  have hd := (integratingWeight_deriv hb t).fun_mul ((hu.inner ℝ hq).fun_sub (hv.inner ℝ hp))
  convert hd using 1; first | rfl |
    (simp only [inner_sub_right,inner_sub_left,inner_smul_right,inner_smul_left,starRingEnd_apply,star_trivial,hA]; ring)

lemma weighted_wronskian_constant {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) (hA : ∀ t x y, ⟪A t x,y⟫_ℝ = ⟪x,A t y⟫_ℝ)
    {u v p q : ℝ → E}
    (hu : ∀ t, HasDerivAt u (v t) t) (hv : ∀ t, HasDerivAt v (A t (u t)-b t • v t) t)
    (hp : ∀ t, HasDerivAt p (q t) t) (hq : ∀ t, HasDerivAt q (A t (p t)-b t • q t) t)
    {l : ℝ} (hvi : v 0 = l • u 0) (hqi : q 0 = l • p 0) (t : ℝ) :
    ⟪u t,q t⟫_ℝ = ⟪v t,p t⟫_ℝ := by
  have hc := is_const_of_deriv_eq_zero (fun s =>
    (weighted_wronskian_deriv hb (hA s) (hu s) (hv s) (hp s) (hq s)).differentiableAt)
    (fun s => (weighted_wronskian_deriv hb (hA s) (hu s) (hv s) (hp s) (hq s)).deriv)
  have he := hc t 0
  rw [hvi,hqi,inner_smul_right,inner_smul_left,starRingEnd_apply,star_trivial,sub_self,mul_zero] at he
  exact sub_eq_zero.mp ((mul_eq_zero.mp he).resolve_left (integratingWeight_pos b t).ne')

variable [CompleteSpace E]

lemma regular_wronskian_zero {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAs : ∀ t x y, ⟪A t x,y⟫_ℝ = ⟪x,A t y⟫_ℝ)
    (l : ℝ) (x y : E) (t : ℝ) :
    ⟪value A b l x t,velocity A b l y t⟫_ℝ =
      ⟪velocity A b l x t,value A b l y t⟫_ℝ := by
  exact weighted_wronskian_constant (l := l) hb hAs
    (value_deriv hA hb hMA hMb hAn hbn l x) (velocity_deriv hA hb hMA hMb hAn hbn l x)
    (value_deriv hA hb hMA hMb hAn hbn l y) (velocity_deriv hA hb hMA hMb hAn hbn l y)
    (by simp only [velocity_initial,value_initial]) (by simp only [velocity_initial,value_initial]) t

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

/-- Left composition lifts a bounded coefficient to the Banach space of operators. -/
def leftAction (A : ℝ → E →L[ℝ] E) (t : ℝ) : (E →L[ℝ] E) →L[ℝ] (E →L[ℝ] E) :=
  ContinuousLinearMap.compL ℝ E E E (A t)

lemma leftAction_continuous {A : ℝ → E →L[ℝ] E} (hA : Continuous A) : Continuous (leftAction A) :=
  (ContinuousLinearMap.compL ℝ E E E).continuous.comp hA

lemma leftAction_smooth {A : ℝ → E →L[ℝ] E} (hA : ContDiff ℝ ∞ A) : ContDiff ℝ ∞ (leftAction A) :=
  (ContinuousLinearMap.compL ℝ E E E).contDiff.comp hA

lemma leftAction_norm_le (A : ℝ → E →L[ℝ] E) (t : ℝ) : ‖leftAction A t‖ ≤ ‖A t‖ := by
  apply le_trans ((ContinuousLinearMap.compL ℝ E E E).le_opNorm (A t))
  exact (mul_le_mul_of_nonneg_right (ContinuousLinearMap.norm_compL_le ℝ E E E) (norm_nonneg _)).trans_eq (one_mul _)

variable [CompleteSpace E]

def operatorValue (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (t : ℝ) : E →L[ℝ] E :=
  value (leftAction A) b l (ContinuousLinearMap.id ℝ E) t

def operatorVelocity (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (t : ℝ) : E →L[ℝ] E :=
  velocity (leftAction A) b l (ContinuousLinearMap.id ℝ E) t

lemma operatorValue_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l t : ℝ) :
    HasDerivAt (operatorValue A b l) (operatorVelocity A b l t) t :=
  value_deriv (leftAction_continuous hA) hb hMA hMb
    (fun t => (leftAction_norm_le A t).trans (hAn t)) hbn l (ContinuousLinearMap.id ℝ E) t

lemma operatorVelocity_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l t : ℝ) :
    HasDerivAt (operatorVelocity A b l)
      (A t * operatorValue A b l t - b t • operatorVelocity A b l t) t :=
  velocity_deriv (leftAction_continuous hA) hb hMA hMb
    (fun t => (leftAction_norm_le A t).trans (hAn t)) hbn l (ContinuousLinearMap.id ℝ E) t

lemma operatorValue_smooth {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : ContDiff ℝ ∞ A) (hb : ContDiff ℝ ∞ b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) :
    ContDiff ℝ ∞ (operatorValue A b l) :=
  value_smooth (leftAction_smooth hA) hb hMA hMb
    (fun t => (leftAction_norm_le A t).trans (hAn t)) hbn l (ContinuousLinearMap.id ℝ E)

lemma operatorValue_apply_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (s : ℝ) :
    HasDerivAt (fun s => operatorValue A b l s x) (operatorVelocity A b l s x) s := by
  simpa only [add_zero,map_zero] using
    (operatorValue_deriv hA hb hMA hMb hAn hbn l s).clm_apply (hasDerivAt_const s x)

lemma operatorVelocity_apply_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (s : ℝ) :
    HasDerivAt (fun s => operatorVelocity A b l s x)
      (A s (operatorValue A b l s x)-b s • operatorVelocity A b l s x) s := by
  simpa only [add_zero,map_zero,sub_apply,smul_apply,mul_apply_eq_comp] using
    (operatorVelocity_deriv hA hb hMA hMb hAn hbn l s).clm_apply (hasDerivAt_const s x)

lemma operatorPhase_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (s : ℝ) :
    HasDerivAt (fun s => (operatorValue A b l s x,operatorVelocity A b l s x))
      (block A b s (operatorValue A b l s x,operatorVelocity A b l s x)) s := by
  exact (operatorValue_apply_deriv hA hb hMA hMb hAn hbn l x s).prodMk
    (operatorVelocity_apply_deriv hA hb hMA hMb hAn hbn l x s)

omit [CompleteSpace E] in
lemma operatorPhase_initial (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) (x : E) :
    (operatorValue A b l 0 x,operatorVelocity A b l 0 x) = (x,l • x) := by
  simp only [operatorValue,operatorVelocity,value_initial,velocity_initial,
    ContinuousLinearMap.id_apply,smul_apply]

lemma operatorPhase_apply {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (t : ℝ) :
    (operatorValue A b l t x,operatorVelocity A b l t x) = phase A b l x t := by
  have hh : (fun t => (operatorValue A b l t x,operatorVelocity A b l t x)) =
      flow (block A b) (x,l • x) :=
    solution_unique (E := E×E) (A := block A b)
      (f := fun t => (operatorValue A b l t x,operatorVelocity A b l t x))
      (g := flow (block A b) (x,l • x)) (by positivity : 0 ≤ 1+MA+Mb) (block_bound hMA hMb hAn hbn)
      (operatorPhase_deriv hA hb hMA hMb hAn hbn l x)
      (flow_hasDerivAt (block_continuous hA hb) (by positivity : 0 ≤ 1+MA+Mb)
        (block_bound hMA hMb hAn hbn) (x,l • x))
      (t₀ := 0) (by rw [flow_initial]; exact operatorPhase_initial A b l x)
  exact congrFun hh t

lemma operatorValue_apply {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (t : ℝ) :
    operatorValue A b l t x = value A b l x t :=
  congrArg Prod.fst (operatorPhase_apply hA hb hMA hMb hAn hbn l x t)

lemma operatorVelocity_apply {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l : ℝ) (x : E) (t : ℝ) :
    operatorVelocity A b l t x = velocity A b l x t :=
  congrArg Prod.snd (operatorPhase_apply hA hb hMA hMb hAn hbn l x t)

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
open scoped InnerProductSpace
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]

/-- The logarithmic derivative of the actual center-regular value operator. -/
def slope (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l t : ℝ) : E →L[ℝ] E :=
  operatorVelocity A b l t * Ring.inverse (operatorValue A b l t)

lemma operatorValue_isUnit [FiniteDimensional ℝ E]
    {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {l : ℝ} (hl : 0 < l)
    {t : ℝ} (ht : 0 ≤ t) : IsUnit (operatorValue A b l t) := by
  have hi : Function.Injective (operatorValue A b l t) := by
    intro x y hxy
    apply value_injective_of_nonnegative hA hb hMA hMb hAn hbn hAp hl ht
    simpa only [operatorValue_apply hA hb hMA hMb hAn hbn] using hxy
  exact ContinuousLinearMap.isUnit_iff_bijective.2
    ⟨hi, LinearMap.surjective_of_injective hi⟩

omit [CompleteSpace E] in
lemma slope_value {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ} {l t : ℝ}
    (hV : IsUnit (operatorValue A b l t)) (x : E) :
    slope A b l t (operatorValue A b l t x) = operatorVelocity A b l t x := by
  change ((operatorVelocity A b l t * Ring.inverse (operatorValue A b l t)) *
    operatorValue A b l t) x = _
  rw [mul_assoc,Ring.inverse_mul_cancel _ hV,mul_one]

omit [CompleteSpace E] in
lemma slope_initial (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ) (l : ℝ) :
    slope A b l 0 = l • (1 : E →L[ℝ] E) := by
  simp only [slope,operatorValue,operatorVelocity,value_initial,velocity_initial]
  change (l • (1 : E →L[ℝ] E)) * Ring.inverse 1 = _
  simp

lemma slope_symmetric {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAs : ∀ t x y, ⟪A t x,y⟫_ℝ = ⟪x,A t y⟫_ℝ) (l t : ℝ)
    (hV : IsUnit (operatorValue A b l t)) : (slope A b l t).IsSymmetric := by
  intro x y
  obtain ⟨u,rfl⟩ := (ContinuousLinearMap.isUnit_iff_bijective.1 hV).2 x
  obtain ⟨v,rfl⟩ := (ContinuousLinearMap.isUnit_iff_bijective.1 hV).2 y
  change ⟪slope A b l t (operatorValue A b l t u),operatorValue A b l t v⟫_ℝ =
    ⟪operatorValue A b l t u,slope A b l t (operatorValue A b l t v)⟫_ℝ
  rw [slope_value hV,slope_value hV]
  simp only [operatorValue_apply hA hb hMA hMb hAn hbn,
    operatorVelocity_apply hA hb hMA hMb hAn hbn]
  exact (regular_wronskian_zero hA hb hMA hMb hAn hbn hAs l u v t).symm

lemma slope_nonnegative {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb)
    (hAp : ∀ t v, 0 ≤ ⟪v,A t v⟫_ℝ) {l t : ℝ} (hl : 0 < l) (ht : 0 ≤ t)
    (hV : IsUnit (operatorValue A b l t)) (x : E) : 0 ≤ ⟪x,slope A b l t x⟫_ℝ := by
  obtain ⟨u,rfl⟩ := (ContinuousLinearMap.isUnit_iff_bijective.1 hV).2 x
  rw [slope_value hV]
  simp only [operatorValue_apply hA hb hMA hMb hAn hbn,
    operatorVelocity_apply hA hb hMA hMb hAn hbn]
  by_cases hu : u = 0
  · subst u
    have hv := (value_linear hA hb hMA hMb hAn hbn l t).mk'.map_zero
    change value A b l 0 t = 0 at hv
    rw [hv,inner_zero_left]
  · exact (regular_pairing_positive hb hAp
      (value_deriv hA hb hMA hMb hAn hbn l u)
      (velocity_deriv hA hb hMA hMb hAn hbn l u) hl
      (by simp only [value_initial,velocity_initial])
      (by simpa only [value_initial] using hu) ht).le

lemma clm_inverse_deriv {V : ℝ → E →L[ℝ] E} {W : E →L[ℝ] E} {t : ℝ}
    (hV : IsUnit (V t)) (hD : HasDerivAt V W t) :
    HasDerivAt (fun s => Ring.inverse (V s))
      (-(Ring.inverse (V t) * W * Ring.inverse (V t))) t := by
  obtain ⟨v,hv⟩ := hV
  have hf : HasFDerivAt Ring.inverse
      (-ContinuousLinearMap.mulLeftRight ℝ (E →L[ℝ] E) (↑v⁻¹) (↑v⁻¹)) (V t) :=
    hv ▸ hasFDerivAt_ringInverse (𝕜 := ℝ) v
  have hd := hf.comp_hasDerivAt t hD
  simpa only [Function.comp_def,neg_apply,
    ContinuousLinearMap.mulLeftRight_apply,← hv,Ring.inverse_unit] using hd

lemma slope_deriv {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t, ‖A t‖ ≤ MA) (hbn : ∀ t, |b t| ≤ Mb) (l t : ℝ)
    (hV : IsUnit (operatorValue A b l t)) :
    HasDerivAt (slope A b l)
      (A t - b t • slope A b l t - slope A b l t * slope A b l t) t := by
  have hd := (operatorVelocity_deriv hA hb hMA hMb hAn hbn l t).mul
    (clm_inverse_deriv hV (operatorValue_deriv hA hb hMA hMb hAn hbn l t))
  have he : (A t * operatorValue A b l t - b t • operatorVelocity A b l t) *
      Ring.inverse (operatorValue A b l t) + operatorVelocity A b l t *
      -(Ring.inverse (operatorValue A b l t) * operatorVelocity A b l t *
        Ring.inverse (operatorValue A b l t)) =
      A t - b t • slope A b l t - slope A b l t * slope A b l t := by
    rw [sub_mul,smul_mul_assoc,mul_assoc,Ring.mul_inverse_cancel _ hV,mul_one]
    simp only [slope,mul_neg,mul_assoc,sub_eq_add_neg]
  exact he ▸ hd

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
open Set

/-- A genuine integrating-factor comparison on the half-line. -/
lemma integrating_factor_nonnegative (p f f' : ℝ → ℝ) (hp : Continuous p)
    (hf : ∀ t,HasDerivAt f (f' t) t) (h0 : 0 ≤ f 0)
    (hineq : ∀ t,0 ≤ t → 0 ≤ f' t+p t*f t) {t : ℝ} (ht : 0 ≤ t) : 0 ≤ f t := by
  let Q := fun s => ∫ u in (0:ℝ)..s,p u
  have hQ (s : ℝ) : HasDerivAt Q (p s) s :=
    intervalIntegral.integral_hasDerivAt_right (hp.intervalIntegrable 0 s)
      hp.stronglyMeasurable.stronglyMeasurableAtFilter hp.continuousAt
  have hd (s : ℝ) : HasDerivAt (fun u => f u*Real.exp (Q u))
      ((f' s+p s*f s)*Real.exp (Q s)) s := by
    apply ((hf s).mul (hQ s).exp).congr_deriv
    ring
  have hm : MonotoneOn (fun u => f u*Real.exp (Q u)) (Ici 0) :=
    monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0)
      (continuous_iff_continuousAt.2 (fun s => (hd s).continuousAt)).continuousOn
      (fun s _ => (hd s).hasDerivWithinAt)
      (fun s hs => mul_nonneg (hineq s (interior_subset hs)) (Real.exp_pos _).le)
  have h := hm (show (0:ℝ) ∈ Ici 0 by simp) ht ht
  have hQ0 : Q 0=0 := by simp [Q]
  change f 0*Real.exp (Q 0) ≤ f t*Real.exp (Q t) at h
  rw [hQ0,Real.exp_zero,mul_one] at h
  exact nonneg_of_mul_nonneg_left (h0.trans h) (Real.exp_pos _)

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
local notation "⟪" x ", " y "⟫" => inner ℝ x y

/-- Energy comparison proves the lower Riccati barrier directly for actual
second-order solutions, without presupposing a global Riccati solution. -/
lemma solution_energy_lower (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ)
    (y v : ℝ → E) (hb : Continuous b) (hy : ∀ t,HasDerivAt y (v t) t)
    (hv : ∀ t,HasDerivAt v (A t (y t)-b t • v t) t) (c : ℝ)
    (h0 : c*⟪y 0,y 0⟫ ≤ ⟪y 0,v 0⟫)
    (hA : ∀ t,0 ≤ t → ∀ z, (b t*c+c^2)*⟪z,z⟫ ≤ ⟪z,A t z⟫)
    {t : ℝ} (ht : 0 ≤ t) : c*⟪y t,y t⟫ ≤ ⟪y t,v t⟫ := by
  let F := fun s => ⟪y s,v s⟫-c*⟪y s,y s⟫
  let F' := fun s => ⟪y s,A s (y s)-b s • v s⟫+⟪v s,v s⟫-
    c*(⟪y s,v s⟫+⟪v s,y s⟫)
  have hd (s : ℝ) : HasDerivAt F (F' s) s :=
    ((hy s).inner ℝ (hv s)).sub (((hy s).inner ℝ (hy s)).const_mul c)
  have he (s : ℝ) : F' s+b s*F s =
      ⟪v s-c • y s,v s-c • y s⟫+⟪y s,A s (y s)⟫-
        (b s*c+c^2)*⟪y s,y s⟫ := by
    dsimp [F,F']
    simp only [inner_sub_left,inner_sub_right,inner_smul_left,inner_smul_right,
      conj_trivial,real_inner_comm (v s) (y s)]
    ring
  have hp := integrating_factor_nonnegative b F F' hb hd (sub_nonneg.2 h0)
    (fun s hs => by rw [he]; linarith [show 0 ≤ ⟪v s-c • y s,v s-c • y s⟫ by rw [real_inner_self_eq_norm_sq]; positivity,hA s hs (y s)]) ht
  exact sub_nonneg.1 hp

/-- Value vectors cannot vanish: the center-regular norm is nondecreasing. -/
lemma solution_norm_lower (A : ℝ → E →L[ℝ] E) (b : ℝ → ℝ)
    (y v : ℝ → E) (hb : Continuous b) (hy : ∀ t,HasDerivAt y (v t) t)
    (hv : ∀ t,HasDerivAt v (A t (y t)-b t • v t) t)
    (h0 : 0 ≤ ⟪y 0,v 0⟫)
    (hA : ∀ t,0 ≤ t → ∀ z,0 ≤ ⟪z,A t z⟫)
    {t : ℝ} (ht : 0 ≤ t) : ‖y 0‖ ≤ ‖y t‖ := by
  have hp (s : ℝ) (hs : 0 ≤ s) : 0 ≤ ⟪y s,v s⟫ := by
    simpa using solution_energy_lower A b y v hb hy hv 0 (by simpa using h0)
      (by simpa using hA) hs
  have hd (s : ℝ) : HasDerivAt (fun u => ⟪y u,y u⟫) (2*⟪y s,v s⟫) s := by
    apply ((hy s).inner ℝ (hy s)).congr_deriv
    rw [real_inner_comm (v s) (y s)]; ring
  have hm := monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici (0:ℝ))
    (continuous_iff_continuousAt.2 (fun s => (hd s).continuousAt)).continuousOn
    (fun s _ => (hd s).hasDerivWithinAt)
    (fun s hs => mul_nonneg (by norm_num) (hp s (interior_subset hs)))
  have h := hm (show (0:ℝ) ∈ Ici 0 by simp) ht ht
  change ⟪y 0,y 0⟫ ≤ ⟪y t,y t⟫ at h
  rw [real_inner_self_eq_norm_sq,real_inner_self_eq_norm_sq] at h
  nlinarith [norm_nonneg (y 0),norm_nonneg (y t)]

variable [CompleteSpace E]

/-- Actual center-regular value flow is norm-expanding for all nonnegative times. -/
theorem value_norm_lower {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t,‖A t‖ ≤ MA) (hbn : ∀ t,|b t| ≤ Mb)
    {l : ℝ} (hl : 0 ≤ l) (hpos : ∀ t,0 ≤ t → ∀ z,0 ≤ ⟪z,A t z⟫)
    (x : E) {t : ℝ} (ht : 0 ≤ t) : ‖x‖ ≤ ‖value A b l x t‖ := by
  have hi : 0 ≤ ⟪value A b l x 0,velocity A b l x 0⟫ := by
    rw [value_initial,velocity_initial,inner_smul_right]
    rw [real_inner_self_eq_norm_sq]
    exact mul_nonneg hl (sq_nonneg _)
  simpa only [value_initial] using solution_norm_lower A b (value A b l x) (velocity A b l x)
    hb (value_deriv hA hb hMA hMb hAn hbn l x)
    (velocity_deriv hA hb hMA hMb hAn hbn l x) hi hpos ht

end HarmonicCounterexample.LinearODE

end

noncomputable section
open Filter MeasureTheory
open scoped BigOperators Topology ENNReal ContDiff
open scoped Topology
open scoped Topology
open scoped Topology BigOperators ContDiff InnerProductSpace
open Filter MeasureTheory Set

namespace HarmonicCounterexample.LinearODE
variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]
open scoped RealInnerProductSpace

/-- Uniform strictly positive lower barrier for the already constructed ACTUAL
center-regular global Riccati slope. No Riccati existence is an assumption. -/
theorem slope_quadratic_lower {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hA : Continuous A) (hb : Continuous b) {MA Mb : ℝ}
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hAn : ∀ t,‖A t‖ ≤ MA) (hbn : ∀ t,|b t| ≤ Mb)
    {l c t : ℝ} (hc : c ≤ l) (ht : 0 ≤ t)
    (hpos : ∀ s,0 ≤ s → ∀ z,(b s*c+c^2)*(inner ℝ z z) ≤ (inner ℝ z (A s z)))
    (hV : IsUnit (operatorValue A b l t)) (x : E) :
    c*‖x‖^2 ≤ (inner ℝ x (slope A b l t x)) := by
  obtain ⟨u,rfl⟩ := (ContinuousLinearMap.isUnit_iff_bijective.1 hV).2 x
  rw [slope_value hV]
  simp only [operatorValue_apply hA hb hMA hMb hAn hbn,
    operatorVelocity_apply hA hb hMA hMb hAn hbn]
  have hi : c*(inner ℝ (value A b l u 0) (value A b l u 0)) ≤
      (inner ℝ (value A b l u 0) (velocity A b l u 0)) := by
    rw [value_initial,velocity_initial,inner_smul_right,real_inner_self_eq_norm_sq]
    exact mul_le_mul_of_nonneg_right hc (sq_nonneg _)
  simpa only [real_inner_self_eq_norm_sq] using
    solution_energy_lower A b (value A b l u) (velocity A b l u) hb
      (value_deriv hA hb hMA hMb hAn hbn l u)
      (velocity_deriv hA hb hMA hMb hAn hbn l u) c hi hpos ht

end HarmonicCounterexample.LinearODE

end

end OAI