ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean

full_name: MeasureTheory.AEStronglyMeasurable.comp_measurePreserving
code: theorem MeasureTheory.AEStronglyMeasurable.comp_measurePreserving
    {γ : Type*} {_ : MeasurableSpace γ} {_ : MeasurableSpace α} {f : γ → α} {μ : Measure γ}
    {ν : Measure α} (hg : AEStronglyMeasurable g ν) (hf : MeasurePreserving f μ ν) :
    AEStronglyMeasurable (g ∘ f) μ 
goal: ∀ {x : MeasurableSpace γ} {x_1 : MeasurableSpace α} {f : γ → α} {μ : MeasureTheory.Measure γ}
  {ν : MeasureTheory.Measure α},
  MeasureTheory.AEStronglyMeasurable g ν →
    MeasureTheory.MeasurePreserving f μ ν → MeasureTheory.AEStronglyMeasurable (g ∘ f) μ

full_name: MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff
code: theorem MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff {β : Type*}
    {f : α → β} {mα : MeasurableSpace α} {μa : Measure α} {mβ : MeasurableSpace β} {μb : Measure β}
    (hf : MeasurePreserving f μa μb) (h₂ : MeasurableEmbedding f) {g : β → γ} :
    AEStronglyMeasurable (g ∘ f) μa ↔ AEStronglyMeasurable g μb 
goal: MeasureTheory.AEStronglyMeasurable (g ∘ f) μa ↔ MeasureTheory.AEStronglyMeasurable g μb

full_name: aestronglyMeasurable_smul_const_iff
code: theorem aestronglyMeasurable_smul_const_iff {f : α → 𝕜} {c : E} (hc : c ≠ 0) :
    AEStronglyMeasurable (fun x => f x • c) μ ↔ AEStronglyMeasurable f μ 
goal: MeasureTheory.AEStronglyMeasurable (fun x => f x • c) μ ↔ MeasureTheory.AEStronglyMeasurable f μ

full_name: StronglyMeasurable.apply_continuousLinearMap
code: theorem StronglyMeasurable.apply_continuousLinearMap
    {_m : MeasurableSpace α} {φ : α → F →L[𝕜] E} (hφ : StronglyMeasurable φ) (v : F) :
    StronglyMeasurable fun a => φ a v 
goal: MeasureTheory.StronglyMeasurable fun a => (φ a) v

full_name: MeasureTheory.AEStronglyMeasurable.apply_continuousLinearMap
code: @[measurability]
theorem MeasureTheory.AEStronglyMeasurable.apply_continuousLinearMap {φ : α → F →L[𝕜] E}
    (hφ : AEStronglyMeasurable φ μ) (v : F) :
    AEStronglyMeasurable (fun a => φ a v) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun a => (φ a) v) μ

full_name: ContinuousLinearMap.aestronglyMeasurable_comp₂
code: theorem ContinuousLinearMap.aestronglyMeasurable_comp₂ (L : E →L[𝕜] F →L[𝕜] G) {f : α → E}
    {g : α → F} (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    AEStronglyMeasurable (fun x => L (f x) (g x)) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun x => (L (f x)) (g x)) μ

full_name: aestronglyMeasurable_withDensity_iff
code: theorem aestronglyMeasurable_withDensity_iff {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] {f : α → ℝ≥0} (hf : Measurable f) {g : α → E} :
    AEStronglyMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
      AEStronglyMeasurable (fun x => (f x : ℝ) • g x) μ 
goal: MeasureTheory.AEStronglyMeasurable g (μ.withDensity fun x => ↑(f x)) ↔
  MeasureTheory.AEStronglyMeasurable (fun x => ↑(f x) • g x) μ
File: Mathlib/MeasureTheory/Function/Intersectivity.lean

full_name: bergelson'
code: /-- **Bergelson Intersectivity Lemma**: In a finite measure space, a sequence of events that have
measure at least `r` has an infinite subset whose finite intersections all have positive volume.

TODO: The infinity of `t` should be strengthened to `t` having positive natural density. -/
lemma bergelson' {s : ℕ → Set α} (hs : ∀ n, MeasurableSet (s n)) (hr₀ : r ≠ 0)
    (hr : ∀ n, r ≤ μ (s n)) :
    ∃ t : Set ℕ, t.Infinite ∧ ∀ ⦃u⦄, u ⊆ t → u.Finite → 0 < μ (⋂ n ∈ u, s n) 
