ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MeasureTheory.Measure.sub_le_of_le_add
theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν d : MeasureTheory.Measure α} (h : μ ≤ d + ν)
Goal: μ - ν ≤ d
-- MeasureTheory.Measure.sub_eq_zero_of_le
theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ≤ ν)
Goal: μ - ν = 0
-- MeasureTheory.Measure.sub_le
theorem sub_le : μ - ν ≤ μ 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
Goal: μ - ν ≤ μ
-- MeasureTheory.Measure.sub_top
@[simp]
theorem sub_top : μ - ⊤ = 0 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
Goal: μ - ⊤ = 0
-- MeasureTheory.Measure.zero_sub
@[simp]
theorem zero_sub : 0 - μ = 0 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
Goal: 0 - μ = 0
-- MeasureTheory.Measure.sub_self
@[simp]
theorem sub_self : μ - μ = 0 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
Goal: μ - μ = 0
-- MeasureTheory.Measure.sub_apply
theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) :
    (μ - ν) s = μ s - ν s 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α} [MeasureTheory.IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
Goal: (μ - ν) s = μ s - ν s
-- MeasureTheory.Measure.sub_add_cancel_of_le
theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure ν] (h₁ : ν ≤ μ)
Goal: μ - ν + ν = μ
-- MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict
theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
    (μ - ν).restrict s = μ.restrict s - ν.restrict s 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α} (h_meas_s : MeasurableSet s)
Goal: (μ - ν).restrict s = μ.restrict s - ν.restrict s
-- MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
    (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 
Arguments: {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α} (h_le : μ.restrict s ≤ ν.restrict s) (h_meas_s : MeasurableSet s)
Goal: (μ - ν) s = 0
-- MeasureTheory.Measure.MutuallySingular.mk
theorem mk {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : univ ⊆ s ∪ t) :
    MutuallySingular μ ν 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s t : Set α} (hs : μ s = 0) (ht : ν t = 0) (hst : Set.univ ⊆ s ∪ t)
