Blame for lean/OAI/Geometry/HarmonicGrowth/GlobalControl.lean

import OAI.Geometry.HarmonicGrowth.PulseSystem
import OAI.Geometry.HarmonicGrowth.AngularStream

namespace OAI

noncomputable section


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

lemma weighted_slope_gap_deriv {A S : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) {C t : ℝ} (hS : (S t).IsSymmetric)
    (hD : HasDerivAt S (A t-b t • S t-S t*S t) t) (v : E) :
    HasDerivAt (fun s => integratingWeight (fun s => 2*C+b s) s * ⟪v,C • v-S s v⟫_ℝ)
      (integratingWeight (fun s => 2*C+b s) t *
        (‖C • v-S t v‖^2+(C^2+b t*C)*‖v‖^2-⟪v,A t v⟫_ℝ)) t := by
  have hv : HasDerivAt (fun s => C • v-S s v)
      (-(A t v-b t • S t v-S t (S t v))) t := by
    simpa only [map_zero,add_zero,sub_apply,smul_apply,mul_apply_eq_comp,zero_sub] using
      (hasDerivAt_const t (C • v)).fun_sub (hD.clm_apply (hasDerivAt_const t v))
  have hd := (integratingWeight_deriv (b := fun s => 2*C+b s) (continuous_const.add hb) t).fun_mul
    ((hasDerivAt_const t v).inner ℝ hv)
  have hs : ⟪v,S t (S t v)⟫_ℝ = ‖S t v‖^2 := by
    calc
      ⟪v,S t (S t v)⟫_ℝ = ⟪S t v,S t v⟫_ℝ := (hS v (S t v)).symm
      _ = ‖S t v‖^2 := real_inner_self_eq_norm_sq _
  have hn : ‖C • v-S t v‖^2 = C^2*‖v‖^2-2*C*⟪v,S t v⟫_ℝ+‖S t v‖^2 := by
    rw [norm_sub_sq_real,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs,
      real_inner_smul_left]
    ring
  convert hd using 1; first | rfl |
    (simp only [inner_zero_left,inner_neg_right,inner_sub_right,
      inner_smul_right,real_inner_self_eq_norm_sq,hs,hn]; ring)

lemma riccati_quadratic_upper {A S : ℝ → E →L[ℝ] E} {b : ℝ → ℝ}
    (hb : Continuous b) {C l MA Mb : ℝ} (hC : 0 ≤ C) (hlC : l ≤ C)
    (hbnd : ∀ t, |b t| ≤ Mb) (hCbound : MA ≤ C^2-Mb*C)
    (hAbnd : ∀ t v, ⟪v,A t v⟫_ℝ ≤ MA*‖v‖^2)
    (hS : ∀ t, 0 ≤ t → (S t).IsSymmetric)
    (hD : ∀ t, 0 ≤ t → HasDerivAt S (A t-b t • S t-S t*S t) t)
    (hi : S 0 = l • (1 : E →L[ℝ] E)) {t : ℝ} (ht : 0 ≤ t) (v : E) :
    ⟪v,S t v⟫_ℝ ≤ C*‖v‖^2 := by
  let F (s : ℝ) := integratingWeight (fun s => 2*C+b s) s * ⟪v,C • v-S s v⟫_ℝ
  have hnonneg (s : ℝ) : 0 ≤ ‖C • v-S s v‖^2+(C^2+b s*C)*‖v‖^2-⟪v,A s v⟫_ℝ := by
    have hb0 : -Mb ≤ b s := (abs_le.1 (hbnd s)).1
    have hcoef : MA ≤ C^2+b s*C := by
      nlinarith [mul_le_mul_of_nonneg_right hb0 hC]
    have := mul_le_mul_of_nonneg_right hcoef (sq_nonneg ‖v‖)
    have := hAbnd s v
    nlinarith [sq_nonneg ‖C • v-S s v‖]
  have hmono : MonotoneOn F (Set.Ici (0:ℝ)) := by
    apply monotoneOn_of_hasDerivWithinAt_nonneg (convex_Ici 0)
    · intro s hs
      exact (weighted_slope_gap_deriv hb (hS s hs) (hD s hs) v).continuousAt.continuousWithinAt
    · intro s hs
      exact (weighted_slope_gap_deriv hb (hS s (interior_subset hs))
        (hD s (interior_subset hs)) v).hasDerivWithinAt
    · intro s _
      exact mul_nonneg (integratingWeight_pos _ _).le (hnonneg s)
  have hzero : 0 ≤ F 0 := by
    simp only [F,hi,integratingWeight_initial,one_mul,smul_apply,one_apply_eq_self,
      inner_sub_right,inner_smul_right,real_inner_self_eq_norm_sq]
    nlinarith [sq_nonneg ‖v‖]
  have hpos : 0 ≤ F t := hzero.trans (hmono (by simp : (0:ℝ) ∈ Set.Ici (0:ℝ)) ht ht)
  have hiq : 0 ≤ ⟪v,C • v-S t v⟫_ℝ :=
    (mul_nonneg_iff_of_pos_left (integratingWeight_pos _ _)).1 hpos
  simpa only [inner_sub_right,inner_smul_right,real_inner_self_eq_norm_sq,sub_nonneg] using hiq

lemma symmetric_norm_bound {S : E →L[ℝ] E} {C : ℝ} (hC : 0 ≤ C)
    (hs : S.IsSymmetric) (hpos : ∀ v, 0 ≤ ⟪v,S v⟫_ℝ)
    (hb : ∀ v, ⟪v,S v⟫_ℝ ≤ C*‖v‖^2) : ‖S‖ ≤ C := by
  rw [S.norm_eq_iSup_rayleighQuotient hs]
  apply ciSup_le
  intro v
  by_cases hv : v = 0
  · simp [hv,hC]
  · have hn : 0 < ‖v‖^2 := sq_pos_of_pos (norm_pos_iff.2 hv)
    have hp := hpos v
    have hupper := hb v
    change |⟪S v,v⟫_ℝ / ‖v‖^2| ≤ C
    rw [real_inner_comm v (S v),abs_of_nonneg (div_nonneg hp hn.le)]
    exact (div_le_iff₀ hn).2 hupper

end HarmonicCounterexample.LinearODE

end

noncomputable section


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

