File size: 7,612 Bytes
e63eb7f | 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 | import OAI.Combinatorics.EditApproximation.Refinement.ComputedChargedQueryBudget
import OAI.Combinatorics.EditApproximation.Queries.QueryDependencyCosts
import OAI.Combinatorics.EditApproximation.Geometry.DependencyWeightedWork
namespace OAI
/-! The dependency expansion is built from the charged evaluator's
executed requests. Its branching bounds therefore apply to actual lazy
evaluation, with coarse leaves at their original physical depths. -/
namespace EditApproximation
theorem chargedRequest_index_le {M J ny passes copies T S : ℕ}
(request : ChargedPhysicalRequest M J ny passes copies T S) :
request.index ≤ passes * (T + S + 1) := by
cases request with
| inl entry => exact Nat.zero_le _
| inr parent =>
have hp : parent.val.pass + 1 ≤ passes := parent.property.1
have hi : parent.val.index + 1 ≤ T + S + 1 := Nat.add_le_add_right parent.property.2.2 1
change parent.val.pass * (T + S + 1) + parent.val.index + 1 ≤ _
calc
_ ≤ (parent.val.pass + 1) * (T + S + 1) := by rw [Nat.add_mul, Nat.one_mul]; omega
_ ≤ _ := Nat.mul_le_mul_right _ hp
section Expansion
variable {α : Type*} [DecidableEq α] {M J R : ℕ} [NeZero R]
(source target : List α) (N P H T S passes copies : ℕ)
(factor : ℕ → ℚ) (multiplier : ℕ → ℕ) (tau eta kappa delta : ℚ)
(group : ℕ → ℕ → PhysicalInternalNode M J → Fin R →
CellGroupDraws M (inputSmallLog N) (inputSmallLog N ^ 80))
(integer : ℕ → ℕ → PhysicalInternalNode M J → Fin R → ℕ → TargetInterval target.length → ℕ)
(initial : PhysicalEntry M J target.length → ℕ)
local notation "program" => chargedGlobalQuery source target N P (inputSmallLog N)
(40 * smallLogExponent N) H (inputSmallLog N ^ 80) T S passes copies factor multiplier
tau eta kappa delta group integer initial
local notation "values" => chargedRequestValue source target N P (inputSmallLog N)
(40 * smallLogExponent N) H (inputSmallLog N ^ 80) T S passes copies factor multiplier
tau eta kappa delta group integer initial
local notation "depth" => @ChargedPhysicalRequest.depth M J target.length passes copies T S
local notation "index" => @ChargedPhysicalRequest.index M J target.length passes copies T S
theorem chargedRequestList_progress (root child : ChargedPhysicalRequest M J target.length passes copies T S)
(hchild : child ∈ queryRequestList depth index program root) :
(depth child < depth root ∧ index child ≤ index root) ∨
(depth child ≤ depth root ∧ index child < index root) := by
have hvalue := rankedProgramValue_eq ChargedPhysicalRequest.rank program values
(chargedGlobalQuery_value source target N P (inputSmallLog N) (40 * smallLogExponent N)
H (inputSmallLog N ^ 80) T S passes copies factor multiplier tau eta kappa delta group integer initial)
change child ∈ ((program root).keys
(fun key => rankedProgramValue ChargedPhysicalRequest.rank program key.val)).map Subtype.val at hchild
simp only [hvalue] at hchild
obtain ⟨key, hk, rfl⟩ := List.mem_map.mp hchild
exact chargedGlobalQuery_keys_progress source target N P (inputSmallLog N) (40 * smallLogExponent N)
H (inputSmallLog N ^ 80) T S passes copies factor multiplier tau eta kappa delta group integer initial root key hk
def chargedDependencyTree (root : ChargedPhysicalRequest M J target.length passes copies T S) :
DependencyExpansion :=
queryDependencyExpansion depth index program
(chargedRequestList_progress source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial) root
variable (hN : 0 < N) (hell : 200 ≤ inputSmallLog N)
(hM : M = (integerParameters N).M) (hP : P = (integerParameters N).P)
(hT : T = (integerParameters N).T) (hS : S = (integerParameters N).S)
(hcopies : copies ≤ inputHeight N ^ 2)
(hAmin : ∀ pass, 1 ≤ factor pass)
(hAmax : ∀ pass, factor pass ≤ ((integerParameters N).initialFactor : ℚ))
include hN hell hM hP hT hS hcopies hAmin hAmax in
theorem chargedDependencyTree_valid (root : ChargedPhysicalRequest M J target.length passes copies T S) :
(chargedDependencyTree source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial root).Valid
(M * inputSmallLog N ^ 257)
(inputHeight N ^ (512 * (coarseExponent (inputSmallLog N) + 1))) := by
apply queryDependencyExpansion_valid
· intro key
rw [querySameRequests_length_eq_cost depth index program values
(chargedGlobalQuery_value source target N P (inputSmallLog N) (40 * smallLogExponent N)
H (inputSmallLog N ^ 80) T S passes copies factor multiplier tau eta kappa delta group integer initial)]
have h := computed_chargedGlobalQuery_current_reads source target N P H T S passes copies
factor multiplier tau eta kappa delta group integer initial hN hell hM hAmax key
apply h.trans
calc
2 * M * inputSmallLog N ^ 256 ≤ inputSmallLog N * M * inputSmallLog N ^ 256 := by
gcongr
omega
_ = M * inputSmallLog N ^ 257 := by ring
· intro key
rw [queryEarlierRequests_length_eq_cost depth index program values
(chargedGlobalQuery_value source target N P (inputSmallLog N) (40 * smallLogExponent N)
H (inputSmallLog N ^ 80) T S passes copies factor multiplier tau eta kappa delta group integer initial)]
exact computed_chargedGlobalQuery_earlier_reads source target N P H T S passes copies
factor multiplier tau eta kappa delta group integer initial hN hell hM hAmax hP hT hS hcopies hAmin key
include hN hell hM hP hT hS hcopies hAmin hAmax in
theorem chargedDependencyTree_widthWork_le
(hJ : J = intervalTreeDepth M source.length)
(hpasses : passes = computedSeedPassCount N + 1)
(root : ChargedPhysicalRequest M J target.length passes copies T S)
(hroot : depth root = J) (overhead : ℝ) (hoverhead : 0 ≤ overhead)
(hpath : ∀ j ≤ intervalTreeDepth M source.length,
(dependencyPathBudget j (computedDependencyIndexCount N)
(M * inputSmallLog N ^ 257)
(inputHeight N ^ (512 * (coarseExponent (inputSmallLog N) + 1))) : ℝ) ≤
(M : ℝ) ^ j * overhead) :
((chargedDependencyTree source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial root).widthWork M source.length : ℝ) ≤
(((intervalTreeDepth M source.length + 1) * source.length +
4 * M * max 1 source.length : ℕ) : ℝ) * overhead := by
apply DependencyExpansion.widthWork_le M source.length _ _ (computedDependencyIndexCount N)
(by rw [hM]; exact (computed_branching_bounds N hN hell).1) _
(chargedDependencyTree_valid source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial hN hell hM hP hT hS hcopies hAmin hAmax root)
· exact (queryDependencyExpansion_depth depth index program
(chargedRequestList_progress source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial) root).trans (hroot.trans hJ)
· have hi := chargedRequest_index_le root
have hb : index root ≤ computedDependencyIndexCount N := by
apply hi.trans_eq
unfold computedDependencyIndexCount
rw [hpasses, hT, hS]
exact (queryDependencyExpansion_index depth index program
(chargedRequestList_progress source target N P H T S passes copies factor multiplier
tau eta kappa delta group integer initial) root).le.trans hb
· exact hoverhead
· exact hpath
end Expansion
end EditApproximation
end OAI
|