import Mathlib
import OAI.MathematicalPhysics.SheetFlows.FormulaProfiles
import OAI.MathematicalPhysics.SheetFlows.CircuitPrograms

namespace OAI

/-! SheetFlows effective forcing. -/

section
open Set Filter Encodable
open scoped BigOperators Topology
namespace Solenoidal
namespace Computing

def readCode {α : Type*} [Primcodable α] [Inhabited α] (c : Nat.Partrec.Code) (n : ℕ) : Part α :=
  (c.eval n).map (fun k => (decode k).getD default)

theorem readCode_pr {α : Type*} [Primcodable α] [Inhabited α] :
    Partrec₂ (@readCode α _ _) := by
  exact Nat.Partrec.Code.eval_part.map
    ((Primrec.option_getD_default.comp (Primrec.decode.comp .snd)).to_comp.to₂)

theorem readCode_mem {α : Type*} [Primcodable α] [Inhabited α]
    {c : Nat.Partrec.Code} {n : ℕ} {a : α} (h : encode a ∈ c.eval n) : a ∈ readCode c n := by
  unfold readCode
  have hh := Part.mem_map (fun k => (decode k).getD (default:α)) h
  simpa only [encodek,Option.getD_some] using hh

def precision (L ε : ℚ) : Part ℕ :=
  Nat.rfind (fun n => Part.some (decide (L*(1/2:ℚ)^n < ε/2)))

theorem precision_pr : Partrec₂ precision := by
  exact Partrec.rfind
    ((rat_lt.comp (rat_mul.comp (Primrec.fst.comp .fst)
      (rat_pow.comp (.const (1/2)) .snd))
      (rat_div.comp (Primrec.snd.comp .fst) (.const 2))).decide.to_comp.partrec.to₂)

abbrev BallVector := Fin 3 → QBall
abbrev RationalPoint := Fin 4 → ℚ
abbrev JetRequest := List (Fin 4) × RationalPoint × ℕ
abbrev BallOracle := JetRequest →. BallVector

def radiusSum (b : BallVector) : ℚ := ∑ j, (b j).2

def centers (b : BallVector) : Fin 3 → ℚ := fun j => (b j).1

theorem radiusSum_pr : Primrec radiusSum :=
  fin_sum_rat (fun j => Primrec.snd.comp (Primrec.fin_app.comp .id (.const j)))

theorem centers_pr : Primrec centers := by
  apply Primrec.fin_curry.mpr
  exact (Primrec.fst.comp Primrec.fin_app).to₂

def ballTest (ε : ℚ) (b : BallVector) : Bool := decide (radiusSum b < ε/2)

theorem ballTest_pr : Primrec₂ ballTest :=
  (rat_lt.comp (radiusSum_pr.comp .snd) (rat_div.comp .fst (.const 2))).decide.to₂

def improve (A : BallOracle) (p : List (Fin 4) × RationalPoint × ℚ) : Part (Fin 3 → ℚ) :=
  (Nat.rfind (fun n => (A (p.1,p.2.1,n)).map (ballTest p.2.2))).bind fun n =>
    (A (p.1,p.2.1,n)).map centers

theorem improve_pr {A : BallOracle} (hA : Partrec A) : Partrec (improve A) := by
  have ha : Partrec (fun p : (List (Fin 4) × RationalPoint × ℚ) × ℕ =>
      A (p.1.1,p.1.2.1,p.2)) :=
    hA.comp ((Primrec.fst.comp .fst).pair
      ((Primrec.fst.comp (Primrec.snd.comp .fst)).pair .snd)).to_comp
  have hp : Partrec₂ (fun p : List (Fin 4) × RationalPoint × ℚ => fun n =>
      (A (p.1,p.2.1,n)).map (ballTest p.2.2)) :=
    (ha.map (ballTest_pr.comp (Primrec.snd.comp (Primrec.snd.comp (Primrec.fst.comp .fst)))
      .snd).to_comp.to₂).to₂
  exact (Partrec.rfind hp).bind
    (ha.map (centers_pr.comp .snd).to_comp.to₂).to₂