Goal: μ ⟂ₘ ν
-- MeasureTheory.Measure.MutuallySingular.measurableSet_nullSet
lemma measurableSet_nullSet (h : μ ⟂ₘ ν) : MeasurableSet h.nullSet 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν)
Goal: MeasurableSet h.nullSet
-- MeasureTheory.Measure.MutuallySingular.measure_nullSet
@[simp]
lemma measure_nullSet (h : μ ⟂ₘ ν) : μ h.nullSet = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν)
Goal: μ h.nullSet = 0
-- MeasureTheory.Measure.MutuallySingular.measure_compl_nullSet
@[simp]
lemma measure_compl_nullSet (h : μ ⟂ₘ ν) : ν h.nullSetᶜ = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν)
Goal: ν h.nullSetᶜ = 0
-- MeasureTheory.Measure.MutuallySingular.restrict_nullSet
@[simp]
lemma restrict_nullSet (h : μ ⟂ₘ ν) : μ.restrict h.nullSet = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν)
Goal: μ.restrict h.nullSet = 0
-- MeasureTheory.Measure.MutuallySingular.restrict_compl_nullSet
@[simp]
lemma restrict_compl_nullSet (h : μ ⟂ₘ ν) : ν.restrict h.nullSetᶜ = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν)
Goal: ν.restrict h.nullSetᶜ = 0
-- MeasureTheory.Measure.MutuallySingular.zero_right
@[simp]
theorem zero_right : μ ⟂ₘ 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
Goal: μ ⟂ₘ 0
-- MeasureTheory.Measure.MutuallySingular.symm
@[symm]
theorem symm (h : ν ⟂ₘ μ) : μ ⟂ₘ ν 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : ν ⟂ₘ μ)
Goal: μ ⟂ₘ ν
-- MeasureTheory.Measure.MutuallySingular.comm
theorem comm : μ ⟂ₘ ν ↔ ν ⟂ₘ μ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}
Goal: μ ⟂ₘ ν ↔ ν ⟂ₘ μ
-- MeasureTheory.Measure.MutuallySingular.zero_left
@[simp]
theorem zero_left : 0 ⟂ₘ μ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
Goal: 0 ⟂ₘ μ
-- MeasureTheory.Measure.MutuallySingular.mono_ac
theorem mono_ac (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ ≪ ν₁) : μ₂ ⟂ₘ ν₂ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ ν₁ ν₂ : MeasureTheory.Measure α} (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≪ μ₁) (hν : ν₂ ≪ ν₁)
Goal: μ₂ ⟂ₘ ν₂
-- MeasureTheory.Measure.MutuallySingular.mono
theorem mono (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁) : μ₂ ⟂ₘ ν₂ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ ν₁ ν₂ : MeasureTheory.Measure α} (h : μ₁ ⟂ₘ ν₁) (hμ : μ₂ ≤ μ₁) (hν : ν₂ ≤ ν₁)
Goal: μ₂ ⟂ₘ ν₂
-- MeasureTheory.Measure.MutuallySingular.self_iff
@[simp]
lemma self_iff (μ : Measure α) : μ ⟂ₘ μ ↔ μ = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α)
Goal: μ ⟂ₘ μ ↔ μ = 0
-- MeasureTheory.Measure.MutuallySingular.sum_left
@[simp]
theorem sum_left {ι : Type*} [Countable ι] {μ : ι → Measure α} : sum μ ⟂ₘ ν ↔ ∀ i, μ i ⟂ₘ ν 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {ν : MeasureTheory.Measure α} {ι : Type u_2} [Countable ι] {μ : ι → MeasureTheory.Measure α}
Goal: MeasureTheory.Measure.sum μ ⟂ₘ ν ↔ ∀ (i : ι), μ i ⟂ₘ ν
-- MeasureTheory.Measure.MutuallySingular.sum_right
@[simp]
theorem sum_right {ι : Type*} [Countable ι] {ν : ι → Measure α} : μ ⟂ₘ sum ν ↔ ∀ i, μ ⟂ₘ ν i 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_2} [Countable ι] {ν : ι → MeasureTheory.Measure α}
Goal: μ ⟂ₘ MeasureTheory.Measure.sum ν ↔ ∀ (i : ι), μ ⟂ₘ ν i
-- MeasureTheory.Measure.MutuallySingular.add_left_iff
@[simp]
theorem add_left_iff : μ₁ + μ₂ ⟂ₘ ν ↔ μ₁ ⟂ₘ ν ∧ μ₂ ⟂ₘ ν 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ₁ μ₂ ν : MeasureTheory.Measure α}
Goal: μ₁ + μ₂ ⟂ₘ ν ↔ μ₁ ⟂ₘ ν ∧ μ₂ ⟂ₘ ν
-- MeasureTheory.Measure.MutuallySingular.add_right_iff
@[simp]
theorem add_right_iff : μ ⟂ₘ ν₁ + ν₂ ↔ μ ⟂ₘ ν₁ ∧ μ ⟂ₘ ν₂ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν₁ ν₂ : MeasureTheory.Measure α}
Goal: μ ⟂ₘ ν₁ + ν₂ ↔ μ ⟂ₘ ν₁ ∧ μ ⟂ₘ ν₂
-- MeasureTheory.Measure.MutuallySingular.add_left
theorem add_left (h₁ : ν₁ ⟂ₘ μ) (h₂ : ν₂ ⟂ₘ μ) : ν₁ + ν₂ ⟂ₘ μ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν₁ ν₂ : MeasureTheory.Measure α} (h₁ : ν₁ ⟂ₘ μ) (h₂ : ν₂ ⟂ₘ μ)
Goal: ν₁ + ν₂ ⟂ₘ μ
-- MeasureTheory.Measure.MutuallySingular.add_right
theorem add_right (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂) : μ ⟂ₘ ν₁ + ν₂ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν₁ ν₂ : MeasureTheory.Measure α} (h₁ : μ ⟂ₘ ν₁) (h₂ : μ ⟂ₘ ν₂)
Goal: μ ⟂ₘ ν₁ + ν₂
-- MeasureTheory.Measure.MutuallySingular.smul
theorem smul (r : ℝ≥0∞) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (r : ℝ≥0∞) (h : ν ⟂ₘ μ)
Goal: r • ν ⟂ₘ μ
-- MeasureTheory.Measure.MutuallySingular.smul_nnreal
theorem smul_nnreal (r : ℝ≥0) (h : ν ⟂ₘ μ) : r • ν ⟂ₘ μ 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (r : ℝ≥0) (h : ν ⟂ₘ μ)
Goal: r • ν ⟂ₘ μ
-- MeasureTheory.Measure.MutuallySingular.restrict
lemma restrict (h : μ ⟂ₘ ν) (s : Set α) : μ.restrict s ⟂ₘ ν 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ ⟂ₘ ν) (s : Set α)
Goal: μ.restrict s ⟂ₘ ν
-- MeasureTheory.Measure.eq_zero_of_absolutelyContinuous_of_mutuallySingular
lemma eq_zero_of_absolutelyContinuous_of_mutuallySingular {μ ν : Measure α}
    (h_ac : μ ≪ ν) (h_ms : μ ⟂ₘ ν) :
    μ = 0 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h_ac : μ ≪ ν) (h_ms : μ ⟂ₘ ν)