goal: ∃ t, t.Infinite ∧ ∀ ⦃u : Set ℕ⦄, u ⊆ t → u.Finite → 0 < μ (⋂ n ∈ u, s n)

full_name: bergelson
code: /-- **Bergelson Intersectivity Lemma**: In a finite measure space, a sequence of events that have
measure at least `r` has an infinite subset whose finite intersections all have positive volume. -/
lemma bergelson [Infinite ι] {s : ι → Set α} (hs : ∀ i, MeasurableSet (s i)) (hr₀ : r ≠ 0)
    (hr : ∀ i, r ≤ μ (s i)) :
    ∃ t : Set ι, t.Infinite ∧ ∀ ⦃u⦄, u ⊆ t → u.Finite → 0 < μ (⋂ i ∈ u, s i) 
goal: ∃ t, t.Infinite ∧ ∀ ⦃u : Set ι⦄, u ⊆ t → u.Finite → 0 < μ (⋂ i ∈ u, s i)
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Indicator.lean

full_name: MeasureTheory.condexp_ae_eq_restrict_zero
code: theorem condexp_ae_eq_restrict_zero (hs : MeasurableSet[m] s) (hf : f =ᵐ[μ.restrict s] 0) :
    μ[f|m] =ᵐ[μ.restrict s] 0 
goal: μ[f|m] =ᵐ[μ.restrict s] 0

full_name: MeasureTheory.condexp_indicator_aux
code: /-- Auxiliary lemma for `condexp_indicator`. -/
theorem condexp_indicator_aux (hs : MeasurableSet[m] s) (hf : f =ᵐ[μ.restrict sᶜ] 0) :
    μ[s.indicator f|m] =ᵐ[μ] s.indicator (μ[f|m]) 
goal: μ[s.indicator f|m] =ᵐ[μ] s.indicator (μ[f|m])

full_name: MeasureTheory.condexp_indicator
code: /-- The conditional expectation of the indicator of a function over an `m`-measurable set with
respect to the σ-algebra `m` is a.e. equal to the indicator of the conditional expectation. -/
theorem condexp_indicator (hf_int : Integrable f μ) (hs : MeasurableSet[m] s) :
    μ[s.indicator f|m] =ᵐ[μ] s.indicator (μ[f|m]) 
goal: μ[s.indicator f|m] =ᵐ[μ] s.indicator (μ[f|m])

full_name: MeasureTheory.condexp_restrict_ae_eq_restrict
code: theorem condexp_restrict_ae_eq_restrict (hm : m ≤ m0) [SigmaFinite (μ.trim hm)]
    (hs_m : MeasurableSet[m] s) (hf_int : Integrable f μ) :
    (μ.restrict s)[f|m] =ᵐ[μ.restrict s] μ[f|m] 
goal: μ.restrict s[f|m] =ᵐ[μ.restrict s] μ[f|m]

full_name: MeasureTheory.condexp_ae_eq_restrict_of_measurableSpace_eq_on
code: /-- If the restriction to an `m`-measurable set `s` of a σ-algebra `m` is equal to the restriction
to `s` of another σ-algebra `m₂` (hypothesis `hs`), then `μ[f | m] =ᵐ[μ.restrict s] μ[f | m₂]`. -/
theorem condexp_ae_eq_restrict_of_measurableSpace_eq_on {m m₂ m0 : MeasurableSpace α}
    {μ : Measure α} (hm : m ≤ m0) (hm₂ : m₂ ≤ m0) [SigmaFinite (μ.trim hm)]
    [SigmaFinite (μ.trim hm₂)] (hs_m : MeasurableSet[m] s)
    (hs : ∀ t, MeasurableSet[m] (s ∩ t) ↔ MeasurableSet[m₂] (s ∩ t)) :
    μ[f|m] =ᵐ[μ.restrict s] μ[f|m₂] 
goal: μ[f|m] =ᵐ[μ.restrict s] μ[f|m₂]
File: Mathlib/MeasureTheory/MeasurableSpace/Instances.lean

