import OAI.Dynamics.SmoothObstruction.CoordinateTubes
import OAI.Dynamics.SmoothObstruction.GreenOperator

namespace OAI

section

open MeasureTheory Filter Topology TopologicalSpace Set Finset
open scoped ENNReal NNReal BoundedContinuousFunction
open Finset MeasureTheory Filter Topology
open scoped BigOperators
open Finset Matrix
open scoped Matrix.Norms.L2Operator
open Matrix

namespace SmoothObstruction.ShortBin
open EuclideanSplitting
open scoped Matrix.Norms.L2Operator
variable {d n : ℕ} {K : ℝ}

noncomputable def Gauge.evolution (A : Gauge d n K) :=
  EuclideanSplitting.evolution A.U A.V A.lam A.UV A.VU
noncomputable def Gauge.splitting (A : Gauge d n K) (S : Finset (Fin d)) :=
  EuclideanSplitting.splitting A.U A.V A.lam A.UV A.VU S

lemma Gauge.space_eq_range (A : Gauge d n K) (S : Finset (Fin d)) :
    A.space S=((A.splitting S).slow 0).range :=
  (splitting_slow_range _ _ _ _ _ _ _).symm

/-- The orthogonal common-bin space comparisons construct the middle
matching equivalence for two genuine gauges with a possibly positive slow
threshold. Complementarity is proved, not assumed for the moving spaces. -/
theorem gauge_matching (A₀ A Z : Gauge d n K) (S₀ S T : Finset (Fin d))
    {ε : ℝ} (hε : 0≤ε) (hεhalf : ε≤1/2)
    (hdS : S₀.card=S.card) (hdT : S₀ᶜ.card=T.card)
    (hcS : ‖(A₀.space S₀).starProjection-(A.space S).starProjection‖≤ε)
    (hcT : ‖(A₀.space S₀ᶜ).starProjection-(Z.space T).starProjection‖≤ε)
    (hsmall : Real.exp (2*K)*(2*ε)≤1/2) :
    ∃ L : (((A.splitting S).slow 0).range×((Z.splitting T).slow 0).range) ≃L[ℝ]
      EuclideanSpace ℝ (Fin d),
      (∀ x,L x=(x.1:EuclideanSpace ℝ (Fin d))-(x.2:EuclideanSpace ℝ (Fin d))) ∧
      ‖L.symm.toContinuousLinearMap‖≤2*Real.exp (2*K) := by
  let B := A₀.splitting S₀
  have hs : ‖B.slow 0‖≤Real.exp (2*K) :=
    splitting_slow_norm _ _ _ _ _ _ 0 (A₀.normU _ (Nat.zero_le n)) (A₀.normV _ (Nat.zero_le n))
  have hf : ‖B.fast 0‖≤Real.exp (2*K) :=
    splitting_fast_norm _ _ _ _ _ _ 0 (A₀.normU _ (Nat.zero_le n)) (A₀.normV _ (Nat.zero_le n))
  have heS : (B.slow 0).range=A₀.space S₀ := (A₀.space_eq_range S₀).symm
  have heT : (B.fast 0).range=A₀.space S₀ᶜ :=
    splitting_fast_range _ _ _ _ _ _ _
  have hdS' : Module.finrank ℝ (B.slow 0).range=Module.finrank ℝ ((A.splitting S).slow 0).range := by
    rw [heS,←A.space_eq_range,A₀.rank,A.rank,hdS]
  have hdT' : Module.finrank ℝ (B.fast 0).range=Module.finrank ℝ ((Z.splitting T).slow 0).range := by
    rw [heT,←Z.space_eq_range,A₀.rank,Z.rank,hdT]
  apply CloseComplement.exists_matching (B.slow 0).range (B.fast 0).range
    ((A.splitting S).slow 0).range ((Z.splitting T).slow 0).range
    (B.referenceMatching 0) (B.referenceMatching_apply 0) hdS' hdT' hε hεhalf
  · simpa only [heS,←A.space_eq_range] using hcS
  · simpa only [heT,←Z.space_eq_range] using hcT
  · exact B.referenceMatching_inverse_norm 0 hs hf
  · exact hsmall
end SmoothObstruction.ShortBin

namespace SmoothObstruction.ManifoldCoordinates
open Bundle Set Filter Topology Metric MeasureTheory
open scoped Manifold ContDiff Matrix.Norms.L2Operator
variable {d : ℕ} {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners ℝ (EuclideanSpace ℝ (Fin d)) H)
    {M : Type*} [MetricSpace M] [ProperSpace M] [ChartedSpace H M] [IsManifold I ∞ M]
    {ι : Type*} [Fintype ι]