Goal: μ = 0
-- MeasurableEmbedding.mutuallySingular_map
lemma _root_.MeasurableEmbedding.mutuallySingular_map {β : Type*} {_ : MeasurableSpace β}
    {f : α → β} (hf : MeasurableEmbedding f) (hμν : μ ⟂ₘ ν) :
    μ.map f ⟂ₘ ν.map f 
Arguments: {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {β : Type u_2}
Goal: ∀ {x : MeasurableSpace β} {f : α → β},
  MeasurableEmbedding f → μ ⟂ₘ ν → MeasureTheory.Measure.map f μ ⟂ₘ MeasureTheory.Measure.map f ν
-- MeasureTheory.Measure.le_count_apply
theorem le_count_apply : ∑' _ : s, (1 : ℝ≥0∞) ≤ count s 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α}
Goal: ∑' (x : ↑s), 1 ≤ MeasureTheory.Measure.count s
-- MeasureTheory.Measure.count_apply
theorem count_apply (hs : MeasurableSet s) : count s = ∑' i : s, 1 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (hs : MeasurableSet s)
Goal: MeasureTheory.Measure.count s = ∑' (i : ↑s), 1
-- MeasureTheory.Measure.count_empty
theorem count_empty : count (∅ : Set α) = 0 
Arguments: {α : Type u_1} [MeasurableSpace α]
Goal: MeasureTheory.Measure.count ∅ = 0
-- MeasureTheory.Measure.count_apply_finset'
@[simp]
theorem count_apply_finset' {s : Finset α} (s_mble : MeasurableSet (s : Set α)) :
    count (↑s : Set α) = s.card 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Finset α} (s_mble : MeasurableSet ↑s)
Goal: MeasureTheory.Measure.count ↑s = ↑s.card
-- MeasureTheory.Measure.count_apply_finset
@[simp]
theorem count_apply_finset [MeasurableSingletonClass α] (s : Finset α) :
    count (↑s : Set α) = s.card 
Arguments: {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α] (s : Finset α)
Goal: MeasureTheory.Measure.count ↑s = ↑s.card
-- MeasureTheory.Measure.count_apply_finite'
theorem count_apply_finite' {s : Set α} (s_fin : s.Finite) (s_mble : MeasurableSet s) :
    count s = s_fin.toFinset.card 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (s_fin : s.Finite) (s_mble : MeasurableSet s)
Goal: MeasureTheory.Measure.count s = ↑s_fin.toFinset.card
-- MeasureTheory.Measure.count_apply_finite
theorem count_apply_finite [MeasurableSingletonClass α] (s : Set α) (hs : s.Finite) :
    count s = hs.toFinset.card 