/-- The history-independent Riccati bound is proved for the actual center-regular
PB solution. It is not an assumption on an arbitrary incoming solution. -/
theorem actual_slope_norm_bound {A : ℝ → E →L[ℝ] E} {p : ℝ → ℝ}
    (hA : Continuous A) (hp : Continuous p) {MA Mp : ℝ}
    (hMA : 0 ≤ MA) (hMp : 0 ≤ Mp)
    (hAn : ∀ t,‖A t‖ ≤ MA) (hpn : ∀ t,|p t| ≤ Mp)
    (hAs : ∀ t x y,inner ℝ (A t x) y=inner ℝ x (A t y))
    (hAp : ∀ t x,0 ≤ inner ℝ x (A t x))
    {l B : ℝ} (hl : 0 < l) (hAc : ∀ t ≤ 0,∀ x,A t x=(l*(l+B)) • x)
    (hpc : ∀ t ≤ 0,p t=B) {t : ℝ} (ht : 0 ≤ t) :
    ‖slope A p l t‖ ≤ l+MA+Mp+1 := by
  let C := l+MA+Mp+1
  have hC : 0 ≤ C := by dsimp [C];linarith
  have hCbound : MA ≤ C^2-Mp*C := by
    have hc1 : 1 ≤ C-Mp := by dsimp [C];linarith
    have hc2 : MA ≤ C := by dsimp [C];linarith
    have hm := mul_le_mul_of_nonneg_left hc1 hC
    nlinarith
  have hu (s : ℝ) := actual_value_unit_all_time hA hp hMA hMp hAn hpn hAp hl hAc hpc s
  have hsym (s : ℝ) : (slope A p l s).IsSymmetric :=
    slope_symmetric hA hp hMA hMp hAn hpn hAs l s (hu s)
  apply symmetric_norm_bound hC (hsym t)
  · exact slope_nonnegative hA hp hMA hMp hAn hpn hAp hl ht (hu t)
  · apply riccati_quadratic_upper hp hC (show l ≤ C by dsimp [C];linarith)
      hpn hCbound
    · intro s x
      calc
        inner ℝ x (A s x) ≤ ‖x‖*‖A s x‖ := real_inner_le_norm _ _
        _ ≤ ‖x‖*(MA*‖x‖) := mul_le_mul_of_nonneg_left
          (((A s).le_opNorm x).trans (mul_le_mul_of_nonneg_right (hAn s) (norm_nonneg x)))
          (norm_nonneg x)
        _ = MA*‖x‖^2 := by ring
    · intro s _;exact hsym s
    · intro s _;exact slope_deriv hA hp hMA hMp hAn hpn l s (hu s)
    · exact slope_initial A p l
    · exact ht

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses
open scoped Topology Matrix.Norms.Frobenius InnerProductSpace
variable {E ι : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
  [FiniteDimensional ℝ E] [Fintype ι] [DecidableEq ι]
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

/-- A single late threshold resets EVERY positive symmetric bounded history.
Only the actual preceding round interval is used. -/
theorem uniform_round_reset (basis : OrthonormalBasis ι ℝ E)
    {α p : ℝ → ℝ} (hp : Continuous p) {β p₀ γ θ B l B₀ MA Mp : ℝ}
    (hαlim : Tendsto α atTop (𝓝 β)) (hplim : Tendsto p atTop (𝓝 p₀))
    (hγ : 0 < γ) (hθ : 0 < θ) (hpl : ∀ᶠ t in atTop,γ ≤ p t)
    (hroot : β*B-p₀*θ-θ^2=0) (hMA : 0 ≤ MA) (hMp : 0 ≤ Mp)
    (hpn : ∀ t,|p t| ≤ Mp) (hl : 0 < l) (hpc : ∀ t ≤ 0,p t=B₀)
    {ε : ℝ} (hε : 0 < ε) :
    ∃ J : ℕ,∀ j,J ≤ j → ∀ A : ℝ → E →L[ℝ] E,
      Continuous A → (∀ t,‖A t‖ ≤ MA) →
      (∀ t x y,inner ℝ (A t x) y=inner ℝ x (A t y)) →
      (∀ t x,0 ≤ inner ℝ x (A t x)) →
      (∀ t ≤ 0,∀ x,A t x=(l*(l+B₀)) • x) →
      (∀ t ∈ Icc (time j+3*pulse j+dwell j) (time (j+1)),
        A t=α t • (B • (1:E →L[ℝ] E))) →
      ‖orthogonalMatrix basis (slope A p l (time (j+1)))-θ • (1:Matrix ι ι ℝ)‖ ≤ ε := by
  let lam := γ+θ
  have hlam : 0 < lam := by dsimp [lam];linarith
  let C := ‖orthogonalMatrix basis‖*(l+MA+Mp+1)+|θ| * ‖(1:Matrix ι ι ℝ)‖
  let M := ε/2*lam
  have hM : 0 < M := mul_pos (by linarith) hlam
  have hroot' : β*B-(p₀*θ+θ^2)=0 := by linarith
  have hf : Tendsto (fun t : ℝ => ‖(α t*B-(p t*θ+θ^2)) • (1:Matrix ι ι ℝ)‖)
      atTop (𝓝 0) := by
    have hh := (((hαlim.mul_const B).sub ((hplim.mul_const θ).add_const (θ^2))).smul_const
      (1:Matrix ι ι ℝ)).norm
    simpa only [hroot',zero_smul,norm_zero] using hh
  obtain ⟨a₀,ha₀⟩ := eventually_atTop.1 ((hf.eventually (gt_mem_nhds hM)).and hpl)
  have he : Tendsto (fun j => C*Real.exp (-lam*pulse j)) atTop (𝓝 0) := by
    have hh := (Real.tendsto_exp_neg_atTop_nhds_zero.comp
      (pulse_atTop_limit.const_mul_atTop hlam)).const_mul C
    simpa only [Function.comp_apply,neg_mul,mul_zero] using hh
  obtain ⟨J,hJ⟩ := eventually_atTop.1
    ((time_atTop.eventually_ge_atTop a₀).and (he.eventually (gt_mem_nhds (show 0<ε/2 by linarith))))
  refine ⟨J,fun j hj A hA hAn hAs hAp hAc hround => ?_⟩
  let a := time j+3*pulse j+dwell j
  have ha : 0 ≤ a := by dsimp [a];linarith [time_pos j,pulse_pos j,dwell_pos j]
  have hab : a ≤ time (j+1) := by dsimp [a];rw [time_succ];linarith [pulse_pos j]
  have hat (t : ℝ) (ht : t ∈ Icc a (time (j+1))) : a₀ ≤ t := by
    have := (hJ j hj).1
    dsimp [a] at ht
    linarith [ht.1,pulse_pos j,dwell_pos j]
  have hinit : ‖orthogonalMatrix basis (slope A p l a)-θ • (1:Matrix ι ι ℝ)‖ ≤ C := by
    calc
      _ ≤ ‖orthogonalMatrix basis (slope A p l a)‖+‖θ • (1:Matrix ι ι ℝ)‖ := norm_sub_le _ _
      _ ≤ ‖orthogonalMatrix basis‖*(l+MA+Mp+1)+|θ| * ‖(1:Matrix ι ι ℝ)‖ := by
        rw [norm_smul,Real.norm_eq_abs]
        exact add_le_add (((orthogonalMatrix basis).le_opNorm _).trans
          (mul_le_mul_of_nonneg_left (actual_slope_norm_bound hA hp hMA hMp hAn hpn hAs hAp hl hAc hpc ha)
            (norm_nonneg _))) le_rfl
      _ = C := rfl
  have hforce (t : ℝ) (ht : t ∈ Icc a (time (j+1))) :
      ‖orthogonalMatrix basis (A t)-(p t*θ+θ^2) • (1:Matrix ι ι ℝ)‖ ≤ M := by
    rw [hround t ht,map_smul,map_smul,orthogonalMatrix_one,smul_smul,← sub_smul]
    exact (ha₀ t (hat t ht)).1.le
  have hh := actual_round_reset basis hA hp hMA hMp hAn hpn hAp hl hAc hpc ha
    hlam hM.le (fun t ht => (ha₀ t (hat t ht)).2) hforce hinit
    (time (j+1)) ⟨hab,le_rfl⟩
  have hlen : time (j+1)-a=pulse j := by dsimp [a];rw [time_succ];ring
  rw [hlen] at hh
  have hdiv : M/lam=ε/2 := by dsimp [M];exact mul_div_cancel_right₀ _ (ne_of_gt hlam)
  change _ ≤ C*Real.exp (-lam*pulse j)+M/lam at hh
  rw [hdiv] at hh
  linarith [(hJ j hj).2]

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open scoped Topology ContDiff InnerProductSpace 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

/-- Primitive radial coefficients and fixed angular operators. All fields are
scalar/asymptotic or pointwise geometric facts; no transmission/reset/growth
conclusion is part of this data. -/
structure HistoryGeometry (S : PulseSystem E ι κ) where
  D₀ : ∀ b,E b →L[ℝ] E b
  D₀nonpos : ∀ b v,inner ℝ v (D₀ b v) ≤ 0
  BD₀ : ∀ b v,-(S.B b*‖v‖^2) ≤ inner ℝ v (D₀ b v)
  D₀symm : ∀ b x y,inner ℝ (D₀ b x) y=inner ℝ x (D₀ b y)
  Dsymm : ∀ b j x y,inner ℝ (S.D b j x) y=inner ℝ x (S.D b j y)
  qstar : ℝ
  qstar_ge : 1 ≤ qstar
  l : ξ → ℝ
  lpos : ∀ b,0 < l b
  B₀ : ℝ
  B_eq : ∀ b,S.B b=l b*(l b+B₀)
  α : ℝ → ℝ
  drift : ℝ → ℝ
  Mp : ℝ
  Mpnonneg : 0 ≤ Mp
  αsmooth : ContDiff ℝ ∞ α
  driftContinuous : Continuous drift
  αbound : ∀ t,|α t| ≤ S.M
  αnonneg : ∀ t,0 ≤ α t
  driftBound : ∀ t,|drift t| ≤ Mp
  αcenter : ∀ t ≤ 0,α t=1
  driftCenter : ∀ t ≤ 0,drift t=B₀
  αlimit : ∀ b,Tendsto α atTop (𝓝 (S.β b))
  driftLimit : Tendsto drift atTop (𝓝 S.p₀)
  driftLower : ∀ᶠ t in atTop,S.γ ≤ drift t

variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n] (slot : Fin n → κ)

def HistoryGeometry.coefficient (s : ℕ → Fin n → ℝ) (j0 : ℕ) (b : ξ) (t : ℝ) : E b →L[ℝ] E b :=
  G.α t • angular S.r (S.B b • (1:E b →L[ℝ] E b)) (G.D₀ b) (fun i => S.D b (slot i)) s G.qstar j0 t

def HistoryGeometry.bound (b : ξ) : ℝ := S.M *
  (angular_uniform_bound S.r (S.B b • (1:E b →L[ℝ] E b)) (G.D₀ b)
    (fun i => S.D b (slot i)) G.qstar_ge).choose

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.bound_nonneg (b : ξ) : 0 ≤ G.bound slot b :=
  mul_nonneg S.hM (angular_uniform_bound S.r (S.B b • (1:E b →L[ℝ] E b)) (G.D₀ b)
    (fun i => S.D b (slot i)) G.qstar_ge).choose_spec.1

variable (s : ℕ → Fin n → ℝ) (j0 : ℕ)
  (hpos : ∀ j,j0 ≤ j → ∀ t i,packetStretch (s j) (pulse j) t i ∈ Icc (1/2:ℝ) (3/2))

include hpos

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.coefficient_smooth (b : ξ) : ContDiff ℝ ∞ (G.coefficient slot s j0 b) :=
  G.αsmooth.smul (angular_smooth S.r _ _ _ s G.qstar_ge j0
    (fun j hj t i => by linarith [(hpos j hj t i).1]))

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.coefficient_bound (b : ξ) (t : ℝ) :
    ‖G.coefficient slot s j0 b t‖ ≤ G.bound slot b := by
  rw [HistoryGeometry.coefficient,norm_smul,Real.norm_eq_abs]
  apply mul_le_mul (G.αbound t)
    ((angular_uniform_bound S.r (S.B b • (1:E b →L[ℝ] E b)) (G.D₀ b)
      (fun i => S.D b (slot i)) G.qstar_ge).choose_spec.2 s j0 hpos t)
    (norm_nonneg _) S.hM

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.coefficient_nonnegative (b : ξ) (t : ℝ) (x : E b) :
    0 ≤ inner ℝ x (G.coefficient slot s j0 b t x) := by
  simp only [HistoryGeometry.coefficient,smul_apply,inner_smul_right]
  apply mul_nonneg (G.αnonneg t)
  apply angular_nonnegative S.r (S.B b) (G.D₀ b) (fun i => S.D b (slot i)) s G.qstar_ge j0 hpos
  · intro d x;cases d with
    | none => exact G.D₀nonpos b x
    | some i => exact S.hD b (slot i) x
  · intro d x;cases d with
    | none => exact G.BD₀ b x
    | some i => exact S.hBD b (slot i) x

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.coefficient_symmetric (b : ξ) (t : ℝ) (x y : E b) :
    inner ℝ (G.coefficient slot s j0 b t x) y=inner ℝ x (G.coefficient slot s j0 b t y) := by
  simp only [HistoryGeometry.coefficient,smul_apply,real_inner_smul_left,inner_smul_right]
  congr 1
  apply angular_symmetric S.r (S.B b) (G.D₀ b) (fun i => S.D b (slot i)) s G.qstar_ge j0 hpos
  intro d x y;cases d with
  | none => exact G.D₀symm b x y
  | some i => exact G.Dsymm b (slot i) x y

omit hpos [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.coefficient_center (b : ξ) (t : ℝ) (ht : t ≤ 0) (x : E b) :
    G.coefficient slot s j0 b t x=(G.l b*(G.l b+G.B₀)) • x := by
  rw [HistoryGeometry.coefficient,angular_initial S.r _ _ _ s (ht.trans (time_pos j0).le),
    G.αcenter t ht,one_smul,G.B_eq b]
  rfl

omit hpos [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.coefficient_round (b : ξ) {j : ℕ} (hj : j0 ≤ j) (hz : s j=0)
    (t : ℝ) (ht : t ∈ Icc (time j) (time j+pulse j)) :
    G.coefficient slot s j0 b t=G.α t • (S.B b • (1:E b →L[ℝ] E b)) := by
  rw [HistoryGeometry.coefficient,angular_zero_pulse S.r _ _ _ s hj hz ht.1 ht.2]

omit hpos [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.coefficient_rest (b : ξ) (j : ℕ)
    (t : ℝ) (ht : t ∈ Icc (time j+3*pulse j+dwell j) (time (j+1))) :
    G.coefficient slot s j0 b t=G.α t • (S.B b • (1:E b →L[ℝ] E b)) := by
  rw [HistoryGeometry.coefficient,angular_rest S.r _ _ _ s ht.1 ht.2]

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open scoped Topology ContDiff InnerProductSpace 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
variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n] (slot : Fin n → κ)

omit [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
/-- Uniform reset for the explicit smooth angular stream, including the first
active period and arbitrary prior admissible control choices. -/
theorem HistoryGeometry.uniform_incoming {ε : ℝ} (hε : 0 < ε) :
    ∃ J : ℕ,∀ j0 j,J ≤ j → ∀ s : ℕ → Fin n → ℝ,
      (∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2)) →
      ∀ b,‖orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j))-
        S.θ b • (1:Matrix (ι b) (ι b) ℝ)‖ ≤ ε := by
  classical
  have hex (b : ξ) := uniform_round_reset (S.basis b) G.driftContinuous (G.αlimit b) G.driftLimit
    S.hγ (S.hθ b) G.driftLower (S.hroot b) (G.bound_nonneg slot b) G.Mpnonneg
    G.driftBound (G.lpos b) G.driftCenter hε
  choose J hJ using hex
  refine ⟨Finset.univ.sup J+1,fun j0 j hj s hpos b => ?_⟩
  have hji : J b ≤ j-1 := by
    have hsup := Finset.le_sup (s:=Finset.univ) (f:=J) (Finset.mem_univ b)
    omega
  have he : j-1+1=j := by omega
  have hh := hJ b (j-1) hji (G.coefficient slot s j0 b)
    (G.coefficient_smooth slot s j0 hpos b).continuous
    (G.coefficient_bound slot s j0 hpos b)
    (G.coefficient_symmetric slot s j0 hpos b)
    (G.coefficient_nonnegative slot s j0 hpos b)
    (G.coefficient_center slot s j0 b)
    (G.coefficient_rest slot s j0 b (j-1))
  simpa only [he] using hh

omit [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.uniform_radial_tail {δ : ℝ} (hδ : 0 < δ) :
    ∃ J : ℕ,∀ j,J ≤ j → ∀ t,time j ≤ t →
      (∀ b,|G.α t-S.β b| ≤ δ) ∧ |G.drift t-S.p₀| ≤ δ ∧ S.γ ≤ G.drift t := by
  have hα : ∀ᶠ t in atTop,∀ b,|G.α t-S.β b| ≤ δ := by
    apply Filter.eventually_all.2
    intro b
    have hh : Tendsto (fun t => |G.α t-S.β b|) atTop (𝓝 0) := by
      simpa only [sub_self,abs_zero] using ((G.αlimit b).sub_const (S.β b)).abs
    exact (hh.eventually (gt_mem_nhds hδ)).mono (fun _ h => h.le)
  have hp : Tendsto (fun t => |G.drift t-S.p₀|) atTop (𝓝 0) := by
    simpa only [sub_self,abs_zero] using (G.driftLimit.sub_const S.p₀).abs
  obtain ⟨a,ha⟩ := eventually_atTop.1 (hα.and ((hp.eventually (gt_mem_nhds hδ)).and G.driftLower))
  obtain ⟨J,hJ⟩ := eventually_atTop.1 (time_atTop.eventually_ge_atTop a)
  exact ⟨J,fun j hj t ht => ⟨(ha t ((hJ j hj).trans ht)).1,
    (ha t ((hJ j hj).trans ht)).2.1.le,(ha t ((hJ j hj).trans ht)).2.2⟩⟩

omit [Nonempty ξ] [Nonempty κ] [∀ b, Nontrivial (ι b)] in
/-- All scalar and incoming thresholds simultaneously, chosen BEFORE the
start index, entire control stream, and current history. -/
theorem HistoryGeometry.eventual_history_conditions (T₀ : ℝ) {ρ : ℝ} (hρ : 0 < ρ) :
    ∃ J : ℕ,∀ j0 j,J ≤ j0 → j0 ≤ j →
      T₀ ≤ pulse j ∧ ρ/4+(pulse j)⁻¹+ρ/4 ≤ ρ ∧
      (∀ t,time j ≤ t → (∀ b,|G.α t-S.β b| ≤ ρ/4) ∧
        |G.drift t-S.p₀| ≤ ρ/4 ∧ S.γ ≤ G.drift t) ∧
      ∀ s : ℕ → Fin n → ℝ,
        (∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2)) →
        ∀ b,‖orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j))-
          S.θ b • (1:Matrix (ι b) (ι b) ℝ)‖ ≤ ρ/4 := by
  have hquarter : 0 < ρ/4 := by linarith
  obtain ⟨J₁,hJ₁⟩ := G.uniform_incoming slot hquarter
  obtain ⟨J₂,hJ₂⟩ := G.uniform_radial_tail hquarter
  have hi : Tendsto (fun j => (pulse j)⁻¹) atTop (𝓝 0) :=
    tendsto_inv_atTop_zero.comp pulse_atTop_limit
  obtain ⟨J₃,hJ₃⟩ := eventually_atTop.1 ((pulse_atTop_limit.eventually_ge_atTop T₀).and
    (hi.eventually (gt_mem_nhds (show 0 < ρ/2 by linarith))))
  refine ⟨max J₁ (max J₂ J₃),fun j0 j hj0 hj => ?_⟩
  have hh := hj0.trans hj
  have h1 : J₁ ≤ j := (le_max_left _ _).trans hh
  have h2 : J₂ ≤ j := (le_max_left _ _).trans ((le_max_right _ _).trans hh)
  have h3 : J₃ ≤ j := (le_max_right _ _).trans ((le_max_right _ _).trans hh)
  exact ⟨(hJ₃ j h3).1,by linarith [(hJ₃ j h3).2],hJ₂ j h2,hJ₁ j0 j h1⟩

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
local instance (d : ℕ) : NormedAddCommGroup (EuclideanSpace ℝ (Fin d) →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedAddCommGroup
local instance (d : ℕ) : NormedSpace ℝ (EuclideanSpace ℝ (Fin d) →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedSpace

omit [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma PhysicalWord.ideal_factor (S : PulseSystem E ι κ) (w : PhysicalWord κ) :
    (fun x b => orthogonalMatrix (S.basis b) (flow (fun t => ContinuousLinearMap.mul ℝ (E b →L[ℝ] E b)
        (unitPacketCoefficient (fun j => w.amps j x) (fun j => bergerSlowGenerator S.r (S.B b) (S.β b) S.p₀ (S.θ b) 1 (S.D b (w.slot j))) t)) 1 1))=w.ideal S := by
  funext x b
  rw [orthogonalMatrix_packet]
  exact (actual_packet_apply (fun j => w.amps j x) (S.generator ∘ w.slot) b).symm

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma PhysicalWord.value_factor (S : PulseSystem E ι κ) (w : PhysicalWord κ) (H : PulseHistory S) :
    (fun x b => orthogonalMatrix (S.basis b) (Real.exp (-(∫ t in H.a..H.a+H.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)))) •
        (operatorValue (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) H.drift (H.l b) (H.a+H.T)*
        Ring.inverse (operatorValue (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) H.drift (H.l b) H.a)))) = w.value S H := rfl

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma PhysicalWord.defect_factor (S : PulseSystem E ι κ) (w : PhysicalWord κ) (H : PulseHistory S) :
    (fun x b => orthogonalMatrix (S.basis b) (slope (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)
      H.drift (H.l b) (H.a+H.T))-S.θ b • (1:Matrix (ι b) (ι b) ℝ)) = w.defect S H := rfl

omit [Nonempty κ] [∀ b,Nontrivial (ι b)] in
/-- Packaged uniform estimate with precisely the data that occur in a recursive
center-regular geometric construction. -/
theorem word_physical_C1 (S : PulseSystem E ι κ) (w : PhysicalWord κ) :
    ∃ T₀ ρ C : ℝ,1 ≤ T₀ ∧ 0 < ρ ∧ 1 ≤ C ∧
      ∀ H : PulseHistory S,T₀ ≤ H.T → H.δ+H.T⁻¹+H.ε ≤ ρ →
      ∀ x ∈ w.ball,
        DifferentiableAt ℝ (w.value S H) x ∧ DifferentiableAt ℝ (w.defect S H) x ∧
        max (max ‖w.value S H x-w.ideal S x‖ ‖fderiv ℝ (w.value S H) x-fderiv ℝ (w.ideal S) x‖)
          (max ‖w.defect S H x‖ ‖fderiv ℝ (w.defect S H) x‖) ≤ C*(H.δ+H.T⁻¹+H.ε) := by
  classical
  let : NeZero w.n := ⟨w.n_ne⟩
  obtain ⟨threshold,smallness,constant,hthreshold,hsmallness,hconstant,hestimate⟩ :=
    compact_simultaneous_physical_C1 S.basis
      (EuclideanSpace.basisFun (Fin w.d) ℝ) (isCompact_closedBall _ _) S.r S.p₀ S.γ S.M S.B S.β S.θ
      (fun block index => S.D block (w.slot index))
      (fun block index => S.hD block (w.slot index))
      (fun block index => S.hBD block (w.slot index))
      S.hM S.hB S.hθ S.hγ S.hden S.hroot w.amps
      (fun index => fderiv ℝ (w.amps index))
      (fun point (_ : point ∈ Metric.closedBall (0:w.Parameter) (w.radius+1)) index =>
        ((w.smooth index).differentiable (by simp) point).hasFDerivAt)
      (fun index => (w.smooth index).continuous.continuousOn)
      (fun index => ((w.smooth index).continuous_fderiv (by simp)).continuousOn)
  refine ⟨threshold,smallness,constant,hthreshold,hsmallness,hconstant,?_⟩
  intro H hT hsmall x hx
  have hlocal := hestimate H.T hT H.history H.α H.drift H.MH H.Mb H.l H.B₀ H.a H.δ H.ε
    (Metric.ball (0:w.Parameter) (w.radius+1))
    Metric.isOpen_ball (convex_ball _ _).isPreconnected Metric.ball_subset_closedBall
    H.smooth H.αsmooth H.driftContinuous H.MHnonneg H.Mbnonneg H.αbound H.αnonneg
    H.driftBound H.bound H.nonneg H.round H.lpos H.center H.driftCenter H.apos H.δnonneg H.εnonneg
    H.αclose H.driftClose H.driftLower hsmall H.incoming
  have hball : w.ball ⊆ Metric.ball (0:w.Parameter) (w.radius+1) :=
    Metric.closedBall_subset_ball (by linarith)
  simp only [← w.ideal_factor S,← w.value_factor S H,← w.defect_factor S H]
  exact hlocal x (hball hx)


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
attribute [local instance 100] LieRing.ofAssociativeRing
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
local instance (d : ℕ) : NormedAddCommGroup (EuclideanSpace ℝ (Fin d) →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedAddCommGroup
local instance (d : ℕ) : NormedSpace ℝ (EuclideanSpace ℝ (Fin d) →L[ℝ] MatrixProduct ι) := ContinuousLinearMap.toNormedSpace

/-- The uniform local producer: the genuine simultaneous Lie packet admits
exact physical whole-period tuning, with all thresholds chosen before histories
and BEFORE the bounded complete diagonal-leg normalizers. -/
theorem local_physical_tuning (S : PulseSystem E ι κ)
    (htrace : ∀ j b,(S.generator j b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range S.generator))
    (target : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ)
    {K₀ : ℝ} (hK₀ : 0 ≤ K₀) :
    ∃ (w : PhysicalWord κ) (T₀ ρ : ℝ),1 ≤ T₀ ∧ 0 < ρ ∧
      ∀ H : PulseHistory S,T₀ ≤ H.T → H.δ+H.T⁻¹+H.ε ≤ ρ →
      ∀ K : MatrixProduct ι,‖K‖ ≤ K₀ →
      ∃ x ∈ w.ball,∀ b,∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
        wholePeriod K (w.defect S H x) (w.value S H x) b=
          c • ((slProductToUnits target:MatrixProduct ι) b) := by
  classical
  obtain ⟨d,n,hn,slot,amps,A,ha,hΦs,hΦ₀,hΦjet⟩ :=
    smooth_SL_packet_submersion S.generator htrace hfull target
  let Φ := fun x => flow (fun t => ContinuousLinearMap.mul ℝ (MatrixProduct ι)
    (unitPacketCoefficient (fun j => amps j x) (S.generator ∘ slot) t)) 1 1
  have hΦs' : ContDiff ℝ ∞ Φ := hΦs
  obtain ⟨R,σ,hR,hσ,hatt⟩ := Frobenius.whole_period_uniform_attainment (slProductToUnits target) Φ
    (fderiv ℝ Φ) A hΦs'.continuous (hΦs'.continuous_fderiv (by simp)) hΦ₀ (by convert! hΦjet using 1) hK₀
  let w : PhysicalWord κ := ⟨d,n,hn.out,slot,amps,ha,R,hR⟩
  obtain ⟨T₀,ρ,C,hT₀,hρ,hC,hworks⟩ := word_physical_C1 S w
  have hCpos : 0 < C := lt_of_lt_of_le zero_lt_one hC
  refine ⟨w,T₀,min ρ (σ/C),hT₀,lt_min hρ (div_pos hσ hCpos),?_⟩
  intro H hT hsmall K hK
  have heσ : C*(H.δ+H.T⁻¹+H.ε) ≤ σ := by
    have he := (le_div_iff₀ hCpos).1 (hsmall.trans (min_le_right ρ (σ/C)))
    simpa only [mul_comm] using he
  have hlocal := hworks H hT (hsmall.trans (min_le_left ρ (σ/C)))
  apply hatt K (w.defect S H) (w.value S H) (fderiv ℝ (w.defect S H)) (fderiv ℝ (w.value S H)) hK
  · intro x hx;exact (hlocal x hx).2.1.hasFDerivAt
  · intro x hx;exact (hlocal x hx).1.hasFDerivAt
  · intro x hx;exact ((le_max_left _ _).trans ((le_max_right _ _).trans (hlocal x hx).2.2)).trans heσ
  · intro x hx;exact ((le_max_left _ _).trans ((le_max_left _ _).trans (hlocal x hx).2.2)).trans heσ
  · intro x hx;exact ((le_max_right _ _).trans ((le_max_right _ _).trans (hlocal x hx).2.2)).trans heσ
  · intro x hx;exact ((le_max_right _ _).trans ((le_max_left _ _).trans (hlocal x hx).2.2)).trans heσ

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses FiniteControl.SmoothWord
open scoped Topology ContDiff BigOperators
variable {κ : Type*} (w : PhysicalWord κ)

/-- Zero belongs to the admissible control space as a genuinely absent pulse,
not as the generally nonzero word at parameter zero. -/
def PhysicalWord.admissible : Set (Fin w.n → ℝ) :=
  {a | a=0 ∨ ∃ x ∈ w.ball,a=(fun i => w.amps i x)}

lemma PhysicalWord.zero_admissible : (0:Fin w.n → ℝ) ∈ w.admissible := Or.inl rfl

lemma PhysicalWord.amplitudes_admissible {x : w.Parameter} (hx : x ∈ w.ball) :
    (fun i => w.amps i x) ∈ w.admissible := Or.inr ⟨x,hx,rfl⟩

lemma PhysicalWord.admissible_uniform_bound : ∃ U : ℝ,0 ≤ U ∧
    ∀ a ∈ w.admissible,∀ i,|a i| ≤ U := by
  classical
  choose C hC using fun i : Fin w.n => (isCompact_closedBall (0:w.Parameter) w.radius).exists_bound_of_continuousOn
    (f:=w.amps i) ((w.smooth i).continuous.continuousOn : ContinuousOn (w.amps i) w.ball)
  let U := ∑ i : Fin w.n,max (C i) 0
  have hU : 0 ≤ U := Finset.sum_nonneg (fun i _ => le_max_right _ _)
  refine ⟨U,hU,fun a ha i => ?_⟩
  rcases ha with rfl | ⟨x,hx,rfl⟩
  · simpa using hU
  · exact (hC i x hx).trans ((le_max_left _ _).trans
      (Finset.single_le_sum (fun j _ => le_max_right (C j) 0) (Finset.mem_univ i)))

/-- The same compact parameter ball works in every later pulse, with a
threshold independent of histories or later parameter choices. -/
theorem PhysicalWord.admissible_stretch_threshold : ∃ J : ℕ,∀ j,J ≤ j →
    ∀ a ∈ w.admissible,∀ t i,packetStretch a (pulse j) t i ∈ Icc (1/2:ℝ) (3/2) := by
  obtain ⟨U,hU,hbound⟩ := w.admissible_uniform_bound
  obtain ⟨C,hC,hpos⟩ := packetStretch_uniform_positive w.n
  obtain ⟨J,hJ⟩ := eventually_atTop.1 (pulse_atTop_limit.eventually_ge_atTop (2*C*U))
  exact ⟨J,fun j hj a ha => hpos a U (pulse j) hU (hbound a ha) (pulse_pos j) (hJ j hj)⟩

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl HarmonicCounterexample.FiniteControl.Frobenius
open scoped Topology ContDiff InnerProductSpace 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
variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n] (slot : Fin n → κ)

