import OAI.MathematicalPhysics.AlternatingFlow.FieldPrograms

namespace OAI

section LocalNamesDevelopment

open scoped BigOperators Topology ContDiff
namespace AlternatingNS.Effective
attribute [local instance] Arithmetic.rationalCoding

variable {A : Type*} [Primcodable A]

lemma Named.nat (f : A → ℕ) (hf : Computable f) : Named (fun a => (f a : ℝ)) :=
  (Named.rational (Arithmetic.rat_natCast.to_comp.comp hf)).congr (fun _ => Rat.cast_natCast _)

lemma Named.natPow (b n : A → ℕ) (hb : Computable b) (hn : Computable n) :
    Named (fun a => (b a : ℝ) ^ n a) :=
  (Named.rational (Arithmetic.rat_pow.to_comp.comp
    (Arithmetic.rat_natCast.to_comp.comp hb) hn)).congr (by intro a; simp)

lemma Named.invNatPow (b n : A → ℕ) (hb : Computable b) (hn : Computable n) :
    Named (fun a => ((b a : ℝ) ^ n a)⁻¹) :=
  (Named.rational (Arithmetic.rat_inv.to_comp.comp (Arithmetic.rat_pow.to_comp.comp
    (Arithmetic.rat_natCast.to_comp.comp hb) hn))).congr (by intro a; simp)

lemma Named.divNat {f : A → ℝ} (hf : Named f) (b : A → ℕ) (hb : Computable b) :
    Named (fun a => f a / b a) :=
  (hf.mul (Named.invNatPow b (fun _ => 1) hb (Computable.const 1))).congr
    (by intro a; simp [div_eq_mul_inv])

lemma Named.selector {f : A → ℝ} (hf : Named f) (b a : A → ℕ)
    (hb : Computable b) (ha : Computable a) :
    Named (fun z => Profiles.selector (b z) (a z) (f z)) := by
  have h1 := (((Named.const 8).mul (((Named.nat b hb).mul hf).sub
    ((Named.const 2).mul (Named.nat a ha)))).add (Named.const 2)).transition
  have h2 := (((Named.const 8).mul ((((Named.const 2).mul (Named.nat a ha)).add
    (Named.const 1)).sub ((Named.nat b hb).mul hf))).add (Named.const 2)).transition
  exact (h1.mul h2).congr (by intro; simp only [Profiles.selector, Rat.cast_ofNat, Rat.cast_one])

lemma read_named (M : A → Machine) (N n : A → ℕ) (D : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hD : Named D) :
    Named (fun z => LocalRule.readC (M z) (N z) (n z) (D z)) ∧
    Named (fun z => LocalRule.readB (M z) (N z) (n z) (D z)) ∧
    Named (fun z => LocalRule.readA (M z) (N z) (n z) (D z)) := by
  have hb := base.to_comp.comp hM
  have hs := exponent.to_comp.comp hN hn
  have hK := capacity.to_comp.comp hN hn
  have hbase (z : A) : 2 ≤ (M z).base := by have := (M z).base_ge_four; omega
  have hC := ((Named.natPow (fun z => (M z).base) _ hb hs).mul hD).decoder
    (fun z => (M z).base) hb hbase
  have hB := ((Named.natPow (fun z => (M z).base) _ hb
    (Primrec.nat_add.to_comp.comp (Computable.succ.comp hs) hK)).mul hD).decoder
    (fun z => (M z).base) hb hbase
  have hA := ((Named.natPow (fun z => (M z).base) _ hb (Computable.succ.comp hs)).mul hD).decoder
    (fun z => (M z).base) hb hbase
  exact ⟨hC,hB,hA.sub ((Named.invNatPow (fun z => (M z).base) _ hb hK).mul hB)⟩

