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

import OAI.Geometry.HarmonicGrowth.Attainment
import OAI.Geometry.HarmonicGrowth.EndpointBounds

namespace OAI

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
variable {A : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]
attribute [local instance 100] LieRing.ofAssociativeRing
local instance : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℝ A

def expUnit (x : A) : Aˣ := (NormedSpace.isUnit_exp x).unit

@[simp] lemma expUnit_val (x : A) : (expUnit x : A)=NormedSpace.exp x :=
  (NormedSpace.isUnit_exp x).unit_spec

lemma expUnit_inv_val (x : A) : ((expUnit x)⁻¹ : Aˣ).val = NormedSpace.exp (-x) := by
  rw [← Ring.inverse_exp,← expUnit_val,Ring.inverse_unit]

def adjoint (h : Aˣ) : A →ₗ[ℝ] A where
  toFun X := (h:A)*X*(h⁻¹:Aˣ).val
  map_add' X Y := by simp only [mul_add,add_mul]
  map_smul' c X := by simp only [mul_smul_comm,smul_mul_assoc,RingHom.id_apply]

omit [CompleteSpace A] in
@[simp] lemma adjoint_apply (h : Aˣ) (X : A) :
    adjoint h X=(h:A)*X*(h⁻¹:Aˣ).val := rfl

omit [CompleteSpace A] in
@[simp] lemma adjoint_one (X : A) : adjoint 1 X=X := by simp [adjoint]

omit [CompleteSpace A] in
lemma adjoint_mul (h k : Aˣ) (X : A) : adjoint (h*k) X=adjoint h (adjoint k X) := by
  simp only [adjoint_apply,mul_inv_rev,Units.val_mul]
  noncomm_ring

omit [CompleteSpace A] in
lemma adjoint_lie (h : Aˣ) (X Y : A) :
    adjoint h ⁅X,Y⁆=⁅adjoint h X,adjoint h Y⁆ := by
  simp only [adjoint_apply,Ring.lie_def,mul_sub,sub_mul,mul_assoc]
  simp only [← mul_assoc (h⁻¹:Aˣ).val (h:A),Units.inv_mul,one_mul]

lemma adjoint_exp_deriv (X Y : A) :
    HasDerivAt (fun t : ℝ => adjoint (expUnit (t • X)) Y) ⁅X,Y⁆ 0 := by
  have hp : HasDerivAt (fun t : ℝ => NormedSpace.exp (t • X)) X 0 := by
    simpa only [zero_smul,NormedSpace.exp_zero,one_mul] using hasDerivAt_exp_smul_const X (0:ℝ)
  have hm : HasDerivAt (fun t : ℝ => NormedSpace.exp (t • (-X))) (-X) 0 := by
    simpa only [zero_smul,NormedSpace.exp_zero,one_mul] using hasDerivAt_exp_smul_const (-X) (0:ℝ)
  convert (hp.mul_const Y).mul hm using 1 <;> first | rfl |
    simp only [adjoint_apply,expUnit_val,expUnit_inv_val,smul_neg,zero_smul,
      NormedSpace.exp_zero,mul_one,one_mul,mul_neg,neg_zero,Ring.lie_def,sub_eq_add_neg] <;> rfl

omit [CompleteSpace A] in
lemma deriv_mem_submodule [FiniteDimensional ℝ A] (S : Submodule ℝ A)
    {f : ℝ → A} {f' : A} {t : ℝ} (hf : HasDerivAt f f' t) (hS : ∀ t,f t ∈ S) : f' ∈ S := by
  apply S.closed_of_finiteDimensional.mem_of_tendsto hf.tendsto_slope
  exact Filter.Eventually.of_forall (fun u => S.smul_mem _ (S.sub_mem (hS u) (hS t)))

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open NormedSpace Module
variable {A κ : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]
attribute [local instance 100] LieRing.ofAssociativeRing

def reachable (g : κ → A) : Subgroup Aˣ :=
  Subgroup.closure (Set.range (fun p : κ × ℝ => expUnit (p.2 • g p.1)))

def adjointSpan (g : κ → A) : Submodule ℝ A :=
  Submodule.span ℝ {x | ∃ h ∈ reachable g,∃ k,x=adjoint h (g k)}

lemma generator_mem_adjointSpan (g : κ → A) (k : κ) : g k ∈ adjointSpan g :=
  Submodule.subset_span ⟨1,(reachable g).one_mem,k,(adjoint_one _).symm⟩

lemma adjoint_mem_adjointSpan (g : κ → A) {h : Aˣ} (hh : h ∈ reachable g)
    {X : A} (hX : X ∈ adjointSpan g) : adjoint h X ∈ adjointSpan g := by
  induction hX using Submodule.span_induction with
  | mem x hx =>
    obtain ⟨k,hk,i,rfl⟩ := hx
    exact Submodule.subset_span ⟨h*k,(reachable g).mul_mem hh hk,i,(adjoint_mul h k (g i)).symm⟩
  | zero => rw [map_zero]; exact (adjointSpan g).zero_mem
  | add x y _ _ hx hy => rw [map_add]; exact (adjointSpan g).add_mem hx hy
  | smul c x _ hx => rw [map_smul]; exact (adjointSpan g).smul_mem c hx

lemma generator_lie_adjointSpan [FiniteDimensional ℝ A] (g : κ → A) (k : κ)
    {X : A} (hX : X ∈ adjointSpan g) : ⁅g k,X⁆ ∈ adjointSpan g := by
  apply deriv_mem_submodule (adjointSpan g) (adjoint_exp_deriv (g k) X)
  intro t
  exact adjoint_mem_adjointSpan g
    (Subgroup.subset_closure (Set.mem_range_self (k,t))) hX

omit [CompleteSpace A] in
lemma adjoint_inv_cancel (h : Aˣ) (X : A) : adjoint h (adjoint h⁻¹ X)=X := by
  rw [← adjoint_mul,mul_inv_cancel,adjoint_one]

lemma adjointSpan_lie_mem [FiniteDimensional ℝ A] (g : κ → A)
    {X Y : A} (hX : X ∈ adjointSpan g) (hY : Y ∈ adjointSpan g) :
    ⁅X,Y⁆ ∈ adjointSpan g := by
  induction hX using Submodule.span_induction with
  | mem x hx =>
    obtain ⟨h,hh,k,rfl⟩ := hx
    have hz := adjoint_mem_adjointSpan g ((reachable g).inv_mem hh) hY
    have hb := generator_lie_adjointSpan g k hz
    have hc := adjoint_mem_adjointSpan g hh hb
    rw [adjoint_lie,adjoint_inv_cancel] at hc
    exact hc
  | zero => simpa only [zero_lie] using (adjointSpan g).zero_mem
  | add x y _ _ hx hy => rw [add_lie]; exact (adjointSpan g).add_mem hx hy
  | smul c x _ hx => rw [smul_lie]; exact (adjointSpan g).smul_mem c hx

