openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionAnnealing.lean
| import OAI.Combinatorics.ContingencyTables.Rooted.ForestPenaltyBound | |
| import OAI.Combinatorics.ContingencyTables.Transport.PairedLabels | |
| namespace OAI | |
| /-! | |
| # Adjacent actual companion weights and ideal multipliers | |
| The parameter step is 1/(H/A). Its factor-two bounds are proved from | |
| the literal forest penalty bound, then passed to the actual labelled | |
| weights and their exact transversal/defect totals. | |
| -/ | |
| namespace ContingencyTables.CompanionAnnealing | |
| open scoped BigOperators Classical | |
| open CommonBasesFPRAS CompanionFactorialApplication ForestPenaltyBound LabelledFactorial | |
| open TwoLiftStates BalancedBox | |
| variable {I J : Type*} [Fintype I] [Fintype J] | |
| noncomputable def scale (A : Instance I J) : ℝ := 10*(A.d:ℝ)^2*((A.W:ℝ)+1) | |
| lemma scale_positive (A : Instance I J) : 0< scale A := by | |
| have hd : (0:ℝ)< A.d := by | |
| exact_mod_cast (show 0< A.d by have := A.hd; omega) | |
| unfold scale | |
| positivity | |
| /-- The source's j*A/H parameter is exactly j/(H/A), for its literal | |
| integer H=10*A*d²*(W+1). The arbitrary positive penalty coefficient | |
| therefore cancels from every adjacent-phase estimate below. -/ | |
| lemma source_parameter (A : Instance I J) (coefficient j : ℕ) (hc : 0< coefficient) : | |
| (j:ℝ)*(coefficient:ℝ)/((10*coefficient*A.d^2*(A.W+1):ℕ):ℝ)= | |
| (j:ℝ)/scale A := by | |
| have hcR : (coefficient:ℝ)≠0 := Nat.cast_ne_zero.mpr (Nat.ne_of_gt hc) | |
| have hQ : scale A≠0 := (scale_positive A).ne' | |
| have he : ((10*coefficient*A.d^2*(A.W+1):ℕ):ℝ)=(coefficient:ℝ)*scale A := by | |
| unfold scale | |
| push_cast | |
| ring | |
| rw [he] | |
| field_simp [hcR,hQ] | |
| noncomputable def weight (A : Instance I J) (j : ℕ) : Set (Labels A×Bool) → ℝ := | |
| f A ((j:ℝ)/scale A) | |
| theorem count_adjacent (A : Instance I J) (j : ℕ) (z : View A → ℕ) | |
| (hz : InBox (bounds A) z) : | |
| (1/2)*h A ((j:ℝ)/scale A) z≤ h A (((j+1:ℕ):ℝ)/scale A) z ∧ | |
| h A (((j+1:ℕ):ℝ)/scale A) z≤ h A ((j:ℝ)/scale A) z := by | |
| let K (k : ℕ) (a : ForestAssignmentSplit.FreeIndex A.small A.T A.b) : ℝ := | |
| (2:ℝ)^(-((k:ℝ)/scale A)*penalty A z a) | |
| have hterm (a : ForestAssignmentSplit.FreeIndex A.small A.T A.b) : | |
| (1/2)*K j a≤ K (j+1) a ∧ K (j+1) a≤ K j a := by | |
| have hp := penalty_bound A z hz a | |
| have hQ := scale_positive A | |
| have hPQ0 : 0≤ penalty A z a/scale A := div_nonneg hp.1 hQ.le | |
| have hPQ1 : penalty A z a/scale A≤1 := (div_le_one hQ).mpr hp.2 | |
| have hlo : (1/2:ℝ)≤(2:ℝ)^(-(penalty A z a/scale A)) := by | |
| calc | |
| _ = (2:ℝ)^(-1:ℝ) := by norm_num | |
| _ ≤ _ := Real.rpow_le_rpow_of_exponent_le (by norm_num) (by linarith) | |
| have hup : (2:ℝ)^(-(penalty A z a/scale A))≤1 := by | |
| calc | |
| _ ≤ (2:ℝ)^(0:ℝ) := Real.rpow_le_rpow_of_exponent_le (by norm_num) (by linarith) | |
| _ = _ := by norm_num | |
| have he : K (j+1) a=K j a*(2:ℝ)^(-(penalty A z a/scale A)) := by | |
| unfold K | |
| rw [← Real.rpow_add (by norm_num : (0:ℝ)<2)] | |
| congr 1 | |
| push_cast | |
| ring | |
| have hK : 0≤ K j a := (Real.rpow_pos_of_pos (by norm_num) _).le | |
| rw [he] | |
| constructor | |
| · nlinarith [mul_le_mul_of_nonneg_left hlo hK] | |
| · nlinarith [mul_le_mul_of_nonneg_left hup hK] | |
| change (1/2)*(∑ a, K j a)≤(∑ a, K (j+1) a) ∧ (∑ a, K (j+1) a)≤∑ a, K j a | |
| constructor | |
| · rw [Finset.mul_sum] | |
| exact Finset.sum_le_sum (fun a _ => (hterm a).1) | |
| · exact Finset.sum_le_sum (fun a _ => (hterm a).2) | |
| theorem weight_positive (A : Instance I J) (j : ℕ) (S : Set (Labels A×Bool)) : | |
| 0< weight A j S := by | |
| exact div_pos (mul_pos (h_positive A _ _) (FactorialSignatures.factorialProduct_positive _)) | |
| (CompanionFactorialApplication.denominator_positive A) | |
| theorem weight_adjacent (A : Instance I J) (j : ℕ) (S : Set (Labels A×Bool)) : | |
| (1/2)*weight A j S≤ weight A (j+1) S ∧ weight A (j+1) S≤ weight A j S := by | |
| have hz : InBox (bounds A) (groupCount (group (labelCell A)) S) := by | |
| rw [← label_capacity] | |
| exact SliceFactorial.groupCount_inBox _ _ | |
| have h := count_adjacent A j _ hz | |
| have hc : 0≤ FactorialSignatures.factorialProduct (groupCount (group (labelCell A)) S)/ | |
| CompanionFactorialApplication.denominator A := | |
| (div_pos (FactorialSignatures.factorialProduct_positive _) | |
| (CompanionFactorialApplication.denominator_positive A)).le | |
| unfold weight f firstLift | |
| simp only [mul_div_assoc] | |
| constructor | |
| · nlinarith [mul_le_mul_of_nonneg_right h.1 hc] | |
| · exact mul_le_mul_of_nonneg_right h.2 hc | |
| theorem total_adjacent (A : Instance I J) (j : ℕ) | |
| (ps : List ((Labels A×Bool)×(Labels A×Bool))) (S : Set (Labels A×Bool)) : | |
| (1/2)*slotTotal ps (weight A j) S≤ slotTotal ps (weight A (j+1)) S ∧ | |
| slotTotal ps (weight A (j+1)) S≤ slotTotal ps (weight A j) S := by | |
| constructor | |
| · rw [← slotTotal_scale] | |
| exact slotTotal_mono _ _ _ (fun T => (weight_adjacent A j T).1) _ | |
| · exact slotTotal_mono _ _ _ (fun T => (weight_adjacent A j T).2) _ | |
| theorem ideal_adjacent (A : Instance I J) (j : ℕ) | |
| (p r : (Labels A×Bool)×(Labels A×Bool)) (hp : p∈pairs) (hr : r∈pairs) (hpr : p≠r) : | |
| (slotTotal pairs (weight A j) ∅/slotDefect pairs (weight A j) ∅ p r)/2≤ | |
| slotTotal pairs (weight A (j+1)) ∅/slotDefect pairs (weight A (j+1)) ∅ p r ∧ | |
| slotTotal pairs (weight A (j+1)) ∅/slotDefect pairs (weight A (j+1)) ∅ p r≤ | |
| 2*(slotTotal pairs (weight A j) ∅/slotDefect pairs (weight A j) ∅ p r) := by | |
| have h0 := slotTotal_pos pairs _ (weight_positive A j) ∅ PairedLabels.fresh | |
| have hd0 := slotDefect_pos pairs _ (weight_positive A j) ∅ PairedLabels.fresh p r hp hr hpr | |
| have hd1 := slotDefect_pos pairs _ (weight_positive A (j+1)) ∅ PairedLabels.fresh p r hp hr hpr | |
| have ha := total_adjacent A j pairs ∅ | |
| have hb' : (1/2)*slotDefect pairs (weight A j) ∅ p r≤ slotDefect pairs (weight A (j+1)) ∅ p r ∧ | |
| slotDefect pairs (weight A (j+1)) ∅ p r≤ slotDefect pairs (weight A j) ∅ p r := by | |
| unfold slotDefect | |
| constructor | |
| · rw [← slotTotal_scale] | |
| exact slotTotal_mono _ _ _ (fun S => (weight_adjacent A j S).1) _ | |
| · exact slotTotal_mono _ _ _ (fun S => (weight_adjacent A j S).2) _ | |
| constructor | |
| · rw [div_div,div_le_div_iff₀ (mul_pos hd0 (by norm_num)) hd1] | |
| nlinarith [mul_nonneg h0.le (sub_nonneg.mpr hb'.2),mul_nonneg hd0.le (sub_nonneg.mpr ha.1)] | |
| · rw [← mul_div_assoc,div_le_div_iff₀ hd1 hd0] | |
| nlinarith [mul_nonneg hd0.le (sub_nonneg.mpr ha.2),mul_nonneg h0.le (sub_nonneg.mpr hb'.1)] | |
| end ContingencyTables.CompanionAnnealing | |
| end OAI | |