l3lab/ntp-mathlib huggingface dataset:
@[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulLeftInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulLeftInvariant ν
inst✝ : SFinite ν
⊢ IsMulLeftInvariant (Measure.prod μ ν)

Next tactic:
constructor
@[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) := by
  constructor
  

Proof state:
case map_mul_left_eq_self
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulLeftInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulLeftInvariant ν
inst✝ : SFinite ν
⊢ ∀ (g : G × H), map (fun x => g * x) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
rintro ⟨g, h⟩
@[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) := by
  constructor
  rintro ⟨g, h⟩
  

Proof state:
case map_mul_left_eq_self.mk
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulLeftInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulLeftInvariant ν
inst✝ : SFinite ν
g : G
h : H
⊢ map (fun x => (g, h) * x) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
change map (Prod.map (g * ·) (h * ·)) (μ.prod ν) = μ.prod ν
@[to_additive]
instance Measure.prod.instIsMulLeftInvariant [IsMulLeftInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulLeftInvariant ν]
    [SFinite ν] : IsMulLeftInvariant (μ.prod ν) := by
  constructor
  rintro ⟨g, h⟩
  change map (Prod.map (g * ·) (h * ·)) (μ.prod ν) = μ.prod ν
  

Proof state:
case map_mul_left_eq_self.mk
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulLeftInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulLeftInvariant ν
inst✝ : SFinite ν
g : G
h : H
⊢ map (Prod.map (fun x => g * x) fun x => h * x) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
rw [← map_prod_map _ _ (measurable_const_mul g) (measurable_const_mul h),
    map_mul_left_eq_self μ g, map_mul_left_eq_self ν h]
@[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulRightInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulRightInvariant ν
inst✝ : SFinite ν
⊢ IsMulRightInvariant (Measure.prod μ ν)

Next tactic:
constructor
@[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) := by
  constructor
  

Proof state:
case map_mul_right_eq_self
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulRightInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulRightInvariant ν
inst✝ : SFinite ν
⊢ ∀ (g : G × H), map (fun x => x * g) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
rintro ⟨g, h⟩
@[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) := by
  constructor
  rintro ⟨g, h⟩
  

Proof state:
case map_mul_right_eq_self.mk
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulRightInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulRightInvariant ν
inst✝ : SFinite ν
g : G
h : H
⊢ map (fun x => x * (g, h)) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
change map (Prod.map (· * g) (· * h)) (μ.prod ν) = μ.prod ν
@[to_additive]
instance Measure.prod.instIsMulRightInvariant [IsMulRightInvariant μ] [SFinite μ] {H : Type*}
    [Mul H] {mH : MeasurableSpace H} {ν : Measure H} [MeasurableMul H] [IsMulRightInvariant ν]
    [SFinite ν] : IsMulRightInvariant (μ.prod ν) := by
  constructor
  rintro ⟨g, h⟩
  change map (Prod.map (· * g) (· * h)) (μ.prod ν) = μ.prod ν
  

Proof state:
case map_mul_right_eq_self.mk
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁹ : MeasurableSpace G
inst✝⁸ : MeasurableSpace H✝
inst✝⁷ : Mul G
μ : Measure G
inst✝⁶ : MeasurableMul G
inst✝⁵ : IsMulRightInvariant μ
inst✝⁴ : SFinite μ
H : Type u_4
inst✝³ : Mul H
mH : MeasurableSpace H
ν : Measure H
inst✝² : MeasurableMul H
inst✝¹ : IsMulRightInvariant ν
inst✝ : SFinite ν
g : G
h : H
⊢ map (Prod.map (fun x => x * g) fun x => x * h) (Measure.prod μ ν) = Measure.prod μ ν

Next tactic:
rw [← map_prod_map _ _ (measurable_mul_const g) (measurable_mul_const h),
    map_mul_right_eq_self μ g, map_mul_right_eq_self ν h]
@[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 μ) := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
⊢ IsMulLeftInvariant (Measure.map (⇑f) μ)

Next tactic:
refine' ⟨fun h => _⟩
@[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 μ) := by
  refine' ⟨fun h => _⟩
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
h : H
⊢ Measure.map (fun x => h * x) (Measure.map (⇑f) μ) = Measure.map (⇑f) μ

Next tactic:
rw [map_map (measurable_const_mul _) hf]
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
h : H
⊢ Measure.map ((fun x => h * x) ∘ ⇑f) μ = Measure.map (⇑f) μ

Next tactic:
obtain ⟨g, rfl⟩ := h_surj h
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  

Proof state:
case intro
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g : G
⊢ Measure.map ((fun x => f g * x) ∘ ⇑f) μ = Measure.map (⇑f) μ

Next tactic:
conv_rhs => rw [← map_mul_left_eq_self μ g]
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g : G
| Measure.map (⇑f) μ

Next tactic:
rw [← map_mul_left_eq_self μ g]
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  conv_rhs => rw [← map_mul_left_eq_self μ g]
  

Proof state:
case intro
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g : G
⊢ Measure.map ((fun x => f g * x) ∘ ⇑f) μ = Measure.map (⇑f) (Measure.map (fun x => g * x) μ)

Next tactic:
rw [map_map hf (measurable_const_mul _)]
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  conv_rhs => rw [← map_mul_left_eq_self μ g]
  rw [map_map hf (measurable_const_mul _)]
  

Proof state:
case intro
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g : G
⊢ Measure.map ((fun x => f g * x) ∘ ⇑f) μ = Measure.map (⇑f ∘ fun x => g * x) μ

Next tactic:
congr 2
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  conv_rhs => rw [← map_mul_left_eq_self μ g]
  rw [map_map hf (measurable_const_mul _)]
  congr 2
  

Proof state:
case intro.e_f
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g : G
⊢ (fun x => f g * x) ∘ ⇑f = ⇑f ∘ fun x => g * x

Next tactic:
ext y
@[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 μ) := by
  refine' ⟨fun h => _⟩
  rw [map_map (measurable_const_mul _) hf]
  obtain ⟨g, rfl⟩ := h_surj h
  conv_rhs => rw [← map_mul_left_eq_self μ g]
  rw [map_map hf (measurable_const_mul _)]
  congr 2
  ext y
  

Proof state:
case intro.e_f.h
𝕜 : Type u_1
G : Type u_2
H✝ : Type u_3
inst✝⁷ : MeasurableSpace G
inst✝⁶ : MeasurableSpace H✝
inst✝⁵ : Mul G
μ : Measure G
inst✝⁴ : MeasurableMul G
H : Type u_4
inst✝³ : MeasurableSpace H
inst✝² : Mul H
inst✝¹ : MeasurableMul H
inst✝ : IsMulLeftInvariant μ
f : G →ₙ* H
hf : Measurable ⇑f
h_surj : Surjective ⇑f
g y : G
⊢ ((fun x => f g * x) ∘ ⇑f) y = (⇑f ∘ fun x => g * x) y

Next tactic:
simp only [comp_apply, map_mul]
@[to_additive]
theorem map_div_right_eq_self (μ : Measure G) [IsMulRightInvariant μ] (g : G) : map (· / g) μ = μ :=
  by 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSpace H
inst✝¹ : DivInvMonoid G
μ : Measure G
inst✝ : IsMulRightInvariant μ
g : G
⊢ Measure.map (fun x => x / g) μ = μ

Next tactic:
simp_rw [div_eq_mul_inv, map_mul_right_eq_self μ g⁻¹]
@[to_additive]
theorem measurePreserving_div_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) :
    MeasurePreserving (· / g) μ μ := by 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
g : G
⊢ MeasurePreserving fun x => x / g

Next tactic:
simp_rw [div_eq_mul_inv, measurePreserving_mul_right μ g⁻¹]
/-- 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 :=
  calc
    μ ((fun h => g * h) ⁻¹' A) = map (fun h => g * h) μ A :=
      ((MeasurableEquiv.mulLeft g).map_apply A).symm
    _ = μ A := by 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
g : G
A : Set G
⊢ ↑↑(Measure.map (fun h => g * h) μ) A = ↑↑μ A

Next tactic:
rw [map_mul_left_eq_self μ g]
@[to_additive (attr := simp)]
theorem measure_preimage_mul_right (μ : Measure G) [IsMulRightInvariant μ] (g : G) (A : Set G) :
    μ ((fun h => h * g) ⁻¹' A) = μ A :=
  calc
    μ ((fun h => h * g) ⁻¹' A) = map (fun h => h * g) μ A :=
      ((MeasurableEquiv.mulRight g).map_apply A).symm
    _ = μ A := by 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
g : G
A : Set G
⊢ ↑↑(Measure.map (fun h => h * g) μ) A = ↑↑μ A

Next tactic:
rw [map_mul_right_eq_self μ g]
@[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (t * x)) ↔ ∀ᵐ (x : G) ∂μ, p x

Next tactic:
conv_rhs => rw [Filter.Eventually, ← map_mul_left_ae μ t]; rfl
@[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_mul_left_ae μ t]; rfl
@[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_mul_left_ae μ t]
@[to_additive]
theorem eventually_mul_left_iff (μ : Measure G) [IsMulLeftInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (t * x)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => rw [Filter.Eventually, ← map_mul_left_ae μ t]; 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
t : G
p : G → Prop
| {x | p x} ∈ Filter.map (fun h => t * h) (ae μ)

Next tactic:
rfl
@[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x * t)) ↔ ∀ᵐ (x : G) ∂μ, p x

Next tactic:
conv_rhs => rw [Filter.Eventually, ← map_mul_right_ae μ t]; rfl
@[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_mul_right_ae μ t]; rfl
@[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_mul_right_ae μ t]
@[to_additive]
theorem eventually_mul_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x * t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => rw [Filter.Eventually, ← map_mul_right_ae μ t]; 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| {x | p x} ∈ Filter.map (fun h => h * t) (ae μ)

Next tactic:
rfl
@[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
⊢ (∀ᵐ (x : G) ∂μ, p (x / t)) ↔ ∀ᵐ (x : G) ∂μ, p x

Next tactic:
conv_rhs => rw [Filter.Eventually, ← map_div_right_ae μ t]; rfl
@[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_div_right_ae μ t]; rfl
@[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| ∀ᵐ (x : G) ∂μ, p x

Next tactic:
rw [Filter.Eventually, ← map_div_right_ae μ t]
@[to_additive]
theorem eventually_div_right_iff (μ : Measure G) [IsMulRightInvariant μ] (t : G) {p : G → Prop} :
    (∀ᵐ x ∂μ, p (x / t)) ↔ ∀ᵐ x ∂μ, p x := by
  conv_rhs => rw [Filter.Eventually, ← map_div_right_ae μ t]; 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Group G
inst✝¹ : MeasurableMul G
μ : Measure G
inst✝ : IsMulRightInvariant μ
t : G
p : G → Prop
| {x | p x} ∈ Filter.map (fun t_1 => t_1 / t) (ae μ)

Next tactic:
rfl
@[to_additive]
instance inv.instSFinite (μ : Measure G) [SFinite μ] : SFinite μ.inv := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Inv G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : SFinite μ
⊢ SFinite (Measure.inv μ)

Next tactic:
rw [Measure.inv]
@[to_additive]
instance inv.instSFinite (μ : Measure G) [SFinite μ] : SFinite μ.inv := by
  rw [Measure.inv]; 

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : Inv G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : SFinite μ
⊢ SFinite (map inv μ)

Next tactic:
infer_instance
@[to_additive (attr := simp)]
theorem measure_inv (μ : Measure G) [IsInvInvariant μ] (A : Set G) : μ A⁻¹ = μ A := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace H
inst✝² : InvolutiveInv G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : IsInvInvariant μ
A : Set G
⊢ ↑↑μ A⁻¹ = ↑↑μ A

Next tactic:
rw [← inv_apply, inv_eq_self]
@[to_additive]
instance inv.instIsMulRightInvariant [IsMulLeftInvariant μ] : IsMulRightInvariant μ.inv := by
  

Proof state:
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSpace H
inst✝³ : DivisionMonoid G
inst✝² : MeasurableMul G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
⊢ IsMulRightInvariant (Measure.inv μ)

Next tactic:
constructor
@[to_additive]
instance inv.instIsMulRightInvariant [IsMulLeftInvariant μ] : IsMulRightInvariant μ.inv := by
  constructor
  

Proof state:
case map_mul_right_eq_self
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSpace H
inst✝³ : DivisionMonoid G
inst✝² : MeasurableMul G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
⊢ ∀ (g : G), map (fun x => x * g) (Measure.inv μ) = Measure.inv μ

Next tactic:
intro g
@[to_additive]
instance inv.instIsMulRightInvariant [IsMulLeftInvariant μ] : IsMulRightInvariant μ.inv := by
  constructor
  intro g
  

Proof state:
case map_mul_right_eq_self
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSpace H
inst✝³ : DivisionMonoid G
inst✝² : MeasurableMul G
inst✝¹ : MeasurableInv G
μ : Measure G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ map (fun x => x * g) (Measure.inv μ) = Measure.inv μ

Next tactic:
conv_rhs => rw [← map_mul_left_eq_self μ g⁻¹]