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

full_name: borel
code: /-- `MeasurableSpace` structure generated by `TopologicalSpace`. -/
def borel (α : Type u) [TopologicalSpace α] : MeasurableSpace α 
goal: MeasurableSpace α

full_name: borel_anti
code: theorem borel_anti : Antitone (@borel α) 
goal: Antitone (@borel α)

full_name: borel_eq_top_of_discrete
code: theorem borel_eq_top_of_discrete [TopologicalSpace α] [DiscreteTopology α] : borel α = ⊤ 
goal: borel α = ⊤

full_name: borel_eq_top_of_countable
code: theorem borel_eq_top_of_countable [TopologicalSpace α] [T1Space α] [Countable α] : borel α = ⊤ 
goal: borel α = ⊤

full_name: borel_eq_generateFrom_of_subbasis
code: theorem borel_eq_generateFrom_of_subbasis {s : Set (Set α)} [t : TopologicalSpace α]
    [SecondCountableTopology α] (hs : t = .generateFrom s) : borel α = .generateFrom s 
goal: borel α = MeasurableSpace.generateFrom s

full_name: TopologicalSpace.IsTopologicalBasis.borel_eq_generateFrom
code: theorem TopologicalSpace.IsTopologicalBasis.borel_eq_generateFrom [TopologicalSpace α]
    [SecondCountableTopology α] {s : Set (Set α)} (hs : IsTopologicalBasis s) :
    borel α = .generateFrom s 
goal: borel α = MeasurableSpace.generateFrom s

full_name: isPiSystem_isOpen
code: theorem isPiSystem_isOpen [TopologicalSpace α] : IsPiSystem ({s : Set α | IsOpen s}) 
goal: IsPiSystem {s | IsOpen s}

full_name: isPiSystem_isClosed
code: lemma isPiSystem_isClosed [TopologicalSpace α] : IsPiSystem ({s : Set α | IsClosed s}) 
goal: IsPiSystem {s | IsClosed s}

full_name: borel_eq_generateFrom_isClosed
code: theorem borel_eq_generateFrom_isClosed [TopologicalSpace α] :
    borel α = .generateFrom { s | IsClosed s } 
goal: borel α = MeasurableSpace.generateFrom {s | IsClosed s}

full_name: borel_comap
code: theorem borel_comap {f : α → β} {t : TopologicalSpace β} :
    @borel α (t.induced f) = (@borel β t).comap f 
goal: borel α = MeasurableSpace.comap f (borel β)

full_name: Continuous.borel_measurable
code: theorem Continuous.borel_measurable [TopologicalSpace α] [TopologicalSpace β] {f : α → β}
    (hf : Continuous f) : @Measurable α β (borel α) (borel β) f 
goal: Measurable f

full_name: OpensMeasurableSpace
code: /-- A space with `MeasurableSpace` and `TopologicalSpace` structures such that
all open sets are measurable. -/
class OpensMeasurableSpace (α : Type*) [TopologicalSpace α] [h : MeasurableSpace α] : Prop where
  /-- Borel-measurable sets are measurable. -/
  borel_le : borel α ≤ h
goal: Prop

full_name: OpensMeasurableSpace.borel_le
code: /-- A space with `MeasurableSpace` and `TopologicalSpace` structures such that
all open sets are measurable. -/
class OpensMeasurableSpace (α : Type*) [TopologicalSpace α] [h : MeasurableSpace α] : Prop where
  /-- Borel-measurable sets are measurable. -/
  borel_le : borel α ≤ h
goal: borel α ≤ h

full_name: BorelSpace.measurable_eq
code: /-- A space with `MeasurableSpace` and `TopologicalSpace` structures such that
the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets. -/
class BorelSpace (α : Type*) [TopologicalSpace α] [MeasurableSpace α] : Prop where
  /-- The measurable sets are exactly the Borel-measurable sets. -/
  measurable_eq : ‹MeasurableSpace α› = borel α
goal: inst✝ = borel α

full_name: BorelSpace
code: /-- A space with `MeasurableSpace` and `TopologicalSpace` structures such that
the `σ`-algebra of measurable sets is exactly the `σ`-algebra generated by open sets. -/
class BorelSpace (α : Type*) [TopologicalSpace α] [MeasurableSpace α] : Prop where
  /-- The measurable sets are exactly the Borel-measurable sets. -/
  measurable_eq : ‹MeasurableSpace α› = borel α