def evalJets (B : List (Fin 4) → ℚ) (A : BallOracle)
    (p : List (Fin 4) × Nat.Partrec.Code × ℚ) : Part (Fin 3 → ℚ) :=
  (precision (jetLipschitz B p.1) p.2.2).bind fun n =>
    (readCode p.2.1 n).bind fun q => improve A (p.1,q,p.2.2)

theorem evalJets_pr {B : List (Fin 4) → ℚ} (hB : Primrec B)
    {A : BallOracle} (hA : Partrec A) : Partrec (evalJets B A) := by
  have hn : Partrec (fun p : List (Fin 4) × Nat.Partrec.Code × ℚ =>
      precision (jetLipschitz B p.1) p.2.2) :=
    precision_pr.comp ((jetLipschitz_pr hB).comp .fst).to_comp (Primrec.snd.comp .snd).to_comp
  have hq : Partrec (fun p : (List (Fin 4) × Nat.Partrec.Code × ℚ) × ℕ =>
      @readCode RationalPoint _ _ p.1.2.1 p.2) :=
    readCode_pr.comp (Primrec.fst.comp (Primrec.snd.comp .fst)).to_comp Primrec.snd.to_comp
  exact hn.bind (hq.bind
    ((improve_pr hA).comp ((Primrec.fst.comp (Primrec.fst.comp .fst)).pair
      (Primrec.snd.pair (Primrec.snd.comp (Primrec.snd.comp (Primrec.fst.comp .fst))))).to_comp).to₂).to₂

end Computing
end Solenoidal
end

section
open Set Filter Encodable
open scoped BigOperators Topology
namespace Solenoidal
namespace Computing

