Loogle!
Result
Found 61 declarations mentioning ProbabilityTheory.Kernel.map.
- ProbabilityTheory.Kernel.map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} [MeasurableSpace γ] (κ : ProbabilityTheory.Kernel α β) (f : β → γ) : ProbabilityTheory.Kernel α γ - ProbabilityTheory.Kernel.map_id 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β) : κ.map id = κ - ProbabilityTheory.Kernel.map_id' 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β) : (κ.map fun a => a) = κ - ProbabilityTheory.Kernel.IsFiniteKernel.map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsFiniteKernel κ] (f : β → γ) : ProbabilityTheory.IsFiniteKernel (κ.map f) - ProbabilityTheory.Kernel.IsSFiniteKernel.map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (f : β → γ) : ProbabilityTheory.IsSFiniteKernel (κ.map f) - ProbabilityTheory.Kernel.IsZeroOrMarkovKernel.map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsZeroOrMarkovKernel κ] (f : β → γ) : ProbabilityTheory.IsZeroOrMarkovKernel (κ.map f) - ProbabilityTheory.Kernel.id_map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β} (hf : Measurable f) : ProbabilityTheory.Kernel.id.map f = ProbabilityTheory.Kernel.deterministic f hf - ProbabilityTheory.Kernel.IsMarkovKernel.map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ] (hf : Measurable f) : ProbabilityTheory.IsMarkovKernel (κ.map f) - ProbabilityTheory.Kernel.mapOfMeasurable_eq_map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : Measurable f) : κ.mapOfMeasurable f hf = κ.map f - ProbabilityTheory.Kernel.fst_eq 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) : κ.fst = κ.map Prod.fst - ProbabilityTheory.Kernel.snd_eq 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) : κ.snd = κ.map Prod.snd - ProbabilityTheory.Kernel.map_const 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (μ : MeasureTheory.Measure α) {f : α → β} (hf : Measurable f) : (ProbabilityTheory.Kernel.const γ μ).map f = ProbabilityTheory.Kernel.const γ (MeasureTheory.Measure.map f μ) - ProbabilityTheory.Kernel.map_of_not_measurable 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : ¬Measurable f) : κ.map f = 0 - ProbabilityTheory.Kernel.fst_map_id_prod 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : Measurable f) : (κ.map fun a => (a, f a)).fst = κ - ProbabilityTheory.Kernel.snd_map_prod_id 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : Measurable f) : (κ.map fun a => (f a, a)).snd = κ - ProbabilityTheory.Kernel.map_zero 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} : ProbabilityTheory.Kernel.map 0 f = 0 - ProbabilityTheory.Kernel.sum_map_seq 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (f : β → γ) : (ProbabilityTheory.Kernel.sum fun n => (κ.seq n).map f) = κ.map f - ProbabilityTheory.Kernel.swapRight_eq 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α (β × γ)) : κ.swapRight = κ.map Prod.swap - ProbabilityTheory.Kernel.deterministic_map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {f : α → β} (hf : Measurable f) {g : β → γ} (hg : Measurable g) : (ProbabilityTheory.Kernel.deterministic f hf).map g = ProbabilityTheory.Kernel.deterministic (g ∘ f) ⋯ - ProbabilityTheory.Kernel.map_prodMkLeft 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {δ : Type u_4} {mδ : MeasurableSpace δ} (γ : Type u_5) [MeasurableSpace γ] (κ : ProbabilityTheory.Kernel α β) (f : β → δ) : (ProbabilityTheory.Kernel.prodMkLeft γ κ).map f = ProbabilityTheory.Kernel.prodMkLeft γ (κ.map f) - ProbabilityTheory.Kernel.map_prodMkRight 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {δ : Type u_4} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) (γ : Type u_5) {mγ : MeasurableSpace γ} (f : β → δ) : (ProbabilityTheory.Kernel.prodMkRight γ κ).map f = ProbabilityTheory.Kernel.prodMkRight γ (κ.map f) - ProbabilityTheory.Kernel.map_comp_right 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : Measurable f) {g : γ → δ} (hg : Measurable g) : κ.map (g ∘ f) = (κ.map f).map g - ProbabilityTheory.Kernel.fst_map_prod 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {δ : Type u_4} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} {g : β → δ} (hg : Measurable g) : (κ.map fun x => (f x, g x)).fst = κ.map f - ProbabilityTheory.Kernel.snd_map_prod 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {δ : Type u_4} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) {f : β → γ} {g : β → δ} (hf : Measurable f) : (κ.map fun x => (f x, g x)).snd = κ.map g - ProbabilityTheory.Kernel.comap_map_comm 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel β γ) {f : α → β} {g : γ → δ} (hf : Measurable f) (hg : Measurable g) : (κ.map g).comap f hf = (κ.comap f hf).map g - ProbabilityTheory.Kernel.map_apply 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (κ : ProbabilityTheory.Kernel α β) (hf : Measurable f) (a : α) : (κ.map f) a = MeasureTheory.Measure.map f (κ a) - ProbabilityTheory.Kernel.lintegral_map 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (κ : ProbabilityTheory.Kernel α β) (hf : Measurable f) (a : α) {g' : γ → ENNReal} (hg : Measurable g') : ∫⁻ (b : γ), g' b ∂(κ.map f) a = ∫⁻ (a : β), g' (f a) ∂κ a - ProbabilityTheory.Kernel.map.eq_1 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} [MeasurableSpace γ] (κ : ProbabilityTheory.Kernel α β) (f : β → γ) : κ.map f = if hf : Measurable f then κ.mapOfMeasurable f hf else 0 - ProbabilityTheory.Kernel.map_apply' 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (κ : ProbabilityTheory.Kernel α β) (hf : Measurable f) (a : α) {s : Set γ} (hs : MeasurableSet s) : ((κ.map f) a) s = (κ a) (f ⁻¹' s) - ProbabilityTheory.Kernel.map_apply_eq_iff_map_symm_apply_eq 📋 Mathlib.Probability.Kernel.Composition.MapComap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) {f : β ≃ᵐ γ} (η : ProbabilityTheory.Kernel α γ) : κ.map ⇑f = η ↔ κ = η.map ⇑f.symm - ProbabilityTheory.Kernel.deterministic_comp_eq_map 📋 Mathlib.Probability.Kernel.Composition.CompMap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : β → γ} (hf : Measurable f) (κ : ProbabilityTheory.Kernel α β) : (ProbabilityTheory.Kernel.deterministic f hf).comp κ = κ.map f - ProbabilityTheory.Kernel.map_comp 📋 Mathlib.Probability.Kernel.Composition.CompMap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel β γ) (f : γ → δ) : (η.comp κ).map f = (η.map f).comp κ - ProbabilityTheory.Kernel.comp_map 📋 Mathlib.Probability.Kernel.Composition.CompMap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel γ δ) {f : β → γ} (hf : Measurable f) : η.comp (κ.map f) = (η.comap f hf).comp κ - ProbabilityTheory.Kernel.swap_comp_eq_map 📋 Mathlib.Probability.Kernel.Composition.CompMap
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α (β × γ)} : (ProbabilityTheory.Kernel.swap β γ).comp κ = κ.map Prod.swap - ProbabilityTheory.Kernel.map_prod_swap 📋 Mathlib.Probability.Kernel.Composition.Prod
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel κ] [ProbabilityTheory.IsSFiniteKernel η] : (κ.prod η).map Prod.swap = η.prod κ - ProbabilityTheory.Kernel.map_prod_eq 📋 Mathlib.Probability.Kernel.Composition.Prod
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η] {f : β → δ} (hf : Measurable f) : (κ.map f).prod η = (κ.prod η).map (Prod.map f id) - ProbabilityTheory.Kernel.map_prod_map 📋 Mathlib.Probability.Kernel.Composition.Prod
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} {ε : Type u_6} {mε : MeasurableSpace ε} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α δ) [ProbabilityTheory.IsSFiniteKernel η] {f : β → γ} (hf : Measurable f) {g : δ → ε} (hg : Measurable g) : (κ.map f).prod (η.map g) = (κ.prod η).map (Prod.map f g) - ProbabilityTheory.Kernel.comap_prod_swap 📋 Mathlib.Probability.Kernel.Composition.Prod
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel γ δ) [ProbabilityTheory.IsSFiniteKernel κ] [ProbabilityTheory.IsSFiniteKernel η] : ((ProbabilityTheory.Kernel.prodMkRight α η).prod (ProbabilityTheory.Kernel.prodMkLeft γ κ)).comap Prod.swap ⋯ = ((ProbabilityTheory.Kernel.prodMkRight γ κ).prod (ProbabilityTheory.Kernel.prodMkLeft α η)).map Prod.swap - ProbabilityTheory.Kernel.prodAssoc_prod 📋 Mathlib.Probability.Kernel.Composition.Prod
{α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel α γ) [ProbabilityTheory.IsSFiniteKernel η] (ξ : ProbabilityTheory.Kernel α δ) [ProbabilityTheory.IsSFiniteKernel ξ] : ((κ.prod ξ).prod η).map ⇑MeasurableEquiv.prodAssoc = κ.prod (ξ.prod η) - MeasureTheory.Measure.map_comp 📋 Mathlib.Probability.Kernel.Composition.MeasureComp
{α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} (μ : MeasureTheory.Measure α) (κ : ProbabilityTheory.Kernel α β) {f : β → γ} (hf : Measurable f) : MeasureTheory.Measure.map f (μ.bind ⇑κ) = μ.bind ⇑(κ.map f) - ProbabilityTheory.Kernel.condKernelUnitBorel.eq_1 📋 Mathlib.Probability.Kernel.Disintegration.StandardBorel
{α : Type u_1} {Ω : Type u_4} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] (κ : ProbabilityTheory.Kernel Unit (α × Ω)) [ProbabilityTheory.IsFiniteKernel κ] : κ.condKernelUnitBorel = ProbabilityTheory.Kernel.borelMarkovFromReal Ω (κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))).condKernelUnitReal - ProbabilityTheory.Kernel.condKernelBorel.eq_1 📋 Mathlib.Probability.Kernel.Disintegration.StandardBorel
{α : Type u_1} {γ : Type u_3} {Ω : Type u_4} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} [MeasurableSpace.CountablyGenerated γ] [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] (κ : ProbabilityTheory.Kernel α (γ × Ω)) [ProbabilityTheory.IsFiniteKernel κ] : κ.condKernelBorel = ProbabilityTheory.Kernel.borelMarkovFromReal Ω (κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))).condKernelReal - ProbabilityTheory.Kernel.compProd_fst_borelMarkovFromReal 📋 Mathlib.Probability.Kernel.Disintegration.StandardBorel
{α : Type u_1} {β : Type u_2} {Ω : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] (κ : ProbabilityTheory.Kernel α (β × Ω)) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel (α × β) ℝ) [ProbabilityTheory.IsSFiniteKernel η] (hη : (κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))).fst.compProd η = κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))) : κ.fst.compProd (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η) = κ - ProbabilityTheory.Kernel.compProd_fst_borelMarkovFromReal_eq_comapRight_compProd 📋 Mathlib.Probability.Kernel.Disintegration.StandardBorel
{α : Type u_1} {β : Type u_2} {Ω : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] (κ : ProbabilityTheory.Kernel α (β × Ω)) [ProbabilityTheory.IsSFiniteKernel κ] (η : ProbabilityTheory.Kernel (α × β) ℝ) [ProbabilityTheory.IsSFiniteKernel η] (hη : (κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))).fst.compProd η = κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))) : κ.fst.compProd (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η) = ((κ.map (Prod.map id (MeasureTheory.embeddingReal Ω))).fst.compProd η).comapRight ⋯ - ProbabilityTheory.Kernel.rnDerivAux.eq_1 📋 Mathlib.Probability.Kernel.RadonNikodym
{α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} [hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ) (a : α) (x : γ) : κ.rnDerivAux η a x = if hα : Countable α then ((κ a).rnDeriv (η a) x).toReal else (κ.map fun a => (a, ())).density η a x Set.univ - ProbabilityTheory.Kernel.partialTraj_map_frestrictLe₂ 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {b c : ℕ} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] (a : ℕ) (hbc : b ≤ c) : (ProbabilityTheory.Kernel.partialTraj κ a c).map (Preorder.frestrictLe₂ hbc) = ProbabilityTheory.Kernel.partialTraj κ a b - ProbabilityTheory.Kernel.partialTraj_succ_map_frestrictLe₂ 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] (a b : ℕ) : (ProbabilityTheory.Kernel.partialTraj κ a (b + 1)).map (Preorder.frestrictLe₂ ⋯) = ProbabilityTheory.Kernel.partialTraj κ a b - ProbabilityTheory.Kernel.lmarginalPartialTraj_eq_lintegral_map 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b : ℕ} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsSFiniteKernel (κ n)] {f : ((n : ℕ) → X n) → ENNReal} (mf : Measurable f) (x₀ : (n : ℕ) → X n) : ProbabilityTheory.Kernel.lmarginalPartialTraj κ a b f x₀ = ∫⁻ (x : (i : { x // x ∈ Finset.Ioc a b }) → X ↑i), f (Function.updateFinset x₀ (Finset.Ioc a b) x) ∂((ProbabilityTheory.Kernel.partialTraj κ a b).map (Finset.restrict₂ ⋯)) (Preorder.frestrictLe a x₀) - ProbabilityTheory.Kernel.partialTraj_eq_prod 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsSFiniteKernel (κ n)] (a b : ℕ) : ProbabilityTheory.Kernel.partialTraj κ a b = (ProbabilityTheory.Kernel.id.prod ((ProbabilityTheory.Kernel.partialTraj κ a b).map (Finset.restrict₂ ⋯))).map (IicProdIoc a b) - ProbabilityTheory.Kernel.partialTraj_succ_self 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} (a : ℕ) : ProbabilityTheory.Kernel.partialTraj κ a (a + 1) = (ProbabilityTheory.Kernel.id.prod ((κ a).map ⇑(MeasurableEquiv.piSingleton a))).map (IicProdIoc a (a + 1)) - ProbabilityTheory.Kernel.partialTraj_succ_of_le 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b : ℕ} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} (hab : a ≤ b) : ProbabilityTheory.Kernel.partialTraj κ a (b + 1) = ((ProbabilityTheory.Kernel.id.prod ((κ b).map ⇑(MeasurableEquiv.piSingleton b))).comp (ProbabilityTheory.Kernel.partialTraj κ a b)).map (IicProdIoc b (b + 1)) - ProbabilityTheory.Kernel.partialTraj_le_def 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b : ℕ} {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} (hab : a ≤ b) : ProbabilityTheory.Kernel.partialTraj κ a b = Nat.leRec ProbabilityTheory.Kernel.id (fun k x κ_k => ((ProbabilityTheory.Kernel.id.prod ((κ k).map ⇑(MeasurableEquiv.piSingleton k))).comp κ_k).map (IicProdIoc k (k + 1))) hab - ProbabilityTheory.Kernel.partialTraj.eq_1 📋 Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} (κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))) (a b : ℕ) : ProbabilityTheory.Kernel.partialTraj κ a b = if h : b ≤ a then ProbabilityTheory.Kernel.deterministic (Preorder.frestrictLe₂ h) ⋯ else Nat.leRec ProbabilityTheory.Kernel.id (fun k x κ_k => ((ProbabilityTheory.Kernel.id.prod ((κ k).map ⇑(MeasurableEquiv.piSingleton k))).comp κ_k).map (IicProdIoc k (k + 1))) ⋯ - ProbabilityTheory.Kernel.traj_map_frestrictLe 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] (a b : ℕ) : (ProbabilityTheory.Kernel.traj κ a).map (Preorder.frestrictLe b) = ProbabilityTheory.Kernel.partialTraj κ a b - ProbabilityTheory.Kernel.eq_traj 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] (κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))) [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {a : ℕ} (η : ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic a }) → X ↑i) ((n : ℕ) → X n)) (hη : ∀ (b : ℕ), η.map (Preorder.frestrictLe b) = ProbabilityTheory.Kernel.partialTraj κ a b) : η = ProbabilityTheory.Kernel.traj κ a - ProbabilityTheory.Kernel.eq_traj' 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] (κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))) [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {a : ℕ} (n : ℕ) (η : ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic a }) → X ↑i) ((n : ℕ) → X n)) (hη : ∀ b ≥ n, η.map (Preorder.frestrictLe b) = ProbabilityTheory.Kernel.partialTraj κ a b) : η = ProbabilityTheory.Kernel.traj κ a - ProbabilityTheory.Kernel.traj_map_frestrictLe_of_le 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] {a b : ℕ} (hab : a ≤ b) : (ProbabilityTheory.Kernel.traj κ b).map (Preorder.frestrictLe a) = ProbabilityTheory.Kernel.deterministic (Preorder.frestrictLe₂ hab) ⋯ - ProbabilityTheory.Kernel.traj_eq_prod 📋 Mathlib.Probability.Kernel.IonescuTulcea.Traj
{X : ℕ → Type u_1} [(n : ℕ) → MeasurableSpace (X n)] {κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (X (n + 1))} [∀ (n : ℕ), ProbabilityTheory.IsMarkovKernel (κ n)] (a : ℕ) : ProbabilityTheory.Kernel.traj κ a = (ProbabilityTheory.Kernel.id.prod ((ProbabilityTheory.Kernel.traj κ a).map (Set.Ioi a).restrict)).map ⇑(MeasurableEquiv.IicProdIoi a) - ProbabilityTheory.Kernel.HasSubgaussianMGF.of_map 📋 Mathlib.Probability.Moments.SubGaussian
{Ω : Type u_1} {Ω' : Type u_2} {mΩ : MeasurableSpace Ω} {mΩ' : MeasurableSpace Ω'} {ν : MeasureTheory.Measure Ω'} {c : NNReal} {Ω'' : Type u_3} {mΩ'' : MeasurableSpace Ω''} {κ : ProbabilityTheory.Kernel Ω' Ω''} {Y : Ω'' → Ω} {X : Ω → ℝ} (hY : Measurable Y) (h : ProbabilityTheory.Kernel.HasSubgaussianMGF X c (κ.map Y) ν) : ProbabilityTheory.Kernel.HasSubgaussianMGF (X ∘ Y) c κ ν - MeasureTheory.partialTraj_const_restrict₂ 📋 Mathlib.Probability.ProductMeasure
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} (μ : (n : ℕ) → MeasureTheory.Measure (X n)) [hμ : ∀ (n : ℕ), MeasureTheory.IsProbabilityMeasure (μ n)] {a b : ℕ} : (ProbabilityTheory.Kernel.partialTraj (fun n => ProbabilityTheory.Kernel.const ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (μ (n + 1))) a b).map (Finset.restrict₂ ⋯) = ProbabilityTheory.Kernel.const ((i : { x // x ∈ Finset.Iic a }) → X ↑i) (MeasureTheory.Measure.pi fun i => μ ↑i) - MeasureTheory.partialTraj_const 📋 Mathlib.Probability.ProductMeasure
{X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} (μ : (n : ℕ) → MeasureTheory.Measure (X n)) [hμ : ∀ (n : ℕ), MeasureTheory.IsProbabilityMeasure (μ n)] {a b : ℕ} : ProbabilityTheory.Kernel.partialTraj (fun n => ProbabilityTheory.Kernel.const ((i : { x // x ∈ Finset.Iic n }) → X ↑i) (μ (n + 1))) a b = (ProbabilityTheory.Kernel.id.prod (ProbabilityTheory.Kernel.const ((i : { x // x ∈ Finset.Iic a }) → X ↑i) (MeasureTheory.Measure.pi fun i => μ ↑i))).map (IicProdIoc a b)
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using (by default) Ctrl-K Ctrl-S. You can also try the
#loogle
command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
🔍Real.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
🔍"differ"
finds all lemmas that have"differ"
somewhere in their lemma name.By subexpression:
🔍_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
🔍Real.sqrt ?a * Real.sqrt ?a
If the pattern has parameters, they are matched in any order. Both of these will find
List.map
:
🔍(?a -> ?b) -> List ?a -> List ?b
🔍List ?a -> (?a -> ?b) -> List ?b
By main conclusion:
🔍|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all→
and∀
) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍|- _ < _ → tsum _ < tsum _
will findtsum_lt_tsum
even though the hypothesisf i < g i
is not the last.
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin
and tsum
, have "two"
as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _
(if
there were any such lemmas). Metavariables (?a
) are
assigned independently in each filter.
The #lucky
button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.
This is Loogle revision 19971e9
serving mathlib revision bce1d65