import OAI.Computability.SpaceSimulation.Evaluation.Ready

namespace OAI

namespace Fifths
namespace Circuit
namespace Ready
open Modulus Bin Fifths.Comp
variable {I U X : Type}

section
variable {C : I → Circuit} {x : I → List X} {S a : I → ℕ}
  {R : ∀ i, (C i).Pool} {f g : ∀ i, (C i).Frame}

theorem endCode (r : Comp x S a (fun i => (C i).packPool (R i))) :
    Comp x S a (fun i => (C i).flow.packMove ((R i),FlowMove.finish)) :=
  r.pair ((Comp.constant r.source 0).pair
    ((Comp.constant r.source 0).pair (Comp.constant r.source 0)))

theorem carryCode (r : Comp x S a (fun i => (C i).packPool (R i)))
    (s : Comp x S a (fun i => (C i).packFrame (f i))) :
    Comp x S a (fun i => (C i).flow.packMove ((R i),FlowMove.cont (f i))) := by
  change Comp x S a (fun i => Bin.pair ((C i).packPool (R i)) (Bin.pair 1
    (Bin.pair ((C i).packFrame (f i)) 0)))
  exact r.pair ((Comp.constant r.source 1).pair (s.pair (Comp.constant r.source 0)))

theorem callCode (r : Comp x S a (fun i => (C i).packPool (R i)))
    (s : Comp x S a (fun i => (C i).packFrame (f i)))
    (t : Comp x S a (fun i => (C i).packFrame (g i))) :
    Comp x S a (fun i => (C i).flow.packMove ((R i),FlowMove.call (f i) (g i))) := by
  simp only [Flow.packMove,Flow.tag,Flow.arg1,Flow.arg2,flow]
  exact r.pair ((Comp.constant r.source 2).pair (s.pair t))
end

