File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

full_name: MeasureTheory.Measure.instMeasurableSpace
code: /-- Measurability structure on `Measure`: Measures are measurable w.r.t. all projections -/
instance instMeasurableSpace : MeasurableSpace (Measure α) 
goal: MeasurableSpace (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.measurable_coe
code: theorem measurable_coe {s : Set α} (hs : MeasurableSet s) : Measurable fun μ : Measure α => μ s 
goal: Measurable fun μ => μ s

full_name: MeasureTheory.Measure.measurable_of_measurable_coe
code: theorem measurable_of_measurable_coe (f : β → Measure α)
    (h : ∀ (s : Set α), MeasurableSet s → Measurable fun b => f b s) : Measurable f 
goal: Measurable f

full_name: MeasureTheory.Measure.instMeasurableAdd₂
code: instance instMeasurableAdd₂ {α : Type*} {m : MeasurableSpace α} : MeasurableAdd₂ (Measure α) 
goal: MeasurableAdd₂ (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.measurable_measure
code: theorem measurable_measure {μ : α → Measure β} :
    Measurable μ ↔ ∀ (s : Set β), MeasurableSet s → Measurable fun b => μ b s 
goal: Measurable μ ↔ ∀ (s : Set β), MeasurableSet s → Measurable fun b => (μ b) s

full_name: MeasureTheory.Measure.measurable_map
code: theorem measurable_map (f : α → β) (hf : Measurable f) :
    Measurable fun μ : Measure α => map f μ 
goal: Measurable fun μ => MeasureTheory.Measure.map f μ

full_name: MeasureTheory.Measure.measurable_dirac
code: theorem measurable_dirac : Measurable (Measure.dirac : α → Measure α) 
goal: Measurable MeasureTheory.Measure.dirac

full_name: MeasureTheory.Measure.measurable_lintegral
code: theorem measurable_lintegral {f : α → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun μ : Measure α => ∫⁻ x, f x ∂μ 
goal: Measurable fun μ => ∫⁻ (x : α), f x ∂μ

full_name: MeasureTheory.Measure.join
code: /-- Monadic join on `Measure` in the category of measurable spaces and measurable
functions. -/
def join (m : Measure (Measure α)) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.join_apply
code: @[simp]
theorem join_apply {m : Measure (Measure α)} {s : Set α} (hs : MeasurableSet s) :
    join m s = ∫⁻ μ, μ s ∂m 
goal: m.join s = ∫⁻ (μ : MeasureTheory.Measure α), μ s ∂m

full_name: MeasureTheory.Measure.join_zero
code: @[simp]
theorem join_zero : (0 : Measure (Measure α)).join = 0 
goal: MeasureTheory.Measure.join 0 = 0

full_name: MeasureTheory.Measure.measurable_join
code: theorem measurable_join : Measurable (join : Measure (Measure α) → Measure α) 
goal: Measurable MeasureTheory.Measure.join

full_name: MeasureTheory.Measure.lintegral_join
code: theorem lintegral_join {m : Measure (Measure α)} {f : α → ℝ≥0∞} (hf : Measurable f) :
    ∫⁻ x, f x ∂join m = ∫⁻ μ, ∫⁻ x, f x ∂μ ∂m 
goal: ∫⁻ (x : α), f x ∂m.join = ∫⁻ (μ : MeasureTheory.Measure α), ∫⁻ (x : α), f x ∂μ ∂m

full_name: MeasureTheory.Measure.bind
code: /-- Monadic bind on `Measure`, only works in the category of measurable spaces and measurable
functions. When the function `f` is not measurable the result is not well defined. -/
def bind (m : Measure α) (f : α → Measure β) : Measure β 
goal: MeasureTheory.Measure β

full_name: MeasureTheory.Measure.bind_zero_left
code: @[simp]
theorem bind_zero_left (f : α → Measure β) : bind 0 f = 0 
goal: MeasureTheory.Measure.bind 0 f = 0

full_name: MeasureTheory.Measure.bind_zero_right
code: @[simp]
theorem bind_zero_right (m : Measure α) : bind m (0 : α → Measure β) = 0 
goal: m.bind 0 = 0

full_name: MeasureTheory.Measure.bind_zero_right'
code: @[simp]
theorem bind_zero_right' (m : Measure α) : bind m (fun _ => 0 : α → Measure β) = 0 
goal: (m.bind fun x => 0) = 0

full_name: MeasureTheory.Measure.bind_apply
code: @[simp]
theorem bind_apply {m : Measure α} {f : α → Measure β} {s : Set β} (hs : MeasurableSet s)
    (hf : Measurable f) : bind m f s = ∫⁻ a, f a s ∂m 
goal: (m.bind f) s = ∫⁻ (a : α), (f a) s ∂m

full_name: MeasureTheory.Measure.measurable_bind'
code: theorem measurable_bind' {g : α → Measure β} (hg : Measurable g) : Measurable fun m => bind m g 
goal: Measurable fun m => m.bind g

full_name: MeasureTheory.Measure.lintegral_bind
code: theorem lintegral_bind {m : Measure α} {μ : α → Measure β} {f : β → ℝ≥0∞} (hμ : Measurable μ)
    (hf : Measurable f) : ∫⁻ x, f x ∂bind m μ = ∫⁻ a, ∫⁻ x, f x ∂μ a ∂m 
goal: ∫⁻ (x : β), f x ∂m.bind μ = ∫⁻ (a : α), ∫⁻ (x : β), f x ∂μ a ∂m

full_name: MeasureTheory.Measure.bind_bind
code: theorem bind_bind {γ} [MeasurableSpace γ] {m : Measure α} {f : α → Measure β} {g : β → Measure γ}
    (hf : Measurable f) (hg : Measurable g) : bind (bind m f) g = bind m fun a => bind (f a) g 
goal: (m.bind f).bind g = m.bind fun a => (f a).bind g

full_name: MeasureTheory.Measure.bind_dirac
code: theorem bind_dirac {f : α → Measure β} (hf : Measurable f) (a : α) : bind (dirac a) f = f a 
goal: (MeasureTheory.Measure.dirac a).bind f = f a

full_name: MeasureTheory.Measure.dirac_bind
code: theorem dirac_bind {m : Measure α} : bind m dirac = m 
goal: m.bind MeasureTheory.Measure.dirac = m

full_name: MeasureTheory.Measure.join_eq_bind
code: theorem join_eq_bind (μ : Measure (Measure α)) : join μ = bind μ id 
goal: μ.join = μ.bind id

full_name: MeasureTheory.Measure.join_map_map
code: theorem join_map_map {f : α → β} (hf : Measurable f) (μ : Measure (Measure α)) :
    join (map (map f) μ) = map f (join μ) 
goal: (MeasureTheory.Measure.map (MeasureTheory.Measure.map f) μ).join = MeasureTheory.Measure.map f μ.join

full_name: MeasureTheory.Measure.join_map_join
code: theorem join_map_join (μ : Measure (Measure (Measure α))) : join (map join μ) = join (join μ) 
goal: (MeasureTheory.Measure.map MeasureTheory.Measure.join μ).join = μ.join.join

full_name: MeasureTheory.Measure.join_map_dirac
code: theorem join_map_dirac (μ : Measure α) : join (map dirac μ) = μ 
goal: (MeasureTheory.Measure.map MeasureTheory.Measure.dirac μ).join = μ

full_name: MeasureTheory.Measure.join_dirac
code: theorem join_dirac (μ : Measure α) : join (dirac μ) = μ 
goal: (MeasureTheory.Measure.dirac μ).join = μ