import OAI.Combinatorics.LowSpaceSubsetSum.Search.StoppedStreamJoin

namespace OAI

/-! # Erasing proof-carrying callback states through the actual join

This refinement lets a counted dictionary carry its invariant intrinsically,
while retaining exactly the original join's cursors, counters and halt behavior.
-/

namespace LowSpaceSubsetSum

universe u v s t w z
variable {α : Type u} {β : Type v} {σ : Type s} {τ : Type w} {τ' : Type z}

namespace TieReplay

def mapUser (f : τ → τ') (r : Result σ τ) : Result σ τ' :=
  ⟨r.cursor, f r.state, r.queries, r.reports, r.complete, r.halted⟩

theorem runAcc_mapUser (read : σ → Option (α × σ)) (key : α → ℤ) (K : ℤ)
    (report : α → τ → τ × Bool) (report' : α → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x a, report' x (f a) = (f (report x a).1, (report x a).2))
    (fuel : ℕ) (s : σ) (a : τ) (q r : ℕ) :
    mapUser f (runAcc read key K report fuel s a q r) =
      runAcc read key K report' fuel s (f a) q r := by
  induction fuel generalizing s a q r with
  | zero => rfl
  | succ fuel ih =>
    cases hr : read s with
    | none => simp only [runAcc, hr, mapUser]
    | some p =>
      rcases p with ⟨x, s'⟩
      simp only [runAcc, hr]
      split
      · rw [hf]
        split
        · rfl
        · exact ih _ _ _ _
      · rfl

theorem run_mapUser (read : σ → Option (α × σ)) (key : α → ℤ) (K : ℤ)
    (report : α → τ → τ × Bool) (report' : α → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x a, report' x (f a) = (f (report x a).1, (report x a).2))
    (fuel : ℕ) (s : σ) (a : τ) :
    mapUser f (run read key K report fuel s a) =
      run read key K report' fuel s (f a) :=
  runAcc_mapUser read key K report report' f hf fuel s a 0 0

end TieReplay

namespace JoinOne

theorem run_mapUser (read : σ → Option (α × σ)) (key : α → ℤ) (K : ℤ)
    (report : α → τ → τ × Bool) (report' : α → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x a, report' x (f a) = (f (report x a).1, (report x a).2))
    (buffer : Array α) (saved : σ) (long : Bool) (fuel : ℕ) (a : τ) :
    TieReplay.mapUser f (run read key K report buffer saved long fuel a) =
      run read key K report' buffer saved long fuel (f a) := by
  simp only [run, BufferReplay.run,
    ← TieReplay.run_mapUser (BufferReplay.read buffer) key K report report' f hf,
    TieReplay.mapUser]
  split
  · simp_all only [↓reduceIte]
  · simp_all only [Bool.false_eq_true, ↓reduceIte]
    split
    · simp_all only
      have h := TieReplay.run_mapUser read key K report report' f hf fuel saved
        (TieReplay.run (BufferReplay.read buffer) key K report buffer.size 0 a).state
      cases h₁ : TieReplay.run read key K report fuel saved
        (TieReplay.run (BufferReplay.read buffer) key K report buffer.size 0 a).state
      simp only [h₁, TieReplay.mapUser] at h
      rw [← h]
    · simp_all only

end JoinOne

namespace TieGroup

variable {σ₂ : Type t}

def mapUser (f : τ → τ') (a : State σ₂ τ) : State σ₂ τ' :=
  ⟨a.last, f a.user, a.queries, a.reports, a.restores⟩

def mapResult (f : τ → τ') (r : Result σ σ₂ τ) : Result σ σ₂ τ' :=
  ⟨TieReplay.mapUser (mapUser f) r.outer, r.fillQueries, r.bufferSize, r.snapshot⟩

theorem step_mapUser (read : σ₂ → Option (β × σ₂)) (key : β → ℤ) (K : ℤ)
    (report : α → β → τ → τ × Bool) (report' : α → β → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x y a, report' x y (f a) = (f (report x y a).1, (report x y a).2))
    (buffer : Array β) (saved : σ₂) (long : Bool) (fuel : ℕ) (x : α) (a : State σ₂ τ) :
    (mapUser f (step read key K report buffer saved long fuel x a).1,
      (step read key K report buffer saved long fuel x a).2) =
      step read key K report' buffer saved long fuel x (mapUser f a) := by
  simp only [step, mapUser,
    ← JoinOne.run_mapUser read key K (report x) (report' x) f (hf x), TieReplay.mapUser]

theorem run_mapUser (read₁ : σ → Option (α × σ)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ) (K : ℤ)
    (report : α → β → τ → τ × Bool) (report' : α → β → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x y a, report' x y (f a) = (f (report x y a).1, (report x y a).2))
    (B fuel₁ fuel₂ : ℕ) (s₁ : σ) (s₂ : σ₂) (a : τ) :
    mapResult f (run read₁ key₁ read₂ key₂ K report B fuel₁ fuel₂ s₁ s₂ a) =
      run read₁ key₁ read₂ key₂ K report' B fuel₁ fuel₂ s₁ s₂ (f a) := by
  let filled := TieBuffer.fill read₂ key₂ K B s₂
  let long := TieBuffer.hasKey read₂ key₂ K filled.cursor
  have hstep := fun x st => (step_mapUser read₂ key₂ K report report' f hf
    filled.buffer filled.cursor long fuel₂ x st).symm
  have h := TieReplay.run_mapUser read₁ key₁ K
    (step read₂ key₂ K report filled.buffer filled.cursor long fuel₂)
    (step read₂ key₂ K report' filled.buffer filled.cursor long fuel₂)
    (mapUser f) hstep fuel₁ s₁ ⟨filled.cursor, a, 0, 0, 0⟩
  change mapResult f ⟨_, filled.queries, filled.buffer.size, _⟩ = _
  unfold mapResult
  rw [h]
  rfl

end TieGroup
namespace StreamJoin

variable {σ₂ : Type t}

def mapUser (f : τ → τ') (a : State σ σ₂ τ) : State σ σ₂ τ' :=
  ⟨a.left, a.right, f a.user, a.queries, a.reports, a.copies, a.done⟩

def mapStopped (f : τ → τ') (a : StoppedResult σ σ₂ τ) : StoppedResult σ σ₂ τ' :=
  ⟨mapUser f a.state, a.steps⟩

theorem step_mapUser (read₁ : σ → Option (α × σ)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ)
    (report : α → β → τ → τ × Bool) (report' : α → β → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x y a, report' x y (f a) = (f (report x y a).1, (report x y a).2))
    (B fuel₁ fuel₂ : ℕ) (a : State σ σ₂ τ) :
    mapUser f (step read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ a) =
      step read₁ key₁ read₂ key₂ report' B fuel₁ fuel₂ (mapUser f a) := by
  by_cases hd : a.done = true
  · simp only [step, mapUser, hd, ↓reduceIte]
  · cases h₁ : read₁ a.left with
    | none => simp only [step, mapUser, hd, Bool.false_eq_true, ↓reduceIte, h₁]
    | some p₁ =>
      rcases p₁ with ⟨x, l⟩
      cases h₂ : read₂ a.right with
      | none => simp only [step, mapUser, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂]
      | some p₂ =>
        rcases p₂ with ⟨y, r⟩
        simp only [step, mapUser, hd, Bool.false_eq_true, ↓reduceIte, h₁, h₂,
          ← TieGroup.run_mapUser read₁ key₁ read₂ key₂ (key₁ x) report report' f hf,
          TieGroup.mapResult, TieReplay.mapUser, TieGroup.mapUser]
        split
        · simp_all only
        · split <;> simp_all only

theorem stoppedAcc_mapUser (read₁ : σ → Option (α × σ)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ)
    (report : α → β → τ → τ × Bool) (report' : α → β → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x y a, report' x y (f a) = (f (report x y a).1, (report x y a).2))
    (B fuel₁ fuel₂ fuel : ℕ) (a : State σ σ₂ τ) :
    mapStopped f (stoppedAcc read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ fuel a) =
      stoppedAcc read₁ key₁ read₂ key₂ report' B fuel₁ fuel₂ fuel (mapUser f a) := by
  induction fuel generalizing a with
  | zero => rfl
  | succ fuel ih =>
    by_cases hd : a.done = true
    · simp only [stoppedAcc, mapStopped, mapUser, hd, ↓reduceIte]
    · have h := ih (step read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ a)
      have hdone : (mapUser f a).done = a.done := rfl
      simp only [stoppedAcc, hdone, hd, Bool.false_eq_true, ↓reduceIte]
      rw [← step_mapUser read₁ key₁ read₂ key₂ report report' f hf]
      rw [← h]
      rfl

theorem run_mapUser (read₁ : σ → Option (α × σ)) (key₁ : α → ℤ)
    (read₂ : σ₂ → Option (β × σ₂)) (key₂ : β → ℤ)
    (report : α → β → τ → τ × Bool) (report' : α → β → τ' → τ' × Bool) (f : τ → τ')
    (hf : ∀ x y a, report' x y (f a) = (f (report x y a).1, (report x y a).2))
    (B fuel₁ fuel₂ fuel : ℕ) (s₁ : σ) (s₂ : σ₂) (a : τ) :
    mapUser f (run read₁ key₁ read₂ key₂ report B fuel₁ fuel₂ fuel s₁ s₂ a) =
      run read₁ key₁ read₂ key₂ report' B fuel₁ fuel₂ fuel s₁ s₂ (f a) := by
  have h := congrArg StoppedResult.state (stoppedAcc_mapUser read₁ key₁ read₂ key₂
    report report' f hf B fuel₁ fuel₂ fuel (start s₁ s₂ a))
  simpa only [mapStopped, stoppedAcc_eq, mapUser, start, run] using h

end StreamJoin

end LowSpaceSubsetSum

end OAI