import OAI.Geometry.HarmonicGrowth.ControlWords

namespace OAI

noncomputable section


namespace HarmonicCounterexample.LinearODE
open scoped BigOperators Matrix.Norms.Frobenius

lemma finite_positive_thresholds {β : Type*} [Fintype β] [Nonempty β]
    (t ρ C : β → ℝ) (hρ : ∀ b,0 < ρ b) :
    ∃ T R H : ℝ,1 ≤ T ∧ 0 < R ∧ 1 ≤ H ∧
      (∀ b,t b ≤ T) ∧ (∀ b,R ≤ ρ b) ∧ (∀ b,C b ≤ H) := by
  classical
  obtain ⟨T,hT⟩ := Finite.exists_le t
  obtain ⟨H,hH⟩ := Finite.exists_le C
  refine ⟨max 1 T,Finset.univ.inf' Finset.univ_nonempty ρ,max 1 H,
    le_max_left _ _,?_,le_max_left _ _,fun b => (hT b).trans (le_max_right _ _),
    fun b => Finset.inf'_le ρ (Finset.mem_univ b),fun b => (hH b).trans (le_max_right _ _)⟩
  exact (Finset.lt_inf'_iff _).2 (fun b _ => hρ b)

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.FiniteControl.SmoothWord
open HarmonicCounterexample.LinearODE
open scoped Matrix.Norms.Frobenius
variable {β : Type*} [Fintype β] {ι : β → Type*}
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)]

lemma exp_apply (X : MatrixProduct ι) (b : β) :
    (NormedSpace.exp X) b=NormedSpace.exp (X b) := by
  exact NormedSpace.map_exp (Pi.evalAlgHom ℝ (fun b => Matrix (ι b) (ι b) ℝ) b)
    (continuous_apply b) X

lemma leftWord_apply (X : ℕ → MatrixProduct ι) (n : ℕ) (b : β) :
    leftWord X n b=leftWord (fun j => X j b) n := by
  induction n with
  | zero => rfl
  | succ n ih =>
    change (NormedSpace.exp (X n)) b*leftWord X n b=_
    rw [exp_apply,ih]
    rfl

/-- The actual product packet has exactly the actual block packet as each
factor; no norm or ODE product convention is changed in the assembly. -/
lemma actual_packet_apply {n : ℕ} (a : Fin n → ℝ) (X : Fin n → MatrixProduct ι) (b : β) :
    (flow (fun t => ContinuousLinearMap.mul ℝ (MatrixProduct ι)
      (unitPacketCoefficient a X t)) 1 1) b=
    flow (fun t => ContinuousLinearMap.mul ℝ (Matrix (ι b) (ι b) ℝ)
      (unitPacketCoefficient a (fun j => X j b) t)) 1 1 := by
  rw [actual_packet_endpoint,actual_packet_endpoint,leftWord_apply]
  congr 1
  funext j
  by_cases hj : j < n
  · simp only [extendWord,dite_eq_left hj,Pi.smul_apply]
  · simp only [extendWord,dite_eq_right hj,Pi.zero_apply]

end HarmonicCounterexample.FiniteControl.SmoothWord

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set HarmonicCounterexample.FiniteControl HarmonicCounterexample.FiniteControl.SmoothWord
open scoped ContDiff InnerProductSpace BigOperators Matrix.Norms.Frobenius
variable {ξ H κ : Type*} [Fintype ξ] [Nonempty ξ]
  {E : ξ → Type*} {ι : ξ → Type*} {n : ℕ} [NeZero n]
  [∀ b,NormedAddCommGroup (E b)] [∀ b,InnerProductSpace ℝ (E b)] [∀ b,FiniteDimensional ℝ (E b)]
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)]
  [NormedAddCommGroup H] [InnerProductSpace ℝ H] [FiniteDimensional ℝ H] [Fintype κ]
