| import OAI.Combinatorics.ContingencyTables.Sampling.ExactIntegerProgram |
| import OAI.Combinatorics.ContingencyTables.Transport.RejectionLaw |
| import Mathlib.Analysis.SpecificLimits.Basic |
|
|
| namespace OAI |
|
|
| /-! # Exact law and geometric tail of integer rejection -/ |
|
|
| namespace ContingencyTables.ExactIntegerChoice |
| open MatchingFPRAS ResidualMixture FirstSuccess |
| open scoped BigOperators Classical |
|
|
| noncomputable section |
| variable {r Q : ℕ} (w : Fin r → ℕ) (h : 0<totalWeight w) [NeZero Q] |
| variable (hQ : totalWeight w≤Q) |
|
|
| abbrev trialLaw : RationalLaw (Option (Fin r)) := |
| mapLaw (uniformLaw (α := Fin Q)) (weightedTrial w h hQ) |
|
|
| def failure : ℚ := 1-(totalWeight w:ℚ)/Q |
|
|
| lemma trialLaw_none : (trialLaw w h hQ).mass none=failure w (Q := Q) := by |
| have ht := (trialLaw w h hQ).total |
| rw [Fintype.sum_option] at ht |
| simp_rw [weightedTrial_mass w h hQ] at ht |
| rw [←Finset.sum_div,←Nat.cast_sum] at ht |
| change _+(totalWeight w:ℚ)/Q=1 at ht |
| unfold failure |
| linarith |
|
|
| private lemma lifted_success (p : RationalLaw (Option (Fin r))) (i : Fin r) : |
| successMass p (fun x => x.map some) (some i)=p.mass (some i) := by |
| simp [successMass] |
|
|
| private lemma lifted_no_success (p : RationalLaw (Option (Fin r))) : |
| successMass p (fun x => x.map some) none=0 := by |
| simp [successMass] |
|
|
| private lemma lifted_failure (p : RationalLaw (Option (Fin r))) : |
| failureMass p (fun x => x.map some)=p.mass none := by |
| simp [failureMass] |
|
|
| /-- `none` records that all supplied independent trials rejected; it is |
| not a fallback table. This is the finite prefix law of exact rejection. -/ |
| def retryIntegerLaw (N : ℕ) : RationalLaw (Option (Fin r)) := |
| retryLaw (trialLaw w h hQ) (fun x => x.map some) none N |
|
|
| lemma retryIntegerLaw_none (N : ℕ) : |
| (retryIntegerLaw w h hQ N).mass none=(failure w (Q := Q))^N := by |
| rw [retryIntegerLaw,retryLaw_mass,outputMass,lifted_no_success,lifted_failure,trialLaw_none] |
| simp only [zero_mul,ite_true,zero_add] |
|
|
| lemma retryIntegerLaw_some (N : ℕ) (i : Fin r) : |
| (retryIntegerLaw w h hQ N).mass (some i)= |
| normalized w i*(1-(failure w (Q := Q))^N) := by |
| rw [retryIntegerLaw,retryLaw_mass,outputMass,lifted_success,lifted_failure,trialLaw_none, |
| weightedTrial_mass] |
| simp only [reduceCtorEq,ite_false,add_zero] |
| have hV : (totalWeight w:ℚ)≠0 := by exact_mod_cast h.ne' |
| have hQt : (Q:ℚ)≠0 := by exact_mod_cast (NeZero.ne Q) |
| have he : (w i:ℚ)/Q=normalized w i*(1-failure w (Q := Q)) := by |
| unfold normalized failure |
| field_simp |
| ring |
| rw [he,mul_assoc] |
| congr 1 |
| have hg := geometric_balance (failure w (Q := Q)) N |
| linarith |
| |
| include hQ in |
| lemma failure_nonnegative : 0≤failure w (Q := Q) := by |
| unfold failure |
| have hQt : (0:ℚ)<Q := by exact_mod_cast (NeZero.pos Q) |
| exact sub_nonneg.mpr ((div_le_one hQt).mpr (by exact_mod_cast hQ)) |
| |
| lemma failure_lt_half (hshort : Q<2*totalWeight w) : failure w (Q := Q)<1/2 := by |
| unfold failure |
| have hQt : (0:ℚ)<Q := by exact_mod_cast (NeZero.pos Q) |
| have he : (1/2:ℚ)<(totalWeight w:ℚ)/Q := by |
| rw [lt_div_iff₀ hQt] |
| have hc : (Q:ℚ)<2*totalWeight w := by exact_mod_cast hshort |
| linarith |
| linarith |
| |
| lemma retryIntegerLaw_failure_bound (hshort : Q<2*totalWeight w) (N : ℕ) : |
| (retryIntegerLaw w h hQ N).mass none≤(1/2:ℚ)^N := by |
| rw [retryIntegerLaw_none] |
| exact pow_le_pow_left₀ (failure_nonnegative w hQ) (failure_lt_half w hshort).le N |
| |
| lemma retryIntegerLaw_limit (hshort : Q<2*totalWeight w) (i : Fin r) : |
| Filter.Tendsto (fun N => ((retryIntegerLaw w h hQ N).mass (some i):ℝ)) |
| Filter.atTop (nhds (normalized w i:ℝ)) := by |
| have hf0 : (0:ℝ)≤failure w (Q := Q) := by exact_mod_cast failure_nonnegative w hQ |
| have hf1 : (failure w (Q := Q):ℝ)<1 := by |
| have hh : (failure w (Q := Q):ℝ)<1/2 := by |
| have hh := (Rat.cast_lt (K := ℝ)).mpr (failure_lt_half w hshort) |
| norm_num at hh ⊢ |
| exact hh |
| linarith |
| have ht := tendsto_pow_atTop_nhds_zero_of_lt_one hf0 hf1 |
| have hout : Filter.Tendsto |
| (fun N => (normalized w i:ℝ)*(1-(failure w (Q := Q):ℝ)^N)) |
| Filter.atTop (nhds ((normalized w i:ℝ)*(1-0))) := |
| tendsto_const_nhds.mul (tendsto_const_nhds.sub ht) |
| simpa only [retryIntegerLaw_some,Rat.cast_mul,Rat.cast_sub,Rat.cast_one,Rat.cast_pow, |
| sub_zero,mul_one] using hout |
| |
| /-- The expected number of independent integer proposals is less than two. -/ |
| lemma retryIntegerLaw_expected_attempts (hshort : Q<2*totalWeight w) : |
| Summable (fun N => ((retryIntegerLaw w h hQ N).mass none:ℝ)) ∧ |
| (∑' N,((retryIntegerLaw w h hQ N).mass none:ℝ))<2 := by |
| have hf0 : (0:ℝ)≤failure w (Q := Q) := by exact_mod_cast failure_nonnegative w hQ |
| have hfhalf : (failure w (Q := Q):ℝ)<1/2 := by |
| have hh := (Rat.cast_lt (K := ℝ)).mpr (failure_lt_half w hshort) |
| norm_num at hh ⊢ |
| exact hh |
| have hf1 : (failure w (Q := Q):ℝ)<1 := by linarith |
| simp only [retryIntegerLaw_none,Rat.cast_pow] |
| refine ⟨summable_geometric_of_lt_one hf0 hf1,?_⟩ |
| rw [tsum_geometric_of_lt_one hf0 hf1] |
| rw [inv_lt_comm₀ (by linarith : (0:ℝ)<1-failure w (Q := Q)) (by norm_num)] |
| linarith |
|
|
| lemma clog_power_lt_twice (V : ℕ) (hV : 0<V) : 2^(Nat.clog 2 V)<2*V := by |
| by_cases hV1 : V=1 |
| · subst V |
| simp |
| · have h1 : 1<V := by omega |
| have hc : 0<Nat.clog 2 V := Nat.clog_pos (by decide) h1 |
| have hp : 2^(Nat.clog 2 V-1)<V := by |
| simpa only [Nat.pred_eq_sub_one] using Nat.pow_pred_clog_lt_self (by decide : 1<2) h1 |
| rw [show Nat.clog 2 V=(Nat.clog 2 V-1)+1 by omega,pow_succ] |
| omega |
|
|
| end |
| end ContingencyTables.ExactIntegerChoice |
|
|
| end OAI |
|
|