full_name: Empty.instMeasurableSpace
code: instance Empty.instMeasurableSpace : MeasurableSpace Empty 
goal: MeasurableSpace Empty

full_name: PUnit.instMeasurableSpace
code: instance PUnit.instMeasurableSpace : MeasurableSpace PUnit 
goal: MeasurableSpace PUnit.{u_1 + 1}

full_name: Bool.instMeasurableSpace
code: instance Bool.instMeasurableSpace : MeasurableSpace Bool 
goal: MeasurableSpace Bool

full_name: Prop.instMeasurableSpace
code: instance Prop.instMeasurableSpace : MeasurableSpace Prop 
goal: MeasurableSpace Prop

full_name: Nat.instMeasurableSpace
code: instance Nat.instMeasurableSpace : MeasurableSpace ℕ 
goal: MeasurableSpace ℕ

full_name: Fin.instMeasurableSpace
code: instance Fin.instMeasurableSpace (n : ℕ) : MeasurableSpace (Fin n) 
goal: MeasurableSpace (Fin n)

full_name: ZMod.instMeasurableSpace
code: instance ZMod.instMeasurableSpace (n : ℕ) : MeasurableSpace (ZMod n) 
goal: MeasurableSpace (ZMod n)

full_name: Int.instMeasurableSpace
code: instance Int.instMeasurableSpace : MeasurableSpace ℤ 
goal: MeasurableSpace ℤ

full_name: Rat.instMeasurableSpace
code: instance Rat.instMeasurableSpace : MeasurableSpace ℚ 
goal: MeasurableSpace ℚ

full_name: Subsingleton.measurableSingletonClass
code: instance Subsingleton.measurableSingletonClass {α} [MeasurableSpace α] [Subsingleton α] :
    MeasurableSingletonClass α 
goal: MeasurableSingletonClass α

full_name: Bool.instMeasurableSingletonClass
code: instance Bool.instMeasurableSingletonClass : MeasurableSingletonClass Bool 
goal: MeasurableSingletonClass Bool

full_name: Prop.instMeasurableSingletonClass
code: instance Prop.instMeasurableSingletonClass : MeasurableSingletonClass Prop 
goal: MeasurableSingletonClass Prop

full_name: Nat.instMeasurableSingletonClass
code: instance Nat.instMeasurableSingletonClass : MeasurableSingletonClass ℕ 
goal: MeasurableSingletonClass ℕ

full_name: Fin.instMeasurableSingletonClass
code: instance Fin.instMeasurableSingletonClass (n : ℕ) : MeasurableSingletonClass (Fin n) 
goal: MeasurableSingletonClass (Fin n)

full_name: ZMod.instMeasurableSingletonClass
code: instance ZMod.instMeasurableSingletonClass (n : ℕ) : MeasurableSingletonClass (ZMod n) 
goal: MeasurableSingletonClass (ZMod n)

full_name: Int.instMeasurableSingletonClass
code: instance Int.instMeasurableSingletonClass : MeasurableSingletonClass ℤ 
goal: MeasurableSingletonClass ℤ

full_name: Rat.instMeasurableSingletonClass
code: instance Rat.instMeasurableSingletonClass : MeasurableSingletonClass ℚ 
goal: MeasurableSingletonClass ℚ
File: Mathlib/MeasureTheory/MeasurableSpace/Invariants.lean

full_name: MeasurableSpace.invariants
code: /-- Given a self-map `f : α → α`,
`invariants f` is the σ-algebra of measurable sets that are invariant under `f`.

A set `s` is `(invariants f)`-measurable
iff it is meaurable w.r.t. the canonical σ-algebra on `α` and `f ⁻¹' s = s`. -/
def invariants [m : MeasurableSpace α] (f : α → α) : MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.measurableSet_invariants
code: /-- A set `s` is `(invariants f)`-measurable
iff it is meaurable w.r.t. the canonical σ-algebra on `α` and `f ⁻¹' s = s`. -/
theorem measurableSet_invariants {f : α → α} {s : Set α} :
    MeasurableSet[invariants f] s ↔ MeasurableSet s ∧ f ⁻¹' s = s 
goal: MeasurableSet s ↔ MeasurableSet s ∧ f ⁻¹' s = s

