File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

full_name: MeasureTheory.Measure.haar.index
code: /-- The index or Haar covering number or ratio of `K` w.r.t. `V`, denoted `(K : V)`:
  it is the smallest number of (left) translates of `V` that is necessary to cover `K`.
  It is defined to be 0 if no finite number of translates cover `K`. -/
@[to_additive addIndex "additive version of `MeasureTheory.Measure.haar.index`"]
noncomputable def index (K V : Set G) : ℕ 
goal: ℕ

full_name: MeasureTheory.Measure.haar.addIndex
code: /-- The index or Haar covering number or ratio of `K` w.r.t. `V`, denoted `(K : V)`:
  it is the smallest number of (left) translates of `V` that is necessary to cover `K`.
  It is defined to be 0 if no finite number of translates cover `K`. -/
@[to_additive addIndex "additive version of `MeasureTheory.Measure.haar.index`"]
noncomputable def index (K V : Set G) : ℕ 
goal: ℕ

full_name: MeasureTheory.Measure.haar.index_empty
code: @[to_additive addIndex_empty]
theorem index_empty {V : Set G} : index ∅ V = 0 
goal: MeasureTheory.Measure.haar.index ∅ V = 0

full_name: MeasureTheory.Measure.haar.addIndex_empty
code: @[to_additive addIndex_empty]
theorem index_empty {V : Set G} : index ∅ V = 0 
goal: MeasureTheory.Measure.haar.addIndex ∅ V = 0

full_name: MeasureTheory.Measure.haar.prehaar
code: /-- `prehaar K₀ U K` is a weighted version of the index, defined as `(K : U)/(K₀ : U)`.
  In the applications `K₀` is compact with non-empty interior, `U` is open containing `1`,
  and `K` is any compact set.
  The argument `K` is a (bundled) compact set, so that we can consider `prehaar K₀ U` as an
  element of `haarProduct` (below). -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.prehaar`"]
noncomputable def prehaar (K₀ U : Set G) (K : Compacts G) : ℝ 
goal: ℝ

full_name: MeasureTheory.Measure.haar.addPrehaar
code: /-- `prehaar K₀ U K` is a weighted version of the index, defined as `(K : U)/(K₀ : U)`.
  In the applications `K₀` is compact with non-empty interior, `U` is open containing `1`,
  and `K` is any compact set.
  The argument `K` is a (bundled) compact set, so that we can consider `prehaar K₀ U` as an
  element of `haarProduct` (below). -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.prehaar`"]
noncomputable def prehaar (K₀ U : Set G) (K : Compacts G) : ℝ 
goal: ℝ

full_name: MeasureTheory.Measure.haar.addPrehaar_empty
code: @[to_additive]
theorem prehaar_empty (K₀ : PositiveCompacts G) {U : Set G} : prehaar (K₀ : Set G) U ⊥ = 0 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U ⊥ = 0

full_name: MeasureTheory.Measure.haar.prehaar_empty
code: @[to_additive]
theorem prehaar_empty (K₀ : PositiveCompacts G) {U : Set G} : prehaar (K₀ : Set G) U ⊥ = 0 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U ⊥ = 0

full_name: MeasureTheory.Measure.haar.addPrehaar_nonneg
code: @[to_additive]
theorem prehaar_nonneg (K₀ : PositiveCompacts G) {U : Set G} (K : Compacts G) :
    0 ≤ prehaar (K₀ : Set G) U K 
goal: 0 ≤ MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K

full_name: MeasureTheory.Measure.haar.prehaar_nonneg
code: @[to_additive]
theorem prehaar_nonneg (K₀ : PositiveCompacts G) {U : Set G} (K : Compacts G) :
    0 ≤ prehaar (K₀ : Set G) U K 
goal: 0 ≤ MeasureTheory.Measure.haar.prehaar (↑K₀) U K

full_name: MeasureTheory.Measure.haar.addHaarProduct
code: /-- `haarProduct K₀` is the product of intervals `[0, (K : K₀)]`, for all compact sets `K`.
  For all `U`, we can show that `prehaar K₀ U ∈ haarProduct K₀`. -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.haarProduct`"]
def haarProduct (K₀ : Set G) : Set (Compacts G → ℝ) 
goal: Set (TopologicalSpace.Compacts G → ℝ)

full_name: MeasureTheory.Measure.haar.haarProduct
code: /-- `haarProduct K₀` is the product of intervals `[0, (K : K₀)]`, for all compact sets `K`.
  For all `U`, we can show that `prehaar K₀ U ∈ haarProduct K₀`. -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.haarProduct`"]
def haarProduct (K₀ : Set G) : Set (Compacts G → ℝ) 
goal: Set (TopologicalSpace.Compacts G → ℝ)

full_name: MeasureTheory.Measure.haar.mem_addPrehaar_empty
code: @[to_additive (attr := simp)]
theorem mem_prehaar_empty {K₀ : Set G} {f : Compacts G → ℝ} :
    f ∈ haarProduct K₀ ↔ ∀ K : Compacts G, f K ∈ Icc (0 : ℝ) (index (K : Set G) K₀) 
goal: f ∈ MeasureTheory.Measure.haar.addHaarProduct K₀ ↔
  ∀ (K : TopologicalSpace.Compacts G), f K ∈ Set.Icc 0 ↑(MeasureTheory.Measure.haar.addIndex (↑K) K₀)

full_name: MeasureTheory.Measure.haar.mem_prehaar_empty
code: @[to_additive (attr := simp)]
theorem mem_prehaar_empty {K₀ : Set G} {f : Compacts G → ℝ} :
    f ∈ haarProduct K₀ ↔ ∀ K : Compacts G, f K ∈ Icc (0 : ℝ) (index (K : Set G) K₀) 
goal: f ∈ MeasureTheory.Measure.haar.haarProduct K₀ ↔
  ∀ (K : TopologicalSpace.Compacts G), f K ∈ Set.Icc 0 ↑(MeasureTheory.Measure.haar.index (↑K) K₀)

full_name: MeasureTheory.Measure.haar.clPrehaar
code: /-- The closure of the collection of elements of the form `prehaar K₀ U`,
  for `U` open neighbourhoods of `1`, contained in `V`. The closure is taken in the space
  `compacts G → ℝ`, with the topology of pointwise convergence.
  We show that the intersection of all these sets is nonempty, and the Haar measure
  on compact sets is defined to be an element in the closure of this intersection. -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.clPrehaar`"]
def clPrehaar (K₀ : Set G) (V : OpenNhdsOf (1 : G)) : Set (Compacts G → ℝ) 
goal: Set (TopologicalSpace.Compacts G → ℝ)

full_name: MeasureTheory.Measure.haar.clAddPrehaar
code: /-- The closure of the collection of elements of the form `prehaar K₀ U`,
  for `U` open neighbourhoods of `1`, contained in `V`. The closure is taken in the space
  `compacts G → ℝ`, with the topology of pointwise convergence.
  We show that the intersection of all these sets is nonempty, and the Haar measure
  on compact sets is defined to be an element in the closure of this intersection. -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.clPrehaar`"]