goal: Prop

full_name: Mathlib.Tactic.Borelize.tacticBorelize___
code: /-- The behaviour of `borelize α` depends on the existing assumptions on `α`.

- if `α` is a topological space with instances `[MeasurableSpace α] [BorelSpace α]`, then
  `borelize α` replaces the former instance by `borel α`;
- otherwise, `borelize α` adds instances `borel α : MeasurableSpace α` and `⟨rfl⟩ : BorelSpace α`.

Finally, `borelize α β γ` runs `borelize α; borelize β; borelize γ`.
-/
syntax "borelize" (ppSpace colGt term:max)* : tactic
goal: Lean.ParserDescr

full_name: Mathlib.Tactic.Borelize.addBorelInstance
code: /-- Add instances `borel e : MeasurableSpace e` and `⟨rfl⟩ : BorelSpace e`. -/
def addBorelInstance (e : Expr) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Mathlib.Tactic.Borelize.borelToRefl
code: /-- Given a type `e`, an assumption `i : MeasurableSpace e`, and an instance `[BorelSpace e]`,
replace `i` with `borel e`. -/
def borelToRefl (e : Expr) (i : FVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Mathlib.Tactic.Borelize.borelize
code: /-- Given a type `$t`, if there is an assumption `[i : MeasurableSpace $t]`, then try to prove
`[BorelSpace $t]` and replace `i` with `borel $t`. Otherwise, add instances
`borel $t : MeasurableSpace $t` and `⟨rfl⟩ : BorelSpace $t`. -/
def borelize (t : Term) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Mathlib.Tactic.Borelize._aux_Mathlib_MeasureTheory_Constructions_BorelSpace_Basic___elabRules_Mathlib_Tactic_Borelize_tacticBorelize____1
code: elab_rules : tactic
  | `(tactic| borelize $[$t:term]*) => t.forM borelize
goal: Lean.Elab.Tactic.Tactic

full_name: OrderDual.opensMeasurableSpace
code: instance (priority := 100) OrderDual.opensMeasurableSpace {α : Type*} [TopologicalSpace α]
    [MeasurableSpace α] [h : OpensMeasurableSpace α] : OpensMeasurableSpace αᵒᵈ 
goal: OpensMeasurableSpace αᵒᵈ

full_name: OrderDual.borelSpace
code: instance (priority := 100) OrderDual.borelSpace {α : Type*} [TopologicalSpace α]
    [MeasurableSpace α] [h : BorelSpace α] : BorelSpace αᵒᵈ 
goal: BorelSpace αᵒᵈ

full_name: BorelSpace.opensMeasurable
code: /-- In a `BorelSpace` all open sets are measurable. -/
instance (priority := 100) BorelSpace.opensMeasurable {α : Type*} [TopologicalSpace α]
    [MeasurableSpace α] [BorelSpace α] : OpensMeasurableSpace α 
goal: OpensMeasurableSpace α

full_name: Subtype.borelSpace
code: instance Subtype.borelSpace {α : Type*} [TopologicalSpace α] [MeasurableSpace α]
    [hα : BorelSpace α] (s : Set α) : BorelSpace s 
goal: BorelSpace ↑s

full_name: Countable.instBorelSpace
code: instance Countable.instBorelSpace [Countable α] [MeasurableSpace α] [MeasurableSingletonClass α]
    [TopologicalSpace α] [DiscreteTopology α] : BorelSpace α 
goal: BorelSpace α

full_name: Subtype.opensMeasurableSpace
code: instance Subtype.opensMeasurableSpace {α : Type*} [TopologicalSpace α] [MeasurableSpace α]
    [h : OpensMeasurableSpace α] (s : Set α) : OpensMeasurableSpace s 
goal: OpensMeasurableSpace ↑s

full_name: opensMeasurableSpace_iff_forall_measurableSet
code: lemma opensMeasurableSpace_iff_forall_measurableSet
    [TopologicalSpace α] [MeasurableSpace α] :
    OpensMeasurableSpace α ↔  (∀ (s : Set α), IsOpen s → MeasurableSet s) 
goal: OpensMeasurableSpace α ↔ ∀ (s : Set α), IsOpen s → MeasurableSet s

full_name: BorelSpace.countablyGenerated
code: instance (priority := 100) BorelSpace.countablyGenerated {α : Type*} [TopologicalSpace α]
    [MeasurableSpace α] [BorelSpace α] [SecondCountableTopology α] : CountablyGenerated α 
goal: MeasurableSpace.CountablyGenerated α

full_name: MeasurableSet.induction_on_open
code: theorem MeasurableSet.induction_on_open [TopologicalSpace α] [MeasurableSpace α] [BorelSpace α]
    {C : Set α → Prop} (h_open : ∀ U, IsOpen U → C U)
    (h_compl : ∀ t, MeasurableSet t → C t → C tᶜ)
    (h_union :
      ∀ f : ℕ → Set α,
        Pairwise (Disjoint on f) → (∀ i, MeasurableSet (f i)) → (∀ i, C (f i)) → C (⋃ i, f i)) :
    ∀ ⦃t⦄, MeasurableSet t → C t 
goal: MeasurableSet t → C t

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

full_name: IsOpen.nullMeasurableSet
code: theorem IsOpen.nullMeasurableSet {μ} (h : IsOpen s) : NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ

full_name: instCountablySeparatedElemOfHasCountableSeparatingOnIsOpen
code: instance (priority := 1000) {s : Set α} [h : HasCountableSeparatingOn α IsOpen s] :
    CountablySeparated s 
goal: MeasurableSpace.CountablySeparated ↑s

full_name: measurableSet_interior
code: @[measurability]
theorem measurableSet_interior : MeasurableSet (interior s) 
goal: MeasurableSet (interior s)

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

full_name: measurableSet_of_continuousAt
code: theorem measurableSet_of_continuousAt {β} [EMetricSpace β] (f : α → β) :
    MeasurableSet { x | ContinuousAt f x } 
goal: MeasurableSet {x | ContinuousAt f x}

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

full_name: IsClosed.nullMeasurableSet
code: theorem IsClosed.nullMeasurableSet {μ} (h : IsClosed s) : NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ

full_name: IsCompact.measurableSet
code: theorem IsCompact.measurableSet [T2Space α] (h : IsCompact s) : MeasurableSet s 
goal: MeasurableSet s

full_name: Inseparable.mem_measurableSet_iff
code: /-- If two points are topologically inseparable,
then they can't be separated by a Borel measurable set. -/
theorem Inseparable.mem_measurableSet_iff {x y : γ} (h : Inseparable x y) {s : Set γ}
    (hs : MeasurableSet s) : x ∈ s ↔ y ∈ s 
goal: x ∈ s ↔ y ∈ s

full_name: IsCompact.closure_subset_measurableSet
code: /-- If `K` is a compact set in an R₁ space and `s ⊇ K` is a Borel measurable superset,
then `s` includes the closure of `K` as well. -/
theorem IsCompact.closure_subset_measurableSet [R1Space γ] {K s : Set γ} (hK : IsCompact K)
    (hs : MeasurableSet s) (hKs : K ⊆ s) : closure K ⊆ s 
goal: closure K ⊆ s

full_name: IsCompact.measure_closure
code: /-- In an R₁ topological space with Borel measure `μ`,
the measure of the closure of a compact set `K` is equal to the measure of `K`.

See also `MeasureTheory.Measure.OuterRegular.measure_closure_eq_of_isCompact`
for a version that assumes `μ` to be outer regular
but does not assume the `σ`-algebra to be Borel.  -/
theorem IsCompact.measure_closure [R1Space γ] {K : Set γ} (hK : IsCompact K) (μ : Measure γ) :
    μ (closure K) = μ K 
goal: μ (closure K) = μ K

full_name: measurableSet_closure
code: @[measurability]
theorem measurableSet_closure : MeasurableSet (closure s) 
goal: MeasurableSet (closure s)

full_name: measurable_of_isOpen
code: theorem measurable_of_isOpen {f : δ → γ} (hf : ∀ s, IsOpen s → MeasurableSet (f ⁻¹' s)) :
    Measurable f 
goal: Measurable f

full_name: measurable_of_isClosed
code: theorem measurable_of_isClosed {f : δ → γ} (hf : ∀ s, IsClosed s → MeasurableSet (f ⁻¹' s)) :
    Measurable f 
goal: Measurable f

full_name: measurable_of_isClosed'
code: theorem measurable_of_isClosed' {f : δ → γ}
    (hf : ∀ s, IsClosed s → s.Nonempty → s ≠ univ → MeasurableSet (f ⁻¹' s)) : Measurable f 
goal: Measurable f

full_name: nhds_isMeasurablyGenerated
code: instance nhds_isMeasurablyGenerated (a : α) : (𝓝 a).IsMeasurablyGenerated 
goal: (𝓝 a).IsMeasurablyGenerated

full_name: MeasurableSet.nhdsWithin_isMeasurablyGenerated
code: /-- If `s` is a measurable set, then `𝓝[s] a` is a measurably generated filter for
each `a`. This cannot be an `instance` because it depends on a non-instance `hs : MeasurableSet s`.
-/
theorem MeasurableSet.nhdsWithin_isMeasurablyGenerated {s : Set α} (hs : MeasurableSet s) (a : α) :
    (𝓝[s] a).IsMeasurablyGenerated 
goal: (𝓝[s] a).IsMeasurablyGenerated

full_name: OpensMeasurableSpace.separatesPoints
code: instance (priority := 100) OpensMeasurableSpace.separatesPoints [T0Space α] :
    SeparatesPoints α 
goal: MeasurableSpace.SeparatesPoints α

full_name: OpensMeasurableSpace.toMeasurableSingletonClass
code: instance (priority := 100) OpensMeasurableSpace.toMeasurableSingletonClass [T1Space α] :
    MeasurableSingletonClass α 
goal: MeasurableSingletonClass α

full_name: Pi.opensMeasurableSpace
code: instance Pi.opensMeasurableSpace {ι : Type*} {π : ι → Type*} [Countable ι]
    [t' : ∀ i, TopologicalSpace (π i)] [∀ i, MeasurableSpace (π i)]
    [∀ i, SecondCountableTopology (π i)] [∀ i, OpensMeasurableSpace (π i)] :
    OpensMeasurableSpace (∀ i, π i) 
goal: OpensMeasurableSpace ((i : ι) → π i)

full_name: SecondCountableTopologyEither
code: /-- The typeclass `SecondCountableTopologyEither α β` registers the fact that at least one of
the two spaces has second countable topology. This is the right assumption to ensure that continuous
maps from `α` to `β` are strongly measurable. -/
class SecondCountableTopologyEither (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] :
  Prop where
  /-- The projection out of `SecondCountableTopologyEither` -/
  out : SecondCountableTopology α ∨ SecondCountableTopology β
goal: Prop

full_name: SecondCountableTopologyEither.out
code: /-- The typeclass `SecondCountableTopologyEither α β` registers the fact that at least one of
the two spaces has second countable topology. This is the right assumption to ensure that continuous
maps from `α` to `β` are strongly measurable. -/
class SecondCountableTopologyEither (α β : Type*) [TopologicalSpace α] [TopologicalSpace β] :
  Prop where
  /-- The projection out of `SecondCountableTopologyEither` -/
  out : SecondCountableTopology α ∨ SecondCountableTopology β
goal: SecondCountableTopology α ∨ SecondCountableTopology β

full_name: secondCountableTopologyEither_of_left
code: instance (priority := 100) secondCountableTopologyEither_of_left (α β : Type*) [TopologicalSpace α]
    [TopologicalSpace β] [SecondCountableTopology α] : SecondCountableTopologyEither α β 
goal: SecondCountableTopologyEither α β

full_name: secondCountableTopologyEither_of_right
code: instance (priority := 100) secondCountableTopologyEither_of_right (α β : Type*)
    [TopologicalSpace α] [TopologicalSpace β] [SecondCountableTopology β] :
    SecondCountableTopologyEither α β 
goal: SecondCountableTopologyEither α β

full_name: Prod.opensMeasurableSpace
code: /-- If either `α` or `β` has second-countable topology, then the open sets in `α × β` belong to the
product sigma-algebra. -/
instance Prod.opensMeasurableSpace [h : SecondCountableTopologyEither α β] :
    OpensMeasurableSpace (α × β) 
goal: OpensMeasurableSpace (α × β)

full_name: interior_ae_eq_of_null_frontier
code: theorem interior_ae_eq_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    interior s =ᵐ[μ] s 
goal: interior s =ᵐ[μ] s

full_name: measure_interior_of_null_frontier
code: theorem measure_interior_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    μ (interior s) = μ s 
goal: μ (interior s) = μ s

full_name: nullMeasurableSet_of_null_frontier
code: theorem nullMeasurableSet_of_null_frontier {s : Set α} {μ : Measure α} (h : μ (frontier s) = 0) :
    NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ

full_name: closure_ae_eq_of_null_frontier
code: theorem closure_ae_eq_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    closure s =ᵐ[μ] s 
goal: closure s =ᵐ[μ] s

full_name: measure_closure_of_null_frontier
code: theorem measure_closure_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    μ (closure s) = μ s 
goal: μ (closure s) = μ s

full_name: separatesPointsOfOpensMeasurableSpaceOfT0Space
code: instance separatesPointsOfOpensMeasurableSpaceOfT0Space [T0Space α] :
    MeasurableSpace.SeparatesPoints α 
goal: MeasurableSpace.SeparatesPoints α

full_name: Continuous.measurable
code: /-- A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is measurable. -/
@[fun_prop]
theorem Continuous.measurable {f : α → γ} (hf : Continuous f) : Measurable f 
goal: Measurable f

full_name: Continuous.aemeasurable
code: /-- A continuous function from an `OpensMeasurableSpace` to a `BorelSpace`
is ae-measurable. -/
theorem Continuous.aemeasurable {f : α → γ} (h : Continuous f) {μ : Measure α} : AEMeasurable f μ 
goal: AEMeasurable f μ

full_name: ClosedEmbedding.measurable
code: theorem ClosedEmbedding.measurable {f : α → γ} (hf : ClosedEmbedding f) : Measurable f 
goal: Measurable f

full_name: ContinuousOn.measurable_piecewise
code: /-- If a function is defined piecewise in terms of functions which are continuous on their
respective pieces, then it is measurable. -/
theorem ContinuousOn.measurable_piecewise {f g : α → γ} {s : Set α} [∀ j : α, Decidable (j ∈ s)]
    (hf : ContinuousOn f s) (hg : ContinuousOn g sᶜ) (hs : MeasurableSet s) :
    Measurable (s.piecewise f g) 
goal: Measurable (s.piecewise f g)

full_name: ContinuousMul.measurableMul
code: @[to_additive]
instance (priority := 100) ContinuousMul.measurableMul [Mul γ] [ContinuousMul γ] :
    MeasurableMul γ 
goal: MeasurableMul γ

full_name: ContinuousAdd.measurableAdd
code: @[to_additive]
instance (priority := 100) ContinuousMul.measurableMul [Mul γ] [ContinuousMul γ] :
    MeasurableMul γ 
goal: MeasurableAdd γ

full_name: ContinuousSub.measurableSub
code: instance (priority := 100) ContinuousSub.measurableSub [Sub γ] [ContinuousSub γ] :
    MeasurableSub γ 
goal: MeasurableSub γ

full_name: TopologicalAddGroup.measurableNeg
code: @[to_additive]
instance (priority := 100) TopologicalGroup.measurableInv [Group γ] [TopologicalGroup γ] :
    MeasurableInv γ 
goal: MeasurableNeg γ

full_name: TopologicalGroup.measurableInv
code: @[to_additive]
instance (priority := 100) TopologicalGroup.measurableInv [Group γ] [TopologicalGroup γ] :
    MeasurableInv γ 
goal: MeasurableInv γ

full_name: ContinuousSMul.measurableSMul
code: instance (priority := 100) ContinuousSMul.measurableSMul {M α} [TopologicalSpace M]
    [TopologicalSpace α] [MeasurableSpace M] [MeasurableSpace α] [OpensMeasurableSpace M]
    [BorelSpace α] [SMul M α] [ContinuousSMul M α] : MeasurableSMul M α 
goal: MeasurableSMul M α

full_name: Homeomorph.measurable
code: @[measurability]
protected theorem Homeomorph.measurable (h : α ≃ₜ γ) : Measurable h 
goal: Measurable ⇑h

full_name: Homeomorph.toMeasurableEquiv
code: /-- A homeomorphism between two Borel spaces is a measurable equivalence. -/
def Homeomorph.toMeasurableEquiv (h : γ ≃ₜ γ₂) : γ ≃ᵐ γ₂ 
goal: γ ≃ᵐ γ₂

full_name: Homeomorph.measurableEmbedding
code: lemma Homeomorph.measurableEmbedding (h : γ ≃ₜ γ₂) : MeasurableEmbedding h 
goal: MeasurableEmbedding ⇑h

full_name: Homeomorph.toMeasurableEquiv_coe
code: @[simp]
theorem Homeomorph.toMeasurableEquiv_coe (h : γ ≃ₜ γ₂) : (h.toMeasurableEquiv : γ → γ₂) = h 
goal: ⇑h.toMeasurableEquiv = ⇑h

full_name: Homeomorph.toMeasurableEquiv_symm_coe
code: @[simp]
theorem Homeomorph.toMeasurableEquiv_symm_coe (h : γ ≃ₜ γ₂) :
    (h.toMeasurableEquiv.symm : γ₂ → γ) = h.symm 
goal: ⇑h.toMeasurableEquiv.symm = ⇑h.symm

full_name: ContinuousMap.measurable
code: @[measurability]
theorem ContinuousMap.measurable (f : C(α, γ)) : Measurable f 
goal: Measurable ⇑f

full_name: measurable_of_continuousOn_compl_singleton
code: @[fun_prop]
theorem measurable_of_continuousOn_compl_singleton [T1Space α] {f : α → γ} (a : α)
    (hf : ContinuousOn f {a}ᶜ) : Measurable f 
goal: Measurable f

full_name: Continuous.measurable2
code: theorem Continuous.measurable2 [SecondCountableTopologyEither α β] {f : δ → α}
    {g : δ → β} {c : α → β → γ} (h : Continuous fun p : α × β => c p.1 p.2) (hf : Measurable f)
    (hg : Measurable g) : Measurable fun a => c (f a) (g a) 
goal: Measurable fun a => c (f a) (g a)

full_name: Continuous.aemeasurable2
code: theorem Continuous.aemeasurable2 [SecondCountableTopologyEither α β]
    {f : δ → α} {g : δ → β} {c : α → β → γ} {μ : Measure δ}
    (h : Continuous fun p : α × β => c p.1 p.2) (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun a => c (f a) (g a)) μ 
goal: AEMeasurable (fun a => c (f a) (g a)) μ

full_name: HasContinuousInv₀.measurableInv
code: instance (priority := 100) HasContinuousInv₀.measurableInv [GroupWithZero γ] [T1Space γ]
    [HasContinuousInv₀ γ] : MeasurableInv γ 
goal: MeasurableInv γ

full_name: ContinuousMul.measurableMul₂
code: @[to_additive]
instance (priority := 100) ContinuousMul.measurableMul₂ [SecondCountableTopology γ] [Mul γ]
    [ContinuousMul γ] : MeasurableMul₂ γ 
goal: MeasurableMul₂ γ

full_name: ContinuousAdd.measurableMul₂
code: @[to_additive]
instance (priority := 100) ContinuousMul.measurableMul₂ [SecondCountableTopology γ] [Mul γ]
    [ContinuousMul γ] : MeasurableMul₂ γ 
goal: MeasurableAdd₂ γ

full_name: ContinuousSub.measurableSub₂
code: instance (priority := 100) ContinuousSub.measurableSub₂ [SecondCountableTopology γ] [Sub γ]
    [ContinuousSub γ] : MeasurableSub₂ γ 
goal: MeasurableSub₂ γ

full_name: ContinuousSMul.measurableSMul₂
code: instance (priority := 100) ContinuousSMul.measurableSMul₂ {M α} [TopologicalSpace M]
    [MeasurableSpace M] [OpensMeasurableSpace M] [TopologicalSpace α]
    [SecondCountableTopologyEither M α] [MeasurableSpace α] [BorelSpace α] [SMul M α]
    [ContinuousSMul M α] : MeasurableSMul₂ M α 
goal: MeasurableSMul₂ M α

full_name: pi_le_borel_pi
code: theorem pi_le_borel_pi {ι : Type*} {π : ι → Type*} [∀ i, TopologicalSpace (π i)]
    [∀ i, MeasurableSpace (π i)] [∀ i, BorelSpace (π i)] :
      MeasurableSpace.pi ≤ borel (∀ i, π i) 
goal: MeasurableSpace.pi ≤ borel ((i : ι) → π i)

full_name: prod_le_borel_prod
code: theorem prod_le_borel_prod : Prod.instMeasurableSpace ≤ borel (α × β) 
goal: Prod.instMeasurableSpace ≤ borel (α × β)

full_name: Pi.borelSpace
code: instance Pi.borelSpace {ι : Type*} {π : ι → Type*} [Countable ι] [∀ i, TopologicalSpace (π i)]
    [∀ i, MeasurableSpace (π i)] [∀ i, SecondCountableTopology (π i)] [∀ i, BorelSpace (π i)] :
    BorelSpace (∀ i, π i) 
goal: BorelSpace ((i : ι) → π i)

full_name: Prod.borelSpace
code: instance Prod.borelSpace [SecondCountableTopologyEither α β] :
    BorelSpace (α × β) 
goal: BorelSpace (α × β)

full_name: MeasurableEmbedding.borelSpace
code: /-- Given a measurable embedding to a Borel space which is also a topological embedding, then the
source space is also a Borel space. -/
lemma MeasurableEmbedding.borelSpace {α β : Type*} [MeasurableSpace α] [TopologicalSpace α]
    [MeasurableSpace β] [TopologicalSpace β] [hβ : BorelSpace β] {e : α → β}
    (h'e : MeasurableEmbedding e) (h''e : Inducing e) :
    BorelSpace α 
goal: BorelSpace α

full_name: ULift.instBorelSpace
code: instance _root_.ULift.instBorelSpace : BorelSpace (ULift α) 
goal: BorelSpace (ULift.{u_6, u_1} α)

full_name: DiscreteMeasurableSpace.toBorelSpace
code: instance DiscreteMeasurableSpace.toBorelSpace {α : Type*} [TopologicalSpace α] [DiscreteTopology α]
    [MeasurableSpace α] [DiscreteMeasurableSpace α] : BorelSpace α 
goal: BorelSpace α

full_name: Embedding.measurableEmbedding
code: protected theorem Embedding.measurableEmbedding {f : α → β} (h₁ : Embedding f)
    (h₂ : MeasurableSet (range f)) : MeasurableEmbedding f 
goal: MeasurableEmbedding f

full_name: ClosedEmbedding.measurableEmbedding
code: protected theorem ClosedEmbedding.measurableEmbedding {f : α → β} (h : ClosedEmbedding f) :
    MeasurableEmbedding f 
goal: MeasurableEmbedding f

full_name: OpenEmbedding.measurableEmbedding
code: protected theorem OpenEmbedding.measurableEmbedding {f : α → β} (h : OpenEmbedding f) :
    MeasurableEmbedding f 
goal: MeasurableEmbedding f

full_name: Empty.borelSpace
code: instance Empty.borelSpace : BorelSpace Empty 
goal: BorelSpace Empty

full_name: Unit.borelSpace
code: instance Unit.borelSpace : BorelSpace Unit 
goal: BorelSpace Unit

full_name: Bool.borelSpace
code: instance Bool.borelSpace : BorelSpace Bool 
goal: BorelSpace Bool

full_name: Nat.borelSpace
code: instance Nat.borelSpace : BorelSpace ℕ 
goal: BorelSpace ℕ

full_name: Int.borelSpace
code: instance Int.borelSpace : BorelSpace ℤ 
goal: BorelSpace ℤ

full_name: Rat.borelSpace
code: instance Rat.borelSpace : BorelSpace ℚ 
goal: BorelSpace ℚ

full_name: Real.measurableSpace
code: instance Real.measurableSpace : MeasurableSpace ℝ 
goal: MeasurableSpace ℝ

full_name: Real.borelSpace
code: instance Real.borelSpace : BorelSpace ℝ 
goal: BorelSpace ℝ

full_name: NNReal.measurableSpace
code: instance NNReal.measurableSpace : MeasurableSpace ℝ≥0 
goal: MeasurableSpace ℝ≥0

full_name: NNReal.borelSpace
code: instance NNReal.borelSpace : BorelSpace ℝ≥0 
goal: BorelSpace ℝ≥0

full_name: ENNReal.measurableSpace
code: instance ENNReal.measurableSpace : MeasurableSpace ℝ≥0∞ 
goal: MeasurableSpace ℝ≥0∞

full_name: ENNReal.borelSpace
code: instance ENNReal.borelSpace : BorelSpace ℝ≥0∞ 
goal: BorelSpace ℝ≥0∞

full_name: EReal.measurableSpace
code: instance EReal.measurableSpace : MeasurableSpace EReal 
goal: MeasurableSpace EReal

full_name: EReal.borelSpace
code: instance EReal.borelSpace : BorelSpace EReal 
goal: BorelSpace EReal