full_name: MeasurableSpace.invariants_id
code: @[simp]
theorem invariants_id : invariants (id : α → α) = ‹MeasurableSpace α› 
goal: MeasurableSpace.invariants id = inst✝

full_name: MeasurableSpace.invariants_le
code: theorem invariants_le (f : α → α) : invariants f ≤ ‹MeasurableSpace α› 
goal: MeasurableSpace.invariants f ≤ inst✝

full_name: MeasurableSpace.inf_le_invariants_comp
code: theorem inf_le_invariants_comp (f g : α → α) :
    invariants f ⊓ invariants g ≤ invariants (f ∘ g) 
goal: MeasurableSpace.invariants f ⊓ MeasurableSpace.invariants g ≤ MeasurableSpace.invariants (f ∘ g)

full_name: MeasurableSpace.le_invariants_iterate
code: theorem le_invariants_iterate (f : α → α) (n : ℕ) :
    invariants f ≤ invariants (f^[n]) 
goal: MeasurableSpace.invariants f ≤ MeasurableSpace.invariants f^[n]

full_name: MeasurableSpace.measurable_invariants_dom
code: theorem measurable_invariants_dom {f : α → α} {g : α → β} :
    Measurable[invariants f] g ↔ Measurable g ∧ ∀ s, MeasurableSet s → (g ∘ f) ⁻¹' s = g ⁻¹' s 
goal: Measurable g ↔ Measurable g ∧ ∀ (s : Set β), MeasurableSet s → g ∘ f ⁻¹' s = g ⁻¹' s

full_name: MeasurableSpace.measurable_invariants_of_semiconj
code: theorem measurable_invariants_of_semiconj {fa : α → α} {fb : β → β} {g : α → β} (hg : Measurable g)
    (hfg : Semiconj g fa fb) : @Measurable _ _ (invariants fa) (invariants fb) g 
goal: Measurable g
File: Mathlib/MeasureTheory/Measure/Lebesgue/Complex.lean

full_name: Complex.measurableEquivPi
code: /-- Measurable equivalence between `ℂ` and `ℝ² = Fin 2 → ℝ`. -/
def measurableEquivPi : ℂ ≃ᵐ (Fin 2 → ℝ) 
goal: ℂ ≃ᵐ (Fin 2 → ℝ)

full_name: Complex.measurableEquivPi_apply
code: @[simp]
theorem measurableEquivPi_apply (a : ℂ) :
    measurableEquivPi a = ![a.re, a.im] 
goal: Complex.measurableEquivPi a = ![a.re, a.im]

full_name: Complex.measurableEquivPi_symm_apply
code: @[simp]
theorem measurableEquivPi_symm_apply (p : (Fin 2) → ℝ) :
    measurableEquivPi.symm p = (p 0) + (p 1) * I 
goal: Complex.measurableEquivPi.symm p = ↑(p 0) + ↑(p 1) * Complex.I

full_name: Complex.measurableEquivRealProd
code: /-- Measurable equivalence between `ℂ` and `ℝ × ℝ`. -/
def measurableEquivRealProd : ℂ ≃ᵐ ℝ × ℝ 
goal: ℂ ≃ᵐ ℝ × ℝ

full_name: Complex.measurableEquivRealProd_apply
code: @[simp]
theorem measurableEquivRealProd_apply (a : ℂ) : measurableEquivRealProd a = (a.re, a.im) 
goal: Complex.measurableEquivRealProd a = (a.re, a.im)

full_name: Complex.measurableEquivRealProd_symm_apply
code: @[simp]
theorem measurableEquivRealProd_symm_apply (p : ℝ × ℝ) :
    measurableEquivRealProd.symm p = {re := p.1, im := p.2} 
goal: Complex.measurableEquivRealProd.symm p = { re := p.1, im := p.2 }

full_name: Complex.volume_preserving_equiv_pi
code: theorem volume_preserving_equiv_pi : MeasurePreserving measurableEquivPi 
goal: MeasureTheory.MeasurePreserving (⇑Complex.measurableEquivPi) MeasureTheory.volume MeasureTheory.volume