local instance (b : ξ) : NormedAddCommGroup (E b →L[ℝ] E b) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ (E b →L[ℝ] E b) := ContinuousLinearMap.toNormedSpace
local instance : NormedAddCommGroup (H →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedAddCommGroup
local instance : NormedSpace ℝ (H →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedSpace

/-- All retained blocks are controlled simultaneously, using one parameter ball
and thresholds chosen before ANY incoming histories. Both value and outgoing
slope below are the actual center-regular physical solutions. -/
theorem compact_simultaneous_physical_C1 (basis : ∀ b,OrthonormalBasis (ι b) ℝ (E b))
    (hbasis : OrthonormalBasis κ ℝ H) {K : Set H} (hK : IsCompact K)
    (r p₀ γ M : ℝ) (B β θ : ξ → ℝ) (D : ∀ b,Fin n → E b →L[ℝ] E b)
    (hD : ∀ b j v,inner ℝ v (D b j v) ≤ 0)
    (hBD : ∀ b j v,-(B b*‖v‖^2) ≤ inner ℝ v (D b j v))
    (hM : 0 ≤ M) (hB : ∀ b,0 ≤ B b) (hθ : ∀ b,0 < θ b) (hγ : 0 < γ)
    (hden : ∀ b,p₀+2*θ b ≠ 0) (hroot : ∀ b,β b*B b-p₀*θ b-θ b^2=0)
    (amps : Fin n → H → ℝ) (amps' : Fin n → H → H →L[ℝ] ℝ)
    (ha : ∀ x ∈ K,∀ j,HasFDerivAt (amps j) (amps' j x) x)
    (hc : ∀ j,ContinuousOn (amps j) K) (hd : ∀ j,ContinuousOn (amps' j) K) :
    ∃ T₀ ρ C : ℝ,1 ≤ T₀ ∧ 0 < ρ ∧ 1 ≤ C ∧ ∀ T ≥ T₀,
      ∀ (history : ∀ b,ℝ → E b →L[ℝ] E b) (α drift : ℝ → ℝ)
        (MH : ξ → ℝ) (Mb : ℝ) (l : ξ → ℝ) (B₀ a δ ε : ℝ) (S : Set H),
      IsOpen S → IsPreconnected S → S ⊆ K →
      (∀ b,ContDiff ℝ ∞ (history b)) → ContDiff ℝ ∞ α → Continuous drift →
      (∀ b,0 ≤ MH b) → 0 ≤ Mb → (∀ t,|α t| ≤ M) → (∀ t,0 ≤ α t) →
      (∀ t,|drift t| ≤ Mb) → (∀ b t,‖history b t‖ ≤ MH b) →
      (∀ b t v,0 ≤ inner ℝ v (history b t v)) →
      (∀ b,∀ t ∈ Icc a (a+T),history b t=α t • (B b • (1:E b →L[ℝ] E b))) →
      (∀ b,0 < l b) → (∀ b,∀ t ≤ 0,∀ v,history b t v=(l b*(l b+B₀)) • v) →
      (∀ t ≤ 0,drift t=B₀) → 0 ≤ a → 0 ≤ δ → 0 ≤ ε →
      (∀ b,∀ t ∈ Icc a (a+T),|α t-β b| ≤ δ) →
      (∀ t ∈ Icc a (a+T),|drift t-p₀| ≤ δ) →
      (∀ t ∈ Icc a (a+T),γ ≤ drift t) → δ+T⁻¹+ε ≤ ρ →
      (∀ b,‖orthogonalMatrix (basis b) (slope (history b) drift (l b) a)-θ b • (1:Matrix (ι b) (ι b) ℝ)‖ ≤ ε) →
      let A := fun b x => insertWord (history b) α r (B b • (1:E b →L[ℝ] E b)) (D b) (fun j => amps j x) a T
      let v := fun b t => scalarBaseline (fun s => α (a+s)*B b) (fun s => drift (a+s)) (θ b) (max 0 (t-a))
      let W := fun x b => orthogonalMatrix (basis b) (flow (fun t => ContinuousLinearMap.mul ℝ (E b →L[ℝ] E b)
        (unitPacketCoefficient (fun j => amps j x) (fun j => bergerSlowGenerator r (B b) (β b) p₀ (θ b) 1 (D b j)) t)) 1 1)
      let Y := fun x b => orthogonalMatrix (basis b) (Real.exp (-(∫ t in a..a+T,v b t)) •
        (operatorValue (A b x) drift (l b) (a+T)*Ring.inverse (operatorValue (A b x) drift (l b) a)))
      let Q := fun x b => orthogonalMatrix (basis b) (slope (A b x) drift (l b) (a+T))-θ b • (1:Matrix (ι b) (ι b) ℝ)
      ∀ x ∈ S,DifferentiableAt ℝ Y x ∧ DifferentiableAt ℝ Q x ∧
        max (max ‖Y x-W x‖ ‖fderiv ℝ Y x-fderiv ℝ W x‖)
          (max ‖Q x‖ ‖fderiv ℝ Q x‖) ≤ C*(δ+T⁻¹+ε) := by
  classical
  choose ts rs cs hts hrs hcs works using fun b => compact_inserted_matrix_C1
    (basis b) hbasis hK r (B b) (β b) p₀ (θ b) γ M (D b) (hD b) (hBD b)
    hM (hB b) (hθ b) hγ (hden b) (hroot b) amps amps' ha hc hd
  obtain ⟨T₀,ρ,C,hT₀,hρ,hC,ht,hρs,hCs⟩ := finite_positive_thresholds ts rs cs hrs
  refine ⟨T₀,ρ,C,hT₀,hρ,hC,?_⟩
  intro T hT history α drift MH Mb l B₀ a δ ε S hS hSc hSK hh hα hb hMH hMb hnα hαpos hnb
    hnH hHpos hround hl hcenter hbcenter ha₀ hδ hε hαclose hbclose hγb hsmall hin
  dsimp only
  intro x hx
  have hTpos : 0 < T := lt_of_lt_of_le zero_lt_one (hT₀.trans hT)
  have herr : 0 ≤ δ+T⁻¹+ε := by positivity
  have hprod : 0 ≤ C*(δ+T⁻¹+ε) := mul_nonneg (by linarith) herr
  have hlocal (b : ξ) := works b T ((ht b).trans hT) (history b) α drift (MH b) Mb (l b) B₀ a δ ε S
    hS hSc hSK (hh b) hα hb (hMH b) hMb hnα hαpos hnb (hnH b) (hHpos b) (hround b)
    (hl b) (hcenter b) hbcenter ha₀ hδ hε (hαclose b) hbclose hγb (hsmall.trans (hρs b)) (hin b) x hx
  have hm (b : ξ) : cs b*(δ+T⁻¹+ε) ≤ C*(δ+T⁻¹+ε) := mul_le_mul_of_nonneg_right (hCs b) herr
  have hv := finite_C1_error hprod (fun b => (hlocal b).1)
    (fun b => (orthogonalMatrix (basis b)).differentiableAt.comp x
      (actual_packet_differentiableAt amps
        (fun j => bergerSlowGenerator r (B b) (β b) p₀ (θ b) 1 (D b j))
        (fun j => (ha x (hSK hx) j).differentiableAt)))
    (fun b => ((le_max_left _ _).trans (hlocal b).2.2).trans (hm b))
  have hq := finite_C1_norm hprod (fun b => (hlocal b).2.1)
    (fun b => ((le_max_right _ _).trans (hlocal b).2.2).trans (hm b))
  exact ⟨hv.1,hq.1,max_le hv.2 hq.2⟩

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set
open scoped ContDiff BigOperators Matrix.Norms.Frobenius

/-- Restart of an actual scalar second-order equation on a diagonal leg. -/
theorem scalar_restart_on {A b f g : ℝ → ℝ} {c d MA Mb : ℝ}
    (hA : Continuous A) (hb : Continuous b) (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb)
    (hnA : ∀ t,|A t| ≤ MA) (hnb : ∀ t,|b t| ≤ Mb)
    (hfc : ContinuousOn f (Icc c d)) (hgc : ContinuousOn g (Icc c d))
    (hf : ∀ t ∈ Ico c d,HasDerivAt f (g t) t)
    (hg : ∀ t ∈ Ico c d,HasDerivAt g (A t*f t-b t*g t) t) :
    ∀ t ∈ Icc c d,f t=
      scalarU (fun s => A (c+s)) (fun s => b (c+s)) (t-c)*f c+
      scalarV (fun s => A (c+s)) (fun s => b (c+s)) (t-c)*g c := by
  let Ac := fun s => A (c+s)
  let bc := fun s => b (c+s)
  have hAc : Continuous Ac := hA.comp (continuous_const.add continuous_id)
  have hbc : Continuous bc := hb.comp (continuous_const.add continuous_id)
  have hnAc : ∀ s,|Ac s| ≤ MA := fun s => hnA _
  have hnbc : ∀ s,|bc s| ≤ Mb := fun s => hnb _
  let F := fun t => (f t,g t)
  let G := fun t => scalarPhase Ac bc (f c) (g c) (t-c)
  let C := block (fun t => ContinuousLinearMap.mul ℝ ℝ (A t)) b
  have hCb : ∀ t,‖C t‖ ≤ 1+MA+Mb := block_bound hMA hMb
    (fun t => (ContinuousLinearMap.opNorm_mul_apply_le ℝ ℝ _).trans (by simpa using hnA t)) hnb
  have hdG (t : ℝ) : HasDerivAt G (C t (G t)) t := by
    have hct : c+(t-c)=t := by ring
    have hh := (scalarPhase_deriv hAc hbc hMA hMb hnAc hnbc (f c) (g c) (t-c)).scomp t
      ((hasDerivAt_id t).sub_const c)
    simpa only [Function.comp_def,id_eq,one_smul,Ac,bc,add_sub_cancel_left,
      G,C,block_apply,ContinuousLinearMap.mul_apply',hct,smul_eq_mul] using hh
  have he := solution_unique_on_Icc (show 0 ≤ 1+MA+Mb by positivity)
    (fun t _ => hCb t) (hfc.prodMk hgc)
    ((continuous_iff_continuousAt.2 (fun t => (hdG t).continuousAt)).continuousOn)
    (fun t ht => by simpa only [F,C,block_apply,ContinuousLinearMap.mul_apply',smul_eq_mul] using (hf t ht).prodMk (hg t ht))
    (fun t _ => hdG t) (by simp only [G,sub_self,scalarPhase_init])
  intro t ht
  have ht' := congrArg Prod.fst (he ht)
  change f t=(scalarPhase Ac bc (f c) (g c) (t-c)).1 at ht'
  rw [scalarPhase_linear hAc hbc hMA hMb hnAc hnbc] at ht'
  simpa only [mul_comm] using ht'

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set
open scoped BigOperators Matrix.Norms.Frobenius
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def matrixEntry (i j : ι) : Matrix ι ι ℝ →L[ℝ] ℝ :=
  ((LinearMap.proj j : (ι → ℝ) →ₗ[ℝ] ℝ).comp (LinearMap.proj i)).toContinuousLinearMap

omit [DecidableEq ι] in
@[simp] lemma matrixEntry_apply (i j : ι) (X : Matrix ι ι ℝ) : matrixEntry i j X=X i j := rfl

/-- Actual entrywise diagonal propagation, retaining both incoming value and
velocity. No incoming stable eigenspace is imposed. -/
theorem matrix_diagonal_restart {lam : ι → ℝ → ℝ} {b : ℝ → ℝ}
    {F G : ℝ → Matrix ι ι ℝ} {c d Mb : ℝ} (MA : ι → ℝ)
    (hlam : ∀ i,Continuous (lam i)) (hb : Continuous b)
    (hMA : ∀ i,0 ≤ MA i) (hMb : 0 ≤ Mb)
    (hnlam : ∀ i t,|lam i t| ≤ MA i) (hnb : ∀ t,|b t| ≤ Mb)
    (hF : ContinuousOn F (Icc c d)) (hG : ContinuousOn G (Icc c d))
    (hdF : ∀ t ∈ Ico c d,HasDerivAt F (G t) t)
    (hdG : ∀ t ∈ Ico c d,HasDerivAt G
      (Matrix.diagonal (fun i => lam i t)*F t-b t • G t) t) :
    ∀ t ∈ Icc c d,F t=
      Matrix.diagonal (fun i => scalarU (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c))*F c+
      Matrix.diagonal (fun i => scalarV (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c))*G c := by
  intro t ht
  ext i j
  have hf (s : ℝ) (hs : s ∈ Ico c d) : HasDerivAt (fun u => F u i j) (G s i j) s :=
    (matrixEntry i j).hasFDerivAt.comp_hasDerivAt s (hdF s hs)
  have hg (s : ℝ) (hs : s ∈ Ico c d) : HasDerivAt (fun u => G u i j)
      (lam i s*F s i j-b s*G s i j) s := by
    have hh := (matrixEntry i j).hasFDerivAt.comp_hasDerivAt s (hdG s hs)
    change HasDerivAt (fun u => G u i j)
      ((Matrix.diagonal (fun i => lam i s)*F s-b s • G s) i j) s at hh
    simpa only [Matrix.sub_apply,Matrix.diagonal_mul,Matrix.smul_apply,
      smul_eq_mul] using hh
  have he := scalar_restart_on (hlam i) hb (hMA i) hMb (hnlam i) hnb
    ((matrixEntry i j).continuous.comp_continuousOn hF)
    ((matrixEntry i j).continuous.comp_continuousOn hG) hf hg t ht
  change F t i j=scalarU (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c)*F c i j+
    scalarV (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c)*G c i j at he
  simpa only [Matrix.add_apply,Matrix.diagonal_mul] using he

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
local instance : NormedAddCommGroup (E →L[ℝ] E) := ContinuousLinearMap.toNormedAddCommGroup
local instance : NormedSpace ℝ (E →L[ℝ] E) := ContinuousLinearMap.toNormedSpace
local instance : NormedAddCommGroup ((E →L[ℝ] E) →L[ℝ] Matrix ι ι ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance : NormedSpace ℝ ((E →L[ℝ] E) →L[ℝ] Matrix ι ι ℝ) := ContinuousLinearMap.toNormedSpace

/-- The complete prescribed diagonal leg for the actual center-regular value
fundamental matrix, not for a model first-order propagator. -/
theorem actual_diagonal_restart (basis : OrthonormalBasis ι ℝ E)
    {A : ℝ → E →L[ℝ] E} {b : ℝ → ℝ} {lam : ι → ℝ → ℝ}
    {MA Mb c d : ℝ} (N : ι → ℝ) (l : ℝ)
    (hA : Continuous A) (hb : Continuous b) (hlam : ∀ i,Continuous (lam i))
    (hMA : 0 ≤ MA) (hMb : 0 ≤ Mb) (hN : ∀ i,0 ≤ N i)
    (hnA : ∀ t,‖A t‖ ≤ MA) (hnb : ∀ t,|b t| ≤ Mb) (hnlam : ∀ i t,|lam i t| ≤ N i)
    (hdiag : ∀ t ∈ Ico c d,orthogonalMatrix basis (A t)=Matrix.diagonal (fun i => lam i t)) :
    ∀ t ∈ Icc c d,orthogonalMatrix basis (operatorValue A b l t)=
      Matrix.diagonal (fun i => scalarU (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c))*
        orthogonalMatrix basis (operatorValue A b l c)+
      Matrix.diagonal (fun i => scalarV (fun s => lam i (c+s)) (fun s => b (c+s)) (t-c))*
        orthogonalMatrix basis (operatorVelocity A b l c) := by
  have hf (t : ℝ) := orthogonalMatrix_hasDerivAt basis (operatorValue_deriv hA hb hMA hMb hnA hnb l t)
  have hg (t : ℝ) := orthogonalMatrix_hasDerivAt basis (operatorVelocity_deriv hA hb hMA hMb hnA hnb l t)
  apply matrix_diagonal_restart N hlam hb hN hMb hnlam hnb
    ((continuous_iff_continuousAt.2 (fun t => (hf t).continuousAt)).continuousOn)
    ((continuous_iff_continuousAt.2 (fun t => (hg t).continuousAt)).continuousOn)
    (fun t _ => hf t)
  intro t ht
  simpa only [map_sub,map_smul,orthogonalMatrix_mul,hdiag t ht] using hg t

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open scoped Matrix.Norms.Frobenius BigOperators
variable {ι : Type*} [Fintype ι] [DecidableEq ι]
local instance : NormedAddCommGroup ((ι → ℝ) →L[ℝ] Matrix ι ι ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance : NormedSpace ℝ ((ι → ℝ) →L[ℝ] Matrix ι ι ℝ) := ContinuousLinearMap.toNormedSpace

/-- The fixed Frobenius-coordinate norm cost of the diagonal embedding. -/
def diagonalL : (ι → ℝ) →L[ℝ] Matrix ι ι ℝ :=
  (Matrix.diagonalLinearMap ι ℝ ℝ).toContinuousLinearMap

@[simp] lemma diagonalL_apply (v : ι → ℝ) : diagonalL v=Matrix.diagonal v := rfl

/-- Exact normalization of a positive scalar diagonal leg, with a bound
independent of its length and anisotropy. -/
theorem diagonal_leg_normalizer (u v : ι → ℝ) {θ : ℝ}
    (hu : ∀ i,1 ≤ u i) (hv : ∀ i,0 ≤ v i) (hθ : 0 < θ) :
    ∃ D : (Matrix ι ι ℝ)ˣ,
      (D:Matrix ι ι ℝ)=Matrix.diagonal u+θ • Matrix.diagonal v ∧
      (∀ i,0 < (D:Matrix ι ι ℝ) i i) ∧
      ‖(↑D⁻¹:Matrix ι ι ℝ)*Matrix.diagonal v‖ ≤ ‖diagonalL (ι:=ι)‖*θ⁻¹ := by
  classical
  let d := fun i => u i+θ*v i
  have hd (i : ι) : 0 < d i := by
    have := hu i
    have := mul_nonneg hθ.le (hv i)
    dsimp [d]
    linarith
  let D : (Matrix ι ι ℝ)ˣ :=
    { val := Matrix.diagonal d
      inv := Matrix.diagonal (fun i => (d i)⁻¹)
      val_inv := by
        rw [Matrix.diagonal_mul_diagonal]
        simp only [mul_inv_cancel₀ (hd _).ne']
        exact Matrix.diagonal_one
      inv_val := by
        rw [Matrix.diagonal_mul_diagonal]
        simp only [inv_mul_cancel₀ (hd _).ne']
        exact Matrix.diagonal_one }
  refine ⟨D,?_,?_,?_⟩
  · change Matrix.diagonal d=_
    simp only [d,← Matrix.diagonal_smul,← Matrix.diagonal_add]
    rfl
  · intro i
    simpa only [D,Units.val_mk,Matrix.diagonal_apply_eq] using hd i
  · let k := fun i => v i/d i
    have hkn : ∀ i,|k i| ≤ θ⁻¹ := by
      intro i
      have hk0 : 0 ≤ k i := div_nonneg (hv i) (hd i).le
      rw [abs_of_nonneg hk0]
      apply (div_le_iff₀ (hd i)).2
      rw [inv_mul_eq_div]
      apply (le_div_iff₀ hθ).2
      dsimp [d]
      have := hu i
      nlinarith
    have hk : ‖k‖ ≤ θ⁻¹ := (pi_norm_le_iff_of_nonneg (inv_nonneg.2 hθ.le)).2 hkn
    have he : (↑D⁻¹:Matrix ι ι ℝ)*Matrix.diagonal v=diagonalL k := by
      change Matrix.diagonal (fun i => (d i)⁻¹)*Matrix.diagonal v=Matrix.diagonal k
      rw [Matrix.diagonal_mul_diagonal]
      congr 1
      funext i
      change (d i)⁻¹*v i=v i/d i
      rw [div_eq_mul_inv,mul_comm]
    rw [he]
    exact ((diagonalL (ι:=ι)).le_opNorm k).trans
      (mul_le_mul_of_nonneg_left hk (norm_nonneg _))

/-- The normalizer belongs to the ACTUAL scalar propagation columns, not
freely chosen diagonal data. -/
theorem actual_diagonal_normalizer {A : ι → ℝ → ℝ} {p : ℝ → ℝ}
    (hA : ∀ i,Continuous (A i)) (hp : Continuous p)
    (MA : ι → ℝ) {Mp t θ : ℝ} (hMA : ∀ i,0 ≤ MA i) (hMp : 0 ≤ Mp)
    (hAn : ∀ i s,|A i s| ≤ MA i) (hpn : ∀ s,|p s| ≤ Mp)
    (hAp : ∀ i s,0 ≤ s → 0 ≤ A i s) (ht : 0 ≤ t) (hθ : 0 < θ) :
    ∃ D : (Matrix ι ι ℝ)ˣ,
      (D:Matrix ι ι ℝ)=Matrix.diagonal (fun i => scalarU (A i) p t)+
        θ • Matrix.diagonal (fun i => scalarV (A i) p t) ∧
      (∀ i,0 < (D:Matrix ι ι ℝ) i i) ∧
      ‖(↑D⁻¹:Matrix ι ι ℝ)*Matrix.diagonal (fun i => scalarV (A i) p t)‖ ≤
        ‖diagonalL (ι:=ι)‖*θ⁻¹ := by
  apply diagonal_leg_normalizer _ _ (fun i => ?_) (fun i => ?_) hθ
  · exact (actual_scalar_leg_nonnegative (hA i) hp (hMA i) hMp (hAn i) hpn (hAp i) ht).1
  · exact (actual_scalar_leg_nonnegative (hA i) hp (hMA i) hMp (hAn i) hpn (hAp i) ht).2

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set HarmonicCounterexample.FiniteControl HarmonicCounterexample.FiniteControl.SmoothWord
open HarmonicCounterexample.FiniteControl.Frobenius HarmonicCounterexample.Transmission
open scoped ContDiff InnerProductSpace BigOperators Matrix.Norms.Frobenius
variable {ξ κ : Type*} [Fintype ξ] [Nonempty ξ] [Nonempty κ]
  {E : ξ → Type*} {ι : ξ → Type*}
  [∀ b,NormedAddCommGroup (E b)] [∀ b,InnerProductSpace ℝ (E b)] [∀ b,FiniteDimensional ℝ (E b)]
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)] [∀ b,Nontrivial (ι b)]
local instance (b : ξ) : NormedAddCommGroup (E b →L[ℝ] E b) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ (E b →L[ℝ] E b) := ContinuousLinearMap.toNormedSpace

/-- Fixed finite angular and radial constants. -/
structure PulseSystem (E : ξ → Type*) (ι : ξ → Type*) (κ : Type*)
    [∀ b,NormedAddCommGroup (E b)] [∀ b,InnerProductSpace ℝ (E b)] [∀ b,FiniteDimensional ℝ (E b)]
    [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)] where
  basis : ∀ b,OrthonormalBasis (ι b) ℝ (E b)
  r : ℝ
  p₀ : ℝ
  γ : ℝ
  M : ℝ
  B : ξ → ℝ
  β : ξ → ℝ
  θ : ξ → ℝ
  D : ∀ b,κ → E b →L[ℝ] E b
  hD : ∀ b j v,inner ℝ v (D b j v) ≤ 0
  hBD : ∀ b j v,-(B b*‖v‖^2) ≤ inner ℝ v (D b j v)
  hM : 0 ≤ M
  hB : ∀ b,0 ≤ B b
  hθ : ∀ b,0 < θ b
  hγ : 0 < γ
  hden : ∀ b,p₀+2*θ b ≠ 0
  hroot : ∀ b,β b*B b-p₀*θ b-θ b^2=0

variable (S : PulseSystem E ι κ)

def PulseSystem.generator (j : κ) : MatrixProduct ι := fun b =>
  orthogonalMatrix (S.basis b) (bergerSlowGenerator S.r (S.B b) (S.β b) S.p₀ (S.θ b) 1 (S.D b j))

/-- Raw center-regular history plus the quantitative hypotheses used on the
current pulse. This structure contains no transmission conclusion. -/
structure PulseHistory where
  history : ∀ b,ℝ → E b →L[ℝ] E b
  α : ℝ → ℝ
  drift : ℝ → ℝ
  MH : ξ → ℝ
  Mb : ℝ
  l : ξ → ℝ
  B₀ : ℝ
  a : ℝ
  T : ℝ
  δ : ℝ
  ε : ℝ
  smooth : ∀ b,ContDiff ℝ ∞ (history b)
  αsmooth : ContDiff ℝ ∞ α
  driftContinuous : Continuous drift
  MHnonneg : ∀ b,0 ≤ MH b
  Mbnonneg : 0 ≤ Mb
  αbound : ∀ t,|α t| ≤ S.M
  αnonneg : ∀ t,0 ≤ α t
  driftBound : ∀ t,|drift t| ≤ Mb
  bound : ∀ b t,‖history b t‖ ≤ MH b
  nonneg : ∀ b t v,0 ≤ inner ℝ v (history b t v)
  round : ∀ b,∀ t ∈ Icc a (a+T),history b t=α t • (S.B b • (1:E b →L[ℝ] E b))
  lpos : ∀ b,0 < l b
  center : ∀ b,∀ t ≤ 0,∀ v,history b t v=(l b*(l b+B₀)) • v
  driftCenter : ∀ t ≤ 0,drift t=B₀
  apos : 0 ≤ a
  δnonneg : 0 ≤ δ
  εnonneg : 0 ≤ ε
  αclose : ∀ b,∀ t ∈ Icc a (a+T),|α t-S.β b| ≤ δ
  driftClose : ∀ t ∈ Icc a (a+T),|drift t-S.p₀| ≤ δ
  driftLower : ∀ t ∈ Icc a (a+T),S.γ ≤ drift t
  incoming : ∀ b,‖orthogonalMatrix (S.basis b) (slope (history b) drift (l b) a)-S.θ b • (1:Matrix (ι b) (ι b) ℝ)‖ ≤ ε

/-- Fixed chronological smooth control data and a nonempty compact parameter
ball. Slot count is positive; a globally zero family is not substituted. -/
structure PhysicalWord (κ : Type*) where
  d : ℕ
  n : ℕ
  n_ne : n ≠ 0
  slot : Fin n → κ
  amps : Fin n → EuclideanSpace ℝ (Fin d) → ℝ
  smooth : ∀ j,ContDiff ℝ ∞ (amps j)
  radius : ℝ
  radius_pos : 0 < radius

namespace PhysicalWord
variable (w : PhysicalWord κ) (H : PulseHistory S)
abbrev Parameter := EuclideanSpace ℝ (Fin w.d)
def ball : Set w.Parameter := Metric.closedBall 0 w.radius

def coefficient (b : ξ) (x : w.Parameter) : ℝ → E b →L[ℝ] E b :=
  insertWord (H.history b) H.α S.r (S.B b • (1:E b →L[ℝ] E b))
    (fun j => S.D b (w.slot j)) (fun j => w.amps j x) H.a H.T

def baseline (b : ξ) (t : ℝ) : ℝ :=
  scalarBaseline (fun s => H.α (H.a+s)*S.B b) (fun s => H.drift (H.a+s)) (S.θ b) (max 0 (t-H.a))

def value (x : w.Parameter) : MatrixProduct ι := fun b =>
  orthogonalMatrix (S.basis b) (Real.exp (-(∫ t in H.a..H.a+H.T,baseline S H b t)) •
    (operatorValue (w.coefficient S H b x) H.drift (H.l b) (H.a+H.T)*
      Ring.inverse (operatorValue (w.coefficient S H b x) H.drift (H.l b) H.a)))

def defect (x : w.Parameter) : MatrixProduct ι := fun b =>
  orthogonalMatrix (S.basis b) (slope (w.coefficient S H b x) H.drift (H.l b) (H.a+H.T))-
    S.θ b • (1:Matrix (ι b) (ι b) ℝ)

def ideal (x : w.Parameter) : MatrixProduct ι :=
  flow (fun t => ContinuousLinearMap.mul ℝ (MatrixProduct ι)
    (unitPacketCoefficient (fun j => w.amps j x) (S.generator ∘ w.slot) t)) 1 1

end PhysicalWord
end HarmonicCounterexample.LinearODE

end

end OAI