lean/OAI/MathematicalPhysics/SheetFlows/CircuitPrograms.lean

import Mathlib
import OAI.MathematicalPhysics.SheetFlows.Circuits

namespace OAI

/-! SheetFlows circuit programs. -/

section
open Encodable Denumerable
namespace Solenoidal.Computing
open Nat.Partrec

theorem atom_argument : Primrec₂ Atom.argument :=
  rat_add.comp
    (rat_mul.comp (Primrec.fst.comp (Primrec.snd.comp .fst))
      (Primrec.fin_app.comp .snd (Primrec.fst.comp .fst)))
    (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .fst)))

theorem atom_bound : Primrec₂ Atom.bound := by
  let k : Atom×ℚ → ℕ := fun p => p.1.2.2.2
  have hk : Primrec k := Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .fst))
  exact Primrec.ite (Primrec.eq.comp hk (.const 0))
    (rat_add.comp (rat_mul.comp (rat_abs.comp (Primrec.fst.comp (Primrec.snd.comp .fst)))
        (rat_abs.comp .snd)) (rat_abs.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .fst)))))
    (Primrec.ite (Primrec.eq.comp hk (.const 1)) (.const 16)
      (rat_nat.comp (nat_factorial.comp (Primrec.nat_sub.comp hk (.const 2)))))

theorem atom_approx : Primrec (fun p : Atom × (Fin 4 → ℚ) × ℕ => Atom.approx p.1 p.2.1 p.2.2) := by
  let k : Atom×(Fin 4 → ℚ)×ℕ → ℕ := fun p => p.1.2.2.2
  have hk : Primrec k := Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .fst))
  have hq : Primrec (fun p : Atom×(Fin 4 → ℚ)×ℕ => Atom.argument p.1 p.2.1) :=
    atom_argument.comp Primrec.fst (Primrec.fst.comp Primrec.snd)
  have hn : Primrec (fun p : Atom×(Fin 4 → ℚ)×ℕ => p.2.2) := Primrec.snd.comp .snd
  exact Primrec.ite (Primrec.eq.comp hk (.const 0)) (ball_point.comp hq)
    (Primrec.ite (Primrec.eq.comp hk (.const 1)) (ball_reciprocalApprox.comp hq hn)
      (ball_flatApprox.comp ((Primrec.nat_sub.comp hk (.const 2)).pair (hq.pair hn))))

theorem circuit_data {α : Type*} [Primcodable α] [Inhabited α] :
    Primrec (@Circuit.data α _ _) :=
  Primrec.option_getD_default.comp (Primrec.decode.comp Primrec.encode)

theorem circuit_const : Primrec Circuit.const :=
  Code.primrec_rfind'.comp ((Primrec.ofNat Code).comp Primrec.encode)

theorem circuit_atom : Primrec Circuit.atom :=
  Code.primrec₂_prec.comp ((Primrec.ofNat Code).comp Primrec.encode) (.const Code.zero)

theorem circuit_add : Primrec₂ Circuit.add := Code.primrec₂_pair
theorem circuit_mul : Primrec₂ Circuit.mul := Code.primrec₂_comp
theorem circuit_sub : Primrec₂ Circuit.sub :=
  circuit_add.comp .fst (circuit_mul.comp (.const (Circuit.const (-1))) .snd)

theorem circuit_bound : Primrec₂ Circuit.bound := by
  have h := Code.primrec_recOn' (α := Circuit×ℚ) (σ := ℚ) Primrec.fst
    (Primrec.const 0) (Primrec.const 0) (Primrec.const 0) (Primrec.const 0)
    (rat_add.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
      (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))).to₂
    (rat_mul.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
      (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))).to₂
    (atom_bound.comp (circuit_data.comp (Primrec.fst.comp .snd)) (Primrec.snd.comp .fst)).to₂
    (rat_abs.comp (circuit_data.comp (Primrec.fst.comp .snd))).to₂
  exact h.of_eq (fun p => by
    induction p.1 with
    | zero | succ | left | right => rfl
    | pair a b ha hb => simp [Circuit.bound,ha,hb]
    | comp a b ha hb => simp [Circuit.bound,ha,hb]
    | prec a b ha hb => rfl
    | rfind' a ha => rfl)

theorem circuit_approx : Primrec (fun p : Circuit×(Fin 4 → ℚ)×ℕ => Circuit.approx p.1 p.2.1 p.2.2) := by
  have h := Code.primrec_recOn' (α := Circuit×(Fin 4 → ℚ)×ℕ) (σ := QBall) Primrec.fst
    (Primrec.const (QBall.point 0)) (Primrec.const (QBall.point 0))
    (Primrec.const (QBall.point 0)) (Primrec.const (QBall.point 0))
    (ball_add.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
      (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))).to₂
    (ball_mul.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
      (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))).to₂
    (atom_approx.comp ((circuit_data.comp (Primrec.fst.comp .snd)).pair (Primrec.snd.comp .fst))).to₂
    (ball_point.comp (circuit_data.comp (Primrec.fst.comp .snd))).to₂
  exact h.of_eq (fun p => by
    induction p.1 with
    | zero | succ | left | right => rfl
    | pair a b ha hb => simp [Circuit.approx,ha,hb]
    | comp a b ha hb => simp [Circuit.approx,ha,hb]
    | prec a b ha hb => rfl
    | rfind' a ha => rfl)

theorem atom_withKind : Primrec₂ Atom.withKind :=
  (Primrec.fst.comp .fst).pair ((Primrec.fst.comp (Primrec.snd.comp .fst)).pair
    ((Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .fst))).pair .snd))