Arguments: {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α] (s : Set α) (hs : s.Finite)
Goal: MeasureTheory.Measure.count s = ↑hs.toFinset.card
-- MeasureTheory.Measure.count_apply_infinite
theorem count_apply_infinite (hs : s.Infinite) : count s = ∞ 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (hs : s.Infinite)
Goal: MeasureTheory.Measure.count s = ⊤
-- MeasureTheory.Measure.count_apply_eq_top'
@[simp]
theorem count_apply_eq_top' (s_mble : MeasurableSet s) : count s = ∞ ↔ s.Infinite 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (s_mble : MeasurableSet s)
Goal: MeasureTheory.Measure.count s = ⊤ ↔ s.Infinite
-- MeasureTheory.Measure.count_apply_eq_top
@[simp]
theorem count_apply_eq_top [MeasurableSingletonClass α] : count s = ∞ ↔ s.Infinite 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} [MeasurableSingletonClass α]
Goal: MeasureTheory.Measure.count s = ⊤ ↔ s.Infinite
-- MeasureTheory.Measure.count_apply_lt_top'
@[simp]
theorem count_apply_lt_top' (s_mble : MeasurableSet s) : count s < ∞ ↔ s.Finite 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (s_mble : MeasurableSet s)
Goal: MeasureTheory.Measure.count s < ⊤ ↔ s.Finite
-- MeasureTheory.Measure.count_apply_lt_top
@[simp]
theorem count_apply_lt_top [MeasurableSingletonClass α] : count s < ∞ ↔ s.Finite 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} [MeasurableSingletonClass α]
Goal: MeasureTheory.Measure.count s < ⊤ ↔ s.Finite
-- MeasureTheory.Measure.empty_of_count_eq_zero'
theorem empty_of_count_eq_zero' (s_mble : MeasurableSet s) (hsc : count s = 0) : s = ∅ 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (s_mble : MeasurableSet s) (hsc : MeasureTheory.Measure.count s = 0)
Goal: s = ∅
-- MeasureTheory.Measure.empty_of_count_eq_zero
theorem empty_of_count_eq_zero [MeasurableSingletonClass α] (hsc : count s = 0) : s = ∅ 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} [MeasurableSingletonClass α] (hsc : MeasureTheory.Measure.count s = 0)
Goal: s = ∅
-- MeasureTheory.Measure.count_eq_zero_iff'
@[simp]
theorem count_eq_zero_iff' (s_mble : MeasurableSet s) : count s = 0 ↔ s = ∅ 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (s_mble : MeasurableSet s)
Goal: MeasureTheory.Measure.count s = 0 ↔ s = ∅
-- MeasureTheory.Measure.count_eq_zero_iff
@[simp]
theorem count_eq_zero_iff [MeasurableSingletonClass α] : count s = 0 ↔ s = ∅ 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} [MeasurableSingletonClass α]
Goal: MeasureTheory.Measure.count s = 0 ↔ s = ∅
-- MeasureTheory.Measure.count_ne_zero'
theorem count_ne_zero' (hs' : s.Nonempty) (s_mble : MeasurableSet s) : count s ≠ 0 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} (hs' : s.Nonempty) (s_mble : MeasurableSet s)
Goal: MeasureTheory.Measure.count s ≠ 0
-- MeasureTheory.Measure.count_ne_zero
theorem count_ne_zero [MeasurableSingletonClass α] (hs' : s.Nonempty) : count s ≠ 0 
Arguments: {α : Type u_1} [MeasurableSpace α] {s : Set α} [MeasurableSingletonClass α] (hs' : s.Nonempty)
Goal: MeasureTheory.Measure.count s ≠ 0
-- MeasureTheory.Measure.count_singleton'
@[simp]
theorem count_singleton' {a : α} (ha : MeasurableSet ({a} : Set α)) : count ({a} : Set α) = 1 
Arguments: {α : Type u_1} [MeasurableSpace α] {a : α} (ha : MeasurableSet {a})
Goal: MeasureTheory.Measure.count {a} = 1
-- MeasureTheory.Measure.count_singleton
theorem count_singleton [MeasurableSingletonClass α] (a : α) : count ({a} : Set α) = 1 
Arguments: {α : Type u_1} [MeasurableSpace α] [MeasurableSingletonClass α] (a : α)
Goal: MeasureTheory.Measure.count {a} = 1
-- MeasureTheory.Measure.count_injective_image'
theorem count_injective_image' {f : β → α} (hf : Function.Injective f) {s : Set β}
    (s_mble : MeasurableSet s) (fs_mble : MeasurableSet (f '' s)) : count (f '' s) = count s 
Arguments: {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {f : β → α} (hf : Function.Injective f) {s : Set β} (s_mble : MeasurableSet s) (fs_mble : MeasurableSet (f '' s))
Goal: MeasureTheory.Measure.count (f '' s) = MeasureTheory.Measure.count s
-- MeasureTheory.Measure.count_injective_image
theorem count_injective_image [MeasurableSingletonClass α] [MeasurableSingletonClass β] {f : β → α}
    (hf : Function.Injective f) (s : Set β) : count (f '' s) = count s 
Arguments: {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSingletonClass α] [MeasurableSingletonClass β] {f : β → α} (hf : Function.Injective f) (s : Set β)
Goal: MeasureTheory.Measure.count (f '' s) = MeasureTheory.Measure.count s
-- Real.volume_eq_stieltjes_id
theorem volume_eq_stieltjes_id : (volume : Measure ℝ) = StieltjesFunction.id.measure 
Goal: MeasureTheory.volume = StieltjesFunction.id.measure
-- Real.volume_val
theorem volume_val (s) : volume s = StieltjesFunction.id.measure s 
Arguments: (s : Set ℝ)
Goal: MeasureTheory.volume s = StieltjesFunction.id.measure s
-- Real.volume_Ico
@[simp]
theorem volume_Ico {a b : ℝ} : volume (Ico a b) = ofReal (b - a) 
Arguments: {a b : ℝ}
Goal: MeasureTheory.volume (Set.Ico a b) = ENNReal.ofReal (b - a)
-- Real.volume_Icc
@[simp]
theorem volume_Icc {a b : ℝ} : volume (Icc a b) = ofReal (b - a) 
Arguments: {a b : ℝ}
Goal: MeasureTheory.volume (Set.Icc a b) = ENNReal.ofReal (b - a)
-- Real.volume_Ioo
@[simp]
theorem volume_Ioo {a b : ℝ} : volume (Ioo a b) = ofReal (b - a) 
Arguments: {a b : ℝ}
Goal: MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a)
-- Real.volume_Ioc
@[simp]
theorem volume_Ioc {a b : ℝ} : volume (Ioc a b) = ofReal (b - a) 
Arguments: {a b : ℝ}
Goal: MeasureTheory.volume (Set.Ioc a b) = ENNReal.ofReal (b - a)
-- Real.volume_singleton
theorem volume_singleton {a : ℝ} : volume ({a} : Set ℝ) = 0 
Arguments: {a : ℝ}
Goal: MeasureTheory.volume {a} = 0
-- Real.volume_univ
theorem volume_univ : volume (univ : Set ℝ) = ∞ 
Goal: MeasureTheory.volume Set.univ = ⊤
-- Real.volume_ball
@[simp]
theorem volume_ball (a r : ℝ) : volume (Metric.ball a r) = ofReal (2 * r) 
Arguments: (a r : ℝ)
Goal: MeasureTheory.volume (Metric.ball a r) = ENNReal.ofReal (2 * r)
-- Real.volume_closedBall
@[simp]
theorem volume_closedBall (a r : ℝ) : volume (Metric.closedBall a r) = ofReal (2 * r) 
Arguments: (a r : ℝ)
Goal: MeasureTheory.volume (Metric.closedBall a r) = ENNReal.ofReal (2 * r)
-- Real.volume_emetric_ball
@[simp]
theorem volume_emetric_ball (a : ℝ) (r : ℝ≥0∞) : volume (EMetric.ball a r) = 2 * r 
Arguments: (a : ℝ) (r : ℝ≥0∞)
Goal: MeasureTheory.volume (EMetric.ball a r) = 2 * r
-- Real.volume_emetric_closedBall
@[simp]
theorem volume_emetric_closedBall (a : ℝ) (r : ℝ≥0∞) : volume (EMetric.closedBall a r) = 2 * r 
Arguments: (a : ℝ) (r : ℝ≥0∞)
Goal: MeasureTheory.volume (EMetric.closedBall a r) = 2 * r
-- Real.volume_interval
@[simp]
theorem volume_interval {a b : ℝ} : volume (uIcc a b) = ofReal |b - a| 
Arguments: {a b : ℝ}
Goal: MeasureTheory.volume (Set.uIcc a b) = ENNReal.ofReal |b - a|
-- Real.volume_Ioi
@[simp]
theorem volume_Ioi {a : ℝ} : volume (Ioi a) = ∞ 
Arguments: {a : ℝ}
Goal: MeasureTheory.volume (Set.Ioi a) = ⊤
-- Real.volume_Ici
@[simp]
theorem volume_Ici {a : ℝ} : volume (Ici a) = ∞ 
Arguments: {a : ℝ}
Goal: MeasureTheory.volume (Set.Ici a) = ⊤
-- Real.volume_Iio
@[simp]
theorem volume_Iio {a : ℝ} : volume (Iio a) = ∞ 
Arguments: {a : ℝ}
Goal: MeasureTheory.volume (Set.Iio a) = ⊤
-- Real.volume_Iic
@[simp]
theorem volume_Iic {a : ℝ} : volume (Iic a) = ∞ 
Arguments: {a : ℝ}
Goal: MeasureTheory.volume (Set.Iic a) = ⊤
-- Real.volume_le_diam
theorem volume_le_diam (s : Set ℝ) : volume s ≤ EMetric.diam s 
Arguments: (s : Set ℝ)
Goal: MeasureTheory.volume s ≤ EMetric.diam s
-- Filter.Eventually.volume_pos_of_nhds_real
theorem _root_.Filter.Eventually.volume_pos_of_nhds_real {p : ℝ → Prop} {a : ℝ}
    (h : ∀ᶠ x in 𝓝 a, p x) : (0 : ℝ≥0∞) < volume { x | p x } 
Arguments: {p : ℝ → Prop} {a : ℝ} (h : ∀ᶠ (x : ℝ) in 𝓝 a, p x)
Goal: 0 < MeasureTheory.volume {x | p x}
-- Real.volume_Icc_pi
theorem volume_Icc_pi {a b : ι → ℝ} : volume (Icc a b) = ∏ i, ENNReal.ofReal (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ}
Goal: MeasureTheory.volume (Set.Icc a b) = ∏ i : ι, ENNReal.ofReal (b i - a i)
-- Real.volume_Icc_pi_toReal
@[simp]
theorem volume_Icc_pi_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (Icc a b)).toReal = ∏ i, (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ} (h : a ≤ b)
Goal: (MeasureTheory.volume (Set.Icc a b)).toReal = ∏ i : ι, (b i - a i)
-- Real.volume_pi_Ioo
theorem volume_pi_Ioo {a b : ι → ℝ} :
    volume (pi univ fun i => Ioo (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ}
Goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ioo (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)
-- Real.volume_pi_Ioo_toReal
@[simp]
theorem volume_pi_Ioo_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ioo (a i) (b i))).toReal = ∏ i, (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ} (h : a ≤ b)
Goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ioo (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
-- Real.volume_pi_Ioc
theorem volume_pi_Ioc {a b : ι → ℝ} :
    volume (pi univ fun i => Ioc (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ}
Goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ioc (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)
-- Real.volume_pi_Ioc_toReal
@[simp]
theorem volume_pi_Ioc_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ioc (a i) (b i))).toReal = ∏ i, (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ} (h : a ≤ b)
Goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ioc (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
-- Real.volume_pi_Ico
theorem volume_pi_Ico {a b : ι → ℝ} :
    volume (pi univ fun i => Ico (a i) (b i)) = ∏ i, ENNReal.ofReal (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ}
Goal: MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i)) = ∏ i : ι, ENNReal.ofReal (b i - a i)
-- Real.volume_pi_Ico_toReal
@[simp]
theorem volume_pi_Ico_toReal {a b : ι → ℝ} (h : a ≤ b) :
    (volume (pi univ fun i => Ico (a i) (b i))).toReal = ∏ i, (b i - a i) 