/-- A one-sided family of actual gauges can be carried to reference charts
using only the short orbit interval. This is also applicable at a long-window
endpoint, without demanding good data beyond that endpoint. -/
theorem uniform_genuine_single_gauges (hclosed : IsClosed (range I))
    (S : Diffeomorph I I M M ∞) (a : ι → M) (K : ι → Set M)
    (hK : ∀ i,IsCompact (K i)) (hKU : ∀ i,K i⊆(chartAt H (a i)).source) :
    ∃ r C₁ D : ℝ,0<r ∧ 1≤C₁ ∧ 1≤D ∧
      ∀ (c : M → ι) (J : Type*) (x : J → M) (e : J) (cR : ℕ → ι)
        (N : ℕ) (B h : ℝ) (A : J → ShortBin.Gauge d N B),
        (∀ y,y∈K (c y)) →
        (∀ i,∀ t<N,(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
          (coord I S (a (c (S^[t] (x i)))) (a (c (S^[t+1] (x i)))) (S^[t] (x i)))*(A i).U t=
            (A i).U (t+1)*EuclideanSplitting.rate (A i).lam 1) →
        (∀ t≤N,S^[t] (x e)∈K (cR t)) →
        (∀ i,I.IsInteriorPoint (x i)) →
        (∀ i,x i∈(chartAt H (a (cR 0))).source) →
        (∀ i,‖(extChartAt I (a (cR 0))) (x i)-(extChartAt I (a (cR 0))) (x e)‖≤h) →
        C₁^N*h≤r →
        ∃ F : J → ShortBin.Gauge d N (B+Real.log D),
          (∀ i,(F i).lam=(A i).lam) ∧
          (∀ i,∀ t<N,(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
            (coord I S (a (cR t)) (a (cR (t+1))) (S^[t] (x i)))*(F i).U t=
              (F i).U (t+1)*EuclideanSplitting.rate (F i).lam 1) ∧
          (∀ i,‖(F i).product-(F e).product‖≤N*C₁*C₁^(2*N)*h) ∧
          ∀ i t,t≤N →
            (F i).U t=(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
              (coord I (Diffeomorph.refl I M ∞) (a (c (S^[t] (x i)))) (a (cR t)) (S^[t] (x i)))*(A i).U t ∧
            (F i).V t=(A i).V t*(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
              (coord I (Diffeomorph.refl I M ∞) (a (cR t)) (a (c (S^[t] (x i)))) (S^[t] (x i))) := by
  classical
  obtain ⟨τ,D,hτ,hD,hcarry⟩ := uniform_carried_gauge_explicit I a K hK hKU
  obtain ⟨r,C₁,hr,hC,hh⟩ := actual_tube_comparison I hclosed S a K hK hKU hτ
  refine ⟨r,C₁,D,hr,hC,hD,fun c J x e cR N B h A hc hA hx hint hsource hdist hs => ?_⟩
  have ht (i : J) := hh cR (x e) (x i) N hx (hint e) (hint i) (hsource i)
    ((mul_le_mul_of_nonneg_left (hdist i) (pow_nonneg (zero_le_one.trans hC) N)).trans hs)
  have hc' (i : J) (t : ℕ) (_ht : t≤N) :
      S^[t] (x i)∈cthickening τ (K (c (S^[t] (x i)))) := self_subset_cthickening _ (hc _)
  choose PF QF hiF hbF hform hstep using fun i =>
    hcarry S (fun t => S^[t] (x i)) (fun t => c (S^[t] (x i))) cR
      (A i).U (A i).V (A i).lam N B (hc' i) (fun t ht' => ((ht i).1 t ht').2)
      (fun t _ => (Function.iterate_succ_apply' _ _ _).symm)
      (fun t => ⟨(A i).UV t,(A i).VU t⟩)
      (fun t ht' => ⟨(A i).normU t ht',(A i).normV t ht'⟩) (hA i)
  have hbound : D*Real.exp B=Real.exp (B+Real.log D) := by
    rw [Real.exp_add,Real.exp_log (lt_of_lt_of_le zero_lt_one hD),mul_comm]
  have hb (i : J) (t : ℕ) (ht : t≤N) :
      ‖PF i t‖≤Real.exp (B+Real.log D) ∧ ‖QF i t‖≤Real.exp (B+Real.log D) := by
    simpa only [hbound] using hbF i t ht
  let F (i : J) := ShortBin.Gauge.ofFinite (PF i) (QF i) (A i).lam (hiF i) (hb i)
  have hstep' (i : J) (t : ℕ) (ht : t<N) :
      (Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
        (coord I S (a (cR t)) (a (cR (t+1))) (S^[t] (x i)))*(F i).U t=
          (F i).U (t+1)*EuclideanSplitting.rate (F i).lam 1 := by
    simpa only [F,ShortBin.Gauge.ofFinite,Nat.min_eq_left ht.le,
      Nat.min_eq_left (show t+1≤N by omega)] using hstep i t ht
  refine ⟨F,fun _ => rfl,hstep',?_,?_⟩
  · intro i
    have hp (j : J) := actual_gauge_product I S (fun t => a (cR t)) (x j) (F j)
      (fun t ht' => ((ht j).1 t ht').1) (hint j) (hstep' j)
    rw [←hp i,←hp e]
    exact ((ht i).2).trans (mul_le_mul_of_nonneg_left (hdist i) (by positivity))
  · intro i t ht'
    simpa only [F,ShortBin.Gauge.ofFinite,Nat.min_eq_left ht'] using hform i t

/-- The past short segment of the true forward gauge, centered at its long
endpoint. Rates are merely negated; the original starting threshold remains
available, and no new stationary witness is chosen. -/
noncomputable def BilateralGauge.endpointBackward (S : Diffeomorph I I M M ∞)
    (a : ι → M) (c : M → ι) {n N : ℕ} {B R : ℝ} {x : M}
    (A : BilateralGauge I S a c n B R x) : ShortBin.Gauge d N B where
  U t := A.UF (n-t)
  V t := A.VF (n-t)
  lam j := -A.lam j
  UV _t := (A.invF _).1
  VU _t := (A.invF _).2
  normU _t _ := (A.normF _ (Nat.sub_le _ _)).1
  normV _t _ := (A.normF _ (Nat.sub_le _ _)).2

omit [ProperSpace M] [Fintype ι] in
lemma BilateralGauge.endpointBackward_step (S : Diffeomorph I I M M ∞)
    (a : ι → M) (c : M → ι) (hc : ∀ y,y∈(chartAt H (a (c y))).source)
    {n N : ℕ} {B R : ℝ} {x : M} (A : BilateralGauge I S a c n B R x) (hN : N≤n) :
    let F := A.endpointBackward I S a c (N:=N)
    ∀ t<N,(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
      (coord I S.symm (a (c (S.symm^[t] (S^[n] x))))
        (a (c (S.symm^[t+1] (S^[n] x)))) (S.symm^[t] (S^[n] x)))*F.U t=
      F.U (t+1)*EuclideanSplitting.rate F.lam 1 := by
  intro F t ht
  have hr (s : ℕ) (hs : s≤n) : S.symm^[s] (S^[n] x)=S^[n-s] x :=
    OrbitCocycle.backward_center S.toHomeomorph x hs
  rw [hr t (by omega),hr (t+1) (by omega)]
  have he : n-(t+1)+1=n-t := by omega
  have hh := reverse_gauge_step I S (fun j => a (c (S^[j] x)))
    (fun j => S^[j] x) A.UF A.lam (n-(t+1))
    (by simp only [Function.iterate_succ_apply']) (hc _) (hc _)
    (A.stepF _ (by omega))
  simpa only [he,F,BilateralGauge.endpointBackward] using hh
end SmoothObstruction.ManifoldCoordinates

namespace SmoothObstruction.ManifoldCoordinates
open Bundle Set Filter Topology Metric MeasureTheory
open scoped Manifold ContDiff Matrix.Norms.L2Operator
variable {d : ℕ} {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners ℝ (EuclideanSpace ℝ (Fin d)) H)
    {M : Type*} [MetricSpace M] [ProperSpace M] [ChartedSpace H M] [IsManifold I ∞ M]
    {ι : Type*} [Fintype ι]

/-- Reverse the two-sided gauge without changing any coordinate basis. -/
def BilateralGauge.symm (S : Diffeomorph I I M M ∞) (a : ι → M) (c : M → ι)
    {n : ℕ} {B R : ℝ} {x : M} (A : BilateralGauge I S a c n B R x) :
    BilateralGauge I S.symm a c n B R x where
  lam j := -A.lam j
  rate_bound j := by simpa only [abs_neg] using A.rate_bound j
  UF := A.UB
  VF := A.VB
  UB := A.UF
  VB := A.VF
  invF := A.invB
  invB := A.invF
  centerU := A.centerU.symm
  centerV := A.centerV.symm
  normF := A.normB
  normB := A.normF
  stepF := A.stepB
  stepB t ht := by
    have heS : S.symm.symm=S := by ext y; rfl
    simpa only [heS,neg_neg] using A.stepF t ht

/-- Quantitative endpoint comparison at a FIXED starting threshold, for all
actual witnesses reaching one endpoint bin. Only the past short segment is
used at the forward endpoint. The displayed basis identities attach the
comparison to the actual long-window spaces. -/
theorem uniform_endpoint_fast_comparison (hclosed : IsClosed (range I))
    (S : Diffeomorph I I M M ∞) (a : ι → M) (K : ι → Set M)
    (hK : ∀ i,IsCompact (K i)) (hKU : ∀ i,K i⊆(chartAt H (a i)).source) :
    ∃ r C₁ D : ℝ,0<r ∧ 1≤C₁ ∧ 1≤D ∧
      ∀ (c : M → ι) (J : Type*) (x : J → M) (e : J) (cR : ℕ → ι)
        (n N : ℕ) (B R h γ g : ℝ) (T : J → Finset (Fin d))
        (A : ∀ i,BilateralGauge I S a c n B R (x i)),
        (∀ y,y∈K (c y)) → N≤n →
        (∀ t≤N,S.symm^[t] (S^[n] (x e))∈K (cR t)) →
        (∀ i,I.IsInteriorPoint (S^[n] (x i))) →
        (∀ i,S^[n] (x i)∈(chartAt H (a (cR 0))).source) →
        (∀ i,‖(extChartAt I (a (cR 0))) (S^[n] (x i))-
          (extChartAt I (a (cR 0))) (S^[n] (x e))‖≤h) →
        C₁^N*h≤r → 0≤h →
        (∀ i,(T e).card=(T i).card) →
        (∀ i,∀ j∈(T i)ᶜ,(A i).lam j≤γ-g) →
        (∀ i,∀ j∈T i,γ+g≤(A i).lam j) →
        (let ε := Real.exp ((γ-g)*N+2*(B+Real.log D))*
          (Real.exp ((-γ-g)*N+2*(B+Real.log D))+N*C₁*C₁^(2*N)*h)
        ε≤1/2) →
        ∃ F : J → ShortBin.Gauge d N (B+Real.log D),
          (∀ i j,(F i).lam j= -(A i).lam j) ∧
          (∀ i,(F i).U 0=(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
            (coord I (Diffeomorph.refl I M ∞) (a (c (S^[n] (x i))))
              (a (cR 0)) (S^[n] (x i)))*(A i).UF n ∧
            (F i).V 0=(A i).VF n*(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm
              (coord I (Diffeomorph.refl I M ∞) (a (cR 0))
                (a (c (S^[n] (x i)))) (S^[n] (x i)))) ∧
          ∀ i,‖((F i).space (T i)).starProjection-((F e).space (T e)).starProjection‖≤
            3*(Real.exp ((γ-g)*N+2*(B+Real.log D))*
              (Real.exp ((-γ-g)*N+2*(B+Real.log D))+N*C₁*C₁^(2*N)*h)) := by
  obtain ⟨r,C₁,D,hr,hC,hD,hh⟩ := uniform_genuine_single_gauges I hclosed S.symm a K hK hKU
  refine ⟨r,C₁,D,hr,hC,hD,fun c J x e cR n N B R h γ g T A hc hN hx hint
    hsource hdist ht hn hdim hslow hfast hsmall => ?_⟩
  obtain ⟨F,hlam,hstep,hprod,hform⟩ := hh c J (fun i => S^[n] (x i)) e cR N B h
    (fun i => (A i).endpointBackward I S a c) hc
    (fun i => (A i).endpointBackward_step I S a c (fun y => hKU _ (hc y)) hN)
    hx hint hsource hdist ht
  have hlam' (i : J) (j : Fin d) : (F i).lam j= -(A i).lam j := congrFun (hlam i) j
  refine ⟨F,hlam',?_,?_⟩
  · intro i
    simpa only [Function.iterate_zero_apply,BilateralGauge.endpointBackward,Nat.sub_zero]
      using hform i 0 (Nat.zero_le N)
  · intro i
    have he : -(-γ+g)=γ-g := by ring
    have hs : Real.exp (-(-γ+g)*N+2*(B+Real.log D))*
        (Real.exp ((-γ-g)*N+2*(B+Real.log D))+N*C₁*C₁^(2*N)*h)≤1/2 := by
      simpa only [he] using hsmall
    have hp : ‖(F e).product-(F i).product‖≤N*C₁*C₁^(2*N)*h := by
      rw [norm_sub_rev]
      exact hprod i
    have hcl := ShortBin.slow_projector_distance (F e) (F i) (T e) (T i) (γ := -γ)
      (hdim i) hp
      (by intro j hj; rw [hlam']; linarith [hslow e j hj])
      (by intro j hj; rw [hlam']; linarith [hfast i j hj]) (by positivity) hs
    simpa only [he] using hcl
end SmoothObstruction.ManifoldCoordinates

namespace SmoothObstruction.FiniteGreen
open Finset
variable {E H G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup H] [NormedSpace ℝ H]
  [NormedAddCommGroup G] [NormedSpace ℝ G]

namespace Splitting
variable {A : Evolution E} (B : Splitting A)

noncomputable def initialSpace : Submodule ℝ E := (B.slow 0).range
lemma slow_initial (x : B.initialSpace) : B.slow 0 x=x := by
  obtain ⟨v,hv⟩ := x.property
  change B.slow 0 v=x.val at hv
  rw [←hv,B.slow_self]

namespace Terminal
variable {B} {n : ℕ} (C : B.Terminal (H:=H) n)

lemma trajectory_initial (f : ℕ → E) (a : E) (ha : B.slow 0 a=a) (h : H) :
    C.trajectory f a h 0=a+C.kernel a+C.trajectory f 0 h 0 := by
  simp only [trajectory,A.forward_zero]
  simp only [terminalValue,Evolution.forward,Evolution.backward, map_add,map_sub,map_zero,
    map_sum,kernel,_root_.neg_apply,ContinuousLinearMap.coe_comp,Function.comp_apply,ha,
    zero_add]
  abel

lemma trajectory_zero : C.trajectory (fun _ => 0) 0 0=fun _ => 0 := by
  funext t
  simp [trajectory,terminalValue,Evolution.forward,Evolution.backward]

end Terminal

end Splitting

namespace Matching
variable [FiniteDimensional ℝ E]
variable {A₁ A₂ : Evolution E} {B₁ : Splitting A₁} {B₂ : Splitting A₂}
  {n₁ n₂ : ℕ} (C₁ : B₁.Terminal (H:=H) n₁) (C₂ : B₂.Terminal (H:=G) n₂)

noncomputable def correction : (B₁.initialSpace × B₂.initialSpace) →L[ℝ] E :=
  (C₁.kernel.comp (B₁.initialSpace.subtypeL.comp (ContinuousLinearMap.fst ℝ _ _)))-
    (C₂.kernel.comp (B₂.initialSpace.subtypeL.comp (ContinuousLinearMap.snd ℝ _ _)))

omit [FiniteDimensional ℝ E] in
@[simp] lemma correction_apply (x : B₁.initialSpace × B₂.initialSpace) :
    correction C₁ C₂ x=C₁.kernel x.1-C₂.kernel x.2 := rfl

omit [FiniteDimensional ℝ E] in
lemma correction_norm {k₁ k₂ : ℝ} (hk₁ : ‖C₁.kernel‖ ≤ k₁) (hk₂ : ‖C₂.kernel‖ ≤ k₂) :
    ‖correction C₁ C₂‖ ≤ k₁+k₂ := by
  have h₁ := (norm_nonneg _).trans hk₁
  have h₂ := (norm_nonneg _).trans hk₂
  apply (correction C₁ C₂).opNorm_le_bound (by positivity)
  intro x
  calc
    _ ≤ ‖C₁.kernel x.1‖+‖C₂.kernel x.2‖ := norm_sub_le _ _
    _ ≤ k₁*‖x.1‖+k₂*‖x.2‖ := by
      gcongr
      · exact (C₁.kernel.le_opNorm _).trans (mul_le_mul_of_nonneg_right hk₁ (norm_nonneg _))
      · exact (C₂.kernel.le_opNorm _).trans (mul_le_mul_of_nonneg_right hk₂ (norm_nonneg _))
    _ ≤ k₁*‖x‖+k₂*‖x‖ := by
      gcongr
      · exact norm_fst_le x
      · exact norm_snd_le x
    _ = _ := by ring

/-- The exact two half-orbit boundary problem. The only matching input is
complementarity of the unperturbed initial spaces. The small graph terms
are inverted by a proved Neumann construction, not by assuming invertibility. -/
theorem solve (L : (B₁.initialSpace × B₂.initialSpace) ≃L[ℝ] E)
    (hL : ∀ x,L x=(x.1:E)-(x.2:E))
    (hsmall : ‖L.symm.toContinuousLinearMap.comp (correction C₁ C₂)‖ < 1)
    (f₁ f₂ : ℕ → E) (h₁ : H) (h₂ : G) (m : E) :
    ∃ v₁ v₂ : ℕ → E,
      (∀ t<n₁,v₁ (t+1)=A₁.map (t+1) t (v₁ t)+f₁ t) ∧
      (∀ t<n₂,v₂ (t+1)=A₂.map (t+1) t (v₂ t)+f₂ t) ∧
      C₁.P (v₁ n₁)=h₁ ∧ C₂.P (v₂ n₂)=h₂ ∧ v₁ 0-v₂ 0=m ∧
      ∀ w₁ w₂ : ℕ → E,
        (∀ t<n₁,w₁ (t+1)=A₁.map (t+1) t (w₁ t)+f₁ t) →
        (∀ t<n₂,w₂ (t+1)=A₂.map (t+1) t (w₂ t)+f₂ t) →
        C₁.P (w₁ n₁)=h₁ → C₂.P (w₂ n₂)=h₂ → w₁ 0-w₂ 0=m →
        (∀ t≤n₁,w₁ t=v₁ t) ∧ (∀ t≤n₂,w₂ t=v₂ t) := by
  let M := BoundaryNeumann.perturb L (correction C₁ C₂) hsmall
  let q₁ := C₁.trajectory f₁ 0 h₁ 0
  let q₂ := C₂.trajectory f₂ 0 h₂ 0
  let a := M.symm (m-q₁+q₂)
  have hM (x : B₁.initialSpace × B₂.initialSpace) :
      M x=(x.1:E)-(x.2:E)+C₁.kernel x.1-C₂.kernel x.2 := by
    rw [BoundaryNeumann.perturb_apply,hL,correction_apply]
    abel
  refine ⟨C₁.trajectory f₁ a.1 h₁,C₂.trajectory f₂ a.2 h₂,
    fun _ ht => C₁.trajectory_step _ _ _ ht,fun _ ht => C₂.trajectory_step _ _ _ ht,
    C₁.trajectory_terminal _ _ _,C₂.trajectory_terminal _ _ _,?_,?_⟩
  · rw [C₁.trajectory_initial _ _ (B₁.slow_initial _) _,
      C₂.trajectory_initial _ _ (B₂.slow_initial _) _]
    have ha : M a=m-q₁+q₂ := M.apply_symm_apply _
    rw [hM] at ha
    change (a.1:E)+C₁.kernel a.1+q₁-((a.2:E)+C₂.kernel a.2+q₂)=m
    calc
      _ = ((a.1:E)-(a.2:E)+C₁.kernel a.1-C₂.kernel a.2)+q₁-q₂ := by abel
      _ = m := by rw [ha]; abel
  · intro w₁ w₂ hw₁ hw₂ he₁ he₂ hm
    let b₁ : B₁.initialSpace := ⟨B₁.slow 0 (w₁ 0),⟨w₁ 0,rfl⟩⟩
    let b₂ : B₂.initialSpace := ⟨B₂.slow 0 (w₂ 0),⟨w₂ 0,rfl⟩⟩
    have hv₁ := C₁.trajectory_unique f₁ b₁ (B₁.slow_initial b₁) h₁ w₁ hw₁ rfl he₁
    have hv₂ := C₂.trajectory_unique f₂ b₂ (B₂.slow_initial b₂) h₂ w₂ hw₂ rfl he₂
    have hb : M (b₁,b₂)=M a := by
      rw [M.apply_symm_apply,hM]
      rw [hv₁ 0 (by omega),hv₂ 0 (by omega),
        C₁.trajectory_initial _ _ (B₁.slow_initial _) _,
        C₂.trajectory_initial _ _ (B₂.slow_initial _) _] at hm
      change (b₁:E)-(b₂:E)+C₁.kernel b₁-C₂.kernel b₂=m-q₁+q₂
      change (b₁:E)+C₁.kernel b₁+q₁-((b₂:E)+C₂.kernel b₂+q₂)=m at hm
      calc
        _ = ((b₁:E)+C₁.kernel b₁+q₁-((b₂:E)+C₂.kernel b₂+q₂))-q₁+q₂ := by abel
        _ = _ := by rw [hm]
    have hb' := M.injective hb
    have hb₁ : b₁=a.1 := congrArg Prod.fst hb'
    have hb₂ : b₂=a.2 := congrArg Prod.snd hb'
    rw [hb₁] at hv₁
    rw [hb₂] at hv₂
    exact ⟨hv₁,hv₂⟩

end Matching
end SmoothObstruction.FiniteGreen

namespace SmoothObstruction.FiniteGreen
open Finset
variable {E H : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup H] [NormedSpace ℝ H]

namespace Evolution
variable (A : Evolution E)
lemma forward_bound (P : ℕ → E →L[ℝ] E) (f : ℕ → E) (a : E) {n t : ℕ}
    {G F : ℝ} (hG : 0≤G) (hF : 0≤F) (ht : t≤n) (ha : P 0 a=a)
    (hp : ∀ s u,s≤u → u≤n → ‖(A.map u s).comp (P s)‖ ≤ G)
    (hf : ∀ j<n,‖f j‖ ≤ F) :
    ‖A.forward P f a t‖ ≤ G*‖a‖+(n:ℝ)*G*F := by
  have hterm (s u : ℕ) (hsu : s≤u) (hu : u≤n) (v : E) :
      ‖A.map u s (P s v)‖ ≤ G*‖v‖ :=
    ((A.map u s).comp (P s)).le_opNorm v |>.trans
      (mul_le_mul_of_nonneg_right (hp s u hsu hu) (norm_nonneg _))
  have hi : ‖A.map t 0 a‖ ≤ G*‖a‖ := by
    simpa only [ha] using hterm 0 t (by omega) ht a
  unfold forward
  calc
    _ ≤ ‖A.map t 0 a‖+‖∑ j∈range t,A.map t (j+1) (P (j+1) (f j))‖ := norm_add_le _ _
    _ ≤ G*‖a‖+∑ j∈range t,G*F := by
      gcongr
      apply (norm_sum_le _ _).trans
      apply sum_le_sum
      intro j hj
      have hjt := mem_range.mp hj
      exact (hterm (j+1) t (by omega) ht (f j)).trans
        (mul_le_mul_of_nonneg_left (hf j (by omega)) hG)
    _ ≤ _ := by
      simp only [sum_const,card_range,nsmul_eq_mul]
      have htt : (t:ℝ)≤n := by exact_mod_cast ht
      nlinarith [mul_nonneg hG hF,mul_le_mul_of_nonneg_right htt (mul_nonneg hG hF)]

lemma backward_bound (P : ℕ → E →L[ℝ] E) (f : ℕ → E) (c : E) {n t : ℕ}
    {G F : ℝ} (hG : 0≤G) (hF : 0≤F) (ht : t≤n) (hc : P n c=c)
    (hp : ∀ s u,s≤u → u≤n → ‖(A.map s u).comp (P u)‖ ≤ G)
    (hf : ∀ j<n,‖f j‖ ≤ F) :
    ‖A.backward P f c n t‖ ≤ G*‖c‖+(n:ℝ)*G*F := by
  have hterm (s u : ℕ) (hsu : s≤u) (hu : u≤n) (v : E) :
      ‖A.map s u (P u v)‖ ≤ G*‖v‖ :=
    ((A.map s u).comp (P u)).le_opNorm v |>.trans
      (mul_le_mul_of_nonneg_right (hp s u hsu hu) (norm_nonneg _))
  have hi : ‖A.map t n c‖ ≤ G*‖c‖ := by
    simpa only [hc] using hterm t n ht le_rfl c
  unfold backward
  calc
    _ ≤ ‖A.map t n c‖+‖∑ j∈Ico t n,A.map t (j+1) (P (j+1) (f j))‖ := norm_sub_le _ _
    _ ≤ G*‖c‖+∑ j∈Ico t n,G*F := by
      gcongr
      apply (norm_sum_le _ _).trans
      apply sum_le_sum
      intro j hj
      have hjt := mem_Ico.mp hj
      exact (hterm t (j+1) (by omega) (by omega) (f j)).trans
        (mul_le_mul_of_nonneg_left (hf j hjt.2) hG)
    _ ≤ _ := by
      simp only [sum_const,Nat.card_Ico,nsmul_eq_mul]
      have htt : ((n-t:ℕ):ℝ)≤n := by exact_mod_cast Nat.sub_le n t
      nlinarith [mul_nonneg hG hF,mul_le_mul_of_nonneg_right htt (mul_nonneg hG hF)]
end Evolution

namespace Splitting.Terminal
variable {A : Evolution E} {B : Splitting A} {n : ℕ} (C : B.Terminal (H:=H) n)

/-- A uniform half-orbit estimate. A polynomial factor in n is harmless
under the source's log(n+1)≤bn floor, but is explicitly retained here. -/
lemma trajectory_bound (f : ℕ → E) (a : E) (h : H) {G F : ℝ}
    (hG : 1≤G) (hF : 0≤F) (ha : B.slow 0 a=a)
    (hs : ∀ s u,s≤u → u≤n → ‖(A.map u s).comp (B.slow s)‖ ≤ G)
    (hb : ∀ s u,s≤u → u≤n → ‖(A.map s u).comp (B.fast u)‖ ≤ G)
    (hJ : ‖C.J‖ ≤ G) (hP : ‖C.P‖ ≤ G)
    (hf : ∀ j<n,‖f j‖ ≤ F) (hh : ‖h‖ ≤ F) {t : ℕ} (ht : t≤n) :
    ‖C.trajectory f a h t‖ ≤ (G+G^4)*‖a‖+(2*G+G^4)*(n:ℝ)*F+G^2*F := by
  have hGn : 0≤G := by linarith
  let R := G*‖a‖+(n:ℝ)*G*F
  have hfor (u : ℕ) (hu : u≤n) : ‖A.forward B.slow f a u‖ ≤ R :=
    A.forward_bound B.slow f a hGn hF hu ha hs hf
  have hc : ‖C.terminalValue f a h‖ ≤ G*(F+G*R) := by
    apply C.J.le_opNorm _ |>.trans
    apply mul_le_mul hJ _ (norm_nonneg _) hGn
    apply (norm_sub_le _ _).trans
    apply add_le_add hh
    exact (C.P.le_opNorm _).trans ((mul_le_mul_of_nonneg_right hP (norm_nonneg _)).trans
      (mul_le_mul_of_nonneg_left (hfor n le_rfl) hGn))
  have hbak := A.backward_bound B.fast f (C.terminalValue f a h) hGn hF ht (C.fast_J _) hb hf
  unfold trajectory
  calc
    _ ≤ ‖A.forward B.slow f a t‖+‖A.backward B.fast f (C.terminalValue f a h) n t‖ := norm_add_le _ _
    _ ≤ R+(G*(G*(F+G*R))+(n:ℝ)*G*F) :=
      add_le_add (hfor t ht) (hbak.trans (add_le_add (mul_le_mul_of_nonneg_left hc hGn) le_rfl))
    _ = _ := by dsimp only [R]; ring

end Splitting.Terminal
end SmoothObstruction.FiniteGreen

namespace SmoothObstruction.FiniteGreen.Matching
open Finset
variable {E H G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup H] [NormedSpace ℝ H]
  [NormedAddCommGroup G] [NormedSpace ℝ G]
variable [FiniteDimensional ℝ E]
variable {A₁ A₂ : Evolution E} {B₁ : Splitting A₁} {B₂ : Splitting A₂}
  {n₁ n₂ : ℕ} (C₁ : B₁.Terminal (H:=H) n₁) (C₂ : B₂.Terminal (H:=G) n₂)

/-- A quantitative bound for every genuine two-half boundary solution.
The explicit polynomial is retained; the source's logarithmic time floor
later absorbs it into the subexponential factor. -/
theorem solution_bound (L : (B₁.initialSpace × B₂.initialSpace) ≃L[ℝ] E)
    (hL : ∀ x,L x=(x.1:E)-(x.2:E)) {U K F : ℝ}
    (hU : 1≤U) (hK : ‖L.symm.toContinuousLinearMap‖≤K) (hF : 0≤F)
    (hsmall : ‖L.symm.toContinuousLinearMap.comp (correction C₁ C₂)‖≤1/2)
    (hs₁ : ∀ s u,s≤u → u≤n₁ → ‖(A₁.map u s).comp (B₁.slow s)‖≤U)
    (hb₁ : ∀ s u,s≤u → u≤n₁ → ‖(A₁.map s u).comp (B₁.fast u)‖≤U)
    (hs₂ : ∀ s u,s≤u → u≤n₂ → ‖(A₂.map u s).comp (B₂.slow s)‖≤U)
    (hb₂ : ∀ s u,s≤u → u≤n₂ → ‖(A₂.map s u).comp (B₂.fast u)‖≤U)
    (hJ₁ : ‖C₁.J‖≤U) (hP₁ : ‖C₁.P‖≤U)
    (hJ₂ : ‖C₂.J‖≤U) (hP₂ : ‖C₂.P‖≤U)
    (f₁ f₂ w₁ w₂ : ℕ → E) (h₁ : H) (h₂ : G) (m : E)
    (hf₁ : ∀ j<n₁,‖f₁ j‖≤F) (hf₂ : ∀ j<n₂,‖f₂ j‖≤F)
    (hh₁ : ‖h₁‖≤F) (hh₂ : ‖h₂‖≤F) (hm : ‖m‖≤F)
    (hw₁ : ∀ t<n₁,w₁ (t+1)=A₁.map (t+1) t (w₁ t)+f₁ t)
    (hw₂ : ∀ t<n₂,w₂ (t+1)=A₂.map (t+1) t (w₂ t)+f₂ t)
    (he₁ : C₁.P (w₁ n₁)=h₁) (he₂ : C₂.P (w₂ n₂)=h₂)
    (hmatch : w₁ 0-w₂ 0=m) :
    let D := (2*U+U^4)*(n₁+n₂ : ℕ)+U^2
    let Q := (U+U^4)*(2*K)*(1+2*D)+D
    (∀ t≤n₁,‖w₁ t‖≤Q*F) ∧ (∀ t≤n₂,‖w₂ t‖≤Q*F) := by
  have hUn : 0≤U := by linarith
  have hKn : 0≤K := (norm_nonneg L.symm.toContinuousLinearMap).trans hK
  let D := (2*U+U^4)*(n₁+n₂ : ℕ)+U^2
  have hD : 0≤D := by dsimp [D]; positivity
  let M := BoundaryNeumann.perturb L (correction C₁ C₂) (hsmall.trans_lt (by norm_num))
  have hMi : ‖M.symm.toContinuousLinearMap‖≤2*K :=
    BoundaryNeumann.inverse_norm L (correction C₁ C₂) hK hsmall
  let b₁ : B₁.initialSpace := ⟨B₁.slow 0 (w₁ 0),⟨w₁ 0,rfl⟩⟩
  let b₂ : B₂.initialSpace := ⟨B₂.slow 0 (w₂ 0),⟨w₂ 0,rfl⟩⟩
  have hv₁ := C₁.trajectory_unique f₁ b₁ (B₁.slow_initial b₁) h₁ w₁ hw₁ rfl he₁
  have hv₂ := C₂.trajectory_unique f₂ b₂ (B₂.slow_initial b₂) h₂ w₂ hw₂ rfl he₂
  let q₁ := C₁.trajectory f₁ 0 h₁ 0
  let q₂ := C₂.trajectory f₂ 0 h₂ 0
  have hn₁ : (n₁:ℝ)≤(n₁+n₂:ℕ) := by exact_mod_cast Nat.le_add_right n₁ n₂
  have hn₂ : (n₂:ℝ)≤(n₁+n₂:ℕ) := by exact_mod_cast Nat.le_add_left n₂ n₁
  have hq₁ : ‖q₁‖≤D*F := by
    have h := C₁.trajectory_bound f₁ 0 h₁ hU hF (by simp) hs₁ hb₁ hJ₁ hP₁ hf₁ hh₁ (Nat.zero_le n₁)
    simp only [norm_zero,mul_zero,zero_add] at h
    apply h.trans
    dsimp only [D]
    calc
      _ ≤ (2*U+U^4)*((n₁+n₂:ℕ):ℝ)*F+U^2*F := by gcongr
      _ = _ := by ring
  have hq₂ : ‖q₂‖≤D*F := by
    have h := C₂.trajectory_bound f₂ 0 h₂ hU hF (by simp) hs₂ hb₂ hJ₂ hP₂ hf₂ hh₂ (Nat.zero_le n₂)
    simp only [norm_zero,mul_zero,zero_add] at h
    apply h.trans
    dsimp only [D]
    calc
      _ ≤ (2*U+U^4)*((n₁+n₂:ℕ):ℝ)*F+U^2*F := by gcongr
      _ = _ := by ring
  have hMb : M (b₁,b₂)=m-q₁+q₂ := by
    rw [BoundaryNeumann.perturb_apply,hL,correction_apply]
    rw [hv₁ 0 (by omega),hv₂ 0 (by omega),
      C₁.trajectory_initial _ _ (B₁.slow_initial _) _,
      C₂.trajectory_initial _ _ (B₂.slow_initial _) _] at hmatch
    change (b₁:E)-(b₂:E)+(C₁.kernel b₁-C₂.kernel b₂)=m-q₁+q₂
    change (b₁:E)+C₁.kernel b₁+q₁-((b₂:E)+C₂.kernel b₂+q₂)=m at hmatch
    calc
      _ = ((b₁:E)+C₁.kernel b₁+q₁-((b₂:E)+C₂.kernel b₂+q₂))-q₁+q₂ := by abel
      _ = _ := by rw [hmatch]
  have hbn : ‖(b₁,b₂)‖≤(2*K)*(1+2*D)*F := by
    have hb : (b₁,b₂)=M.symm (m-q₁+q₂) := ((M.symm_apply_eq).mpr hMb.symm).symm
    rw [hb]
    calc
      _ ≤ (2*K)*‖m-q₁+q₂‖ := (M.symm.toContinuousLinearMap.le_opNorm _).trans
        (mul_le_mul_of_nonneg_right hMi (norm_nonneg _))
      _ ≤ (2*K)*(F+D*F+D*F) := mul_le_mul_of_nonneg_left
        ((norm_add_le _ _).trans (add_le_add ((norm_sub_le _ _).trans (add_le_add hm hq₁)) hq₂))
        (by positivity)
      _ = _ := by ring
  have hbn₁ : ‖(b₁:E)‖≤(2*K)*(1+2*D)*F := (norm_fst_le (b₁,b₂)).trans hbn
  have hbn₂ : ‖(b₂:E)‖≤(2*K)*(1+2*D)*F := (norm_snd_le (b₁,b₂)).trans hbn
  constructor
  · intro t ht
    rw [hv₁ t ht]
    apply (C₁.trajectory_bound f₁ b₁ h₁ hU hF (B₁.slow_initial _) hs₁ hb₁ hJ₁ hP₁ hf₁ hh₁ ht).trans
    change _≤((U+U^4)*(2*K)*(1+2*D)+D)*F
    calc
      _ ≤ (U+U^4)*((2*K)*(1+2*D)*F)+(2*U+U^4)*((n₁+n₂:ℕ):ℝ)*F+U^2*F := by gcongr
      _ = _ := by dsimp only [D]; ring
  · intro t ht
    rw [hv₂ t ht]
    apply (C₂.trajectory_bound f₂ b₂ h₂ hU hF (B₂.slow_initial _) hs₂ hb₂ hJ₂ hP₂ hf₂ hh₂ ht).trans
    change _≤((U+U^4)*(2*K)*(1+2*D)+D)*F
    calc
      _ ≤ (U+U^4)*((2*K)*(1+2*D)*F)+(2*U+U^4)*((n₁+n₂:ℕ):ℝ)*F+U^2*F := by gcongr
      _ = _ := by dsimp only [D]; ring

end SmoothObstruction.FiniteGreen.Matching

namespace SmoothObstruction.FiniteGreen.Matching
open Finset
variable {E H G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup H] [NormedSpace ℝ H]
  [NormedAddCommGroup G] [NormedSpace ℝ G]
  [FiniteDimensional ℝ E]
variable {A₁ A₂ : Evolution E} {B₁ : Splitting A₁} {B₂ : Splitting A₂}
  {n₁ n₂ : ℕ} (C₁ : B₁.Terminal (H:=H) n₁) (C₂ : B₂.Terminal (H:=G) n₂)

abbrev Paths (E : Type*) (n₁ n₂ : ℕ) := (Fin (n₁+1) → E) × (Fin (n₂+1) → E)
abbrev Data (E H G : Type*) (n₁ n₂ : ℕ) :=
  (Fin n₁ → E) × (Fin n₂ → E) × E × H × G

/-- The actual finite-array boundary operator consists of both recurrence
residuals, the middle matching equation, and the two terminal projections. -/
noncomputable def boundaryLinear : Paths E n₁ n₂ →ₗ[ℝ] Data E H G n₁ n₂ where
  toFun v := (fun t => v.1 t.succ-A₁.map (t+1) t (v.1 t.castSucc),
    fun t => v.2 t.succ-A₂.map (t+1) t (v.2 t.castSucc),
    v.1 0-v.2 0,C₁.P (v.1 (Fin.last n₁)),C₂.P (v.2 (Fin.last n₂)))
  map_add' v w := by
    apply Prod.ext
    · funext t; simp only [Prod.fst_add,Pi.add_apply,map_add]; abel
    · apply Prod.ext
      · funext t; simp only [Prod.snd_add,Prod.fst_add,Pi.add_apply,map_add]; abel
      · apply Prod.ext
        · simp only [Prod.snd_add,Prod.fst_add,Pi.add_apply]; abel
        · apply Prod.ext <;> simp only [Prod.snd_add,Prod.fst_add,Pi.add_apply,map_add]
  map_smul' c v := by
    apply Prod.ext
    · funext t; simp [smul_sub]
    · apply Prod.ext
      · funext t; simp [smul_sub]
      · apply Prod.ext
        · simp [smul_sub]
        · apply Prod.ext <;> simp

noncomputable def boundary : Paths E n₁ n₂ →L[ℝ] Data E H G n₁ n₂ :=
  (boundaryLinear C₁ C₂).toContinuousLinearMap

noncomputable def extend {n : ℕ} (v : Fin n → E) (t : ℕ) : E :=
  if h : t<n then v ⟨t,h⟩ else 0

omit [NormedSpace ℝ E] [FiniteDimensional ℝ E] in
lemma extend_apply {n : ℕ} (v : Fin n → E) (t : Fin n) : extend v t=v t := by
  simp [extend,t.isLt]

/-- Finite-dimensional invertibility is a consequence of the Green formulas
and the genuinely small terminal graph correction. No linear inverse is
postulated. -/
theorem boundary_bijective (L : (B₁.initialSpace × B₂.initialSpace) ≃L[ℝ] E)
    (hL : ∀ x,L x=(x.1:E)-(x.2:E))
    (hsmall : ‖L.symm.toContinuousLinearMap.comp (correction C₁ C₂)‖ < 1) :
    Function.Bijective (boundary C₁ C₂) := by
  classical
  have huniq (d : Data E H G n₁ n₂) : ∃! v : Paths E n₁ n₂,boundary C₁ C₂ v=d := by
    obtain ⟨v₁,v₂,hv₁,hv₂,he₁,he₂,hm,hu⟩ := solve C₁ C₂ L hL hsmall
      (extend d.1) (extend d.2.1) d.2.2.2.1 d.2.2.2.2 d.2.2.1
    let v : Paths E n₁ n₂ := (fun t => v₁ t,fun t => v₂ t)
    have hv : boundary C₁ C₂ v=d := by
      apply Prod.ext
      · funext t
        change v₁ (t+1)-A₁.map (t+1) t (v₁ t)=d.1 t
        rw [hv₁ t t.isLt,extend_apply]; abel
      · apply Prod.ext
        · funext t
          change v₂ (t+1)-A₂.map (t+1) t (v₂ t)=d.2.1 t
          rw [hv₂ t t.isLt,extend_apply]; abel
        · exact Prod.ext hm (Prod.ext he₁ he₂)
    refine ⟨v,hv,?_⟩
    intro w hw
    have h₁ : ∀ t<n₁,extend w.1 (t+1)=A₁.map (t+1) t (extend w.1 t)+extend d.1 t := by
      intro t ht
      have h := congrArg (fun z : Data E H G n₁ n₂ => z.1 ⟨t,ht⟩) hw
      change w.1 ⟨t+1,by omega⟩-A₁.map (t+1) t (w.1 ⟨t,by omega⟩)=d.1 ⟨t,ht⟩ at h
      simp only [extend,dite_eq_left (show t+1<n₁+1 by omega),dite_eq_left (show t<n₁+1 by omega),dite_eq_left ht]
      rw [←h]; abel
    have h₂ : ∀ t<n₂,extend w.2 (t+1)=A₂.map (t+1) t (extend w.2 t)+extend d.2.1 t := by
      intro t ht
      have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.1 ⟨t,ht⟩) hw
      change w.2 ⟨t+1,by omega⟩-A₂.map (t+1) t (w.2 ⟨t,by omega⟩)=d.2.1 ⟨t,ht⟩ at h
      simp only [extend,dite_eq_left (show t+1<n₂+1 by omega),dite_eq_left (show t<n₂+1 by omega),dite_eq_left ht]
      rw [←h]; abel
    have he₁' : C₁.P (extend w.1 n₁)=d.2.2.2.1 := by
      have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.2.1) hw
      change C₁.P (w.1 (Fin.last n₁))=d.2.2.2.1 at h
      change C₁.P (extend w.1 (Fin.last n₁))=d.2.2.2.1
      rw [extend_apply]
      exact h
    have he₂' : C₂.P (extend w.2 n₂)=d.2.2.2.2 := by
      have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.2.2) hw
      change C₂.P (w.2 (Fin.last n₂))=d.2.2.2.2 at h
      change C₂.P (extend w.2 (Fin.last n₂))=d.2.2.2.2
      rw [extend_apply]
      exact h
    have hm' : extend w.1 0-extend w.2 0=d.2.2.1 := by
      have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.1) hw
      change w.1 0-w.2 0=d.2.2.1 at h
      change extend w.1 (0 : Fin (n₁+1))-extend w.2 (0 : Fin (n₂+1))=d.2.2.1
      rw [extend_apply,extend_apply]
      exact h
    obtain ⟨hu₁,hu₂⟩ := hu (extend w.1) (extend w.2) h₁ h₂ he₁' he₂' hm'
    apply Prod.ext
    · funext t
      simpa only [extend_apply] using hu₁ t (by omega)
    · funext t
      simpa only [extend_apply] using hu₂ t (by omega)
  constructor
  · intro v w h
    obtain ⟨z,hz,hzu⟩ := huniq (boundary C₁ C₂ v)
    exact (hzu v rfl).trans (hzu w h.symm).symm
  · intro d
    obtain ⟨v,hv,_⟩ := huniq d
    exact ⟨v,hv⟩

noncomputable def boundaryEquiv (L : (B₁.initialSpace × B₂.initialSpace) ≃L[ℝ] E)
    (hL : ∀ x,L x=(x.1:E)-(x.2:E))
    (hsmall : ‖L.symm.toContinuousLinearMap.comp (correction C₁ C₂)‖ < 1) :
    Paths E n₁ n₂ ≃L[ℝ] Data E H G n₁ n₂ :=
  (LinearEquiv.ofBijective (boundaryLinear C₁ C₂)
    (boundary_bijective C₁ C₂ L hL hsmall)).toContinuousLinearEquiv

end SmoothObstruction.FiniteGreen.Matching

namespace SmoothObstruction.FiniteGreen.Matching
open Finset
variable {E H G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup H] [NormedSpace ℝ H]
  [NormedAddCommGroup G] [NormedSpace ℝ G]
variable [FiniteDimensional ℝ E]
variable {A₁ A₂ : Evolution E} {B₁ : Splitting A₁} {B₂ : Splitting A₂}
  {n₁ n₂ : ℕ} (C₁ : B₁.Terminal (H:=H) n₁) (C₂ : B₂.Terminal (H:=G) n₂)

theorem boundary_inverse_norm (L : (B₁.initialSpace × B₂.initialSpace) ≃L[ℝ] E)
    (hL : ∀ x,L x=(x.1:E)-(x.2:E)) {U K : ℝ}
    (hU : 1≤U) (hK : ‖L.symm.toContinuousLinearMap‖≤K)
    (hsmall : ‖L.symm.toContinuousLinearMap.comp (correction C₁ C₂)‖≤1/2)
    (hs₁ : ∀ s u,s≤u → u≤n₁ → ‖(A₁.map u s).comp (B₁.slow s)‖≤U)
    (hb₁ : ∀ s u,s≤u → u≤n₁ → ‖(A₁.map s u).comp (B₁.fast u)‖≤U)
    (hs₂ : ∀ s u,s≤u → u≤n₂ → ‖(A₂.map u s).comp (B₂.slow s)‖≤U)
    (hb₂ : ∀ s u,s≤u → u≤n₂ → ‖(A₂.map s u).comp (B₂.fast u)‖≤U)
    (hJ₁ : ‖C₁.J‖≤U) (hP₁ : ‖C₁.P‖≤U)
    (hJ₂ : ‖C₂.J‖≤U) (hP₂ : ‖C₂.P‖≤U) :
    let D := (2*U+U^4)*(n₁+n₂ : ℕ)+U^2
    ‖(boundaryEquiv C₁ C₂ L hL (hsmall.trans_lt (by norm_num))).symm.toContinuousLinearMap‖≤
      (U+U^4)*(2*K)*(1+2*D)+D := by
  let V := boundaryEquiv C₁ C₂ L hL (hsmall.trans_lt (by norm_num))
  let D := (2*U+U^4)*(n₁+n₂ : ℕ)+U^2
  let Q := (U+U^4)*(2*K)*(1+2*D)+D
  have hUn : 0≤U := by linarith
  have hKn : 0≤K := (norm_nonneg L.symm.toContinuousLinearMap).trans hK
  have hQ : 0≤Q := by dsimp [Q,D]; positivity
  change ‖V.symm.toContinuousLinearMap‖≤Q
  apply V.symm.toContinuousLinearMap.opNorm_le_bound hQ
  intro d
  let w := V.symm d
  have hw : boundary C₁ C₂ w=d := V.apply_symm_apply d
  have hw₁ : ∀ t<n₁,extend w.1 (t+1)=A₁.map (t+1) t (extend w.1 t)+extend d.1 t := by
    intro t ht
    have h := congrArg (fun z : Data E H G n₁ n₂ => z.1 ⟨t,ht⟩) hw
    change w.1 ⟨t+1,by omega⟩-A₁.map (t+1) t (w.1 ⟨t,by omega⟩)=d.1 ⟨t,ht⟩ at h
    simp only [extend,dite_eq_left (show t+1<n₁+1 by omega),dite_eq_left (show t<n₁+1 by omega),dite_eq_left ht]
    rw [←h]; abel
  have hw₂ : ∀ t<n₂,extend w.2 (t+1)=A₂.map (t+1) t (extend w.2 t)+extend d.2.1 t := by
    intro t ht
    have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.1 ⟨t,ht⟩) hw
    change w.2 ⟨t+1,by omega⟩-A₂.map (t+1) t (w.2 ⟨t,by omega⟩)=d.2.1 ⟨t,ht⟩ at h
    simp only [extend,dite_eq_left (show t+1<n₂+1 by omega),dite_eq_left (show t<n₂+1 by omega),dite_eq_left ht]
    rw [←h]; abel
  have he₁ : C₁.P (extend w.1 n₁)=d.2.2.2.1 := by
    have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.2.1) hw
    change C₁.P (w.1 (Fin.last n₁))=d.2.2.2.1 at h
    change C₁.P (extend w.1 (Fin.last n₁))=d.2.2.2.1
    rw [extend_apply]; exact h
  have he₂ : C₂.P (extend w.2 n₂)=d.2.2.2.2 := by
    have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.2.2) hw
    change C₂.P (w.2 (Fin.last n₂))=d.2.2.2.2 at h
    change C₂.P (extend w.2 (Fin.last n₂))=d.2.2.2.2
    rw [extend_apply]; exact h
  have hm : extend w.1 0-extend w.2 0=d.2.2.1 := by
    have h := congrArg (fun z : Data E H G n₁ n₂ => z.2.2.1) hw
    change w.1 0-w.2 0=d.2.2.1 at h
    change extend w.1 (0 : Fin (n₁+1))-extend w.2 (0 : Fin (n₂+1))=d.2.2.1
    rw [extend_apply,extend_apply]; exact h
  have hf₁ : ∀ j<n₁,‖extend d.1 j‖≤‖d‖ := by
    intro j hj
    rw [extend,dite_eq_left hj]
    exact (norm_le_pi_norm d.1 ⟨j,hj⟩).trans (norm_fst_le d)
  have hf₂ : ∀ j<n₂,‖extend d.2.1 j‖≤‖d‖ := by
    intro j hj
    rw [extend,dite_eq_left hj]
    exact (norm_le_pi_norm d.2.1 ⟨j,hj⟩).trans ((norm_fst_le d.2).trans (norm_snd_le d))
  have hh₁ : ‖d.2.2.2.1‖≤‖d‖ := (norm_fst_le _).trans ((norm_snd_le _).trans ((norm_snd_le _).trans (norm_snd_le d)))
  have hh₂ : ‖d.2.2.2.2‖≤‖d‖ := (norm_snd_le _).trans ((norm_snd_le _).trans ((norm_snd_le _).trans (norm_snd_le d)))
  have hmid : ‖d.2.2.1‖≤‖d‖ := (norm_fst_le _).trans ((norm_snd_le _).trans (norm_snd_le d))
  obtain ⟨h₁,h₂⟩ := solution_bound C₁ C₂ L hL hU hK (norm_nonneg d) hsmall
    hs₁ hb₁ hs₂ hb₂ hJ₁ hP₁ hJ₂ hP₂
    (extend d.1) (extend d.2.1) (extend w.1) (extend w.2)
    d.2.2.2.1 d.2.2.2.2 d.2.2.1 hf₁ hf₂ hh₁ hh₂ hmid hw₁ hw₂ he₁ he₂ hm
  change ‖w‖≤Q*‖d‖
  rw [Prod.norm_def,max_le_iff]
  constructor
  · apply (pi_norm_le_iff_of_nonneg (mul_nonneg hQ (norm_nonneg d))).mpr
    intro t
    simpa only [extend_apply] using h₁ t (by omega)
  · apply (pi_norm_le_iff_of_nonneg (mul_nonneg hQ (norm_nonneg d))).mpr
    intro t
    simpa only [extend_apply] using h₂ t (by omega)

end SmoothObstruction.FiniteGreen.Matching

end

end OAI