| import OAI.Probability.MatroidProphet.BatchReveal |
| import OAI.Probability.MatroidProphet.Reverse.Paths |
| import Mathlib.Data.List.Nodup |
| import Mathlib.Data.List.Range |
|
|
| namespace OAI |
|
|
| namespace MatroidProphet |
| open Finset |
| variable {α : Type*} [Fintype α] [DecidableEq α] |
| attribute [local instance] Classical.propDecidable |
|
|
| structure ReverseLayer (α : Type*) where |
| group : Finset α |
| density : Set α |
| state : Set α |
| enabledAt : ℤ |
|
|
| noncomputable def layerNominal (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (L : ReverseLayer α) (A : Set α) : Set α := |
| densityEnabled M hE κ L.density L.enabledAt k A |
|
|
| noncomputable def layerBatch (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (L : ReverseLayer α) (A : Set α) : Finset α := |
| L.group.filter (fun e => e ∈ L.state ∧ e ∉ layerNominal M hE κ k L A) |
|
|
| noncomputable def layerUpdate (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (L : ReverseLayer α) (A : Set α) (C : Finset α) : Set α := |
| M.closure (layerNominal M hE κ k L A ∪ ((C : Set α) ∩ (L.group : Set α) ∩ L.state)) |
|
|
| lemma layerUpdate_eq_batch (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (L : ReverseLayer α) (A : Set α) (C : Finset α) : |
| layerUpdate M hE κ k L A C = |
| M.closure (layerNominal M hE κ k L A ∪ (C ∩ layerBatch M hE κ k L A : Finset α)) := by |
| unfold layerUpdate |
| congr 1 |
| ext e |
| simp only [layerBatch, Set.mem_union, Set.mem_inter_iff, mem_coe, mem_inter, mem_filter] |
| tauto |
|
|
| noncomputable def runReverseLayers (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) : List (ReverseLayer α) → Set α → Finset α → Set α |
| | [], A, _ => A |
| | L::Ls, A, C => runReverseLayers M hE κ k Ls (layerUpdate M hE κ k L A C) C |
|
|
| noncomputable def reverseExposureTree (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) : List (ReverseLayer α) → Set α → RevealTree α (Set α) |
| | [], A => .leaf A |
| | L::Ls, A => |
| revealBatch (layerBatch M hE κ k L A).toList (fun I => |
| reverseExposureTree M hE κ k Ls (M.closure (layerNominal M hE κ k L A ∪ (I : Set α)))) |
|
|
| lemma reverseExposureTree_fresh (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) |
| (hdisj : Ls.Pairwise (fun L L' => Disjoint L.group L'.group)) |
| (V : Finset α) (hV : ∀ L ∈ Ls, (L.group.filter (fun e => e ∈ L.state)) ⊆ V) (A : Set α) : |
| (reverseExposureTree M hE κ k Ls A).Fresh V := by |
| induction Ls generalizing V A with |
| | nil => trivial |
| | cons L Ls ih => |
| rw [List.pairwise_cons] at hdisj |
| apply revealBatch_fresh _ (nodup_toList _) _ V |
| · simp only [toList_toFinset] |
| intro e he |
| exact hV L (by simp) (mem_filter.mpr ⟨(mem_filter.mp he).1, (mem_filter.mp he).2.1⟩) |
| · intro I hI |
| simp only [toList_toFinset] |
| apply ih hdisj.2 |
| intro L' hL' e he |
| refine mem_sdiff.mpr ⟨hV L' (by simp [hL']) he, ?_⟩ |
| intro hb |
| have heL := (mem_filter.mp hb).1 |
| exact Finset.disjoint_left.mp (hdisj.1 L' hL') heL (mem_filter.mp he).1 |
|
|
| lemma layerUpdate_congr (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (L : ReverseLayer α) (A : Set α) (C C' : Finset α) |
| (hC : ∀ e ∈ L.group, (e ∈ C ↔ e ∈ C')) : |
| layerUpdate M hE κ k L A C = layerUpdate M hE κ k L A C' := by |
| unfold layerUpdate |
| congr 1 |
| ext e |
| by_cases heG : e ∈ L.group |
| · simp only [Set.mem_union, Set.mem_inter_iff, mem_coe, hC e heG] |
| · simp [heG] |
|
|
| lemma runReverseLayers_congr (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) (A : Set α) (C C' : Finset α) |
| (hC : ∀ L ∈ Ls, ∀ e ∈ L.group, (e ∈ C ↔ e ∈ C')) : |
| runReverseLayers M hE κ k Ls A C = runReverseLayers M hE κ k Ls A C' := by |
| induction Ls generalizing A with |
| | nil => rfl |
| | cons L Ls ih => |
| rw [runReverseLayers, runReverseLayers, layerUpdate_congr M hE κ k L A C C' (hC L (by simp))] |
| exact ih _ (fun L' hL' => hC L' (by simp [hL'])) |
|
|
| lemma reverseExposureTree_run (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) |
| (hdisj : Ls.Pairwise (fun L L' => Disjoint L.group L'.group)) |
| (A : Set α) (C : Finset α) : |
| (reverseExposureTree M hE κ k Ls A).run C = runReverseLayers M hE κ k Ls A C := by |
| induction Ls generalizing A C with |
| | nil => rfl |
| | cons L Ls ih => |
| rw [List.pairwise_cons] at hdisj |
| rw [reverseExposureTree, revealBatch_run _ (nodup_toList _)] |
| simp only [toList_toFinset] |
| rw [ih hdisj.2, ← layerUpdate_eq_batch, runReverseLayers] |
| apply runReverseLayers_congr |
| intro L' hL' e he |
| have heB : e ∉ layerBatch M hE κ k L A := by |
| intro hb |
| exact Finset.disjoint_left.mp (hdisj.1 L' hL') (mem_filter.mp hb).1 he |
| simp [heB] |
|
|
| theorem reverseExposure_hybrid_independent (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) |
| (hdisj : Ls.Pairwise (fun L L' => Disjoint L.group L'.group)) |
| (V : Finset α) (hV : ∀ L ∈ Ls, (L.group.filter (fun e => e ∈ L.state)) ⊆ V) (A : Set α) |
| (q : α → ℝ) (φ : Set α → ℝ) (ψ : Finset α → ℝ) : |
| bitsExpectation q V (fun C => bitsExpectation q V (fun T => |
| φ (runReverseLayers M hE κ k Ls A C) * |
| ψ ((reverseExposureTree M hE κ k Ls A).hybrid C T))) = |
| bitsExpectation q V (fun C => φ (runReverseLayers M hE κ k Ls A C)) * |
| bitsExpectation q V ψ := by |
| have h := (reverseExposureTree M hE κ k Ls A).hybrid_independent q V |
| (reverseExposureTree_fresh M hE κ k Ls hdisj V hV A) φ ψ |
| simpa only [reverseExposureTree_run M hE κ k Ls hdisj] using h |
|
|
| omit [DecidableEq α] in |
| lemma runReverseLayers_append (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls Ls' : List (ReverseLayer α)) (A : Set α) (C : Finset α) : |
| runReverseLayers M hE κ k (Ls ++ Ls') A C = |
| runReverseLayers M hE κ k Ls' (runReverseLayers M hE κ k Ls A C) C := by |
| induction Ls generalizing A with |
| | nil => rfl |
| | cons L Ls ih => exact ih _ |
|
|
| def sourceLayer (D S : ℕ → Set α) (G : ℕ → Finset α) (j : ℕ) : ReverseLayer α := |
| ⟨G j, D j, S j, activation j⟩ |
|
|
| def sourceLayers (D S : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) : List (ReverseLayer α) := |
| (List.range n).map (sourceLayer D S G) |
|
|
| omit [Fintype α] [DecidableEq α] in |
| lemma sourceLayers_pairwise (D S : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) |
| (hG : Pairwise (fun i j => Disjoint (G i) (G j))) : |
| (sourceLayers D S G n).Pairwise (fun L L' => Disjoint L.group L'.group) := by |
| rw [sourceLayers, List.pairwise_map] |
| exact (List.nodup_range (n := n)).pairwise_of_forall_ne (fun _ _ _ _ hij => hG hij) |
|
|
| omit [DecidableEq α] in |
| lemma runReverseLayers_source (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (D S : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (C : Finset α) : |
| runReverseLayers M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) C = |
| reversePrefix M hE κ D (fun j => (C : Set α) ∩ (G j : Set α)) S k n := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| simp only [sourceLayers, List.range_succ, List.map_append, List.map_cons, List.map_nil, |
| runReverseLayers_append] |
| change layerUpdate M hE κ k (sourceLayer D S G n) |
| (runReverseLayers M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) C) C = _ |
| rw [ih] |
| rfl |
|
|
| theorem source_reverse_hybrid_independent (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (D S : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) |
| (hG : Pairwise (fun i j => Disjoint (G i) (G j))) |
| (V : Finset α) (hV : ∀ j < n, (G j).filter (fun e => e ∈ S j) ⊆ V) |
| (q : α → ℝ) (φ : Set α → ℝ) (ψ : Finset α → ℝ) : |
| let tree := reverseExposureTree M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) |
| bitsExpectation q V (fun C => bitsExpectation q V (fun T => |
| φ (reversePrefix M hE κ D (fun j => (C : Set α) ∩ (G j : Set α)) S k n) * |
| ψ (tree.hybrid C T))) = |
| bitsExpectation q V (fun C => |
| φ (reversePrefix M hE κ D (fun j => (C : Set α) ∩ (G j : Set α)) S k n)) * |
| bitsExpectation q V ψ := by |
| dsimp only |
| have hv : ∀ L ∈ sourceLayers D S G n, L.group.filter (fun e => e ∈ L.state) ⊆ V := by |
| intro L hL |
| obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hL |
| exact hV j (List.mem_range.mp hj) |
| have h := reverseExposure_hybrid_independent M hE κ k (sourceLayers D S G n) |
| (sourceLayers_pairwise D S G n hG) V hv |
| (if k < 0 then M.closure ∅ else Set.univ) q φ ψ |
| simpa only [runReverseLayers_source] using h |
|
|
| noncomputable def queriedReverseLayers (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) : List (ReverseLayer α) → Set α → Finset α → Finset α |
| | [], _, _ => ∅ |
| | L::Ls, A, C => layerBatch M hE κ k L A ∪ |
| queriedReverseLayers M hE κ k Ls (layerUpdate M hE κ k L A C) C |
|
|
| lemma queriedReverseLayers_congr (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) (A : Set α) (C C' : Finset α) |
| (hC : ∀ L ∈ Ls, ∀ e ∈ L.group, (e ∈ C ↔ e ∈ C')) : |
| queriedReverseLayers M hE κ k Ls A C = queriedReverseLayers M hE κ k Ls A C' := by |
| induction Ls generalizing A with |
| | nil => rfl |
| | cons L Ls ih => |
| rw [queriedReverseLayers, queriedReverseLayers, |
| layerUpdate_congr M hE κ k L A C C' (hC L (by simp))] |
| congr 1 |
| exact ih _ (fun L' hL' => hC L' (by simp [hL'])) |
|
|
| lemma reverseExposureTree_queried (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls : List (ReverseLayer α)) |
| (hdisj : Ls.Pairwise (fun L L' => Disjoint L.group L'.group)) |
| (A : Set α) (C : Finset α) : |
| (reverseExposureTree M hE κ k Ls A).queried C = queriedReverseLayers M hE κ k Ls A C := by |
| induction Ls generalizing A C with |
| | nil => rfl |
| | cons L Ls ih => |
| rw [List.pairwise_cons] at hdisj |
| rw [reverseExposureTree, revealBatch_queried _ (nodup_toList _)] |
| simp only [toList_toFinset] |
| rw [ih hdisj.2, ← layerUpdate_eq_batch, queriedReverseLayers] |
| congr 1 |
| apply queriedReverseLayers_congr |
| intro L' hL' e he |
| have heB : e ∉ layerBatch M hE κ k L A := by |
| intro hb |
| exact Finset.disjoint_left.mp (hdisj.1 L' hL') (mem_filter.mp hb).1 he |
| simp [heB] |
|
|
| lemma queriedReverseLayers_append (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (Ls Ls' : List (ReverseLayer α)) (A : Set α) (C : Finset α) : |
| queriedReverseLayers M hE κ k (Ls ++ Ls') A C = queriedReverseLayers M hE κ k Ls A C ∪ |
| queriedReverseLayers M hE κ k Ls' (runReverseLayers M hE κ k Ls A C) C := by |
| induction Ls generalizing A with |
| | nil => simp [queriedReverseLayers, runReverseLayers] |
| | cons L Ls ih => |
| simp only [List.cons_append, queriedReverseLayers, runReverseLayers, ih, union_assoc] |
|
|
| lemma queriedReverseLayers_source (M : Matroid α) (hE : M.E = Set.univ) |
| (κ : ℕ) (k : ℤ) (D S : ℕ → Set α) (G : ℕ → Finset α) (n : ℕ) (C : Finset α) : |
| queriedReverseLayers M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) C = |
| (Finset.range n).biUnion (fun j => (G j).filter (fun e => e ∈ S j ∧ |
| e ∉ reverseNominal M hE κ D (fun i => (C : Set α) ∩ (G i : Set α)) S k j)) := by |
| induction n with |
| | zero => simp [sourceLayers, queriedReverseLayers] |
| | succ n ih => |
| simp only [sourceLayers, List.range_succ, List.map_append, List.map_cons, List.map_nil, |
| queriedReverseLayers_append] |
| change queriedReverseLayers M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) C ∪ |
| (layerBatch M hE κ k (sourceLayer D S G n) |
| (runReverseLayers M hE κ k (sourceLayers D S G n) |
| (if k < 0 then M.closure ∅ else Set.univ) C) ∪ ∅) = _ |
| rw [ih, runReverseLayers_source] |
| simp only [union_empty, Finset.range_add_one, biUnion_insert] |
| rw [union_comm] |
| rfl |
|
|
| end MatroidProphet |
|
|
| end OAI |
|
|
