File size: 8,940 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 | 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
|