/-- Differentiating ACTUAL reachable conjugations, in a closed finite
-dimensional span, proves the spanning assertion used for finite words. -/
theorem lieSpan_le_adjointSpan [FiniteDimensional ℝ A] (g : κ → A) :
    (LieSubalgebra.lieSpan ℝ A (Set.range g)).toSubmodule ≤ adjointSpan g := by
  let E : LieSubalgebra ℝ A :=
    { adjointSpan g with lie_mem' := adjointSpan_lie_mem g }
  have h : LieSubalgebra.lieSpan ℝ A (Set.range g) ≤ E := by
    apply LieSubalgebra.lieSpan_le.2
    rintro _ ⟨k,rfl⟩
    exact generator_mem_adjointSpan g k
  exact h

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
variable {A κ : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]

/-- A finite basis of actual reachable conjugates, as opposed to abstract
iterated brackets or a closure of the reachable subgroup. -/
theorem exists_adjoint_basis [FiniteDimensional ℝ A] (g : κ → A) :
    ∃ (d : ℕ) (b : Module.Basis (Fin d) ℝ (adjointSpan g)),
      ∀ i,∃ (h : Aˣ),h ∈ reachable g ∧ ∃ k,(b i : A)=adjoint h (g k) := by
  classical
  let S : Set A := {x | ∃ h ∈ reachable g,∃ k,x=adjoint h (g k)}
  let inc : S → adjointSpan g := fun x => ⟨x.val,Submodule.subset_span x.property⟩
  have hs : (⊤ : Submodule ℝ (adjointSpan g)) ≤
      Submodule.span ℝ (Set.range inc) := by
    apply le_of_eq
    symm
    apply (Submodule.span_range_subtype_eq_top_iff (adjointSpan g)
      (fun x : S => Submodule.subset_span x.property)).2
    simp only [Subtype.range_coe_subtype,Set.ofPred_mem_eq]
    rfl
  let B := Set.range inc
  let ι : Type _ := ↥((linearIndepOn_empty ℝ (id : adjointSpan g → adjointSpan g)).extend
    (Set.empty_subset B))
  let b : Module.Basis ι ℝ (adjointSpan g) := Module.Basis.ofSpan hs
  let := FiniteDimensional.fintypeBasisIndex b
  let e := Fintype.equivFin ι
  refine ⟨Fintype.card ι,b.reindex e,?_⟩
  intro i
  have hi := Module.Basis.ofSpan_subset hs (Set.mem_range_self (e.symm i))
  obtain ⟨x,hx⟩ := hi
  have heq : ((b.reindex e) i : A)=x.val := by
    simpa only [Module.Basis.reindex_apply,inc,b] using congrArg Subtype.val hx.symm
  rw [heq]
  exact x.property

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open ContinuousLinearMap NormedSpace
variable {A : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]

lemma strict_deriv_conjugate [FiniteDimensional ℝ A] {d : ℕ}
    (h : Aˣ) (X : A) (i : Fin d) :
    HasStrictFDerivAt (fun t : Fin d → ℝ => adjoint h (NormedSpace.exp (t i • X)))
      ((ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).smulRight (adjoint h X)) 0 := by
  have he : HasStrictFDerivAt (fun s : ℝ => NormedSpace.exp (s • X))
      ((1 : ℝ →L[ℝ] ℝ).smulRight X) 0 := by
    simpa only [zero_smul,NormedSpace.exp_zero,one_smul] using
      hasStrictFDerivAt_exp_smul_const (𝕂:=ℝ) X (0:ℝ)
  have hp := he.comp (0 : Fin d → ℝ) (ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).hasStrictFDerivAt
  convert (adjoint h).toContinuousLinearMap.hasStrictFDerivAt.comp (0 : Fin d → ℝ) hp using 1 <;>
    ext t <;> simp

omit [CompleteSpace A] in
@[simp] lemma adjoint_unit (h : Aˣ) : adjoint h (1:A)=1 := by
  simp [adjoint]

omit [NormedAlgebra ℝ A] [CompleteSpace A] in
lemma prod_at_zero {E ι : Type*} [Zero E] (l : List ι) (f : ι → E → A)
    (h0 : ∀ i,f i 0=1) : (l.map (fun i => f i 0)).prod=1 := by
  induction l with
  | nil => rfl
  | cons i l ih => rw [List.map_cons,List.prod_cons,h0,ih,mul_one]

omit [CompleteSpace A] in
lemma strict_deriv_identity_product {E ι : Type*}
    [NormedAddCommGroup E] [NormedSpace ℝ E] (l : List ι)
    (f : ι → E → A) (f' : ι → E →L[ℝ] A)
    (h0 : ∀ i,f i 0=1) (hf : ∀ i,HasStrictFDerivAt (f i) (f' i) 0) :
    HasStrictFDerivAt (fun t => (l.map (fun i => f i t)).prod)
      (l.map f').sum 0 := by
  induction l with
  | nil => simpa only [List.map_nil,List.prod_nil,List.sum_nil] using hasStrictFDerivAt_const (𝕜:=ℝ) (1:A) (0:E)
  | cons i l ih =>
    convert (hf i).fun_mul' ih using 1
    · ext t
      simp only [List.map_cons,List.prod_cons]
    · rw [h0,prod_at_zero l f h0]
      ext t
      simp [add_comm]

/-- The finite conjugation word has the required exact differential, calculated
in the actual Banach algebra, not postulated as a control hypothesis. -/
theorem conjugate_word_differential [FiniteDimensional ℝ A] {d : ℕ}
    (h : Fin d → Aˣ) (X : Fin d → A) :
    HasStrictFDerivAt
      (fun t : Fin d → ℝ => ((List.finRange d).map
        (fun i => adjoint (h i) (NormedSpace.exp (t i • X i)))).prod)
      (∑ i : Fin d,(ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).smulRight (adjoint (h i) (X i))) 0 := by
  have he := strict_deriv_identity_product (List.finRange d)
    (fun i (t : Fin d → ℝ) => adjoint (h i) (NormedSpace.exp (t i • X i)))
    (fun i => (ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).smulRight (adjoint (h i) (X i)))
    (by intro i; simp)
    (fun i => strict_deriv_conjugate (h i) (X i) i)
  simpa only [← List.ofFn_eq_map,List.sum_ofFn] using he

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open ContinuousLinearMap NormedSpace
open scoped ContDiff
variable {A κ : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]

def conjugateWord {d : ℕ} (h : Fin d → Aˣ) (X : Fin d → A) (t : Fin d → ℝ) : A :=
  ((List.finRange d).map (fun i => adjoint (h i) (NormedSpace.exp (t i • X i)))).prod

omit [CompleteSpace A] in
@[simp] lemma conjugateWord_zero {d : ℕ} (h : Fin d → Aˣ) (X : Fin d → A) :
    conjugateWord h X 0 = 1 := by
  unfold conjugateWord
  exact prod_at_zero (List.finRange d)
    (fun i (t : Fin d → ℝ) => adjoint (h i) (NormedSpace.exp (t i • X i)))
    (by intro i; simp)

lemma conjugateWord_smooth [FiniteDimensional ℝ A] {d : ℕ}
    (h : Fin d → Aˣ) (X : Fin d → A) : ContDiff ℝ ∞ (conjugateWord h X) := by
  have he : ContDiff ℝ ∞ (NormedSpace.exp : A → A) :=
    contDiff_iff_contDiffAt.2 (fun x => (NormedSpace.exp_analytic (𝕂:=ℝ) x).contDiffAt)
  have hi (i : Fin d) : ContDiff ℝ ∞ (fun t : Fin d → ℝ =>
      adjoint (h i) (NormedSpace.exp (t i • X i))) :=
    (adjoint (h i)).toContinuousLinearMap.contDiff.comp (he.comp ((ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).contDiff.smul contDiff_const))
  unfold conjugateWord
  induction List.finRange d with
  | nil => simpa only [List.map_nil,List.prod_nil] using (contDiff_const (c:=(1:A)))
  | cons i l ih => simpa only [List.map_cons,List.prod_cons] using (hi i).mul ih

/-- The ACTUAL finite word assembled from reachable conjugates has an
invertible differential onto its adjoint span. If Lie generation is full this
is exactly the finite-word submersion at the group identity. -/
theorem exists_word_submersion [FiniteDimensional ℝ A] (g : κ → A) :
    ∃ (d : ℕ) (h : Fin d → Aˣ) (k : Fin d → κ)
      (e : (Fin d → ℝ) ≃L[ℝ] (adjointSpan g)),
      (∀ i,h i ∈ reachable g) ∧
      d=Module.finrank ℝ (adjointSpan g) ∧
      ContDiff ℝ ∞ (conjugateWord h (g ∘ k)) ∧
      HasStrictFDerivAt (conjugateWord h (g ∘ k))
        ((adjointSpan g).subtypeL.comp (e : (Fin d → ℝ) →L[ℝ] (adjointSpan g))) 0 := by
  classical
  obtain ⟨d,b,hb⟩ := exists_adjoint_basis g
  choose h hh k hk using hb
  let e : (Fin d → ℝ) ≃L[ℝ] adjointSpan g := b.equivFun.symm.toContinuousLinearEquiv
  refine ⟨d,h,k,e,hh,?_,conjugateWord_smooth h (g ∘ k),?_⟩
  · simpa only [Fintype.card_fin] using (Module.finrank_eq_card_basis b).symm
  · have hd : (adjointSpan g).subtypeL.comp (e : (Fin d → ℝ) →L[ℝ] adjointSpan g) =
        ∑ i : Fin d,(ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).smulRight
          (adjoint (h i) (g (k i))) := by
      ext t
      simp only [ContinuousLinearMap.comp_apply,_root_.sum_apply,
        ContinuousLinearMap.smulRight_apply,ContinuousLinearMap.proj_apply]
      change ↑(b.equivFun.symm t) = ∑ i,t i • adjoint (h i) (g (k i))
      rw [Module.Basis.equivFun_symm_apply]
      simp only [Submodule.coe_sum,Submodule.coe_smul,hk]
    rw [hd]
    exact conjugate_word_differential h (g ∘ k)

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open ContinuousLinearMap Filter Set
variable {A κ : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]

def conjugateWordUnit {d : ℕ} (h : Fin d → Aˣ) (X : Fin d → A) (t : Fin d → ℝ) : Aˣ :=
  ((List.finRange d).map (fun i => h i * expUnit (t i • X i) * (h i)⁻¹)).prod

lemma conjugateWordUnit_val {d : ℕ} (h : Fin d → Aˣ) (X : Fin d → A) (t : Fin d → ℝ) :
    (conjugateWordUnit h X t : A) = conjugateWord h X t := by
  unfold conjugateWordUnit conjugateWord
  rw [← Units.coeHom_apply,map_list_prod,List.map_map]
  congr 1

lemma conjugateWordUnit_mem (g : κ → A) {d : ℕ} (h : Fin d → Aˣ)
    (hh : ∀ i,h i ∈ reachable g) (k : Fin d → κ) (t : Fin d → ℝ) :
    conjugateWordUnit h (g ∘ k) t ∈ reachable g := by
  apply Subgroup.list_prod_mem
  intro x hx
  obtain ⟨i,_,rfl⟩ := List.mem_map.1 hx
  exact (reachable g).mul_mem ((reachable g).mul_mem (hh i)
    (Subgroup.subset_closure (Set.mem_range_self (k i,t i)))) ((reachable g).inv_mem (hh i))

/-- Full linear span is promoted to an ACTUAL open reachable subgroup by the
strict inverse/submersion theorem. No topological closure of reachability is used. -/
theorem reachable_open_of_adjointSpan_top [FiniteDimensional ℝ A] (g : κ → A)
    (hfull : adjointSpan g=⊤) : IsOpen (reachable g : Set Aˣ) := by
  obtain ⟨d,h,k,e,hh,_,_,hd⟩ := exists_word_submersion g
  have hsurj : Function.Surjective
      ((adjointSpan g).subtypeL.comp (e : (Fin d → ℝ) →L[ℝ] adjointSpan g)) := by
    intro x
    have hx : x ∈ adjointSpan g := by rw [hfull]; trivial
    exact ⟨e.symm ⟨x,hx⟩,by simp⟩
  have himage : conjugateWord h (g ∘ k) '' Set.univ ∈ (𝓝 (1:A)) := by
    rw [← conjugateWord_zero h (g ∘ k),← hd.map_nhds_eq_of_surj
      (LinearMap.range_eq_top.2 hsurj)]
    exact Filter.image_mem_map Filter.univ_mem
  apply (reachable g).isOpen_of_mem_nhds (g:=1)
  have hpre : Units.val ⁻¹' (conjugateWord h (g ∘ k) '' Set.univ) ∈ 𝓝 (1:Aˣ) :=
    (Units.continuous_val.continuousAt (x := (1:Aˣ))).preimage_mem_nhds himage
  apply Filter.mem_of_superset hpre
  intro u hu
  obtain ⟨t,_,ht⟩ := hu
  have he : conjugateWordUnit h (g ∘ k) t = u := by
    apply Units.ext
    rw [conjugateWordUnit_val,ht]
  rw [← he]
  exact conjugateWordUnit_mem g h hh k t

attribute [local instance 100] LieRing.ofAssociativeRing

theorem reachable_open_of_lieSpan_top [FiniteDimensional ℝ A] (g : κ → A)
    (hfull : LieSubalgebra.lieSpan ℝ A (Set.range g)=⊤) : IsOpen (reachable g : Set Aˣ) := by
  apply reachable_open_of_adjointSpan_top g
  apply top_le_iff.1
  simpa only [hfull,LieSubalgebra.top_toSubmodule] using lieSpan_le_adjointSpan g

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
variable {A κ : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]

lemma expUnit_neg (x : A) : expUnit (-x)=(expUnit x)⁻¹ := by
  apply Units.ext
  simp only [expUnit_val,expUnit_inv_val]

lemma reachable_has_word (g : κ → A) {h : Aˣ} (hh : h ∈ reachable g) :
    ∃ l : List (κ × ℝ), (l.map (fun p => expUnit (p.2 • g p.1))).prod=h := by
  induction hh using Subgroup.closure_induction with
  | mem h hh =>
    obtain ⟨p,rfl⟩ := hh
    exact ⟨[p],by simp⟩
  | one => exact ⟨[],rfl⟩
  | mul x y _ _ hx hy =>
    obtain ⟨l,rfl⟩ := hx
    obtain ⟨m,rfl⟩ := hy
    exact ⟨l++m,by simp⟩
  | inv x _ hx =>
    obtain ⟨l,rfl⟩ := hx
    refine ⟨(l.map (fun p => (p.1,-p.2))).reverse,?_⟩
    rw [List.prod_inv_reverse,List.map_reverse,List.map_map]
    simp only [List.map_map]
    congr 2
    apply List.map_congr_left
    intro p _
    simp only [Function.comp_apply,neg_smul,expUnit_neg]

lemma word_reachable (g : κ → A) (l : List (κ × ℝ)) :
    (l.map (fun p => expUnit (p.2 • g p.1))).prod ∈ reachable g := by
  apply Subgroup.list_prod_mem
  intro x hx
  obtain ⟨p,_,rfl⟩ := List.mem_map.1 hx
  exact Subgroup.subset_closure (Set.mem_range_self p)

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open Matrix Matrix.SpecialLinearGroup
variable {ι F : Type*} [Fintype ι] [DecidableEq ι] [Field F]

lemma single_product (i j k l : ι) (a b : F) :
    single i j a * single k l b = if j=k then single i l (a*b) else 0 := by
  split_ifs with h
  · subst k; exact single_mul_single_same a i j l b
  · exact single_mul_single_of_ne a i j k h b

lemma diag2n_decompose {i j : ι} (hij : i ≠ j) (a : F) (ha : a ≠ 0) :
    diag2n hij a ha = transvection hij a * transvection hij.symm (-a⁻¹) *
      transvection hij a * transvection hij (-1) * transvection hij.symm 1 *
      transvection hij (-1) := by
  apply Subtype.ext
  simp only [coe_mul,transvection_coe,diag2n_coe]
  simp only [mul_add,add_mul,one_mul,mul_one,single_product,hij,hij.symm,ite_false,ite_true,add_zero]
  ext k l
  by_cases hki : k=i <;> by_cases hkj : k=j <;> by_cases hli : l=i <;> by_cases hlj : l=j
  all_goals subst_vars
  all_goals simp_all [diagonal_apply,single,one_apply,eq_comm]

/-- Every real or arbitrary-field special-linear matrix has a finite elementary
transvection word. This avoids assuming polar decomposition or connectedness. -/
lemma transvection_induction [Nontrivial ι] (P : Matrix.SpecialLinearGroup ι F → Prop)
    (htransvec : ∀ (i j : ι) (hij : i ≠ j) (a : F),P (transvection hij a))
    (hmul : ∀ A B,P A → P B → P (A*B)) (M : Matrix.SpecialLinearGroup ι F) : P M := by
  apply diagonal_transvection_induction' P M _ htransvec hmul
  intro i j hij a ha
  rw [diag2n_decompose hij a ha]
  exact hmul _ _ (hmul _ _ (hmul _ _ (hmul _ _ (hmul _ _
    (htransvec i j hij a) (htransvec j i hij.symm (-a⁻¹)))
    (htransvec i j hij a)) (htransvec i j hij (-1)))
    (htransvec j i hij.symm 1)) (htransvec i j hij (-1))

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

namespace HarmonicCounterexample.FiniteControl
open Matrix Matrix.SpecialLinearGroup
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma continuous_transvection {i j : ι} (hij : i ≠ j) :
    Continuous (fun a : ℝ => transvection hij a) := by
  apply continuous_induced_rng.2
  change Continuous (fun a : ℝ => (1 : Matrix ι ι ℝ)+single i j a)
  apply continuous_const.add
  apply continuous_pi
  intro k
  apply continuous_pi
  intro l
  simp only [single,Matrix.of_apply]
  split_ifs <;> fun_prop

lemma joined_transvection {i j : ι} (hij : i ≠ j) (a : ℝ) :
    Joined (1 : Matrix.SpecialLinearGroup ι ℝ) (transvection hij a) := by
  simpa using (PathConnectedSpace.joined (0:ℝ) a).map (continuous_transvection hij)

lemma sl_joined_one [Nontrivial ι] (M : Matrix.SpecialLinearGroup ι ℝ) :
    Joined 1 M := by
  apply transvection_induction (fun M => Joined 1 M) _ _ M
  · intro i j hij a
    exact joined_transvection hij a
  · intro A B hA hB
    simpa using hA.mul hB

/-- Actual path connectedness of every nontrivial real special linear group,
proved by finite elementary operations, without any polar decomposition axiom. -/
theorem sl_pathConnected [Nontrivial ι] : PathConnectedSpace (Matrix.SpecialLinearGroup ι ℝ) := by
  constructor
  · exact ⟨1⟩
  · intro A B
    exact (sl_joined_one A).symm.trans (sl_joined_one B)

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter

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

abbrev MatrixProduct (ι : β → Type*) [∀ b,Fintype (ι b)] := ∀ b,Matrix (ι b) (ι b) ℝ

def centralMatrix (c : β → ℝ) : MatrixProduct ι := fun b => c b • 1

omit [Fintype β] in
@[simp] lemma centralMatrix_zero : centralMatrix (ι:=ι) 0=0 := by
  funext b; exact zero_smul ℝ _

omit [Fintype β] in
lemma centralMatrix_add (c d : β → ℝ) : centralMatrix (ι:=ι) (c+d)=centralMatrix c+centralMatrix d := by
  funext b; exact add_smul _ _ _

omit [Fintype β] in
lemma centralMatrix_neg (c : β → ℝ) : centralMatrix (ι:=ι) (-c) = -centralMatrix c := by
  funext b; exact neg_smul _ _

omit [Fintype β] in
lemma centralMatrix_commute (c : β → ℝ) (X : MatrixProduct ι) : Commute (centralMatrix c) X := by
  show centralMatrix c*X=X*centralMatrix c
  funext b
  simp only [Pi.mul_apply,centralMatrix,smul_mul_assoc,one_mul,mul_smul_comm,mul_one]

lemma expUnit_add_commute {A : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]
    (X Y : A) (h : Commute X Y) : expUnit (X+Y)=expUnit X*expUnit Y := by
  let : NormedAlgebra ℚ A := NormedAlgebra.restrictScalars ℚ ℝ A
  apply Units.ext
  simp only [expUnit_val,Units.val_mul,NormedSpace.exp_add_of_commute h]

lemma central_expUnit_commute (c : β → ℝ) (u : (MatrixProduct ι)ˣ) :
    Commute (expUnit (centralMatrix c)) u := by
  apply Units.val_injective
  exact (centralMatrix_commute c (u : MatrixProduct ι)).exp_left.eq

def augmented (g : κ → MatrixProduct ι) : (κ ⊕ (β → ℝ)) → MatrixProduct ι :=
  Sum.elim g centralMatrix

attribute [local instance 100] LieRing.ofAssociativeRing

omit [Fintype β] in
lemma augmented_lieSpan_top [∀ b,Nonempty (ι b)] (g : κ → MatrixProduct ι)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g)) :
    LieSubalgebra.lieSpan ℝ _ (Set.range (augmented g))=⊤ := by
  apply top_le_iff.1
  intro X _
  let c : β → ℝ := fun b => (X b).trace/(Fintype.card (ι b):ℝ)
  have htrace : ∀ b,(X b-centralMatrix (ι:=ι) c b).trace=0 := by
    intro b
    simp only [centralMatrix,Matrix.trace_sub,Matrix.trace_smul,Matrix.trace_one,smul_eq_mul,c]
    rw [div_mul_cancel₀ _ (Nat.cast_ne_zero.2 (Fintype.card_ne_zero)) ,sub_self]
  have hinc : LieSubalgebra.lieSpan ℝ _ (Set.range g) ≤
      LieSubalgebra.lieSpan ℝ _ (Set.range (augmented g)) := by
    apply LieSubalgebra.lieSpan_mono
    rintro _ ⟨k,rfl⟩
    exact ⟨Sum.inl k,rfl⟩
  have hc : centralMatrix (ι:=ι) c ∈ LieSubalgebra.lieSpan ℝ _ (Set.range (augmented g)) :=
    LieSubalgebra.subset_lieSpan (Set.mem_range_self (Sum.inr c))
  convert
    (LieSubalgebra.lieSpan ℝ _ (Set.range (augmented g))).add_mem
      (hinc (hfull (X-centralMatrix c) htrace)) hc using 1
  ext b i j; simp

lemma augmented_reachable_split (g : κ → MatrixProduct ι)
    {u : (MatrixProduct ι)ˣ} (hu : u ∈ reachable (augmented g)) :
    ∃ c : β → ℝ,∃ v ∈ reachable g,u=expUnit (centralMatrix c)*v := by
  induction hu using Subgroup.closure_induction with
  | mem u hu =>
    obtain ⟨⟨k,t⟩,rfl⟩ := hu
    cases k with
    | inl k =>
      refine ⟨0,expUnit (t • g k),Subgroup.subset_closure (Set.mem_range_self (k,t)),?_⟩
      apply Units.ext
      simp [augmented,expUnit_val]
    | inr c =>
      refine ⟨t • c,1,(reachable g).one_mem,?_⟩
      rw [mul_one]
      change expUnit (t • centralMatrix c)=expUnit (centralMatrix (t • c))
      congr 1
      funext b
      simp [centralMatrix,smul_smul]
  | one =>
    refine ⟨0,1,(reachable g).one_mem,?_⟩
    apply Units.ext
    simp [expUnit_val]
  | mul u v _ _ hu hv =>
    obtain ⟨c,u,hu,rfl⟩ := hu
    obtain ⟨d,v,hv,rfl⟩ := hv
    refine ⟨c+d,u*v,(reachable g).mul_mem hu hv,?_⟩
    rw [centralMatrix_add,expUnit_add_commute _ _ (centralMatrix_commute _ _)]
    have hc := (central_expUnit_commute d u).eq
    calc
      (expUnit (centralMatrix c)*u)*(expUnit (centralMatrix d)*v) =
          expUnit (centralMatrix c)*(u*expUnit (centralMatrix d))*v := by group
      _ = (expUnit (centralMatrix c)*expUnit (centralMatrix d))*(u*v) := by rw [← hc]; group
  | inv u _ hu =>
    obtain ⟨c,v,hv,rfl⟩ := hu
    refine ⟨-c,v⁻¹,(reachable g).inv_mem hv,?_⟩
    rw [centralMatrix_neg,expUnit_neg,_root_.mul_inv_rev]
    exact ((central_expUnit_commute c v).inv_inv).eq.symm

/-- The ordinary product of REAL SL groups has a continuous genuine embedding
into units of the product matrix algebra. -/
def slProductToUnits : (∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) →* (MatrixProduct ι)ˣ where
  toFun M :=
    { val := fun b => (M b : Matrix (ι b) (ι b) ℝ)
      inv := fun b => ((M b)⁻¹ : Matrix.SpecialLinearGroup (ι b) ℝ)
      val_inv := by funext b; exact (Matrix.SpecialLinearGroup.toGL (M b)).val_inv
      inv_val := by funext b; exact (Matrix.SpecialLinearGroup.toGL (M b)).inv_val }
  map_one' := by apply Units.ext; rfl
  map_mul' _ _ := by apply Units.ext; rfl

omit [Fintype β] in
lemma slProductToUnits_continuous : Continuous (slProductToUnits (ι:=ι)) := by
  rw [Units.continuous_iff]
  constructor
  · exact continuous_pi (fun b => continuous_subtype_val.comp (continuous_apply b))
  · change Continuous (fun M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ =>
      fun b => ((M b)⁻¹ : Matrix.SpecialLinearGroup (ι b) ℝ).val)
    exact continuous_pi (fun b => continuous_subtype_val.comp ((continuous_apply b).inv))

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter
open scoped Topology

namespace HarmonicCounterexample.FiniteControl
open Matrix
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

def detMultilinear : ContinuousMultilinearMap ℝ (fun _ : ι => ι → ℝ) ℝ :=
  ⟨Matrix.detRowAlternating.toMultilinearMap,continuous_id.matrix_det⟩

lemma hasDerivAt_det {f : ℝ → Matrix ι ι ℝ} {f' : Matrix ι ι ℝ} {t : ℝ}
    (hf : ∀ i,HasDerivAt (fun s => f s i) (f' i) t) :
    HasDerivAt (fun s => (f s).det) (∑ i,(Matrix.updateRow (f t) i (f' i)).det) t := by
  have h := (detMultilinear (ι:=ι)).hasFDerivAt (f t) |>.comp_hasDerivAt t
    (hasDerivAt_pi.2 hf)
  erw [ContinuousMultilinearMap.linearDeriv_apply] at h
  exact h

lemma hasDerivAt_det_leftODE {f : ℝ → Matrix ι ι ℝ} {X : Matrix ι ι ℝ} {t : ℝ}
    (hf : ∀ i,HasDerivAt (fun s => f s i) ((X*f t) i) t) :
    HasDerivAt (fun s => (f s).det) (X.trace*(f t).det) t := by
  convert hasDerivAt_det hf using 1
  rw [Matrix.trace,Finset.sum_mul]
  apply Finset.sum_congr rfl
  intro i _
  have he : (X*f t) i=∑ j,X i j • f t j := by ext k; simp [Matrix.mul_apply]
  rw [he,Matrix.det_updateRow_sum]
  rfl

open scoped Matrix.Norms.Frobenius in
lemma hasDerivAt_exp_row (X : Matrix ι ι ℝ) (t : ℝ) (i : ι) :
    HasDerivAt (fun s : ℝ => NormedSpace.exp (s • X) i)
      ((X*NormedSpace.exp (t • X)) i) t := by
  let row : Matrix ι ι ℝ →ₗ[ℝ] (ι → ℝ) :=
    { toFun M := M i, map_add' _ _ := rfl, map_smul' _ _ := rfl }
  have h := row.toContinuousLinearMap.hasFDerivAt.comp_hasDerivAt t
    (hasDerivAt_exp_smul_const X t)
  have hc : Commute (t • X) X := by
    show (t • X)*X=X*(t • X)
    rw [smul_mul_assoc,mul_smul_comm]
  erw [hc.exp_left.eq] at h
  exact h

lemma hasDerivAt_det_exp (X : Matrix ι ι ℝ) (t : ℝ) :
    HasDerivAt (fun s : ℝ => (NormedSpace.exp (s • X)).det)
      (X.trace*(NormedSpace.exp (t • X)).det) t :=
  hasDerivAt_det_leftODE (hasDerivAt_exp_row X t)

/-- Liouville's formula for the ACTUAL real matrix exponential. -/
theorem matrix_det_exp (X : Matrix ι ι ℝ) :
    (NormedSpace.exp X).det=Real.exp X.trace := by
  let f : ℝ → ℝ := fun t => (NormedSpace.exp (t • X)).det*Real.exp (-t*X.trace)
  have hf (t : ℝ) : HasDerivAt f 0 t := by
    have he : HasDerivAt (fun s : ℝ => Real.exp (-s*X.trace))
        (Real.exp (-t*X.trace)*(-X.trace)) t := by
      convert (((hasDerivAt_id t).neg).mul_const X.trace).exp using 1 <;> simp
    convert (hasDerivAt_det_exp X t).mul he using 1
    first | rfl | ring
  have h := is_const_of_deriv_eq_zero (fun t => (hf t).differentiableAt)
    (fun t => (hf t).deriv) 1 0
  change (NormedSpace.exp ((1:ℝ) • X)).det*Real.exp (-1*X.trace)=
    (NormedSpace.exp ((0:ℝ) • X)).det*Real.exp (-0*X.trace) at h
  simp only [one_smul,zero_smul,NormedSpace.exp_zero,Matrix.det_one,neg_zero,
    zero_mul,Real.exp_zero,mul_one,neg_mul,one_mul,Real.exp_neg] at h
  exact (mul_inv_eq_iff_eq_mul₀ (Real.exp_pos X.trace).ne').1 h |>.trans (one_mul _)

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter
open scoped Topology

namespace HarmonicCounterexample.FiniteControl
open Matrix
open scoped Matrix.Norms.Frobenius
attribute [local instance 100] LieRing.ofAssociativeRing
variable {β κ : Type*} [Fintype β] {ι : β → Type*}
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)]

lemma reachable_tracefree_det (g : κ → MatrixProduct ι)
    (hg : ∀ k b,(g k b).trace=0) {u : (MatrixProduct ι)ˣ} (hu : u ∈ reachable g) :
    ∀ b,((u : MatrixProduct ι) b).det=1 := by
  induction hu using Subgroup.closure_induction with
  | mem u hu =>
    obtain ⟨⟨k,t⟩,rfl⟩ := hu
    intro b
    simp only [expUnit_val,Pi.coe_exp,Pi.smul_apply]
    erw [matrix_det_exp]
    rw [Matrix.trace_smul,hg,smul_zero,Real.exp_zero]
  | one => intro b; exact Matrix.det_one
  | mul u v _ _ hu hv =>
    intro b
    change ((u : MatrixProduct ι) b*(v : MatrixProduct ι) b).det=1
    rw [Matrix.det_mul,hu,hv,mul_one]
  | inv u _ hu =>
    intro b
    have h := congrArg (fun X : MatrixProduct ι => (X b).det) u.val_inv
    change ((u : MatrixProduct ι) b*((u⁻¹ : (MatrixProduct ι)ˣ) : MatrixProduct ι) b).det=(1 : Matrix (ι b) (ι b) ℝ).det at h
    rw [Matrix.det_mul,hu,one_mul,Matrix.det_one] at h
    exact h

lemma slProduct_augmented_reachable [∀ b,Nontrivial (ι b)]
    (g : κ → MatrixProduct ι)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g))
    (M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    slProductToUnits M ∈ reachable (augmented g) := by
  let : ∀ b,PathConnectedSpace (Matrix.SpecialLinearGroup (ι b) ℝ) :=
    fun b => sl_pathConnected
  let S : OpenSubgroup (MatrixProduct ι)ˣ :=
    ⟨reachable (augmented g),reachable_open_of_lieSpan_top _ (augmented_lieSpan_top g hfull)⟩
  let T := S.comap slProductToUnits slProductToUnits_continuous
  have he : (T : Set (∀ b,Matrix.SpecialLinearGroup (ι b) ℝ))=Set.univ :=
    T.isClopen.eq_univ ⟨1,T.one_mem⟩
  have hm : M ∈ (T : Set (∀ b,Matrix.SpecialLinearGroup (ι b) ℝ)) := by rw [he]; trivial
  exact hm

/-- Lie generation of the actual trace-free product implies exact finite-word
reachability in the genuine product of real special-linear groups. The proof
uses ambient submersion only; central augmentation is eliminated by determinants. -/
theorem slProduct_reachable [∀ b,Nontrivial (ι b)]
    (g : κ → MatrixProduct ι) (hg : ∀ k b,(g k b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g))
    (M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    slProductToUnits M ∈ reachable g := by
  obtain ⟨c,v,hv,he⟩ := augmented_reachable_split g (slProduct_augmented_reachable g hfull M)
  have hc : c=0 := by
    funext b
    have hd := congrArg (fun u : (MatrixProduct ι)ˣ => ((u : MatrixProduct ι) b).det) he
    change (M b).val.det=(((expUnit (centralMatrix (ι:=ι) c) : MatrixProduct ι) b)*
      ((v : MatrixProduct ι) b)).det at hd
    rw [(M b).property,Matrix.det_mul,reachable_tracefree_det g hg hv,mul_one,
      expUnit_val,Pi.coe_exp] at hd
    erw [matrix_det_exp] at hd
    have hz := (Real.exp_eq_one_iff _).1 hd.symm
    simp only [centralMatrix,Matrix.trace_smul,Matrix.trace_one,smul_eq_mul] at hz
    exact (mul_eq_zero.1 hz).resolve_right (Nat.cast_ne_zero.2 Fintype.card_ne_zero)
  rw [hc,centralMatrix_zero] at he
  have hz : expUnit (0 : MatrixProduct ι)=1 := by apply Units.ext; simp [expUnit_val]
  rw [hz,one_mul] at he
  rw [he]; exact hv

theorem slProduct_has_finite_word [∀ b,Nontrivial (ι b)]
    (g : κ → MatrixProduct ι) (hg : ∀ k b,(g k b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g))
    (M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    ∃ l : List (κ × ℝ),(l.map (fun p => expUnit (p.2 • g p.1))).prod=slProductToUnits M :=
  reachable_has_word g (slProduct_reachable g hg hfull M)

end HarmonicCounterexample.FiniteControl

end

noncomputable section
open scoped Topology
open NormedSpace Module Filter
open scoped Topology

namespace HarmonicCounterexample.FiniteControl
open Matrix
open scoped Matrix.Norms.Frobenius ContDiff
attribute [local instance 100] LieRing.ofAssociativeRing
variable {β κ : Type*} [Fintype β] {ι : β → Type*}
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)]

def tracefreeProduct : Submodule ℝ (MatrixProduct ι) where
  carrier := {X | ∀ b,(X b).trace=0}
  zero_mem' := by simp
  add_mem' hx hy := by intro b; rw [Pi.add_apply,Matrix.trace_add,hx,hy,add_zero]
  smul_mem' c X hx := by intro b; rw [Pi.smul_apply,Matrix.trace_smul,hx,smul_zero]

lemma adjoint_trace (h : (MatrixProduct ι)ˣ) (X : MatrixProduct ι) (b : β) :
    (adjoint h X b).trace=(X b).trace := by
  change (((h : MatrixProduct ι) b * X b) * ((h⁻¹ : (MatrixProduct ι)ˣ) : MatrixProduct ι) b).trace= _
  rw [Matrix.trace_mul_cycle]
  have hi := congrFun h.inv_val b
  change ((h⁻¹ : (MatrixProduct ι)ˣ) : MatrixProduct ι) b * (h : MatrixProduct ι) b=1 at hi
  rw [hi,Matrix.one_mul]

lemma adjointSpan_eq_tracefree (g : κ → MatrixProduct ι)
    (hg : ∀ k b,(g k b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g)) :
    adjointSpan g=tracefreeProduct := by
  apply le_antisymm
  · apply Submodule.span_le.2
    rintro X ⟨h,_,k,rfl⟩
    intro b
    rw [adjoint_trace,hg]
  · intro X hX
    exact lieSpan_le_adjointSpan g (hfull X hX)

/-- A genuine smooth finite control word centered at ANY desired special-linear
product, with an isomorphic derivative onto the right-translated trace-free
space. Every conjugating factor is itself an actual finite control word. -/
theorem sl_target_word_submersion [∀ b,Nontrivial (ι b)]
    (g : κ → MatrixProduct ι) (hg : ∀ k b,(g k b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g))
    (M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    ∃ (d : ℕ) (h : Fin d → (MatrixProduct ι)ˣ) (k : Fin d → κ)
      (e : (Fin d → ℝ) ≃L[ℝ] (tracefreeProduct (ι:=ι)))
      (targetWord : List (κ × ℝ)),
      (∀ i,∃ l : List (κ × ℝ),(l.map (fun p => expUnit (p.2 • g p.1))).prod=h i) ∧
      (targetWord.map (fun p => expUnit (p.2 • g p.1))).prod=slProductToUnits M ∧
      d=Module.finrank ℝ (tracefreeProduct (ι:=ι)) ∧
      ContDiff ℝ ∞ (fun t => conjugateWord h (g ∘ k) t * (slProductToUnits M : MatrixProduct ι)) ∧
      HasStrictFDerivAt (conjugateWord h (g ∘ k))
        ((tracefreeProduct (ι:=ι)).subtypeL.comp (e : (Fin d → ℝ) →L[ℝ] _)) 0 := by
  have H := exists_word_submersion g
  rw [adjointSpan_eq_tracefree g hg hfull] at H
  obtain ⟨d,h,k,e,hh,hd,hs,he⟩ := H
  obtain ⟨w,hw⟩ := slProduct_has_finite_word g hg hfull M
  exact ⟨d,h,k,e,w,fun i => reachable_has_word g (hh i),hw,hd,hs.mul contDiff_const,he⟩

end HarmonicCounterexample.FiniteControl

end

noncomputable section


namespace HarmonicCounterexample.FiniteControl
open scoped ContDiff
variable {A κ H : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]
  [NormedAddCommGroup H] [NormedSpace ℝ H]

/-- A finite control word with genuine smooth scalar amplitudes. -/
def parameterWord (g : κ → A) (w : List (κ × (H → ℝ))) (x : H) : A :=
  (w.map (fun p => NormedSpace.exp (p.2 x • g p.1))).prod

def constantWord (w : List (κ × ℝ)) : List (κ × (H → ℝ)) :=
  w.map (fun p => (p.1,fun _ => p.2))

def inverseWord (w : List (κ × ℝ)) : List (κ × ℝ) :=
  w.reverse.map (fun p => (p.1,-p.2))

omit [CompleteSpace A] [NormedAddCommGroup H] [NormedSpace ℝ H] in
lemma parameterWord_append (g : κ → A) (w v : List (κ × (H → ℝ))) (x : H) :
    parameterWord g (w++v) x=parameterWord g w x*parameterWord g v x := by
  simp [parameterWord]

omit [NormedAddCommGroup H] [NormedSpace ℝ H] in
lemma constantWord_value (g : κ → A) (w : List (κ × ℝ)) (x : H) :
    parameterWord g (constantWord w) x=
      ((w.map (fun p => expUnit (p.2 • g p.1))).prod : Aˣ) := by
  induction w with
  | nil => simp [parameterWord,constantWord]
  | cons p w ih => simpa only [constantWord,List.map_cons,parameterWord,List.prod_cons,
      Units.val_mul,expUnit_val] using congrArg (fun y : A => NormedSpace.exp (p.2 • g p.1)*y) ih

lemma inverseWord_value (g : κ → A) (w : List (κ × ℝ)) :
    ((inverseWord w).map (fun p => expUnit (p.2 • g p.1))).prod=
      ((w.map (fun p => expUnit (p.2 • g p.1))).prod)⁻¹ := by
  simp only [inverseWord,List.map_map,Function.comp_def,neg_smul,expUnit_neg]
  simp only [List.prod_inv_reverse,List.map_reverse,List.map_map,Function.comp_def]

lemma constantWord_smooth (w : List (κ × ℝ)) :
    ∀ p ∈ constantWord (H:=H) w,ContDiff ℝ ∞ p.2 := by
  intro p hp
  obtain ⟨q,_,rfl⟩ := List.mem_map.1 hp
  exact contDiff_const

/-- Flatten reachable conjugations and the target into one fixed finite list.
No abstract exponential controls remain beyond the permitted generators. -/
theorem conjugate_word_flatten {d : ℕ} (g : κ → A)
    (h : Fin d → Aˣ) (k : Fin d → κ) (w : Fin d → List (κ × ℝ))
    (hw : ∀ i,(w i |>.map (fun p => expUnit (p.2 • g p.1))).prod=h i)
    (target : List (κ × ℝ)) (coord : H →L[ℝ] (Fin d → ℝ)) :
    ∃ z : List (κ × (H → ℝ)),
      (∀ p ∈ z,ContDiff ℝ ∞ p.2) ∧
      ∀ x,parameterWord g z x=conjugateWord h (g ∘ k) (coord x)*
        ((target.map (fun p => expUnit (p.2 • g p.1))).prod : Aˣ) := by
  let packet := fun i : Fin d => constantWord (H:=H) (w i) ++
    [(k i,fun x => coord x i)] ++ constantWord (H:=H) (inverseWord (w i))
  have hpacket (i : Fin d) (x : H) : parameterWord g (packet i) x=
      adjoint (h i) (NormedSpace.exp (coord x i • g (k i))) := by
    dsimp only [packet]
    rw [parameterWord_append,parameterWord_append,constantWord_value,constantWord_value,
      inverseWord_value,hw]
    simp only [parameterWord,List.map_cons,List.map_nil,List.prod_cons,List.prod_nil,mul_one,adjoint_apply]
  have hpacketsmooth (i : Fin d) : ∀ p ∈ packet i,ContDiff ℝ ∞ p.2 := by
    intro p hp
    simp only [packet,List.mem_append,List.mem_singleton] at hp
    rcases hp with (hp|rfl)|hp
    · exact constantWord_smooth _ _ hp
    · exact ((ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ).comp coord).contDiff
    · exact constantWord_smooth _ _ hp
  let z := (List.finRange d).flatMap packet ++ constantWord (H:=H) target
  refine ⟨z,?_,?_⟩
  · intro p hp
    rcases List.mem_append.1 hp with hp|hp
    · obtain ⟨i,_,hp⟩ := List.mem_flatMap.1 hp
      exact hpacketsmooth i p hp
    · exact constantWord_smooth _ _ hp
  · intro x
    rw [show z=(List.finRange d).flatMap packet ++ constantWord target from rfl,
      parameterWord_append,constantWord_value]
    congr 1
    unfold conjugateWord
    induction List.finRange d with
    | nil => simp [parameterWord]
    | cons i l ih => simp only [List.flatMap_cons,parameterWord_append,List.map_cons,
        List.prod_cons,hpacket,ih,Function.comp_apply]

end HarmonicCounterexample.FiniteControl

end

noncomputable section


namespace HarmonicCounterexample.FiniteControl.SmoothWord
open scoped ContDiff
variable {A κ H : Type*} [NormedRing A] [NormedAlgebra ℝ A] [CompleteSpace A]
  [NormedAddCommGroup H] [NormedSpace ℝ H]

omit [NormedAlgebra ℝ A] [CompleteSpace A] in
lemma leftWord_reverse_product (X : ℕ → A) (n : ℕ) :
    leftWord X n=((List.ofFn (fun i : Fin n => NormedSpace.exp (X i.val))).reverse).prod := by
  induction n with
  | zero => simp [leftWord]
  | succ n ih =>
    simp only [leftWord,List.ofFn_succ',List.concat_eq_append,List.reverse_append,List.reverse_cons,List.reverse_nil,
      List.nil_append,List.prod_append,List.prod_cons,List.prod_nil,mul_one,Fin.val_last,Fin.val_castSucc]
    rw [ih]

omit [NormedAddCommGroup H] [NormedSpace ℝ H] in
lemma packet_reverse_list (g : κ → A) (w : List (κ × (H → ℝ))) (x : H) :
    LinearODE.flow (fun t => ContinuousLinearMap.mul ℝ A
      (unitPacketCoefficient (fun i : Fin w.reverse.length => (w.reverse.get i).2 x)
        (fun i => g (w.reverse.get i).1) t)) 1 1=parameterWord g w x := by
  rw [actual_packet_endpoint,leftWord_reverse_product]
  have he : (List.ofFn (fun i : Fin w.reverse.length =>
      NormedSpace.exp (extendWord (fun i => (w.reverse.get i).2 x)
        (fun i => g (w.reverse.get i).1) i.val)))=
      w.reverse.map (fun p => NormedSpace.exp (p.2 x • g p.1)) := by
    simp only [extendWord,Fin.isLt,dite_eq_left]
    simpa only [Function.comp_def,List.ofFn_get] using
      (List.map_ofFn (f:=w.reverse.get)
        (g:=fun p : κ × (H → ℝ) => NormedSpace.exp (p.2 x • g p.1))).symm
  rw [he,← List.map_reverse,List.reverse_reverse]
  rfl

/-- The finite SL word is realized by the actual smooth chronological packet,
with a positive number of slots and smooth genuine amplitudes. -/
theorem smooth_packet_of_parameter_word [Nonempty κ] (g : κ → A)
    (w : List (κ × (H → ℝ))) (hw : ∀ p ∈ w,ContDiff ℝ ∞ p.2) :
    ∃ (n : ℕ) (_ : NeZero n) (slot : Fin n → κ) (amps : Fin n → H → ℝ),
      (∀ i,ContDiff ℝ ∞ (amps i)) ∧ ∀ x,
      LinearODE.flow (fun t => ContinuousLinearMap.mul ℝ A
        (unitPacketCoefficient (fun i => amps i x) (fun i => g (slot i)) t)) 1 1=
          parameterWord g w x := by
  classical
  let k₀ : κ := Classical.choice inferInstance
  let z : List (κ × (H → ℝ)) := (k₀,fun _ => (0:ℝ))::w
  refine ⟨z.reverse.length,⟨by simp [z]⟩,fun i => (z.reverse.get i).1,
    fun i => (z.reverse.get i).2,?_,?_⟩
  · intro i
    have hi : z.reverse.get i ∈ z := List.mem_reverse.1 (List.get_mem _ _)
    rcases List.mem_cons.1 hi with hi|hi
    · change ContDiff ℝ ∞ (z.reverse.get i).2
      rw [hi]
      exact contDiff_const
    · exact hw _ hi
  · intro x
    rw [packet_reverse_list]
    simp only [parameterWord,z,List.map_cons,List.prod_cons,zero_smul,NormedSpace.exp_zero,one_mul]

end HarmonicCounterexample.FiniteControl.SmoothWord

end

noncomputable section


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

abbrev MatrixProduct' := ∀ b,Matrix (ι b) (ι b) ℝ

def tracefreeProduct' : Submodule ℝ (MatrixProduct' (ι:=ι)) where
  carrier := {X | ∀ b,(X b).trace=0}
  zero_mem' := by simp
  add_mem' hx hy := by intro b; rw [Pi.add_apply,Matrix.trace_add,hx,hy,add_zero]
  smul_mem' c X hx := by intro b; rw [Pi.smul_apply,Matrix.trace_smul,hx,smul_zero]

def meanTrace (X : MatrixProduct' (ι:=ι)) (b : β) : ℝ :=
  (X b).trace/(Fintype.card (ι b):ℝ)

/-- Linear local SL chart: project away scalar matrices after translating the
exact target to the identity. No abstract manifold chart is assumed. -/
def tracefreeProjection : MatrixProduct' (ι:=ι) →ₗ[ℝ] tracefreeProduct' (ι:=ι) where
  toFun X := ⟨fun b => X b-meanTrace X b • 1,by
    intro b
    have hn : (Fintype.card (ι b):ℝ) ≠ 0 := Nat.cast_ne_zero.2 Fintype.card_ne_zero
    simp only [Matrix.trace_sub,Matrix.trace_smul,Matrix.trace_one,smul_eq_mul,meanTrace]
    rw [div_mul_cancel₀ _ hn,sub_self]⟩
  map_add' X Y := by
    apply Subtype.ext
    funext b
    change (X b+Y b)-meanTrace (X+Y) b • 1=
      (X b-meanTrace X b • 1)+(Y b-meanTrace Y b • 1)
    simp only [Pi.add_apply,Matrix.trace_add,meanTrace,add_div,add_smul]
    abel
  map_smul' c X := by
    apply Subtype.ext
    funext b
    change c • X b-meanTrace (c • X) b • 1=c • (X b-meanTrace X b • 1)
    simp only [Pi.smul_apply,Matrix.trace_smul,meanTrace,smul_eq_mul,
      mul_div_assoc,smul_sub,smul_smul]

/-- Projection zero is exactly scalarity, with the scalar given explicitly. -/
lemma tracefreeProjection_zero_iff (X : MatrixProduct' (ι:=ι)) :
    tracefreeProjection X=0 ↔ ∀ b,X b=meanTrace X b • 1 := by
  constructor
  · intro h b
    have he := congrFun (congrArg Subtype.val h) b
    exact sub_eq_zero.1 he
  · intro h
    apply Subtype.ext
    funext b
    change X b-meanTrace X b • 1=0
    rw [h b,sub_self]

lemma tracefreeProjection_id : tracefreeProjection (1 : MatrixProduct' (ι:=ι))=0 := by
  apply (tracefreeProjection_zero_iff _).2
  intro b
  have hn : (Fintype.card (ι b):ℝ) ≠ 0 := Nat.cast_ne_zero.2 Fintype.card_ne_zero
  simp [meanTrace,hn]

lemma tracefreeProjection_subtype (X : tracefreeProduct' (ι:=ι)) :
    tracefreeProjection X=X := by
  apply Subtype.ext
  funext b
  change (X : MatrixProduct' (ι:=ι)) b-meanTrace (X : MatrixProduct' (ι:=ι)) b • 1=(X : MatrixProduct' (ι:=ι)) b
  simp only [meanTrace,X.property b,zero_div,zero_smul,sub_zero]

/-- Positivity of trace resolves the spurious negative scalar branch. This is
an OPEN condition near the prescribed positive scalar times the target. -/
lemma positive_scalar_of_projection_zero {X : MatrixProduct' (ι:=ι)}
    (hX : tracefreeProjection X=0) (htr : ∀ b,0 < (X b).trace) :
    ∀ b,∃ c : ℝ,0 < c ∧ X b=c • 1 := by
  intro b
  exact ⟨meanTrace X b,div_pos (htr b) (Nat.cast_pos.2 Fintype.card_pos),
    (tracefreeProjection_zero_iff X).1 hX b⟩

/-- Vanishing projected transmission gives the EXACT target, up to the
positive scalar permitted by source equation (exact-transmission). -/
lemma exact_scalar_target {X : MatrixProduct' (ι:=ι)} (M : (MatrixProduct' (ι:=ι))ˣ)
    (hX : tracefreeProjection (X*(↑M⁻¹ : MatrixProduct' (ι:=ι)))=0)
    (htr : ∀ b,0 < ((X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b).trace) :
    ∀ b,∃ c : ℝ,0 < c ∧ X b=c • ((M : MatrixProduct' (ι:=ι)) b) := by
  intro b
  obtain ⟨c,hc,he⟩ := positive_scalar_of_projection_zero hX htr b
  refine ⟨c,hc,?_⟩
  have h := congrArg (fun A : Matrix (ι b) (ι b) ℝ => A*((M : MatrixProduct' (ι:=ι)) b)) he
  have hi := congrFun M.inv_val b
  change ((M⁻¹ : (MatrixProduct' (ι:=ι))ˣ) : MatrixProduct' (ι:=ι)) b*
    (M : MatrixProduct' (ι:=ι)) b=1 at hi
  simpa only [Pi.mul_apply,Matrix.mul_assoc,hi,Matrix.mul_one,Matrix.smul_mul,
    Matrix.one_mul] using h

end HarmonicCounterexample.FiniteControl.Frobenius

end

noncomputable section


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

def translatedProjection (M : (MatrixProduct' (ι:=ι))ˣ) :
    MatrixProduct' (ι:=ι) →L[ℝ] tracefreeProduct' (ι:=ι) :=
  (tracefreeProjection (ι:=ι)).toContinuousLinearMap.comp
    ((ContinuousLinearMap.mul ℝ (MatrixProduct' (ι:=ι))).flip (↑M⁻¹))

lemma translatedProjection_apply (M : (MatrixProduct' (ι:=ι))ˣ)
    (X : MatrixProduct' (ι:=ι)) :
    translatedProjection M X=tracefreeProjection (X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) := rfl

lemma positive_trace_neighborhood (M : (MatrixProduct' (ι:=ι))ˣ) :
    IsOpen {X : MatrixProduct' (ι:=ι) | ∀ b,0 < ((X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b).trace} ∧
    (M : MatrixProduct' (ι:=ι)) ∈
      {X : MatrixProduct' (ι:=ι) | ∀ b,0 < ((X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b).trace} := by
  constructor
  · rw [show {X : MatrixProduct' (ι:=ι) | ∀ b,0 < ((X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b).trace}=
        (⋂ b,{X : MatrixProduct' (ι:=ι) | 0 < ((X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b).trace}) by ext X; simp]
    apply isOpen_iInter_of_finite
    intro b
    apply isOpen_lt continuous_const
    simp only [Matrix.trace]
    apply continuous_finsetSum
    intro i _
    apply Continuous.matrix_elem
    exact (continuous_apply b).comp (continuous_id.mul continuous_const)
  · intro b
    rw [Units.mul_inv]
    change 0 < (1 : Matrix (ι b) (ι b) ℝ).trace
    rw [Matrix.trace_one]
    exact Nat.cast_pos.2 Fintype.card_pos

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

/-- Quantitative actual exact positive-scalar attainment, avoiding determinant
normalization altogether. Each actual map has genuine Frechet derivatives and
uniform C1 errors; the same tolerance works for every preceding history. -/
theorem uniform_exact_scalar_attainment
    (M : (MatrixProduct' (ι:=ι))ˣ) (Φ : E → MatrixProduct' (ι:=ι))
    (Φ' : E → E →L[ℝ] MatrixProduct' (ι:=ι))
    (A : E ≃L[ℝ] tracefreeProduct' (ι:=ι))
    (hΦ : ContinuousAt Φ 0) (hΦ' : ContinuousAt Φ' 0)
    (hvalue : Φ 0=(M : MatrixProduct' (ι:=ι)))
    (hjet : (translatedProjection M).comp (Φ' 0)=A.toContinuousLinearMap) :
    ∃ r ε : ℝ,0 < r ∧ 0 < ε ∧
      ∀ (Ψ : E → MatrixProduct' (ι:=ι)) (Ψ' : E → E →L[ℝ] MatrixProduct' (ι:=ι)),
        (∀ x ∈ Metric.closedBall (0:E) r,HasFDerivAt Ψ (Ψ' x) x) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖Ψ x-Φ x‖ ≤ ε) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖(Ψ' x-Φ' x : E →L[ℝ] MatrixProduct' (ι:=ι))‖ ≤ ε) →
        ∃ x ∈ Metric.closedBall (0:E) r,
          ∀ b,∃ c : ℝ,0 < c ∧ Ψ x b=c • ((M : MatrixProduct' (ι:=ι)) b) := by
  let L := A.symm.toContinuousLinearMap.comp (translatedProjection M)
  have hLzero : L (Φ 0)=0 := by
    dsimp [L]
    rw [hvalue,translatedProjection_apply,Units.mul_inv,tracefreeProjection_id,map_zero]
  have hLjet : L.comp (Φ' 0)=(ContinuousLinearEquiv.refl ℝ E).toContinuousLinearMap := by
    dsimp [L]
    rw [ContinuousLinearMap.comp_assoc,hjet]
    ext x
    exact A.symm_apply_apply x
  obtain ⟨hU,htgt⟩ := positive_trace_neighborhood M
  obtain ⟨r,ε,hr,hε,hworks⟩ := HarmonicCounterexample.Transmission.uniform_projected_attainment
    Φ Φ' L (ContinuousLinearEquiv.refl ℝ E) hΦ hΦ' hLzero hLjet hU (hvalue ▸ htgt)
  refine ⟨r,ε,hr,hε,fun Ψ Ψ' hd hv hj => ?_⟩
  obtain ⟨x,hx,hxz,hxU⟩ := hworks Ψ Ψ' hd hv hj
  refine ⟨x,hx,exact_scalar_target M ?_ hxU⟩
  apply A.symm.injective
  change A.symm (translatedProjection M (Ψ x))=A.symm 0
  rw [map_zero]
  exact hxz

end HarmonicCounterexample.FiniteControl.Frobenius

end

noncomputable section


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

def boundedScalarNeighborhood (M : (MatrixProduct' (ι:=ι))ˣ) : Set (MatrixProduct' (ι:=ι)) :=
  {X | ∀ b,meanTrace (X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b ∈ Set.Ioo (1/2:ℝ) (3/2)}

lemma boundedScalarNeighborhood_open (M : (MatrixProduct' (ι:=ι))ˣ) :
    IsOpen (boundedScalarNeighborhood M) ∧ (M : MatrixProduct' (ι:=ι)) ∈ boundedScalarNeighborhood M := by
  have hc (b : β) : Continuous (fun X : MatrixProduct' (ι:=ι) =>
      meanTrace (X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b) := by
    apply Continuous.div_const
    simp only [Matrix.trace]
    apply continuous_finsetSum
    intro i _
    apply Continuous.matrix_elem
    exact (continuous_apply b).comp (continuous_id.mul continuous_const)
  constructor
  · rw [show boundedScalarNeighborhood M=⋂ b,{X | meanTrace (X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b ∈ Set.Ioo (1/2:ℝ) (3/2)} by ext X;simp [boundedScalarNeighborhood]]
    exact isOpen_iInter_of_finite fun b => isOpen_Ioo.preimage (hc b)
  · intro b
    rw [Units.mul_inv]
    have hn : (Fintype.card (ι b):ℝ) ≠ 0 := Nat.cast_ne_zero.2 Fintype.card_ne_zero
    norm_num [meanTrace,hn]

lemma bounded_scalar_target {X : MatrixProduct' (ι:=ι)} (M : (MatrixProduct' (ι:=ι))ˣ)
    (hX : translatedProjection M X=0) (hU : X ∈ boundedScalarNeighborhood M) :
    ∀ b,∃ c : ℝ,c ∈ Set.Ioo (1/2:ℝ) (3/2) ∧ X b=c • ((M : MatrixProduct' (ι:=ι)) b) := by
  intro b
  refine ⟨meanTrace (X*(↑M⁻¹ : MatrixProduct' (ι:=ι))) b,hU b,?_⟩
  change tracefreeProjection (X*(↑M⁻¹ : MatrixProduct' (ι:=ι)))=0 at hX
  have he := (tracefreeProjection_zero_iff _).1 hX b
  have h := congrArg (fun A : Matrix (ι b) (ι b) ℝ => A*((M : MatrixProduct' (ι:=ι)) b)) he
  have hi := congrFun M.inv_val b
  change (↑M⁻¹ : MatrixProduct' (ι:=ι)) b*(M : MatrixProduct' (ι:=ι)) b=1 at hi
  simpa only [Pi.mul_apply,Matrix.mul_assoc,hi,Matrix.mul_one,Matrix.smul_mul,Matrix.one_mul] using h

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

/-- The exact target scalar stays in a fixed compact positive range. This
also supplies the uniform logarithmic scalar bound required for growth. -/
theorem uniform_exact_bounded_scalar_attainment
    (M : (MatrixProduct' (ι:=ι))ˣ) (Φ : E → MatrixProduct' (ι:=ι))
    (Φ' : E → E →L[ℝ] MatrixProduct' (ι:=ι))
    (A : E ≃L[ℝ] tracefreeProduct' (ι:=ι))
    (hΦ : ContinuousAt Φ 0) (hΦ' : ContinuousAt Φ' 0)
    (hvalue : Φ 0=(M : MatrixProduct' (ι:=ι)))
    (hjet : (translatedProjection M).comp (Φ' 0)=A.toContinuousLinearMap) :
    ∃ r ε : ℝ,0 < r ∧ 0 < ε ∧
      ∀ (Ψ : E → MatrixProduct' (ι:=ι)) (Ψ' : E → E →L[ℝ] MatrixProduct' (ι:=ι)),
        (∀ x ∈ Metric.closedBall (0:E) r,HasFDerivAt Ψ (Ψ' x) x) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖Ψ x-Φ x‖ ≤ ε) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖(Ψ' x-Φ' x : E →L[ℝ] MatrixProduct' (ι:=ι))‖ ≤ ε) →
        ∃ x ∈ Metric.closedBall (0:E) r,
          ∀ b,∃ c : ℝ,c ∈ Set.Ioo (1/2:ℝ) (3/2) ∧ Ψ x b=c • ((M : MatrixProduct' (ι:=ι)) b) := by
  let L := A.symm.toContinuousLinearMap.comp (translatedProjection M)
  have hLzero : L (Φ 0)=0 := by
    dsimp [L]
    rw [hvalue,translatedProjection_apply,Units.mul_inv,tracefreeProjection_id,map_zero]
  have hLjet : L.comp (Φ' 0)=(ContinuousLinearEquiv.refl ℝ E).toContinuousLinearMap := by
    dsimp [L]
    rw [ContinuousLinearMap.comp_assoc,hjet]
    ext x
    exact A.symm_apply_apply x
  obtain ⟨hU,htgt⟩ := boundedScalarNeighborhood_open M
  obtain ⟨r,ε,hr,hε,hworks⟩ := HarmonicCounterexample.Transmission.uniform_projected_attainment
    Φ Φ' L (ContinuousLinearEquiv.refl ℝ E) hΦ hΦ' hLzero hLjet hU (hvalue ▸ htgt)
  refine ⟨r,ε,hr,hε,fun Ψ Ψ' hd hv hj => ?_⟩
  obtain ⟨x,hx,hxz,hxU⟩ := hworks Ψ Ψ' hd hv hj
  refine ⟨x,hx,bounded_scalar_target M ?_ hxU⟩
  apply A.symm.injective
  change A.symm (translatedProjection M (Ψ x))=A.symm 0
  rw [map_zero]
  exact hxz

end HarmonicCounterexample.FiniteControl.Frobenius

end

noncomputable section


namespace HarmonicCounterexample.FiniteControl.Frobenius
open Matrix HarmonicCounterexample.Transmission
open scoped BigOperators Matrix.Norms.Frobenius Topology
variable {β : Type*} [Fintype β] {ι : β → Type*}
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)] [∀ b,Nonempty (ι b)]
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [FiniteDimensional ℝ E]
local instance : NormedAddCommGroup (E →L[ℝ] MatrixProduct' (ι:=ι)) := ContinuousLinearMap.toNormedAddCommGroup
local instance : NormedSpace ℝ (E →L[ℝ] MatrixProduct' (ι:=ι)) := ContinuousLinearMap.toNormedSpace

/-- Uniform actual WHOLE-period attainment, after factoring the entire
parameter-independent diagonal leg. The error tolerance is chosen before
K, Q and B, so it does not depend on the incoming history or diagonal
anisotropy. Q and B have genuine Frechet derivatives. -/
theorem whole_period_uniform_attainment
    (M : (MatrixProduct' (ι:=ι))ˣ) (Φ : E → MatrixProduct' (ι:=ι))
    (Φ' : E → E →L[ℝ] MatrixProduct' (ι:=ι))
    (A : E ≃L[ℝ] tracefreeProduct' (ι:=ι))
    (hΦ : Continuous Φ) (hΦ' : Continuous Φ')
    (hvalue : Φ 0=(M : MatrixProduct' (ι:=ι)))
    (hjet : (translatedProjection M).comp (Φ' 0)=A.toContinuousLinearMap)
    {K₀ : ℝ} (hK₀ : 0 ≤ K₀) :
    ∃ r σ : ℝ,0 < r ∧ 0 < σ ∧
      ∀ (K : MatrixProduct' (ι:=ι)) (Q B : E → MatrixProduct' (ι:=ι))
        (Q' B' : E → E →L[ℝ] MatrixProduct' (ι:=ι)),
        ‖K‖ ≤ K₀ →
        (∀ x ∈ Metric.closedBall (0:E) r,HasFDerivAt Q (Q' x) x) →
        (∀ x ∈ Metric.closedBall (0:E) r,HasFDerivAt B (B' x) x) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖Q x‖ ≤ σ) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖B x-Φ x‖ ≤ σ) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖Q' x‖ ≤ σ) →
        (∀ x ∈ Metric.closedBall (0:E) r,‖(B' x-Φ' x : E →L[ℝ] MatrixProduct' (ι:=ι))‖ ≤ σ) →
        ∃ x ∈ Metric.closedBall (0:E) r,
          ∀ b,∃ c : ℝ,c ∈ Set.Ioo (1/2:ℝ) (3/2) ∧
            wholePeriod K (Q x) (B x) b=c • ((M : MatrixProduct' (ι:=ι)) b) := by
  obtain ⟨r,ε,hr,hε,hworks⟩ := uniform_exact_bounded_scalar_attainment M Φ Φ' A
    hΦ.continuousAt hΦ'.continuousAt hvalue hjet
  obtain ⟨H₀,hH₀⟩ := (isCompact_closedBall (0:E) r).exists_bound_of_continuousOn hΦ.continuousOn
  obtain ⟨H₁,hH₁⟩ := (isCompact_closedBall (0:E) r).exists_bound_of_continuousOn hΦ'.continuousOn
  let V₀ := max H₀ 0
  let V₁ := max H₁ 0
  have hv₀ : 0 ≤ V₀ := le_max_right _ _
  have hv₁ : 0 ≤ V₁ := le_max_right _ _
  let N := 1+K₀*(V₁+1)+K₀*(V₀+1)
  have hN : 0 < N := by dsimp [N];positivity
  let σ := min 1 (ε/N)
  have hσ : 0 < σ := lt_min zero_lt_one (div_pos hε hN)
  have hσ₁ : σ ≤ 1 := min_le_left _ _
  have hσε : σ*N ≤ ε := (le_div_iff₀ hN).1 (min_le_right _ _)
  refine ⟨r,σ,hr,hσ,?_⟩
  intro K Q B Q' B' hK hdQ hdB hQ hB hQ' hB'
  apply hworks (fun x => wholePeriod K (Q x) (B x)) (fun x => wholePeriodJet K (Q x) (B x) (Q' x) (B' x))
  · intro x hx
    exact wholePeriod_hasFDerivAt K (hdQ x hx) (hdB x hx)
  · intro x hx
    have hb0 : ‖Φ x‖ ≤ V₀ := (hH₀ x hx).trans (le_max_left _ _)
    have hh := wholePeriod_value_error hK (hQ x hx) (hB x hx) hb0
    have hks : 0 ≤ K₀*σ := mul_nonneg hK₀ hσ.le
    have he : K₀*σ*(V₀+σ) ≤ K₀*σ*(V₀+1) :=
      mul_le_mul_of_nonneg_left (add_le_add_right hσ₁ V₀) hks
    have hextra : 0 ≤ σ*(K₀*(V₁+1)) := by positivity
    apply hh.trans
    apply le_trans _ hσε
    dsimp [N]
    nlinarith
  · intro x hx
    have hb0 : ‖Φ x‖ ≤ V₀ := (hH₀ x hx).trans (le_max_left _ _)
    have hb1 : ‖Φ' x‖ ≤ V₁ := (hH₁ x hx).trans (le_max_left _ _)
    have hh := wholePeriod_jet_error hK (hQ x hx) (hB x hx) hb0 (hQ' x hx) (hB' x hx) hb1
    have hks : 0 ≤ K₀*σ := mul_nonneg hK₀ hσ.le
    have he0 : K₀*σ*(V₀+σ) ≤ K₀*σ*(V₀+1) :=
      mul_le_mul_of_nonneg_left (add_le_add_right hσ₁ V₀) hks
    have he1 : K₀*σ*(V₁+σ) ≤ K₀*σ*(V₁+1) :=
      mul_le_mul_of_nonneg_left (add_le_add_right hσ₁ V₁) hks
    apply hh.trans
    apply le_trans _ hσε
    dsimp [N]
    nlinarith

omit [∀ (b : β), Nonempty (ι b)] in
/-- Cancellation of the factor of the ENTIRE diagonal leg gives the exact
chronological target c D M. No exponentially anisotropic conjugation occurs. -/
lemma whole_period_exact_leg {U V P B : MatrixProduct' (ι:=ι)} {θ : ℝ}
    (D M : (MatrixProduct' (ι:=ι))ˣ) (hD : (D:MatrixProduct' (ι:=ι))=U+θ • V)
    (hatt : ∀ b,∃ c : ℝ,c ∈ Set.Ioo (1/2:ℝ) (3/2) ∧
      wholePeriod ((↑D⁻¹:MatrixProduct' (ι:=ι))*V) (P-θ • 1) B b=
        c • ((M:MatrixProduct' (ι:=ι)) b)) :
    ∀ b,∃ c : ℝ,c ∈ Set.Ioo (1/2:ℝ) (3/2) ∧
      ((U+V*P)*B) b=c • (((D:MatrixProduct' (ι:=ι))*(M:MatrixProduct' (ι:=ι))) b) := by
  intro b
  obtain ⟨c,hc,he⟩ := hatt b
  refine ⟨c,hc,?_⟩
  have hf := full_leg_factor U V P B θ D hD
  change (↑D⁻¹:MatrixProduct' (ι:=ι))*((U+V*P)*B)=wholePeriod ((↑D⁻¹:MatrixProduct' (ι:=ι))*V) (P-θ • 1) B at hf
  have hh := congrArg (fun X : MatrixProduct' (ι:=ι) => ((D:MatrixProduct' (ι:=ι))*X) b) hf
  rw [← mul_assoc,Units.mul_inv,one_mul] at hh
  rw [hh]
  change (D:MatrixProduct' (ι:=ι)) b*wholePeriod ((↑D⁻¹:MatrixProduct' (ι:=ι))*V) (P-θ • 1) B b=_
  rw [he,Matrix.mul_smul]
  rfl

end HarmonicCounterexample.FiniteControl.Frobenius

end

noncomputable section


namespace HarmonicCounterexample.FiniteControl
open SmoothWord Frobenius
open scoped ContDiff Matrix.Norms.Frobenius
attribute [local instance 100] LieRing.ofAssociativeRing
variable {β κ : Type*} [Fintype β] [Nonempty κ] {ι : β → Type*}
  [∀ b,Fintype (ι b)] [∀ b,DecidableEq (ι b)] [∀ b,Nontrivial (ι b)]

/-- The actual smooth chronological finite control packet centered at the exact
SL target, with a genuine invertible projected derivative. The parameter norm
is Euclidean, the same norm used by the uniform physical estimates. -/
theorem smooth_SL_packet_submersion (g : κ → MatrixProduct ι)
    (hg : ∀ k b,(g k b).trace=0)
    (hfull : ∀ X : MatrixProduct ι,(∀ b,(X b).trace=0) →
      X ∈ LieSubalgebra.lieSpan ℝ _ (Set.range g))
    (M : ∀ b,Matrix.SpecialLinearGroup (ι b) ℝ) :
    ∃ (d n : ℕ) (_ : NeZero n) (slot : Fin n → κ)
      (amps : Fin n → EuclideanSpace ℝ (Fin d) → ℝ)
      (A : EuclideanSpace ℝ (Fin d) ≃L[ℝ] tracefreeProduct' (ι:=ι)),
      (∀ j,ContDiff ℝ ∞ (amps j)) ∧
      let Φ := fun x => LinearODE.flow (fun t => ContinuousLinearMap.mul ℝ (MatrixProduct ι)
        (unitPacketCoefficient (fun j => amps j x) (g ∘ slot) t)) 1 1
      ContDiff ℝ ∞ Φ ∧ Φ 0=(slProductToUnits M : MatrixProduct ι) ∧
      (translatedProjection (slProductToUnits M)).comp (fderiv ℝ Φ 0)=A.toContinuousLinearMap := by
  classical
  obtain ⟨d,h,k,e,target,hh,htarget,hd,hs,hjet⟩ := sl_target_word_submersion g hg hfull M
  choose w hw using hh
  let coord := EuclideanSpace.equiv (Fin d) ℝ
  obtain ⟨z,hzs,hz⟩ := conjugate_word_flatten g h k w hw target coord.toContinuousLinearMap
  obtain ⟨n,hn,slot,amps,ha,hpacket⟩ := smooth_packet_of_parameter_word g z hzs
  let Φ := fun x => LinearODE.flow (fun t => ContinuousLinearMap.mul ℝ (MatrixProduct ι)
    (unitPacketCoefficient (fun j => amps j x) (g ∘ slot) t)) 1 1
  have hΦ (x : EuclideanSpace ℝ (Fin d)) : Φ x=
      conjugateWord h (g ∘ k) (coord x)*(slProductToUnits M : MatrixProduct ι) := by
    rw [show Φ x=parameterWord g z x from hpacket x,hz,htarget]
    rfl
  have hΦs : ContDiff ℝ ∞ Φ := actual_packet_contDiff amps (g ∘ slot) ha
  let A : EuclideanSpace ℝ (Fin d) ≃L[ℝ] tracefreeProduct' (ι:=ι) := coord.trans e
  refine ⟨d,n,hn,slot,amps,A,ha,hΦs,?_,?_⟩
  · change Φ 0=_
    rw [hΦ,map_zero,conjugateWord_zero,one_mul]
  · have hc : HasFDerivAt (fun x : EuclideanSpace ℝ (Fin d) => conjugateWord h (g ∘ k) (coord x))
        (((tracefreeProduct (ι:=ι)).subtypeL.comp e.toContinuousLinearMap).comp coord.toContinuousLinearMap) 0 := by
      have hj := hjet.hasFDerivAt.comp (0:EuclideanSpace ℝ (Fin d)) coord.hasFDerivAt
      convert! hj using 1
    have hj := hc.mul_const' (slProductToUnits M : MatrixProduct ι)
    have heq : Φ=(fun x : EuclideanSpace ℝ (Fin d) => conjugateWord h (g ∘ k) (coord x)*
        (slProductToUnits M : MatrixProduct ι)) := funext hΦ
    let J := ((ContinuousLinearMap.mul ℝ (MatrixProduct ι)).flip (slProductToUnits M : MatrixProduct ι)).comp
      (((tracefreeProduct (ι:=ι)).subtypeL.comp e.toContinuousLinearMap).comp coord.toContinuousLinearMap)
    have hdΦ : HasFDerivAt Φ J 0 := by
      rw [heq]
      convert! hj using 1
    change (translatedProjection (slProductToUnits M)).comp (fderiv ℝ Φ 0)=A.toContinuousLinearMap
    have hdf : fderiv ℝ Φ (0 : EuclideanSpace ℝ (Fin d)) = J := by
      convert! hdΦ.fderiv using 1
    rw [hdf]
    apply ContinuousLinearMap.ext
    intro x
    simp only [J]
    change tracefreeProjection ((e (coord x) : MatrixProduct ι)*
      (slProductToUnits M : MatrixProduct ι)*(↑(slProductToUnits M)⁻¹ : MatrixProduct ι))=A x
    rw [mul_assoc,Units.mul_inv,mul_one]
    exact tracefreeProjection_subtype (A x)

end HarmonicCounterexample.FiniteControl

end

end OAI