File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

full_name: MeasurableEmbedding.measurableSet_image'
code: /-- A map `f : α → β` is called a *measurable embedding* if it is injective, measurable, and sends
measurable sets to measurable sets. The latter assumption can be replaced with “`f` has measurable
inverse `g : Set.range f → α`”, see `MeasurableEmbedding.measurable_rangeSplitting`,
`MeasurableEmbedding.of_measurable_inverse_range`, and
`MeasurableEmbedding.of_measurable_inverse`.

One more interpretation: `f` is a measurable embedding if it defines a measurable equivalence to its
range and the range is a measurable set. One implication is formalized as
`MeasurableEmbedding.equivRange`; the other one follows from
`MeasurableEquiv.measurableEmbedding`, `MeasurableEmbedding.subtype_coe`, and
`MeasurableEmbedding.comp`. -/
structure MeasurableEmbedding [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop where
  /-- A measurable embedding is injective. -/
  protected injective : Injective f
  /-- A measurable embedding is a measurable function. -/
  protected measurable : Measurable f
  /-- The image of a measurable set under a measurable embedding is a measurable set. -/
  protected measurableSet_image' : ∀ ⦃s⦄, MeasurableSet s → MeasurableSet (f '' s)
goal: MeasurableSet s → MeasurableSet (f '' s)

full_name: MeasurableEmbedding.injective
code: /-- A map `f : α → β` is called a *measurable embedding* if it is injective, measurable, and sends
measurable sets to measurable sets. The latter assumption can be replaced with “`f` has measurable
inverse `g : Set.range f → α`”, see `MeasurableEmbedding.measurable_rangeSplitting`,
`MeasurableEmbedding.of_measurable_inverse_range`, and
`MeasurableEmbedding.of_measurable_inverse`.

One more interpretation: `f` is a measurable embedding if it defines a measurable equivalence to its
range and the range is a measurable set. One implication is formalized as
`MeasurableEmbedding.equivRange`; the other one follows from
`MeasurableEquiv.measurableEmbedding`, `MeasurableEmbedding.subtype_coe`, and
`MeasurableEmbedding.comp`. -/
structure MeasurableEmbedding [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop where
  /-- A measurable embedding is injective. -/
  protected injective : Injective f
  /-- A measurable embedding is a measurable function. -/
  protected measurable : Measurable f
  /-- The image of a measurable set under a measurable embedding is a measurable set. -/
  protected measurableSet_image' : ∀ ⦃s⦄, MeasurableSet s → MeasurableSet (f '' s)
goal: Function.Injective f

full_name: MeasurableEmbedding
code: /-- A map `f : α → β` is called a *measurable embedding* if it is injective, measurable, and sends
measurable sets to measurable sets. The latter assumption can be replaced with “`f` has measurable
inverse `g : Set.range f → α`”, see `MeasurableEmbedding.measurable_rangeSplitting`,
`MeasurableEmbedding.of_measurable_inverse_range`, and
`MeasurableEmbedding.of_measurable_inverse`.

One more interpretation: `f` is a measurable embedding if it defines a measurable equivalence to its
range and the range is a measurable set. One implication is formalized as
`MeasurableEmbedding.equivRange`; the other one follows from
`MeasurableEquiv.measurableEmbedding`, `MeasurableEmbedding.subtype_coe`, and
`MeasurableEmbedding.comp`. -/
structure MeasurableEmbedding [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop where
  /-- A measurable embedding is injective. -/
  protected injective : Injective f
  /-- A measurable embedding is a measurable function. -/
  protected measurable : Measurable f
  /-- The image of a measurable set under a measurable embedding is a measurable set. -/
  protected measurableSet_image' : ∀ ⦃s⦄, MeasurableSet s → MeasurableSet (f '' s)
goal: Prop

full_name: MeasurableEmbedding.measurable
code: /-- A map `f : α → β` is called a *measurable embedding* if it is injective, measurable, and sends
measurable sets to measurable sets. The latter assumption can be replaced with “`f` has measurable
inverse `g : Set.range f → α`”, see `MeasurableEmbedding.measurable_rangeSplitting`,
`MeasurableEmbedding.of_measurable_inverse_range`, and
`MeasurableEmbedding.of_measurable_inverse`.

One more interpretation: `f` is a measurable embedding if it defines a measurable equivalence to its
range and the range is a measurable set. One implication is formalized as
`MeasurableEmbedding.equivRange`; the other one follows from
`MeasurableEquiv.measurableEmbedding`, `MeasurableEmbedding.subtype_coe`, and
`MeasurableEmbedding.comp`. -/
structure MeasurableEmbedding [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop where
  /-- A measurable embedding is injective. -/
  protected injective : Injective f
  /-- A measurable embedding is a measurable function. -/
  protected measurable : Measurable f
  /-- The image of a measurable set under a measurable embedding is a measurable set. -/
  protected measurableSet_image' : ∀ ⦃s⦄, MeasurableSet s → MeasurableSet (f '' s)
goal: Measurable f

full_name: MeasurableEmbedding.measurableSet_image
code: theorem measurableSet_image (hf : MeasurableEmbedding f) :
    MeasurableSet (f '' s) ↔ MeasurableSet s 
goal: MeasurableSet (f '' s) ↔ MeasurableSet s

full_name: MeasurableEmbedding.id
code: theorem id : MeasurableEmbedding (id : α → α) 
goal: MeasurableEmbedding id

full_name: MeasurableEmbedding.comp
code: theorem comp (hg : MeasurableEmbedding g) (hf : MeasurableEmbedding f) :
    MeasurableEmbedding (g ∘ f) 
goal: MeasurableEmbedding (g ∘ f)

full_name: MeasurableEmbedding.subtype_coe
code: theorem subtype_coe (hs : MeasurableSet s) : MeasurableEmbedding ((↑) : s → α) 
goal: MeasurableEmbedding Subtype.val

full_name: MeasurableEmbedding.measurableSet_range
code: theorem measurableSet_range (hf : MeasurableEmbedding f) : MeasurableSet (range f) 
goal: MeasurableSet (Set.range f)

full_name: MeasurableEmbedding.measurableSet_preimage
code: theorem measurableSet_preimage (hf : MeasurableEmbedding f) {s : Set β} :
    MeasurableSet (f ⁻¹' s) ↔ MeasurableSet (s ∩ range f) 
goal: MeasurableSet (f ⁻¹' s) ↔ MeasurableSet (s ∩ Set.range f)

full_name: MeasurableEmbedding.measurable_rangeSplitting
code: theorem measurable_rangeSplitting (hf : MeasurableEmbedding f) :
    Measurable (rangeSplitting f) 
goal: Measurable (Set.rangeSplitting f)

full_name: MeasurableEmbedding.measurable_extend
code: theorem measurable_extend (hf : MeasurableEmbedding f) {g : α → γ} {g' : β → γ} (hg : Measurable g)
    (hg' : Measurable g') : Measurable (extend f g g') 
goal: Measurable (Function.extend f g g')

full_name: MeasurableEmbedding.exists_measurable_extend
code: theorem exists_measurable_extend (hf : MeasurableEmbedding f) {g : α → γ} (hg : Measurable g)
    (hne : β → Nonempty γ) : ∃ g' : β → γ, Measurable g' ∧ g' ∘ f = g 
goal: ∃ g', Measurable g' ∧ g' ∘ f = g

full_name: MeasurableEmbedding.measurable_comp_iff
code: theorem measurable_comp_iff (hg : MeasurableEmbedding g) : Measurable (g ∘ f) ↔ Measurable f 
goal: Measurable (g ∘ f) ↔ Measurable f

full_name: MeasurableSet.exists_measurable_proj
code: theorem MeasurableSet.exists_measurable_proj {_ : MeasurableSpace α}
    (hs : MeasurableSet s) (hne : s.Nonempty) : ∃ f : α → s, Measurable f ∧ ∀ x : s, f x = x 
goal: ∀ {x : MeasurableSpace α}, MeasurableSet s → s.Nonempty → ∃ f, Measurable f ∧ ∀ (x : ↑s), f ↑x = x

full_name: MeasurableEquiv
code: /-- Equivalences between measurable spaces. Main application is the simplification of measurability
statements along measurable equivalences. -/
structure MeasurableEquiv (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] extends α ≃ β where
  /-- The forward function of a measurable equivalence is measurable. -/
  measurable_toFun : Measurable toEquiv
  /-- The inverse function of a measurable equivalence is measurable. -/
  measurable_invFun : Measurable toEquiv.symm
goal: Type (max u_6 u_7)

full_name: MeasurableEquiv.measurable_invFun
code: /-- Equivalences between measurable spaces. Main application is the simplification of measurability
statements along measurable equivalences. -/
structure MeasurableEquiv (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] extends α ≃ β where
  /-- The forward function of a measurable equivalence is measurable. -/
  measurable_toFun : Measurable toEquiv
  /-- The inverse function of a measurable equivalence is measurable. -/
  measurable_invFun : Measurable toEquiv.symm
goal: Measurable ⇑self.symm

full_name: MeasurableEquiv.measurable_toFun
code: /-- Equivalences between measurable spaces. Main application is the simplification of measurability
statements along measurable equivalences. -/
structure MeasurableEquiv (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] extends α ≃ β where
  /-- The forward function of a measurable equivalence is measurable. -/
  measurable_toFun : Measurable toEquiv
  /-- The inverse function of a measurable equivalence is measurable. -/
  measurable_invFun : Measurable toEquiv.symm
goal: Measurable ⇑self.toEquiv

full_name: _aux_Mathlib_MeasureTheory_MeasurableSpace_Embedding___unexpand_MeasurableEquiv_1
code: @[inherit_doc]
infixl:25 " ≃ᵐ " => MeasurableEquiv
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_MeasureTheory_MeasurableSpace_Embedding___macroRules_term_≃ᵐ__1»
code: @[inherit_doc]
infixl:25 " ≃ᵐ " => MeasurableEquiv
goal: Lean.Macro

full_name: MeasurableEquiv.toEquiv_injective
code: theorem toEquiv_injective : Injective (toEquiv : α ≃ᵐ β → α ≃ β) 
goal: Function.Injective MeasurableEquiv.toEquiv

full_name: MeasurableEquiv.instEquivLike
code: instance instEquivLike : EquivLike (α ≃ᵐ β) α β 
goal: EquivLike (α ≃ᵐ β) α β

full_name: MeasurableEquiv.coe_toEquiv
code: @[simp]
theorem coe_toEquiv (e : α ≃ᵐ β) : (e.toEquiv : α → β) = e 
goal: ⇑e.toEquiv = ⇑e

full_name: MeasurableEquiv.measurable
code: @[measurability]
protected theorem measurable (e : α ≃ᵐ β) : Measurable (e : α → β) 
goal: Measurable ⇑e

full_name: MeasurableEquiv.coe_mk
code: @[simp]
theorem coe_mk (e : α ≃ β) (h1 : Measurable e) (h2 : Measurable e.symm) :
    ((⟨e, h1, h2⟩ : α ≃ᵐ β) : α → β) = e 
goal: ⇑{ toEquiv := e, measurable_toFun := h1, measurable_invFun := h2 } = ⇑e

full_name: MeasurableEquiv.refl
code: /-- Any measurable space is equivalent to itself. -/
def refl (α : Type*) [MeasurableSpace α] : α ≃ᵐ α 
goal: α ≃ᵐ α

full_name: MeasurableEquiv.instInhabited
code: instance instInhabited : Inhabited (α ≃ᵐ α) 
goal: Inhabited (α ≃ᵐ α)

full_name: MeasurableEquiv.trans
code: /-- The composition of equivalences between measurable spaces. -/
def trans (ab : α ≃ᵐ β) (bc : β ≃ᵐ γ) : α ≃ᵐ γ 
goal: α ≃ᵐ γ

full_name: MeasurableEquiv.coe_trans
code: theorem coe_trans (ab : α ≃ᵐ β) (bc : β ≃ᵐ γ) : ⇑(ab.trans bc) = bc ∘ ab 
goal: ⇑(ab.trans bc) = ⇑bc ∘ ⇑ab

full_name: MeasurableEquiv.symm
code: /-- The inverse of an equivalence between measurable spaces. -/
def symm (ab : α ≃ᵐ β) : β ≃ᵐ α 
goal: β ≃ᵐ α

full_name: MeasurableEquiv.coe_toEquiv_symm
code: @[simp]
theorem coe_toEquiv_symm (e : α ≃ᵐ β) : (e.toEquiv.symm : β → α) = e.symm 
goal: ⇑e.symm = ⇑e.symm

full_name: MeasurableEquiv.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (h : α ≃ᵐ β) : α → β 
goal: α → β

full_name: MeasurableEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def Simps.symm_apply (h : α ≃ᵐ β) : β → α 
goal: β → α

full_name: MeasurableEquiv.ext
code: @[ext] theorem ext {e₁ e₂ : α ≃ᵐ β} (h : (e₁ : α → β) = e₂) : e₁ = e₂ 
goal: e₁ = e₂

full_name: MeasurableEquiv.symm_mk
code: @[simp]
theorem symm_mk (e : α ≃ β) (h1 : Measurable e) (h2 : Measurable e.symm) :
    (⟨e, h1, h2⟩ : α ≃ᵐ β).symm = ⟨e.symm, h2, h1⟩ 
goal: { toEquiv := e, measurable_toFun := h1, measurable_invFun := h2 }.symm =
  { toEquiv := e.symm, measurable_toFun := h2, measurable_invFun := h1 }

full_name: MeasurableEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : α ≃ᵐ β) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: MeasurableEquiv.symm_bijective
code: theorem symm_bijective :
    Function.Bijective (MeasurableEquiv.symm : (α ≃ᵐ β) → β ≃ᵐ α) 
goal: Function.Bijective MeasurableEquiv.symm

full_name: MeasurableEquiv.symm_refl
code: @[simp]
theorem symm_refl (α : Type*) [MeasurableSpace α] : (refl α).symm = refl α 
goal: (MeasurableEquiv.refl α).symm = MeasurableEquiv.refl α

full_name: MeasurableEquiv.symm_comp_self
code: @[simp]
theorem symm_comp_self (e : α ≃ᵐ β) : e.symm ∘ e = id 
goal: ⇑e.symm ∘ ⇑e = id

full_name: MeasurableEquiv.self_comp_symm
code: @[simp]
theorem self_comp_symm (e : α ≃ᵐ β) : e ∘ e.symm = id 
goal: ⇑e ∘ ⇑e.symm = id

full_name: MeasurableEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : α ≃ᵐ β) (y : β) : e (e.symm y) = y 
goal: e (e.symm y) = y

full_name: MeasurableEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : α ≃ᵐ β) (x : α) : e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: MeasurableEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : α ≃ᵐ β) : e.symm.trans e = refl β 
goal: e.symm.trans e = MeasurableEquiv.refl β

full_name: MeasurableEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : α ≃ᵐ β) : e.trans e.symm = refl α 
goal: e.trans e.symm = MeasurableEquiv.refl α

full_name: MeasurableEquiv.surjective
code: protected theorem surjective (e : α ≃ᵐ β) : Surjective e 
goal: Function.Surjective ⇑e

full_name: MeasurableEquiv.bijective
code: protected theorem bijective (e : α ≃ᵐ β) : Bijective e 
goal: Function.Bijective ⇑e

full_name: MeasurableEquiv.injective
code: protected theorem injective (e : α ≃ᵐ β) : Injective e 
goal: Function.Injective ⇑e

full_name: MeasurableEquiv.symm_preimage_preimage
code: @[simp]
theorem symm_preimage_preimage (e : α ≃ᵐ β) (s : Set β) : e.symm ⁻¹' (e ⁻¹' s) = s 
goal: ⇑e.symm ⁻¹' (⇑e ⁻¹' s) = s

full_name: MeasurableEquiv.image_eq_preimage
code: theorem image_eq_preimage (e : α ≃ᵐ β) (s : Set α) : e '' s = e.symm ⁻¹' s 
goal: ⇑e '' s = ⇑e.symm ⁻¹' s

full_name: MeasurableEquiv.preimage_symm
code: lemma preimage_symm (e : α ≃ᵐ β) (s : Set α) : e.symm ⁻¹' s = e '' s 
goal: ⇑e.symm ⁻¹' s = ⇑e '' s

full_name: MeasurableEquiv.image_symm
code: lemma image_symm (e : α ≃ᵐ β) (s : Set β) : e.symm '' s = e ⁻¹' s 
goal: ⇑e.symm '' s = ⇑e ⁻¹' s

full_name: MeasurableEquiv.eq_image_iff_symm_image_eq
code: lemma eq_image_iff_symm_image_eq (e : α ≃ᵐ β) (s : Set β) (t : Set α) :
    s = e '' t ↔ e.symm '' s = t 
goal: s = ⇑e '' t ↔ ⇑e.symm '' s = t

full_name: MeasurableEquiv.image_preimage
code: @[simp]
lemma image_preimage (e : α ≃ᵐ β) (s : Set β) : e '' (e ⁻¹' s) = s 
goal: ⇑e '' (⇑e ⁻¹' s) = s

full_name: MeasurableEquiv.preimage_image
code: @[simp]
lemma preimage_image (e : α ≃ᵐ β) (s : Set α) : e ⁻¹' (e '' s) = s 
goal: ⇑e ⁻¹' (⇑e '' s) = s

full_name: MeasurableEquiv.measurableSet_preimage
code: @[simp]
theorem measurableSet_preimage (e : α ≃ᵐ β) {s : Set β} :
    MeasurableSet (e ⁻¹' s) ↔ MeasurableSet s 
goal: MeasurableSet (⇑e ⁻¹' s) ↔ MeasurableSet s

full_name: MeasurableEquiv.measurableSet_image
code: @[simp]
theorem measurableSet_image (e : α ≃ᵐ β) :
    MeasurableSet (e '' s) ↔ MeasurableSet s 
goal: MeasurableSet (⇑e '' s) ↔ MeasurableSet s

full_name: MeasurableEquiv.map_eq
code: @[simp] theorem map_eq (e : α ≃ᵐ β) : MeasurableSpace.map e ‹_› = ‹_› 
goal: MeasurableSpace.map (⇑e) inst✝ = inst✝¹

full_name: MeasurableEquiv.measurableEmbedding
code: /-- A measurable equivalence is a measurable embedding. -/
protected theorem measurableEmbedding (e : α ≃ᵐ β) : MeasurableEmbedding e 
goal: MeasurableEmbedding ⇑e

full_name: MeasurableEquiv.cast
code: /-- Equal measurable spaces are equivalent. -/
protected def cast {α β} [i₁ : MeasurableSpace α] [i₂ : MeasurableSpace β] (h : α = β)
    (hi : HEq i₁ i₂) : α ≃ᵐ β 
goal: α ≃ᵐ β

full_name: MeasurableEquiv.ulift
code: /-- Measurable equivalence between `ULift α` and `α`. -/
def ulift.{u, v} {α : Type u} [MeasurableSpace α] : ULift.{v, u} α ≃ᵐ α 
goal: ULift.{v, u} α ≃ᵐ α

full_name: MeasurableEquiv.measurable_comp_iff
code: protected theorem measurable_comp_iff {f : β → γ} (e : α ≃ᵐ β) :
    Measurable (f ∘ e) ↔ Measurable f 
goal: Measurable (f ∘ ⇑e) ↔ Measurable f

full_name: MeasurableEquiv.ofUniqueOfUnique
code: /-- Any two types with unique elements are measurably equivalent. -/
def ofUniqueOfUnique (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] [Unique α] [Unique β] :
    α ≃ᵐ β 
goal: α ≃ᵐ β

full_name: MeasurableEquiv.prodCongr
code: /-- Products of equivalent measurable spaces are equivalent. -/
def prodCongr (ab : α ≃ᵐ β) (cd : γ ≃ᵐ δ) : α × γ ≃ᵐ β × δ 
goal: α × γ ≃ᵐ β × δ

full_name: MeasurableEquiv.prodComm
code: /-- Products of measurable spaces are symmetric. -/
def prodComm : α × β ≃ᵐ β × α 
goal: α × β ≃ᵐ β × α

full_name: MeasurableEquiv.prodAssoc
code: /-- Products of measurable spaces are associative. -/
def prodAssoc : (α × β) × γ ≃ᵐ α × β × γ 
goal: (α × β) × γ ≃ᵐ α × β × γ

full_name: MeasurableEquiv.sumCongr
code: /-- Sums of measurable spaces are symmetric. -/
def sumCongr (ab : α ≃ᵐ β) (cd : γ ≃ᵐ δ) : α ⊕ γ ≃ᵐ β ⊕ δ 
goal: α ⊕ γ ≃ᵐ β ⊕ δ

full_name: MeasurableEquiv.Set.prod
code: /-- `s ×ˢ t ≃ (s × t)` as measurable spaces. -/
def Set.prod (s : Set α) (t : Set β) : ↥(s ×ˢ t) ≃ᵐ s × t 
goal: ↑(s ×ˢ t) ≃ᵐ ↑s × ↑t

full_name: MeasurableEquiv.Set.univ
code: /-- `univ α ≃ α` as measurable spaces. -/
def Set.univ (α : Type*) [MeasurableSpace α] : (univ : Set α) ≃ᵐ α 
goal: ↑Set.univ ≃ᵐ α

full_name: MeasurableEquiv.Set.singleton
code: /-- `{a} ≃ Unit` as measurable spaces. -/
def Set.singleton (a : α) : ({a} : Set α) ≃ᵐ Unit 
goal: ↑{a} ≃ᵐ Unit

full_name: MeasurableEquiv.Set.rangeInl
code: /-- `α` is equivalent to its image in `α ⊕ β` as measurable spaces. -/
def Set.rangeInl : (range Sum.inl : Set (α ⊕ β)) ≃ᵐ α 
goal: ↑(Set.range Sum.inl) ≃ᵐ α

full_name: MeasurableEquiv.Set.rangeInr
code: /-- `β` is equivalent to its image in `α ⊕ β` as measurable spaces. -/
def Set.rangeInr : (range Sum.inr : Set (α ⊕ β)) ≃ᵐ β 
goal: ↑(Set.range Sum.inr) ≃ᵐ β

full_name: MeasurableEquiv.sumProdDistrib
code: /-- Products distribute over sums (on the right) as measurable spaces. -/
def sumProdDistrib (α β γ) [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] :
    (α ⊕ β) × γ ≃ᵐ (α × γ) ⊕ (β × γ) 
goal: (α ⊕ β) × γ ≃ᵐ α × γ ⊕ β × γ

full_name: MeasurableEquiv.prodSumDistrib
code: /-- Products distribute over sums (on the left) as measurable spaces. -/
def prodSumDistrib (α β γ) [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] :
    α × (β ⊕ γ) ≃ᵐ (α × β) ⊕ (α × γ) 
goal: α × (β ⊕ γ) ≃ᵐ α × β ⊕ α × γ

full_name: MeasurableEquiv.sumProdSum
code: /-- Products distribute over sums as measurable spaces. -/
def sumProdSum (α β γ δ) [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ]
    [MeasurableSpace δ] : (α ⊕ β) × (γ ⊕ δ) ≃ᵐ ((α × γ) ⊕ (α × δ)) ⊕ ((β × γ) ⊕ (β × δ)) 
goal: (α ⊕ β) × (γ ⊕ δ) ≃ᵐ (α × γ ⊕ α × δ) ⊕ β × γ ⊕ β × δ

full_name: MeasurableEquiv.piCongrRight
code: /-- A family of measurable equivalences `Π a, β₁ a ≃ᵐ β₂ a` generates a measurable equivalence
  between `Π a, β₁ a` and `Π a, β₂ a`. -/
def piCongrRight (e : ∀ a, π a ≃ᵐ π' a) : (∀ a, π a) ≃ᵐ ∀ a, π' a 
goal: ((a : δ') → π a) ≃ᵐ ((a : δ') → π' a)

full_name: MeasurableEquiv.piCongrLeft
code: /-- Moving a dependent type along an equivalence of coordinates, as a measurable equivalence. -/
def piCongrLeft (f : δ ≃ δ') : (∀ b, π (f b)) ≃ᵐ ∀ a, π a 
goal: ((b : δ) → π (f b)) ≃ᵐ ((a : δ') → π a)

full_name: MeasurableEquiv.coe_piCongrLeft
code: theorem coe_piCongrLeft (f : δ ≃ δ') :
    ⇑(MeasurableEquiv.piCongrLeft π f) = f.piCongrLeft π 
goal: ⇑(MeasurableEquiv.piCongrLeft π f) = ⇑(Equiv.piCongrLeft π f)

full_name: MeasurableEquiv.piCongrLeft_apply_apply
code: lemma piCongrLeft_apply_apply {ι ι' : Type*} (e : ι ≃ ι') {β : ι' → Type*}
    [∀ i', MeasurableSpace (β i')] (x : (i : ι) → β (e i)) (i : ι) :
    piCongrLeft (fun i' ↦ β i') e x (e i) = x i 
goal: (MeasurableEquiv.piCongrLeft (fun i' => β i') e) x (e i) = x i

full_name: MeasurableEquiv.piMeasurableEquivTProd
code: /-- Pi-types are measurably equivalent to iterated products. -/
@[simps! (config := .asFn)]
def piMeasurableEquivTProd [DecidableEq δ'] {l : List δ'} (hnd : l.Nodup) (h : ∀ i, i ∈ l) :
    (∀ i, π i) ≃ᵐ List.TProd π l 
goal: ((i : δ') → π i) ≃ᵐ List.TProd π l

full_name: MeasurableEquiv.piMeasurableEquivTProd_apply
code: /-- Pi-types are measurably equivalent to iterated products. -/
@[simps! (config := .asFn)]
def piMeasurableEquivTProd [DecidableEq δ'] {l : List δ'} (hnd : l.Nodup) (h : ∀ i, i ∈ l) :
    (∀ i, π i) ≃ᵐ List.TProd π l 
goal: ⇑(MeasurableEquiv.piMeasurableEquivTProd hnd h) = List.TProd.mk l

full_name: MeasurableEquiv.piMeasurableEquivTProd_symm_apply
code: /-- Pi-types are measurably equivalent to iterated products. -/
@[simps! (config := .asFn)]
def piMeasurableEquivTProd [DecidableEq δ'] {l : List δ'} (hnd : l.Nodup) (h : ∀ i, i ∈ l) :
    (∀ i, π i) ≃ᵐ List.TProd π l 
goal: ⇑(MeasurableEquiv.piMeasurableEquivTProd hnd h).symm = List.TProd.elim' h

full_name: MeasurableEquiv.piUnique
code: /-- The measurable equivalence `(∀ i, π i) ≃ᵐ π ⋆` when the domain of `π` only contains `⋆` -/
@[simps! (config := .asFn)]
def piUnique [Unique δ'] : (∀ i, π i) ≃ᵐ π default 
goal: ((i : δ') → π i) ≃ᵐ π default

full_name: MeasurableEquiv.piUnique_symm_apply
code: /-- The measurable equivalence `(∀ i, π i) ≃ᵐ π ⋆` when the domain of `π` only contains `⋆` -/
@[simps! (config := .asFn)]
def piUnique [Unique δ'] : (∀ i, π i) ≃ᵐ π default 
goal: ⇑(MeasurableEquiv.piUnique π).symm = uniqueElim

full_name: MeasurableEquiv.piUnique_apply
code: /-- The measurable equivalence `(∀ i, π i) ≃ᵐ π ⋆` when the domain of `π` only contains `⋆` -/
@[simps! (config := .asFn)]
def piUnique [Unique δ'] : (∀ i, π i) ≃ᵐ π default 
goal: ⇑(MeasurableEquiv.piUnique π) = fun f => f default

full_name: MeasurableEquiv.funUnique_symm_apply
code: /-- If `α` has a unique term, then the type of function `α → β` is measurably equivalent to `β`. -/
@[simps! (config := .asFn)]
def funUnique (α β : Type*) [Unique α] [MeasurableSpace β] : (α → β) ≃ᵐ β 
goal: ⇑(MeasurableEquiv.funUnique α β).symm = uniqueElim

full_name: MeasurableEquiv.funUnique
code: /-- If `α` has a unique term, then the type of function `α → β` is measurably equivalent to `β`. -/
@[simps! (config := .asFn)]
def funUnique (α β : Type*) [Unique α] [MeasurableSpace β] : (α → β) ≃ᵐ β 
goal: (α → β) ≃ᵐ β

full_name: MeasurableEquiv.funUnique_apply
code: /-- If `α` has a unique term, then the type of function `α → β` is measurably equivalent to `β`. -/
@[simps! (config := .asFn)]
def funUnique (α β : Type*) [Unique α] [MeasurableSpace β] : (α → β) ≃ᵐ β 
goal: ⇑(MeasurableEquiv.funUnique α β) = fun f => f default

full_name: MeasurableEquiv.piFinTwo_symm_apply
code: /-- The space `Π i : Fin 2, α i` is measurably equivalent to `α 0 × α 1`. -/
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type*) [∀ i, MeasurableSpace (α i)] : (∀ i, α i) ≃ᵐ α 0 × α 1 
goal: ⇑(MeasurableEquiv.piFinTwo α).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)

full_name: MeasurableEquiv.piFinTwo_apply
code: /-- The space `Π i : Fin 2, α i` is measurably equivalent to `α 0 × α 1`. -/
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type*) [∀ i, MeasurableSpace (α i)] : (∀ i, α i) ≃ᵐ α 0 × α 1 
goal: ⇑(MeasurableEquiv.piFinTwo α) = fun f => (f 0, f 1)

full_name: MeasurableEquiv.piFinTwo
code: /-- The space `Π i : Fin 2, α i` is measurably equivalent to `α 0 × α 1`. -/
@[simps! (config := .asFn)]
def piFinTwo (α : Fin 2 → Type*) [∀ i, MeasurableSpace (α i)] : (∀ i, α i) ≃ᵐ α 0 × α 1 
goal: ((i : Fin 2) → α i) ≃ᵐ α 0 × α 1

full_name: MeasurableEquiv.finTwoArrow_apply
code: /-- The space `Fin 2 → α` is measurably equivalent to `α × α`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → α) ≃ᵐ α × α 
goal: ⇑MeasurableEquiv.finTwoArrow = fun f => (f 0, f 1)

full_name: MeasurableEquiv.finTwoArrow_symm_apply
code: /-- The space `Fin 2 → α` is measurably equivalent to `α × α`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → α) ≃ᵐ α × α 
goal: ⇑MeasurableEquiv.finTwoArrow.symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)

full_name: MeasurableEquiv.finTwoArrow
code: /-- The space `Fin 2 → α` is measurably equivalent to `α × α`. -/
@[simps! (config := .asFn)]
def finTwoArrow : (Fin 2 → α) ≃ᵐ α × α 
goal: (Fin 2 → α) ≃ᵐ α × α

full_name: MeasurableEquiv.piFinSuccAbove_symm_apply
code: /-- Measurable equivalence between `Π j : Fin (n + 1), α j` and
`α i × Π j : Fin n, α (Fin.succAbove i j)`. -/
@[simps! (config := .asFn)]
def piFinSuccAbove {n : ℕ} (α : Fin (n + 1) → Type*) [∀ i, MeasurableSpace (α i)]
    (i : Fin (n + 1)) : (∀ j, α j) ≃ᵐ α i × ∀ j, α (i.succAbove j) 
goal: ⇑(MeasurableEquiv.piFinSuccAbove α i).symm = fun f => i.insertNth f.1 f.2

full_name: MeasurableEquiv.piFinSuccAbove_apply
code: /-- Measurable equivalence between `Π j : Fin (n + 1), α j` and
`α i × Π j : Fin n, α (Fin.succAbove i j)`. -/
@[simps! (config := .asFn)]
def piFinSuccAbove {n : ℕ} (α : Fin (n + 1) → Type*) [∀ i, MeasurableSpace (α i)]
    (i : Fin (n + 1)) : (∀ j, α j) ≃ᵐ α i × ∀ j, α (i.succAbove j) 
goal: ⇑(MeasurableEquiv.piFinSuccAbove α i) = fun f => (f i, i.removeNth f)

full_name: MeasurableEquiv.piFinSuccAbove
code: /-- Measurable equivalence between `Π j : Fin (n + 1), α j` and
`α i × Π j : Fin n, α (Fin.succAbove i j)`. -/
@[simps! (config := .asFn)]
def piFinSuccAbove {n : ℕ} (α : Fin (n + 1) → Type*) [∀ i, MeasurableSpace (α i)]
    (i : Fin (n + 1)) : (∀ j, α j) ≃ᵐ α i × ∀ j, α (i.succAbove j) 
goal: ((j : Fin (n + 1)) → α j) ≃ᵐ α i × ((j : Fin n) → α (i.succAbove j))

full_name: MeasurableEquiv.piEquivPiSubtypeProd_apply
code: /-- Measurable equivalence between (dependent) functions on a type and pairs of functions on
`{i // p i}` and `{i // ¬p i}`. See also `Equiv.piEquivPiSubtypeProd`. -/
@[simps! (config := .asFn)]
def piEquivPiSubtypeProd (p : δ' → Prop) [DecidablePred p] :
    (∀ i, π i) ≃ᵐ (∀ i : Subtype p, π i) × ∀ i : { i // ¬p i }, π i 
goal: ⇑(MeasurableEquiv.piEquivPiSubtypeProd π p) = fun f => (fun x => f ↑x, fun x => f ↑x)

full_name: MeasurableEquiv.piEquivPiSubtypeProd_symm_apply
code: /-- Measurable equivalence between (dependent) functions on a type and pairs of functions on
`{i // p i}` and `{i // ¬p i}`. See also `Equiv.piEquivPiSubtypeProd`. -/
@[simps! (config := .asFn)]
def piEquivPiSubtypeProd (p : δ' → Prop) [DecidablePred p] :
    (∀ i, π i) ≃ᵐ (∀ i : Subtype p, π i) × ∀ i : { i // ¬p i }, π i 
goal: ⇑(MeasurableEquiv.piEquivPiSubtypeProd π p).symm = fun f x => if h : p x then f.1 ⟨x, h⟩ else f.2 ⟨x, h⟩

full_name: MeasurableEquiv.piEquivPiSubtypeProd
code: /-- Measurable equivalence between (dependent) functions on a type and pairs of functions on
`{i // p i}` and `{i // ¬p i}`. See also `Equiv.piEquivPiSubtypeProd`. -/
@[simps! (config := .asFn)]
def piEquivPiSubtypeProd (p : δ' → Prop) [DecidablePred p] :
    (∀ i, π i) ≃ᵐ (∀ i : Subtype p, π i) × ∀ i : { i // ¬p i }, π i 
goal: ((i : δ') → π i) ≃ᵐ ((i : Subtype p) → π ↑i) × ((i : { i // ¬p i }) → π ↑i)

full_name: MeasurableEquiv.sumPiEquivProdPi
code: /-- The measurable equivalence between the pi type over a sum type and a product of pi-types.
This is similar to `MeasurableEquiv.piEquivPiSubtypeProd`. -/
def sumPiEquivProdPi (α : δ ⊕ δ' → Type*) [∀ i, MeasurableSpace (α i)] :
    (∀ i, α i) ≃ᵐ (∀ i, α (.inl i)) × ∀ i', α (.inr i') 
goal: ((i : δ ⊕ δ') → α i) ≃ᵐ ((i : δ) → α (Sum.inl i)) × ((i' : δ') → α (Sum.inr i'))

full_name: MeasurableEquiv.coe_sumPiEquivProdPi
code: theorem coe_sumPiEquivProdPi (α : δ ⊕ δ' → Type*) [∀ i, MeasurableSpace (α i)] :
    ⇑(MeasurableEquiv.sumPiEquivProdPi α) = Equiv.sumPiEquivProdPi α 
goal: ⇑(MeasurableEquiv.sumPiEquivProdPi α) = ⇑(Equiv.sumPiEquivProdPi α)

full_name: MeasurableEquiv.coe_sumPiEquivProdPi_symm
code: theorem coe_sumPiEquivProdPi_symm (α : δ ⊕ δ' → Type*) [∀ i, MeasurableSpace (α i)] :
    ⇑(MeasurableEquiv.sumPiEquivProdPi α).symm = (Equiv.sumPiEquivProdPi α).symm 
goal: ⇑(MeasurableEquiv.sumPiEquivProdPi α).symm = ⇑(Equiv.sumPiEquivProdPi α).symm

full_name: MeasurableEquiv.piOptionEquivProd
code: /-- The measurable equivalence for (dependent) functions on an Option type
  `(∀ i : Option δ, α i) ≃ᵐ (∀ (i : δ), α i) × α none`. -/
def piOptionEquivProd {δ : Type*} (α : Option δ → Type*) [∀ i, MeasurableSpace (α i)] :
    (∀ i, α i) ≃ᵐ (∀ (i : δ), α i) × α none 
goal: ((i : Option δ) → α i) ≃ᵐ ((i : δ) → α (some i)) × α none

full_name: MeasurableEquiv.piFinsetUnion
code: /-- The measurable equivalence `(∀ i : s, π i) × (∀ i : t, π i) ≃ᵐ (∀ i : s ∪ t, π i)`
  for disjoint finsets `s` and `t`. `Equiv.piFinsetUnion` as a measurable equivalence. -/
def piFinsetUnion [DecidableEq δ'] {s t : Finset δ'} (h : Disjoint s t) :
    ((∀ i : s, π i) × ∀ i : t, π i) ≃ᵐ ∀ i : (s ∪ t : Finset δ'), π i 
goal: ((i : { x // x ∈ s }) → π ↑i) × ((i : { x // x ∈ t }) → π ↑i) ≃ᵐ ((i : { x // x ∈ s ∪ t }) → π ↑i)

full_name: MeasurableEquiv.sumCompl
code: /-- If `s` is a measurable set in a measurable space, that space is equivalent
to the sum of `s` and `sᶜ`. -/
def sumCompl {s : Set α} [DecidablePred (· ∈ s)] (hs : MeasurableSet s) :
    s ⊕ (sᶜ : Set α) ≃ᵐ α 
goal: ↑s ⊕ ↑sᶜ ≃ᵐ α

full_name: MeasurableEquiv.ofInvolutive_toEquiv
code: /-- Convert a measurable involutive function `f` to a measurable permutation with
`toFun = invFun = f`. See also `Function.Involutive.toPerm`. -/
@[simps toEquiv]
def ofInvolutive (f : α → α) (hf : Involutive f) (hf' : Measurable f) : α ≃ᵐ α 
goal: (MeasurableEquiv.ofInvolutive f hf hf').toEquiv = Function.Involutive.toPerm f hf

full_name: MeasurableEquiv.ofInvolutive
code: /-- Convert a measurable involutive function `f` to a measurable permutation with
`toFun = invFun = f`. See also `Function.Involutive.toPerm`. -/
@[simps toEquiv]
def ofInvolutive (f : α → α) (hf : Involutive f) (hf' : Measurable f) : α ≃ᵐ α 
goal: α ≃ᵐ α

full_name: MeasurableEquiv.ofInvolutive_apply
code: @[simp] theorem ofInvolutive_apply (f : α → α) (hf : Involutive f) (hf' : Measurable f) (a : α) :
    ofInvolutive f hf hf' a = f a 
goal: (MeasurableEquiv.ofInvolutive f hf hf') a = f a

full_name: MeasurableEquiv.ofInvolutive_symm
code: @[simp] theorem ofInvolutive_symm (f : α → α) (hf : Involutive f) (hf' : Measurable f) :
    (ofInvolutive f hf hf').symm = ofInvolutive f hf hf' 
goal: (MeasurableEquiv.ofInvolutive f hf hf').symm = MeasurableEquiv.ofInvolutive f hf hf'

full_name: MeasurableEmbedding.comap_eq
code: @[simp] theorem comap_eq (hf : MeasurableEmbedding f) : MeasurableSpace.comap f ‹_› = ‹_› 
goal: MeasurableSpace.comap f inst✝ = inst✝¹

full_name: MeasurableEmbedding.iff_comap_eq
code: theorem iff_comap_eq :
    MeasurableEmbedding f ↔
      Injective f ∧ MeasurableSpace.comap f ‹_› = ‹_› ∧ MeasurableSet (range f) 
goal: MeasurableEmbedding f ↔ Function.Injective f ∧ MeasurableSpace.comap f inst✝ = inst✝¹ ∧ MeasurableSet (Set.range f)

full_name: MeasurableEmbedding.equivImage
code: /-- A set is equivalent to its image under a function `f` as measurable spaces,
  if `f` is a measurable embedding -/
noncomputable def equivImage (s : Set α) (hf : MeasurableEmbedding f) : s ≃ᵐ f '' s 
goal: ↑s ≃ᵐ ↑(f '' s)

full_name: MeasurableEmbedding.equivRange
code: /-- The domain of `f` is equivalent to its range as measurable spaces,
  if `f` is a measurable embedding -/
noncomputable def equivRange (hf : MeasurableEmbedding f) : α ≃ᵐ range f 
goal: α ≃ᵐ ↑(Set.range f)

full_name: MeasurableEmbedding.of_measurable_inverse_on_range
code: theorem of_measurable_inverse_on_range {g : range f → α} (hf₁ : Measurable f)
    (hf₂ : MeasurableSet (range f)) (hg : Measurable g) (H : LeftInverse g (rangeFactorization f)) :
    MeasurableEmbedding f 
goal: MeasurableEmbedding f

full_name: MeasurableEmbedding.of_measurable_inverse
code: theorem of_measurable_inverse (hf₁ : Measurable f) (hf₂ : MeasurableSet (range f))
    (hg : Measurable g) (H : LeftInverse g f) : MeasurableEmbedding f 
goal: MeasurableEmbedding f

full_name: MeasurableEmbedding.schroederBernstein
code: /-- The **measurable Schröder-Bernstein Theorem**: given measurable embeddings
`α → β` and `β → α`, we can find a measurable equivalence `α ≃ᵐ β`. -/
noncomputable def schroederBernstein {f : α → β} {g : β → α} (hf : MeasurableEmbedding f)
    (hg : MeasurableEmbedding g) : α ≃ᵐ β 
goal: α ≃ᵐ β

full_name: MeasurableSpace.comap_compl
code: theorem MeasurableSpace.comap_compl {m' : MeasurableSpace β} [BooleanAlgebra β]
    (h : Measurable (compl : β → β)) (f : α → β) :
    MeasurableSpace.comap (fun a => (f a)ᶜ) inferInstance =
      MeasurableSpace.comap f inferInstance 
goal: MeasurableSpace.comap (fun a => (f a)ᶜ) inferInstance = MeasurableSpace.comap f inferInstance

full_name: MeasurableSpace.comap_not
code: @[simp] theorem MeasurableSpace.comap_not (p : α → Prop) :
    MeasurableSpace.comap (fun a ↦ ¬p a) inferInstance = MeasurableSpace.comap p inferInstance 
goal: MeasurableSpace.comap (fun a => ¬p a) inferInstance = MeasurableSpace.comap p inferInstance