theorem precision_correct (L ε : ℚ) (hε : 0 < ε) :
    ∃ n, n ∈ precision L ε ∧ L*(1/2:ℚ)^n < ε/2 := by
  have hlim : Tendsto (fun n : ℕ => (L:ℝ)*(1/2:ℝ)^n) atTop (𝓝 0) := by
    simpa using (tendsto_pow_atTop_nhds_zero_of_lt_one
      (by norm_num : (0:ℝ)≤1/2) (by norm_num : (1/2:ℝ)<1)).const_mul (L:ℝ)
  have heps : (0:ℝ) < (ε:ℝ)/2 := by exact_mod_cast (div_pos hε (by norm_num : (0:ℚ)<2))
  obtain ⟨n,hn⟩ := (hlim.eventually (gt_mem_nhds heps)).exists
  have hnq : L*(1/2:ℚ)^n < ε/2 := by
    apply (Rat.cast_lt (K := ℝ)).mp
    simpa only [Rat.cast_mul, Rat.cast_pow, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hn
  have hd : (precision L ε).Dom := Nat.rfind_dom.mpr
    ⟨n,by simpa only [Part.mem_some_iff,true_eq_decide_iff] using hnq,
      fun {_} _ => trivial⟩
  obtain ⟨k,hk⟩ := Part.dom_iff_mem.mp hd
  refine ⟨k,hk,?_⟩
  have hh := Nat.rfind_spec hk
  simpa only [Part.mem_some_iff,true_eq_decide_iff] using hh

def OracleCorrect (A : BallOracle) (u : Field) : Prop := ∀ a q,
  ∃ b : ℕ → BallVector, (∀ n, b n ∈ A (a,q,n)) ∧
    ∀ j, QBall.Approximates (fun n => b n j) (mixedDerivative u a (Circuit.ofRational q) j)

theorem radiusSum_nonneg {b : BallVector} {v : Space} (h : ∀ j, (b j).Contains (v j)) :
    0 ≤ radiusSum b := Finset.sum_nonneg (fun j _ => QBall.radius_nonneg (h j))

theorem centers_error {b : BallVector} {v : Space} (h : ∀ j, (b j).Contains (v j)) :
    ‖(fun j => (centers b j:ℝ)) - v‖ ≤ (radiusSum b:ℝ) := by
  apply (pi_norm_le_iff_of_nonneg (by exact_mod_cast radiusSum_nonneg h)).mpr
  intro j
  exact (h j).trans (by exact_mod_cast
    Finset.single_le_sum (fun k _ => QBall.radius_nonneg (h k)) (Finset.mem_univ j))

theorem improve_correct {A : BallOracle} {u : Field} (hA : OracleCorrect A u)
    (a : List (Fin 4)) (q : RationalPoint) (ε : ℚ) (hε : 0 < ε) :
    ∃ r : Fin 3 → ℚ, r ∈ improve A (a,q,ε) ∧
      ‖(fun j => (r j:ℝ)) - mixedDerivative u a (Circuit.ofRational q)‖ < (ε:ℝ)/2 := by
  obtain ⟨b,hb,happrox⟩ := hA a q
  have hlim : Tendsto (fun n => (radiusSum (b n):ℝ)) atTop (𝓝 0) := by
    simpa [radiusSum] using tendsto_finsetSum Finset.univ (fun j _ => (happrox j).radius)
  have heps : (0:ℝ) < (ε:ℝ)/2 := by exact_mod_cast (div_pos hε (by norm_num : (0:ℚ)<2))
  obtain ⟨n,hn⟩ := (hlim.eventually (gt_mem_nhds heps)).exists
  have hnq : radiusSum (b n) < ε/2 := by exact_mod_cast hn
  have htest (m : ℕ) : ballTest ε (b m) ∈ (A (a,q,m)).map (ballTest ε) :=
    Part.mem_map _ (hb m)
  have hd : (Nat.rfind (fun m => (A (a,q,m)).map (ballTest ε))).Dom := by
    apply Nat.rfind_dom.mpr
    refine ⟨n,?_,fun {m} _ => (htest m).1⟩
    simpa only [ballTest,decide_eq_true hnq] using htest n
  obtain ⟨k,hk⟩ := Part.dom_iff_mem.mp hd
  have heq : ballTest ε (b k) = true := Part.mem_unique (htest k) (Nat.rfind_spec hk)
  have he : radiusSum (b k) < ε/2 := of_decide_eq_true heq
  refine ⟨centers (b k),Part.mem_bind hk (Part.mem_map centers (hb k)),?_⟩
  exact (centers_error (fun j => (happrox j).contains k)).trans_lt (by exact_mod_cast he)

theorem ofRational_distance (q : RationalPoint) (z : SpaceTime) :
    ‖Circuit.ofRational q - z‖ = ‖(fun j => (q j:ℝ)) - flatten z‖ := by
  rw [← norm_flatten]
  congr 1
  ext j
  fin_cases j <;> rfl

theorem evalJets_correct {u : Field} (hu : Smooth u) {B : List (Fin 4) → ℚ}
    (hB : ∀ a, 0 ≤ B a) (hb : ∀ a z, ‖mixedDerivative u a z‖ ≤ (B a:ℝ))
    {A : BallOracle} (hA : OracleCorrect A u)
    (a : List (Fin 4)) (c : Nat.Partrec.Code) (z : SpaceTime) (hc : NamesPoint c z)
    (ε : ℚ) (hε : 0 < ε) : ∃ r : Fin 3 → ℚ, r ∈ evalJets B A (a,c,ε) ∧
      ‖(fun j => (r j:ℝ)) - mixedDerivative u a z‖ < (ε:ℝ) := by
  obtain ⟨n,hn,hnlt⟩ := precision_correct (jetLipschitz B a) ε hε
  obtain ⟨q,hq,hqerr⟩ := hc n
  obtain ⟨r,hr,hrerr⟩ := improve_correct hA a q ε hε
  refine ⟨r,Part.mem_bind hn (Part.mem_bind (readCode_mem hq) hr),?_⟩
  have hdist : ‖Circuit.ofRational q-z‖ ≤ (1/2:ℝ)^n := by
    rwa [ofRational_distance]
  have hlip := mixed_lipschitz hu hB hb a (Circuit.ofRational q) z
  have herr : ‖mixedDerivative u a (Circuit.ofRational q) - mixedDerivative u a z‖ < (ε:ℝ)/2 := by
    apply hlip.trans_lt
    apply (mul_le_mul_of_nonneg_left hdist (by exact_mod_cast jetLipschitz_nonneg hB a)).trans_lt
    have hh : ((jetLipschitz B a * (1/2:ℚ)^n : ℚ):ℝ) < ((ε/2:ℚ):ℝ) :=
      Rat.cast_lt.mpr hnlt
    simpa only [Rat.cast_mul, Rat.cast_pow, Rat.cast_div, Rat.cast_one, Rat.cast_ofNat] using hh
  calc
    ‖(fun j => (r j:ℝ)) - mixedDerivative u a z‖ ≤
        ‖(fun j => (r j:ℝ)) - mixedDerivative u a (Circuit.ofRational q)‖ +
        ‖mixedDerivative u a (Circuit.ofRational q) - mixedDerivative u a z‖ := by
          simpa only [dist_eq_norm] using dist_triangle
            (fun j => (r j:ℝ)) (mixedDerivative u a (Circuit.ofRational q))
            (mixedDerivative u a z)
    _ < (ε:ℝ)/2+(ε:ℝ)/2 := add_lt_add hrerr herr
    _ = _ := by ring

end Computing

theorem effective_of_oracle {u : Field} (hu : Smooth u) {B : List (Fin 4) → ℚ}
    (hBpr : Primrec B) (hB : ∀ a, 0 ≤ B a)
    (hb : ∀ a z, ‖mixedDerivative u a z‖ ≤ (B a:ℝ))
    {A : Computing.BallOracle} (hApr : Partrec A) (hA : Computing.OracleCorrect A u) : Effective u := by
  obtain ⟨e,he⟩ := Computing.partrec_code (Computing.evalJets_pr hBpr hApr)
  refine ⟨e,fun a c z hc ε hε => ?_⟩
  obtain ⟨r,hr,herr⟩ := Computing.evalJets_correct hu hB hb hA a c z hc ε hε
  have hh := he (a,c,ε) r hr
  exact ⟨r,hh,herr⟩

theorem HasCircuit.effective {u : Field} (h : HasCircuit u) (hu : Smooth u)
    (hx : SpatiallyPeriodic u) (ht : OnePeriodic u) : Effective u := by
  obtain ⟨e,he⟩ := h
  apply effective_of_oracle hu (Computing.circuit_jetBound e) (Circuit.jetBound_nonneg e)
    (circuit_periodic_bound hu hx ht he) (Computing.circuit_jetApprox e).to_comp.partrec
  intro a q
  exact ⟨Circuit.jetApprox e a q,fun precision => Part.mem_some (Circuit.jetApprox e a q precision),
    circuit_periodic_approx hu hx ht he a q⟩

end Solenoidal
end

open Set Filter Encodable
open scoped BigOperators Topology
namespace Solenoidal

theorem mixedDerivative_add {u v : Field} (hu : Smooth u) (hv : Smooth v) (a : List (Fin 4)) :
    mixedDerivative (u+v) a = mixedDerivative u a + mixedDerivative v a := by
  induction a with
  | nil => rfl
  | cons j a ih =>
    funext z
    rw [mixedDerivative,ih]
    dsimp only
    rw [fderiv_add ((mixedDerivative_contDiff hu a).differentiable (by simp) z)
      ((mixedDerivative_contDiff hv a).differentiable (by simp) z)]
    rfl

theorem mixedDerivative_smul {u : Field} (hu : Smooth u) (r : ℝ) (a : List (Fin 4)) :
    mixedDerivative (r • u) a = r • mixedDerivative u a := by
  induction a with
  | nil => rfl
  | cons j a ih =>
    funext z
    rw [mixedDerivative,ih]
    dsimp only
    rw [fderiv_const_smul ((mixedDerivative_contDiff hu a).differentiable (by simp) z)]
    rfl

theorem smooth_linear {u v : Field} (hu : Smooth u) (hv : Smooth v) (r : ℝ) :
    Smooth (u+r•v) := hu.add (hv.const_smul r)

theorem mixedDerivative_linear {u v : Field} (hu : Smooth u) (hv : Smooth v)
    (r : ℝ) (a : List (Fin 4)) :
    mixedDerivative (u+r•v) a = mixedDerivative u a + r • mixedDerivative v a := by
  rw [mixedDerivative_add (v := r • v) hu (hv.const_smul r),mixedDerivative_smul hv]

namespace Computing

def realBall (c : Nat.Partrec.Code) (n : ℕ) : Part QBall :=
  (@readCode ℚ _ _ c n).map (fun q => (q,(1/2:ℚ)^n))

theorem realBall_pr : Partrec₂ realBall :=
  (readCode_pr.map (Primrec.snd.pair
    (rat_pow.comp (.const (1/2)) (Primrec.snd.comp .fst))).to_comp.to₂)

theorem realBall_correct {c : Nat.Partrec.Code} {r : ℝ} (h : NamesReal c r) :
    ∃ b : ℕ → QBall, (∀ n, b n ∈ realBall c n) ∧ QBall.Approximates b r := by
  classical
  choose q hq he using h
  refine ⟨fun n => (q n,(1/2:ℚ)^n),fun n => Part.mem_map _ (readCode_mem (hq n)),?_,?_⟩
  · intro n
    simpa [QBall.Contains] using he n
  · simpa using (tendsto_pow_atTop_nhds_zero_of_lt_one
      (by norm_num : (0:ℝ)≤1/2) (by norm_num : (1/2:ℝ)<1))

def linearBalls (r : QBall) (a b : BallVector) : BallVector := fun j => (a j).add (r.mul (b j))

theorem linearBalls_pr : Primrec (fun p : QBall × BallVector × BallVector => linearBalls p.1 p.2.1 p.2.2) := by
  apply Primrec.fin_curry.mpr
  apply Primrec₂.mk
  exact ball_add.comp
    (Primrec.fin_app.comp (Primrec.fst.comp (Primrec.snd.comp .fst)) .snd)
    (ball_mul.comp (Primrec.fst.comp .fst)
      (Primrec.fin_app.comp (Primrec.snd.comp (Primrec.snd.comp .fst)) .snd))

def linearOracle (c : Nat.Partrec.Code) (A B : BallOracle) (p : JetRequest) : Part BallVector :=
  (realBall c p.2.2).bind fun r => (A p).bind fun a =>
    (B p).map (linearBalls r a)

theorem linearOracle_pr (c : Nat.Partrec.Code) {A B : BallOracle}
    (hA : Partrec A) (hB : Partrec B) : Partrec (linearOracle c A B) := by
  have hr : Partrec (fun p : JetRequest => realBall c p.2.2) :=
    realBall_pr.comp (.const c) (Primrec.snd.comp .snd).to_comp
  have ha : Partrec (fun p : JetRequest × QBall => A p.1) := hA.comp .fst
  have hb : Partrec (fun p : (JetRequest × QBall) × BallVector => B p.1.1) :=
    hB.comp (Primrec.fst.comp .fst).to_comp
  exact hr.bind (ha.bind (hb.map
    (linearBalls_pr.comp ((Primrec.snd.comp (Primrec.fst.comp .fst)).pair
      ((Primrec.snd.comp .fst).pair .snd))).to_comp.to₂).to₂).to₂

theorem linearOracle_correct {c : Nat.Partrec.Code} {r : ℝ} (hc : NamesReal c r)
    {u v : Field} (hu : Smooth u) (hv : Smooth v) {A B : BallOracle}
    (hA : OracleCorrect A u) (hB : OracleCorrect B v) :
    OracleCorrect (linearOracle c A B) (u+r•v) := by
  obtain ⟨br,hbr,hbrc⟩ := realBall_correct hc
  intro a q
  obtain ⟨bu,hbu,hbuc⟩ := hA a q
  obtain ⟨bv,hbv,hbvc⟩ := hB a q
  refine ⟨fun n => linearBalls (br n) (bu n) (bv n),fun n =>
    Part.mem_bind (hbr n) (Part.mem_bind (hbu n) (Part.mem_map _ (hbv n))),?_⟩
  intro j
  rw [mixedDerivative_linear hu hv]
  exact (hbuc j).add (hbrc.mul (hbvc j))

end Computing

theorem NamesReal.rationalBound {c : Nat.Partrec.Code} {r : ℝ} (h : NamesReal c r) :
    ∃ M : ℚ, 0 ≤ M ∧ |r| ≤ (M:ℝ) := by
  obtain ⟨q,hq,he⟩ := h 0
  refine ⟨|q|+1,by positivity,?_⟩
  have hh := abs_sub_comm (q:ℝ) r
  have ht : |r| ≤ |r-(q:ℝ)|+|(q:ℝ)| := by
    simpa using abs_add_le (r-(q:ℝ)) (q:ℝ)
  simp only [pow_zero] at he
  push_cast
  rw [← hh] at ht
  linarith

def linearBound (M : ℚ) (B C : List (Fin 4) → ℚ) (a : List (Fin 4)) : ℚ := B a + M * C a

theorem linearBound_pr (M : ℚ) {B C : List (Fin 4) → ℚ} (hb : Primrec B) (hc : Primrec C) :
    Primrec (linearBound M B C) := Computing.rat_add.comp hb (Computing.rat_mul.comp (.const M) hc)

theorem linearBound_nonneg {M : ℚ} (hM : 0 ≤ M) {B C : List (Fin 4) → ℚ}
    (hb : ∀ a, 0 ≤ B a) (hc : ∀ a, 0 ≤ C a) (a : List (Fin 4)) :
    0 ≤ linearBound M B C a := add_nonneg (hb a) (mul_nonneg hM (hc a))

theorem linearBound_correct {u v : Field} (hu : Smooth u) (hv : Smooth v) {r : ℝ}
    {M : ℚ} (hM : |r| ≤ (M:ℝ)) {B C : List (Fin 4) → ℚ}
    (hb : ∀ a z, ‖mixedDerivative u a z‖ ≤ (B a:ℝ))
    (hc : ∀ a z, ‖mixedDerivative v a z‖ ≤ (C a:ℝ)) (a : List (Fin 4)) (z : SpaceTime) :
    ‖mixedDerivative (u+r•v) a z‖ ≤ (linearBound M B C a:ℝ) := by
  rw [mixedDerivative_linear hu hv]
  apply (norm_add_le _ _).trans
  simp only [Pi.smul_apply,norm_smul,Real.norm_eq_abs,linearBound,Rat.cast_add,Rat.cast_mul]
  exact add_le_add (hb a z) (mul_le_mul hM (hc a z) (norm_nonneg _)
    ((abs_nonneg r).trans hM))

theorem effectiveBounds_of_bound {u : Field} {B : List (Fin 4) → ℚ}
    (hpr : Primrec B) (hn : ∀ a, 0 ≤ B a) (hb : ∀ a z, ‖mixedDerivative u a z‖ ≤ (B a:ℝ)) :
    EffectiveBounds u := by
  obtain ⟨c,hc⟩ := Computing.partrec_code hpr.to_comp.partrec
  exact ⟨c,fun a => ⟨B a,hc a (B a) (Part.mem_some _),hn a,hb a⟩⟩

theorem HasCircuit.computable_linear {u v : Field} (hU : HasCircuit u) (hV : HasCircuit v)
    (hu : Smooth u) (hv : Smooth v) (hux : SpatiallyPeriodic u) (hvx : SpatiallyPeriodic v)
    (hut : OnePeriodic u) (hvt : OnePeriodic v) {r : ℝ} (hr : ComputableReal r) :
    Effective (u+r•v) ∧ EffectiveBounds (u+r•v) := by
  obtain ⟨c,hc⟩ := hr
  obtain ⟨M,hM,hMr⟩ := hc.rationalBound
  obtain ⟨e,he⟩ := hU
  obtain ⟨f,hf⟩ := hV
  let B := linearBound M (Circuit.jetBound e) (Circuit.jetBound f)
  have hBp : Primrec B := linearBound_pr M (Computing.circuit_jetBound e) (Computing.circuit_jetBound f)
  have hBn : ∀ a, 0 ≤ B a := linearBound_nonneg hM (Circuit.jetBound_nonneg e) (Circuit.jetBound_nonneg f)
  have hBb : ∀ a z, ‖mixedDerivative (u+r•v) a z‖ ≤ (B a:ℝ) :=
    linearBound_correct hu hv hMr (circuit_periodic_bound hu hux hut he) (circuit_periodic_bound hv hvx hvt hf)
  constructor
  · apply effective_of_oracle (smooth_linear hu hv r) hBp hBn hBb
      (Computing.linearOracle_pr c (Computing.circuit_jetApprox e).to_comp.partrec
        (Computing.circuit_jetApprox f).to_comp.partrec)
    apply Computing.linearOracle_correct hc hu hv
    · intro a q
      exact ⟨Circuit.jetApprox e a q,fun _ => Part.mem_some _,circuit_periodic_approx hu hux hut he a q⟩
    · intro a q
      exact ⟨Circuit.jetApprox f a q,fun _ => Part.mem_some _,circuit_periodic_approx hv hvx hvt hf a q⟩
  · exact effectiveBounds_of_bound hBp hBn hBb

theorem HasRationalFormula.directForce_effective {u : Field} (h : HasRationalFormula u)
    (hu : Smooth u) (hx : SpatiallyPeriodic u) (ht : OnePeriodic u) {ν : ℝ}
    (hν : ComputableReal ν) : Effective (globalDirectForce ν u) ∧ EffectiveBounds (globalDirectForce ν u) := by
  have hux : SpatiallyPeriodic (Solenoidal.fullTimePartial u) := by
    rw [fullTimePartial_eq_fieldDirectional hu]
    exact fieldDirectional_spatially_periodic hu hx _
  have hut : OnePeriodic (Solenoidal.fullTimePartial u) := by
    rw [fullTimePartial_eq_fieldDirectional hu]
    exact fieldDirectional_onePeriodic hu ht _
  have hvx : SpatiallyPeriodic ((-1:ℝ) • Solenoidal.laplacian u) := by
    intro t x k
    change (-1:ℝ) • (∑ j, Solenoidal.spatialPartial (Solenoidal.spatialPartial u j) j t (x+deck k)) =
      (-1:ℝ) • (∑ j, Solenoidal.spatialPartial (Solenoidal.spatialPartial u j) j t x)
    congr 1
    exact Finset.sum_congr rfl (fun j _ => spatialPartial_spatially_periodic
      (smooth_spatialPartial hu j) (spatialPartial_spatially_periodic hu hx j) j t x k)
  have hvt : OnePeriodic ((-1:ℝ) • Solenoidal.laplacian u) := by
    intro t x
    change (-1:ℝ) • (∑ j, Solenoidal.spatialPartial (Solenoidal.spatialPartial u j) j (t+1) x) =
      (-1:ℝ) • (∑ j, Solenoidal.spatialPartial (Solenoidal.spatialPartial u j) j t x)
    congr 1
    exact Finset.sum_congr rfl (fun j _ => spatialPartial_onePeriodic
      (smooth_spatialPartial hu j) (spatialPartial_onePeriodic hu ht j) j t x)
  have hV : HasCircuit ((-1:ℝ) • Solenoidal.laplacian u) := by
    simpa only [Rat.cast_neg, Rat.cast_one] using (((h.laplacian hu).smul (-1)).circuit)
  have hvs : Smooth ((-1:ℝ) • Solenoidal.laplacian u) :=
    (smooth_laplacian hu).const_smul (-1:ℝ)
  have hh := ((h.fullTimePartial hu).circuit).computable_linear
    hV (smooth_fullTimePartial hu) hvs hux hvx hut hvt hν
  have he : globalDirectForce ν u = Solenoidal.fullTimePartial u + ν • ((-1:ℝ) • Solenoidal.laplacian u) := by
    ext t x j
    simp [globalDirectForce,sub_eq_add_neg]
  rwa [← he] at hh

end Solenoidal

end OAI