| import OAI.Combinatorics.GraphThreshold.ProbabilityTree |
| import OAI.Combinatorics.GraphThreshold.ResamplingEvents |
|
|
| namespace OAI |
|
|
| /-! Fixed-input local masses and the deterministic good-node predicate. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
| open Classical |
|
|
| namespace LeanBlast.SecondKahnKalai |
|
|
| section LocalMasses |
|
|
| variable {X B : Type*} [DecidableEq X] [Fintype B] |
|
|
| def successfulTargetMass (μ : FiniteLaw B) (A : B → Finset X) (ρ : ℝ) (m : ℕ) |
| (W : Finset X) (b : B) : ℝ := |
| ∑ c, if LocalSuccess μ A ρ m W c b then resamplingWeight μ A ρ W (c, b) else 0 |
|
|
| def localFailureMass (μ : FiniteLaw B) (A : B → Finset X) (ρ : ℝ) (m : ℕ) |
| (W : Finset X) : ℝ := |
| ∑ b, ∑ c, if LocalFailure μ A ρ m W c b then resamplingWeight μ A ρ W (c, b) else 0 |
|
|
| theorem successfulTargetMass_nonneg (μ : FiniteLaw B) (A : B → Finset X) |
| {ρ : ℝ} (hρ : 0 ≤ ρ) (m : ℕ) (W : Finset X) (b : B) : |
| 0 ≤ successfulTargetMass μ A ρ m W b := by |
| apply Finset.sum_nonneg |
| intro c _ |
| split_ifs |
| · exact resamplingWeight_nonneg μ A hρ W (c, b) |
| · exact le_rfl |
|
|
| theorem localFailureMass_nonneg (μ : FiniteLaw B) (A : B → Finset X) |
| {ρ : ℝ} (hρ : 0 ≤ ρ) (m : ℕ) (W : Finset X) : |
| 0 ≤ localFailureMass μ A ρ m W := by |
| apply Finset.sum_nonneg |
| intro b _ |
| apply Finset.sum_nonneg |
| intro c _ |
| split_ifs |
| · exact resamplingWeight_nonneg μ A hρ W (c, b) |
| · exact le_rfl |
|
|
| theorem localFailureMass_add_successfulTargetMass (μ : FiniteLaw B) |
| (A : B → Finset X) {ρ : ℝ} (hμ : μ.IsPositive) (hρ : 0 < ρ) |
| (m : ℕ) (W : Finset X) : |
| localFailureMass μ A ρ m W + ∑ b, successfulTargetMass μ A ρ m W b = 1 := by |
| classical |
| calc |
| _ = ∑ b, ∑ c, resamplingWeight μ A ρ W (c, b) := by |
| unfold localFailureMass successfulTargetMass LocalFailure |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro b _ |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro c _ |
| by_cases h : LocalSuccess μ A ρ m W c b <;> simp [h] |
| _ = ∑ c, ∑ b, resamplingWeight μ A ρ W (c, b) := Finset.sum_comm |
| _ = 1 := by |
| simp_rw [resampling_source_marginal μ A hμ hρ W] |
| exact μ.total |
|
|
| theorem localFailureMass_eq_prob (μ : FiniteLaw B) (A : B → Finset X) |
| {ρ : ℝ} (hμ : μ.IsPositive) (hρ : 0 < ρ) (m : ℕ) (W : Finset X) : |
| localFailureMass μ A ρ m W = |
| (resamplingLaw μ A ρ W hμ hρ).prob (fun cb => LocalFailure μ A ρ m W cb.1 cb.2) := by |
| classical |
| unfold localFailureMass FiniteLaw.prob |
| rw [Fintype.sum_prod_type] |
| rw [Finset.sum_comm] |
| rfl |
|
|
| theorem successfulTargetMass_pos_capacity (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) (W : Finset X) (b : B) |
| (hb : 0 < successfulTargetMass μ A ρ m W b) : (A b \ W).card ≤ m / 2 := by |
| by_contra hcap |
| have hfail (c : B) : ¬LocalSuccess μ A ρ m W c b := fun h => hcap h.2 |
| simp [successfulTargetMass, hfail] at hb |
|
|
| theorem resamplingZ_congr_fragments (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) {W V : Finset X} |
| (hWV : ∀ b, resamplingFragment A W b = resamplingFragment A V b) (c : B) : |
| resamplingZ μ A ρ (W ∪ A c) = resamplingZ μ A ρ (V ∪ A c) := by |
| unfold resamplingZ |
| apply Finset.sum_congr rfl |
| intro b _ |
| have hsub : A b ⊆ resamplingY A W c ↔ A b ⊆ resamplingY A V c := by |
| rw [resampling_target_subset_iff_fragment, resampling_target_subset_iff_fragment, hWV] |
| unfold resamplingNumerator |
| exact if_congr hsub rfl rfl |
|
|
| theorem localSuccess_congr_fragments (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) {W V : Finset X} |
| (hWV : ∀ b, resamplingFragment A W b = resamplingFragment A V b) (c b : B) : |
| LocalSuccess μ A ρ m W c b ↔ LocalSuccess μ A ρ m V c b := by |
| unfold LocalSuccess |
| rw [resamplingZ_congr_fragments μ A ρ hWV c] |
| change (_ ∧ (resamplingFragment A W b).card ≤ m / 2) ↔ |
| (_ ∧ (resamplingFragment A V b).card ≤ m / 2) |
| rw [hWV b] |
|
|
| theorem successfulTargetMass_congr_fragments (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) {W V : Finset X} |
| (hWV : ∀ b, resamplingFragment A W b = resamplingFragment A V b) (b : B) : |
| successfulTargetMass μ A ρ m W b = successfulTargetMass μ A ρ m V b := by |
| unfold successfulTargetMass |
| apply Finset.sum_congr rfl |
| intro c _ |
| by_cases h : LocalSuccess μ A ρ m W c b |
| · have hv := (localSuccess_congr_fragments μ A ρ m hWV c b).mp h |
| simp [h, hv, resamplingWeight_congr_fragments μ A ρ hWV] |
| · have hv : ¬LocalSuccess μ A ρ m V c b := |
| fun hv => h ((localSuccess_congr_fragments μ A ρ m hWV c b).mpr hv) |
| simp [h, hv] |
|
|
| theorem localFailureMass_congr_fragments (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) {W V : Finset X} |
| (hWV : ∀ b, resamplingFragment A W b = resamplingFragment A V b) : |
| localFailureMass μ A ρ m W = localFailureMass μ A ρ m V := by |
| unfold localFailureMass LocalFailure |
| apply Finset.sum_congr rfl |
| intro b _ |
| apply Finset.sum_congr rfl |
| intro c _ |
| by_cases h : LocalSuccess μ A ρ m W c b |
| · have hv := (localSuccess_congr_fragments μ A ρ m hWV c b).mp h |
| simp [h, hv] |
| · have hv : ¬LocalSuccess μ A ρ m V c b := |
| fun hv => h ((localSuccess_congr_fragments μ A ρ m hWV c b).mpr hv) |
| simp [h, hv, resamplingWeight_congr_fragments μ A ρ hWV] |
|
|
| theorem fragments_eq_of_inter_label_union_eq (A : B → Finset X) {W V : Finset X} |
| (hWV : W ∩ Finset.univ.biUnion A = V ∩ Finset.univ.biUnion A) (b : B) : |
| resamplingFragment A W b = resamplingFragment A V b := by |
| apply Finset.ext |
| intro x |
| by_cases hx : x ∈ A b |
| · have hxU : x ∈ Finset.univ.biUnion A := |
| Finset.mem_biUnion.mpr ⟨b, Finset.mem_univ b, hx⟩ |
| have hmem : x ∈ W ↔ x ∈ V := by |
| simpa only [Finset.mem_inter, hxU, and_true] using Finset.ext_iff.mp hWV x |
| simp [resamplingFragment, hx, hmem] |
| · simp [resamplingFragment, hx] |
|
|
| theorem successfulTargetMass_dependsOnlyOn (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) (b : B) : |
| DependsOnlyOn (Finset.univ.biUnion A) (fun W => successfulTargetMass μ A ρ m W b) := by |
| intro W V hWV |
| exact successfulTargetMass_congr_fragments μ A ρ m |
| (fragments_eq_of_inter_label_union_eq A hWV) b |
|
|
| theorem localFailureMass_dependsOnlyOn (μ : FiniteLaw B) (A : B → Finset X) |
| (ρ : ℝ) (m : ℕ) : |
| DependsOnlyOn (Finset.univ.biUnion A) (fun W => localFailureMass μ A ρ m W) := by |
| intro W V hWV |
| exact localFailureMass_congr_fragments μ A ρ m |
| (fragments_eq_of_inter_label_union_eq A hWV) |
|
|
| end LocalMasses |
|
|
| variable {X : Type} [DecidableEq X] |
|
|
| / |
| target masses before any pruning or reweighting. -/ |
| def Good (ρ : ℝ) (m : ℕ → ℕ) (W : Finset X) {d : ℕ} (T : ProbabilityTree X d) : Prop := |
| match T with |
| | .leaf => True |
| | @ProbabilityTree.node _ _ B inst μ _hμ A child => |
| 1 - Real.exp (-(m 0 : ℝ)) ≤ |
| ∑ b, if Good ρ (fun j => m (j + 1)) W (child b) then |
| successfulTargetMass μ A ρ (m 0) W b else 0 |
| termination_by d |
|
|
| end LeanBlast.SecondKahnKalai |
|
|
| end |
|
|
| end OAI |
|
|
