Datasets:

roseking
/

openAI-math-dataset

import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationStepCells
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.BudgetedStoppedCells

namespace OAI

/-! # Live cells of the complete prepaid parent join

The stopped driver keeps a single current state. Each iteration includes its
concrete reader, key, tie-buffer, snapshot and dictionary trace. Immutable
leaf arrays are retained once by the outer wrapper.
-/

namespace LowSpaceSubsetSum.RepresentationJoinCells

variable {n : ℕ}

open RepresentationStepCells (State)

def run (I : Instance n) (F : IndexedMask n) (P t : ℤ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
    (st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) :=
  BudgetedStoppedCells.run
    (RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂)
    ParentLiveState.frame control st budget

theorem run_value (I : Instance n) (F : IndexedMask n) (P t : ℤ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
    (st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) :
    (run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ control st budget).1 =
      BudgetedJoinExecution.run base front fill outer inner copy
        (RepresentationKeys.read I F P .direct right₁) (RepresentationKeys.pairKey I F P .direct)
        (RepresentationKeys.read I F P (.complementary t) right₂)
        (RepresentationKeys.pairKey I F P (.complementary t)) CountedParentJoin.cells
        (StoredEntry.report I C (CountedRepresentationEmit.emit I F))
        (CountedParentJoin.snapshot I F P (.complementary t) right₂) B fuel₁ fuel₂ control st budget := by
  rw [run, BudgetedStoppedCells.run_value]
  have he : (fun (s : State I F P t right₁ right₂ d₁ d₂ C) (b : ℕ) =>
      (RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ s b).1) =
      BudgetedStreamStep.execute base front fill outer inner copy
        (RepresentationKeys.read I F P .direct right₁) (RepresentationKeys.pairKey I F P .direct)
        (RepresentationKeys.read I F P (.complementary t) right₂)
        (RepresentationKeys.pairKey I F P (.complementary t)) CountedParentJoin.cells
        (StoredEntry.report I C (CountedRepresentationEmit.emit I F))
        (CountedParentJoin.snapshot I F P (.complementary t) right₂) B fuel₁ fuel₂ := by
    funext s b
    exact RepresentationStepCells.run_value I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ s b
  rw [he]
private theorem scale (u C : ℕ) (hu : 10000 ≤ u) :
    2 * (400 * u * (C + 1)) + u ^ 10 * (C + 1) + 32 ≤ u ^ 11 * (C + 1) := by
  have hp : u ≤ u ^ 10 := by
    simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 1 ≤ u) (by decide : 1 ≤ 10)
  have h1 : 1 ≤ u ^ 10 := Nat.one_le_pow _ _ (by omega)
  have hq : 833 * u ^ 10 ≤ u ^ 11 := by
    calc
      _ ≤ u * u ^ 10 := Nat.mul_le_mul_right _ (by omega)
      _ = _ := (pow_succ' _ _).symm
  have hs : 800 * u + u ^ 10 + 32 ≤ u ^ 11 := by omega
  have hm := Nat.mul_le_mul_right (C + 1) hs
  nlinarith only [hm]

theorem run_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
    (st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) (hn : 10000 ≤ n)
    (hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
    (ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C) :
    (run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ control st budget).2 ≤
      inputScale I ^ 11 * (C + 1) := by
  have h := BudgetedStoppedCells.run_cells
    (RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂)
    ParentLiveState.frame (400 * inputScale I * (C + 1)) (inputScale I ^ 10 * (C + 1))
    (fun s => ParentLiveBounds.frame_le I F P t C right₁ right₂ s ht₁ ht₂)
    (fun s b => RepresentationStepCells.run_cells I F P t right₁ right₂ C base front fill outer inner copy
      B fuel₁ fuel₂ s b hn hd₁ hd₂ ht₁ ht₂ hB) control st budget
  exact h.trans (scale _ _ (by unfold inputScale; omega))

def parent (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
    (s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :=
  let charge := inputScale I ^ 6
  run I F P t right₁ right₂ C charge charge charge charge charge B B fuel₁ fuel₂ control
    (StreamJoin.start s₁ s₂ (StoredEntry.empty I C)) budget

theorem parent_value (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
    (s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :
    (parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget).1 =
      BudgetedParentJoin.run I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget :=
  run_value I F P t right₁ right₂ C _ _ _ _ _ _ _ _ _ _ _ _

theorem parent_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
    (right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
    (s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) (hn : 10000 ≤ n)
    (hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
    (ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C) :
    (parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget).2 ≤ inputScale I ^ 11 * (C + 1) :=
  run_cells I F P t right₁ right₂ C _ _ _ _ _ _ _ _ _ _ _ _ hn hd₁ hd₂ ht₁ ht₂ hB

/-- Explicitly shared arrays are retained once throughout the stopped execution. -/
def withArrays (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
    (left₁ right₁ left₂ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
    (s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :=
  let out := parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget
  (out.1, out.2 + ParentLiveState.sharedArrays left₁ right₁ + ParentLiveState.sharedArrays left₂ right₂ + 16)

theorem withArrays_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
    (left₁ right₁ left₂ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
    (fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
    (s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) (hn : 10000 ≤ n)
    (hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
    (ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C)
    (hl₁ : left₁.size ≤ C) (hr₁ : right₁.size ≤ C) (hl₂ : left₂.size ≤ C) (hr₂ : right₂.size ≤ C) :
    (withArrays I F P t C B left₁ right₁ left₂ right₂ fuel₁ fuel₂ control s₁ s₂ budget).2 ≤
      inputScale I ^ 12 * (C + 1) := by
  have hp := parent_cells I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget hn hd₁ hd₂ ht₁ ht₂ hB
  have ha := ParentLiveBounds.shared_le I C left₁ right₁ hl₁ hr₁
  have hb := ParentLiveBounds.shared_le I C left₂ right₂ hl₂ hr₂
  have hu : 10000 ≤ inputScale I := by unfold inputScale; omega
  have hx : 16 * inputScale I + 16 ≤ inputScale I ^ 11 := by
    have hp : inputScale I ≤ inputScale I ^ 10 := by
      simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 1 ≤ inputScale I) (by decide : 1 ≤ 10)
    have hq : 32 * inputScale I ^ 10 ≤ inputScale I ^ 11 := by
      calc
        _ ≤ inputScale I * inputScale I ^ 10 := Nat.mul_le_mul_right _ (by omega)
        _ = _ := (pow_succ' _ _).symm
    omega
  have hmul : 2 * inputScale I ^ 11 ≤ inputScale I ^ 12 := by
    calc
      _ ≤ inputScale I * inputScale I ^ 11 := Nat.mul_le_mul_right _ (by omega)
      _ = _ := (pow_succ' _ _).symm
  have hfinal := Nat.mul_le_mul_right (C + 1) hmul
  have hsmall := Nat.mul_le_mul_right (C + 1) hx
  change _ + _ + _ + 16 ≤ _
  nlinarith only [hp, ha, hb, hsmall, hfinal]

end LowSpaceSubsetSum.RepresentationJoinCells

end OAI

	import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationStepCells
	import OAI.Combinatorics.LowSpaceSubsetSum.Storage.BudgetedStoppedCells

	namespace OAI

	/-! # Live cells of the complete prepaid parent join

	The stopped driver keeps a single current state. Each iteration includes its
	concrete reader, key, tie-buffer, snapshot and dictionary trace. Immutable
	leaf arrays are retained once by the outer wrapper.
	-/

	namespace LowSpaceSubsetSum.RepresentationJoinCells

	variable {n : ℕ}

	open RepresentationStepCells (State)

	def run (I : Instance n) (F : IndexedMask n) (P t : ℤ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
	(st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) :=
	BudgetedStoppedCells.run
	(RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂)
	ParentLiveState.frame control st budget

	theorem run_value (I : Instance n) (F : IndexedMask n) (P t : ℤ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
	(st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) :
	(run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ control st budget).1 =
	BudgetedJoinExecution.run base front fill outer inner copy
	(RepresentationKeys.read I F P .direct right₁) (RepresentationKeys.pairKey I F P .direct)
	(RepresentationKeys.read I F P (.complementary t) right₂)
	(RepresentationKeys.pairKey I F P (.complementary t)) CountedParentJoin.cells
	(StoredEntry.report I C (CountedRepresentationEmit.emit I F))
	(CountedParentJoin.snapshot I F P (.complementary t) right₂) B fuel₁ fuel₂ control st budget := by
	rw [run, BudgetedStoppedCells.run_value]
	have he : (fun (s : State I F P t right₁ right₂ d₁ d₂ C) (b : ℕ) =>
	(RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ s b).1) =
	BudgetedStreamStep.execute base front fill outer inner copy
	(RepresentationKeys.read I F P .direct right₁) (RepresentationKeys.pairKey I F P .direct)
	(RepresentationKeys.read I F P (.complementary t) right₂)
	(RepresentationKeys.pairKey I F P (.complementary t)) CountedParentJoin.cells
	(StoredEntry.report I C (CountedRepresentationEmit.emit I F))
	(CountedParentJoin.snapshot I F P (.complementary t) right₂) B fuel₁ fuel₂ := by
	funext s b
	exact RepresentationStepCells.run_value I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ s b
	rw [he]

	private theorem scale (u C : ℕ) (hu : 10000 ≤ u) :
	2 * (400 * u * (C + 1)) + u ^ 10 * (C + 1) + 32 ≤ u ^ 11 * (C + 1) := by
	have hp : u ≤ u ^ 10 := by
	simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 1 ≤ u) (by decide : 1 ≤ 10)
	have h1 : 1 ≤ u ^ 10 := Nat.one_le_pow _ _ (by omega)
	have hq : 833 * u ^ 10 ≤ u ^ 11 := by
	calc
	_ ≤ u * u ^ 10 := Nat.mul_le_mul_right _ (by omega)
	_ = _ := (pow_succ' _ _).symm
	have hs : 800 * u + u ^ 10 + 32 ≤ u ^ 11 := by omega
	have hm := Nat.mul_le_mul_right (C + 1) hs
	nlinarith only [hm]

	theorem run_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(C base front fill outer inner copy B fuel₁ fuel₂ control : ℕ)
	(st : State I F P t right₁ right₂ d₁ d₂ C) (budget : ℕ) (hn : 10000 ≤ n)
	(hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
	(ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C) :
	(run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂ control st budget).2 ≤
	inputScale I ^ 11 * (C + 1) := by
	have h := BudgetedStoppedCells.run_cells
	(RepresentationStepCells.run I F P t right₁ right₂ C base front fill outer inner copy B fuel₁ fuel₂)
	ParentLiveState.frame (400 * inputScale I * (C + 1)) (inputScale I ^ 10 * (C + 1))
	(fun s => ParentLiveBounds.frame_le I F P t C right₁ right₂ s ht₁ ht₂)
	(fun s b => RepresentationStepCells.run_cells I F P t right₁ right₂ C base front fill outer inner copy
	B fuel₁ fuel₂ s b hn hd₁ hd₂ ht₁ ht₂ hB) control st budget
	exact h.trans (scale _ _ (by unfold inputScale; omega))

	def parent (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
	(s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :=
	let charge := inputScale I ^ 6
	run I F P t right₁ right₂ C charge charge charge charge charge B B fuel₁ fuel₂ control
	(StreamJoin.start s₁ s₂ (StoredEntry.empty I C)) budget

	theorem parent_value (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
	(s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :
	(parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget).1 =
	BudgetedParentJoin.run I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget :=
	run_value I F P t right₁ right₂ C _ _ _ _ _ _ _ _ _ _ _ _

	theorem parent_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
	(right₁ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
	(s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) (hn : 10000 ≤ n)
	(hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
	(ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C) :
	(parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget).2 ≤ inputScale I ^ 11 * (C + 1) :=
	run_cells I F P t right₁ right₂ C _ _ _ _ _ _ _ _ _ _ _ _ hn hd₁ hd₂ ht₁ ht₂ hB

	/-- Explicitly shared arrays are retained once throughout the stopped execution. -/
	def withArrays (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
	(left₁ right₁ left₂ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
	(s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) :=
	let out := parent I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget
	(out.1, out.2 + ParentLiveState.sharedArrays left₁ right₁ + ParentLiveState.sharedArrays left₂ right₂ + 16)

	theorem withArrays_cells (I : Instance n) (F : IndexedMask n) (P t : ℤ) (C B : ℕ)
	(left₁ right₁ left₂ right₂ : Array (LeafRecord n)) {d₁ d₂ : ℕ}
	(fuel₁ fuel₂ control : ℕ) (s₁ : RepresentationGroupCells.Left I F P right₁ d₁)
	(s₂ : RepresentationGroupCells.Right I F P t right₂ d₂) (budget : ℕ) (hn : 10000 ≤ n)
	(hd₁ : d₁ ≤ n) (hd₂ : d₂ ≤ n)
	(ht₁ : 2 ^ (d₁ + 1) ≤ 4 * (C + 1)) (ht₂ : 2 ^ (d₂ + 1) ≤ 4 * (C + 1)) (hB : B ≤ C)
	(hl₁ : left₁.size ≤ C) (hr₁ : right₁.size ≤ C) (hl₂ : left₂.size ≤ C) (hr₂ : right₂.size ≤ C) :
	(withArrays I F P t C B left₁ right₁ left₂ right₂ fuel₁ fuel₂ control s₁ s₂ budget).2 ≤
	inputScale I ^ 12 * (C + 1) := by
	have hp := parent_cells I F P t C B right₁ right₂ fuel₁ fuel₂ control s₁ s₂ budget hn hd₁ hd₂ ht₁ ht₂ hB
	have ha := ParentLiveBounds.shared_le I C left₁ right₁ hl₁ hr₁
	have hb := ParentLiveBounds.shared_le I C left₂ right₂ hl₂ hr₂
	have hu : 10000 ≤ inputScale I := by unfold inputScale; omega
	have hx : 16 * inputScale I + 16 ≤ inputScale I ^ 11 := by
	have hp : inputScale I ≤ inputScale I ^ 10 := by
	simpa only [pow_one] using Nat.pow_le_pow_right (by omega : 1 ≤ inputScale I) (by decide : 1 ≤ 10)
	have hq : 32 * inputScale I ^ 10 ≤ inputScale I ^ 11 := by
	calc
	_ ≤ inputScale I * inputScale I ^ 10 := Nat.mul_le_mul_right _ (by omega)
	_ = _ := (pow_succ' _ _).symm
	omega
	have hmul : 2 * inputScale I ^ 11 ≤ inputScale I ^ 12 := by
	calc
	_ ≤ inputScale I * inputScale I ^ 11 := Nat.mul_le_mul_right _ (by omega)
	_ = _ := (pow_succ' _ _).symm
	have hfinal := Nat.mul_le_mul_right (C + 1) hmul
	have hsmall := Nat.mul_le_mul_right (C + 1) hx
	change _ + _ + _ + 16 ≤ _
	nlinarith only [hp, ha, hb, hsmall, hfinal]

	end LowSpaceSubsetSum.RepresentationJoinCells

	end OAI