File: Mathlib/MeasureTheory/Function/AEEqFun.lean

full_name: MeasureTheory.Measure.aeEqSetoid
code: /-- The equivalence relation of being almost everywhere equal for almost everywhere strongly
measurable functions. -/
def Measure.aeEqSetoid (μ : Measure α) : Setoid { f : α → β // AEStronglyMeasurable f μ } 
goal: Setoid { f // MeasureTheory.AEStronglyMeasurable f μ }

full_name: MeasureTheory.AEEqFun
code: /-- The space of equivalence classes of almost everywhere strongly measurable functions, where two
    strongly measurable functions are equivalent if they agree almost everywhere, i.e.,
    they differ on a set of measure `0`.  -/
def AEEqFun (μ : Measure α) : Type _ 
goal: Type (max u_1 u_2)

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Function_AEEqFun___unexpand_MeasureTheory_AEEqFun_1
code: @[inherit_doc MeasureTheory.AEEqFun]
notation:25 α " →ₘ[" μ "] " β => AEEqFun α β μ
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_AEEqFun___macroRules_MeasureTheory_term_→ₘ[_]__1»
code: @[inherit_doc MeasureTheory.AEEqFun]
notation:25 α " →ₘ[" μ "] " β => AEEqFun α β μ
goal: Lean.Macro

full_name: MeasureTheory.AEEqFun.mk
code: /-- Construct the equivalence class `[f]` of an almost everywhere measurable function `f`, based
    on the equivalence relation of being almost everywhere equal. -/
def mk {β : Type*} [TopologicalSpace β] (f : α → β) (hf : AEStronglyMeasurable f μ) : α →ₘ[μ] β 
goal: α →ₘ[μ] β

full_name: MeasureTheory.AEEqFun.cast
code: /-- Coercion from a space of equivalence classes of almost everywhere strongly measurable
functions to functions. -/
@[coe]
def cast (f : α →ₘ[μ] β) : α → β 
goal: α → β

full_name: MeasureTheory.AEEqFun.instCoeFun
code: /-- A measurable representative of an `AEEqFun` [f] -/
instance instCoeFun : CoeFun (α →ₘ[μ] β) fun _ => α → β 
goal: CoeFun (α →ₘ[μ] β) fun x => α → β

full_name: MeasureTheory.AEEqFun.stronglyMeasurable
code: protected theorem stronglyMeasurable (f : α →ₘ[μ] β) : StronglyMeasurable f 
goal: MeasureTheory.StronglyMeasurable ↑f

full_name: MeasureTheory.AEEqFun.aestronglyMeasurable
code: protected theorem aestronglyMeasurable (f : α →ₘ[μ] β) : AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable (↑f) μ

full_name: MeasureTheory.AEEqFun.measurable
code: protected theorem measurable [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    (f : α →ₘ[μ] β) : Measurable f 
goal: Measurable ↑f

full_name: MeasureTheory.AEEqFun.aemeasurable
code: protected theorem aemeasurable [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    (f : α →ₘ[μ] β) : AEMeasurable f μ 
goal: AEMeasurable (↑f) μ

full_name: MeasureTheory.AEEqFun.quot_mk_eq_mk
code: @[simp]
theorem quot_mk_eq_mk (f : α → β) (hf) :
    (Quot.mk (@Setoid.r _ <| μ.aeEqSetoid β) ⟨f, hf⟩ : α →ₘ[μ] β) = mk f hf 
goal: Quot.mk Setoid.r ⟨f, hf⟩ = MeasureTheory.AEEqFun.mk f hf

full_name: MeasureTheory.AEEqFun.mk_eq_mk
code: @[simp]
theorem mk_eq_mk {f g : α → β} {hf hg} : (mk f hf : α →ₘ[μ] β) = mk g hg ↔ f =ᵐ[μ] g 
goal: MeasureTheory.AEEqFun.mk f hf = MeasureTheory.AEEqFun.mk g hg ↔ f =ᵐ[μ] g

full_name: MeasureTheory.AEEqFun.mk_coeFn
code: @[simp]
theorem mk_coeFn (f : α →ₘ[μ] β) : mk f f.aestronglyMeasurable = f 
goal: MeasureTheory.AEEqFun.mk ↑f ⋯ = f

full_name: MeasureTheory.AEEqFun.ext
code: @[ext]
theorem ext {f g : α →ₘ[μ] β} (h : f =ᵐ[μ] g) : f = g 
goal: f = g

full_name: MeasureTheory.AEEqFun.ext_iff
code: theorem ext_iff {f g : α →ₘ[μ] β} : f = g ↔ f =ᵐ[μ] g 
goal: f = g ↔ ↑f =ᵐ[μ] ↑g

full_name: MeasureTheory.AEEqFun.coeFn_mk
code: theorem coeFn_mk (f : α → β) (hf) : (mk f hf : α →ₘ[μ] β) =ᵐ[μ] f 
goal: ↑(MeasureTheory.AEEqFun.mk f hf) =ᵐ[μ] f

full_name: MeasureTheory.AEEqFun.induction_on
code: @[elab_as_elim]
theorem induction_on (f : α →ₘ[μ] β) {p : (α →ₘ[μ] β) → Prop} (H : ∀ f hf, p (mk f hf)) : p f 
goal: p f

full_name: MeasureTheory.AEEqFun.induction_on₂
code: @[elab_as_elim]
theorem induction_on₂ {α' β' : Type*} [MeasurableSpace α'] [TopologicalSpace β'] {μ' : Measure α'}
    (f : α →ₘ[μ] β) (f' : α' →ₘ[μ'] β') {p : (α →ₘ[μ] β) → (α' →ₘ[μ'] β') → Prop}
    (H : ∀ f hf f' hf', p (mk f hf) (mk f' hf')) : p f f' 
goal: p f f'

full_name: MeasureTheory.AEEqFun.induction_on₃
code: @[elab_as_elim]
theorem induction_on₃ {α' β' : Type*} [MeasurableSpace α'] [TopologicalSpace β'] {μ' : Measure α'}
    {α'' β'' : Type*} [MeasurableSpace α''] [TopologicalSpace β''] {μ'' : Measure α''}
    (f : α →ₘ[μ] β) (f' : α' →ₘ[μ'] β') (f'' : α'' →ₘ[μ''] β'')
    {p : (α →ₘ[μ] β) → (α' →ₘ[μ'] β') → (α'' →ₘ[μ''] β'') → Prop}
    (H : ∀ f hf f' hf' f'' hf'', p (mk f hf) (mk f' hf') (mk f'' hf'')) : p f f' f'' 
goal: p f f' f''

full_name: MeasureTheory.AEEqFun.compQuasiMeasurePreserving
code: /-- Composition of an almost everywhere equal function and a quasi measure preserving function.

See also `AEEqFun.compMeasurePreserving`. -/
def compQuasiMeasurePreserving (g : β →ₘ[ν] γ) (f : α → β) (hf : QuasiMeasurePreserving f μ ν) :
    α →ₘ[μ] γ 
goal: α →ₘ[μ] γ

full_name: MeasureTheory.AEEqFun.compQuasiMeasurePreserving_mk
code: @[simp]
theorem compQuasiMeasurePreserving_mk {g : β → γ} (hg : AEStronglyMeasurable g ν)
    (hf : QuasiMeasurePreserving f μ ν) :
    (mk g hg).compQuasiMeasurePreserving f hf = mk (g ∘ f) (hg.comp_quasiMeasurePreserving hf) 
goal: (MeasureTheory.AEEqFun.mk g hg).compQuasiMeasurePreserving f hf = MeasureTheory.AEEqFun.mk (g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.compQuasiMeasurePreserving_eq_mk
code: theorem compQuasiMeasurePreserving_eq_mk (g : β →ₘ[ν] γ) (hf : QuasiMeasurePreserving f μ ν) :
    g.compQuasiMeasurePreserving f hf =
      mk (g ∘ f) (g.aestronglyMeasurable.comp_quasiMeasurePreserving hf) 
goal: g.compQuasiMeasurePreserving f hf = MeasureTheory.AEEqFun.mk (↑g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_compQuasiMeasurePreserving
code: theorem coeFn_compQuasiMeasurePreserving (g : β →ₘ[ν] γ) (hf : QuasiMeasurePreserving f μ ν) :
    g.compQuasiMeasurePreserving f hf =ᵐ[μ] g ∘ f 
goal: ↑(g.compQuasiMeasurePreserving f hf) =ᵐ[μ] ↑g ∘ f

full_name: MeasureTheory.AEEqFun.compMeasurePreserving
code: /-- Composition of an almost everywhere equal function and a quasi measure preserving function.

This is an important special case of `AEEqFun.compQuasiMeasurePreserving`. We use a separate
definition so that lemmas that need `f` to be measure preserving can be `@[simp]` lemmas.  -/
def compMeasurePreserving (g : β →ₘ[ν] γ) (f : α → β) (hf : MeasurePreserving f μ ν) : α →ₘ[μ] γ 
goal: α →ₘ[μ] γ

full_name: MeasureTheory.AEEqFun.compMeasurePreserving_mk
code: @[simp]
theorem compMeasurePreserving_mk (hg : AEStronglyMeasurable g ν) (hf : MeasurePreserving f μ ν) :
    (mk g hg).compMeasurePreserving f hf =
      mk (g ∘ f) (hg.comp_quasiMeasurePreserving hf.quasiMeasurePreserving) 
goal: (MeasureTheory.AEEqFun.mk g hg).compMeasurePreserving f hf = MeasureTheory.AEEqFun.mk (g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.compMeasurePreserving_eq_mk
code: theorem compMeasurePreserving_eq_mk (g : β →ₘ[ν] γ) (hf : MeasurePreserving f μ ν) :
    g.compMeasurePreserving f hf =
      mk (g ∘ f) (g.aestronglyMeasurable.comp_quasiMeasurePreserving hf.quasiMeasurePreserving) 
goal: g.compMeasurePreserving f hf = MeasureTheory.AEEqFun.mk (↑g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_compMeasurePreserving
code: theorem coeFn_compMeasurePreserving (g : β →ₘ[ν] γ) (hf : MeasurePreserving f μ ν) :
    g.compMeasurePreserving f hf =ᵐ[μ] g ∘ f 
goal: ↑(g.compMeasurePreserving f hf) =ᵐ[μ] ↑g ∘ f

full_name: MeasureTheory.AEEqFun.comp
code: /-- Given a continuous function `g : β → γ`, and an almost everywhere equal function `[f] : α →ₘ β`,
    return the equivalence class of `g ∘ f`, i.e., the almost everywhere equal function
    `[g ∘ f] : α →ₘ γ`. -/
def comp (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β) : α →ₘ[μ] γ 
goal: α →ₘ[μ] γ

full_name: MeasureTheory.AEEqFun.comp_mk
code: @[simp]
theorem comp_mk (g : β → γ) (hg : Continuous g) (f : α → β) (hf) :
    comp g hg (mk f hf : α →ₘ[μ] β) = mk (g ∘ f) (hg.comp_aestronglyMeasurable hf) 
goal: MeasureTheory.AEEqFun.comp g hg (MeasureTheory.AEEqFun.mk f hf) = MeasureTheory.AEEqFun.mk (g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.comp_eq_mk
code: theorem comp_eq_mk (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β) :
    comp g hg f = mk (g ∘ f) (hg.comp_aestronglyMeasurable f.aestronglyMeasurable) 
goal: MeasureTheory.AEEqFun.comp g hg f = MeasureTheory.AEEqFun.mk (g ∘ ↑f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_comp
code: theorem coeFn_comp (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β) : comp g hg f =ᵐ[μ] g ∘ f 
goal: ↑(MeasureTheory.AEEqFun.comp g hg f) =ᵐ[μ] g ∘ ↑f

full_name: MeasureTheory.AEEqFun.comp_compQuasiMeasurePreserving
code: theorem comp_compQuasiMeasurePreserving [MeasurableSpace β] {ν} (g : γ → δ) (hg : Continuous g)
    (f : β →ₘ[ν] γ) {φ : α → β} (hφ : Measure.QuasiMeasurePreserving φ μ ν) :
    (comp g hg f).compQuasiMeasurePreserving φ hφ =
      comp g hg (f.compQuasiMeasurePreserving φ hφ) 
goal: (MeasureTheory.AEEqFun.comp g hg f).compQuasiMeasurePreserving φ hφ =
  MeasureTheory.AEEqFun.comp g hg (f.compQuasiMeasurePreserving φ hφ)

full_name: MeasureTheory.AEEqFun.compMeasurable
code: /-- Given a measurable function `g : β → γ`, and an almost everywhere equal function `[f] : α →ₘ β`,
    return the equivalence class of `g ∘ f`, i.e., the almost everywhere equal function
    `[g ∘ f] : α →ₘ γ`. This requires that `γ` has a second countable topology. -/
def compMeasurable (g : β → γ) (hg : Measurable g) (f : α →ₘ[μ] β) : α →ₘ[μ] γ 
goal: α →ₘ[μ] γ

full_name: MeasureTheory.AEEqFun.compMeasurable_mk
code: @[simp]
theorem compMeasurable_mk (g : β → γ) (hg : Measurable g) (f : α → β)
    (hf : AEStronglyMeasurable f μ) :
    compMeasurable g hg (mk f hf : α →ₘ[μ] β) =
      mk (g ∘ f) (hg.comp_aemeasurable hf.aemeasurable).aestronglyMeasurable 
goal: MeasureTheory.AEEqFun.compMeasurable g hg (MeasureTheory.AEEqFun.mk f hf) = MeasureTheory.AEEqFun.mk (g ∘ f) ⋯

full_name: MeasureTheory.AEEqFun.compMeasurable_eq_mk
code: theorem compMeasurable_eq_mk (g : β → γ) (hg : Measurable g) (f : α →ₘ[μ] β) :
    compMeasurable g hg f =
    mk (g ∘ f) (hg.comp_aemeasurable f.aemeasurable).aestronglyMeasurable 
goal: MeasureTheory.AEEqFun.compMeasurable g hg f = MeasureTheory.AEEqFun.mk (g ∘ ↑f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_compMeasurable
code: theorem coeFn_compMeasurable (g : β → γ) (hg : Measurable g) (f : α →ₘ[μ] β) :
    compMeasurable g hg f =ᵐ[μ] g ∘ f 
goal: ↑(MeasureTheory.AEEqFun.compMeasurable g hg f) =ᵐ[μ] g ∘ ↑f

full_name: MeasureTheory.AEEqFun.pair
code: /-- The class of `x ↦ (f x, g x)`. -/
def pair (f : α →ₘ[μ] β) (g : α →ₘ[μ] γ) : α →ₘ[μ] β × γ 
goal: α →ₘ[μ] β × γ

full_name: MeasureTheory.AEEqFun.pair_mk_mk
code: @[simp]
theorem pair_mk_mk (f : α → β) (hf) (g : α → γ) (hg) :
    (mk f hf : α →ₘ[μ] β).pair (mk g hg) = mk (fun x => (f x, g x)) (hf.prod_mk hg) 
goal: (MeasureTheory.AEEqFun.mk f hf).pair (MeasureTheory.AEEqFun.mk g hg) = MeasureTheory.AEEqFun.mk (fun x => (f x, g x)) ⋯

full_name: MeasureTheory.AEEqFun.pair_eq_mk
code: theorem pair_eq_mk (f : α →ₘ[μ] β) (g : α →ₘ[μ] γ) :
    f.pair g =
      mk (fun x => (f x, g x)) (f.aestronglyMeasurable.prod_mk g.aestronglyMeasurable) 
goal: f.pair g = MeasureTheory.AEEqFun.mk (fun x => (↑f x, ↑g x)) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_pair
code: theorem coeFn_pair (f : α →ₘ[μ] β) (g : α →ₘ[μ] γ) : f.pair g =ᵐ[μ] fun x => (f x, g x) 
goal: ↑(f.pair g) =ᵐ[μ] fun x => (↑f x, ↑g x)

full_name: MeasureTheory.AEEqFun.comp₂
code: /-- Given a continuous function `g : β → γ → δ`, and almost everywhere equal functions
    `[f₁] : α →ₘ β` and `[f₂] : α →ₘ γ`, return the equivalence class of the function
    `fun a => g (f₁ a) (f₂ a)`, i.e., the almost everywhere equal function
    `[fun a => g (f₁ a) (f₂ a)] : α →ₘ γ` -/
def comp₂ (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β) (f₂ : α →ₘ[μ] γ) :
    α →ₘ[μ] δ 
goal: α →ₘ[μ] δ

full_name: MeasureTheory.AEEqFun.comp₂_mk_mk
code: @[simp]
theorem comp₂_mk_mk (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α → β) (f₂ : α → γ)
    (hf₁ hf₂) :
    comp₂ g hg (mk f₁ hf₁ : α →ₘ[μ] β) (mk f₂ hf₂) =
      mk (fun a => g (f₁ a) (f₂ a)) (hg.comp_aestronglyMeasurable (hf₁.prod_mk hf₂)) 
goal: MeasureTheory.AEEqFun.comp₂ g hg (MeasureTheory.AEEqFun.mk f₁ hf₁) (MeasureTheory.AEEqFun.mk f₂ hf₂) =
  MeasureTheory.AEEqFun.mk (fun a => g (f₁ a) (f₂ a)) ⋯

full_name: MeasureTheory.AEEqFun.comp₂_eq_pair
code: theorem comp₂_eq_pair (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : comp₂ g hg f₁ f₂ = comp _ hg (f₁.pair f₂) 
goal: MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂ = MeasureTheory.AEEqFun.comp (Function.uncurry g) hg (f₁.pair f₂)

full_name: MeasureTheory.AEEqFun.comp₂_eq_mk
code: theorem comp₂_eq_mk (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : comp₂ g hg f₁ f₂ = mk (fun a => g (f₁ a) (f₂ a))
      (hg.comp_aestronglyMeasurable (f₁.aestronglyMeasurable.prod_mk f₂.aestronglyMeasurable)) 
goal: MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂ = MeasureTheory.AEEqFun.mk (fun a => g (↑f₁ a) (↑f₂ a)) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_comp₂
code: theorem coeFn_comp₂ (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : comp₂ g hg f₁ f₂ =ᵐ[μ] fun a => g (f₁ a) (f₂ a) 
goal: ↑(MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂) =ᵐ[μ] fun a => g (↑f₁ a) (↑f₂ a)

full_name: MeasureTheory.AEEqFun.comp₂Measurable
code: /-- Given a measurable function `g : β → γ → δ`, and almost everywhere equal functions
    `[f₁] : α →ₘ β` and `[f₂] : α →ₘ γ`, return the equivalence class of the function
    `fun a => g (f₁ a) (f₂ a)`, i.e., the almost everywhere equal function
    `[fun a => g (f₁ a) (f₂ a)] : α →ₘ γ`. This requires `δ` to have second-countable topology. -/
def comp₂Measurable (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : α →ₘ[μ] δ 
goal: α →ₘ[μ] δ

full_name: MeasureTheory.AEEqFun.comp₂Measurable_mk_mk
code: @[simp]
theorem comp₂Measurable_mk_mk (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α → β)
    (f₂ : α → γ) (hf₁ hf₂) :
    comp₂Measurable g hg (mk f₁ hf₁ : α →ₘ[μ] β) (mk f₂ hf₂) =
      mk (fun a => g (f₁ a) (f₂ a))
        (hg.comp_aemeasurable (hf₁.aemeasurable.prod_mk hf₂.aemeasurable)).aestronglyMeasurable 
goal: MeasureTheory.AEEqFun.comp₂Measurable g hg (MeasureTheory.AEEqFun.mk f₁ hf₁) (MeasureTheory.AEEqFun.mk f₂ hf₂) =
  MeasureTheory.AEEqFun.mk (fun a => g (f₁ a) (f₂ a)) ⋯

full_name: MeasureTheory.AEEqFun.comp₂Measurable_eq_pair
code: theorem comp₂Measurable_eq_pair (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : comp₂Measurable g hg f₁ f₂ = compMeasurable _ hg (f₁.pair f₂) 
goal: MeasureTheory.AEEqFun.comp₂Measurable g hg f₁ f₂ =
  MeasureTheory.AEEqFun.compMeasurable (Function.uncurry g) hg (f₁.pair f₂)

full_name: MeasureTheory.AEEqFun.comp₂Measurable_eq_mk
code: theorem comp₂Measurable_eq_mk (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) :
    comp₂Measurable g hg f₁ f₂ =
      mk (fun a => g (f₁ a) (f₂ a))
        (hg.comp_aemeasurable (f₁.aemeasurable.prod_mk f₂.aemeasurable)).aestronglyMeasurable 
goal: MeasureTheory.AEEqFun.comp₂Measurable g hg f₁ f₂ = MeasureTheory.AEEqFun.mk (fun a => g (↑f₁ a) (↑f₂ a)) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_comp₂Measurable
code: theorem coeFn_comp₂Measurable (g : β → γ → δ) (hg : Measurable (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : comp₂Measurable g hg f₁ f₂ =ᵐ[μ] fun a => g (f₁ a) (f₂ a) 
goal: ↑(MeasureTheory.AEEqFun.comp₂Measurable g hg f₁ f₂) =ᵐ[μ] fun a => g (↑f₁ a) (↑f₂ a)

full_name: MeasureTheory.AEEqFun.toGerm
code: /-- Interpret `f : α →ₘ[μ] β` as a germ at `ae μ` forgetting that `f` is almost everywhere
    strongly measurable. -/
def toGerm (f : α →ₘ[μ] β) : Germ (ae μ) β 
goal: (MeasureTheory.ae μ).Germ β

full_name: MeasureTheory.AEEqFun.mk_toGerm
code: @[simp]
theorem mk_toGerm (f : α → β) (hf) : (mk f hf : α →ₘ[μ] β).toGerm = f 
goal: (MeasureTheory.AEEqFun.mk f hf).toGerm = ↑f

full_name: MeasureTheory.AEEqFun.toGerm_eq
code: theorem toGerm_eq (f : α →ₘ[μ] β) : f.toGerm = (f : α → β) 
goal: f.toGerm = ↑↑f

full_name: MeasureTheory.AEEqFun.toGerm_injective
code: theorem toGerm_injective : Injective (toGerm : (α →ₘ[μ] β) → Germ (ae μ) β) 
goal: Function.Injective MeasureTheory.AEEqFun.toGerm

full_name: MeasureTheory.AEEqFun.compQuasiMeasurePreserving_toGerm
code: @[simp]
theorem compQuasiMeasurePreserving_toGerm [MeasurableSpace β] {f : α → β} {ν}
    (g : β →ₘ[ν] γ) (hf : Measure.QuasiMeasurePreserving f μ ν) :
    (g.compQuasiMeasurePreserving f hf).toGerm = g.toGerm.compTendsto f hf.tendsto_ae 
goal: (g.compQuasiMeasurePreserving f hf).toGerm = g.toGerm.compTendsto f ⋯

full_name: MeasureTheory.AEEqFun.compMeasurePreserving_toGerm
code: @[simp]
theorem compMeasurePreserving_toGerm [MeasurableSpace β] {f : α → β} {ν}
    (g : β →ₘ[ν] γ) (hf : MeasurePreserving f μ ν) :
    (g.compMeasurePreserving f hf).toGerm =
      g.toGerm.compTendsto f hf.quasiMeasurePreserving.tendsto_ae 
goal: (g.compMeasurePreserving f hf).toGerm = g.toGerm.compTendsto f ⋯

full_name: MeasureTheory.AEEqFun.comp_toGerm
code: theorem comp_toGerm (g : β → γ) (hg : Continuous g) (f : α →ₘ[μ] β) :
    (comp g hg f).toGerm = f.toGerm.map g 
goal: (MeasureTheory.AEEqFun.comp g hg f).toGerm = Filter.Germ.map g f.toGerm

full_name: MeasureTheory.AEEqFun.compMeasurable_toGerm
code: theorem compMeasurable_toGerm [MeasurableSpace β] [BorelSpace β] [PseudoMetrizableSpace β]
    [PseudoMetrizableSpace γ] [SecondCountableTopology γ] [MeasurableSpace γ]
    [OpensMeasurableSpace γ] (g : β → γ) (hg : Measurable g) (f : α →ₘ[μ] β) :
    (compMeasurable g hg f).toGerm = f.toGerm.map g 
goal: (MeasureTheory.AEEqFun.compMeasurable g hg f).toGerm = Filter.Germ.map g f.toGerm

full_name: MeasureTheory.AEEqFun.comp₂_toGerm
code: theorem comp₂_toGerm (g : β → γ → δ) (hg : Continuous (uncurry g)) (f₁ : α →ₘ[μ] β)
    (f₂ : α →ₘ[μ] γ) : (comp₂ g hg f₁ f₂).toGerm = f₁.toGerm.map₂ g f₂.toGerm 
goal: (MeasureTheory.AEEqFun.comp₂ g hg f₁ f₂).toGerm = Filter.Germ.map₂ g f₁.toGerm f₂.toGerm

full_name: MeasureTheory.AEEqFun.comp₂Measurable_toGerm
code: theorem comp₂Measurable_toGerm [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β]
    [PseudoMetrizableSpace γ] [SecondCountableTopologyEither β γ]
    [MeasurableSpace γ] [BorelSpace γ] [PseudoMetrizableSpace δ] [SecondCountableTopology δ]
    [MeasurableSpace δ] [OpensMeasurableSpace δ] (g : β → γ → δ) (hg : Measurable (uncurry g))
    (f₁ : α →ₘ[μ] β) (f₂ : α →ₘ[μ] γ) :
    (comp₂Measurable g hg f₁ f₂).toGerm = f₁.toGerm.map₂ g f₂.toGerm 
goal: (MeasureTheory.AEEqFun.comp₂Measurable g hg f₁ f₂).toGerm = Filter.Germ.map₂ g f₁.toGerm f₂.toGerm

full_name: MeasureTheory.AEEqFun.LiftPred
code: /-- Given a predicate `p` and an equivalence class `[f]`, return true if `p` holds of `f a`
    for almost all `a` -/
def LiftPred (p : β → Prop) (f : α →ₘ[μ] β) : Prop 
goal: Prop

full_name: MeasureTheory.AEEqFun.LiftRel
code: /-- Given a relation `r` and equivalence class `[f]` and `[g]`, return true if `r` holds of
    `(f a, g a)` for almost all `a` -/
def LiftRel (r : β → γ → Prop) (f : α →ₘ[μ] β) (g : α →ₘ[μ] γ) : Prop 
goal: Prop

full_name: MeasureTheory.AEEqFun.liftRel_mk_mk
code: theorem liftRel_mk_mk {r : β → γ → Prop} {f : α → β} {g : α → γ} {hf hg} :
    LiftRel r (mk f hf : α →ₘ[μ] β) (mk g hg) ↔ ∀ᵐ a ∂μ, r (f a) (g a) 
goal: MeasureTheory.AEEqFun.LiftRel r (MeasureTheory.AEEqFun.mk f hf) (MeasureTheory.AEEqFun.mk g hg) ↔
  ∀ᵐ (a : α) ∂μ, r (f a) (g a)

full_name: MeasureTheory.AEEqFun.liftRel_iff_coeFn
code: theorem liftRel_iff_coeFn {r : β → γ → Prop} {f : α →ₘ[μ] β} {g : α →ₘ[μ] γ} :
    LiftRel r f g ↔ ∀ᵐ a ∂μ, r (f a) (g a) 
goal: MeasureTheory.AEEqFun.LiftRel r f g ↔ ∀ᵐ (a : α) ∂μ, r (↑f a) (↑g a)

full_name: MeasureTheory.AEEqFun.instPreorder
code: instance instPreorder [Preorder β] : Preorder (α →ₘ[μ] β) 
goal: Preorder (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.mk_le_mk
code: @[simp]
theorem mk_le_mk [Preorder β] {f g : α → β} (hf hg) : (mk f hf : α →ₘ[μ] β) ≤ mk g hg ↔ f ≤ᵐ[μ] g 
goal: MeasureTheory.AEEqFun.mk f hf ≤ MeasureTheory.AEEqFun.mk g hg ↔ f ≤ᵐ[μ] g

full_name: MeasureTheory.AEEqFun.coeFn_le
code: @[simp, norm_cast]
theorem coeFn_le [Preorder β] {f g : α →ₘ[μ] β} : (f : α → β) ≤ᵐ[μ] g ↔ f ≤ g 
goal: ↑f ≤ᵐ[μ] ↑g ↔ f ≤ g

full_name: MeasureTheory.AEEqFun.instPartialOrder
code: instance instPartialOrder [PartialOrder β] : PartialOrder (α →ₘ[μ] β) 
goal: PartialOrder (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.instSup
code: instance instSup : Sup (α →ₘ[μ] β) 
goal: Sup (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.coeFn_sup
code: theorem coeFn_sup (f g : α →ₘ[μ] β) : ⇑(f ⊔ g) =ᵐ[μ] fun x => f x ⊔ g x 
goal: ↑(f ⊔ g) =ᵐ[μ] fun x => ↑f x ⊔ ↑g x

full_name: MeasureTheory.AEEqFun.le_sup_left
code: protected theorem le_sup_left (f g : α →ₘ[μ] β) : f ≤ f ⊔ g 
goal: f ≤ f ⊔ g

full_name: MeasureTheory.AEEqFun.le_sup_right
code: protected theorem le_sup_right (f g : α →ₘ[μ] β) : g ≤ f ⊔ g 
goal: g ≤ f ⊔ g

full_name: MeasureTheory.AEEqFun.sup_le
code: protected theorem sup_le (f g f' : α →ₘ[μ] β) (hf : f ≤ f') (hg : g ≤ f') : f ⊔ g ≤ f' 
goal: f ⊔ g ≤ f'

full_name: MeasureTheory.AEEqFun.instInf
code: instance instInf : Inf (α →ₘ[μ] β) 
goal: Inf (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.coeFn_inf
code: theorem coeFn_inf (f g : α →ₘ[μ] β) : ⇑(f ⊓ g) =ᵐ[μ] fun x => f x ⊓ g x 
goal: ↑(f ⊓ g) =ᵐ[μ] fun x => ↑f x ⊓ ↑g x

full_name: MeasureTheory.AEEqFun.inf_le_left
code: protected theorem inf_le_left (f g : α →ₘ[μ] β) : f ⊓ g ≤ f 
goal: f ⊓ g ≤ f

full_name: MeasureTheory.AEEqFun.inf_le_right
code: protected theorem inf_le_right (f g : α →ₘ[μ] β) : f ⊓ g ≤ g 
goal: f ⊓ g ≤ g

full_name: MeasureTheory.AEEqFun.le_inf
code: protected theorem le_inf (f' f g : α →ₘ[μ] β) (hf : f' ≤ f) (hg : f' ≤ g) : f' ≤ f ⊓ g 
goal: f' ≤ f ⊓ g

full_name: MeasureTheory.AEEqFun.instLattice
code: instance instLattice [Lattice β] [TopologicalLattice β] : Lattice (α →ₘ[μ] β) 
goal: Lattice (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.const
code: /-- The equivalence class of a constant function: `[fun _ : α => b]`, based on the equivalence
relation of being almost everywhere equal -/
def const (b : β) : α →ₘ[μ] β 
goal: α →ₘ[μ] β

full_name: MeasureTheory.AEEqFun.coeFn_const
code: theorem coeFn_const (b : β) : (const α b : α →ₘ[μ] β) =ᵐ[μ] Function.const α b 
goal: ↑(MeasureTheory.AEEqFun.const α b) =ᵐ[μ] Function.const α b

full_name: MeasureTheory.AEEqFun.instInhabited
code: instance instInhabited [Inhabited β] : Inhabited (α →ₘ[μ] β) 
goal: Inhabited (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.instOne
code: @[to_additive]
instance instOne [One β] : One (α →ₘ[μ] β) 
goal: One (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.instZero
code: @[to_additive]
instance instOne [One β] : One (α →ₘ[μ] β) 
goal: Zero (α →ₘ[μ] β)

full_name: MeasureTheory.AEEqFun.zero_def
code: @[to_additive]
theorem one_def [One β] : (1 : α →ₘ[μ] β) = mk (fun _ : α => 1) aestronglyMeasurable_const 
goal: 0 = MeasureTheory.AEEqFun.mk (fun x => 0) ⋯

full_name: MeasureTheory.AEEqFun.one_def
code: @[to_additive]
theorem one_def [One β] : (1 : α →ₘ[μ] β) = mk (fun _ : α => 1) aestronglyMeasurable_const 
goal: 1 = MeasureTheory.AEEqFun.mk (fun x => 1) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_zero
code: @[to_additive]
theorem coeFn_one [One β] : ⇑(1 : α →ₘ[μ] β) =ᵐ[μ] 1 
goal: ↑0 =ᵐ[μ] 0

full_name: MeasureTheory.AEEqFun.coeFn_one
code: @[to_additive]
theorem coeFn_one [One β] : ⇑(1 : α →ₘ[μ] β) =ᵐ[μ] 1 
goal: ↑1 =ᵐ[μ] 1

full_name: MeasureTheory.AEEqFun.one_toGerm
code: @[to_additive (attr := simp)]
theorem one_toGerm [One β] : (1 : α →ₘ[μ] β).toGerm = 1 
goal: MeasureTheory.AEEqFun.toGerm 1 = 1

full_name: MeasureTheory.AEEqFun.zero_toGerm
code: @[to_additive (attr := simp)]
theorem one_toGerm [One β] : (1 : α →ₘ[μ] β).toGerm = 1 
goal: MeasureTheory.AEEqFun.toGerm 0 = 0

full_name: MeasureTheory.AEEqFun.instSMul
code: instance instSMul : SMul 𝕜 (α →ₘ[μ] γ) 
goal: SMul 𝕜 (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.smul_mk
code: @[simp]
theorem smul_mk (c : 𝕜) (f : α → γ) (hf : AEStronglyMeasurable f μ) :
    c • (mk f hf : α →ₘ[μ] γ) = mk (c • f) (hf.const_smul _) 
goal: c • MeasureTheory.AEEqFun.mk f hf = MeasureTheory.AEEqFun.mk (c • f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_smul
code: theorem coeFn_smul (c : 𝕜) (f : α →ₘ[μ] γ) : ⇑(c • f) =ᵐ[μ] c • ⇑f 
goal: ↑(c • f) =ᵐ[μ] c • ↑f

full_name: MeasureTheory.AEEqFun.smul_toGerm
code: theorem smul_toGerm (c : 𝕜) (f : α →ₘ[μ] γ) : (c • f).toGerm = c • f.toGerm 
goal: (c • f).toGerm = c • f.toGerm

full_name: MeasureTheory.AEEqFun.instSMulCommClass
code: instance instSMulCommClass [SMulCommClass 𝕜 𝕜' γ] : SMulCommClass 𝕜 𝕜' (α →ₘ[μ] γ) 
goal: SMulCommClass 𝕜 𝕜' (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instIsScalarTower
code: instance instIsScalarTower [SMul 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' γ] : IsScalarTower 𝕜 𝕜' (α →ₘ[μ] γ) 
goal: IsScalarTower 𝕜 𝕜' (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instIsCentralScalar
code: instance instIsCentralScalar [SMul 𝕜ᵐᵒᵖ γ] [IsCentralScalar 𝕜 γ] : IsCentralScalar 𝕜 (α →ₘ[μ] γ) 
goal: IsCentralScalar 𝕜 (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instMul
code: @[to_additive]
instance instMul : Mul (α →ₘ[μ] γ) 
goal: Mul (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instAdd
code: @[to_additive]
instance instMul : Mul (α →ₘ[μ] γ) 
goal: Add (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.mk_mul_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk (f g : α → γ) (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    (mk f hf : α →ₘ[μ] γ) * mk g hg = mk (f * g) (hf.mul hg) 
goal: MeasureTheory.AEEqFun.mk f hf * MeasureTheory.AEEqFun.mk g hg = MeasureTheory.AEEqFun.mk (f * g) ⋯

full_name: MeasureTheory.AEEqFun.mk_add_mk
code: @[to_additive (attr := simp)]
theorem mk_mul_mk (f g : α → γ) (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    (mk f hf : α →ₘ[μ] γ) * mk g hg = mk (f * g) (hf.mul hg) 
goal: MeasureTheory.AEEqFun.mk f hf + MeasureTheory.AEEqFun.mk g hg = MeasureTheory.AEEqFun.mk (f + g) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_add
code: @[to_additive]
theorem coeFn_mul (f g : α →ₘ[μ] γ) : ⇑(f * g) =ᵐ[μ] f * g 
goal: ↑(f + g) =ᵐ[μ] ↑f + ↑g

full_name: MeasureTheory.AEEqFun.coeFn_mul
code: @[to_additive]
theorem coeFn_mul (f g : α →ₘ[μ] γ) : ⇑(f * g) =ᵐ[μ] f * g 
goal: ↑(f * g) =ᵐ[μ] ↑f * ↑g

full_name: MeasureTheory.AEEqFun.add_toGerm
code: @[to_additive (attr := simp)]
theorem mul_toGerm (f g : α →ₘ[μ] γ) : (f * g).toGerm = f.toGerm * g.toGerm 
goal: (f + g).toGerm = f.toGerm + g.toGerm

full_name: MeasureTheory.AEEqFun.mul_toGerm
code: @[to_additive (attr := simp)]
theorem mul_toGerm (f g : α →ₘ[μ] γ) : (f * g).toGerm = f.toGerm * g.toGerm 
goal: (f * g).toGerm = f.toGerm * g.toGerm

full_name: MeasureTheory.AEEqFun.instAddMonoid
code: instance instAddMonoid [AddMonoid γ] [ContinuousAdd γ] : AddMonoid (α →ₘ[μ] γ) 
goal: AddMonoid (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instAddCommMonoid
code: instance instAddCommMonoid [AddCommMonoid γ] [ContinuousAdd γ] : AddCommMonoid (α →ₘ[μ] γ) 
goal: AddCommMonoid (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instPowNat
code: instance instPowNat : Pow (α →ₘ[μ] γ) ℕ 
goal: Pow (α →ₘ[μ] γ) ℕ

full_name: MeasureTheory.AEEqFun.mk_pow
code: @[simp]
theorem mk_pow (f : α → γ) (hf) (n : ℕ) :
    (mk f hf : α →ₘ[μ] γ) ^ n =
      mk (f ^ n) ((_root_.continuous_pow n).comp_aestronglyMeasurable hf) 
goal: MeasureTheory.AEEqFun.mk f hf ^ n = MeasureTheory.AEEqFun.mk (f ^ n) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_pow
code: theorem coeFn_pow (f : α →ₘ[μ] γ) (n : ℕ) : ⇑(f ^ n) =ᵐ[μ] (⇑f) ^ n 
goal: ↑(f ^ n) =ᵐ[μ] ↑f ^ n

full_name: MeasureTheory.AEEqFun.pow_toGerm
code: @[simp]
theorem pow_toGerm (f : α →ₘ[μ] γ) (n : ℕ) : (f ^ n).toGerm = f.toGerm ^ n 
goal: (f ^ n).toGerm = f.toGerm ^ n

full_name: MeasureTheory.AEEqFun.instMonoid
code: @[to_additive existing]
instance instMonoid : Monoid (α →ₘ[μ] γ) 
goal: Monoid (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.toGermMonoidHom_apply
code: /-- `AEEqFun.toGerm` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`AEEqFun.toGerm` as an `AddMonoidHom`."]
def toGermMonoidHom : (α →ₘ[μ] γ) →* (ae μ).Germ γ 
goal: MeasureTheory.AEEqFun.toGermMonoidHom f = f.toGerm

full_name: MeasureTheory.AEEqFun.toGermAddMonoidHom
code: /-- `AEEqFun.toGerm` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`AEEqFun.toGerm` as an `AddMonoidHom`."]
def toGermMonoidHom : (α →ₘ[μ] γ) →* (ae μ).Germ γ 
goal: (α →ₘ[μ] γ) →+ (MeasureTheory.ae μ).Germ γ

full_name: MeasureTheory.AEEqFun.toGermMonoidHom
code: /-- `AEEqFun.toGerm` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`AEEqFun.toGerm` as an `AddMonoidHom`."]
def toGermMonoidHom : (α →ₘ[μ] γ) →* (ae μ).Germ γ 
goal: (α →ₘ[μ] γ) →* (MeasureTheory.ae μ).Germ γ

full_name: MeasureTheory.AEEqFun.toGermAddMonoidHom_apply
code: /-- `AEEqFun.toGerm` as a `MonoidHom`. -/
@[to_additive (attr := simps) "`AEEqFun.toGerm` as an `AddMonoidHom`."]
def toGermMonoidHom : (α →ₘ[μ] γ) →* (ae μ).Germ γ 
goal: MeasureTheory.AEEqFun.toGermAddMonoidHom f = f.toGerm

full_name: MeasureTheory.AEEqFun.instCommMonoid
code: @[to_additive existing]
instance instCommMonoid [CommMonoid γ] [ContinuousMul γ] : CommMonoid (α →ₘ[μ] γ) 
goal: CommMonoid (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instNeg
code: @[to_additive]
instance instInv : Inv (α →ₘ[μ] γ) 
goal: Neg (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instInv
code: @[to_additive]
instance instInv : Inv (α →ₘ[μ] γ) 
goal: Inv (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.inv_mk
code: @[to_additive (attr := simp)]
theorem inv_mk (f : α → γ) (hf) : (mk f hf : α →ₘ[μ] γ)⁻¹ = mk f⁻¹ hf.inv 
goal: (MeasureTheory.AEEqFun.mk f hf)⁻¹ = MeasureTheory.AEEqFun.mk f⁻¹ ⋯

full_name: MeasureTheory.AEEqFun.neg_mk
code: @[to_additive (attr := simp)]
theorem inv_mk (f : α → γ) (hf) : (mk f hf : α →ₘ[μ] γ)⁻¹ = mk f⁻¹ hf.inv 
goal: -MeasureTheory.AEEqFun.mk f hf = MeasureTheory.AEEqFun.mk (-f) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_neg
code: @[to_additive]
theorem coeFn_inv (f : α →ₘ[μ] γ) : ⇑f⁻¹ =ᵐ[μ] f⁻¹ 
goal: ↑(-f) =ᵐ[μ] -↑f

full_name: MeasureTheory.AEEqFun.coeFn_inv
code: @[to_additive]
theorem coeFn_inv (f : α →ₘ[μ] γ) : ⇑f⁻¹ =ᵐ[μ] f⁻¹ 
goal: ↑f⁻¹ =ᵐ[μ] (↑f)⁻¹

full_name: MeasureTheory.AEEqFun.inv_toGerm
code: @[to_additive]
theorem inv_toGerm (f : α →ₘ[μ] γ) : f⁻¹.toGerm = f.toGerm⁻¹ 
goal: f⁻¹.toGerm = f.toGerm⁻¹

full_name: MeasureTheory.AEEqFun.neg_toGerm
code: @[to_additive]
theorem inv_toGerm (f : α →ₘ[μ] γ) : f⁻¹.toGerm = f.toGerm⁻¹ 
goal: (-f).toGerm = -f.toGerm

full_name: MeasureTheory.AEEqFun.instDiv
code: @[to_additive]
instance instDiv : Div (α →ₘ[μ] γ) 
goal: Div (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instSub
code: @[to_additive]
instance instDiv : Div (α →ₘ[μ] γ) 
goal: Sub (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.mk_div
code: @[to_additive (attr := simp, nolint simpNF)] -- Porting note: LHS does not simplify.
theorem mk_div (f g : α → γ) (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    mk (f / g) (hf.div hg) = (mk f hf : α →ₘ[μ] γ) / mk g hg 
goal: MeasureTheory.AEEqFun.mk (f / g) ⋯ = MeasureTheory.AEEqFun.mk f hf / MeasureTheory.AEEqFun.mk g hg

full_name: MeasureTheory.AEEqFun.mk_sub
code: @[to_additive (attr := simp, nolint simpNF)] -- Porting note: LHS does not simplify.
theorem mk_div (f g : α → γ) (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    mk (f / g) (hf.div hg) = (mk f hf : α →ₘ[μ] γ) / mk g hg 
goal: MeasureTheory.AEEqFun.mk (f - g) ⋯ = MeasureTheory.AEEqFun.mk f hf - MeasureTheory.AEEqFun.mk g hg

full_name: MeasureTheory.AEEqFun.coeFn_div
code: @[to_additive]
theorem coeFn_div (f g : α →ₘ[μ] γ) : ⇑(f / g) =ᵐ[μ] f / g 
goal: ↑(f / g) =ᵐ[μ] ↑f / ↑g

full_name: MeasureTheory.AEEqFun.coeFn_sub
code: @[to_additive]
theorem coeFn_div (f g : α →ₘ[μ] γ) : ⇑(f / g) =ᵐ[μ] f / g 
goal: ↑(f - g) =ᵐ[μ] ↑f - ↑g

full_name: MeasureTheory.AEEqFun.div_toGerm
code: @[to_additive]
theorem div_toGerm (f g : α →ₘ[μ] γ) : (f / g).toGerm = f.toGerm / g.toGerm 
goal: (f / g).toGerm = f.toGerm / g.toGerm

full_name: MeasureTheory.AEEqFun.sub_toGerm
code: @[to_additive]
theorem div_toGerm (f g : α →ₘ[μ] γ) : (f / g).toGerm = f.toGerm / g.toGerm 
goal: (f - g).toGerm = f.toGerm - g.toGerm

full_name: MeasureTheory.AEEqFun.instPowInt
code: instance instPowInt : Pow (α →ₘ[μ] γ) ℤ 
goal: Pow (α →ₘ[μ] γ) ℤ

full_name: MeasureTheory.AEEqFun.mk_zpow
code: @[simp]
theorem mk_zpow (f : α → γ) (hf) (n : ℤ) :
    (mk f hf : α →ₘ[μ] γ) ^ n = mk (f ^ n) ((continuous_zpow n).comp_aestronglyMeasurable hf) 
goal: MeasureTheory.AEEqFun.mk f hf ^ n = MeasureTheory.AEEqFun.mk (f ^ n) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_zpow
code: theorem coeFn_zpow (f : α →ₘ[μ] γ) (n : ℤ) : ⇑(f ^ n) =ᵐ[μ] (⇑f) ^ n 
goal: ↑(f ^ n) =ᵐ[μ] ↑f ^ n

full_name: MeasureTheory.AEEqFun.zpow_toGerm
code: @[simp]
theorem zpow_toGerm (f : α →ₘ[μ] γ) (n : ℤ) : (f ^ n).toGerm = f.toGerm ^ n 
goal: (f ^ n).toGerm = f.toGerm ^ n

full_name: MeasureTheory.AEEqFun.instAddGroup
code: instance instAddGroup [AddGroup γ] [TopologicalAddGroup γ] : AddGroup (α →ₘ[μ] γ) 
goal: AddGroup (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instAddCommGroup
code: instance instAddCommGroup [AddCommGroup γ] [TopologicalAddGroup γ] : AddCommGroup (α →ₘ[μ] γ) 
goal: AddCommGroup (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instGroup
code: @[to_additive existing]
instance instGroup [Group γ] [TopologicalGroup γ] : Group (α →ₘ[μ] γ) 
goal: Group (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instCommGroup
code: @[to_additive existing]
instance instCommGroup [CommGroup γ] [TopologicalGroup γ] : CommGroup (α →ₘ[μ] γ) 
goal: CommGroup (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instMulAction
code: instance instMulAction [Monoid 𝕜] [MulAction 𝕜 γ] [ContinuousConstSMul 𝕜 γ] :
    MulAction 𝕜 (α →ₘ[μ] γ) 
goal: MulAction 𝕜 (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instDistribMulAction
code: instance instDistribMulAction [Monoid 𝕜] [AddMonoid γ] [ContinuousAdd γ] [DistribMulAction 𝕜 γ]
    [ContinuousConstSMul 𝕜 γ] : DistribMulAction 𝕜 (α →ₘ[μ] γ) 
goal: DistribMulAction 𝕜 (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.instModule
code: instance instModule [Semiring 𝕜] [AddCommMonoid γ] [ContinuousAdd γ] [Module 𝕜 γ]
    [ContinuousConstSMul 𝕜 γ] : Module 𝕜 (α →ₘ[μ] γ) 
goal: Module 𝕜 (α →ₘ[μ] γ)

full_name: MeasureTheory.AEEqFun.lintegral
code: /-- For `f : α → ℝ≥0∞`, define `∫ [f]` to be `∫ f` -/
def lintegral (f : α →ₘ[μ] ℝ≥0∞) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: MeasureTheory.AEEqFun.lintegral_mk
code: @[simp]
theorem lintegral_mk (f : α → ℝ≥0∞) (hf) : (mk f hf : α →ₘ[μ] ℝ≥0∞).lintegral = ∫⁻ a, f a ∂μ 
goal: (MeasureTheory.AEEqFun.mk f hf).lintegral = ∫⁻ (a : α), f a ∂μ

full_name: MeasureTheory.AEEqFun.lintegral_coeFn
code: theorem lintegral_coeFn (f : α →ₘ[μ] ℝ≥0∞) : ∫⁻ a, f a ∂μ = f.lintegral 
goal: ∫⁻ (a : α), ↑f a ∂μ = f.lintegral

full_name: MeasureTheory.AEEqFun.lintegral_zero
code: @[simp]
nonrec theorem lintegral_zero : lintegral (0 : α →ₘ[μ] ℝ≥0∞) = 0 
goal: MeasureTheory.AEEqFun.lintegral 0 = 0

full_name: MeasureTheory.AEEqFun.lintegral_eq_zero_iff
code: @[simp]
theorem lintegral_eq_zero_iff {f : α →ₘ[μ] ℝ≥0∞} : lintegral f = 0 ↔ f = 0 
goal: f.lintegral = 0 ↔ f = 0

full_name: MeasureTheory.AEEqFun.lintegral_add
code: theorem lintegral_add (f g : α →ₘ[μ] ℝ≥0∞) : lintegral (f + g) = lintegral f + lintegral g 
goal: (f + g).lintegral = f.lintegral + g.lintegral

full_name: MeasureTheory.AEEqFun.lintegral_mono
code: theorem lintegral_mono {f g : α →ₘ[μ] ℝ≥0∞} : f ≤ g → lintegral f ≤ lintegral g 
goal: f ≤ g → f.lintegral ≤ g.lintegral

full_name: MeasureTheory.AEEqFun.coeFn_abs
code: theorem coeFn_abs {β} [TopologicalSpace β] [Lattice β] [TopologicalLattice β] [AddGroup β]
    [TopologicalAddGroup β] (f : α →ₘ[μ] β) : ⇑|f| =ᵐ[μ] fun x => |f x| 
goal: ↑|f| =ᵐ[μ] fun x => |↑f x|

full_name: MeasureTheory.AEEqFun.posPart
code: /-- Positive part of an `AEEqFun`. -/
def posPart (f : α →ₘ[μ] γ) : α →ₘ[μ] γ 
goal: α →ₘ[μ] γ

full_name: MeasureTheory.AEEqFun.posPart_mk
code: @[simp]
theorem posPart_mk (f : α → γ) (hf) :
    posPart (mk f hf : α →ₘ[μ] γ) =
      mk (fun x => max (f x) 0)
        ((continuous_id.max continuous_const).comp_aestronglyMeasurable hf) 
goal: (MeasureTheory.AEEqFun.mk f hf).posPart = MeasureTheory.AEEqFun.mk (fun x => max (f x) 0) ⋯

full_name: MeasureTheory.AEEqFun.coeFn_posPart
code: theorem coeFn_posPart (f : α →ₘ[μ] γ) : ⇑(posPart f) =ᵐ[μ] fun a => max (f a) 0 
goal: ↑f.posPart =ᵐ[μ] fun a => max (↑f a) 0

full_name: ContinuousMap.toAEEqFun
code: /-- The equivalence class of `μ`-almost-everywhere measurable functions associated to a continuous
map. -/
def toAEEqFun (f : C(α, β)) : α →ₘ[μ] β 
goal: α →ₘ[μ] β

full_name: ContinuousMap.coeFn_toAEEqFun
code: theorem coeFn_toAEEqFun (f : C(α, β)) : f.toAEEqFun μ =ᵐ[μ] f 
goal: ↑(ContinuousMap.toAEEqFun μ f) =ᵐ[μ] ⇑f

full_name: ContinuousMap.toAEEqFunAddHom
code: /-- The `MulHom` from the group of continuous maps from `α` to `β` to the group of equivalence
classes of `μ`-almost-everywhere measurable functions. -/
@[to_additive "The `AddHom` from the group of continuous maps from `α` to `β` to the group of
equivalence classes of `μ`-almost-everywhere measurable functions."]
def toAEEqFunMulHom : C(α, β) →* α →ₘ[μ] β 
goal: C(α, β) →+ α →ₘ[μ] β

full_name: ContinuousMap.toAEEqFunMulHom
code: /-- The `MulHom` from the group of continuous maps from `α` to `β` to the group of equivalence
classes of `μ`-almost-everywhere measurable functions. -/
@[to_additive "The `AddHom` from the group of continuous maps from `α` to `β` to the group of
equivalence classes of `μ`-almost-everywhere measurable functions."]
def toAEEqFunMulHom : C(α, β) →* α →ₘ[μ] β 
goal: C(α, β) →* α →ₘ[μ] β

full_name: ContinuousMap.toAEEqFunLinearMap
code: /-- The linear map from the group of continuous maps from `α` to `β` to the group of equivalence
classes of `μ`-almost-everywhere measurable functions. -/
def toAEEqFunLinearMap : C(α, γ) →ₗ[𝕜] α →ₘ[μ] γ 
goal: C(α, γ) →ₗ[𝕜] α →ₘ[μ] γ