def HistoryGeometry.baseline (j : ℕ) (b : ξ) (t : ℝ) : ℝ :=
  scalarBaseline (fun s => G.α (time j+s)*S.B b) (fun s => G.drift (time j+s))
    (S.θ b) (max 0 (t-time j))

def HistoryGeometry.packet (s : ℕ → Fin n → ℝ) (j0 j : ℕ) : MatrixProduct ι := fun b =>
  orthogonalMatrix (S.basis b) (Real.exp (-(∫ t in time j..time j+pulse j,G.baseline j b t)) •
    (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)*
      Ring.inverse (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j))))

def HistoryGeometry.defect (s : ℕ → Fin n → ℝ) (j0 j : ℕ) : MatrixProduct ι := fun b =>
  orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j))-
    S.θ b • (1:Matrix (ι b) (ι b) ℝ)

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.coefficient_causal {s u : ℕ → Fin n → ℝ} {j0 j : ℕ}
    (he : ∀ i < j,s i=u i) {t : ℝ} (ht : t ≤ time j) (b : ξ) :
    G.coefficient slot s j0 b t=G.coefficient slot u j0 b t := by
  dsimp [HistoryGeometry.coefficient]
  rw [angular_causal S.r _ _ _ G.qstar j0 he ht]

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.packet_causal {s u : ℕ → Fin n → ℝ} {j0 j : ℕ}
    (he : ∀ i < j+1,s i=u i) :
    G.packet slot s j0 j=G.packet slot u j0 j ∧ G.defect slot s j0 j=G.defect slot u j0 j := by
  have ht1 : time j ∈ Icc 0 (time (j+1)) :=
    ⟨(time_pos j).le,time_strictMono.monotone (by omega)⟩
  have ht2 : time j+pulse j ∈ Icc 0 (time (j+1)) := by
    constructor
    · linarith [time_pos j,pulse_pos j]
    · rw [time_succ];linarith [dwell_pos j,pulse_pos j]
  have hcoeff (b : ξ) : EqOn (G.coefficient slot s j0 b) (G.coefficient slot u j0 b)
      (Icc 0 (time (j+1))) := fun t ht => G.coefficient_causal slot he ht.2 b
  constructor
  · funext b
    simp only [HistoryGeometry.packet,(operator_history_eq (hcoeff b) G.drift (G.l b) ht1).1,
      (operator_history_eq (hcoeff b) G.drift (G.l b) ht2).1]
  · funext b
    simp only [HistoryGeometry.defect,slope_history_eq (hcoeff b) G.drift (G.l b) ht2]

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl
open scoped Topology ContDiff InnerProductSpace 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
variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n] (slot : Fin n → κ)
variable (s : ℕ → Fin n → ℝ) (j0 j : ℕ) (δ ε : ℝ)
  (hpos : ∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2))
  (hj : j0 ≤ j) (hz : s j=0) (hδ : 0 ≤ δ) (hε : 0 ≤ ε)
  (hr : ∀ t,time j ≤ t → (∀ b,|G.α t-S.β b| ≤ δ) ∧ |G.drift t-S.p₀| ≤ δ ∧ S.γ ≤ G.drift t)
  (hi : ∀ b,‖orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j))-
    S.θ b • (1:Matrix (ι b) (ι b) ℝ)‖ ≤ ε)

