l3lab/ntp-mathlib huggingface dataset:
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> 

Proof state:
case intro.intro.neg
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
⊢ ∀ {a : R}, AddGroup.InClosure (Monoid.Closure s) a → f a ∈ closure (⇑f '' s) → f (-a) ∈ closure (⇑f '' s)

Next tactic:
intros
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> 

Proof state:
case intro.intro.add
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
⊢ ∀ {a b : R},
    AddGroup.InClosure (Monoid.Closure s) a →
      AddGroup.InClosure (Monoid.Closure s) b →
        f a ∈ closure (⇑f '' s) → f b ∈ closure (⇑f '' s) → f (a + b) ∈ closure (⇑f '' s)

Next tactic:
intros
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> 

Proof state:
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
⊢ ∀ {a : R} (a_1 : a ∈ Monoid.Closure s),
    (fun {x} x_1 => f x ∈ closure (⇑f '' s)) (_ : AddGroup.InClosure (Monoid.Closure s) a)

Next tactic:
intros
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · 

Proof state:
case intro.intro.zero
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
⊢ f 0 ∈ closure (⇑f '' s)

Next tactic:
rw [f.map_zero]
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    

Proof state:
case intro.intro.zero
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
⊢ 0 ∈ closure (⇑f '' s)

Next tactic:
apply closure.isSubring.zero_mem
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · 

Proof state:
case intro.intro.neg
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : AddGroup.InClosure (Monoid.Closure s) a✝¹
a_ih✝ : f a✝¹ ∈ closure (⇑f '' s)
⊢ f (-a✝¹) ∈ closure (⇑f '' s)

Next tactic:
rw [f.map_neg]
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    

Proof state:
case intro.intro.neg
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : AddGroup.InClosure (Monoid.Closure s) a✝¹
a_ih✝ : f a✝¹ ∈ closure (⇑f '' s)
⊢ -f a✝¹ ∈ closure (⇑f '' s)

Next tactic:
apply closure.isSubring.neg_mem
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    

Proof state:
case intro.intro.neg
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : AddGroup.InClosure (Monoid.Closure s) a✝¹
a_ih✝ : f a✝¹ ∈ closure (⇑f '' s)
⊢ f a✝¹ ∈ closure (⇑f '' s)

Next tactic:
assumption
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · 

Proof state:
case intro.intro.add
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝² b✝ : R
a✝¹ : AddGroup.InClosure (Monoid.Closure s) a✝²
a✝ : AddGroup.InClosure (Monoid.Closure s) b✝
a_ih✝¹ : f a✝² ∈ closure (⇑f '' s)
a_ih✝ : f b✝ ∈ closure (⇑f '' s)
⊢ f (a✝² + b✝) ∈ closure (⇑f '' s)

Next tactic:
rw [f.map_add]
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    

Proof state:
case intro.intro.add
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝² b✝ : R
a✝¹ : AddGroup.InClosure (Monoid.Closure s) a✝²
a✝ : AddGroup.InClosure (Monoid.Closure s) b✝
a_ih✝¹ : f a✝² ∈ closure (⇑f '' s)
a_ih✝ : f b✝ ∈ closure (⇑f '' s)
⊢ f a✝² + f b✝ ∈ closure (⇑f '' s)

Next tactic:
apply closure.isSubring.add_mem
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    apply closure.isSubring.add_mem
    

Proof state:
case intro.intro.add.a
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝² b✝ : R
a✝¹ : AddGroup.InClosure (Monoid.Closure s) a✝²
a✝ : AddGroup.InClosure (Monoid.Closure s) b✝
a_ih✝¹ : f a✝² ∈ closure (⇑f '' s)
a_ih✝ : f b✝ ∈ closure (⇑f '' s)
⊢ f a✝² ∈ closure (⇑f '' s)
case intro.intro.add.a
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝² b✝ : R
a✝¹ : AddGroup.InClosure (Monoid.Closure s) a✝²
a✝ : AddGroup.InClosure (Monoid.Closure s) b✝
a_ih✝¹ : f a✝² ∈ closure (⇑f '' s)
a_ih✝ : f b✝ ∈ closure (⇑f '' s)
⊢ f b✝ ∈ closure (⇑f '' s)

Next tactic:
assumption'
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    apply closure.isSubring.add_mem
    assumption'
  · 

Proof state:
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : a✝¹ ∈ Monoid.Closure s
⊢ f a✝¹ ∈ closure (⇑f '' s)

Next tactic:
apply AddGroup.mem_closure
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    apply closure.isSubring.add_mem
    assumption'
  · apply AddGroup.mem_closure
    

Proof state:
case a
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : a✝¹ ∈ Monoid.Closure s
⊢ f a✝¹ ∈ Monoid.Closure (⇑f '' s)

Next tactic:
rw [← Monoid.image_closure f.to_isMonoidHom]
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    apply closure.isSubring.add_mem
    assumption'
  · apply AddGroup.mem_closure
    rw [← Monoid.image_closure f.to_isMonoidHom]
    