theorem atom_reflect : Primrec Atom.reflect :=
  Primrec.fst.pair ((rat_neg.comp (Primrec.fst.comp .snd)).pair
    ((rat_sub.comp (.const 1) (Primrec.fst.comp (Primrec.snd.comp .snd))).pair
      (Primrec.snd.comp (Primrec.snd.comp .snd))))

theorem circuit_atomDiff : Primrec₂ Circuit.atomDiff := by
  let k : Fin 4×Atom → ℕ := fun p => p.2.2.2.2
  have hk : Primrec k := Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd))
  have hat (f : Fin 4×Atom → Atom) (hf : Primrec f) (n : Fin 4×Atom → ℕ) (hn : Primrec n) :
      Primrec (fun p => Circuit.atom ((f p).withKind (n p))) :=
    circuit_atom.comp (atom_withKind.comp hf hn)
  exact Primrec.ite (Primrec.eq.comp (Primrec.fst.comp .snd) .fst)
    (circuit_mul.comp (circuit_const.comp (Primrec.fst.comp (Primrec.snd.comp .snd)))
      (Primrec.ite (Primrec.eq.comp hk (.const 0)) (.const (Circuit.const 1))
        (Primrec.ite (Primrec.eq.comp hk (.const 1))
          (circuit_mul.comp (.const (Circuit.const (-1)))
            (circuit_mul.comp (circuit_mul.comp (circuit_atom.comp .snd) (circuit_atom.comp .snd))
              (circuit_sub.comp (hat _ .snd _ (.const 4))
                (hat _ (atom_reflect.comp .snd) _ (.const 4)))))
          (circuit_sub.comp
            (hat _ .snd _ (Primrec.nat_add.comp (Primrec.nat_sub.comp hk (.const 2)) (.const 4)))
            (circuit_mul.comp (circuit_const.comp (rat_nat.comp (Primrec.nat_sub.comp hk (.const 2))))
              (hat _ .snd _ (Primrec.nat_add.comp (Primrec.nat_sub.comp hk (.const 2)) (.const 3))))))))
    (.const (Circuit.const 0))