/-- This is a constructor from the actual stream. All nontrivial input facts
are supplied by the single history-independent threshold theorem. -/
def HistoryGeometry.pulseHistory : PulseHistory S where
  history := G.coefficient slot s j0
  α := G.α
  drift := G.drift
  MH := G.bound slot
  Mb := G.Mp
  l := G.l
  B₀ := G.B₀
  a := time j
  T := pulse j
  δ := δ
  ε := ε
  smooth := G.coefficient_smooth slot s j0 hpos
  αsmooth := G.αsmooth
  driftContinuous := G.driftContinuous
  MHnonneg := G.bound_nonneg slot
  Mbnonneg := G.Mpnonneg
  αbound := G.αbound
  αnonneg := G.αnonneg
  driftBound := G.driftBound
  bound := G.coefficient_bound slot s j0 hpos
  nonneg := G.coefficient_nonnegative slot s j0 hpos
  round := fun b t ht => G.coefficient_round slot s j0 b hj hz t ht
  lpos := G.lpos
  center := G.coefficient_center slot s j0
  driftCenter := G.driftCenter
  apos := (time_pos j).le
  δnonneg := hδ
  εnonneg := hε
  αclose := fun b t ht => (hr t ht.1).1 b
  driftClose := fun t ht => (hr t ht.1).2.1
  driftLower := fun t ht => (hr t ht.1).2.2
  incoming := hi

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl
open scoped Topology ContDiff InnerProductSpace Matrix.Norms.Frobenius
attribute [local instance 100] LieRing.ofAssociativeRing
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