Proof state:
case a
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : a✝¹ ∈ Monoid.Closure s
⊢ f a✝¹ ∈ ⇑f '' Monoid.Closure s

Next tactic:
apply Set.mem_image_of_mem
theorem image_closure {S : Type*} [Ring S] (f : R →+* S) (s : Set R) :
    f '' closure s = closure (f '' s) := by
  refine' le_antisymm _ (closure_subset (RingHom.isSubring_image _ closure.isSubring) <|
    Set.image_subset _ subset_closure)
  rintro _ ⟨x, hx, rfl⟩
  apply AddGroup.InClosure.recOn (motive := fun {x} _ ↦ f x ∈ closure (f '' s)) hx _ <;> intros
  · rw [f.map_zero]
    apply closure.isSubring.zero_mem
  · rw [f.map_neg]
    apply closure.isSubring.neg_mem
    assumption
  · rw [f.map_add]
    apply closure.isSubring.add_mem
    assumption'
  · apply AddGroup.mem_closure
    rw [← Monoid.image_closure f.to_isMonoidHom]
    apply Set.mem_image_of_mem
    

Proof state:
case a.h
R : Type u
inst✝² : Ring R
cR : Type u
inst✝¹ : CommRing cR
s✝ : Set R
S : Type u_1
inst✝ : Ring S
f : R →+* S
s : Set R
x : R
hx : x ∈ closure s
a✝¹ : R
a✝ : a✝¹ ∈ Monoid.Closure s
⊢ a✝¹ ∈ Monoid.Closure s

Next tactic:
assumption
@[to_additive]
theorem integral_inv_eq_self (f : G → E) (μ : Measure G) [IsInvInvariant μ] :
    ∫ x, f x⁻¹ ∂μ = ∫ x, f x ∂μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableInv G
