File: Mathlib/MeasureTheory/Group/Measure.lean

full_name: MeasureTheory.Measure.IsAddLeftInvariant.map_add_left_eq_self
code: /-- A measure `μ` on a measurable additive group is left invariant
  if the measure of left translations of a set are equal to the measure of the set itself. -/
class IsAddLeftInvariant [Add G] (μ : Measure G) : Prop where
  map_add_left_eq_self : ∀ g : G, map (g + ·) μ = μ
goal: MeasureTheory.Measure.map (fun x => g + x) μ = μ

full_name: MeasureTheory.Measure.IsAddLeftInvariant
code: /-- A measure `μ` on a measurable additive group is left invariant
  if the measure of left translations of a set are equal to the measure of the set itself. -/
class IsAddLeftInvariant [Add G] (μ : Measure G) : Prop where
  map_add_left_eq_self : ∀ g : G, map (g + ·) μ = μ
goal: Prop

full_name: MeasureTheory.Measure.IsMulLeftInvariant
code: /-- A measure `μ` on a measurable group is left invariant
  if the measure of left translations of a set are equal to the measure of the set itself. -/
@[to_additive existing]
class IsMulLeftInvariant [Mul G] (μ : Measure G) : Prop where
  map_mul_left_eq_self : ∀ g : G, map (g * ·) μ = μ
goal: Prop

full_name: MeasureTheory.Measure.IsMulLeftInvariant.map_mul_left_eq_self
code: /-- A measure `μ` on a measurable group is left invariant
  if the measure of left translations of a set are equal to the measure of the set itself. -/
@[to_additive existing]
class IsMulLeftInvariant [Mul G] (μ : Measure G) : Prop where
  map_mul_left_eq_self : ∀ g : G, map (g * ·) μ = μ
goal: MeasureTheory.Measure.map (fun x => g * x) μ = μ

full_name: MeasureTheory.Measure.IsAddRightInvariant
code: /-- A measure `μ` on a measurable additive group is right invariant
  if the measure of right translations of a set are equal to the measure of the set itself. -/
class IsAddRightInvariant [Add G] (μ : Measure G) : Prop where
  map_add_right_eq_self : ∀ g : G, map (· + g) μ = μ
goal: Prop

full_name: MeasureTheory.Measure.IsAddRightInvariant.map_add_right_eq_self
code: /-- A measure `μ` on a measurable additive group is right invariant
  if the measure of right translations of a set are equal to the measure of the set itself. -/
class IsAddRightInvariant [Add G] (μ : Measure G) : Prop where
  map_add_right_eq_self : ∀ g : G, map (· + g) μ = μ
goal: MeasureTheory.Measure.map (fun x => x + g) μ = μ

full_name: MeasureTheory.Measure.IsMulRightInvariant.map_mul_right_eq_self
code: /-- A measure `μ` on a measurable group is right invariant
  if the measure of right translations of a set are equal to the measure of the set itself. -/
@[to_additive existing]
class IsMulRightInvariant [Mul G] (μ : Measure G) : Prop where
  map_mul_right_eq_self : ∀ g : G, map (· * g) μ = μ
goal: MeasureTheory.Measure.map (fun x => x * g) μ = μ

full_name: MeasureTheory.Measure.IsMulRightInvariant
code: /-- A measure `μ` on a measurable group is right invariant
  if the measure of right translations of a set are equal to the measure of the set itself. -/
@[to_additive existing]
class IsMulRightInvariant [Mul G] (μ : Measure G) : Prop where
  map_mul_right_eq_self : ∀ g : G, map (· * g) μ = μ
goal: Prop

full_name: MeasureTheory.map_add_left_eq_self
code: @[to_additive]
theorem map_mul_left_eq_self (μ : Measure G) [IsMulLeftInvariant μ] (g : G) :
    map (g * ·) μ = μ 
goal: MeasureTheory.Measure.map (fun x => g + x) μ = μ

full_name: MeasureTheory.map_mul_left_eq_self
code: @[to_additive]
theorem map_mul_left_eq_self (μ : Measure G) [IsMulLeftInvariant μ] (g : G) :
    map (g * ·) μ = μ 
goal: MeasureTheory.Measure.map (fun x => g * x) μ = μ

full_name: MeasureTheory.map_add_right_eq_self
code: @[to_additive]
theorem map_mul_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) : map (· * g) μ = μ 
goal: MeasureTheory.Measure.map (fun x => x + g) μ = μ

full_name: MeasureTheory.map_mul_right_eq_self
code: @[to_additive]
theorem map_mul_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) : map (· * g) μ = μ 
goal: MeasureTheory.Measure.map (fun x => x * g) μ = μ

full_name: MeasureTheory.isAddLeftInvariant_smul
code: @[to_additive MeasureTheory.isAddLeftInvariant_smul]
instance isMulLeftInvariant_smul [IsMulLeftInvariant μ] (c : ℝ≥0∞) : IsMulLeftInvariant (c • μ) 
goal: (c • μ).IsAddLeftInvariant

full_name: MeasureTheory.isMulLeftInvariant_smul
code: @[to_additive MeasureTheory.isAddLeftInvariant_smul]
instance isMulLeftInvariant_smul [IsMulLeftInvariant μ] (c : ℝ≥0∞) : IsMulLeftInvariant (c • μ) 
goal: (c • μ).IsMulLeftInvariant

full_name: MeasureTheory.isMulRightInvariant_smul
code: @[to_additive MeasureTheory.isAddRightInvariant_smul]
instance isMulRightInvariant_smul [IsMulRightInvariant μ] (c : ℝ≥0∞) :
    IsMulRightInvariant (c • μ) 
goal: (c • μ).IsMulRightInvariant

full_name: MeasureTheory.isAddRightInvariant_smul
code: @[to_additive MeasureTheory.isAddRightInvariant_smul]
instance isMulRightInvariant_smul [IsMulRightInvariant μ] (c : ℝ≥0∞) :
    IsMulRightInvariant (c • μ) 
goal: (c • μ).IsAddRightInvariant

full_name: MeasureTheory.isMulLeftInvariant_smul_nnreal
code: @[to_additive MeasureTheory.isAddLeftInvariant_smul_nnreal]
instance isMulLeftInvariant_smul_nnreal [IsMulLeftInvariant μ] (c : ℝ≥0) :
    IsMulLeftInvariant (c • μ) 
goal: (c • μ).IsMulLeftInvariant

full_name: MeasureTheory.isAddLeftInvariant_smul_nnreal
code: @[to_additive MeasureTheory.isAddLeftInvariant_smul_nnreal]
instance isMulLeftInvariant_smul_nnreal [IsMulLeftInvariant μ] (c : ℝ≥0) :
    IsMulLeftInvariant (c • μ) 
goal: (c • μ).IsAddLeftInvariant

full_name: MeasureTheory.isMulRightInvariant_smul_nnreal
code: @[to_additive MeasureTheory.isAddRightInvariant_smul_nnreal]
instance isMulRightInvariant_smul_nnreal [IsMulRightInvariant μ] (c : ℝ≥0) :
    IsMulRightInvariant (c • μ) 
goal: (c • μ).IsMulRightInvariant

full_name: MeasureTheory.isAddRightInvariant_smul_nnreal
code: @[to_additive MeasureTheory.isAddRightInvariant_smul_nnreal]
instance isMulRightInvariant_smul_nnreal [IsMulRightInvariant μ] (c : ℝ≥0) :
    IsMulRightInvariant (c • μ) 
goal: (c • μ).IsAddRightInvariant

full_name: MeasureTheory.IsMulLeftInvariant.vaddInvariantMeasure
code: @[to_additive]
instance IsMulLeftInvariant.smulInvariantMeasure [IsMulLeftInvariant μ] :
    SMulInvariantMeasure G G μ 
goal: MeasureTheory.VAddInvariantMeasure G G μ

full_name: MeasureTheory.IsMulLeftInvariant.smulInvariantMeasure
code: @[to_additive]
instance IsMulLeftInvariant.smulInvariantMeasure [IsMulLeftInvariant μ] :
    SMulInvariantMeasure G G μ 
goal: MeasureTheory.SMulInvariantMeasure G G μ

full_name: MeasureTheory.IsMulRightInvariant.toVAddInvariantMeasure_op
code: @[to_additive]
instance IsMulRightInvariant.toSMulInvariantMeasure_op [μ.IsMulRightInvariant] :
    SMulInvariantMeasure Gᵐᵒᵖ G μ 
goal: MeasureTheory.VAddInvariantMeasure Gᵃᵒᵖ G μ

full_name: MeasureTheory.IsMulRightInvariant.toSMulInvariantMeasure_op
code: @[to_additive]
instance IsMulRightInvariant.toSMulInvariantMeasure_op [μ.IsMulRightInvariant] :
    SMulInvariantMeasure Gᵐᵒᵖ G μ 
goal: MeasureTheory.SMulInvariantMeasure Gᵐᵒᵖ G μ

full_name: MeasureTheory.measurePreserving_mul_left
code: @[to_additive]
theorem measurePreserving_mul_left (μ : Measure G) [IsMulLeftInvariant μ] (g : G) :
    MeasurePreserving (g * ·) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => g * x) μ μ

full_name: MeasureTheory.measurePreserving_add_left
code: @[to_additive]
theorem measurePreserving_mul_left (μ : Measure G) [IsMulLeftInvariant μ] (g : G) :
    MeasurePreserving (g * ·) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => g + x) μ μ

