File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

full_name: borel_eq_generateFrom_Iio
code: theorem borel_eq_generateFrom_Iio : borel α = .generateFrom (range Iio) 
goal: borel α = MeasurableSpace.generateFrom (Set.range Set.Iio)

full_name: borel_eq_generateFrom_Ioi
code: theorem borel_eq_generateFrom_Ioi : borel α = .generateFrom (range Ioi) 
goal: borel α = MeasurableSpace.generateFrom (Set.range Set.Ioi)

full_name: borel_eq_generateFrom_Iic
code: theorem borel_eq_generateFrom_Iic :
    borel α = MeasurableSpace.generateFrom (range Iic) 
goal: borel α = MeasurableSpace.generateFrom (Set.range Set.Iic)

full_name: borel_eq_generateFrom_Ici
code: theorem borel_eq_generateFrom_Ici : borel α = MeasurableSpace.generateFrom (range Ici) 
goal: borel α = MeasurableSpace.generateFrom (Set.range Set.Ici)

full_name: measurableSet_Ici
code: @[simp, measurability]
theorem measurableSet_Ici : MeasurableSet (Ici a) 
goal: MeasurableSet (Set.Ici a)

full_name: measurableSet_Iic
code: @[simp, measurability]
theorem measurableSet_Iic : MeasurableSet (Iic a) 
goal: MeasurableSet (Set.Iic a)

full_name: measurableSet_Icc
code: @[simp, measurability]
theorem measurableSet_Icc : MeasurableSet (Icc a b) 
goal: MeasurableSet (Set.Icc a b)

full_name: nhdsWithin_Ici_isMeasurablyGenerated
code: instance nhdsWithin_Ici_isMeasurablyGenerated : (𝓝[Ici b] a).IsMeasurablyGenerated 
goal: (𝓝[Set.Ici b] a).IsMeasurablyGenerated

full_name: nhdsWithin_Iic_isMeasurablyGenerated
code: instance nhdsWithin_Iic_isMeasurablyGenerated : (𝓝[Iic b] a).IsMeasurablyGenerated 
goal: (𝓝[Set.Iic b] a).IsMeasurablyGenerated

full_name: nhdsWithin_Icc_isMeasurablyGenerated
code: instance nhdsWithin_Icc_isMeasurablyGenerated : IsMeasurablyGenerated (𝓝[Icc a b] x) 
goal: (𝓝[Set.Icc a b] x).IsMeasurablyGenerated

full_name: atTop_isMeasurablyGenerated
code: instance atTop_isMeasurablyGenerated : (Filter.atTop : Filter α).IsMeasurablyGenerated 
goal: Filter.atTop.IsMeasurablyGenerated

full_name: atBot_isMeasurablyGenerated
code: instance atBot_isMeasurablyGenerated : (Filter.atBot : Filter α).IsMeasurablyGenerated 
goal: Filter.atBot.IsMeasurablyGenerated

full_name: instIsMeasurablyGeneratedCocompactOfR1Space
code: instance [R1Space α] : IsMeasurablyGenerated (cocompact α) 
goal: (Filter.cocompact α).IsMeasurablyGenerated

full_name: measurableSet_le'
code: @[measurability]
theorem measurableSet_le' : MeasurableSet { p : α × α | p.1 ≤ p.2 } 
goal: MeasurableSet {p | p.1 ≤ p.2}

full_name: measurableSet_le
code: @[measurability]
theorem measurableSet_le {f g : δ → α} (hf : Measurable f) (hg : Measurable g) :
    MeasurableSet { a | f a ≤ g a } 
goal: MeasurableSet {a | f a ≤ g a}

full_name: measurableSet_Iio
code: @[simp, measurability]
theorem measurableSet_Iio : MeasurableSet (Iio a) 
goal: MeasurableSet (Set.Iio a)