full_name: Complex.volume_preserving_equiv_real_prod
code: theorem volume_preserving_equiv_real_prod : MeasurePreserving measurableEquivRealProd 
goal: MeasureTheory.MeasurePreserving (⇑Complex.measurableEquivRealProd) MeasureTheory.volume MeasureTheory.volume
File: Mathlib/MeasureTheory/Measure/Haar/Disintegration.lean

full_name: LinearMap.exists_map_addHaar_eq_smul_addHaar'
code: /-- The image of an additive Haar measure under a surjective linear map is proportional to a given
additive Haar measure. The proportionality factor will be infinite if the linear map has a
nontrivial kernel. -/
theorem LinearMap.exists_map_addHaar_eq_smul_addHaar' (h : Function.Surjective L) :
    ∃ (c : ℝ≥0∞), 0 < c ∧ c < ∞ ∧ μ.map L = (c * addHaar (univ : Set (LinearMap.ker L))) • ν 
goal: ∃ c, 0 < c ∧ c < ⊤ ∧ MeasureTheory.Measure.map (⇑L) μ = (c * MeasureTheory.Measure.addHaar Set.univ) • ν

full_name: LinearMap.exists_map_addHaar_eq_smul_addHaar
code: /-- The image of an additive Haar measure under a surjective linear map is proportional to a given
additive Haar measure, with a positive (but maybe infinite) factor. -/
theorem LinearMap.exists_map_addHaar_eq_smul_addHaar (h : Function.Surjective L) :
    ∃ (c : ℝ≥0∞), 0 < c ∧ μ.map L = c • ν 
goal: ∃ c, 0 < c ∧ MeasureTheory.Measure.map (⇑L) μ = c • ν

full_name: MeasureTheory.ae_comp_linearMap_mem_iff
code: /-- Given a surjective linear map `L`, it is equivalent to require a property almost everywhere
in the source or the target spaces of `L`, with respect to additive Haar measures there. -/
lemma ae_comp_linearMap_mem_iff (h : Function.Surjective L) {s : Set F} (hs : MeasurableSet s) :
    (∀ᵐ x ∂μ, L x ∈ s) ↔ ∀ᵐ y ∂ν, y ∈ s 
goal: (∀ᵐ (x : E) ∂μ, L x ∈ s) ↔ ∀ᵐ (y : F) ∂ν, y ∈ s

full_name: MeasureTheory.ae_ae_add_linearMap_mem_iff
code: /-- Given a linear map `L : E → F`, a property holds almost everywhere in `F` if and only if,
almost everywhere in `F`, it holds almost everywhere along the subspace spanned by the
image of `L`. This is an instance of a disintegration argument for additive Haar measures. -/
lemma ae_ae_add_linearMap_mem_iff [LocallyCompactSpace F] {s : Set F} (hs : MeasurableSet s) :
    (∀ᵐ y ∂ν, ∀ᵐ x ∂μ, y + L x ∈ s) ↔ ∀ᵐ y ∂ν, y ∈ s 
goal: (∀ᵐ (y : F) ∂ν, ∀ᵐ (x : E) ∂μ, y + L x ∈ s) ↔ ∀ᵐ (y : F) ∂ν, y ∈ s

full_name: MeasureTheory.ae_mem_of_ae_add_linearMap_mem
code: /-- To check that a property holds almost everywhere with respect to an additive Haar measure, it
suffices to check it almost everywhere along all translates of a given vector subspace. This is an
instance of a disintegration argument for additive Haar measures. -/
lemma ae_mem_of_ae_add_linearMap_mem [LocallyCompactSpace F] {s : Set F} (hs : MeasurableSet s)
    (h : ∀ y, ∀ᵐ x ∂μ, y + L x ∈ s) : ∀ᵐ y ∂ν, y ∈ s 
goal: ∀ᵐ (y : F) ∂ν, y ∈ s
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

full_name: volume_regionBetween_eq_integral'
code: theorem volume_regionBetween_eq_integral' [SigmaFinite μ] (f_int : IntegrableOn f s μ)
    (g_int : IntegrableOn g s μ) (hs : MeasurableSet s) (hfg : f ≤ᵐ[μ.restrict s] g) :
    μ.prod volume (regionBetween f g s) = ENNReal.ofReal (∫ y in s, (g - f) y ∂μ) 