full_name: MeasureTheory.MeasurePreserving.mul_left
code: @[to_additive]
theorem MeasurePreserving.mul_left (μ : Measure G) [IsMulLeftInvariant μ] (g : G) {X : Type*}
    [MeasurableSpace X] {μ' : Measure X} {f : X → G} (hf : MeasurePreserving f μ' μ) :
    MeasurePreserving (fun x => g * f x) μ' μ 
goal: MeasureTheory.MeasurePreserving (fun x => g * f x) μ' μ

full_name: MeasureTheory.MeasurePreserving.add_left
code: @[to_additive]
theorem MeasurePreserving.mul_left (μ : Measure G) [IsMulLeftInvariant μ] (g : G) {X : Type*}
    [MeasurableSpace X] {μ' : Measure X} {f : X → G} (hf : MeasurePreserving f μ' μ) :
    MeasurePreserving (fun x => g * f x) μ' μ 
goal: MeasureTheory.MeasurePreserving (fun x => g + f x) μ' μ

full_name: MeasureTheory.measurePreserving_add_right
code: @[to_additive]
theorem measurePreserving_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· * g) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => x + g) μ μ

full_name: MeasureTheory.measurePreserving_mul_right
code: @[to_additive]
theorem measurePreserving_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· * g) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => x * g) μ μ

full_name: MeasureTheory.MeasurePreserving.mul_right
code: @[to_additive]
theorem MeasurePreserving.mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) {X : Type*}
    [MeasurableSpace X] {μ' : Measure X} {f : X → G} (hf : MeasurePreserving f μ' μ) :
    MeasurePreserving (fun x => f x * g) μ' μ 
goal: MeasureTheory.MeasurePreserving (fun x => f x * g) μ' μ

full_name: MeasureTheory.MeasurePreserving.add_right
code: @[to_additive]
theorem MeasurePreserving.mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) {X : Type*}
    [MeasurableSpace X] {μ' : Measure X} {f : X → G} (hf : MeasurePreserving f μ' μ) :
    MeasurePreserving (fun x => f x * g) μ' μ 
goal: MeasureTheory.MeasurePreserving (fun x => f x + g) μ' μ

full_name: MeasureTheory.Subgroup.smulInvariantMeasure
code: @[to_additive]
instance Subgroup.smulInvariantMeasure {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace α]
    {μ : Measure α} [SMulInvariantMeasure G α μ] (H : Subgroup G) : SMulInvariantMeasure H α μ 
goal: MeasureTheory.SMulInvariantMeasure (↥H) α μ

full_name: MeasureTheory.Subgroup.vaddInvariantMeasure
code: @[to_additive]
instance Subgroup.smulInvariantMeasure {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace α]
    {μ : Measure α} [SMulInvariantMeasure G α μ] (H : Subgroup G) : SMulInvariantMeasure H α μ 
goal: MeasureTheory.VAddInvariantMeasure (↥H) α μ

full_name: MeasureTheory.forall_measure_preimage_add_iff
code: /-- An alternative way to prove that `μ` is left invariant under multiplication. -/
@[to_additive " An alternative way to prove that `μ` is left invariant under addition. "]
theorem forall_measure_preimage_mul_iff (μ : Measure G) :
    (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => g * h) ⁻¹' A) = μ A) ↔
      IsMulLeftInvariant μ 
goal: (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => g + h) ⁻¹' A) = μ A) ↔ μ.IsAddLeftInvariant

full_name: MeasureTheory.forall_measure_preimage_mul_iff
code: /-- An alternative way to prove that `μ` is left invariant under multiplication. -/
@[to_additive " An alternative way to prove that `μ` is left invariant under addition. "]
theorem forall_measure_preimage_mul_iff (μ : Measure G) :
    (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => g * h) ⁻¹' A) = μ A) ↔
      IsMulLeftInvariant μ 
goal: (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => g * h) ⁻¹' A) = μ A) ↔ μ.IsMulLeftInvariant

full_name: MeasureTheory.forall_measure_preimage_add_right_iff
code: /-- An alternative way to prove that `μ` is right invariant under multiplication. -/
@[to_additive " An alternative way to prove that `μ` is right invariant under addition. "]
theorem forall_measure_preimage_mul_right_iff (μ : Measure G) :
    (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔
      IsMulRightInvariant μ 
goal: (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h + g) ⁻¹' A) = μ A) ↔ μ.IsAddRightInvariant

full_name: MeasureTheory.forall_measure_preimage_mul_right_iff
code: /-- An alternative way to prove that `μ` is right invariant under multiplication. -/
@[to_additive " An alternative way to prove that `μ` is right invariant under addition. "]
theorem forall_measure_preimage_mul_right_iff (μ : Measure G) :
    (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔
      IsMulRightInvariant μ 
goal: (∀ (g : G) (A : Set G), MeasurableSet A → μ ((fun h => h * g) ⁻¹' A) = μ A) ↔ μ.IsMulRightInvariant

full_name: MeasureTheory.Measure.prod.instIsMulLeftInvariant
code: @[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) 
goal: (μ.prod ν).IsMulLeftInvariant

full_name: MeasureTheory.Measure.prod.instIsAddLeftInvariant
code: @[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) 
goal: (μ.prod ν).IsAddLeftInvariant

full_name: MeasureTheory.Measure.prod.instIsAddRightInvariant
code: @[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) 
goal: (μ.prod ν).IsAddRightInvariant

full_name: MeasureTheory.Measure.prod.instIsMulRightInvariant
code: @[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) 
goal: (μ.prod ν).IsMulRightInvariant

full_name: MeasureTheory.isAddLeftInvariant_map
code: @[to_additive]
theorem isMulLeftInvariant_map {H : Type*} [MeasurableSpace H] [Mul H] [MeasurableMul H]
    [IsMulLeftInvariant μ] (f : G →ₙ* H) (hf : Measurable f) (h_surj : Surjective f) :
    IsMulLeftInvariant (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsAddLeftInvariant

full_name: MeasureTheory.isMulLeftInvariant_map
code: @[to_additive]
theorem isMulLeftInvariant_map {H : Type*} [MeasurableSpace H] [Mul H] [MeasurableMul H]
    [IsMulLeftInvariant μ] (f : G →ₙ* H) (hf : Measurable f) (h_surj : Surjective f) :
    IsMulLeftInvariant (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsMulLeftInvariant

full_name: MeasureTheory.isMulLeftInvariant_map_smul
code: /-- The image of a left invariant measure under a left action is left invariant, assuming that
the action preserves multiplication. -/
@[to_additive "The image of a left invariant measure under a left additive action is left invariant,
assuming that the action preserves addition."]
theorem isMulLeftInvariant_map_smul
    {α} [SMul α G] [SMulCommClass α G G] [MeasurableSpace α] [MeasurableSMul α G]
    [IsMulLeftInvariant μ] (a : α) :
    IsMulLeftInvariant (map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a • x) μ).IsMulLeftInvariant

full_name: MeasureTheory.isAddLeftInvariant_map_vadd
code: /-- The image of a left invariant measure under a left action is left invariant, assuming that
the action preserves multiplication. -/
@[to_additive "The image of a left invariant measure under a left additive action is left invariant,
assuming that the action preserves addition."]
theorem isMulLeftInvariant_map_smul
    {α} [SMul α G] [SMulCommClass α G G] [MeasurableSpace α] [MeasurableSMul α G]
    [IsMulLeftInvariant μ] (a : α) :
    IsMulLeftInvariant (map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a +ᵥ x) μ).IsAddLeftInvariant

full_name: MeasureTheory.isAddRightInvariant_map_vadd
code: /-- The image of a right invariant measure under a left action is right invariant, assuming that
the action preserves multiplication. -/
@[to_additive "The image of a right invariant measure under a left additive action is right
 invariant, assuming that the action preserves addition."]
theorem isMulRightInvariant_map_smul
    {α} [SMul α G] [SMulCommClass α Gᵐᵒᵖ G] [MeasurableSpace α] [MeasurableSMul α G]
    [IsMulRightInvariant μ] (a : α) :
    IsMulRightInvariant (map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a +ᵥ x) μ).IsAddRightInvariant

full_name: MeasureTheory.isMulRightInvariant_map_smul
code: /-- The image of a right invariant measure under a left action is right invariant, assuming that
the action preserves multiplication. -/
@[to_additive "The image of a right invariant measure under a left additive action is right
 invariant, assuming that the action preserves addition."]
theorem isMulRightInvariant_map_smul
    {α} [SMul α G] [SMulCommClass α Gᵐᵒᵖ G] [MeasurableSpace α] [MeasurableSMul α G]
    [IsMulRightInvariant μ] (a : α) :
    IsMulRightInvariant (map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a • x) μ).IsMulRightInvariant

full_name: MeasureTheory.isMulLeftInvariant_map_mul_right
code: /-- The image of a left invariant measure under right multiplication is left invariant. -/
@[to_additive isMulLeftInvariant_map_add_right
"The image of a left invariant measure under right addition is left invariant."]
instance isMulLeftInvariant_map_mul_right [IsMulLeftInvariant μ] (g : G) :
    IsMulLeftInvariant (map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x * g) μ).IsMulLeftInvariant

full_name: MeasureTheory.isMulLeftInvariant_map_add_right
code: /-- The image of a left invariant measure under right multiplication is left invariant. -/
@[to_additive isMulLeftInvariant_map_add_right
"The image of a left invariant measure under right addition is left invariant."]
instance isMulLeftInvariant_map_mul_right [IsMulLeftInvariant μ] (g : G) :
    IsMulLeftInvariant (map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x + g) μ).IsAddLeftInvariant

full_name: MeasureTheory.isMulRightInvariant_map_mul_left
code: /-- The image of a right invariant measure under left multiplication is right invariant. -/
@[to_additive isMulRightInvariant_map_add_left
"The image of a right invariant measure under left addition is right invariant."]
instance isMulRightInvariant_map_mul_left [IsMulRightInvariant μ] (g : G) :
    IsMulRightInvariant (map (g * ·) μ) 
goal: (MeasureTheory.Measure.map (fun x => g * x) μ).IsMulRightInvariant

full_name: MeasureTheory.isMulRightInvariant_map_add_left
code: /-- The image of a right invariant measure under left multiplication is right invariant. -/
@[to_additive isMulRightInvariant_map_add_left
"The image of a right invariant measure under left addition is right invariant."]
instance isMulRightInvariant_map_mul_left [IsMulRightInvariant μ] (g : G) :
    IsMulRightInvariant (map (g * ·) μ) 
goal: (MeasureTheory.Measure.map (fun x => g + x) μ).IsAddRightInvariant

full_name: MeasureTheory.map_div_right_eq_self
code: @[to_additive]
theorem map_div_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    map (· / g) μ = μ 
goal: MeasureTheory.Measure.map (fun x => x / g) μ = μ

full_name: MeasureTheory.map_sub_right_eq_self
code: @[to_additive]
theorem map_div_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    map (· / g) μ = μ 
goal: MeasureTheory.Measure.map (fun x => x - g) μ = μ

full_name: MeasureTheory.measurePreserving_sub_right
code: @[to_additive]
theorem measurePreserving_div_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· / g) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => x - g) μ μ

full_name: MeasureTheory.measurePreserving_div_right
code: @[to_additive]
theorem measurePreserving_div_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· / g) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => x / g) μ μ