full_name: measurableSet_Ioi
code: @[simp, measurability]
theorem measurableSet_Ioi : MeasurableSet (Ioi a) 
goal: MeasurableSet (Set.Ioi a)

full_name: measurableSet_Ioo
code: @[simp, measurability]
theorem measurableSet_Ioo : MeasurableSet (Ioo a b) 
goal: MeasurableSet (Set.Ioo a b)

full_name: measurableSet_Ioc
code: @[simp, measurability]
theorem measurableSet_Ioc : MeasurableSet (Ioc a b) 
goal: MeasurableSet (Set.Ioc a b)

full_name: measurableSet_Ico
code: @[simp, measurability]
theorem measurableSet_Ico : MeasurableSet (Ico a b) 
goal: MeasurableSet (Set.Ico a b)

full_name: nhdsWithin_Ioi_isMeasurablyGenerated
code: instance nhdsWithin_Ioi_isMeasurablyGenerated : (𝓝[Ioi b] a).IsMeasurablyGenerated 
goal: (𝓝[Set.Ioi b] a).IsMeasurablyGenerated

full_name: nhdsWithin_Iio_isMeasurablyGenerated
code: instance nhdsWithin_Iio_isMeasurablyGenerated : (𝓝[Iio b] a).IsMeasurablyGenerated 
goal: (𝓝[Set.Iio b] a).IsMeasurablyGenerated

full_name: nhdsWithin_uIcc_isMeasurablyGenerated
code: instance nhdsWithin_uIcc_isMeasurablyGenerated : IsMeasurablyGenerated (𝓝[[[a, b]]] x) 
goal: (𝓝[Set.uIcc a b] x).IsMeasurablyGenerated

full_name: measurableSet_lt'
code: @[measurability]
theorem measurableSet_lt' [SecondCountableTopology α] : MeasurableSet { p : α × α | p.1 < p.2 } 
goal: MeasurableSet {p | p.1 < p.2}

full_name: measurableSet_lt
code: @[measurability]
theorem measurableSet_lt [SecondCountableTopology α] {f g : δ → α} (hf : Measurable f)
    (hg : Measurable g) : MeasurableSet { a | f a < g a } 
goal: MeasurableSet {a | f a < g a}