/-- One smooth infinite stream simultaneously tunes every whole-period packet.
All thresholds precede EVERY history. The bounded normalizers may be any
predetermined actual complete diagonal legs; they do not supply transmissions. -/
theorem global_physical_tuning (S : PulseSystem E ι κ) (G : HistoryGeometry S)
    (htrace : ∀ j b,(S.generator j b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range S.generator))
    (target : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ)
    {K₀ : ℝ} (hK₀ : 0 ≤ K₀) :
    ∃ w : PhysicalWord κ,∃ J : ℕ,∀ j0,J ≤ j0 →
      ∀ K : ℕ → MatrixProduct ι,(∀ j,j0 ≤ j → ‖K j‖ ≤ K₀) →
      ∃ s : ℕ → Fin w.n → ℝ,
        (∀ j,s j ∈ w.admissible) ∧ (∀ j,j<j0 → s j=0) ∧
        (∀ j,j0 ≤ j → ∀ t i,packetStretch (s j) (pulse j) t i ∈ Icc (1/2:ℝ) (3/2)) ∧
        ∀ j,j0 ≤ j → ∀ b,∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
          wholePeriod (K j) (G.defect w.slot s j0 j) (G.packet w.slot s j0 j) b=
            c • ((slProductToUnits target:MatrixProduct ι) b) := by
  classical
  obtain ⟨w,T₀,ρ,hT₀,hρ,htune⟩ := local_physical_tuning S htrace hfull target hK₀
  let : NeZero w.n := ⟨w.n_ne⟩
  obtain ⟨J₁,hJ₁⟩ := G.eventual_history_conditions w.slot T₀ hρ
  obtain ⟨J₂,hJ₂⟩ := w.admissible_stretch_threshold
  refine ⟨w,max J₁ J₂,fun j0 hj0 K hK => ?_⟩
  have hj1 : J₁ ≤ j0 := (le_max_left _ _).trans hj0
  have hj2 : J₂ ≤ j0 := (le_max_right _ _).trans hj0
  let good (j : ℕ) (s : ℕ → Fin w.n → ℝ) (a : Fin w.n → ℝ) : Prop :=
    (j<j0 → a=0) ∧ (j0 ≤ j → ∀ b,∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
      wholePeriod (K j) (G.defect w.slot (Function.update s j a) j0 j)
        (G.packet w.slot (Function.update s j a) j0 j) b=
          c • ((slProductToUnits target:MatrixProduct ι) b))
  have produce : ∀ j s,(∀ i < j,s i ∈ w.admissible) → (∀ i,j ≤ i → s i=0) →
      ∃ a ∈ w.admissible,good j s a := by
    intro j s hs hz
    by_cases hj : j0 ≤ j
    · have hsall (i : ℕ) : s i ∈ w.admissible := by
        by_cases hi : i<j
        · exact hs i hi
        · rw [hz i (by omega)];exact w.zero_admissible
      have hpos : ∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2) :=
        fun k hk => hJ₂ k (hj2.trans hk) (s k) (hsall k)
      obtain ⟨hT,hsmall,hr,hin⟩ := hJ₁ j0 j hj1 hj
      have hquarter : 0 ≤ ρ/4 := by linarith
      let H := G.pulseHistory w.slot s j0 j (ρ/4) (ρ/4) hpos hj (hz j le_rfl)
        hquarter hquarter hr (hin s hpos)
      obtain ⟨x,hx,hxTune⟩ := htune H hT hsmall (K j) (hK j hj)
      let a : Fin w.n → ℝ := fun i => w.amps i x
      have hc (b : ξ) : w.coefficient S H b x=G.coefficient w.slot (Function.update s j a) j0 b := by
        change insertWord (G.coefficient w.slot s j0 b) G.α S.r (S.B b • (1:E b →L[ℝ] E b))
          (fun i => S.D b (w.slot i)) a (time j) (pulse j)=_
        exact (coefficient_update S.r _ (G.D₀ b) _ s a G.qstar G.α hj (hz j le_rfl)).symm
      have hv : w.value S H x=G.packet w.slot (Function.update s j a) j0 j := by
        funext b
        unfold PhysicalWord.value HistoryGeometry.packet
        rw [hc b]
        rfl
      have hd : w.defect S H x=G.defect w.slot (Function.update s j a) j0 j := by
        funext b
        unfold PhysicalWord.defect HistoryGeometry.defect
        rw [hc b]
        rfl
      refine ⟨a,w.amplitudes_admissible hx,?_,?_⟩
      · intro h;omega
      · intro _
        rw [←hv,←hd]
        exact hxTune
    · refine ⟨0,w.zero_admissible,fun _ => rfl,?_⟩
      intro h;exact (hj h).elim
  obtain ⟨s,hs,hgood⟩ := CausalConstruction.causal_choice 0 w.admissible good produce
  refine ⟨s,hs,fun j hj => (hgood j).1 hj,?_,?_⟩
  · intro j hj
    exact hJ₂ j (hj2.trans hj) (s j) (hs j)
  · intro j hj
    have ht := (hgood j).2 hj
    have he : ∀ i < j+1,s i=Function.update (fun k => if k<j then s k else 0) j (s j) i := by
      intro i hi
      by_cases hij : i=j
      · subst i;simp
      · rw [Function.update_of_ne hij,ite_eq_left (by omega)]
    obtain ⟨hv,hd⟩ := G.packet_causal w.slot (j0:=j0) he
    rw [←hv,←hd] at ht
    exact ht