def clPrehaar (K₀ : Set G) (V : OpenNhdsOf (1 : G)) : Set (Compacts G → ℝ) 
goal: Set (TopologicalSpace.Compacts G → ℝ)

full_name: MeasureTheory.Measure.haar.addIndex_defined
code: /-- If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined,
  there is a finite set `t` satisfying the desired properties. -/
@[to_additive addIndex_defined
"If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined, there is
a finite set `t` satisfying the desired properties."]
theorem index_defined {K V : Set G} (hK : IsCompact K) (hV : (interior V).Nonempty) :
    ∃ n : ℕ, n ∈ Finset.card '' { t : Finset G | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V } 
goal: ∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g + h) ⁻¹' V}

full_name: MeasureTheory.Measure.haar.index_defined
code: /-- If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined,
  there is a finite set `t` satisfying the desired properties. -/
@[to_additive addIndex_defined
"If `K` is compact and `V` has nonempty interior, then the index `(K : V)` is well-defined, there is
a finite set `t` satisfying the desired properties."]
theorem index_defined {K V : Set G} (hK : IsCompact K) (hV : (interior V).Nonempty) :
    ∃ n : ℕ, n ∈ Finset.card '' { t : Finset G | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V } 
goal: ∃ n, n ∈ Finset.card '' {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}

full_name: MeasureTheory.Measure.haar.addIndex_elim
code: @[to_additive addIndex_elim]
theorem index_elim {K V : Set G} (hK : IsCompact K) (hV : (interior V).Nonempty) :
    ∃ t : Finset G, (K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V) ∧ Finset.card t = index K V 
goal: ∃ t, K ⊆ ⋃ g ∈ t, (fun h => g + h) ⁻¹' V ∧ t.card = MeasureTheory.Measure.haar.addIndex K V

full_name: MeasureTheory.Measure.haar.index_elim
code: @[to_additive addIndex_elim]
theorem index_elim {K V : Set G} (hK : IsCompact K) (hV : (interior V).Nonempty) :
    ∃ t : Finset G, (K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V) ∧ Finset.card t = index K V 
goal: ∃ t, K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V ∧ t.card = MeasureTheory.Measure.haar.index K V

full_name: MeasureTheory.Measure.haar.le_addIndex_mul
code: @[to_additive le_addIndex_mul]
theorem le_index_mul (K₀ : PositiveCompacts G) (K : Compacts G) {V : Set G}
    (hV : (interior V).Nonempty) :
    index (K : Set G) V ≤ index (K : Set G) K₀ * index (K₀ : Set G) V 
goal: MeasureTheory.Measure.haar.addIndex (↑K) V ≤
  MeasureTheory.Measure.haar.addIndex ↑K ↑K₀ * MeasureTheory.Measure.haar.addIndex (↑K₀) V

full_name: MeasureTheory.Measure.haar.le_index_mul
code: @[to_additive le_addIndex_mul]
theorem le_index_mul (K₀ : PositiveCompacts G) (K : Compacts G) {V : Set G}
    (hV : (interior V).Nonempty) :
    index (K : Set G) V ≤ index (K : Set G) K₀ * index (K₀ : Set G) V 
goal: MeasureTheory.Measure.haar.index (↑K) V ≤
  MeasureTheory.Measure.haar.index ↑K ↑K₀ * MeasureTheory.Measure.haar.index (↑K₀) V

full_name: MeasureTheory.Measure.haar.addIndex_pos
code: @[to_additive addIndex_pos]
theorem index_pos (K : PositiveCompacts G) {V : Set G} (hV : (interior V).Nonempty) :
    0 < index (K : Set G) V 
goal: 0 < MeasureTheory.Measure.haar.addIndex (↑K) V

full_name: MeasureTheory.Measure.haar.index_pos
code: @[to_additive addIndex_pos]
theorem index_pos (K : PositiveCompacts G) {V : Set G} (hV : (interior V).Nonempty) :
    0 < index (K : Set G) V 
goal: 0 < MeasureTheory.Measure.haar.index (↑K) V

full_name: MeasureTheory.Measure.haar.index_mono
code: @[to_additive addIndex_mono]
theorem index_mono {K K' V : Set G} (hK' : IsCompact K') (h : K ⊆ K') (hV : (interior V).Nonempty) :
    index K V ≤ index K' V 
goal: MeasureTheory.Measure.haar.index K V ≤ MeasureTheory.Measure.haar.index K' V

full_name: MeasureTheory.Measure.haar.addIndex_mono
code: @[to_additive addIndex_mono]
theorem index_mono {K K' V : Set G} (hK' : IsCompact K') (h : K ⊆ K') (hV : (interior V).Nonempty) :
    index K V ≤ index K' V 
goal: MeasureTheory.Measure.haar.addIndex K V ≤ MeasureTheory.Measure.haar.addIndex K' V

full_name: MeasureTheory.Measure.haar.addIndex_union_le
code: @[to_additive addIndex_union_le]
theorem index_union_le (K₁ K₂ : Compacts G) {V : Set G} (hV : (interior V).Nonempty) :
    index (K₁.1 ∪ K₂.1) V ≤ index K₁.1 V + index K₂.1 V 
goal: MeasureTheory.Measure.haar.addIndex (K₁.carrier ∪ K₂.carrier) V ≤
  MeasureTheory.Measure.haar.addIndex K₁.carrier V + MeasureTheory.Measure.haar.addIndex K₂.carrier V

full_name: MeasureTheory.Measure.haar.index_union_le
code: @[to_additive addIndex_union_le]
theorem index_union_le (K₁ K₂ : Compacts G) {V : Set G} (hV : (interior V).Nonempty) :
    index (K₁.1 ∪ K₂.1) V ≤ index K₁.1 V + index K₂.1 V 
goal: MeasureTheory.Measure.haar.index (K₁.carrier ∪ K₂.carrier) V ≤
  MeasureTheory.Measure.haar.index K₁.carrier V + MeasureTheory.Measure.haar.index K₂.carrier V

full_name: MeasureTheory.Measure.haar.addIndex_union_eq
code: @[to_additive addIndex_union_eq]
theorem index_union_eq (K₁ K₂ : Compacts G) {V : Set G} (hV : (interior V).Nonempty)
    (h : Disjoint (K₁.1 * V⁻¹) (K₂.1 * V⁻¹)) :
    index (K₁.1 ∪ K₂.1) V = index K₁.1 V + index K₂.1 V 
goal: MeasureTheory.Measure.haar.addIndex (K₁.carrier ∪ K₂.carrier) V =
  MeasureTheory.Measure.haar.addIndex K₁.carrier V + MeasureTheory.Measure.haar.addIndex K₂.carrier V

full_name: MeasureTheory.Measure.haar.index_union_eq
code: @[to_additive addIndex_union_eq]
theorem index_union_eq (K₁ K₂ : Compacts G) {V : Set G} (hV : (interior V).Nonempty)
    (h : Disjoint (K₁.1 * V⁻¹) (K₂.1 * V⁻¹)) :
    index (K₁.1 ∪ K₂.1) V = index K₁.1 V + index K₂.1 V 
goal: MeasureTheory.Measure.haar.index (K₁.carrier ∪ K₂.carrier) V =
  MeasureTheory.Measure.haar.index K₁.carrier V + MeasureTheory.Measure.haar.index K₂.carrier V

full_name: MeasureTheory.Measure.haar.add_left_addIndex_le
code: @[to_additive add_left_addIndex_le]
theorem mul_left_index_le {K : Set G} (hK : IsCompact K) {V : Set G} (hV : (interior V).Nonempty)
    (g : G) : index ((fun h => g * h) '' K) V ≤ index K V 
goal: MeasureTheory.Measure.haar.addIndex ((fun h => g + h) '' K) V ≤ MeasureTheory.Measure.haar.addIndex K V

full_name: MeasureTheory.Measure.haar.mul_left_index_le
code: @[to_additive add_left_addIndex_le]
theorem mul_left_index_le {K : Set G} (hK : IsCompact K) {V : Set G} (hV : (interior V).Nonempty)
    (g : G) : index ((fun h => g * h) '' K) V ≤ index K V 
goal: MeasureTheory.Measure.haar.index ((fun h => g * h) '' K) V ≤ MeasureTheory.Measure.haar.index K V

full_name: MeasureTheory.Measure.haar.is_left_invariant_addIndex
code: @[to_additive is_left_invariant_addIndex]
theorem is_left_invariant_index {K : Set G} (hK : IsCompact K) (g : G) {V : Set G}
    (hV : (interior V).Nonempty) : index ((fun h => g * h) '' K) V = index K V 
goal: MeasureTheory.Measure.haar.addIndex ((fun h => g + h) '' K) V = MeasureTheory.Measure.haar.addIndex K V

full_name: MeasureTheory.Measure.haar.is_left_invariant_index
code: @[to_additive is_left_invariant_addIndex]
theorem is_left_invariant_index {K : Set G} (hK : IsCompact K) (g : G) {V : Set G}
    (hV : (interior V).Nonempty) : index ((fun h => g * h) '' K) V = index K V 
goal: MeasureTheory.Measure.haar.index ((fun h => g * h) '' K) V = MeasureTheory.Measure.haar.index K V

full_name: MeasureTheory.Measure.haar.add_prehaar_le_addIndex
code: @[to_additive add_prehaar_le_addIndex]
theorem prehaar_le_index (K₀ : PositiveCompacts G) {U : Set G} (K : Compacts G)
    (hU : (interior U).Nonempty) : prehaar (K₀ : Set G) U K ≤ index (K : Set G) K₀ 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K ≤ ↑(MeasureTheory.Measure.haar.addIndex ↑K ↑K₀)

full_name: MeasureTheory.Measure.haar.prehaar_le_index
code: @[to_additive add_prehaar_le_addIndex]
theorem prehaar_le_index (K₀ : PositiveCompacts G) {U : Set G} (K : Compacts G)
    (hU : (interior U).Nonempty) : prehaar (K₀ : Set G) U K ≤ index (K : Set G) K₀ 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U K ≤ ↑(MeasureTheory.Measure.haar.index ↑K ↑K₀)

full_name: MeasureTheory.Measure.haar.prehaar_pos
code: @[to_additive]
theorem prehaar_pos (K₀ : PositiveCompacts G) {U : Set G} (hU : (interior U).Nonempty) {K : Set G}
    (h1K : IsCompact K) (h2K : (interior K).Nonempty) : 0 < prehaar (K₀ : Set G) U ⟨K, h1K⟩ 
goal: 0 < MeasureTheory.Measure.haar.prehaar (↑K₀) U { carrier := K, isCompact' := h1K }

full_name: MeasureTheory.Measure.haar.addPrehaar_pos
code: @[to_additive]
theorem prehaar_pos (K₀ : PositiveCompacts G) {U : Set G} (hU : (interior U).Nonempty) {K : Set G}
    (h1K : IsCompact K) (h2K : (interior K).Nonempty) : 0 < prehaar (K₀ : Set G) U ⟨K, h1K⟩ 
goal: 0 < MeasureTheory.Measure.haar.addPrehaar (↑K₀) U { carrier := K, isCompact' := h1K }

full_name: MeasureTheory.Measure.haar.prehaar_mono
code: @[to_additive]
theorem prehaar_mono {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty)
    {K₁ K₂ : Compacts G} (h : (K₁ : Set G) ⊆ K₂.1) :
    prehaar (K₀ : Set G) U K₁ ≤ prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U K₁ ≤ MeasureTheory.Measure.haar.prehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.addPrehaar_mono
code: @[to_additive]
theorem prehaar_mono {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty)
    {K₁ K₂ : Compacts G} (h : (K₁ : Set G) ⊆ K₂.1) :
    prehaar (K₀ : Set G) U K₁ ≤ prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₁ ≤ MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.prehaar_self
code: @[to_additive]
theorem prehaar_self {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U K₀.toCompacts = 1 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.addPrehaar_self
code: @[to_additive]
theorem prehaar_self {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U K₀.toCompacts = 1 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.prehaar_sup_le
code: @[to_additive]
theorem prehaar_sup_le {K₀ : PositiveCompacts G} {U : Set G} (K₁ K₂ : Compacts G)
    (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U (K₁ ⊔ K₂) ≤ prehaar (K₀ : Set G) U K₁ + prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U (K₁ ⊔ K₂) ≤
  MeasureTheory.Measure.haar.prehaar (↑K₀) U K₁ + MeasureTheory.Measure.haar.prehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.addPrehaar_sup_le
code: @[to_additive]
theorem prehaar_sup_le {K₀ : PositiveCompacts G} {U : Set G} (K₁ K₂ : Compacts G)
    (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U (K₁ ⊔ K₂) ≤ prehaar (K₀ : Set G) U K₁ + prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U (K₁ ⊔ K₂) ≤
  MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₁ + MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.prehaar_sup_eq
code: @[to_additive]
theorem prehaar_sup_eq {K₀ : PositiveCompacts G} {U : Set G} {K₁ K₂ : Compacts G}
    (hU : (interior U).Nonempty) (h : Disjoint (K₁.1 * U⁻¹) (K₂.1 * U⁻¹)) :
    prehaar (K₀ : Set G) U (K₁ ⊔ K₂) = prehaar (K₀ : Set G) U K₁ + prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U (K₁ ⊔ K₂) =
  MeasureTheory.Measure.haar.prehaar (↑K₀) U K₁ + MeasureTheory.Measure.haar.prehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.addPrehaar_sup_eq
code: @[to_additive]
theorem prehaar_sup_eq {K₀ : PositiveCompacts G} {U : Set G} {K₁ K₂ : Compacts G}
    (hU : (interior U).Nonempty) (h : Disjoint (K₁.1 * U⁻¹) (K₂.1 * U⁻¹)) :
    prehaar (K₀ : Set G) U (K₁ ⊔ K₂) = prehaar (K₀ : Set G) U K₁ + prehaar (K₀ : Set G) U K₂ 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U (K₁ ⊔ K₂) =
  MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₁ + MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K₂

full_name: MeasureTheory.Measure.haar.is_left_invariant_prehaar
code: @[to_additive]
theorem is_left_invariant_prehaar {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty)
    (g : G) (K : Compacts G) :
    prehaar (K₀ : Set G) U (K.map _ <| continuous_mul_left g) = prehaar (K₀ : Set G) U K 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U (TopologicalSpace.Compacts.map (fun b => g * b) ⋯ K) =
  MeasureTheory.Measure.haar.prehaar (↑K₀) U K

full_name: MeasureTheory.Measure.haar.is_left_invariant_addPrehaar
code: @[to_additive]
theorem is_left_invariant_prehaar {K₀ : PositiveCompacts G} {U : Set G} (hU : (interior U).Nonempty)
    (g : G) (K : Compacts G) :
    prehaar (K₀ : Set G) U (K.map _ <| continuous_mul_left g) = prehaar (K₀ : Set G) U K 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U (TopologicalSpace.Compacts.map (fun b => g + b) ⋯ K) =
  MeasureTheory.Measure.haar.addPrehaar (↑K₀) U K

full_name: MeasureTheory.Measure.haar.addPrehaar_mem_addHaarProduct
code: @[to_additive]
theorem prehaar_mem_haarProduct (K₀ : PositiveCompacts G) {U : Set G} (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U ∈ haarProduct (K₀ : Set G) 
goal: MeasureTheory.Measure.haar.addPrehaar (↑K₀) U ∈ MeasureTheory.Measure.haar.addHaarProduct ↑K₀

full_name: MeasureTheory.Measure.haar.prehaar_mem_haarProduct
code: @[to_additive]
theorem prehaar_mem_haarProduct (K₀ : PositiveCompacts G) {U : Set G} (hU : (interior U).Nonempty) :
    prehaar (K₀ : Set G) U ∈ haarProduct (K₀ : Set G) 
goal: MeasureTheory.Measure.haar.prehaar (↑K₀) U ∈ MeasureTheory.Measure.haar.haarProduct ↑K₀

full_name: MeasureTheory.Measure.haar.nonempty_iInter_clAddPrehaar
code: @[to_additive]
theorem nonempty_iInter_clPrehaar (K₀ : PositiveCompacts G) :
    (haarProduct (K₀ : Set G) ∩ ⋂ V : OpenNhdsOf (1 : G), clPrehaar K₀ V).Nonempty 
goal: (MeasureTheory.Measure.haar.addHaarProduct ↑K₀ ∩ ⋂ V, MeasureTheory.Measure.haar.clAddPrehaar (↑K₀) V).Nonempty

full_name: MeasureTheory.Measure.haar.nonempty_iInter_clPrehaar
code: @[to_additive]
theorem nonempty_iInter_clPrehaar (K₀ : PositiveCompacts G) :
    (haarProduct (K₀ : Set G) ∩ ⋂ V : OpenNhdsOf (1 : G), clPrehaar K₀ V).Nonempty 
goal: (MeasureTheory.Measure.haar.haarProduct ↑K₀ ∩ ⋂ V, MeasureTheory.Measure.haar.clPrehaar (↑K₀) V).Nonempty

full_name: MeasureTheory.Measure.haar.addCHaar
code: /-- This is the "limit" of `prehaar K₀ U K` as `U` becomes a smaller and smaller open
  neighborhood of `(1 : G)`. More precisely, it is defined to be an arbitrary element
  in the intersection of all the sets `clPrehaar K₀ V` in `haarProduct K₀`.
  This is roughly equal to the Haar measure on compact sets,
  but it can differ slightly. We do know that
  `haarMeasure K₀ (interior K) ≤ chaar K₀ K ≤ haarMeasure K₀ K`. -/
@[to_additive addCHaar "additive version of `MeasureTheory.Measure.haar.chaar`"]
noncomputable def chaar (K₀ : PositiveCompacts G) (K : Compacts G) : ℝ 
goal: ℝ

full_name: MeasureTheory.Measure.haar.chaar
code: /-- This is the "limit" of `prehaar K₀ U K` as `U` becomes a smaller and smaller open
  neighborhood of `(1 : G)`. More precisely, it is defined to be an arbitrary element
  in the intersection of all the sets `clPrehaar K₀ V` in `haarProduct K₀`.
  This is roughly equal to the Haar measure on compact sets,
  but it can differ slightly. We do know that
  `haarMeasure K₀ (interior K) ≤ chaar K₀ K ≤ haarMeasure K₀ K`. -/
@[to_additive addCHaar "additive version of `MeasureTheory.Measure.haar.chaar`"]
noncomputable def chaar (K₀ : PositiveCompacts G) (K : Compacts G) : ℝ 
goal: ℝ

full_name: MeasureTheory.Measure.haar.chaar_mem_haarProduct
code: @[to_additive addCHaar_mem_addHaarProduct]
theorem chaar_mem_haarProduct (K₀ : PositiveCompacts G) : chaar K₀ ∈ haarProduct (K₀ : Set G) 
goal: MeasureTheory.Measure.haar.chaar K₀ ∈ MeasureTheory.Measure.haar.haarProduct ↑K₀

full_name: MeasureTheory.Measure.haar.addCHaar_mem_addHaarProduct
code: @[to_additive addCHaar_mem_addHaarProduct]
theorem chaar_mem_haarProduct (K₀ : PositiveCompacts G) : chaar K₀ ∈ haarProduct (K₀ : Set G) 
goal: MeasureTheory.Measure.haar.addCHaar K₀ ∈ MeasureTheory.Measure.haar.addHaarProduct ↑K₀

full_name: MeasureTheory.Measure.haar.chaar_mem_clPrehaar
code: @[to_additive addCHaar_mem_clAddPrehaar]
theorem chaar_mem_clPrehaar (K₀ : PositiveCompacts G) (V : OpenNhdsOf (1 : G)) :
    chaar K₀ ∈ clPrehaar (K₀ : Set G) V 
goal: MeasureTheory.Measure.haar.chaar K₀ ∈ MeasureTheory.Measure.haar.clPrehaar (↑K₀) V

full_name: MeasureTheory.Measure.haar.addCHaar_mem_clAddPrehaar
code: @[to_additive addCHaar_mem_clAddPrehaar]
theorem chaar_mem_clPrehaar (K₀ : PositiveCompacts G) (V : OpenNhdsOf (1 : G)) :
    chaar K₀ ∈ clPrehaar (K₀ : Set G) V 
goal: MeasureTheory.Measure.haar.addCHaar K₀ ∈ MeasureTheory.Measure.haar.clAddPrehaar (↑K₀) V

full_name: MeasureTheory.Measure.haar.addCHaar_nonneg
code: @[to_additive addCHaar_nonneg]
theorem chaar_nonneg (K₀ : PositiveCompacts G) (K : Compacts G) : 0 ≤ chaar K₀ K 
goal: 0 ≤ MeasureTheory.Measure.haar.addCHaar K₀ K

full_name: MeasureTheory.Measure.haar.chaar_nonneg
code: @[to_additive addCHaar_nonneg]
theorem chaar_nonneg (K₀ : PositiveCompacts G) (K : Compacts G) : 0 ≤ chaar K₀ K 
goal: 0 ≤ MeasureTheory.Measure.haar.chaar K₀ K

full_name: MeasureTheory.Measure.haar.chaar_empty
code: @[to_additive addCHaar_empty]
theorem chaar_empty (K₀ : PositiveCompacts G) : chaar K₀ ⊥ = 0 
goal: MeasureTheory.Measure.haar.chaar K₀ ⊥ = 0

full_name: MeasureTheory.Measure.haar.addCHaar_empty
code: @[to_additive addCHaar_empty]
theorem chaar_empty (K₀ : PositiveCompacts G) : chaar K₀ ⊥ = 0 
goal: MeasureTheory.Measure.haar.addCHaar K₀ ⊥ = 0

full_name: MeasureTheory.Measure.haar.addCHaar_self
code: @[to_additive addCHaar_self]
theorem chaar_self (K₀ : PositiveCompacts G) : chaar K₀ K₀.toCompacts = 1 
goal: MeasureTheory.Measure.haar.addCHaar K₀ K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.chaar_self
code: @[to_additive addCHaar_self]
theorem chaar_self (K₀ : PositiveCompacts G) : chaar K₀ K₀.toCompacts = 1 
goal: MeasureTheory.Measure.haar.chaar K₀ K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.chaar_mono
code: @[to_additive addCHaar_mono]
theorem chaar_mono {K₀ : PositiveCompacts G} {K₁ K₂ : Compacts G} (h : (K₁ : Set G) ⊆ K₂) :
    chaar K₀ K₁ ≤ chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.chaar K₀ K₁ ≤ MeasureTheory.Measure.haar.chaar K₀ K₂

full_name: MeasureTheory.Measure.haar.addCHaar_mono
code: @[to_additive addCHaar_mono]
theorem chaar_mono {K₀ : PositiveCompacts G} {K₁ K₂ : Compacts G} (h : (K₁ : Set G) ⊆ K₂) :
    chaar K₀ K₁ ≤ chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.addCHaar K₀ K₁ ≤ MeasureTheory.Measure.haar.addCHaar K₀ K₂

full_name: MeasureTheory.Measure.haar.addCHaar_sup_le
code: @[to_additive addCHaar_sup_le]
theorem chaar_sup_le {K₀ : PositiveCompacts G} (K₁ K₂ : Compacts G) :
    chaar K₀ (K₁ ⊔ K₂) ≤ chaar K₀ K₁ + chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.addCHaar K₀ (K₁ ⊔ K₂) ≤
  MeasureTheory.Measure.haar.addCHaar K₀ K₁ + MeasureTheory.Measure.haar.addCHaar K₀ K₂

full_name: MeasureTheory.Measure.haar.chaar_sup_le
code: @[to_additive addCHaar_sup_le]
theorem chaar_sup_le {K₀ : PositiveCompacts G} (K₁ K₂ : Compacts G) :
    chaar K₀ (K₁ ⊔ K₂) ≤ chaar K₀ K₁ + chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.chaar K₀ (K₁ ⊔ K₂) ≤
  MeasureTheory.Measure.haar.chaar K₀ K₁ + MeasureTheory.Measure.haar.chaar K₀ K₂

full_name: MeasureTheory.Measure.haar.chaar_sup_eq
code: @[to_additive addCHaar_sup_eq]
theorem chaar_sup_eq {K₀ : PositiveCompacts G}
    {K₁ K₂ : Compacts G} (h : Disjoint K₁.1 K₂.1) (h₂ : IsClosed K₂.1) :
    chaar K₀ (K₁ ⊔ K₂) = chaar K₀ K₁ + chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.chaar K₀ (K₁ ⊔ K₂) =
  MeasureTheory.Measure.haar.chaar K₀ K₁ + MeasureTheory.Measure.haar.chaar K₀ K₂

full_name: MeasureTheory.Measure.haar.addCHaar_sup_eq
code: @[to_additive addCHaar_sup_eq]
theorem chaar_sup_eq {K₀ : PositiveCompacts G}
    {K₁ K₂ : Compacts G} (h : Disjoint K₁.1 K₂.1) (h₂ : IsClosed K₂.1) :
    chaar K₀ (K₁ ⊔ K₂) = chaar K₀ K₁ + chaar K₀ K₂ 
goal: MeasureTheory.Measure.haar.addCHaar K₀ (K₁ ⊔ K₂) =
  MeasureTheory.Measure.haar.addCHaar K₀ K₁ + MeasureTheory.Measure.haar.addCHaar K₀ K₂

full_name: MeasureTheory.Measure.haar.is_left_invariant_chaar
code: @[to_additive is_left_invariant_addCHaar]
theorem is_left_invariant_chaar {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
    chaar K₀ (K.map _ <| continuous_mul_left g) = chaar K₀ K 
goal: MeasureTheory.Measure.haar.chaar K₀ (TopologicalSpace.Compacts.map (fun b => g * b) ⋯ K) =
  MeasureTheory.Measure.haar.chaar K₀ K

full_name: MeasureTheory.Measure.haar.is_left_invariant_addCHaar
code: @[to_additive is_left_invariant_addCHaar]
theorem is_left_invariant_chaar {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
    chaar K₀ (K.map _ <| continuous_mul_left g) = chaar K₀ K 
goal: MeasureTheory.Measure.haar.addCHaar K₀ (TopologicalSpace.Compacts.map (fun b => g + b) ⋯ K) =
  MeasureTheory.Measure.haar.addCHaar K₀ K

full_name: MeasureTheory.Measure.haar.addHaarContent
code: /-- The function `chaar` interpreted in `ℝ≥0`, as a content -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.haarContent`"]
noncomputable def haarContent (K₀ : PositiveCompacts G) : Content G 
goal: MeasureTheory.Content G

full_name: MeasureTheory.Measure.haar.haarContent
code: /-- The function `chaar` interpreted in `ℝ≥0`, as a content -/
@[to_additive "additive version of `MeasureTheory.Measure.haar.haarContent`"]
noncomputable def haarContent (K₀ : PositiveCompacts G) : Content G 
goal: MeasureTheory.Content G

full_name: MeasureTheory.Measure.haar.haarContent_apply
code: @[to_additive]
theorem haarContent_apply (K₀ : PositiveCompacts G) (K : Compacts G) :
    haarContent K₀ K = show NNReal from ⟨chaar K₀ K, chaar_nonneg _ _⟩ 
goal: (fun s => ↑((MeasureTheory.Measure.haar.haarContent K₀).toFun s)) K =
  ↑(let_fun this := ⟨MeasureTheory.Measure.haar.chaar K₀ K, ⋯⟩;
    this)

full_name: MeasureTheory.Measure.haar.addHaarContent_apply
code: @[to_additive]
theorem haarContent_apply (K₀ : PositiveCompacts G) (K : Compacts G) :
    haarContent K₀ K = show NNReal from ⟨chaar K₀ K, chaar_nonneg _ _⟩ 
goal: (fun s => ↑((MeasureTheory.Measure.haar.addHaarContent K₀).toFun s)) K =
  ↑(let_fun this := ⟨MeasureTheory.Measure.haar.addCHaar K₀ K, ⋯⟩;
    this)

full_name: MeasureTheory.Measure.haar.addHaarContent_self
code: /-- The variant of `chaar_self` for `haarContent` -/
@[to_additive "The variant of `addCHaar_self` for `addHaarContent`."]
theorem haarContent_self {K₀ : PositiveCompacts G} : haarContent K₀ K₀.toCompacts = 1 
goal: (fun s => ↑((MeasureTheory.Measure.haar.addHaarContent K₀).toFun s)) K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.haarContent_self
code: /-- The variant of `chaar_self` for `haarContent` -/
@[to_additive "The variant of `addCHaar_self` for `addHaarContent`."]
theorem haarContent_self {K₀ : PositiveCompacts G} : haarContent K₀ K₀.toCompacts = 1 
goal: (fun s => ↑((MeasureTheory.Measure.haar.haarContent K₀).toFun s)) K₀.toCompacts = 1

full_name: MeasureTheory.Measure.haar.is_left_invariant_haarContent
code: /-- The variant of `is_left_invariant_chaar` for `haarContent` -/
@[to_additive "The variant of `is_left_invariant_addCHaar` for `addHaarContent`"]
theorem is_left_invariant_haarContent {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
    haarContent K₀ (K.map _ <| continuous_mul_left g) = haarContent K₀ K 
goal: (fun s => ↑((MeasureTheory.Measure.haar.haarContent K₀).toFun s)) (TopologicalSpace.Compacts.map (fun b => g * b) ⋯ K) =
  (fun s => ↑((MeasureTheory.Measure.haar.haarContent K₀).toFun s)) K

full_name: MeasureTheory.Measure.haar.is_left_invariant_addHaarContent
code: /-- The variant of `is_left_invariant_chaar` for `haarContent` -/
@[to_additive "The variant of `is_left_invariant_addCHaar` for `addHaarContent`"]
theorem is_left_invariant_haarContent {K₀ : PositiveCompacts G} (g : G) (K : Compacts G) :
    haarContent K₀ (K.map _ <| continuous_mul_left g) = haarContent K₀ K 
goal: (fun s => ↑((MeasureTheory.Measure.haar.addHaarContent K₀).toFun s))
    (TopologicalSpace.Compacts.map (fun b => g + b) ⋯ K) =
  (fun s => ↑((MeasureTheory.Measure.haar.addHaarContent K₀).toFun s)) K

full_name: MeasureTheory.Measure.haar.addHaarContent_outerMeasure_self_pos
code: @[to_additive]
theorem haarContent_outerMeasure_self_pos (K₀ : PositiveCompacts G) :
    0 < (haarContent K₀).outerMeasure K₀ 
goal: 0 < (MeasureTheory.Measure.haar.addHaarContent K₀).outerMeasure ↑K₀

full_name: MeasureTheory.Measure.haar.haarContent_outerMeasure_self_pos
code: @[to_additive]
theorem haarContent_outerMeasure_self_pos (K₀ : PositiveCompacts G) :
    0 < (haarContent K₀).outerMeasure K₀ 
goal: 0 < (MeasureTheory.Measure.haar.haarContent K₀).outerMeasure ↑K₀

full_name: MeasureTheory.Measure.haar.haarContent_outerMeasure_closure_pos
code: @[to_additive]
theorem haarContent_outerMeasure_closure_pos (K₀ : PositiveCompacts G) :
    0 < (haarContent K₀).outerMeasure (closure K₀) 
goal: 0 < (MeasureTheory.Measure.haar.haarContent K₀).outerMeasure (closure ↑K₀)

full_name: MeasureTheory.Measure.haar.addHaarContent_outerMeasure_closure_pos
code: @[to_additive]
theorem haarContent_outerMeasure_closure_pos (K₀ : PositiveCompacts G) :
    0 < (haarContent K₀).outerMeasure (closure K₀) 
goal: 0 < (MeasureTheory.Measure.haar.addHaarContent K₀).outerMeasure (closure ↑K₀)

full_name: MeasureTheory.Measure.addHaarMeasure
code: /-- The Haar measure on the locally compact group `G`, scaled so that `haarMeasure K₀ K₀ = 1`. -/
@[to_additive
"The Haar measure on the locally compact additive group `G`, scaled so that
`addHaarMeasure K₀ K₀ = 1`."]
noncomputable def haarMeasure (K₀ : PositiveCompacts G) : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.haarMeasure
code: /-- The Haar measure on the locally compact group `G`, scaled so that `haarMeasure K₀ K₀ = 1`. -/
@[to_additive
"The Haar measure on the locally compact additive group `G`, scaled so that
`addHaarMeasure K₀ K₀ = 1`."]
noncomputable def haarMeasure (K₀ : PositiveCompacts G) : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.addHaarMeasure_apply
code: @[to_additive]
theorem haarMeasure_apply {K₀ : PositiveCompacts G} {s : Set G} (hs : MeasurableSet s) :
    haarMeasure K₀ s = (haarContent K₀).outerMeasure s / (haarContent K₀).measure K₀ 
goal: (MeasureTheory.Measure.addHaarMeasure K₀) s =
  (MeasureTheory.Measure.haar.addHaarContent K₀).outerMeasure s /
    (MeasureTheory.Measure.haar.addHaarContent K₀).measure ↑K₀

full_name: MeasureTheory.Measure.haarMeasure_apply
code: @[to_additive]
theorem haarMeasure_apply {K₀ : PositiveCompacts G} {s : Set G} (hs : MeasurableSet s) :
    haarMeasure K₀ s = (haarContent K₀).outerMeasure s / (haarContent K₀).measure K₀ 
goal: (MeasureTheory.Measure.haarMeasure K₀) s =
  (MeasureTheory.Measure.haar.haarContent K₀).outerMeasure s / (MeasureTheory.Measure.haar.haarContent K₀).measure ↑K₀

full_name: MeasureTheory.Measure.isAddLeftInvariant_addHaarMeasure
code: @[to_additive]
instance isMulLeftInvariant_haarMeasure (K₀ : PositiveCompacts G) :
    IsMulLeftInvariant (haarMeasure K₀) 
goal: (MeasureTheory.Measure.addHaarMeasure K₀).IsAddLeftInvariant

full_name: MeasureTheory.Measure.isMulLeftInvariant_haarMeasure
code: @[to_additive]
instance isMulLeftInvariant_haarMeasure (K₀ : PositiveCompacts G) :
    IsMulLeftInvariant (haarMeasure K₀) 
goal: (MeasureTheory.Measure.haarMeasure K₀).IsMulLeftInvariant

full_name: MeasureTheory.Measure.addHaarMeasure_self
code: @[to_additive]
theorem haarMeasure_self {K₀ : PositiveCompacts G} : haarMeasure K₀ K₀ = 1 
goal: (MeasureTheory.Measure.addHaarMeasure K₀) ↑K₀ = 1

full_name: MeasureTheory.Measure.haarMeasure_self
code: @[to_additive]
theorem haarMeasure_self {K₀ : PositiveCompacts G} : haarMeasure K₀ K₀ = 1 
goal: (MeasureTheory.Measure.haarMeasure K₀) ↑K₀ = 1

full_name: MeasureTheory.Measure.regular_haarMeasure
code: /-- The Haar measure is regular. -/
@[to_additive "The additive Haar measure is regular."]
instance regular_haarMeasure {K₀ : PositiveCompacts G} : (haarMeasure K₀).Regular 
goal: (MeasureTheory.Measure.haarMeasure K₀).Regular

full_name: MeasureTheory.Measure.regular_addHaarMeasure
code: /-- The Haar measure is regular. -/
@[to_additive "The additive Haar measure is regular."]
instance regular_haarMeasure {K₀ : PositiveCompacts G} : (haarMeasure K₀).Regular 
goal: (MeasureTheory.Measure.addHaarMeasure K₀).Regular

full_name: MeasureTheory.Measure.addHaarMeasure_closure_self
code: @[to_additive]
theorem haarMeasure_closure_self {K₀ : PositiveCompacts G} : haarMeasure K₀ (closure K₀) = 1 
goal: (MeasureTheory.Measure.addHaarMeasure K₀) (closure ↑K₀) = 1

full_name: MeasureTheory.Measure.haarMeasure_closure_self
code: @[to_additive]
theorem haarMeasure_closure_self {K₀ : PositiveCompacts G} : haarMeasure K₀ (closure K₀) = 1 
goal: (MeasureTheory.Measure.haarMeasure K₀) (closure ↑K₀) = 1

full_name: MeasureTheory.Measure.sigmaFinite_addHaarMeasure
code: /-- The Haar measure is sigma-finite in a second countable group. -/
@[to_additive "The additive Haar measure is sigma-finite in a second countable group."]
instance sigmaFinite_haarMeasure [SecondCountableTopology G] {K₀ : PositiveCompacts G} :
    SigmaFinite (haarMeasure K₀) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.addHaarMeasure K₀)

full_name: MeasureTheory.Measure.sigmaFinite_haarMeasure
code: /-- The Haar measure is sigma-finite in a second countable group. -/
@[to_additive "The additive Haar measure is sigma-finite in a second countable group."]
instance sigmaFinite_haarMeasure [SecondCountableTopology G] {K₀ : PositiveCompacts G} :
    SigmaFinite (haarMeasure K₀) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.haarMeasure K₀)

full_name: MeasureTheory.Measure.isHaarMeasure_haarMeasure
code: /-- The Haar measure is a Haar measure, i.e., it is invariant and gives finite mass to compact
sets and positive mass to nonempty open sets. -/
@[to_additive
"The additive Haar measure is an additive Haar measure, i.e., it is invariant and gives finite mass
to compact sets and positive mass to nonempty open sets."]
instance isHaarMeasure_haarMeasure (K₀ : PositiveCompacts G) : IsHaarMeasure (haarMeasure K₀) 
goal: (MeasureTheory.Measure.haarMeasure K₀).IsHaarMeasure

full_name: MeasureTheory.Measure.isAddHaarMeasure_addHaarMeasure
code: /-- The Haar measure is a Haar measure, i.e., it is invariant and gives finite mass to compact
sets and positive mass to nonempty open sets. -/
@[to_additive
"The additive Haar measure is an additive Haar measure, i.e., it is invariant and gives finite mass
to compact sets and positive mass to nonempty open sets."]
instance isHaarMeasure_haarMeasure (K₀ : PositiveCompacts G) : IsHaarMeasure (haarMeasure K₀) 
goal: (MeasureTheory.Measure.addHaarMeasure K₀).IsAddHaarMeasure

full_name: MeasureTheory.Measure.addHaar
code: /-- `haar` is some choice of a Haar measure, on a locally compact group. -/
@[to_additive (attr := reducible)
"`addHaar` is some choice of a Haar measure, on a locally compact additive group."]
noncomputable def haar [LocallyCompactSpace G] : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.haar
code: /-- `haar` is some choice of a Haar measure, on a locally compact group. -/
@[to_additive (attr := reducible)
"`addHaar` is some choice of a Haar measure, on a locally compact additive group."]
noncomputable def haar [LocallyCompactSpace G] : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.sub_mem_nhds_zero_of_addHaar_pos
code: /-- **Steinhaus Theorem** In any locally compact group `G` with an inner regular Haar measure `μ`,
for any measurable set `E` of positive measure, the set `E / E` is a neighbourhood of `1`. -/
@[to_additive
"**Steinhaus Theorem** In any locally compact group `G` with an inner regular Haar measure `μ`,
for any measurable set `E` of positive measure, the set `E - E` is a neighbourhood of `0`."]
theorem div_mem_nhds_one_of_haar_pos (μ : Measure G) [IsHaarMeasure μ] [LocallyCompactSpace G]
    [InnerRegular μ] (E : Set G) (hE : MeasurableSet E) (hEpos : 0 < μ E) :
    E / E ∈ 𝓝 (1 : G) 
goal: E - E ∈ 𝓝 0

full_name: MeasureTheory.Measure.div_mem_nhds_one_of_haar_pos
code: /-- **Steinhaus Theorem** In any locally compact group `G` with an inner regular Haar measure `μ`,
for any measurable set `E` of positive measure, the set `E / E` is a neighbourhood of `1`. -/
@[to_additive
"**Steinhaus Theorem** In any locally compact group `G` with an inner regular Haar measure `μ`,
for any measurable set `E` of positive measure, the set `E - E` is a neighbourhood of `0`."]
theorem div_mem_nhds_one_of_haar_pos (μ : Measure G) [IsHaarMeasure μ] [LocallyCompactSpace G]
    [InnerRegular μ] (E : Set G) (hE : MeasurableSet E) (hEpos : 0 < μ E) :
    E / E ∈ 𝓝 (1 : G) 
goal: E / E ∈ 𝓝 1

full_name: MeasureTheory.Measure.haarMeasure_unique
code: /-- **Uniqueness of left-invariant measures**: In a second-countable locally compact group, any
  σ-finite left-invariant measure is a scalar multiple of the Haar measure.
  This is slightly weaker than assuming that `μ` is a Haar measure (in particular we don't require
  `μ ≠ 0`).
  See also `isMulLeftInvariant_eq_smul_of_regular`
  for a statement not assuming second-countability. -/
@[to_additive
"**Uniqueness of left-invariant measures**: In a second-countable locally compact additive group,
  any σ-finite left-invariant measure is a scalar multiple of the additive Haar measure.
  This is slightly weaker than assuming that `μ` is a additive Haar measure (in particular we don't
  require `μ ≠ 0`).
  See also `isAddLeftInvariant_eq_smul_of_regular`
  for a statement not assuming second-countability."]
theorem haarMeasure_unique (μ : Measure G) [SigmaFinite μ] [IsMulLeftInvariant μ]
    (K₀ : PositiveCompacts G) : μ = μ K₀ • haarMeasure K₀ 
goal: μ = μ ↑K₀ • MeasureTheory.Measure.haarMeasure K₀

full_name: MeasureTheory.Measure.addHaarMeasure_unique
code: /-- **Uniqueness of left-invariant measures**: In a second-countable locally compact group, any
  σ-finite left-invariant measure is a scalar multiple of the Haar measure.
  This is slightly weaker than assuming that `μ` is a Haar measure (in particular we don't require
  `μ ≠ 0`).
  See also `isMulLeftInvariant_eq_smul_of_regular`
  for a statement not assuming second-countability. -/
@[to_additive
"**Uniqueness of left-invariant measures**: In a second-countable locally compact additive group,
  any σ-finite left-invariant measure is a scalar multiple of the additive Haar measure.
  This is slightly weaker than assuming that `μ` is a additive Haar measure (in particular we don't
  require `μ ≠ 0`).
  See also `isAddLeftInvariant_eq_smul_of_regular`
  for a statement not assuming second-countability."]
theorem haarMeasure_unique (μ : Measure G) [SigmaFinite μ] [IsMulLeftInvariant μ]
    (K₀ : PositiveCompacts G) : μ = μ K₀ • haarMeasure K₀ 
goal: μ = μ ↑K₀ • MeasureTheory.Measure.addHaarMeasure K₀

full_name: MeasureTheory.Measure.addHaarMeasure_eq_iff
code: /-- Let `μ` be a σ-finite left invariant measure on `G`. Then `μ` is equal to the Haar measure
defined by `K₀` iff `μ K₀ = 1`. -/
@[to_additive]
theorem haarMeasure_eq_iff (K₀ : PositiveCompacts G) (μ : Measure G) [SigmaFinite μ]
    [IsMulLeftInvariant μ] :
    haarMeasure K₀ = μ ↔ μ K₀ = 1 
goal: MeasureTheory.Measure.addHaarMeasure K₀ = μ ↔ μ ↑K₀ = 1

full_name: MeasureTheory.Measure.haarMeasure_eq_iff
code: /-- Let `μ` be a σ-finite left invariant measure on `G`. Then `μ` is equal to the Haar measure
defined by `K₀` iff `μ K₀ = 1`. -/
@[to_additive]
theorem haarMeasure_eq_iff (K₀ : PositiveCompacts G) (μ : Measure G) [SigmaFinite μ]
    [IsMulLeftInvariant μ] :
    haarMeasure K₀ = μ ↔ μ K₀ = 1 
goal: MeasureTheory.Measure.haarMeasure K₀ = μ ↔ μ ↑K₀ = 1

full_name: MeasureTheory.Measure.regular_of_isAddLeftInvariant
code: /-- To show that an invariant σ-finite measure is regular it is sufficient to show that it is finite
  on some compact set with non-empty interior. -/
@[to_additive
"To show that an invariant σ-finite measure is regular it is sufficient to show that it is finite on
some compact set with non-empty interior."]
theorem regular_of_isMulLeftInvariant {μ : Measure G} [SigmaFinite μ] [IsMulLeftInvariant μ]
    {K : Set G} (hK : IsCompact K) (h2K : (interior K).Nonempty) (hμK : μ K ≠ ∞) : Regular μ 
goal: μ.Regular

full_name: MeasureTheory.Measure.regular_of_isMulLeftInvariant
code: /-- To show that an invariant σ-finite measure is regular it is sufficient to show that it is finite
  on some compact set with non-empty interior. -/
@[to_additive
"To show that an invariant σ-finite measure is regular it is sufficient to show that it is finite on
some compact set with non-empty interior."]
theorem regular_of_isMulLeftInvariant {μ : Measure G} [SigmaFinite μ] [IsMulLeftInvariant μ]
    {K : Set G} (hK : IsCompact K) (h2K : (interior K).Nonempty) (hμK : μ K ≠ ∞) : Regular μ 
goal: μ.Regular