import OAI.Combinatorics.LowSpaceSubsetSum.Counting.ParentLiveState

namespace OAI

/-! # Uniform payload bounds for all concrete parent states

The estimates use the stored type invariants, so an interrupted join and an
already overflowing dictionary satisfy the same bounds as a completed run.
Shared input arrays are counted once outside the mutable state.
-/

namespace LowSpaceSubsetSum.ParentLiveBounds

variable {n : ℕ}

theorem reader_le (I : Instance n) (F : IndexedMask n) (P : ℤ) (mode : FilteredStream.Mode)
    (right : Array (LeafRecord n)) {d : ℕ} (s : CountedParentJoin.State I F P mode right d)
    (C : ℕ) (ht : 2 ^ (d + 1) ≤ 4 * (C + 1)) :
    ParentLiveState.reader s ≤ 176 * inputScale I * (C + 1) := by
  have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega
  have hc : 12 * n + 32 ≤ 44 * inputScale I := by omega
  have hm := Nat.mul_le_mul hc ht
  rw [ParentLiveState.reader_exact]
  nlinarith only [hm]

theorem frame_le (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C : ℕ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (st : StreamJoin.State (CountedParentJoin.State I F P .direct right₁ d₁)
      (CountedParentJoin.State I F P (.complementary t) right₂ d₂) (StoredEntry.Dictionary I C))
    (h₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (h₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) :
    ParentLiveState.frame st ≤ 400 * inputScale I * (C + 1) := by
  have hl := reader_le I F P .direct right₁ st.left C h₁
  have hr := reader_le I F P (.complementary t) right₂ st.right C h₂
  have hd := ParentLiveState.dictionary_scale I C st.user
  have hu : 1 ≤ inputScale I := by unfold inputScale; omega
  have hm : inputScale I ≤ inputScale I * (C + 1) := by nlinarith only [hu]
  unfold ParentLiveState.frame
  nlinarith only [hl, hr, hd, hu, hm]

theorem shared_le (I : Instance n) (C : ℕ) (left right : Array (LeafRecord n))
    (hl : left.size ≤ C) (hr : right.size ≤ C) :
    ParentLiveState.sharedArrays left right ≤ 8 * inputScale I * (C + 1) := by
  have h := ParentLiveState.sharedArrays_le left right C hl hr
  have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega
  have hc : 3 * n + 4 ≤ 4 * inputScale I := by omega
  have hm := Nat.mul_le_mul hc (by omega : 2 * C + 1 ≤ 2 * (C + 1))
  exact h.trans (by nlinarith only [hm])

theorem all_inputs_and_state (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C : ℕ)
    (left₁ right₁ left₂ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (st : StreamJoin.State (CountedParentJoin.State I F P .direct right₁ d₁)
      (CountedParentJoin.State I F P (.complementary t) right₂ d₂) (StoredEntry.Dictionary I C))
    (h₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (h₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1))
    (hl₁ : left₁.size ≤ C) (hr₁ : right₁.size ≤ C) (hl₂ : left₂.size ≤ C) (hr₂ : right₂.size ≤ C)
    (hn : 10000 ≤ n) :
    ParentLiveState.frame st + ParentLiveState.sharedArrays left₁ right₁ +
      ParentLiveState.sharedArrays left₂ right₂ ≤ inputScale I ^ 2 * (C + 1) := by
  have hs := frame_le I F P t C right₁ right₂ st h₁ h₂
  have ha := shared_le I C left₁ right₁ hl₁ hr₁
  have hb := shared_le I C left₂ right₂ hl₂ hr₂
  have hu : n + 1 ≤ inputScale I := by unfold inputScale; omega
  have hc : 416 * inputScale I ≤ inputScale I ^ 2 := by nlinarith only [hu, hn]
  have hm := Nat.mul_le_mul_right (C + 1) hc
  nlinarith only [hs, ha, hb, hm]

end LowSpaceSubsetSum.ParentLiveBounds

end OAI