| import Mathlib |
| import OAI.Probability.LogConcave.Analysis.GaussianProposalPotential |
|
|
| namespace OAI |
|
|
| section |
| section |
| noncomputable section |
| open MeasureTheory Filter |
| open scoped ENNReal NNReal Topology |
|
|
| section UpperProof |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| open Function MeasureTheory Set Filter |
| open scoped Topology NNReal |
|
|
| namespace LogConcaveSampling |
|
|
| def transcriptRejection {d : ℕ} : (q : ℕ) → |
| ((Fin q → Point d × ℝ) × (Fin q → ℝ)) → Point d |
| | 0, _ => 0 |
| | n+1, p => |
| if (p.1 (Fin.last n)).2 ≤ Real.exp (-(p.2 (Fin.last n))+ |
| gaussianProposalPotential d (p.1 (Fin.last n)).1) then (p.1 (Fin.last n)).1 |
| else transcriptRejection n (fun i => p.1 i.castSucc,fun i => p.2 i.castSucc) |
|
|
| @[fun_prop] lemma measurable_transcriptRejection (d q : ℕ) : |
| Measurable (transcriptRejection (d := d) q) := by |
| induction q with |
| | zero => exact measurable_const |
| | succ n ih => |
| apply Measurable.ite |
| · apply measurableSet_le |
| · fun_prop |
| · exact Real.measurable_exp.comp (((measurable_pi_apply (Fin.last n)).comp measurable_snd).neg.add |
| ((gaussianProposalPotential_admissible d).smooth.continuous.measurable.comp |
| (((measurable_pi_apply (Fin.last n)).comp measurable_fst).fst))) |
| · fun_prop |
| · exact ih.comp ((Measurable.of_eval fun index => |
| (measurable_pi_apply index.castSucc).comp measurable_fst).prodMk |
| (Measurable.of_eval fun index => (measurable_pi_apply index.castSucc).comp measurable_snd)) |
|
|
| lemma transcriptRejection_eq {d : ℕ} (V : Point d → ℝ) (q : ℕ) (tape : Fin q → Point d × ℝ) : |
| transcriptRejection q (tape,fun i => V (tape i).1) = |
| rejectionPick (gaussianAcceptance V) 0 q tape := by |
| induction q with |
| | zero => rfl |
| | succ n ih => |
| simp only [transcriptRejection,rejectionPick,gaussianAcceptance] |
| congr 1 |
| exact ih _ |
|
|
| def finiteRejectionAlgorithm (d q : ℕ) : OracleAlgorithm (Fin q → Point d × ℝ) d q where |
| query i p := (p.1 i).1 |
| query_measurable _ := by fun_prop |
| output p := transcriptRejection q (p.1,fun i => (p.2 i).1) |
| output_measurable := (measurable_transcriptRejection d q).comp (measurable_fst.prodMk |
| (Measurable.of_eval fun _ => by fun_prop)) |
|
|
| lemma finiteRejection_history {d q : ℕ} (V : Point d → ℝ) (tape : Fin q → Point d × ℝ) |
| (n : ℕ) (i : Fin q) (hi : i.val < n) : |
| (finiteRejectionAlgorithm d q).history V tape n i = firstOrderReply V (tape i).1 := by |
| induction n with |
| | zero => omega |
| | succ n ih => |
| simp only [OracleAlgorithm.history] |
| split_ifs with hn |
| · by_cases he : i = ⟨n,hn⟩ |
| · subst i |
| simp [finiteRejectionAlgorithm] |
| · rw [Function.update_of_ne he] |
| exact ih (by have hne : i.val ≠ n := fun h => he (Fin.ext h); omega) |
| · apply ih |
| omega |
|
|
| lemma finiteRejection_run {d q : ℕ} (V : Point d → ℝ) (tape : Fin q → Point d × ℝ) : |
| (finiteRejectionAlgorithm d q).run V tape = rejectionPick (gaussianAcceptance V) 0 q tape := by |
| change transcriptRejection q (tape,_) = _ |
| have hh : (fun i => ((finiteRejectionAlgorithm d q).history V tape q i).1) = |
| fun i => V (tape i).1 := by |
| funext i |
| rw [finiteRejection_history V tape q i i.isLt] |
| rfl |
| rw [hh,transcriptRejection_eq] |
|
|
| lemma rejection_failure_bound {p : ℝ} (_hp0 : 0 ≤ p) (hp1 : p ≤ 1) (n : ℕ) : |
| (1-p)^n * (1+(n:ℝ)*p) ≤ 1 := by |
| induction n with |
| | zero => simp |
| | succ n ih => |
| rw [pow_succ,Nat.cast_add,Nat.cast_one] |
| have hnon : 0 ≤ (1-p)^n := pow_nonneg (sub_nonneg.mpr hp1) _ |
| have hs : (1-p)*(1+((n:ℝ)+1)*p) ≤ 1+(n:ℝ)*p := by |
| have hh : 0 ≤ ((n:ℝ)+1)*p^2 := by positivity |
| nlinarith |
| have h := mul_le_mul_of_nonneg_left hs hnon |
| nlinarith |
|
|
| theorem finite_dimension_sampler (d : ℕ) : CanSample d (10*2^d) := by |
| let q := 10*2^d |
| let ν := gibbs (gaussianProposalPotential d) |
| have hB := gaussianProposalPotential_admissible d |
| have := hB.isProbabilityMeasure_gibbs |
| refine ⟨Fin q → Point d × ℝ,inferInstance, |
| Measure.pi (fun _ : Fin q => ν.prod unitUniform),inferInstance,finiteRejectionAlgorithm d q,?_⟩ |
| intro V hV |
| refine ⟨(finiteRejectionAlgorithm d q).measurable_run hV,?_⟩ |
| have := hV.isProbabilityMeasure_gibbs |
| let p := (partition V).toReal/(partition (gaussianProposalPotential d)).toReal |
| have hZ : 0 < (partition (gaussianProposalPotential d)).toReal := |
| ENNReal.toReal_pos hB.partition_pos.ne' hB.partition_ne_top |
| have hp0 : 0 ≤ p := div_nonneg ENNReal.toReal_nonneg hZ.le |
| have hp1 : p ≤ 1 := (div_le_one hZ).mpr (partition_comparison hV).2 |
| have hpl : (2:ℝ)^(-(d:ℤ)) ≤ p := (le_div_iff₀ hZ).mpr (partition_comparison hV).1 |
| have hq : (10:ℝ) ≤ (q:ℝ)*p := by |
| have hh := mul_le_mul_of_nonneg_left hpl (show (0:ℝ) ≤ (q:ℝ) by positivity) |
| dsimp [q] at hh ⊢ |
| norm_num only [Nat.cast_mul,Nat.cast_ofNat,Nat.cast_pow,zpow_neg,zpow_natCast] at hh ⊢ |
| have hpow : (2:ℝ)^d ≠ 0 := by positivity |
| field_simp at hh |
| nlinarith |
| have hfail : (1-p)^q ≤ 1/10 := by |
| have h := rejection_failure_bound hp0 hp1 q |
| have hnon : 0 ≤ (1-p)^q := pow_nonneg (sub_nonneg.mpr hp1) q |
| nlinarith |
| have htv := capped_rejection_tv ν (gibbs V) (measurable_gaussianAcceptance hV) |
| hp0 hp1 (gaussian_accepted_measure hV) 0 q |
| have he : (finiteRejectionAlgorithm d q).run V = rejectionPick (gaussianAcceptance V) 0 q := |
| funext (finiteRejection_run V) |
| rw [he] |
| exact fun s hs => (htv s hs).trans hfail |
| |
| end LogConcaveSampling |
| |
| end UpperProof |
| section LowerProof |
| |
| open Matrix Topology TopologicalSpace ProbabilityTheory Classical WithLp |
| open scoped Matrix.Norms.Elementwise |
| |
| namespace LogConcaveSampling.LowerBound |
| |
| abbrev Rotations (d : ℕ) := Matrix.orthogonalGroup (Fin d) ℝ |
| |
| theorem orthogonal_entry_bound {d : ℕ} {M : Matrix (Fin d) (Fin d) ℝ} |
| (hM : M ∈ Matrix.orthogonalGroup (Fin d) ℝ) (i j : Fin d) : |M i j| ≤ 1 := by |
| have h := congrArg (fun A : Matrix (Fin d) (Fin d) ℝ => A i i) |
| ((Matrix.mem_orthogonalGroup_iff (Fin d) ℝ).mp hM) |
| simp only [Matrix.mul_apply, Matrix.transpose_apply, Matrix.one_apply_eq] at h |
| have ht : (M i j)^2 ≤ ∑ k, M i k * M i k := by |
| simpa only [pow_two] using |
| (Finset.single_le_sum (fun k (_ : k ∈ (Finset.univ : Finset (Fin d))) => mul_self_nonneg (M i k)) |
| (Finset.mem_univ j)) |
| rw [h] at ht |
| nlinarith [sq_abs (M i j), abs_nonneg (M i j)] |
| |
| theorem orthogonal_group_isCompact (d : ℕ) : |
| IsCompact (Matrix.orthogonalGroup (Fin d) ℝ : Set (Matrix (Fin d) (Fin d) ℝ)) := by |
| apply Metric.isCompact_of_isClosed_isBounded |
| · exact isClosed_unitary (R := Matrix (Fin d) (Fin d) ℝ) |
| · apply (Metric.isBounded_iff_subset_closedBall (0 : Matrix (Fin d) (Fin d) ℝ)).mpr |
| refine ⟨1,?_⟩ |
| intro M hM |
| rw [Metric.mem_closedBall, dist_zero_right] |
| apply (Matrix.norm_le_iff (by norm_num)).mpr |
| intro i j |
| exact orthogonal_entry_bound hM i j |
| |
| instance rotations_compactSpace (d : ℕ) : CompactSpace (Rotations d) := |
| isCompact_iff_compactSpace.mp (orthogonal_group_isCompact d) |
| |
| instance rotations_measurableSpace (d : ℕ) : MeasurableSpace (Rotations d) := borel _ |
| instance rotations_borelSpace (d : ℕ) : BorelSpace (Rotations d) := ⟨rfl⟩ |
| |
| instance rotations_secondCountable (d : ℕ) : SecondCountableTopology (Rotations d) := by |
| let : SecondCountableTopology (Matrix (Fin d) (Fin d) ℝ) := |
| inferInstanceAs (SecondCountableTopology (Fin d → Fin d → ℝ)) |
| exact (Topology.IsEmbedding.subtypeVal (p := fun M : Matrix (Fin d) (Fin d) ℝ => |
| M ∈ Matrix.orthogonalGroup (Fin d) ℝ)).isInducing.secondCountableTopology |
| |
| instance rotations_measurableMul (d : ℕ) : MeasurableMul₂ (Rotations d) := |
| ⟨continuous_mul.measurable⟩ |
| |
| def rotationHaar (d : ℕ) : Measure (Rotations d) := |
| Measure.haarMeasure (⟨⟨Set.univ, isCompact_univ⟩, by simp⟩ : PositiveCompacts (Rotations d)) |
| |
| instance rotationHaar_probability (d : ℕ) : IsProbabilityMeasure (rotationHaar d) := by |
| constructor |
| exact Measure.haarMeasure_self |
| |
| instance rotationHaar_isHaar (d : ℕ) : (rotationHaar d).IsHaarMeasure := by |
| unfold rotationHaar |
| infer_instance |
| |
| end LogConcaveSampling.LowerBound |
| |
| end LowerProof |
| end |
| end |
| end |
| |
| end OAI |
| |