f : G → E
μ : Measure G
inst✝ : IsInvInvariant μ
⊢ ∫ (x : G), f x⁻¹ ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
have h : MeasurableEmbedding fun x : G => x⁻¹ := (MeasurableEquiv.inv G).measurableEmbedding
@[to_additive]
theorem integral_inv_eq_self (f : G → E) (μ : Measure G) [IsInvInvariant μ] :
    ∫ x, f x⁻¹ ∂μ = ∫ x, f x ∂μ := by
  have h : MeasurableEmbedding fun x : G => x⁻¹ := (MeasurableEquiv.inv G).measurableEmbedding
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableInv G
f : G → E
μ : Measure G
inst✝ : IsInvInvariant μ
h : MeasurableEmbedding fun x => x⁻¹
⊢ ∫ (x : G), f x⁻¹ ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
rw [← h.integral_map, map_inv_eq_self]
/-- Translating a function by left-multiplication does not change its integral with respect to a
left-invariant measure. -/
@[to_additive
      "Translating a function by left-addition does not change its integral with respect to a
      left-invariant measure."] -- Porting note: was `@[simp]`
theorem integral_mul_left_eq_self [IsMulLeftInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (g * x) ∂μ) = ∫ x, f x ∂μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
f : G → E
g : G
⊢ ∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
have h_mul : MeasurableEmbedding fun x => g * x := (MeasurableEquiv.mulLeft g).measurableEmbedding
/-- Translating a function by left-multiplication does not change its integral with respect to a
left-invariant measure. -/
@[to_additive
      "Translating a function by left-addition does not change its integral with respect to a
      left-invariant measure."] -- Porting note: was `@[simp]`
theorem integral_mul_left_eq_self [IsMulLeftInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (g * x) ∂μ) = ∫ x, f x ∂μ := by
  have h_mul : MeasurableEmbedding fun x => g * x := (MeasurableEquiv.mulLeft g).measurableEmbedding
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
f : G → E
g : G
h_mul : MeasurableEmbedding fun x => g * x
⊢ ∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
rw [← h_mul.integral_map, map_mul_left_eq_self]
/-- Translating a function by right-multiplication does not change its integral with respect to a
right-invariant measure. -/
@[to_additive
      "Translating a function by right-addition does not change its integral with respect to a
      right-invariant measure."] -- Porting note: was `@[simp]`
theorem integral_mul_right_eq_self [IsMulRightInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (x * g) ∂μ) = ∫ x, f x ∂μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
⊢ ∫ (x : G), f (x * g) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
have h_mul : MeasurableEmbedding fun x => x * g :=
    (MeasurableEquiv.mulRight g).measurableEmbedding
/-- Translating a function by right-multiplication does not change its integral with respect to a
right-invariant measure. -/
@[to_additive
      "Translating a function by right-addition does not change its integral with respect to a
      right-invariant measure."] -- Porting note: was `@[simp]`
theorem integral_mul_right_eq_self [IsMulRightInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (x * g) ∂μ) = ∫ x, f x ∂μ := by
  have h_mul : MeasurableEmbedding fun x => x * g :=
    (MeasurableEquiv.mulRight g).measurableEmbedding
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
h_mul : MeasurableEmbedding fun x => x * g
⊢ ∫ (x : G), f (x * g) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
rw [← h_mul.integral_map, map_mul_right_eq_self]
@[to_additive] -- Porting note: was `@[simp]`
theorem integral_div_right_eq_self [IsMulRightInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (x / g) ∂μ) = ∫ x, f x ∂μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
⊢ ∫ (x : G), f (x / g) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
simp_rw [div_eq_mul_inv]
@[to_additive] -- Porting note: was `@[simp]`
theorem integral_div_right_eq_self [IsMulRightInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (x / g) ∂μ) = ∫ x, f x ∂μ := by
  simp_rw [div_eq_mul_inv]
  -- Porting note: was `simp_rw`
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
f : G → E
g : G
⊢ ∫ (x : G), f (x * g⁻¹) ∂μ = ∫ (x : G), f x ∂μ

Next tactic:
rw [integral_mul_right_eq_self f g⁻¹]
/-- If some left-translate of a function negates it, then the integral of the function with respect
to a left-invariant measure is 0. -/
@[to_additive
      "If some left-translate of a function negates it, then the integral of the function with
      respect to a left-invariant measure is 0."]
theorem integral_eq_zero_of_mul_left_eq_neg [IsMulLeftInvariant μ] (hf' : ∀ x, f (g * x) = -f x) :
    ∫ x, f x ∂μ = 0 := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulLeftInvariant μ
hf' : ∀ (x : G), f (g * x) = -f x
⊢ ∫ (x : G), f x ∂μ = 0

Next tactic:
simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_left_eq_self]
/-- If some right-translate of a function negates it, then the integral of the function with respect
to a right-invariant measure is 0. -/
@[to_additive
      "If some right-translate of a function negates it, then the integral of the function with
      respect to a right-invariant measure is 0."]
theorem integral_eq_zero_of_mul_right_eq_neg [IsMulRightInvariant μ] (hf' : ∀ x, f (x * g) = -f x) :
    ∫ x, f x ∂μ = 0 := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
inst✝ : IsMulRightInvariant μ
hf' : ∀ (x : G), f (x * g) = -f x
⊢ ∫ (x : G), f x ∂μ = 0

Next tactic:
simp_rw [← self_eq_neg ℝ E, ← integral_neg, ← hf', integral_mul_right_eq_self]
@[to_additive]
theorem Integrable.comp_div_right {f : G → F} [IsMulRightInvariant μ] (hf : Integrable f μ)
    (g : G) : Integrable (fun t => f (t / g)) μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : IsMulRightInvariant μ
hf : Integrable f
g : G
⊢ Integrable fun t => f (t / g)

Next tactic:
simp_rw [div_eq_mul_inv]
@[to_additive]
theorem Integrable.comp_div_right {f : G → F} [IsMulRightInvariant μ] (hf : Integrable f μ)
    (g : G) : Integrable (fun t => f (t / g)) μ := by
  simp_rw [div_eq_mul_inv]
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝² : Group G
inst✝¹ : MeasurableMul G
f : G → F
inst✝ : IsMulRightInvariant μ
hf : Integrable f
g : G
⊢ Integrable fun t => f (t * g⁻¹)

Next tactic:
exact hf.comp_mul_right g⁻¹
@[to_additive] -- Porting note: was `@[simp]`
theorem integrable_comp_div_left (f : G → F) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    Integrable (fun t => f (g / t)) μ ↔ Integrable f μ := by
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
⊢ (Integrable fun t => f (g / t)) ↔ Integrable f

Next tactic:
refine' ⟨fun h => _, fun h => h.comp_div_left g⟩
@[to_additive] -- Porting note: was `@[simp]`
theorem integrable_comp_div_left (f : G → F) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    Integrable (fun t => f (g / t)) μ ↔ Integrable f μ := by
  refine' ⟨fun h => _, fun h => h.comp_div_left g⟩
  

Proof state:
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
h : Integrable fun t => f (g / t)
⊢ Integrable f

Next tactic:
convert h.comp_inv.comp_mul_left g⁻¹
@[to_additive] -- Porting note: was `@[simp]`
theorem integrable_comp_div_left (f : G → F) [IsInvInvariant μ] [IsMulLeftInvariant μ] (g : G) :
    Integrable (fun t => f (g / t)) μ ↔ Integrable f μ := by
  refine' ⟨fun h => _, fun h => h.comp_div_left g⟩
  convert h.comp_inv.comp_mul_left g⁻¹
  

Proof state:
case h.e'_5.h.h.e'_1
𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁹ : MeasurableSpace G
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NormedAddCommGroup F
μ : Measure G
f✝ : G → E
g✝ : G
inst✝⁴ : Group G
inst✝³ : MeasurableMul G
inst✝² : MeasurableInv G
f : G → F
inst✝¹ : IsInvInvariant μ
inst✝ : IsMulLeftInvariant μ
g : G
h : Integrable fun t => f (g / t)
x✝ : G
⊢ x✝ = g / (g⁻¹ * x✝)⁻¹

Next tactic:
simp_rw [div_inv_eq_mul, mul_inv_cancel_left]