full_name: nullMeasurableSet_lt
code: theorem nullMeasurableSet_lt [SecondCountableTopology α] {μ : Measure δ} {f g : δ → α}
    (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : NullMeasurableSet { a | f a < g a } μ 
goal: MeasureTheory.NullMeasurableSet {a | f a < g a} μ

full_name: nullMeasurableSet_lt'
code: theorem nullMeasurableSet_lt' [SecondCountableTopology α] {μ : Measure (α × α)} :
    NullMeasurableSet { p : α × α | p.1 < p.2 } μ 
goal: MeasureTheory.NullMeasurableSet {p | p.1 < p.2} μ

full_name: nullMeasurableSet_le
code: theorem nullMeasurableSet_le [SecondCountableTopology α] {μ : Measure δ}
    {f g : δ → α} (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    NullMeasurableSet { a | f a ≤ g a } μ 
goal: MeasureTheory.NullMeasurableSet {a | f a ≤ g a} μ

full_name: Set.OrdConnected.measurableSet
code: theorem Set.OrdConnected.measurableSet (h : OrdConnected s) : MeasurableSet s 
goal: MeasurableSet s

full_name: IsPreconnected.measurableSet
code: theorem IsPreconnected.measurableSet (h : IsPreconnected s) : MeasurableSet s 
goal: MeasurableSet s

full_name: generateFrom_Ico_mem_le_borel
code: theorem generateFrom_Ico_mem_le_borel {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderClosedTopology α] (s t : Set α) :
    MeasurableSpace.generateFrom { S | ∃ l ∈ s, ∃ u ∈ t, l < u ∧ Ico l u = S }
      ≤ borel α 
goal: MeasurableSpace.generateFrom {S | ∃ l ∈ s, ∃ u ∈ t, l < u ∧ Set.Ico l u = S} ≤ borel α

full_name: Dense.borel_eq_generateFrom_Ico_mem_aux
code: theorem Dense.borel_eq_generateFrom_Ico_mem_aux {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] {s : Set α} (hd : Dense s)
    (hbot : ∀ x, IsBot x → x ∈ s) (hIoo : ∀ x y : α, x < y → Ioo x y = ∅ → y ∈ s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ico l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Set.Ico l u = S}

full_name: Dense.borel_eq_generateFrom_Ico_mem
code: theorem Dense.borel_eq_generateFrom_Ico_mem {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] [DenselyOrdered α] [NoMinOrder α] {s : Set α}
    (hd : Dense s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ico l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Set.Ico l u = S}

full_name: borel_eq_generateFrom_Ico
code: theorem borel_eq_generateFrom_Ico (α : Type*) [TopologicalSpace α] [SecondCountableTopology α]
    [LinearOrder α] [OrderTopology α] :
    borel α = .generateFrom { S : Set α | ∃ (l u : α), l < u ∧ Ico l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l u, l < u ∧ Set.Ico l u = S}

full_name: Dense.borel_eq_generateFrom_Ioc_mem_aux
code: theorem Dense.borel_eq_generateFrom_Ioc_mem_aux {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] {s : Set α} (hd : Dense s)
    (hbot : ∀ x, IsTop x → x ∈ s) (hIoo : ∀ x y : α, x < y → Ioo x y = ∅ → x ∈ s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ioc l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Set.Ioc l u = S}

full_name: Dense.borel_eq_generateFrom_Ioc_mem
code: theorem Dense.borel_eq_generateFrom_Ioc_mem {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] [DenselyOrdered α] [NoMaxOrder α] {s : Set α}
    (hd : Dense s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ioc l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Set.Ioc l u = S}

full_name: borel_eq_generateFrom_Ioc
code: theorem borel_eq_generateFrom_Ioc (α : Type*) [TopologicalSpace α] [SecondCountableTopology α]
    [LinearOrder α] [OrderTopology α] :
    borel α = .generateFrom { S : Set α | ∃ l u, l < u ∧ Ioc l u = S } 
goal: borel α = MeasurableSpace.generateFrom {S | ∃ l u, l < u ∧ Set.Ioc l u = S}

full_name: MeasureTheory.Measure.ext_of_Ico_finite
code: /-- Two finite measures on a Borel space are equal if they agree on all closed-open intervals.  If
`α` is a conditionally complete linear order with no top element,
`MeasureTheory.Measure.ext_of_Ico` is an extensionality lemma with weaker assumptions on `μ` and
`ν`. -/
theorem ext_of_Ico_finite {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] (μ ν : Measure α)
    [IsFiniteMeasure μ] (hμν : μ univ = ν univ) (h : ∀ ⦃a b⦄, a < b → μ (Ico a b) = ν (Ico a b)) :
    μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ioc_finite
code: /-- Two finite measures on a Borel space are equal if they agree on all open-closed intervals.  If
`α` is a conditionally complete linear order with no top element,
`MeasureTheory.Measure.ext_of_Ioc` is an extensionality lemma with weaker assumptions on `μ` and
`ν`. -/
theorem ext_of_Ioc_finite {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] (μ ν : Measure α)
    [IsFiniteMeasure μ] (hμν : μ univ = ν univ) (h : ∀ ⦃a b⦄, a < b → μ (Ioc a b) = ν (Ioc a b)) :
    μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ico'
code: /-- Two measures which are finite on closed-open intervals are equal if they agree on all
closed-open intervals. -/
theorem ext_of_Ico' {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] [NoMaxOrder α]
    (μ ν : Measure α) (hμ : ∀ ⦃a b⦄, a < b → μ (Ico a b) ≠ ∞)
    (h : ∀ ⦃a b⦄, a < b → μ (Ico a b) = ν (Ico a b)) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ioc'
code: /-- Two measures which are finite on closed-open intervals are equal if they agree on all
open-closed intervals. -/
theorem ext_of_Ioc' {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] [NoMinOrder α]
    (μ ν : Measure α) (hμ : ∀ ⦃a b⦄, a < b → μ (Ioc a b) ≠ ∞)
    (h : ∀ ⦃a b⦄, a < b → μ (Ioc a b) = ν (Ioc a b)) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ico
code: /-- Two measures which are finite on closed-open intervals are equal if they agree on all
closed-open intervals. -/
theorem ext_of_Ico {α : Type*} [TopologicalSpace α] {_m : MeasurableSpace α}
    [SecondCountableTopology α] [ConditionallyCompleteLinearOrder α] [OrderTopology α]
    [BorelSpace α] [NoMaxOrder α] (μ ν : Measure α) [IsLocallyFiniteMeasure μ]
    (h : ∀ ⦃a b⦄, a < b → μ (Ico a b) = ν (Ico a b)) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ioc
code: /-- Two measures which are finite on closed-open intervals are equal if they agree on all
open-closed intervals. -/
theorem ext_of_Ioc {α : Type*} [TopologicalSpace α] {_m : MeasurableSpace α}
    [SecondCountableTopology α] [ConditionallyCompleteLinearOrder α] [OrderTopology α]
    [BorelSpace α] [NoMinOrder α] (μ ν : Measure α) [IsLocallyFiniteMeasure μ]
    (h : ∀ ⦃a b⦄, a < b → μ (Ioc a b) = ν (Ioc a b)) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Iic
code: /-- Two finite measures on a Borel space are equal if they agree on all left-infinite right-closed
intervals. -/
theorem ext_of_Iic {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] (μ ν : Measure α)
    [IsFiniteMeasure μ] (h : ∀ a, μ (Iic a) = ν (Iic a)) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_Ici
code: /-- Two finite measures on a Borel space are equal if they agree on all left-closed right-infinite
intervals. -/
theorem ext_of_Ici {α : Type*} [TopologicalSpace α] {m : MeasurableSpace α}
    [SecondCountableTopology α] [LinearOrder α] [OrderTopology α] [BorelSpace α] (μ ν : Measure α)
    [IsFiniteMeasure μ] (h : ∀ a, μ (Ici a) = ν (Ici a)) : μ = ν 
goal: μ = ν

full_name: measurableSet_uIcc
code: @[measurability]
theorem measurableSet_uIcc : MeasurableSet (uIcc a b) 
goal: MeasurableSet (Set.uIcc a b)

full_name: measurableSet_uIoc
code: @[measurability]
theorem measurableSet_uIoc : MeasurableSet (uIoc a b) 
goal: MeasurableSet (Ι a b)

full_name: Measurable.max
code: @[measurability]
theorem Measurable.max {f g : δ → α} (hf : Measurable f) (hg : Measurable g) :
    Measurable fun a => max (f a) (g a) 
goal: Measurable fun a => max (f a) (g a)

full_name: AEMeasurable.max
code: @[measurability]
nonrec theorem AEMeasurable.max {f g : δ → α} {μ : Measure δ} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g μ) : AEMeasurable (fun a => max (f a) (g a)) μ 
goal: AEMeasurable (fun a => max (f a) (g a)) μ

full_name: Measurable.min
code: @[measurability]
theorem Measurable.min {f g : δ → α} (hf : Measurable f) (hg : Measurable g) :
    Measurable fun a => min (f a) (g a) 
goal: Measurable fun a => min (f a) (g a)

full_name: AEMeasurable.min
code: @[measurability]
nonrec theorem AEMeasurable.min {f g : δ → α} {μ : Measure δ} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g μ) : AEMeasurable (fun a => min (f a) (g a)) μ 
goal: AEMeasurable (fun a => min (f a) (g a)) μ