full_name: MeasureTheory.measure_preimage_add
code: /-- We shorten this from `measure_preimage_mul_left`, since left invariant is the preferred option
  for measures in this formalization. -/
@[to_additive (attr := simp)
"We shorten this from `measure_preimage_add_left`, since left invariant is the preferred option for
measures in this formalization."]
theorem measure_preimage_mul (μ : Measure G) [IsMulLeftInvariant μ] (g : G) (A : Set G) :
    μ ((fun h => g * h) ⁻¹' A) = μ A 
goal: μ ((fun h => g + h) ⁻¹' A) = μ A

full_name: MeasureTheory.measure_preimage_mul
code: /-- We shorten this from `measure_preimage_mul_left`, since left invariant is the preferred option
  for measures in this formalization. -/
@[to_additive (attr := simp)
"We shorten this from `measure_preimage_add_left`, since left invariant is the preferred option for
measures in this formalization."]
theorem measure_preimage_mul (μ : Measure G) [IsMulLeftInvariant μ] (g : G) (A : Set G) :
    μ ((fun h => g * h) ⁻¹' A) = μ A 
goal: μ ((fun h => g * h) ⁻¹' A) = μ A

full_name: MeasureTheory.measure_preimage_mul_right
code: @[to_additive (attr := simp)]
theorem measure_preimage_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) (A : Set G) :
    μ ((fun h => h * g) ⁻¹' A) = μ A 
goal: μ ((fun h => h * g) ⁻¹' A) = μ A

full_name: MeasureTheory.measure_preimage_add_right
code: @[to_additive (attr := simp)]
theorem measure_preimage_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) (A : Set G) :
    μ ((fun h => h * g) ⁻¹' A) = μ A 
goal: μ ((fun h => h + g) ⁻¹' A) = μ A

full_name: MeasureTheory.map_mul_left_ae
code: @[to_additive]
theorem map_mul_left_ae (μ : Measure G) [IsMulLeftInvariant μ] (x : G) :
    Filter.map (fun h => x * h) (ae μ) = ae μ 
goal: Filter.map (fun h => x * h) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.map_add_left_ae
code: @[to_additive]
theorem map_mul_left_ae (μ : Measure G) [IsMulLeftInvariant μ] (x : G) :
    Filter.map (fun h => x * h) (ae μ) = ae μ 
goal: Filter.map (fun h => x + h) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.map_add_right_ae
code: @[to_additive]
theorem map_mul_right_ae (μ : Measure G) [IsMulRightInvariant μ] (x : G) :
    Filter.map (fun h => h * x) (ae μ) = ae μ 
goal: Filter.map (fun h => h + x) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.map_mul_right_ae
code: @[to_additive]
theorem map_mul_right_ae (μ : Measure G) [IsMulRightInvariant μ] (x : G) :
    Filter.map (fun h => h * x) (ae μ) = ae μ 
goal: Filter.map (fun h => h * x) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.map_div_right_ae
code: @[to_additive]
theorem map_div_right_ae (μ : Measure G) [IsMulRightInvariant μ] (x : G) :
    Filter.map (fun t => t / x) (ae μ) = ae μ 
goal: Filter.map (fun t => t / x) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.map_sub_right_ae
code: @[to_additive]
theorem map_div_right_ae (μ : Measure G) [IsMulRightInvariant μ] (x : G) :
    Filter.map (fun t => t / x) (ae μ) = ae μ 
goal: Filter.map (fun t => t - x) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.eventually_add_left_iff
code: @[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (t + x)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.eventually_mul_left_iff
code: @[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (t * x)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.eventually_add_right_iff
code: @[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (x + t)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.eventually_mul_right_iff
code: @[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.eventually_sub_right_iff
code: @[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (x - t)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.eventually_div_right_iff
code: @[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : G) ∂μ, p (x / t)) ↔ ∀ᵐ (x : G) ∂μ, p x

full_name: MeasureTheory.Measure.inv
code: /-- The measure `A ↦ μ (A⁻¹)`, where `A⁻¹` is the pointwise inverse of `A`. -/
@[to_additive "The measure `A ↦ μ (- A)`, where `- A` is the pointwise negation of `A`."]
protected noncomputable def inv [Inv G] (μ : Measure G) : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.neg
code: /-- The measure `A ↦ μ (A⁻¹)`, where `A⁻¹` is the pointwise inverse of `A`. -/
@[to_additive "The measure `A ↦ μ (- A)`, where `- A` is the pointwise negation of `A`."]
protected noncomputable def inv [Inv G] (μ : Measure G) : Measure G 
goal: MeasureTheory.Measure G

full_name: MeasureTheory.Measure.IsNegInvariant.neg_eq_self
code: /-- A measure is invariant under negation if `- μ = μ`. Equivalently, this means that for all
measurable `A` we have `μ (- A) = μ A`, where `- A` is the pointwise negation of `A`. -/
class IsNegInvariant [Neg G] (μ : Measure G) : Prop where
  neg_eq_self : μ.neg = μ
goal: μ.neg = μ

full_name: MeasureTheory.Measure.IsNegInvariant
code: /-- A measure is invariant under negation if `- μ = μ`. Equivalently, this means that for all
measurable `A` we have `μ (- A) = μ A`, where `- A` is the pointwise negation of `A`. -/
class IsNegInvariant [Neg G] (μ : Measure G) : Prop where
  neg_eq_self : μ.neg = μ
goal: Prop

full_name: MeasureTheory.Measure.IsInvInvariant.inv_eq_self
code: /-- A measure is invariant under inversion if `μ⁻¹ = μ`. Equivalently, this means that for all
measurable `A` we have `μ (A⁻¹) = μ A`, where `A⁻¹` is the pointwise inverse of `A`. -/
@[to_additive existing]
class IsInvInvariant [Inv G] (μ : Measure G) : Prop where
  inv_eq_self : μ.inv = μ
goal: μ.inv = μ

full_name: MeasureTheory.Measure.IsInvInvariant
code: /-- A measure is invariant under inversion if `μ⁻¹ = μ`. Equivalently, this means that for all
measurable `A` we have `μ (A⁻¹) = μ A`, where `A⁻¹` is the pointwise inverse of `A`. -/
@[to_additive existing]
class IsInvInvariant [Inv G] (μ : Measure G) : Prop where
  inv_eq_self : μ.inv = μ
goal: Prop

full_name: MeasureTheory.Measure.neg_def
code: @[to_additive]
theorem inv_def (μ : Measure G) : μ.inv = Measure.map inv μ 
goal: μ.neg = MeasureTheory.Measure.map Neg.neg μ

full_name: MeasureTheory.Measure.inv_def
code: @[to_additive]
theorem inv_def (μ : Measure G) : μ.inv = Measure.map inv μ 
goal: μ.inv = MeasureTheory.Measure.map Inv.inv μ

full_name: MeasureTheory.Measure.inv_eq_self
code: @[to_additive (attr := simp)]
theorem inv_eq_self (μ : Measure G) [IsInvInvariant μ] : μ.inv = μ 
goal: μ.inv = μ

full_name: MeasureTheory.Measure.neg_eq_self
code: @[to_additive (attr := simp)]
theorem inv_eq_self (μ : Measure G) [IsInvInvariant μ] : μ.inv = μ 
goal: μ.neg = μ

full_name: MeasureTheory.Measure.map_inv_eq_self
code: @[to_additive (attr := simp)]
theorem map_inv_eq_self (μ : Measure G) [IsInvInvariant μ] : map Inv.inv μ = μ 
goal: MeasureTheory.Measure.map Inv.inv μ = μ

full_name: MeasureTheory.Measure.map_neg_eq_self
code: @[to_additive (attr := simp)]
theorem map_inv_eq_self (μ : Measure G) [IsInvInvariant μ] : map Inv.inv μ = μ 
goal: MeasureTheory.Measure.map Neg.neg μ = μ

full_name: MeasureTheory.Measure.measurePreserving_neg
code: @[to_additive]
theorem measurePreserving_inv (μ : Measure G) [IsInvInvariant μ] : MeasurePreserving Inv.inv μ μ 
goal: MeasureTheory.MeasurePreserving Neg.neg μ μ

full_name: MeasureTheory.Measure.measurePreserving_inv
code: @[to_additive]
theorem measurePreserving_inv (μ : Measure G) [IsInvInvariant μ] : MeasurePreserving Inv.inv μ μ 
goal: MeasureTheory.MeasurePreserving Inv.inv μ μ

full_name: MeasureTheory.Measure.neg.instSFinite
code: @[to_additive]
instance inv.instSFinite (μ : Measure G) [SFinite μ] : SFinite μ.inv 
goal: MeasureTheory.SFinite μ.neg

full_name: MeasureTheory.Measure.inv.instSFinite
code: @[to_additive]
instance inv.instSFinite (μ : Measure G) [SFinite μ] : SFinite μ.inv 
goal: MeasureTheory.SFinite μ.inv

full_name: MeasureTheory.Measure.neg_apply
code: @[to_additive (attr := simp)]
theorem inv_apply (μ : Measure G) (s : Set G) : μ.inv s = μ s⁻¹ 
goal: μ.neg s = μ (-s)

full_name: MeasureTheory.Measure.inv_apply
code: @[to_additive (attr := simp)]
theorem inv_apply (μ : Measure G) (s : Set G) : μ.inv s = μ s⁻¹ 
goal: μ.inv s = μ s⁻¹

full_name: MeasureTheory.Measure.neg_neg
code: @[to_additive (attr := simp)]
protected theorem inv_inv (μ : Measure G) : μ.inv.inv = μ 
goal: μ.neg.neg = μ

full_name: MeasureTheory.Measure.inv_inv
code: @[to_additive (attr := simp)]
protected theorem inv_inv (μ : Measure G) : μ.inv.inv = μ 
goal: μ.inv.inv = μ

full_name: MeasureTheory.Measure.measure_neg
code: @[to_additive (attr := simp)]
theorem measure_inv (μ : Measure G) [IsInvInvariant μ] (A : Set G) : μ A⁻¹ = μ A 
goal: μ (-A) = μ A

full_name: MeasureTheory.Measure.measure_inv
code: @[to_additive (attr := simp)]
theorem measure_inv (μ : Measure G) [IsInvInvariant μ] (A : Set G) : μ A⁻¹ = μ A 
goal: μ A⁻¹ = μ A

full_name: MeasureTheory.Measure.measure_preimage_neg
code: @[to_additive]
theorem measure_preimage_inv (μ : Measure G) [IsInvInvariant μ] (A : Set G) :
    μ (Inv.inv ⁻¹' A) = μ A 
goal: μ (Neg.neg ⁻¹' A) = μ A

full_name: MeasureTheory.Measure.measure_preimage_inv
code: @[to_additive]
theorem measure_preimage_inv (μ : Measure G) [IsInvInvariant μ] (A : Set G) :
    μ (Inv.inv ⁻¹' A) = μ A 
goal: μ (Inv.inv ⁻¹' A) = μ A

full_name: MeasureTheory.Measure.neg.instSigmaFinite
code: @[to_additive]
instance inv.instSigmaFinite (μ : Measure G) [SigmaFinite μ] : SigmaFinite μ.inv 
goal: MeasureTheory.SigmaFinite μ.neg

full_name: MeasureTheory.Measure.inv.instSigmaFinite
code: @[to_additive]
instance inv.instSigmaFinite (μ : Measure G) [SigmaFinite μ] : SigmaFinite μ.inv 
goal: MeasureTheory.SigmaFinite μ.inv

full_name: MeasureTheory.Measure.inv.instIsMulRightInvariant
code: @[to_additive]
instance inv.instIsMulRightInvariant [IsMulLeftInvariant μ] : IsMulRightInvariant μ.inv 
goal: μ.inv.IsMulRightInvariant

full_name: MeasureTheory.Measure.neg.instIsAddRightInvariant
code: @[to_additive]
instance inv.instIsMulRightInvariant [IsMulLeftInvariant μ] : IsMulRightInvariant μ.inv 
goal: μ.neg.IsAddRightInvariant

full_name: MeasureTheory.Measure.neg.instIsAddLeftInvariant
code: @[to_additive]
instance inv.instIsMulLeftInvariant [IsMulRightInvariant μ] : IsMulLeftInvariant μ.inv 
goal: μ.neg.IsAddLeftInvariant

full_name: MeasureTheory.Measure.inv.instIsMulLeftInvariant
code: @[to_additive]
instance inv.instIsMulLeftInvariant [IsMulRightInvariant μ] : IsMulLeftInvariant μ.inv 
goal: μ.inv.IsMulLeftInvariant

full_name: MeasureTheory.Measure.measurePreserving_sub_left
code: @[to_additive]
theorem measurePreserving_div_left (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : MeasurePreserving (fun t => g / t) μ μ 
goal: MeasureTheory.MeasurePreserving (fun t => g - t) μ μ

full_name: MeasureTheory.Measure.measurePreserving_div_left
code: @[to_additive]
theorem measurePreserving_div_left (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : MeasurePreserving (fun t => g / t) μ μ 
goal: MeasureTheory.MeasurePreserving (fun t => g / t) μ μ

full_name: MeasureTheory.Measure.map_sub_left_eq_self
code: @[to_additive]
theorem map_div_left_eq_self (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    map (fun t => g / t) μ = μ 
goal: MeasureTheory.Measure.map (fun t => g - t) μ = μ

full_name: MeasureTheory.Measure.map_div_left_eq_self
code: @[to_additive]
theorem map_div_left_eq_self (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    map (fun t => g / t) μ = μ 
goal: MeasureTheory.Measure.map (fun t => g / t) μ = μ

full_name: MeasureTheory.Measure.measurePreserving_add_right_neg
code: @[to_additive]
theorem measurePreserving_mul_right_inv (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : MeasurePreserving (fun t => (g * t)⁻¹) μ μ 
goal: MeasureTheory.MeasurePreserving (fun t => -(g + t)) μ μ

full_name: MeasureTheory.Measure.measurePreserving_mul_right_inv
code: @[to_additive]
theorem measurePreserving_mul_right_inv (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : MeasurePreserving (fun t => (g * t)⁻¹) μ μ 
goal: MeasureTheory.MeasurePreserving (fun t => (g * t)⁻¹) μ μ

full_name: MeasureTheory.Measure.map_mul_right_inv_eq_self
code: @[to_additive]
theorem map_mul_right_inv_eq_self (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : map (fun t => (g * t)⁻¹) μ = μ 
goal: MeasureTheory.Measure.map (fun t => (g * t)⁻¹) μ = μ

full_name: MeasureTheory.Measure.map_add_right_neg_eq_self
code: @[to_additive]
theorem map_mul_right_inv_eq_self (μ : Measure G) [IsInvInvariant μ] [IsMulLeftInvariant μ]
    (g : G) : map (fun t => (g * t)⁻¹) μ = μ 
goal: MeasureTheory.Measure.map (fun t => -(g + t)) μ = μ

full_name: MeasureTheory.Measure.map_div_left_ae
code: @[to_additive]
theorem map_div_left_ae (μ : Measure G) [IsMulLeftInvariant μ] [IsInvInvariant μ] (x : G) :
    Filter.map (fun t => x / t) (ae μ) = ae μ 
goal: Filter.map (fun t => x / t) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.Measure.map_sub_left_ae
code: @[to_additive]
theorem map_div_left_ae (μ : Measure G) [IsMulLeftInvariant μ] [IsInvInvariant μ] (x : G) :
    Filter.map (fun t => x / t) (ae μ) = ae μ 
goal: Filter.map (fun t => x - t) (MeasureTheory.ae μ) = MeasureTheory.ae μ

full_name: MeasureTheory.Measure.IsFiniteMeasureOnCompacts.neg
code: @[to_additive]
instance Measure.IsFiniteMeasureOnCompacts.inv [ContinuousInv G] [IsFiniteMeasureOnCompacts μ] :
    IsFiniteMeasureOnCompacts μ.inv 
goal: MeasureTheory.IsFiniteMeasureOnCompacts μ.neg

full_name: MeasureTheory.Measure.IsFiniteMeasureOnCompacts.inv
code: @[to_additive]
instance Measure.IsFiniteMeasureOnCompacts.inv [ContinuousInv G] [IsFiniteMeasureOnCompacts μ] :
    IsFiniteMeasureOnCompacts μ.inv 
goal: MeasureTheory.IsFiniteMeasureOnCompacts μ.inv

full_name: MeasureTheory.Measure.IsOpenPosMeasure.inv
code: @[to_additive]
instance Measure.IsOpenPosMeasure.inv [ContinuousInv G] [IsOpenPosMeasure μ] :
    IsOpenPosMeasure μ.inv 
goal: μ.inv.IsOpenPosMeasure

full_name: MeasureTheory.Measure.IsOpenPosMeasure.neg
code: @[to_additive]
instance Measure.IsOpenPosMeasure.inv [ContinuousInv G] [IsOpenPosMeasure μ] :
    IsOpenPosMeasure μ.inv 
goal: μ.neg.IsOpenPosMeasure

full_name: MeasureTheory.Measure.Regular.neg
code: @[to_additive]
instance Measure.Regular.inv [ContinuousInv G] [Regular μ] : Regular μ.inv 
goal: μ.neg.Regular

full_name: MeasureTheory.Measure.Regular.inv
code: @[to_additive]
instance Measure.Regular.inv [ContinuousInv G] [Regular μ] : Regular μ.inv 
goal: μ.inv.Regular

full_name: MeasureTheory.Measure.InnerRegular.neg
code: @[to_additive]
instance Measure.InnerRegular.inv [ContinuousInv G] [InnerRegular μ] : InnerRegular μ.inv 
goal: μ.neg.InnerRegular

full_name: MeasureTheory.Measure.InnerRegular.inv
code: @[to_additive]
instance Measure.InnerRegular.inv [ContinuousInv G] [InnerRegular μ] : InnerRegular μ.inv 
goal: μ.inv.InnerRegular

full_name: MeasureTheory.innerRegular_map_smul
code: /-- The image of an inner regular measure under map of a left action is again inner regular. -/
@[to_additive
   "The image of a inner regular measure under map of a left additive action is again
    inner regular"]
instance innerRegular_map_smul {α} [Monoid α] [MulAction α G] [ContinuousConstSMul α G]
    [InnerRegular μ] (a : α) : InnerRegular (Measure.map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a • x) μ).InnerRegular

full_name: MeasureTheory.innerRegular_map_vadd
code: /-- The image of an inner regular measure under map of a left action is again inner regular. -/
@[to_additive
   "The image of a inner regular measure under map of a left additive action is again
    inner regular"]
instance innerRegular_map_smul {α} [Monoid α] [MulAction α G] [ContinuousConstSMul α G]
    [InnerRegular μ] (a : α) : InnerRegular (Measure.map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a +ᵥ x) μ).InnerRegular

full_name: MeasureTheory.innerRegular_map_add_left
code: /-- The image of an inner regular measure under left multiplication is again inner regular. -/
@[to_additive "The image of an inner regular measure under left addition is again inner regular."]
instance innerRegular_map_mul_left [TopologicalGroup G] [InnerRegular μ] (g : G) :
    InnerRegular (Measure.map (g * ·) μ) 
goal: (MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular

full_name: MeasureTheory.innerRegular_map_mul_left
code: /-- The image of an inner regular measure under left multiplication is again inner regular. -/
@[to_additive "The image of an inner regular measure under left addition is again inner regular."]
instance innerRegular_map_mul_left [TopologicalGroup G] [InnerRegular μ] (g : G) :
    InnerRegular (Measure.map (g * ·) μ) 
goal: (MeasureTheory.Measure.map (fun x => g * x) μ).InnerRegular

full_name: MeasureTheory.innerRegular_map_add_right
code: /-- The image of an inner regular measure under right multiplication is again inner regular. -/
@[to_additive "The image of an inner regular measure under right addition is again inner regular."]
instance innerRegular_map_mul_right [TopologicalGroup G] [InnerRegular μ] (g : G) :
    InnerRegular (Measure.map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x + g) μ).InnerRegular

full_name: MeasureTheory.innerRegular_map_mul_right
code: /-- The image of an inner regular measure under right multiplication is again inner regular. -/
@[to_additive "The image of an inner regular measure under right addition is again inner regular."]
instance innerRegular_map_mul_right [TopologicalGroup G] [InnerRegular μ] (g : G) :
    InnerRegular (Measure.map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x * g) μ).InnerRegular

full_name: MeasureTheory.regular_neg_iff
code: @[to_additive]
theorem regular_inv_iff : μ.inv.Regular ↔ μ.Regular 
goal: μ.neg.Regular ↔ μ.Regular

full_name: MeasureTheory.regular_inv_iff
code: @[to_additive]
theorem regular_inv_iff : μ.inv.Regular ↔ μ.Regular 
goal: μ.inv.Regular ↔ μ.Regular

full_name: MeasureTheory.innerRegular_inv_iff
code: @[to_additive]
theorem innerRegular_inv_iff : μ.inv.InnerRegular ↔ μ.InnerRegular 
goal: μ.inv.InnerRegular ↔ μ.InnerRegular

full_name: MeasureTheory.innerRegular_neg_iff
code: @[to_additive]
theorem innerRegular_inv_iff : μ.inv.InnerRegular ↔ μ.InnerRegular 
goal: μ.neg.InnerRegular ↔ μ.InnerRegular

full_name: MeasureTheory.eventually_nhds_zero_measure_vadd_diff_lt
code: /-- Continuity of the measure of translates of a compact set: Given a compact set `k` in a
topological group, for `g` close enough to the origin, `μ (g • k \ k)` is arbitrarily small. -/
@[to_additive]
lemma eventually_nhds_one_measure_smul_diff_lt [LocallyCompactSpace G]
    [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ] {k : Set G}
    (hk : IsCompact k) (h'k : IsClosed k) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∀ᶠ g in 𝓝 (1 : G), μ (g • k \ k) < ε 
goal: ∀ᶠ (g : G) in 𝓝 0, μ ((g +ᵥ k) \ k) < ε

full_name: MeasureTheory.eventually_nhds_one_measure_smul_diff_lt
code: /-- Continuity of the measure of translates of a compact set: Given a compact set `k` in a
topological group, for `g` close enough to the origin, `μ (g • k \ k)` is arbitrarily small. -/
@[to_additive]
lemma eventually_nhds_one_measure_smul_diff_lt [LocallyCompactSpace G]
    [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ] {k : Set G}
    (hk : IsCompact k) (h'k : IsClosed k) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∀ᶠ g in 𝓝 (1 : G), μ (g • k \ k) < ε 
goal: ∀ᶠ (g : G) in 𝓝 1, μ (g • k \ k) < ε

full_name: MeasureTheory.tendsto_measure_smul_diff_isCompact_isClosed
code: /-- Continuity of the measure of translates of a compact set:
Given a closed compact set `k` in a topological group,
the measure of `g • k \ k` tends to zero as `g` tends to `1`. -/
@[to_additive]
lemma tendsto_measure_smul_diff_isCompact_isClosed [LocallyCompactSpace G]
    [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ] {k : Set G}
    (hk : IsCompact k) (h'k : IsClosed k) :
    Tendsto (fun g : G ↦ μ (g • k \ k)) (𝓝 1) (𝓝 0) 
goal: Filter.Tendsto (fun g => μ (g • k \ k)) (𝓝 1) (𝓝 0)

full_name: MeasureTheory.tendsto_measure_vadd_diff_isCompact_isClosed
code: /-- Continuity of the measure of translates of a compact set:
Given a closed compact set `k` in a topological group,
the measure of `g • k \ k` tends to zero as `g` tends to `1`. -/
@[to_additive]
lemma tendsto_measure_smul_diff_isCompact_isClosed [LocallyCompactSpace G]
    [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ] {k : Set G}
    (hk : IsCompact k) (h'k : IsClosed k) :
    Tendsto (fun g : G ↦ μ (g • k \ k)) (𝓝 1) (𝓝 0) 
goal: Filter.Tendsto (fun g => μ ((g +ᵥ k) \ k)) (𝓝 0) (𝓝 0)

full_name: MeasureTheory.isOpenPosMeasure_of_mulLeftInvariant_of_compact
code: /-- If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set. -/
@[to_additive
"If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set."]
theorem isOpenPosMeasure_of_mulLeftInvariant_of_compact (K : Set G) (hK : IsCompact K)
    (h : μ K ≠ 0) : IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.isOpenPosMeasure_of_addLeftInvariant_of_compact
code: /-- If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set. -/
@[to_additive
"If a left-invariant measure gives positive mass to a compact set, then it gives positive mass to
any open set."]
theorem isOpenPosMeasure_of_mulLeftInvariant_of_compact (K : Set G) (hK : IsCompact K)
    (h : μ K ≠ 0) : IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.isOpenPosMeasure_of_mulLeftInvariant_of_regular
code: /-- A nonzero left-invariant regular measure gives positive mass to any open set. -/
@[to_additive "A nonzero left-invariant regular measure gives positive mass to any open set."]
instance (priority := 80) isOpenPosMeasure_of_mulLeftInvariant_of_regular [Regular μ] [NeZero μ] :
    IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.isOpenPosMeasure_of_addLeftInvariant_of_regular
code: /-- A nonzero left-invariant regular measure gives positive mass to any open set. -/
@[to_additive "A nonzero left-invariant regular measure gives positive mass to any open set."]
instance (priority := 80) isOpenPosMeasure_of_mulLeftInvariant_of_regular [Regular μ] [NeZero μ] :
    IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.isOpenPosMeasure_of_addLeftInvariant_of_innerRegular
code: /-- A nonzero left-invariant inner regular measure gives positive mass to any open set. -/
@[to_additive "A nonzero left-invariant inner regular measure gives positive mass to any open set."]
instance (priority := 80) isOpenPosMeasure_of_mulLeftInvariant_of_innerRegular
    [InnerRegular μ] [NeZero μ] :
    IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.isOpenPosMeasure_of_mulLeftInvariant_of_innerRegular
code: /-- A nonzero left-invariant inner regular measure gives positive mass to any open set. -/
@[to_additive "A nonzero left-invariant inner regular measure gives positive mass to any open set."]
instance (priority := 80) isOpenPosMeasure_of_mulLeftInvariant_of_innerRegular
    [InnerRegular μ] [NeZero μ] :
    IsOpenPosMeasure μ 
goal: μ.IsOpenPosMeasure

full_name: MeasureTheory.null_iff_of_isMulLeftInvariant
code: @[to_additive]
theorem null_iff_of_isMulLeftInvariant [Regular μ] {s : Set G} (hs : IsOpen s) :
    μ s = 0 ↔ s = ∅ ∨ μ = 0 
goal: μ s = 0 ↔ s = ∅ ∨ μ = 0

full_name: MeasureTheory.null_iff_of_isAddLeftInvariant
code: @[to_additive]
theorem null_iff_of_isMulLeftInvariant [Regular μ] {s : Set G} (hs : IsOpen s) :
    μ s = 0 ↔ s = ∅ ∨ μ = 0 
goal: μ s = 0 ↔ s = ∅ ∨ μ = 0

full_name: MeasureTheory.measure_ne_zero_iff_nonempty_of_isAddLeftInvariant
code: @[to_additive]
theorem measure_ne_zero_iff_nonempty_of_isMulLeftInvariant [Regular μ] (hμ : μ ≠ 0) {s : Set G}
    (hs : IsOpen s) : μ s ≠ 0 ↔ s.Nonempty 
goal: μ s ≠ 0 ↔ s.Nonempty

full_name: MeasureTheory.measure_ne_zero_iff_nonempty_of_isMulLeftInvariant
code: @[to_additive]
theorem measure_ne_zero_iff_nonempty_of_isMulLeftInvariant [Regular μ] (hμ : μ ≠ 0) {s : Set G}
    (hs : IsOpen s) : μ s ≠ 0 ↔ s.Nonempty 
goal: μ s ≠ 0 ↔ s.Nonempty

full_name: MeasureTheory.measure_pos_iff_nonempty_of_isAddLeftInvariant
code: @[to_additive]
theorem measure_pos_iff_nonempty_of_isMulLeftInvariant [Regular μ] (h3μ : μ ≠ 0) {s : Set G}
    (hs : IsOpen s) : 0 < μ s ↔ s.Nonempty 
goal: 0 < μ s ↔ s.Nonempty

full_name: MeasureTheory.measure_pos_iff_nonempty_of_isMulLeftInvariant
code: @[to_additive]
theorem measure_pos_iff_nonempty_of_isMulLeftInvariant [Regular μ] (h3μ : μ ≠ 0) {s : Set G}
    (hs : IsOpen s) : 0 < μ s ↔ s.Nonempty 
goal: 0 < μ s ↔ s.Nonempty

full_name: MeasureTheory.measure_lt_top_of_isCompact_of_isAddLeftInvariant
code: /-- If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass
to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass to
any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant (U : Set G) (hU : IsOpen U)
    (h'U : U.Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞ 
goal: μ K < ⊤

full_name: MeasureTheory.measure_lt_top_of_isCompact_of_isMulLeftInvariant
code: /-- If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass
to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a nonempty open set, then it gives finite mass to
any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant (U : Set G) (hU : IsOpen U)
    (h'U : U.Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞ 
goal: μ K < ⊤

full_name: MeasureTheory.measure_lt_top_of_isCompact_of_isMulLeftInvariant'
code: /-- If a left-invariant measure gives finite mass to a set with nonempty interior, then
it gives finite mass to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives finite
mass to any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant' {U : Set G}
    (hU : (interior U).Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞ 
goal: μ K < ⊤

full_name: MeasureTheory.measure_lt_top_of_isCompact_of_isAddLeftInvariant'
code: /-- If a left-invariant measure gives finite mass to a set with nonempty interior, then
it gives finite mass to any compact set. -/
@[to_additive
"If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives finite
mass to any compact set."]
theorem measure_lt_top_of_isCompact_of_isMulLeftInvariant' {U : Set G}
    (hU : (interior U).Nonempty) (h : μ U ≠ ∞) {K : Set G} (hK : IsCompact K) : μ K < ∞ 
goal: μ K < ⊤

full_name: MeasureTheory.measure_univ_of_isMulLeftInvariant
code: /-- In a noncompact locally compact group, a left-invariant measure which is positive
on open sets has infinite mass. -/
@[to_additive (attr := simp)
"In a noncompact locally compact additive group, a left-invariant measure which is positive on open
sets has infinite mass."]
theorem measure_univ_of_isMulLeftInvariant [WeaklyLocallyCompactSpace G] [NoncompactSpace G]
    (μ : Measure G) [IsOpenPosMeasure μ] [μ.IsMulLeftInvariant] : μ univ = ∞ 
goal: μ Set.univ = ⊤

full_name: MeasureTheory.measure_univ_of_isAddLeftInvariant
code: /-- In a noncompact locally compact group, a left-invariant measure which is positive
on open sets has infinite mass. -/
@[to_additive (attr := simp)
"In a noncompact locally compact additive group, a left-invariant measure which is positive on open
sets has infinite mass."]
theorem measure_univ_of_isMulLeftInvariant [WeaklyLocallyCompactSpace G] [NoncompactSpace G]
    (μ : Measure G) [IsOpenPosMeasure μ] [μ.IsMulLeftInvariant] : μ univ = ∞ 
goal: μ Set.univ = ⊤

full_name: MeasurableSet.mul_closure_one_eq
code: @[to_additive]
lemma _root_.MeasurableSet.mul_closure_one_eq {s : Set G} (hs : MeasurableSet s) :
    s * (closure {1} : Set G) = s 
goal: s * closure {1} = s

full_name: MeasurableSet.add_closure_zero_eq
code: @[to_additive]
lemma _root_.MeasurableSet.mul_closure_one_eq {s : Set G} (hs : MeasurableSet s) :
    s * (closure {1} : Set G) = s 
goal: s + closure {0} = s

full_name: IsCompact.closure_subset_of_measurableSet_of_group
code: /-- If a compact set is included in a measurable set, then so is its closure. -/
@[to_additive (attr := deprecated IsCompact.closure_subset_measurableSet (since := "2024-01-28"))]
lemma _root_.IsCompact.closure_subset_of_measurableSet_of_group {k s : Set G}
    (hk : IsCompact k) (hs : MeasurableSet s) (h : k ⊆ s) : closure k ⊆ s 
goal: closure k ⊆ s

full_name: IsCompact.closure_subset_of_measurableSet_of_addGroup
code: /-- If a compact set is included in a measurable set, then so is its closure. -/
@[to_additive (attr := deprecated IsCompact.closure_subset_measurableSet (since := "2024-01-28"))]
lemma _root_.IsCompact.closure_subset_of_measurableSet_of_group {k s : Set G}
    (hk : IsCompact k) (hs : MeasurableSet s) (h : k ⊆ s) : closure k ⊆ s 
goal: closure k ⊆ s

full_name: MeasureTheory.measure_mul_closure_one
code: @[to_additive (attr := simp)]
lemma measure_mul_closure_one (s : Set G) (μ : Measure G) :
    μ (s * (closure {1} : Set G)) = μ s 
goal: μ (s * closure {1}) = μ s

full_name: MeasureTheory.measure_add_closure_zero
code: @[to_additive (attr := simp)]
lemma measure_mul_closure_one (s : Set G) (μ : Measure G) :
    μ (s * (closure {1} : Set G)) = μ s 
goal: μ (s + closure {0}) = μ s

full_name: IsCompact.measure_closure_eq_of_addGroup
code: @[to_additive (attr := deprecated IsCompact.measure_closure (since := "2024-01-28"))]
lemma _root_.IsCompact.measure_closure_eq_of_group {k : Set G} (hk : IsCompact k) (μ : Measure G) :
    μ (closure k) = μ k 
goal: μ (closure k) = μ k

full_name: IsCompact.measure_closure_eq_of_group
code: @[to_additive (attr := deprecated IsCompact.measure_closure (since := "2024-01-28"))]
lemma _root_.IsCompact.measure_closure_eq_of_group {k : Set G} (hk : IsCompact k) (μ : Measure G) :
    μ (closure k) = μ k 
goal: μ (closure k) = μ k

full_name: MeasureTheory.innerRegularWRT_isCompact_isClosed_measure_ne_top_of_addGroup
code: @[to_additive]
lemma innerRegularWRT_isCompact_isClosed_measure_ne_top_of_group [h : InnerRegularCompactLTTop μ] :
    InnerRegularWRT μ (fun s ↦ IsCompact s ∧ IsClosed s) (fun s ↦ MeasurableSet s ∧ μ s ≠ ∞) 
goal: μ.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) fun s => MeasurableSet s ∧ μ s ≠ ⊤

full_name: MeasureTheory.innerRegularWRT_isCompact_isClosed_measure_ne_top_of_group
code: @[to_additive]
lemma innerRegularWRT_isCompact_isClosed_measure_ne_top_of_group [h : InnerRegularCompactLTTop μ] :
    InnerRegularWRT μ (fun s ↦ IsCompact s ∧ IsClosed s) (fun s ↦ MeasurableSet s ∧ μ s ≠ ∞) 
goal: μ.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) fun s => MeasurableSet s ∧ μ s ≠ ⊤

full_name: MeasureTheory.IsMulLeftInvariant.isMulRightInvariant
code: /-- In an abelian group every left invariant measure is also right-invariant.
  We don't declare the converse as an instance, since that would loop type-class inference, and
  we use `IsMulLeftInvariant` as the default hypothesis in abelian groups. -/
@[to_additive IsAddLeftInvariant.isAddRightInvariant
"In an abelian additive group every left invariant measure is also right-invariant. We don't declare
the converse as an instance, since that would loop type-class inference, and we use
`IsAddLeftInvariant` as the default hypothesis in abelian groups."]
instance (priority := 100) IsMulLeftInvariant.isMulRightInvariant {μ : Measure G}
    [IsMulLeftInvariant μ] : IsMulRightInvariant μ 
goal: μ.IsMulRightInvariant

full_name: MeasureTheory.IsAddLeftInvariant.isAddRightInvariant
code: /-- In an abelian group every left invariant measure is also right-invariant.
  We don't declare the converse as an instance, since that would loop type-class inference, and
  we use `IsMulLeftInvariant` as the default hypothesis in abelian groups. -/
@[to_additive IsAddLeftInvariant.isAddRightInvariant
"In an abelian additive group every left invariant measure is also right-invariant. We don't declare
the converse as an instance, since that would loop type-class inference, and we use
`IsAddLeftInvariant` as the default hypothesis in abelian groups."]
instance (priority := 100) IsMulLeftInvariant.isMulRightInvariant {μ : Measure G}
    [IsMulLeftInvariant μ] : IsMulRightInvariant μ 
goal: μ.IsAddRightInvariant

full_name: MeasureTheory.Measure.IsAddHaarMeasure
code: /-- A measure on an additive group is an additive Haar measure if it is left-invariant, and
gives finite mass to compact sets and positive mass to open sets.

Textbooks generally require an additional regularity assumption to ensure nice behavior on
arbitrary locally compact groups. Use `[IsAddHaarMeasure μ] [Regular μ]` or
`[IsAddHaarMeasure μ] [InnerRegular μ]` in these situations. Note that a Haar measure in our
sense is automatically regular and inner regular on second countable locally compact groups, as
checked just below this definition. -/
class IsAddHaarMeasure {G : Type*} [AddGroup G] [TopologicalSpace G] [MeasurableSpace G]
  (μ : Measure G) extends IsFiniteMeasureOnCompacts μ, IsAddLeftInvariant μ, IsOpenPosMeasure μ :
  Prop
goal: Prop

full_name: MeasureTheory.Measure.IsHaarMeasure
code: /-- A measure on a group is a Haar measure if it is left-invariant, and gives finite mass to
compact sets and positive mass to open sets.

Textbooks generally require an additional regularity assumption to ensure nice behavior on
arbitrary locally compact groups. Use `[IsHaarMeasure μ] [Regular μ]` or
`[IsHaarMeasure μ] [InnerRegular μ]` in these situations. Note that a Haar measure in our
sense is automatically regular and inner regular on second countable locally compact groups, as
checked just below this definition. -/
@[to_additive existing]
class IsHaarMeasure {G : Type*} [Group G] [TopologicalSpace G] [MeasurableSpace G]
  (μ : Measure G) extends IsFiniteMeasureOnCompacts μ, IsMulLeftInvariant μ, IsOpenPosMeasure μ :
  Prop
goal: Prop

full_name: MeasureTheory.Measure.haar_singleton
code: @[to_additive (attr := simp)]
theorem haar_singleton [TopologicalGroup G] [BorelSpace G] (g : G) : μ {g} = μ {(1 : G)} 
goal: μ {g} = μ {1}

full_name: MeasureTheory.Measure.addHaar_singleton
code: @[to_additive (attr := simp)]
theorem haar_singleton [TopologicalGroup G] [BorelSpace G] (g : G) : μ {g} = μ {(1 : G)} 
goal: μ {g} = μ {0}

full_name: MeasureTheory.Measure.IsHaarMeasure.smul
code: @[to_additive IsAddHaarMeasure.smul]
theorem IsHaarMeasure.smul {c : ℝ≥0∞} (cpos : c ≠ 0) (ctop : c ≠ ∞) : IsHaarMeasure (c • μ) 
goal: (c • μ).IsHaarMeasure

full_name: MeasureTheory.Measure.IsAddHaarMeasure.smul
code: @[to_additive IsAddHaarMeasure.smul]
theorem IsHaarMeasure.smul {c : ℝ≥0∞} (cpos : c ≠ 0) (ctop : c ≠ ∞) : IsHaarMeasure (c • μ) 
goal: (c • μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_of_isCompact_nonempty_interior
code: /-- If a left-invariant measure gives positive mass to some compact set with nonempty interior, then
it is a Haar measure. -/
@[to_additive
"If a left-invariant measure gives positive mass to some compact set with nonempty interior, then
it is an additive Haar measure."]
theorem isHaarMeasure_of_isCompact_nonempty_interior [TopologicalGroup G] [BorelSpace G]
    (μ : Measure G) [IsMulLeftInvariant μ] (K : Set G) (hK : IsCompact K)
    (h'K : (interior K).Nonempty) (h : μ K ≠ 0) (h' : μ K ≠ ∞) : IsHaarMeasure μ 
goal: μ.IsHaarMeasure

full_name: MeasureTheory.Measure.isAddHaarMeasure_of_isCompact_nonempty_interior
code: /-- If a left-invariant measure gives positive mass to some compact set with nonempty interior, then
it is a Haar measure. -/
@[to_additive
"If a left-invariant measure gives positive mass to some compact set with nonempty interior, then
it is an additive Haar measure."]
theorem isHaarMeasure_of_isCompact_nonempty_interior [TopologicalGroup G] [BorelSpace G]
    (μ : Measure G) [IsMulLeftInvariant μ] (K : Set G) (hK : IsCompact K)
    (h'K : (interior K).Nonempty) (h : μ K ≠ 0) (h' : μ K ≠ ∞) : IsHaarMeasure μ 
goal: μ.IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_map
code: /-- The image of a Haar measure under a continuous surjective proper group homomorphism is again
a Haar measure. See also `MulEquiv.isHaarMeasure_map`. -/
@[to_additive
"The image of an additive Haar measure under a continuous surjective proper additive group
homomorphism is again an additive Haar measure. See also `AddEquiv.isAddHaarMeasure_map`."]
theorem isHaarMeasure_map [BorelSpace G] [TopologicalGroup G] {H : Type*} [Group H]
    [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H] [T2Space H] [TopologicalGroup H]
    (f : G →* H) (hf : Continuous f) (h_surj : Surjective f)
    (h_prop : Tendsto f (cocompact G) (cocompact H)) : IsHaarMeasure (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsHaarMeasure

full_name: MeasureTheory.Measure.isAddHaarMeasure_map
code: /-- The image of a Haar measure under a continuous surjective proper group homomorphism is again
a Haar measure. See also `MulEquiv.isHaarMeasure_map`. -/
@[to_additive
"The image of an additive Haar measure under a continuous surjective proper additive group
homomorphism is again an additive Haar measure. See also `AddEquiv.isAddHaarMeasure_map`."]
theorem isHaarMeasure_map [BorelSpace G] [TopologicalGroup G] {H : Type*} [Group H]
    [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H] [T2Space H] [TopologicalGroup H]
    (f : G →* H) (hf : Continuous f) (h_surj : Surjective f)
    (h_prop : Tendsto f (cocompact G) (cocompact H)) : IsHaarMeasure (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_map_of_isFiniteMeasure
code: /-- The image of a finite Haar measure under a continuous surjective group homomorphism is again
a Haar measure. See also `isHaarMeasure_map`. -/
@[to_additive
"The image of a finite additive Haar measure under a continuous surjective additive group
homomorphism is again an additive Haar measure. See also `isAddHaarMeasure_map`."]
theorem isHaarMeasure_map_of_isFiniteMeasure
    [BorelSpace G] [TopologicalGroup G] {H : Type*} [Group H]
    [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H] [TopologicalGroup H] [IsFiniteMeasure μ]
    (f : G →* H) (hf : Continuous f) (h_surj : Surjective f) :
    IsHaarMeasure (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsHaarMeasure

full_name: MeasureTheory.Measure.isAddHaarMeasure_map_of_isFiniteMeasure
code: /-- The image of a finite Haar measure under a continuous surjective group homomorphism is again
a Haar measure. See also `isHaarMeasure_map`. -/
@[to_additive
"The image of a finite additive Haar measure under a continuous surjective additive group
homomorphism is again an additive Haar measure. See also `isAddHaarMeasure_map`."]
theorem isHaarMeasure_map_of_isFiniteMeasure
    [BorelSpace G] [TopologicalGroup G] {H : Type*} [Group H]
    [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H] [TopologicalGroup H] [IsFiniteMeasure μ]
    (f : G →* H) (hf : Continuous f) (h_surj : Surjective f) :
    IsHaarMeasure (Measure.map f μ) 
goal: (MeasureTheory.Measure.map (⇑f) μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_map_smul
code: /-- The image of a Haar measure under map of a left action is again a Haar measure. -/
@[to_additive
   "The image of a Haar measure under map of a left additive action is again a Haar measure"]
instance isHaarMeasure_map_smul {α} [BorelSpace G] [TopologicalGroup G]
    [Group α] [MulAction α G] [SMulCommClass α G G] [MeasurableSpace α] [MeasurableSMul α G]
    [ContinuousConstSMul α G] (a : α) : IsHaarMeasure (Measure.map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a • x) μ).IsHaarMeasure

full_name: MeasureTheory.Measure.isAddHaarMeasure_map_vadd
code: /-- The image of a Haar measure under map of a left action is again a Haar measure. -/
@[to_additive
   "The image of a Haar measure under map of a left additive action is again a Haar measure"]
instance isHaarMeasure_map_smul {α} [BorelSpace G] [TopologicalGroup G]
    [Group α] [MulAction α G] [SMulCommClass α G G] [MeasurableSpace α] [MeasurableSMul α G]
    [ContinuousConstSMul α G] (a : α) : IsHaarMeasure (Measure.map (a • · : G → G) μ) 
goal: (MeasureTheory.Measure.map (fun x => a +ᵥ x) μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_map_add_right
code: /-- The image of a Haar measure under right multiplication is again a Haar measure. -/
@[to_additive isHaarMeasure_map_add_right
  "The image of a Haar measure under right addition is again a Haar measure."]
instance isHaarMeasure_map_mul_right [BorelSpace G] [TopologicalGroup G] (g : G) :
    IsHaarMeasure (Measure.map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x + g) μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.isHaarMeasure_map_mul_right
code: /-- The image of a Haar measure under right multiplication is again a Haar measure. -/
@[to_additive isHaarMeasure_map_add_right
  "The image of a Haar measure under right addition is again a Haar measure."]
instance isHaarMeasure_map_mul_right [BorelSpace G] [TopologicalGroup G] (g : G) :
    IsHaarMeasure (Measure.map (· * g) μ) 
goal: (MeasureTheory.Measure.map (fun x => x * g) μ).IsHaarMeasure

full_name: MulEquiv.isHaarMeasure_map
code: /-- A convenience wrapper for `MeasureTheory.Measure.isHaarMeasure_map`. -/
@[to_additive "A convenience wrapper for `MeasureTheory.Measure.isAddHaarMeasure_map`."]
nonrec theorem _root_.MulEquiv.isHaarMeasure_map [BorelSpace G] [TopologicalGroup G] {H : Type*}
    [Group H] [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H]
    [TopologicalGroup H] (e : G ≃* H) (he : Continuous e) (hesymm : Continuous e.symm) :
    IsHaarMeasure (Measure.map e μ) 
goal: (MeasureTheory.Measure.map (⇑e) μ).IsHaarMeasure

full_name: AddEquiv.isAddHaarMeasure_map
code: /-- A convenience wrapper for `MeasureTheory.Measure.isHaarMeasure_map`. -/
@[to_additive "A convenience wrapper for `MeasureTheory.Measure.isAddHaarMeasure_map`."]
nonrec theorem _root_.MulEquiv.isHaarMeasure_map [BorelSpace G] [TopologicalGroup G] {H : Type*}
    [Group H] [TopologicalSpace H] [MeasurableSpace H] [BorelSpace H]
    [TopologicalGroup H] (e : G ≃* H) (he : Continuous e) (hesymm : Continuous e.symm) :
    IsHaarMeasure (Measure.map e μ) 
goal: (MeasureTheory.Measure.map (⇑e) μ).IsAddHaarMeasure

full_name: ContinuousLinearEquiv.isAddHaarMeasure_map
code: /-- A convenience wrapper for MeasureTheory.Measure.isAddHaarMeasure_map`. -/
theorem _root_.ContinuousLinearEquiv.isAddHaarMeasure_map
    {E F R S : Type*} [Semiring R] [Semiring S]
    [AddCommGroup E] [Module R E] [AddCommGroup F] [Module S F]
    [TopologicalSpace E] [TopologicalAddGroup E] [TopologicalSpace F]
    [TopologicalAddGroup F]
    {σ : R →+* S} {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ]
    [MeasurableSpace E] [BorelSpace E] [MeasurableSpace F] [BorelSpace F]
    (L : E ≃SL[σ] F) (μ : Measure E) [IsAddHaarMeasure μ] :
    IsAddHaarMeasure (μ.map L) 
goal: (MeasureTheory.Measure.map (⇑L) μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.IsHaarMeasure.sigmaFinite
code: /-- A Haar measure on a σ-compact space is σ-finite.

See Note [lower instance priority] -/
@[to_additive
"A Haar measure on a σ-compact space is σ-finite.

See Note [lower instance priority]"]
instance (priority := 100) IsHaarMeasure.sigmaFinite [SigmaCompactSpace G] : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.Measure.IsAddHaarMeasure.sigmaFinite
code: /-- A Haar measure on a σ-compact space is σ-finite.

See Note [lower instance priority] -/
@[to_additive
"A Haar measure on a σ-compact space is σ-finite.

See Note [lower instance priority]"]
instance (priority := 100) IsHaarMeasure.sigmaFinite [SigmaCompactSpace G] : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.Measure.prod.instIsHaarMeasure
code: @[to_additive]
instance prod.instIsHaarMeasure {G : Type*} [Group G] [TopologicalSpace G] {_ : MeasurableSpace G}
    {H : Type*} [Group H] [TopologicalSpace H] {_ : MeasurableSpace H} (μ : Measure G)
    (ν : Measure H) [IsHaarMeasure μ] [IsHaarMeasure ν] [SFinite μ] [SFinite ν]
    [MeasurableMul G] [MeasurableMul H] : IsHaarMeasure (μ.prod ν) 
goal: ∀ {x : MeasurableSpace G} {H : Type u_5} [inst : Group H] [inst_1 : TopologicalSpace H] {x_1 : MeasurableSpace H}
  (μ : MeasureTheory.Measure G) (ν : MeasureTheory.Measure H) [inst_2 : μ.IsHaarMeasure] [inst_3 : ν.IsHaarMeasure]
  [inst_4 : MeasureTheory.SFinite μ] [inst_5 : MeasureTheory.SFinite ν] [inst_6 : MeasurableMul G]
  [inst_7 : MeasurableMul H], (μ.prod ν).IsHaarMeasure

full_name: MeasureTheory.Measure.prod.instIsAddHaarMeasure
code: @[to_additive]
instance prod.instIsHaarMeasure {G : Type*} [Group G] [TopologicalSpace G] {_ : MeasurableSpace G}
    {H : Type*} [Group H] [TopologicalSpace H] {_ : MeasurableSpace H} (μ : Measure G)
    (ν : Measure H) [IsHaarMeasure μ] [IsHaarMeasure ν] [SFinite μ] [SFinite ν]
    [MeasurableMul G] [MeasurableMul H] : IsHaarMeasure (μ.prod ν) 
goal: ∀ {x : MeasurableSpace G} {H : Type u_5} [inst : AddGroup H] [inst_1 : TopologicalSpace H] {x_1 : MeasurableSpace H}
  (μ : MeasureTheory.Measure G) (ν : MeasureTheory.Measure H) [inst_2 : μ.IsAddHaarMeasure]
  [inst_3 : ν.IsAddHaarMeasure] [inst_4 : MeasureTheory.SFinite μ] [inst_5 : MeasureTheory.SFinite ν]
  [inst_6 : MeasurableAdd G] [inst_7 : MeasurableAdd H], (μ.prod ν).IsAddHaarMeasure

full_name: MeasureTheory.Measure.IsHaarMeasure.noAtoms
code: /-- If the neutral element of a group is not isolated, then a Haar measure on this group has
no atoms.

The additive version of this instance applies in particular to show that an additive Haar
measure on a nontrivial finite-dimensional real vector space has no atom. -/
@[to_additive
"If the zero element of an additive group is not isolated, then an additive Haar measure on this
group has no atoms.

This applies in particular to show that an additive Haar measure on a nontrivial
finite-dimensional real vector space has no atom."]
instance (priority := 100) IsHaarMeasure.noAtoms [TopologicalGroup G] [BorelSpace G] [T1Space G]
    [WeaklyLocallyCompactSpace G] [(𝓝[≠] (1 : G)).NeBot] (μ : Measure G) [μ.IsHaarMeasure] :
    NoAtoms μ 
goal: MeasureTheory.NoAtoms μ

full_name: MeasureTheory.Measure.IsAddHaarMeasure.noAtoms
code: /-- If the neutral element of a group is not isolated, then a Haar measure on this group has
no atoms.

The additive version of this instance applies in particular to show that an additive Haar
measure on a nontrivial finite-dimensional real vector space has no atom. -/
@[to_additive
"If the zero element of an additive group is not isolated, then an additive Haar measure on this
group has no atoms.

This applies in particular to show that an additive Haar measure on a nontrivial
finite-dimensional real vector space has no atom."]
instance (priority := 100) IsHaarMeasure.noAtoms [TopologicalGroup G] [BorelSpace G] [T1Space G]
    [WeaklyLocallyCompactSpace G] [(𝓝[≠] (1 : G)).NeBot] (μ : Measure G) [μ.IsHaarMeasure] :
    NoAtoms μ 
goal: MeasureTheory.NoAtoms μ