goal: (μ.prod MeasureTheory.volume) (regionBetween f g s) = ENNReal.ofReal (∫ (y : α) in s, (g - f) y ∂μ)

full_name: volume_regionBetween_eq_integral
code: /-- If two functions are integrable on a measurable set, and one function is less than
    or equal to the other on that set, then the volume of the region
    between the two functions can be represented as an integral. -/
theorem volume_regionBetween_eq_integral [SigmaFinite μ] (f_int : IntegrableOn f s μ)
    (g_int : IntegrableOn g s μ) (hs : MeasurableSet s) (hfg : ∀ x ∈ s, f x ≤ g x) :
    μ.prod volume (regionBetween f g s) = ENNReal.ofReal (∫ y in s, (g - f) y ∂μ) 
goal: (μ.prod MeasureTheory.volume) (regionBetween f g s) = ENNReal.ofReal (∫ (y : α) in s, (g - f) y ∂μ)

full_name: Real.integrable_of_summable_norm_Icc
code: /-- If the sequence with `n`-th term the sup norm of `fun x ↦ f (x + n)` on the interval `Icc 0 1`,
for `n ∈ ℤ`, is summable, then `f` is integrable on `ℝ`. -/
theorem Real.integrable_of_summable_norm_Icc {E : Type*} [NormedAddCommGroup E] {f : C(ℝ, E)}
    (hf : Summable fun n : ℤ => ‖(f.comp <| ContinuousMap.addRight n).restrict (Icc 0 1)‖) :
    Integrable f 
goal: MeasureTheory.Integrable (⇑f) MeasureTheory.volume

full_name: integral_comp_neg_Iic
code: theorem integral_comp_neg_Iic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (c : ℝ) (f : ℝ → E) : (∫ x in Iic c, f (-x)) = ∫ x in Ioi (-c), f x 
goal: ∫ (x : ℝ) in Set.Iic c, f (-x) = ∫ (x : ℝ) in Set.Ioi (-c), f x