end HarmonicCounterexample.LinearODE

end

noncomputable section


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

omit [Fintype β] in
/-- Block-dependent Riccati roots are kept in the complete-leg identity. -/
lemma blockwise_whole_period_exact_leg
    {U V P B : ∀ b,Matrix (ι b) (ι b) ℝ} (θ : β → ℝ)
    (D M : ∀ b,(Matrix (ι b) (ι b) ℝ)ˣ)
    (hD : ∀ b,(D b:Matrix (ι b) (ι b) ℝ)=U b+θ b • V b)
    (hatt : ∀ b,∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
      wholePeriod ((↑(D b)⁻¹:Matrix (ι b) (ι b) ℝ)*V b) (P b-θ b • 1) (B b)=
        c • (M b:Matrix (ι b) (ι b) ℝ)) :
    ∀ b,∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
      (U b+V b*P b)*B b=c • ((D b:Matrix (ι b) (ι b) ℝ)*(M b:Matrix (ι b) (ι b) ℝ)) := by
  intro b
  obtain ⟨c,hc,he⟩ := hatt b
  refine ⟨c,hc,?_⟩
  have hf := full_leg_factor (U b) (V b) (P b) (B b) (θ b) (D b) (hD b)
  change (↑(D b)⁻¹:Matrix (ι b) (ι b) ℝ)*((U b+V b*P b)*B b)=
    wholePeriod ((↑(D b)⁻¹:Matrix (ι b) (ι b) ℝ)*V b) (P b-θ b • 1) (B b) at hf
  have hh := congrArg (fun X => (D b:Matrix (ι b) (ι b) ℝ)*X) hf
  rw [← mul_assoc,Units.mul_inv,one_mul,he,Matrix.mul_smul] at hh
  exact hh

variable {R : Type*} [NormedRing R] [NormedAlgebra ℝ R]

/-- Undo ONLY the harmless scalar pulse normalization. The scalar logarithmic
cost is separated from the genuine diagonal factor of the entire leg. -/
lemma unnormalize_whole_leg {Fa Fc Fd U V P D M : R} {I c : ℝ}
    (hvalue : Fd=(U+V*P)*Fc)
    (htune : (U+V*P)*(Real.exp (-I) • (Fc*Fa))=c • (D*M)) :
    Fd*Fa=(Real.exp I*c) • (D*M) := by
  have he := congrArg (fun X : R => Real.exp I • X) htune
  rw [mul_smul_comm,smul_smul,← Real.exp_add,add_neg_cancel,Real.exp_zero,one_smul] at he
  rw [hvalue,mul_assoc]
  simpa only [smul_smul] using he