section
variable {C : I → Circuit} {x : I → List X} {S cp : I → ℕ}
set_option maxHeartbeats 1500000 in
theorem byPc (b : Ready C x S cp) (ok : ∀ i, (C i).Good)
    (r : U → I) (a : U → ℕ)
    (R : ∀ i, (C (r i)).Pool) (f : ∀ i, (C (r i)).Frame)
    (CP : ReComp x S r a (fun i => cp (r i)))
    (RC : ReComp x S r a (fun i => (C (r i)).packPool (R i)))
    (FC : ReComp x S r a (fun i => (C (r i)).packFrame (f i)))
    (k : Pc) :
    ReComp x S r a (fun i => (C (r i)).flow.packMove ((C (r i)).atPc (R i) (f i) k)) := by
  let D := fun i => C (r i)
  let Q := fun i => (f i).x
  let M := ReComp x S r a
  let sc := fun i => (f i).s.val
  let z := fun i => (f i).z.val
  let y := fun i => (f i).y.val
  let j := fun i => (f i).i.val
  let t := fun i => (f i).r.val
  have fr : M (fun i => (D i).packX (Q i)) := Comp.left FC
  have w₁ : M sc := Comp.left (Comp.right (Comp.right FC))
  have f₂ := Comp.right (Comp.right (Comp.right FC))
  have w₂ : M z := f₂.left
  have w₃ : M y := f₂.right.left
  have w₄ : M j := f₂.right.right.left
  have w₅ : M t := f₂.right.right.right.left
  have w₆ := f₂.right.right.right.right.left
  have w₇ := f₂.right.right.right.right.right
  have p := Comp.trans CP (b.modulusN.pull r)
  have pn := Comp.trans CP (b.countOf.pull r)
  have q := Comp.trans CP (b.widthOf.pull r)
  have vv := b.fitRegisters.pull r
  have origin : M (fun _ => 0) := Comp.constant p.source 0
  have zero := valZero p
  have e0 (v : ∀ i : U, (D i).Request)
      (l : M (fun i => (D i).packX (v i))) :
      M (fun i => (D i).packFrame ((D i).fEntry (v i))) :=
    formComp vv p q _ l pn origin origin origin origin origin zero zero
  let u0 := fun i => (Q i).node
  have kT := Comp.left fr
  have kN := Comp.left (Comp.right fr)
  have HH := slotMap Slot.H kT
  have AA := slotMap Slot.A kT
  have np := b.nav r u0 CP kN
  have psc := valCast p w₁
  have pr := valCast p w₅
  have B₁ : ∀ i, z i ≤ (D i).width+1 := fun i => Nat.le_of_lt_succ (f i).z.isLt
  have B₂ : ∀ i, y i ≤ 2^(D i).width := fun i => Nat.le_of_lt_succ (f i).y.isLt
  have B₃ : ∀ i, j i ≤ (D i).count := fun i => Nat.le_of_lt_succ (f i).i.isLt
  have A := b.children r u0 _ CP kN w₄ B₃
  cases k with
  | entry =>
    have inc := jump vv p q (Comp.right (Comp.right fr)) np.2.2.2
    have rt := plusComp vv p q RC kT inc
    have e := formComp vv p q .outer fr pn origin origin origin origin origin zero zero
    have v := Comp.iteB np.1 (endCode rt) (carryCode RC e)
    apply v.congr
    intro i
    change (if (D i).base (Q i).node then _ else _) =
      (D i).flow.packMove ((D i).atPc (R i) (f i) _)
    cases h : (D i).base (Q i).node <;>
      (simp only [h,Bool.false_eq_true,↓reduceIte,atPc,Q] at *; rfl)
  | outer =>
    have h := e0 (fun i => (Q i).otherH (sc i)) (HH.pair (Comp.pair np.2.2.1 psc))
    have g := formComp vv p q .coord fr pn w₁ origin origin origin origin zero zero
    have v := Comp.iteB (Comp.lt w₁ p) (callCode RC h g) (endCode RC)
    apply v.congr
    intro i
    dsimp only [atPc]
    split <;> rename_i ex
    · split
      · rfl
      · rename_i ho
        exact (ho (of_decide_eq_true ex)).elim
    · split
      · rename_i ho
        exact (ex (decide_eq_true ho)).elim
      · rfl
  | coord =>
    have h := e0 (fun i => ((Q i).otherH (sc i)).undo)
      (HH.pair (Comp.pair np.2.2.1 (fieldNeg p psc)))
    have g := formComp vv p q .guess fr pn w₁ w₂ origin origin origin zero zero
    have l := formComp vv p q .outer fr pn (Comp.plus1 w₁) origin origin origin origin zero zero
    have v := Comp.iteB (Comp.lt w₂ q.plus1) (carryCode RC g) (callCode RC h l)
    refine v.congr (fun i => ?_)
    dsimp only [atPc]
    split <;> rename_i ex
    · split
      · rfl
      · rename_i ho
        exact (ho (of_decide_eq_true ex)).elim
    · split
      · rename_i ho
        exact (ex (decide_eq_true ho)).elim
      · rfl
  | guess =>
    have fs := chooseSlot RC HH
    have h : M (fun i => ((D i).EG (u0 i) (z i) (y i)
        (R i (Slot.H (Q i).target))).val) := by
      apply lookupOne vv p q (fun i => (D i).G (u0 i) (z i) (y i)) fs
      intro V k e j P Q w
      exact valCast (P.trans (p.pull k))
        (b.proposeOf (fun i => r (k i)) (fun i => u0 (k i)) _ _ _
          (Comp.trans P (Comp.pull CP k)) (P.trans (kN.pull k))
          (P.trans (Comp.pull w₂ k)) (P.trans (Comp.pull w₃ k)) Q
          (fun i => B₁ (k i)) (fun i => B₂ (k i)) w)
    have e := formComp vv p q .factor fr pn w₁ w₂ w₃ origin origin h zero
    have l := formComp vv p q .coord fr pn w₁ (Comp.plus1 w₂) origin origin origin zero zero
    have powb := (Comp.constant p.source 2).pow np.2.1 ((fitBitsD vv).mono
      (fun i => Nat.pow_le_pow_right (by omega) ((ok (r i)).small (u0 i))))
    apply (Comp.iteB (Comp.lt w₃ powb) (carryCode RC e) (carryCode RC l)).congr
    intro i
    dsimp only [atPc]
    split <;> rename_i ex
    · split
      · rfl
      · rename_i ho
        exact (ho (of_decide_eq_true ex)).elim
    · split
      · rename_i ho
        exact (ex (decide_eq_true ho)).elim
      · rfl
  | factor =>
    have v := formComp vv p q .sample fr pn w₁ w₂ w₃ w₄ origin w₆ zero
    have w := fieldNeg p (fieldPow p psc (p.minus1.sub
      (Comp.trans CP (b.uniformDegree.pull r))))
    have h := fieldMul p (fieldMul p (Comp.right (Comp.right fr)) w) w₆
    have f := formComp vv p q .guess fr pn w₁ w₂ (Comp.plus1 w₃) origin origin zero zero
    apply (Comp.iteB (Comp.lt w₄ pn) (carryCode RC v)
      (carryCode (plusComp vv p q RC kT (jumpOne vv p q h w₂)) f)).congr
    intro i
    dsimp only [atPc]
    split <;> rename_i ex
    · split
      · rfl
      · rename_i ho
        exact (ho (of_decide_eq_true ex)).elim
    · split
      · rename_i ho
        exact (ex (decide_eq_true ho)).elim
      · rfl
  | sample =>
    have g := e0 (fun i => (Q i).otherA (j i) (t i)) (AA.pair (Comp.pair A pr))
    have h := formComp vv p q .checkA fr pn w₁ w₂ w₃ w₄ w₅ w₆ w₇
    have l := formComp vv p q .factor fr pn w₁ w₂ w₃ (Comp.plus1 w₄) origin
      (fieldMul p w₆ w₇) zero
    apply (Comp.iteB (Comp.lt w₅ p) (callCode RC g h) (carryCode RC l)).congr
    intro i
    dsimp only [atPc]
    split <;> rename_i ex
    · split
      · rfl
      · rename_i ho
        exact (ho (of_decide_eq_true ex)).elim
    · split
      · rename_i ho
        exact (ex (decide_eq_true ho)).elim
      · rfl
  | checkA =>
    have fs := chooseSlot RC HH
    have fa := chooseSlot RC AA
    have h : M (fun i => ((D i).ET (u0 i) (z i) (y i) (j i)
        (R i (Slot.H (Q i).target)) (R i (Slot.A (Q i).target))).val) := by
      apply lookupTwo vv p q (fun i => (D i).test (u0 i) (z i) (y i) (j i)) fs fa
      intro V k e u v P Q t l c
      exact valCast (P.trans (p.pull k))
        (b.allowOf (fun i => r (k i)) (fun i => u0 (k i)) _ _ _ _ _
          (Comp.trans P (Comp.pull CP k)) (P.trans (kN.pull k))
          (P.trans (Comp.pull w₂ k)) (P.trans (Comp.pull w₃ k)) (P.trans (Comp.pull w₄ k))
          Q t (fun i => B₁ (k i)) (fun i => B₂ (k i)) (fun i => B₃ (k i)) l c)
    have w := fieldNeg p (fieldPow p pr (p.minus1.sub q))
    have l := formComp vv p q .sample fr pn w₁ w₂ w₃ w₄ (Comp.plus1 w₅) w₆
      (fieldAdd p w₇ (fieldMul p w h))
    have g := e0 (fun i => ((Q i).otherA (j i) (t i)).undo)
      (AA.pair (Comp.pair A (fieldNeg p pr)))
    exact callCode RC g l
end
end Ready
end Circuit
end Fifths

end OAI