full_name: integral_comp_neg_Ioi
code: theorem integral_comp_neg_Ioi {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (c : ℝ) (f : ℝ → E) : (∫ x in Ioi c, f (-x)) = ∫ x in Iic (-c), f x 
goal: ∫ (x : ℝ) in Set.Ioi c, f (-x) = ∫ (x : ℝ) in Set.Iic (-c), f x

full_name: integral_comp_abs
code: theorem integral_comp_abs {f : ℝ → ℝ} :
    ∫ x, f |x| = 2 * ∫ x in Ioi (0 : ℝ), f x 
goal: ∫ (x : ℝ), f |x| = 2 * ∫ (x : ℝ) in Set.Ioi 0, f x
File: Mathlib/MeasureTheory/Measure/Sub.lean

full_name: MeasureTheory.Measure.instSub
code: /-- The measure `μ - ν` is defined to be the least measure `τ` such that `μ ≤ τ + ν`.
It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
Compare with `ENNReal.instSub`.
Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`, and
`ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
`ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
noncomputable instance instSub {α : Type*} [MeasurableSpace α] : Sub (Measure α) 
goal: Sub (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.sub_def
code: theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } 
goal: μ - ν = sInf {d | μ ≤ d + ν}

full_name: MeasureTheory.Measure.sub_le_of_le_add
code: theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d 
goal: μ - ν ≤ d

full_name: MeasureTheory.Measure.sub_eq_zero_of_le
code: theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 
goal: μ - ν = 0

full_name: MeasureTheory.Measure.sub_le
code: theorem sub_le : μ - ν ≤ μ 
goal: μ - ν ≤ μ

full_name: MeasureTheory.Measure.sub_top
code: @[simp]
theorem sub_top : μ - ⊤ = 0 
goal: μ - ⊤ = 0

full_name: MeasureTheory.Measure.zero_sub
code: @[simp]
theorem zero_sub : 0 - μ = 0 
goal: 0 - μ = 0

full_name: MeasureTheory.Measure.sub_self
code: @[simp]
theorem sub_self : μ - μ = 0 
goal: μ - μ = 0

full_name: MeasureTheory.Measure.sub_apply
code: /-- This application lemma only works in special circumstances. Given knowledge of
when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) :
    (μ - ν) s = μ s - ν s 
goal: (μ - ν) s = μ s - ν s

full_name: MeasureTheory.Measure.sub_add_cancel_of_le
code: theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ 
goal: μ - ν + ν = μ

full_name: MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict
code: theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
    (μ - ν).restrict s = μ.restrict s - ν.restrict s 
goal: (μ - ν).restrict s = μ.restrict s - ν.restrict s

full_name: MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
code: theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
    (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 
goal: (μ - ν) s = 0

full_name: MeasureTheory.Measure.isFiniteMeasure_sub
code: instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) 
goal: MeasureTheory.IsFiniteMeasure (μ - ν)
File: Mathlib/MeasureTheory/Group/AddCircle.lean

full_name: AddCircle.closedBall_ae_eq_ball
code: theorem closedBall_ae_eq_ball {x : AddCircle T} {ε : ℝ} : closedBall x ε =ᵐ[volume] ball x ε 
goal: Metric.closedBall x ε =ᵐ[MeasureTheory.volume] Metric.ball x ε

full_name: AddCircle.isAddFundamentalDomain_of_ae_ball
code: /-- Let `G` be the subgroup of `AddCircle T` generated by a point `u` of finite order `n : ℕ`. Then
any set `I` that is almost equal to a ball of radius `T / 2n` is a fundamental domain for the action
of `G` on `AddCircle T` by left addition. -/
theorem isAddFundamentalDomain_of_ae_ball (I : Set <| AddCircle T) (u x : AddCircle T)
    (hu : IsOfFinAddOrder u) (hI : I =ᵐ[volume] ball x (T / (2 * addOrderOf u))) :
    IsAddFundamentalDomain (AddSubgroup.zmultiples u) I 
goal: MeasureTheory.IsAddFundamentalDomain (↥(AddSubgroup.zmultiples u)) I MeasureTheory.volume

full_name: AddCircle.volume_of_add_preimage_eq
code: theorem volume_of_add_preimage_eq (s I : Set <| AddCircle T) (u x : AddCircle T)
    (hu : IsOfFinAddOrder u) (hs : (u +ᵥ s : Set <| AddCircle T) =ᵐ[volume] s)
    (hI : I =ᵐ[volume] ball x (T / (2 * addOrderOf u))) :
    volume s = addOrderOf u • volume (s ∩ I) 
goal: MeasureTheory.volume s = addOrderOf u • MeasureTheory.volume (s ∩ I)
File: Mathlib/MeasureTheory/Group/Pointwise.lean

full_name: MeasurableSet.const_smul
code: @[to_additive]
theorem MeasurableSet.const_smul {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace G]
    [MeasurableSpace α] [MeasurableSMul G α] {s : Set α} (hs : MeasurableSet s) (a : G) :
    MeasurableSet (a • s) 
goal: MeasurableSet (a • s)

full_name: MeasurableSet.const_vadd
code: @[to_additive]
theorem MeasurableSet.const_smul {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace G]
    [MeasurableSpace α] [MeasurableSMul G α] {s : Set α} (hs : MeasurableSet s) (a : G) :
    MeasurableSet (a • s) 
goal: MeasurableSet (a +ᵥ s)

full_name: MeasurableSet.const_smul_of_ne_zero
code: theorem MeasurableSet.const_smul_of_ne_zero {G₀ α : Type*} [GroupWithZero G₀] [MulAction G₀ α]
    [MeasurableSpace G₀] [MeasurableSpace α] [MeasurableSMul G₀ α] {s : Set α}
    (hs : MeasurableSet s) {a : G₀} (ha : a ≠ 0) : MeasurableSet (a • s) 
goal: MeasurableSet (a • s)

full_name: MeasurableSet.const_smul₀
code: theorem MeasurableSet.const_smul₀ {G₀ α : Type*} [GroupWithZero G₀] [Zero α]
    [MulActionWithZero G₀ α] [MeasurableSpace G₀] [MeasurableSpace α] [MeasurableSMul G₀ α]
    [MeasurableSingletonClass α] {s : Set α} (hs : MeasurableSet s) (a : G₀) :
    MeasurableSet (a • s) 
goal: MeasurableSet (a • s)