Arguments: {ι : Type u_1} [Fintype ι] {a b : ι → ℝ} (h : a ≤ b)
Goal: (MeasureTheory.volume (Set.univ.pi fun i => Set.Ico (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
-- Real.volume_pi_ball
@[simp]
nonrec theorem volume_pi_ball (a : ι → ℝ) {r : ℝ} (hr : 0 < r) :
    volume (Metric.ball a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι) 
Arguments: {ι : Type u_1} [Fintype ι] (a : ι → ℝ) {r : ℝ} (hr : 0 < r)
Goal: MeasureTheory.volume (Metric.ball a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι)
-- Real.volume_pi_closedBall
@[simp]
nonrec theorem volume_pi_closedBall (a : ι → ℝ) {r : ℝ} (hr : 0 ≤ r) :
    volume (Metric.closedBall a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι) 
Arguments: {ι : Type u_1} [Fintype ι] (a : ι → ℝ) {r : ℝ} (hr : 0 ≤ r)
Goal: MeasureTheory.volume (Metric.closedBall a r) = ENNReal.ofReal ((2 * r) ^ Fintype.card ι)
-- Real.volume_pi_le_prod_diam
theorem volume_pi_le_prod_diam (s : Set (ι → ℝ)) :
    volume s ≤ ∏ i : ι, EMetric.diam (Function.eval i '' s) 
Arguments: {ι : Type u_1} [Fintype ι] (s : Set (ι → ℝ))
Goal: MeasureTheory.volume s ≤ ∏ i : ι, EMetric.diam (Function.eval i '' s)
-- Real.volume_pi_le_diam_pow
theorem volume_pi_le_diam_pow (s : Set (ι → ℝ)) : volume s ≤ EMetric.diam s ^ Fintype.card ι 
Arguments: {ι : Type u_1} [Fintype ι] (s : Set (ι → ℝ))
Goal: MeasureTheory.volume s ≤ EMetric.diam s ^ Fintype.card ι
-- Real.smul_map_volume_mul_left
theorem smul_map_volume_mul_left {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (a * ·) volume = volume 
Arguments: {a : ℝ} (h : a ≠ 0)
Goal: ENNReal.ofReal |a| • MeasureTheory.Measure.map (fun x => a * x) MeasureTheory.volume = MeasureTheory.volume
-- Real.map_volume_mul_left
theorem map_volume_mul_left {a : ℝ} (h : a ≠ 0) :
    Measure.map (a * ·) volume = ENNReal.ofReal |a⁻¹| • volume 
Arguments: {a : ℝ} (h : a ≠ 0)
Goal: MeasureTheory.Measure.map (fun x => a * x) MeasureTheory.volume = ENNReal.ofReal |a⁻¹| • MeasureTheory.volume
-- Real.volume_preimage_mul_left
@[simp]
theorem volume_preimage_mul_left {a : ℝ} (h : a ≠ 0) (s : Set ℝ) :
    volume ((a * ·) ⁻¹' s) = ENNReal.ofReal (abs a⁻¹) * volume s 
Arguments: {a : ℝ} (h : a ≠ 0) (s : Set ℝ)
Goal: MeasureTheory.volume ((fun x => a * x) ⁻¹' s) = ENNReal.ofReal |a⁻¹| * MeasureTheory.volume s
-- Real.smul_map_volume_mul_right
theorem smul_map_volume_mul_right {a : ℝ} (h : a ≠ 0) :
    ENNReal.ofReal |a| • Measure.map (· * a) volume = volume 
Arguments: {a : ℝ} (h : a ≠ 0)
Goal: ENNReal.ofReal |a| • MeasureTheory.Measure.map (fun x => x * a) MeasureTheory.volume = MeasureTheory.volume
-- Real.map_volume_mul_right
theorem map_volume_mul_right {a : ℝ} (h : a ≠ 0) :
    Measure.map (· * a) volume = ENNReal.ofReal |a⁻¹| • volume 
Arguments: {a : ℝ} (h : a ≠ 0)
Goal: MeasureTheory.Measure.map (fun x => x * a) MeasureTheory.volume = ENNReal.ofReal |a⁻¹| • MeasureTheory.volume
-- Real.volume_preimage_mul_right
@[simp]
theorem volume_preimage_mul_right {a : ℝ} (h : a ≠ 0) (s : Set ℝ) :
    volume ((· * a) ⁻¹' s) = ENNReal.ofReal (abs a⁻¹) * volume s 
Arguments: {a : ℝ} (h : a ≠ 0) (s : Set ℝ)
Goal: MeasureTheory.volume ((fun x => x * a) ⁻¹' s) = ENNReal.ofReal |a⁻¹| * MeasureTheory.volume s
-- Real.smul_map_diagonal_volume_pi
theorem smul_map_diagonal_volume_pi [DecidableEq ι] {D : ι → ℝ} (h : det (diagonal D) ≠ 0) :
    ENNReal.ofReal (abs (det (diagonal D))) • Measure.map (toLin' (diagonal D)) volume =
      volume 
Arguments: {ι : Type u_1} [Fintype ι] [DecidableEq ι] {D : ι → ℝ} (h : (Matrix.diagonal D).det ≠ 0)
Goal: ENNReal.ofReal |(Matrix.diagonal D).det| •
    MeasureTheory.Measure.map (⇑(Matrix.toLin' (Matrix.diagonal D))) MeasureTheory.volume =
  MeasureTheory.volume