lemma numerator_named (b K a l : A → ℕ) (r : A → Rule) (u v : A → ℝ)
    (hb : Computable b) (hK : Computable K) (ha : Computable a) (hl : Computable l)
    (hr : Computable r) (hu : Named u) (hv : Named v) :
    Named (fun z => LocalRule.branchNumerator (b z) (K z) (a z) (l z) (r z) (u z) (v z)) := by
  have h2a := Named.nat (fun z => 2 * a z) (Primrec.nat_mul.to_comp.comp (Computable.const 2) ha)
  have h2l := Named.nat (fun z => 2 * l z) (Primrec.nat_mul.to_comp.comp (Computable.const 2) hl)
  have h2w := Named.nat (fun z => 2 * (r z).2.1)
    (Primrec.nat_mul.to_comp.comp (Computable.const 2) (Computable.fst.comp (Computable.snd.comp hr)))
  have h2q := Named.nat (fun z => 2 * (r z).1)
    (Primrec.nat_mul.to_comp.comp (Computable.const 2) (Computable.fst.comp hr))
  have hi (i : Fin 3) : Computable (fun z => decide ((r z).2.2 = i)) :=
    Primrec.eq.decide.to_comp.comp (Computable.snd.comp (Computable.snd.comp hr)) (Computable.const i)
  have hL := Named.ite (fun z => (r z).2.2 = 0) (hi 0)
    (((Named.nat b hb).mul hu).sub h2l)
    (Named.ite (fun z => (r z).2.2 = 1) (hi 1) hu ((h2w.add hu).divNat b hb))
  have hR := ((Named.nat b hb).mul hv).sub h2a
  have hR' := Named.ite (fun z => (r z).2.2 = 0) (hi 0)
    ((h2l.add ((h2w.add hR).divNat b hb)).divNat b hb)
    (Named.ite (fun z => (r z).2.2 = 1) (hi 1) ((h2w.add hR).divNat b hb) hR)
  exact ((h2q.add hL).add ((Named.invNatPow b K hb hK).mul hR')).congr (by
    intro z; dsimp [LocalRule.branchNumerator, LocalRule.updateLeft, LocalRule.updateRight]
    push_cast; split_ifs <;> rfl)

lemma branch_named (M : A → Machine) (N n q a : A → ℕ) (u v : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hq : Computable q)
    (ha : Computable a) (hu : Named u) (hv : Named v) :
    Named (fun z => LocalRule.branch (M z) (N z) (n z) (q z) (a z) (u z) (v z)) := by
  let r := fun z => (M z).command (q z) (a z)
  have hr : Computable r := command.to_comp.comp (hM.pair (hq.pair ha))
  have hb := base.to_comp.comp hM
  have hK := capacity.to_comp.comp hN (Computable.succ.comp hn)
  have hsel := (hu.comp (g := (Prod.fst : A × ℕ → A)) Computable.fst).selector
    (fun z => (M z.1).base) Prod.snd (hb.comp Computable.fst) Computable.snd
  have hnum := numerator_named (fun z : A × ℕ => (M z.1).base)
    (fun z => Scales.K (N z.1) (n z.1+1)) (fun z => a z.1) Prod.snd (fun z => r z.1)
    (fun z => u z.1) (fun z => v z.1) (hb.comp Computable.fst) (hK.comp Computable.fst)
    (ha.comp Computable.fst) Computable.snd (hr.comp Computable.fst)
    (hu.comp Computable.fst) (hv.comp Computable.fst)
  have hsum := (hsel.mul hnum).sum_range (fun z => (M z).alphabet) (alphabet.to_comp.comp hM)
  have hother := numerator_named (fun z => (M z).base) (fun z => Scales.K (N z) (n z+1))
    a (fun _ => 0) r u v hb hK ha (Computable.const 0) hr hu hv
  have hi : Computable (fun z => decide ((r z).2.2 = 0)) :=
    Primrec.eq.decide.to_comp.comp (Computable.snd.comp (Computable.snd.comp hr)) (Computable.const (0 : Fin 3))
  exact (Named.ite (fun z => (r z).2.2 = 0) hi hsum hother).congr (by intro z; rfl)

lemma writeCore_named (M : A → Machine) (N n : A → ℕ) (D : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hD : Named D) :
    Named (fun z => Bounds.writeCore (M z) (N z) (n z) (D z)) := by
  let P := (A × ℕ) × ℕ
  let M' := fun z : P => M z.1.1
  let N' := fun z : P => N z.1.1
  let n' := fun z : P => n z.1.1
  let D' := fun z : P => D z.1.1
  have hp : Computable (fun z : P => z.1.1) := Computable.fst.comp Computable.fst
  have hm : Computable M' := hM.comp hp
  have hnn : Computable n' := hn.comp hp
  have hnd : Computable N' := hN.comp hp
  obtain ⟨hC,hB,hA⟩ := read_named M' N' n' D' hm hnd hnn (hD.comp hp)
  have hb := base.to_comp.comp hm
  have hQ : Computable (fun z : P => z.1.2) := Computable.snd.comp Computable.fst
  have hterm := ((hC.selector (fun z => (M' z).base) (fun z => z.1.2) hb hQ).mul
    (hB.selector (fun z => (M' z).base) Prod.snd hb Computable.snd)).mul
    (branch_named M' N' n' (fun z => z.1.2) Prod.snd _ _ hm hnd hnn hQ Computable.snd hA hB)
  have hsum := (hterm.sum_range (fun z : A × ℕ => (M z.1).alphabet)
    (alphabet.to_comp.comp (hM.comp Computable.fst))).sum_range
      (fun z => (M z).states+1) (Computable.succ.comp (states.to_comp.comp hM))
  exact (hsum.divNat (fun z => (M z).base) (base.to_comp.comp hM)).congr (by
    intro z; dsimp [P,M',N',n',D',Bounds.writeCore]; ring)

lemma haltWeight_named (M : A → Machine) (N n : A → ℕ) (D : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hD : Named D) :
    Named (fun z => LocalRule.haltWeight (M z) (N z) (n z) (D z)) := by
  have hC := (read_named M N n D hM hN hn hD).1
  have hsel := (hC.comp (g := (Prod.fst : A × ℕ → A)) Computable.fst).selector
    (fun z => (M z.1).base) Prod.snd (base.to_comp.comp (hM.comp Computable.fst)) Computable.snd
  have hp : Computable (fun z : A × ℕ =>
      decide (z.2 = (M z.1).states ∨ z.2 ∈ (M z.1).haltingStates)) :=
    (Computable.cond
      (Primrec.eq.decide.to_comp.comp Computable.snd (states.to_comp.comp (hM.comp Computable.fst)))
      (Computable.const true)
      (member.decide.to_comp.comp (haltingStates.to_comp.comp (hM.comp Computable.fst)) Computable.snd)).of_eq
        (by intro z; simp)
  exact ((Named.ite _ hp hsel (Named.const 0)).sum_range
    (fun z => (M z).states+1) (Computable.succ.comp (states.to_comp.comp hM))).congr
    (by intro z; simp only [LocalRule.haltWeight, Function.comp_apply, Rat.cast_zero])

lemma write_named (M : A → Machine) (N n : A → ℕ) (D : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hD : Named D) :
    Named (fun z => LocalRule.write (M z) (N z) (n z) (D z)) := by
  have he := epsilon_named.comp ((hM.pair hN).pair (Computable.succ.comp hn))
  exact (he.mul (writeCore_named M N n D hM hN hn hD)).congr
    (fun z => (Bounds.write_factor _ _ _ _).symm)

lemma signal_named (M : A → Machine) (N n : A → ℕ) (D : A → ℝ)
    (hM : Computable M) (hN : Computable N) (hn : Computable n) (hD : Named D) :
    Named (fun z => LocalRule.signal (M z) (N z) (n z) (D z)) := by
  have he := epsilon_named.comp ((hM.pair hN).pair hn)
  have he' := epsilon_named.comp ((hM.pair hN).pair (Computable.succ.comp hn))
  exact ((he.sub he').add (((Named.const 2).mul he').mul
    (haltWeight_named M N n D hM hN hn hD))).congr (by intro z; simp [LocalRule.signal])

end AlternatingNS.Effective

end LocalNamesDevelopment

end OAI