| import OAI.Probability.MatroidProphet.AdaptiveResampling |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| open Finset |
| variable {α β γ : Type*} [DecidableEq α] |
|
|
| def RevealTree.map (f : β → γ) : RevealTree α β → RevealTree α γ |
| | .leaf b => .leaf (f b) |
| | .query e no yes => .query e (no.map f) (yes.map f) |
|
|
| lemma RevealTree.fresh_map (tree : RevealTree α β) (f : β → γ) (V : Finset α) : |
| (tree.map f).Fresh V ↔ tree.Fresh V := by |
| induction tree generalizing V with |
| | leaf b => rfl |
| | query e no yes ihn ihy => simp only [map, Fresh, ihn, ihy] |
|
|
| lemma RevealTree.run_map (tree : RevealTree α β) (f : β → γ) (S : Finset α) : |
| (tree.map f).run S = f (tree.run S) := by |
| induction tree generalizing S with |
| | leaf b => rfl |
| | query e no yes ihn ihy => |
| simp only [map, run] |
| split_ifs <;> simp_all |
|
|
| def revealBatch : List α → (Finset α → RevealTree α β) → RevealTree α β |
| | [], cont => cont ∅ |
| | e :: xs, cont => .query e (revealBatch xs cont) |
| (revealBatch xs (fun I => cont (insert e I))) |
|
|
| lemma erase_sdiff_eq_sdiff_insert (S X : Finset α) (e : α) : |
| S.erase e \ X = S \ insert e X := by |
| ext x |
| simp only [mem_sdiff, mem_erase, mem_insert] |
| tauto |
|
|
| lemma revealBatch_fresh (xs : List α) (hxs : xs.Nodup) |
| (cont : Finset α → RevealTree α β) (V : Finset α) |
| (hXV : xs.toFinset ⊆ V) |
| (hcont : ∀ I ⊆ xs.toFinset, (cont I).Fresh (V \ xs.toFinset)) : |
| (revealBatch xs cont).Fresh V := by |
| induction xs generalizing cont V with |
| | nil => simpa [revealBatch] using hcont ∅ (empty_subset _) |
| | cons e xs ih => |
| have heX : e ∉ xs.toFinset := by simpa using (List.nodup_cons.mp hxs).1 |
| have heV : e ∈ V := hXV (by simp) |
| have hsub : xs.toFinset ⊆ V.erase e := by |
| intro x hx |
| refine mem_erase.mpr ⟨?_, hXV (by simp [hx])⟩ |
| intro h; subst x; exact heX hx |
| have htail := (List.nodup_cons.mp hxs).2 |
| refine ⟨heV, ih htail cont (V.erase e) hsub ?_, |
| ih htail (fun I => cont (insert e I)) (V.erase e) hsub ?_⟩ |
| · intro I hI |
| rw [erase_sdiff_eq_sdiff_insert] |
| simpa only [List.toFinset_cons] using hcont I (by simpa using hI.trans (subset_insert e xs.toFinset)) |
| · intro I hI |
| rw [erase_sdiff_eq_sdiff_insert] |
| simpa only [List.toFinset_cons] using hcont (insert e I) (by simpa using insert_subset_insert e hI) |
|
|
| lemma revealBatch_run (xs : List α) (hxs : xs.Nodup) |
| (cont : Finset α → RevealTree α β) (S : Finset α) : |
| (revealBatch xs cont).run S = (cont (S ∩ xs.toFinset)).run (S \ xs.toFinset) := by |
| induction xs generalizing cont S with |
| | nil => simp [revealBatch] |
| | cons e xs ih => |
| have heX : e ∉ xs.toFinset := by simpa using (List.nodup_cons.mp hxs).1 |
| have htail := (List.nodup_cons.mp hxs).2 |
| have hinter : S.erase e ∩ xs.toFinset = S ∩ xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heX] |
| · simp [hx] |
| by_cases heS : e ∈ S |
| · rw [revealBatch, RevealTree.run, ite_eq_left heS, ih htail, |
| hinter, erase_sdiff_eq_sdiff_insert] |
| have hins : insert e (S ∩ xs.toFinset) = S ∩ insert e xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heS] |
| · simp [hx] |
| simp only [List.toFinset_cons, hins] |
| · rw [revealBatch, RevealTree.run, ite_eq_right heS, ih htail, |
| hinter, erase_sdiff_eq_sdiff_insert] |
| have hins : S ∩ xs.toFinset = S ∩ insert e xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heS] |
| · simp [hx] |
| simp only [List.toFinset_cons, hins] |
|
|
| lemma revealBatch_queried (xs : List α) (hxs : xs.Nodup) |
| (cont : Finset α → RevealTree α β) (S : Finset α) : |
| (revealBatch xs cont).queried S = |
| xs.toFinset ∪ (cont (S ∩ xs.toFinset)).queried (S \ xs.toFinset) := by |
| induction xs generalizing cont S with |
| | nil => simp [revealBatch] |
| | cons e xs ih => |
| have heX : e ∉ xs.toFinset := by simpa using (List.nodup_cons.mp hxs).1 |
| have htail := (List.nodup_cons.mp hxs).2 |
| have hinter : S.erase e ∩ xs.toFinset = S ∩ xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heX] |
| · simp [hx] |
| by_cases heS : e ∈ S |
| · rw [revealBatch, RevealTree.queried, ite_eq_left heS, ih htail, |
| hinter, erase_sdiff_eq_sdiff_insert] |
| have hins : insert e (S ∩ xs.toFinset) = S ∩ insert e xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heS] |
| · simp [hx] |
| simp only [List.toFinset_cons, hins, insert_union] |
| · rw [revealBatch, RevealTree.queried, ite_eq_right heS, ih htail, |
| hinter, erase_sdiff_eq_sdiff_insert] |
| have hins : S ∩ xs.toFinset = S ∩ insert e xs.toFinset := by |
| ext x |
| by_cases hx : x = e |
| · subst x; simp [heS] |
| · simp [hx] |
| simp only [List.toFinset_cons, hins, insert_union] |
|
|
| lemma RevealTree.queried_map (tree : RevealTree α β) (f : β → γ) (S : Finset α) : |
| (tree.map f).queried S = tree.queried S := by |
| induction tree generalizing S with |
| | leaf b => rfl |
| | query e no yes ihn ihy => |
| simp only [map, queried] |
| split_ifs <;> simp_all |
|
|
| lemma RevealTree.hybrid_map (tree : RevealTree α β) (f : β → γ) (S T : Finset α) : |
| (tree.map f).hybrid S T = tree.hybrid S T := by |
| induction tree generalizing S T with |
| | leaf b => rfl |
| | query e no yes ihn ihy => |
| simp only [map, hybrid, ihn, ihy] |
|
|
| structure RevealRecord (α β : Type*) where |
| value : β |
| queried : Finset α |
| positive : Finset α |
|
|
| def RevealTree.record : RevealTree α β → RevealTree α (RevealRecord α β) |
| | .leaf b => .leaf ⟨b, ∅, ∅⟩ |
| | .query e no yes => .query e |
| (no.record.map (fun r => ⟨r.value, insert e r.queried, r.positive⟩)) |
| (yes.record.map (fun r => ⟨r.value, insert e r.queried, insert e r.positive⟩)) |
|
|
| lemma RevealTree.record_fresh (tree : RevealTree α β) (V : Finset α) : |
| tree.record.Fresh V ↔ tree.Fresh V := by |
| induction tree generalizing V with |
| | leaf b => rfl |
| | query e no yes ihn ihy => simp only [record, Fresh, fresh_map, ihn, ihy] |
|
|
| lemma RevealTree.record_run (tree : RevealTree α β) (S : Finset α) : |
| tree.record.run S = ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ := by |
| induction tree generalizing S with |
| | leaf b => simp [record, run, queried] |
| | query e no yes ihn ihy => |
| by_cases heS : e ∈ S |
| · simp only [record, run, queried, ite_eq_left heS, run_map, ihy] |
| congr 1 |
| ext x |
| by_cases hxe : x = e |
| · subst x; simp [heS] |
| · simp [hxe] |
| · simp only [record, run, queried, ite_eq_right heS, run_map, ihn] |
| congr 1 |
| ext x |
| by_cases hxe : x = e |
| · subst x; simp [heS] |
| · simp [hxe] |
|
|
| lemma RevealTree.record_hybrid (tree : RevealTree α β) (S T : Finset α) : |
| tree.record.hybrid S T = tree.hybrid S T := by |
| induction tree generalizing S T with |
| | leaf b => rfl |
| | query e no yes ihn ihy => simp only [record, hybrid, hybrid_map, ihn, ihy] |
|
|
| lemma RevealTree.transcript_hybrid_independent (tree : RevealTree α β) |
| (q : α → ℝ) (V : Finset α) (fresh : tree.Fresh V) |
| (φ : RevealRecord α β → ℝ) (ψ : Finset α → ℝ) : |
| bitsExpectation q V (fun S => bitsExpectation q V (fun T => |
| φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ * ψ (tree.hybrid S T))) = |
| bitsExpectation q V (fun S => φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩) * |
| bitsExpectation q V ψ := by |
| have h := tree.record.hybrid_independent q V ((tree.record_fresh V).mpr fresh) φ ψ |
| simpa only [record_run, record_hybrid] using h |
|
|
| lemma RevealTree.transcript_freshness (tree : RevealTree α β) |
| (q : α → ℝ) (V Q : Finset α) (fresh : tree.Fresh V) |
| (φ : RevealRecord α β → ℝ) (ψ : Finset α → ℝ) |
| (support : ∀ r, r.queried ≠ Q → φ r = 0) : |
| bitsExpectation q V (fun S => |
| φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ * ψ (S \ Q)) = |
| bitsExpectation q V (fun S => φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩) * |
| bitsExpectation q V (fun S => ψ (S \ Q)) := by |
| have h := tree.transcript_hybrid_independent q V fresh φ (fun S => ψ (S \ Q)) |
| rw [← h] |
| apply bitsExpectation_congr |
| intro S hS |
| by_cases hQ : tree.queried S = Q |
| · have hhybrid (T : Finset α) (hT : T ⊆ V) : tree.hybrid S T \ Q = S \ Q := by |
| rw [tree.hybrid_eq_resample V S T fresh hS hT, hQ] |
| ext e |
| simp only [mem_sdiff, mem_union, mem_inter] |
| tauto |
| have hc : bitsExpectation q V (fun T => |
| φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ * ψ (tree.hybrid S T \ Q)) = |
| bitsExpectation q V (fun _ => |
| φ ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ * ψ (S \ Q)) := by |
| apply bitsExpectation_congr |
| intro T hT |
| rw [hhybrid T hT] |
| rw [hc, bitsExpectation_const] |
| · have hf := support ⟨tree.run S, tree.queried S, S ∩ tree.queried S⟩ hQ |
| simp only [hf, zero_mul, bitsExpectation_const] |
|
|
| lemma RevealTree.record_queried (tree : RevealTree α β) (S : Finset α) : |
| tree.record.queried S = tree.queried S := by |
| induction tree generalizing S with |
| | leaf b => rfl |
| | query e no yes ihn ihy => simp only [record, queried, queried_map, ihn, ihy] |
|
|
| end MatroidProphet |
|
|
| end OAI |
|
|