theorem circuit_diff : Primrec₂ Circuit.diff := by
  have h := Code.primrec_recOn' (α := Fin 4×Circuit) (σ := Circuit) Primrec.snd
    (Primrec.const (Circuit.const 0)) (Primrec.const (Circuit.const 0))
    (Primrec.const (Circuit.const 0)) (Primrec.const (Circuit.const 0))
    (circuit_add.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
      (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))).to₂
    (circuit_add.comp
      (circuit_mul.comp (Primrec.fst.comp (Primrec.snd.comp (Primrec.snd.comp .snd)))
        (Primrec.fst.comp (Primrec.snd.comp .snd)))
      (circuit_mul.comp (Primrec.fst.comp .snd)
        (Primrec.snd.comp (Primrec.snd.comp (Primrec.snd.comp .snd))))).to₂
    (circuit_atomDiff.comp (Primrec.fst.comp .fst) (circuit_data.comp (Primrec.fst.comp .snd))).to₂
    (Primrec₂.const (Circuit.const 0))
  exact h.of_eq (fun p => by
    induction p.2 with
    | zero | succ | left | right => rfl
    | pair a b ha hb => simp [Circuit.diff,ha,hb]
    | comp a b ha hb => simp [Circuit.diff,ha,hb]
    | prec a b ha hb => rfl
    | rfind' a ha => rfl)

theorem circuit_mixed : Primrec₂ Circuit.mixed := by
  have h := Primrec.list_foldr (α := Circuit×List (Fin 4)) Primrec.snd Primrec.fst
    (circuit_diff.comp (Primrec.fst.comp .snd) (Primrec.snd.comp .snd)).to₂
  exact h.of_eq (fun p => by
    induction p.2 with
    | nil => rfl
    | cons j a ha => simp [Circuit.mixed,List.foldr,ha])

end Solenoidal.Computing
end

open Set Filter Encodable
open scoped BigOperators Topology
namespace Solenoidal

def HasCircuit (u : Field) : Prop := ∃ e : Fin 3 → Circuit,
  Set.EqOn (fun z => u z.1 z.2) (fun z => Circuit.field e z.1 z.2) closedPeriodCell

theorem HasRationalFormula.circuit {u : Field} (h : HasRationalFormula u) : HasCircuit u := by
  obtain ⟨e,he⟩ := h
  refine ⟨fun j => BoxExpr.compile (e j), ?_⟩
  intro z hz
  rw [he hz]
  ext j
  exact (BoxExpr.compile_correct (e j) z).symm

namespace Circuit

def jetBound (e : Fin 3 → Circuit) (a : List (Fin 4)) : ℚ :=
  ∑ j, bound (mixed (e j) a) 10

theorem jetBound_nonneg (e : Fin 3 → Circuit) (a : List (Fin 4)) : 0 ≤ jetBound e a :=
  Finset.sum_nonneg (fun _ _ => bound_nonneg _ _)

theorem jetBound_correct (e : Fin 3 → Circuit) (a : List (Fin 4)) (z : SpaceTime)
    (hz : ∀ j, |coordinateLinear j z| ≤ 10) :
    ‖mixedDerivative (field e) a z‖ ≤ (jetBound e a : ℝ) := by
  apply (pi_norm_le_iff_of_nonneg (by exact_mod_cast jetBound_nonneg e a)).mpr
  intro j
  rw [mixed_field]
  change |eval (mixed (e j) a) z| ≤ _
  apply (bound_correct _ 10 z (by simpa using hz)).trans
  exact_mod_cast Finset.single_le_sum (fun i _ => bound_nonneg _ _) (Finset.mem_univ j)

def wrapRat (q : Fin 4 → ℚ) : Fin 4 → ℚ := fun j =>
  let T : ℚ := if j=0 then 1 else 10
  T * Int.fract (q j / T)

theorem wrapRat_correct (q : Fin 4 → ℚ) : ofRational (wrapRat q) =
    (Int.fract (ofRational q).1,wrapSpace (ofRational q).2) := by
  apply Prod.ext
  · simp [ofRational,wrapRat,Rat.cast_fract]
  · ext j
    fin_cases j <;> simp [ofRational,wrapRat,wrapSpace,Rat.cast_fract]

def jetApprox (e : Fin 3 → Circuit) (a : List (Fin 4)) (q : Fin 4 → ℚ) (n : ℕ) : Fin 3 → QBall :=
  fun j => approx (mixed (e j) a) (wrapRat q) n

end Circuit

theorem circuit_periodic_jet {u : Field} (hu : Smooth u) (hx : SpatiallyPeriodic u)
    (ht : OnePeriodic u) {e : Fin 3 → Circuit}
    (he : Set.EqOn (fun z => u z.1 z.2) (fun z => Circuit.field e z.1 z.2) closedPeriodCell)
    (a : List (Fin 4)) (z : SpaceTime) :
    mixedDerivative u a z = mixedDerivative (Circuit.field e) a (Int.fract z.1,wrapSpace z.2) := by
  have hp := periodic_field_reduction
    (mixedDerivative_spatially_periodic hu hx a) (mixedDerivative_onePeriodic hu ht a) z.1 z.2
  change mixedDerivative u a z = mixedDerivative u a (Int.fract z.1,wrapSpace z.2) at hp
  rw [hp]
  exact mixedDerivative_eqOn_cell hu (Circuit.field_smooth e) he a
    ⟨⟨Int.fract_nonneg _,(wrapSpace_mem z.2).1⟩,
      ⟨(Int.fract_lt_one _).le,(wrapSpace_mem z.2).2⟩⟩

theorem circuit_periodic_bound {u : Field} (hu : Smooth u) (hx : SpatiallyPeriodic u)
    (ht : OnePeriodic u) {e : Fin 3 → Circuit}
    (he : Set.EqOn (fun z => u z.1 z.2) (fun z => Circuit.field e z.1 z.2) closedPeriodCell)
    (a : List (Fin 4)) (z : SpaceTime) :
    ‖mixedDerivative u a z‖ ≤ (Circuit.jetBound e a : ℝ) := by
  rw [circuit_periodic_jet hu hx ht he]
  apply Circuit.jetBound_correct
  intro j
  fin_cases j
  · change |Int.fract z.1| ≤ 10
    rw [abs_of_nonneg (Int.fract_nonneg _)]
    exact (Int.fract_lt_one _).le.trans (by norm_num)
  all_goals
    change |wrapSpace z.2 _| ≤ 10
    rw [abs_of_nonneg ((wrapSpace_mem z.2).1 _)]
    exact (wrapSpace_mem z.2).2 _

theorem circuit_periodic_approx {u : Field} (hu : Smooth u) (hx : SpatiallyPeriodic u)
    (ht : OnePeriodic u) {e : Fin 3 → Circuit}
    (he : Set.EqOn (fun z => u z.1 z.2) (fun z => Circuit.field e z.1 z.2) closedPeriodCell)
    (a : List (Fin 4)) (q : Fin 4 → ℚ) (j : Fin 3) :
    QBall.Approximates (fun n => Circuit.jetApprox e a q n j)
      (mixedDerivative u a (Circuit.ofRational q) j) := by
  rw [circuit_periodic_jet hu hx ht he, Circuit.mixed_field,← Circuit.wrapRat_correct]
  exact Circuit.approximates _ _

namespace Computing

theorem fin_sum_rat {α : Type*} [Primcodable α] {n : ℕ} {f : α → Fin n → ℚ}
    (hf : ∀ i, Primrec (fun a => f a i)) : Primrec (fun a => ∑ i, f a i) := by
  induction n with
  | zero => simpa using (Primrec.const (0:ℚ) : Primrec (fun _ : α => (0:ℚ)))
  | succ n ih =>
    simpa [Fin.sum_univ_succ] using rat_add.comp (hf 0) (ih (fun i => hf i.succ))

theorem circuit_jetBound (e : Fin 3 → Circuit) : Primrec (Circuit.jetBound e) :=
  fin_sum_rat (fun j => circuit_bound.comp (circuit_mixed.comp (.const (e j)) .id) (.const 10))

theorem circuit_wrapRat : Primrec Circuit.wrapRat := by
  apply Primrec.fin_curry.mpr
  apply Primrec₂.mk
  exact rat_mul.comp
    (Primrec.ite (Primrec.eq.comp .snd (.const 0)) (.const 1) (.const 10))
    (rat_sub.comp
      (rat_div.comp Primrec.fin_app
        (Primrec.ite (Primrec.eq.comp .snd (.const 0)) (.const 1) (.const 10)))
      (rat_int.comp (rat_floor.comp (rat_div.comp Primrec.fin_app
        (Primrec.ite (Primrec.eq.comp .snd (.const 0)) (.const 1) (.const 10))))))

theorem circuit_jetApprox (e : Fin 3 → Circuit) :
    Primrec (fun p : List (Fin 4) × (Fin 4 → ℚ) × ℕ => Circuit.jetApprox e p.1 p.2.1 p.2.2) := by
  apply Primrec.fin_curry.mpr
  apply Primrec₂.mk
  exact circuit_approx.comp
    ((circuit_mixed.comp (Primrec.fin_app.comp (.const e) .snd) (Primrec.fst.comp .fst)).pair
      ((circuit_wrapRat.comp (Primrec.fst.comp (Primrec.snd.comp .fst))).pair
        (Primrec.snd.comp (Primrec.snd.comp .fst))))

theorem partrec_code {α β : Type*} [Primcodable α] [Primcodable β]
    {f : α →. β} (h : Partrec f) : ∃ c : Nat.Partrec.Code,
      ∀ a b, b ∈ f a → encode b ∈ c.eval (encode a) := by
  obtain ⟨c,hc⟩ := Nat.Partrec.Code.exists_code.mp h
  refine ⟨c,fun a b hb => ?_⟩
  rw [hc]
  simp only [encodek,Part.coe_some,Part.bind_some]
  exact Part.mem_map encode hb

end Computing

theorem HasCircuit.effectiveBounds {u : Field} (h : HasCircuit u) (hu : Smooth u)
    (hx : SpatiallyPeriodic u) (ht : OnePeriodic u) : EffectiveBounds u := by
  obtain ⟨e,he⟩ := h
  obtain ⟨c,hc⟩ := Computing.partrec_code (Computing.circuit_jetBound e).to_comp.partrec
  refine ⟨c,fun a => ⟨Circuit.jetBound e a, hc a _ (Part.mem_some _),
    Circuit.jetBound_nonneg e a, circuit_periodic_bound hu hx ht he a⟩⟩

theorem norm_flatten (z : SpaceTime) : ‖flatten z‖ = ‖z‖ := by
  rw [Prod.norm_def]
  apply le_antisymm
  · apply (pi_norm_le_iff_of_nonneg (le_trans (norm_nonneg z.1) (le_max_left _ _))).mpr
    intro j
    fin_cases j
    · exact le_max_left _ _
    all_goals exact (norm_le_pi_norm z.2 _).trans (le_max_right _ _)
  · apply max_le
    · exact norm_le_pi_norm (flatten z) 0
    · apply pi_norm_le_iff_of_nonneg (norm_nonneg _) |>.mpr
      intro j
      exact (show ‖z.2 j‖ ≤ ‖flatten z‖ by
        fin_cases j
        · exact norm_le_pi_norm (flatten z) 1
        · exact norm_le_pi_norm (flatten z) 2
        · exact norm_le_pi_norm (flatten z) 3)

theorem spacetime_expansion (z : SpaceTime) :
    z = ∑ j : Fin 4, flatten z j • spacetimeBasis j := by
  apply Prod.ext
  · simp [flatten,spacetimeBasis,Fin.sum_univ_succ]
  · ext k
    fin_cases k <;> simp [flatten,spacetimeBasis,basis,Fin.sum_univ_succ]

def jetLipschitz (B : List (Fin 4) → ℚ) (a : List (Fin 4)) : ℚ :=
  ∑ j : Fin 4, B (j::a)

theorem jetLipschitz_nonneg {B : List (Fin 4) → ℚ} (h : ∀ a, 0 ≤ B a)
    (a : List (Fin 4)) : 0 ≤ jetLipschitz B a := Finset.sum_nonneg (fun _ _ => h _)

theorem mixed_lipschitz {u : Field} (hu : Smooth u) {B : List (Fin 4) → ℚ}
    (hB : ∀ a, 0 ≤ B a) (hb : ∀ a z, ‖mixedDerivative u a z‖ ≤ (B a:ℝ))
    (a : List (Fin 4)) (z w : SpaceTime) :
    ‖mixedDerivative u a z - mixedDerivative u a w‖ ≤ (jetLipschitz B a:ℝ)*‖z-w‖ := by
  have hd (x : SpaceTime) : ‖fderiv ℝ (mixedDerivative u a) x‖ ≤ (jetLipschitz B a:ℝ) := by
    apply ContinuousLinearMap.opNorm_le_bound _ (by exact_mod_cast jetLipschitz_nonneg hB a)
    intro v
    have he : fderiv ℝ (mixedDerivative u a) x v =
        ∑ j : Fin 4, flatten v j • mixedDerivative u (j::a) x := by
      conv_lhs => rw [spacetime_expansion v]
      simp only [map_sum,map_smul,mixedDerivative]
    rw [he]
    apply (norm_sum_le _ _).trans
    calc
      ∑ j : Fin 4, ‖flatten v j • mixedDerivative u (j::a) x‖ ≤
          ∑ j : Fin 4, (B (j::a):ℝ) * ‖v‖ := by
        apply Finset.sum_le_sum
        intro j _
        rw [norm_smul,mul_comm]
        exact mul_le_mul (hb (j::a) x)
          ((norm_le_pi_norm (flatten v) j).trans_eq (norm_flatten v))
          (norm_nonneg _) (by exact_mod_cast hB (j::a))
      _ = _ := by simp [jetLipschitz,Finset.sum_mul]
  exact Convex.norm_image_sub_le_of_norm_fderiv_le
    (fun x _ => (mixedDerivative_contDiff hu a).differentiable (by simp) x)
    (fun x _ => hd x) convex_univ (Set.mem_univ w) (Set.mem_univ z)

namespace Computing

theorem jetLipschitz_pr {B : List (Fin 4) → ℚ} (hB : Primrec B) : Primrec (jetLipschitz B) :=
  fin_sum_rat (fun j => hB.comp (Primrec.list_cons.comp (.const j) .id))

end Computing
end Solenoidal

end OAI