full_name: ContinuousSup.measurableSup
code: instance (priority := 100) ContinuousSup.measurableSup [Sup γ] [ContinuousSup γ] :
    MeasurableSup γ 
goal: MeasurableSup γ

full_name: ContinuousSup.measurableSup₂
code: instance (priority := 100) ContinuousSup.measurableSup₂ [SecondCountableTopology γ] [Sup γ]
    [ContinuousSup γ] : MeasurableSup₂ γ 
goal: MeasurableSup₂ γ

full_name: ContinuousInf.measurableInf
code: instance (priority := 100) ContinuousInf.measurableInf [Inf γ] [ContinuousInf γ] :
    MeasurableInf γ 
goal: MeasurableInf γ

full_name: ContinuousInf.measurableInf₂
code: instance (priority := 100) ContinuousInf.measurableInf₂ [SecondCountableTopology γ] [Inf γ]
    [ContinuousInf γ] : MeasurableInf₂ γ 
goal: MeasurableInf₂ γ

full_name: measurable_of_Iio
code: theorem measurable_of_Iio {f : δ → α} (hf : ∀ x, MeasurableSet (f ⁻¹' Iio x)) : Measurable f 
goal: Measurable f

full_name: UpperSemicontinuous.measurable
code: theorem UpperSemicontinuous.measurable [TopologicalSpace δ] [OpensMeasurableSpace δ] {f : δ → α}
    (hf : UpperSemicontinuous f) : Measurable f 
goal: Measurable f

full_name: measurable_of_Ioi
code: theorem measurable_of_Ioi {f : δ → α} (hf : ∀ x, MeasurableSet (f ⁻¹' Ioi x)) : Measurable f 
goal: Measurable f

full_name: LowerSemicontinuous.measurable
code: theorem LowerSemicontinuous.measurable [TopologicalSpace δ] [OpensMeasurableSpace δ] {f : δ → α}
    (hf : LowerSemicontinuous f) : Measurable f 
goal: Measurable f

full_name: measurable_of_Iic
code: theorem measurable_of_Iic {f : δ → α} (hf : ∀ x, MeasurableSet (f ⁻¹' Iic x)) : Measurable f 
goal: Measurable f

full_name: measurable_of_Ici
code: theorem measurable_of_Ici {f : δ → α} (hf : ∀ x, MeasurableSet (f ⁻¹' Ici x)) : Measurable f 
goal: Measurable f

full_name: Measurable.isLUB
code: /-- If a function is the least upper bound of countably many measurable functions,
then it is measurable. -/
theorem Measurable.isLUB {ι} [Countable ι] {f : ι → δ → α} {g : δ → α} (hf : ∀ i, Measurable (f i))
    (hg : ∀ b, IsLUB { a | ∃ i, f i b = a } (g b)) : Measurable g 
goal: Measurable g

full_name: Measurable.isLUB_of_mem
code: /-- If a function is the least upper bound of countably many measurable functions on a measurable
set `s`, and coincides with a measurable function outside of `s`, then it is measurable. -/
theorem Measurable.isLUB_of_mem {ι} [Countable ι] {f : ι → δ → α} {g g' : δ → α}
    (hf : ∀ i, Measurable (f i))
    {s : Set δ} (hs : MeasurableSet s) (hg : ∀ b ∈ s, IsLUB { a | ∃ i, f i b = a } (g b))
    (hg' : EqOn g g' sᶜ) (g'_meas : Measurable g') : Measurable g 
goal: Measurable g

full_name: AEMeasurable.isLUB
code: theorem AEMeasurable.isLUB {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α} {g : δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hg : ∀ᵐ b ∂μ, IsLUB { a | ∃ i, f i b = a } (g b)) :
    AEMeasurable g μ 
goal: AEMeasurable g μ

full_name: Measurable.isGLB
code: /-- If a function is the greatest lower bound of countably many measurable functions,
then it is measurable. -/
theorem Measurable.isGLB {ι} [Countable ι] {f : ι → δ → α} {g : δ → α} (hf : ∀ i, Measurable (f i))
    (hg : ∀ b, IsGLB { a | ∃ i, f i b = a } (g b)) : Measurable g 
goal: Measurable g

full_name: Measurable.isGLB_of_mem
code: /-- If a function is the greatest lower bound of countably many measurable functions on a measurable
set `s`, and coincides with a measurable function outside of `s`, then it is measurable. -/
theorem Measurable.isGLB_of_mem {ι} [Countable ι] {f : ι → δ → α} {g g' : δ → α}
    (hf : ∀ i, Measurable (f i))
    {s : Set δ} (hs : MeasurableSet s) (hg : ∀ b ∈ s, IsGLB { a | ∃ i, f i b = a } (g b))
    (hg' : EqOn g g' sᶜ) (g'_meas : Measurable g') : Measurable g 
goal: Measurable g

full_name: AEMeasurable.isGLB
code: theorem AEMeasurable.isGLB {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α} {g : δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) (hg : ∀ᵐ b ∂μ, IsGLB { a | ∃ i, f i b = a } (g b)) :
    AEMeasurable g μ 
goal: AEMeasurable g μ

full_name: Monotone.measurable
code: protected theorem Monotone.measurable [LinearOrder β] [OrderClosedTopology β] {f : β → α}
    (hf : Monotone f) : Measurable f 
goal: Measurable f

full_name: aemeasurable_restrict_of_monotoneOn
code: theorem aemeasurable_restrict_of_monotoneOn [LinearOrder β] [OrderClosedTopology β] {μ : Measure β}
    {s : Set β} (hs : MeasurableSet s) {f : β → α} (hf : MonotoneOn f s) :
    AEMeasurable f (μ.restrict s) 
goal: AEMeasurable f (μ.restrict s)

full_name: Antitone.measurable
code: protected theorem Antitone.measurable [LinearOrder β] [OrderClosedTopology β] {f : β → α}
    (hf : Antitone f) : Measurable f 
goal: Measurable f

full_name: aemeasurable_restrict_of_antitoneOn
code: theorem aemeasurable_restrict_of_antitoneOn [LinearOrder β] [OrderClosedTopology β] {μ : Measure β}
    {s : Set β} (hs : MeasurableSet s) {f : β → α} (hf : AntitoneOn f s) :
    AEMeasurable f (μ.restrict s) 
goal: AEMeasurable f (μ.restrict s)

full_name: measurableSet_of_mem_nhdsWithin_Ioi_aux
code: theorem measurableSet_of_mem_nhdsWithin_Ioi_aux {s : Set α} (h : ∀ x ∈ s, s ∈ 𝓝[>] x)
    (h' : ∀ x ∈ s, ∃ y, x < y) : MeasurableSet s 
goal: MeasurableSet s

full_name: measurableSet_of_mem_nhdsWithin_Ioi
code: /-- If a set is a right-neighborhood of all of its points, then it is measurable. -/
theorem measurableSet_of_mem_nhdsWithin_Ioi {s : Set α} (h : ∀ x ∈ s, s ∈ 𝓝[>] x) :
    MeasurableSet s 
goal: MeasurableSet s

full_name: measurableSet_bddAbove_range
code: lemma measurableSet_bddAbove_range {ι} [Countable ι] {f : ι → δ → α} (hf : ∀ i, Measurable (f i)) :
    MeasurableSet {b | BddAbove (range (fun i ↦ f i b))} 
goal: MeasurableSet {b | BddAbove (Set.range fun i => f i b)}

full_name: measurableSet_bddBelow_range
code: lemma measurableSet_bddBelow_range {ι} [Countable ι] {f : ι → δ → α} (hf : ∀ i, Measurable (f i)) :
    MeasurableSet {b | BddBelow (range (fun i ↦ f i b))} 
goal: MeasurableSet {b | BddBelow (Set.range fun i => f i b)}

full_name: Measurable.iSup_Prop
code: @[measurability]
theorem Measurable.iSup_Prop {α} [MeasurableSpace α] [ConditionallyCompleteLattice α]
    (p : Prop) {f : δ → α} (hf : Measurable f) : Measurable fun b => ⨆ _ : p, f b 
goal: Measurable fun b => ⨆ (_ : p), f b

full_name: Measurable.iInf_Prop
code: @[measurability]
theorem Measurable.iInf_Prop {α} [MeasurableSpace α] [ConditionallyCompleteLattice α]
    (p : Prop) {f : δ → α} (hf : Measurable f) : Measurable fun b => ⨅ _ : p, f b 
goal: Measurable fun b => ⨅ (_ : p), f b

full_name: measurable_iSup
code: @[measurability]
theorem measurable_iSup {ι} [Countable ι] {f : ι → δ → α} (hf : ∀ i, Measurable (f i)) :
    Measurable (fun b ↦ ⨆ i, f i b) 
goal: Measurable fun b => ⨆ i, f i b

full_name: aemeasurable_iSup
code: @[measurability]
theorem aemeasurable_iSup {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨆ i, f i b) μ 
goal: AEMeasurable (fun b => ⨆ i, f i b) μ

full_name: measurable_iInf
code: @[measurability]
theorem measurable_iInf {ι} [Countable ι] {f : ι → δ → α} (hf : ∀ i, Measurable (f i)) :
    Measurable fun b => ⨅ i, f i b 
goal: Measurable fun b => ⨅ i, f i b

full_name: aemeasurable_iInf
code: @[measurability]
theorem aemeasurable_iInf {ι} {μ : Measure δ} [Countable ι] {f : ι → δ → α}
    (hf : ∀ i, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨅ i, f i b) μ 
goal: AEMeasurable (fun b => ⨅ i, f i b) μ

full_name: measurable_sSup
code: theorem measurable_sSup {ι} {f : ι → δ → α} {s : Set ι} (hs : s.Countable)
    (hf : ∀ i ∈ s, Measurable (f i)) :
    Measurable fun x => sSup ((fun i => f i x) '' s) 
goal: Measurable fun x => sSup ((fun i => f i x) '' s)

full_name: measurable_sInf
code: theorem measurable_sInf {ι} {f : ι → δ → α} {s : Set ι} (hs : s.Countable)
    (hf : ∀ i ∈ s, Measurable (f i)) :
    Measurable fun x => sInf ((fun i => f i x) '' s) 
goal: Measurable fun x => sInf ((fun i => f i x) '' s)

full_name: measurable_biSup
code: theorem measurable_biSup {ι} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, Measurable (f i)) : Measurable fun b => ⨆ i ∈ s, f i b 
goal: Measurable fun b => ⨆ i ∈ s, f i b

full_name: aemeasurable_biSup
code: theorem aemeasurable_biSup {ι} {μ : Measure δ} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨆ i ∈ s, f i b) μ 
goal: AEMeasurable (fun b => ⨆ i ∈ s, f i b) μ

full_name: measurable_biInf
code: theorem measurable_biInf {ι} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, Measurable (f i)) : Measurable fun b => ⨅ i ∈ s, f i b 
goal: Measurable fun b => ⨅ i ∈ s, f i b

full_name: aemeasurable_biInf
code: theorem aemeasurable_biInf {ι} {μ : Measure δ} (s : Set ι) {f : ι → δ → α} (hs : s.Countable)
    (hf : ∀ i ∈ s, AEMeasurable (f i) μ) : AEMeasurable (fun b => ⨅ i ∈ s, f i b) μ 
goal: AEMeasurable (fun b => ⨅ i ∈ s, f i b) μ

full_name: measurable_liminf'
code: /-- `liminf` over a general filter is measurable. See `measurable_liminf` for the version over `ℕ`.
-/
theorem measurable_liminf' {ι ι'} {f : ι → δ → α} {v : Filter ι} (hf : ∀ i, Measurable (f i))
    {p : ι' → Prop} {s : ι' → Set ι} (hv : v.HasCountableBasis p s) (hs : ∀ j, (s j).Countable) :
    Measurable fun x => liminf (f · x) v 
goal: Measurable fun x => Filter.liminf (fun x_1 => f x_1 x) v

full_name: measurable_limsup'
code: /-- `limsup` over a general filter is measurable. See `measurable_limsup` for the version over `ℕ`.
-/
theorem measurable_limsup' {ι ι'} {f : ι → δ → α} {u : Filter ι} (hf : ∀ i, Measurable (f i))
    {p : ι' → Prop} {s : ι' → Set ι} (hu : u.HasCountableBasis p s) (hs : ∀ i, (s i).Countable) :
    Measurable fun x => limsup (fun i => f i x) u 
goal: Measurable fun x => Filter.limsup (fun i => f i x) u

full_name: measurable_liminf
code: /-- `liminf` over `ℕ` is measurable. See `measurable_liminf'` for a version with a general filter.
-/
@[measurability]
theorem measurable_liminf {f : ℕ → δ → α} (hf : ∀ i, Measurable (f i)) :
    Measurable fun x => liminf (fun i => f i x) atTop 
goal: Measurable fun x => Filter.liminf (fun i => f i x) Filter.atTop

full_name: measurable_limsup
code: /-- `limsup` over `ℕ` is measurable. See `measurable_limsup'` for a version with a general filter.
-/
@[measurability]
theorem measurable_limsup {f : ℕ → δ → α} (hf : ∀ i, Measurable (f i)) :
    Measurable fun x => limsup (fun i => f i x) atTop 
goal: Measurable fun x => Filter.limsup (fun i => f i x) Filter.atTop

full_name: Homemorph.toMeasurableEquiv
code: /-- Convert a `Homeomorph` to a `MeasurableEquiv`. -/
def Homemorph.toMeasurableEquiv (h : α ≃ₜ β) : α ≃ᵐ β 
goal: α ≃ᵐ β

full_name: IsFiniteMeasureOnCompacts.map
code: protected theorem IsFiniteMeasureOnCompacts.map (μ : Measure α) [IsFiniteMeasureOnCompacts μ]
    (f : α ≃ₜ β) : IsFiniteMeasureOnCompacts (Measure.map f μ) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (MeasureTheory.Measure.map (⇑f) μ)

full_name: measure_eq_measure_preimage_add_measure_tsum_Ico_zpow
code: /-- One can cut out `ℝ≥0∞` into the sets `{0}`, `Ico (t^n) (t^(n+1))` for `n : ℤ` and `{∞}`. This
gives a way to compute the measure of a set in terms of sets on which a given function `f` does not
fluctuate by more than `t`. -/
theorem measure_eq_measure_preimage_add_measure_tsum_Ico_zpow {α : Type*} [MeasurableSpace α]
    (μ : Measure α) {f : α → ℝ≥0∞} (hf : Measurable f) {s : Set α} (hs : MeasurableSet s)
    {t : ℝ≥0} (ht : 1 < t) :
    μ s =
      μ (s ∩ f ⁻¹' {0}) + μ (s ∩ f ⁻¹' {∞}) +
      ∑' n : ℤ, μ (s ∩ f ⁻¹' Ico ((t : ℝ≥0∞) ^ n) ((t : ℝ≥0∞) ^ (n + 1))) 
goal: μ s = μ (s ∩ f ⁻¹' {0}) + μ (s ∩ f ⁻¹' {⊤}) + ∑' (n : ℤ), μ (s ∩ f ⁻¹' Set.Ico (↑t ^ n) (↑t ^ (n + 1)))