end HarmonicCounterexample.Transmission

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl
open scoped Topology 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
local instance (b : ξ) : NormedAddCommGroup ((E b →L[ℝ] E b) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ ((E b →L[ℝ] E b) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedSpace

local instance (b : ξ) : NormedAddCommGroup (Matrix (ι b) (ι b) ℝ →L[ℝ] ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ (Matrix (ι b) (ι b) ℝ →L[ℝ] ℝ) := ContinuousLinearMap.toNormedSpace
local instance (b : ξ) : NormedAddCommGroup ((ι b → ℝ) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ ((ι b → ℝ) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedSpace

variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n]

omit [NeZero n] in
lemma zero_stretch (j : ℕ) (t : ℝ) (i : Fin n) :
    packetStretch (0:Fin n → ℝ) (pulse j) t i ∈ Icc (1/2:ℝ) (3/2) := by
  norm_num [packetStretch]

/-- Background diagonal coefficient, independent of all control choices. -/
def HistoryGeometry.baseCoefficient (j0 : ℕ) (b : ξ) (t : ℝ) : E b →L[ℝ] E b :=
  G.α t • PulseTaylor.angular S.r (S.B b • (1:E b →L[ℝ] E b)) (G.D₀ b) (base G.qstar j0 t)

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] [NeZero n] in
lemma HistoryGeometry.baseCoefficient_eq (slot : Fin n → κ) (j0 : ℕ) (b : ξ) :
    G.baseCoefficient j0 b=G.coefficient slot 0 j0 b := by
  funext t
  unfold HistoryGeometry.baseCoefficient HistoryGeometry.coefficient angular
  have he : (fun j => activeIncrement S.r (S.B b • (1:E b →L[ℝ] E b))
      (fun i => S.D b (slot i)) 0 j0 j t)=fun _ => (0:E b →L[ℝ] E b) := by
    funext j
    dsimp [activeIncrement]
    split_ifs
    · exact increment_zero S.r _ _ rfl t
    · rfl
  rw [he,tsum_zero,add_zero]

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.baseCoefficient_diagonal (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b))
    (j0 : ℕ) (b : ξ) (t : ℝ) :
    orthogonalMatrix (S.basis b) (G.baseCoefficient j0 b t)=Matrix.diagonal (fun i =>
      G.α t*((base G.qstar j0 t)^S.r*S.B b+
        ((base G.qstar j0 t)^S.r-(base G.qstar j0 t)^(S.r-1))*d₀ b i)) := by
  simp only [HistoryGeometry.baseCoefficient,PulseTaylor.angular,map_smul,map_add,
    orthogonalMatrix_one,hd₀]
  ext i j
  by_cases h : i=j
  · subst j;simp [Matrix.diagonal_apply_eq,smul_eq_mul]
  · simp [h,smul_eq_mul]

/-- The genuine fixed diagonal scalar coefficient. -/
def HistoryGeometry.legLambda (d₀ : ∀ b,ι b → ℝ) (j0 : ℕ) (b : ξ) (i : ι b) (t : ℝ) : ℝ :=
  G.α t*((base G.qstar j0 t)^S.r*S.B b+
    ((base G.qstar j0 t)^S.r-(base G.qstar j0 t)^(S.r-1))*d₀ b i)

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b,Nontrivial (ι b)] in
lemma HistoryGeometry.legLambda_properties (slot : Fin n → κ) (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b)) (j0 : ℕ) (b : ξ) :
    ∃ N : ι b → ℝ,(∀ i,0 ≤ N i) ∧
      (∀ i,Continuous (G.legLambda d₀ j0 b i)) ∧
      (∀ i t,|G.legLambda d₀ j0 b i t| ≤ N i) ∧
      (∀ i t,0 ≤ G.legLambda d₀ j0 b i t) := by
  have hp : ∀ j,j0 ≤ j → ∀ t i,packetStretch ((0:ℕ → Fin n → ℝ) j) (pulse j) t i ∈ Icc (1/2:ℝ) (3/2) :=
    fun j _ t i => zero_stretch j t i
  have hbc := G.baseCoefficient_eq slot j0 b
  have hc : Continuous (G.baseCoefficient j0 b) := by
    rw [hbc];exact (G.coefficient_smooth slot 0 j0 hp b).continuous
  have he (i : ι b) (t : ℝ) : G.legLambda d₀ j0 b i t=
      matrixEntry i i (orthogonalMatrix (S.basis b) (G.baseCoefficient j0 b t)) := by
    rw [matrixEntry_apply,G.baseCoefficient_diagonal d₀ hd₀,Matrix.diagonal_apply_eq]
    rfl
  let N : ι b → ℝ := fun i => ‖matrixEntry i i‖*‖orthogonalMatrix (S.basis b)‖*G.bound slot b
  refine ⟨N,fun i => mul_nonneg (mul_nonneg (norm_nonneg _) (norm_nonneg _)) (G.bound_nonneg slot b),?_,?_,?_⟩
  · intro i
    have hf : G.legLambda d₀ j0 b i=fun t => matrixEntry i i (orthogonalMatrix (S.basis b) (G.baseCoefficient j0 b t)) := funext (he i)
    rw [hf];exact (matrixEntry i i).continuous.comp ((orthogonalMatrix (S.basis b)).continuous.comp hc)
  · intro i t
    rw [he i t,← Real.norm_eq_abs]
    calc
      _ ≤ ‖matrixEntry i i‖*‖orthogonalMatrix (S.basis b) (G.baseCoefficient j0 b t)‖ := (matrixEntry i i).le_opNorm _
      _ ≤ ‖matrixEntry i i‖*(‖orthogonalMatrix (S.basis b)‖*‖G.baseCoefficient j0 b t‖) :=
        mul_le_mul_of_nonneg_left ((orthogonalMatrix (S.basis b)).le_opNorm _) (norm_nonneg _)
      _ ≤ N i := by
        dsimp [N];rw [mul_assoc,hbc]
        exact mul_le_mul_of_nonneg_left
          (mul_le_mul_of_nonneg_left (G.coefficient_bound slot 0 j0 hp b t) (norm_nonneg _)) (norm_nonneg _)
  · intro i t
    rw [he i t,matrixEntry_apply,orthogonalMatrix_apply,OrthonormalBasis.repr_apply_apply,hbc]
    exact G.coefficient_nonnegative slot 0 j0 hp b t (S.basis b i)

/-- ACTUAL complete-leg columns with the physical schedule. -/
def HistoryGeometry.legU (d₀ : ∀ b,ι b → ℝ) (j0 j : ℕ) (b : ξ) : Matrix (ι b) (ι b) ℝ :=
  Matrix.diagonal (fun i => scalarU (fun t => G.legLambda d₀ j0 b i (time j+pulse j+t))
    (fun t => G.drift (time j+pulse j+t)) (time (j+1)-(time j+pulse j)))
def HistoryGeometry.legV (d₀ : ∀ b,ι b → ℝ) (j0 j : ℕ) (b : ξ) : Matrix (ι b) (ι b) ℝ :=
  Matrix.diagonal (fun i => scalarV (fun t => G.legLambda d₀ j0 b i (time j+pulse j+t))
    (fun t => G.drift (time j+pulse j+t)) (time (j+1)-(time j+pulse j)))

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b, Nontrivial (ι b)] in
lemma HistoryGeometry.leg_normalizer (slot : Fin n → κ) (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b)) (j0 j : ℕ) (b : ξ) :
    ∃ D : (Matrix (ι b) (ι b) ℝ)ˣ,
      (D:Matrix (ι b) (ι b) ℝ)=G.legU d₀ j0 j b+S.θ b • G.legV d₀ j0 j b ∧
      (∀ i,0 < (D:Matrix (ι b) (ι b) ℝ) i i) ∧
      ‖(↑D⁻¹:Matrix (ι b) (ι b) ℝ)*G.legV d₀ j0 j b‖ ≤
        ‖diagonalL (ι:=ι b)‖*(S.θ b)⁻¹ := by
  obtain ⟨N,hN,hc,hb,hp⟩ := G.legLambda_properties slot d₀ hd₀ j0 b
  apply actual_diagonal_normalizer (fun i => (hc i).comp (continuous_const.add continuous_id))
    (G.driftContinuous.comp (continuous_const.add continuous_id)) N hN G.Mpnonneg
    (fun i t => hb i _) (fun t => G.driftBound _) (fun i t _ => hp i _) ?_ (S.hθ b)
  rw [time_succ];linarith [pulse_pos j,dwell_pos j]

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl
open scoped Topology 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
variable {S : PulseSystem E ι κ} (G : HistoryGeometry S) {n : ℕ} [NeZero n] (slot : Fin n → κ)

