File size: 7,443 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 | import OAI.Combinatorics.EditApproximation.Queries.QuerySourceWidths
import OAI.Combinatorics.EditApproximation.Queries.QueryRestrictionCost
namespace OAI
namespace EditApproximation
section Body
variable {σ : Type*} {M J n : ℕ} (passes copies T S : ℕ)
(parent : {r : PhysicalTableRequest M J n // r.Bounded passes copies T S})
abbrev QueryBoundedChild := Sum σ {child : {r : PhysicalTableRequest M J n //
r.Bounded passes copies T S} // child.val.combinedRank T S < parent.val.combinedRank T S}
def queryRestrictedPhysicalOracle (oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction) :
QueryPhysicalChild (σ := σ) passes copies T S parent → BinaryFraction :=
BitQuery.restrictedOracle _ (querySupportedChildWithWork passes copies T S parent)
(querySupportedChildWithWork_value passes copies T S parent)
(fun key => oracle (SourceRanked.supportedChildMap (PhysicalTableRequest.combinedRank T S)
(PhysicalTableRequest.Bounded passes copies T S) parent key))
def queryRestrictedPhysicalReadWork (readWork : QueryBoundedChild (σ := σ) passes copies T S parent → ℕ) :
QueryPhysicalChild (σ := σ) passes copies T S parent → ℕ :=
BitQuery.restrictedReadWork _ (querySupportedChildWithWork passes copies T S parent)
(querySupportedChildWithWork_value passes copies T S parent)
(fun key => 1 + readWork (SourceRanked.supportedChildMap (PhysicalTableRequest.combinedRank T S)
(PhysicalTableRequest.Bounded passes copies T S) parent key))
theorem queryRestrictPhysicalBody_work
(program : BitQuery (QueryPhysicalChild (σ := σ) passes copies T S parent) BinaryFraction)
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction)
(readWork : QueryBoundedChild (σ := σ) passes copies T S parent → ℕ) :
(queryRestrictPhysicalBody passes copies T S parent program).work oracle readWork =
program.work (queryRestrictedPhysicalOracle passes copies T S parent oracle)
(queryRestrictedPhysicalReadWork passes copies T S parent readWork) := by
rw [queryRestrictPhysicalBody, BitQuery.mapKeysWithWork_work, BitQuery.restrictWithWork_work]
rfl
theorem queryRestrictPhysicalBody_value
(program : BitQuery (QueryPhysicalChild (σ := σ) passes copies T S parent) BinaryFraction)
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction) :
(queryRestrictPhysicalBody passes copies T S parent program).value oracle =
program.value (queryRestrictedPhysicalOracle passes copies T S parent oracle) := by
rw [queryRestrictPhysicalBody, BitQuery.mapKeysWithWork_value, BitQuery.restrictWithWork_value]
rfl
theorem queryRestrictedPhysicalOracle_table_width
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction)
(B : ℕ) (hB : 2 ≤ B) (hw : ∀ key, (oracle (Sum.inr key)).width ≤ B) (child) :
(queryRestrictedPhysicalOracle passes copies T S parent oracle (Sum.inr child)).width ≤ B := by
unfold queryRestrictedPhysicalOracle BitQuery.restrictedOracle
split
· exact hw _
· exact (BinaryFraction.nat_width_le 0).trans (by simpa only [Nat.size_zero, Nat.zero_add] using hB)
theorem queryRestrictedPhysicalOracle_table_nonneg
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction)
(hn : ∀ key, 0 ≤ (oracle (Sum.inr key)).value) (child) :
0 ≤ (queryRestrictedPhysicalOracle passes copies T S parent oracle (Sum.inr child)).value := by
unfold queryRestrictedPhysicalOracle BitQuery.restrictedOracle
split
· exact hn _
· simp only [BinaryFraction.nat_value, Nat.cast_zero, le_refl]
theorem queryRestrictedPhysicalOracle_width
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction)
(B : ℕ) (hB : 2 ≤ B) (hw : ∀ key, (oracle key).width ≤ B) (key) :
(queryRestrictedPhysicalOracle passes copies T S parent oracle key).width ≤ B :=
BitQuery.restrictedOracle_width _ _ _ _ B hB (fun _ => hw _) key
@[simp] theorem queryRestrictedPhysicalOracle_source
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction) (source : σ) :
queryRestrictedPhysicalOracle passes copies T S parent oracle (Sum.inl source) = oracle (Sum.inl source) := rfl
theorem queryRestrictedPhysicalOracle_table
(oracle : QueryBoundedChild (σ := σ) passes copies T S parent → BinaryFraction)
(child : {r : PhysicalTableRequest M J n // r.combinedRank T S < parent.val.combinedRank T S})
(hb : child.val.Bounded passes copies T S) :
queryRestrictedPhysicalOracle passes copies T S parent oracle (Sum.inr child) =
oracle (Sum.inr ⟨⟨child.val, hb⟩, child.property⟩) := by
unfold queryRestrictedPhysicalOracle BitQuery.restrictedOracle
rw [dite_eq_left ((querySupportedChildWithWork_value passes copies T S parent (Sum.inr child)).mpr hb)]
rfl
private theorem index_le_combinedRank (request : PhysicalTableRequest M J n) :
request.index ≤ request.combinedRank T S := by
unfold PhysicalTableRequest.combinedRank PhysicalTableRequest.rank
omega
private theorem pass_le_combinedRank (request : PhysicalTableRequest M J n) :
request.pass ≤ request.combinedRank T S := by
have hmul : request.pass ≤ request.pass * (T + S + 1) := Nat.le_mul_of_pos_right _ (by omega)
unfold PhysicalTableRequest.combinedRank PhysicalTableRequest.rank
omega
theorem queryRestrictedPhysicalReadWork_bound
(readWork : QueryBoundedChild (σ := σ) passes copies T S parent → ℕ) (B W : ℕ)
(hp : Nat.size passes ≤ B) (hc : Nat.size copies ≤ B) (hT : Nat.size T ≤ B) (hS : Nat.size S ≤ B)
(hr : Nat.size (parent.val.combinedRank T S) ≤ B) (hcopy : Nat.size parent.val.copy ≤ B)
(hW : ∀ key, readWork key ≤ W)
(key : QueryPhysicalChild (σ := σ) passes copies T S parent)
(hk : ∀ child, key = Sum.inr child → child.val.copy = parent.val.copy) :
queryRestrictedPhysicalReadWork passes copies T S parent readWork key ≤ 50 * B + 21 + W := by
have hread (k) := hW (SourceRanked.supportedChildMap (PhysicalTableRequest.combinedRank T S)
(PhysicalTableRequest.Bounded passes copies T S) parent k)
cases key with
| inl source =>
change 1 + (1 + readWork _) ≤ _
have := hread ⟨Sum.inl source, trivial⟩
omega
| inr child =>
have hpass : Nat.size child.val.pass ≤ B :=
(Nat.size_le_size ((pass_le_combinedRank T S child.val).trans child.property.le)).trans hr
have hindex : Nat.size child.val.index ≤ B :=
(Nat.size_le_size ((index_le_combinedRank T S child.val).trans child.property.le)).trans hr
have hcopy' : Nat.size child.val.copy ≤ B := by rw [hk child rfl]; exact hcopy
have hguard := queryPhysicalBoundedWithWork_cost passes copies T S B child.val hp hc hT hS hpass hcopy' hindex
unfold queryRestrictedPhysicalReadWork BitQuery.restrictedReadWork
change (querySupportedChildWithWork (σ := σ) passes copies T S parent (Sum.inr child)).2 ≤ 50 * B + 20 at hguard
by_cases hgate : (querySupportedChildWithWork (σ := σ) passes copies T S parent (Sum.inr child)).1 = true
· rw [dite_eq_left hgate]
dsimp only
have := hread ⟨Sum.inr child, (querySupportedChildWithWork_value passes copies T S parent _).mp hgate⟩
omega
· rw [dite_eq_right hgate]
omega
end Body
end EditApproximation
end OAI
|