/-- Actual center-regular value transmission, including the complete diagonal
leg and with no pulse scalar normalization. -/
def HistoryGeometry.transmission (s : ℕ → Fin n → ℝ) (j0 j : ℕ) (b : ξ) : Matrix (ι b) (ι b) ℝ :=
  orthogonalMatrix (S.basis b)
    (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time (j+1))*
      Ring.inverse (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j)))

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b, Nontrivial (ι b)] in
lemma HistoryGeometry.actual_leg_restart (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b))
    (s : ℕ → Fin n → ℝ) (j0 j : ℕ)
    (hpos : ∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2))
    (hj : j0 ≤ j) (b : ξ) :
    orthogonalMatrix (S.basis b) (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time (j+1)))=
      (G.legU d₀ j0 j b+G.legV d₀ j0 j b*
        orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)))*
      orthogonalMatrix (S.basis b) (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)) := by
  obtain ⟨N,hN,hc,hb,hp⟩ := G.legLambda_properties slot d₀ hd₀ j0 b
  have hA := (G.coefficient_smooth slot s j0 hpos b).continuous
  have hbound := G.coefficient_bound slot s j0 hpos b
  have hnonneg := G.coefficient_nonnegative slot s j0 hpos b
  have hdiag (t : ℝ) (ht : t ∈ Ico (time j+pulse j) (time (j+1))) :
      orthogonalMatrix (S.basis b) (G.coefficient slot s j0 b t)=
        Matrix.diagonal (fun i => G.legLambda d₀ j0 b i t) := by
    change orthogonalMatrix (S.basis b) (G.α t • angular _ _ _ _ _ _ _ _)=_
    rw [angular_leg _ _ _ _ _ hj ht.1 ht.2.le]
    exact G.baseCoefficient_diagonal d₀ hd₀ j0 b t
  have he := actual_diagonal_restart (S.basis b) N (G.l b) hA G.driftContinuous hc
    (G.bound_nonneg slot b) G.Mpnonneg hN hbound G.driftBound hb hdiag
    (time (j+1)) ⟨by rw [time_succ];linarith [pulse_pos j,dwell_pos j],le_rfl⟩
  change _=G.legU d₀ j0 j b*_
    +G.legV d₀ j0 j b*orthogonalMatrix (S.basis b)
      (operatorVelocity (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)) at he
  have hu := operatorValue_isUnit hA G.driftContinuous (G.bound_nonneg slot b) G.Mpnonneg
    hbound G.driftBound hnonneg (G.lpos b) (t:=time j+pulse j) (by linarith [time_pos j,pulse_pos j])
  have hs : operatorVelocity (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)=
      slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j)*
        operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j) := by
    ext x;exact (slope_value hu x).symm
  rw [hs,orthogonalMatrix_mul,← mul_assoc,← add_mul] at he
  exact he

omit [Fintype ξ] [Nonempty ξ] [Nonempty κ] [∀ b, Nontrivial (ι b)] in
/-- Attainment in normalized pulse coordinates gives the actual WHOLE period,
with its scalar exactly separated. -/
theorem HistoryGeometry.exact_period (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b))
    (s : ℕ → Fin n → ℝ) (j0 j : ℕ)
    (hpos : ∀ k,j0 ≤ k → ∀ t i,packetStretch (s k) (pulse k) t i ∈ Icc (1/2:ℝ) (3/2))
    (hj : j0 ≤ j) (b : ξ) (D : (Matrix (ι b) (ι b) ℝ)ˣ)
    (hD : (D:Matrix (ι b) (ι b) ℝ)=G.legU d₀ j0 j b+S.θ b • G.legV d₀ j0 j b)
    (M : Matrix (ι b) (ι b) ℝ) {c : ℝ}
    (htune : wholePeriod ((↑D⁻¹:Matrix (ι b) (ι b) ℝ)*G.legV d₀ j0 j b)
      (G.defect slot s j0 j b) (G.packet slot s j0 j b)=c • M) :
    G.transmission slot s j0 j b=
      (Real.exp (∫ t in time j..time j+pulse j,G.baseline j b t)*c) • ((D:Matrix (ι b) (ι b) ℝ)*M) := by
  let P := orthogonalMatrix (S.basis b) (slope (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j))
  have hf := full_leg_factor (G.legU d₀ j0 j b) (G.legV d₀ j0 j b) P
    (G.packet slot s j0 j b) (S.θ b) D hD
  have he := congrArg (fun X => (D:Matrix (ι b) (ι b) ℝ)*X) hf
  rw [←mul_assoc,Units.mul_inv,one_mul] at he
  change (G.legU d₀ j0 j b+G.legV d₀ j0 j b*P)*G.packet slot s j0 j b=
    (D:Matrix (ι b) (ι b) ℝ)*wholePeriod _ (G.defect slot s j0 j b) (G.packet slot s j0 j b) at he
  rw [htune,Matrix.mul_smul] at he
  have hv := G.actual_leg_restart slot d₀ hd₀ s j0 j hpos hj b
  have hp : G.packet slot s j0 j b=
      Real.exp (-(∫ t in time j..time j+pulse j,G.baseline j b t)) •
        (orthogonalMatrix (S.basis b) (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j+pulse j))*
        orthogonalMatrix (S.basis b) (Ring.inverse (operatorValue (G.coefficient slot s j0 b) G.drift (G.l b) (time j)))) := by
    simp only [HistoryGeometry.packet,map_smul,orthogonalMatrix_mul]
  rw [hp] at he
  have hu := unnormalize_whole_leg hv he
  simpa only [HistoryGeometry.transmission,orthogonalMatrix_mul] using hu

end HarmonicCounterexample.LinearODE

end

noncomputable section


namespace HarmonicCounterexample.LinearODE
open Set Filter Schedule Pulses AngularStream FiniteControl.SmoothWord
open HarmonicCounterexample.Transmission HarmonicCounterexample.FiniteControl
open scoped Topology ContDiff InnerProductSpace BigOperators Matrix.Norms.Frobenius
attribute [local instance 100] LieRing.ofAssociativeRing
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 ((ι b → ℝ) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedAddCommGroup
local instance (b : ξ) : NormedSpace ℝ ((ι b → ℝ) →L[ℝ] Matrix (ι b) (ι b) ℝ) := ContinuousLinearMap.toNormedSpace

/-- One actual infinite center-regular equation realizes ALL the requested
complete-period transmissions. Its normalizers are the true second-order
post-pulse columns U,V, not supplied targets or asymptotic substitutes. -/
theorem global_actual_transmission (S : PulseSystem E ι κ) (G : HistoryGeometry S)
    (d₀ : ∀ b,ι b → ℝ)
    (hd₀ : ∀ b,orthogonalMatrix (S.basis b) (G.D₀ b)=Matrix.diagonal (d₀ b))
    (htrace : ∀ j b,(S.generator j b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range S.generator))
    (target : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    ∃ w : PhysicalWord κ,∃ J : ℕ,∀ j0,J ≤ j0 →
      ∃ s : ℕ → Fin w.n → ℝ,
        (∀ j,s j ∈ w.admissible) ∧ (∀ j,j<j0 → s j=0) ∧
        (∀ j,j0 ≤ j → ∀ t i,packetStretch (s j) (pulse j) t i ∈ Icc (1/2:ℝ) (3/2)) ∧
        ∀ j,j0 ≤ j → ∀ b,∃ D : (Matrix (ι b) (ι b) ℝ)ˣ,
          (D:Matrix (ι b) (ι b) ℝ)=G.legU d₀ j0 j b+S.θ b • G.legV d₀ j0 j b ∧
          (∀ i,0 < (D:Matrix (ι b) (ι b) ℝ) i i) ∧
          ∃ c : ℝ,c ∈ Ioo (1/2:ℝ) (3/2) ∧
            G.transmission w.slot s j0 j b=
              (Real.exp (∫ t in time j..time j+pulse j,G.baseline j b t)*c) •
                ((D:Matrix (ι b) (ι b) ℝ)*((target b):Matrix (ι b) (ι b) ℝ)) := by
  classical
  let K₀ : ℝ := ∑ b : ξ,‖diagonalL (ι:=ι b)‖*(S.θ b)⁻¹
  have hK₀ : 0 ≤ K₀ := Finset.sum_nonneg (fun b _ => mul_nonneg (norm_nonneg _) (inv_nonneg.2 (S.hθ b).le))
  obtain ⟨w,J,htune⟩ := global_physical_tuning S G htrace hfull target hK₀
  let : NeZero w.n := ⟨w.n_ne⟩
  refine ⟨w,J,fun j0 hj0 => ?_⟩
  let D (j : ℕ) (b : ξ) := (G.leg_normalizer w.slot d₀ hd₀ j0 j b).choose
  have hD (j : ℕ) (b : ξ) := (G.leg_normalizer w.slot d₀ hd₀ j0 j b).choose_spec
  let K (j : ℕ) : MatrixProduct ι := fun b => (↑(D j b)⁻¹:Matrix (ι b) (ι b) ℝ)*G.legV d₀ j0 j b
  have hK (j : ℕ) (_ : j0 ≤ j) : ‖K j‖ ≤ K₀ := by
    apply (pi_norm_le_iff_of_nonneg hK₀).2
    intro b
    exact (hD j b).2.2.trans (Finset.single_le_sum
      (fun c _ => mul_nonneg (norm_nonneg (diagonalL (ι:=ι c))) (inv_nonneg.2 (S.hθ c).le)) (Finset.mem_univ b))
  obtain ⟨s,hs,hzero,hpos,he⟩ := htune j0 hj0 K hK
  refine ⟨s,hs,hzero,hpos,fun j hj b => ?_⟩
  obtain ⟨c,hc,ht⟩ := he j hj b
  refine ⟨D j b,(hD j b).1,(hD j b).2.1,c,hc,?_⟩
  apply G.exact_period w.slot d₀ hd₀ s j0 j hpos hj b (D j b) (hD j b).1 _ ht

end HarmonicCounterexample.LinearODE

end

end OAI