File: Mathlib/MeasureTheory/Group/Prod.lean

full_name: MeasurableEquiv.shearAddRight
code: /-- The map `(x, y) ↦ (x, xy)` as a `MeasurableEquiv`. -/
@[to_additive "The map `(x, y) ↦ (x, x + y)` as a `MeasurableEquiv`."]
protected def MeasurableEquiv.shearMulRight [MeasurableInv G] : G × G ≃ᵐ G × G 
goal: G × G ≃ᵐ G × G

full_name: MeasurableEquiv.shearMulRight
code: /-- The map `(x, y) ↦ (x, xy)` as a `MeasurableEquiv`. -/
@[to_additive "The map `(x, y) ↦ (x, x + y)` as a `MeasurableEquiv`."]
protected def MeasurableEquiv.shearMulRight [MeasurableInv G] : G × G ≃ᵐ G × G 
goal: G × G ≃ᵐ G × G

full_name: MeasurableEquiv.shearDivRight
code: /-- The map `(x, y) ↦ (x, y / x)` as a `MeasurableEquiv` with as inverse `(x, y) ↦ (x, yx)` -/
@[to_additive
"The map `(x, y) ↦ (x, y - x)` as a `MeasurableEquiv` with as inverse `(x, y) ↦ (x, y + x)`."]
protected def MeasurableEquiv.shearDivRight [MeasurableInv G] : G × G ≃ᵐ G × G 
goal: G × G ≃ᵐ G × G

full_name: MeasurableEquiv.shearSubRight
code: /-- The map `(x, y) ↦ (x, y / x)` as a `MeasurableEquiv` with as inverse `(x, y) ↦ (x, yx)` -/
@[to_additive
"The map `(x, y) ↦ (x, y - x)` as a `MeasurableEquiv` with as inverse `(x, y) ↦ (x, y + x)`."]
protected def MeasurableEquiv.shearDivRight [MeasurableInv G] : G × G ≃ᵐ G × G 
goal: G × G ≃ᵐ G × G

full_name: MeasureTheory.measurePreserving_prod_mul
code: /-- The multiplicative shear mapping `(x, y) ↦ (x, xy)` preserves the measure `μ × ν`.
This condition is part of the definition of a measurable group in [Halmos, §59].
There, the map in this lemma is called `S`. -/
@[to_additive measurePreserving_prod_add
" The shear mapping `(x, y) ↦ (x, x + y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_prod_mul [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.1 * z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.1 * z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_add
code: /-- The multiplicative shear mapping `(x, y) ↦ (x, xy)` preserves the measure `μ × ν`.
This condition is part of the definition of a measurable group in [Halmos, §59].
There, the map in this lemma is called `S`. -/
@[to_additive measurePreserving_prod_add
" The shear mapping `(x, y) ↦ (x, x + y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_prod_mul [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.1 * z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.1 + z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_mul_swap
code: /-- The map `(x, y) ↦ (y, yx)` sends the measure `μ × ν` to `ν × μ`.
This is the map `SR` in [Halmos, §59].
`S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_prod_add_swap
" The map `(x, y) ↦ (y, y + x)` sends the measure `μ × ν` to `ν × μ`. "]
theorem measurePreserving_prod_mul_swap [IsMulLeftInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.2 * z.1)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.2 * z.1)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_prod_add_swap
code: /-- The map `(x, y) ↦ (y, yx)` sends the measure `μ × ν` to `ν × μ`.
This is the map `SR` in [Halmos, §59].
`S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_prod_add_swap
" The map `(x, y) ↦ (y, y + x)` sends the measure `μ × ν` to `ν × μ`. "]
theorem measurePreserving_prod_mul_swap [IsMulLeftInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.2 * z.1)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.2 + z.1)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurable_measure_mul_right
code: @[to_additive]
theorem measurable_measure_mul_right (hs : MeasurableSet s) :
    Measurable fun x => μ ((fun y => y * x) ⁻¹' s) 
goal: Measurable fun x => μ ((fun y => y * x) ⁻¹' s)

full_name: MeasureTheory.measurable_measure_add_right
code: @[to_additive]
theorem measurable_measure_mul_right (hs : MeasurableSet s) :
    Measurable fun x => μ ((fun y => y * x) ⁻¹' s) 
goal: Measurable fun x => μ ((fun y => y + x) ⁻¹' s)

full_name: MeasureTheory.measurePreserving_prod_neg_add
code: /-- The map `(x, y) ↦ (x, x⁻¹y)` is measure-preserving.
This is the function `S⁻¹` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)`. -/
@[to_additive measurePreserving_prod_neg_add
"The map `(x, y) ↦ (x, - x + y)` is measure-preserving."]
theorem measurePreserving_prod_inv_mul [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.1⁻¹ * z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, -z.1 + z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_inv_mul
code: /-- The map `(x, y) ↦ (x, x⁻¹y)` is measure-preserving.
This is the function `S⁻¹` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)`. -/
@[to_additive measurePreserving_prod_neg_add
"The map `(x, y) ↦ (x, - x + y)` is measure-preserving."]
theorem measurePreserving_prod_inv_mul [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.1⁻¹ * z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.1⁻¹ * z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_inv_mul_swap
code: /-- The map `(x, y) ↦ (y, y⁻¹x)` sends `μ × ν` to `ν × μ`.
This is the function `S⁻¹R` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_prod_neg_add_swap
"The map `(x, y) ↦ (y, - y + x)` sends `μ × ν` to `ν × μ`."]
theorem measurePreserving_prod_inv_mul_swap :
    MeasurePreserving (fun z : G × G => (z.2, z.2⁻¹ * z.1)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.2⁻¹ * z.1)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_prod_neg_add_swap
code: /-- The map `(x, y) ↦ (y, y⁻¹x)` sends `μ × ν` to `ν × μ`.
This is the function `S⁻¹R` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_prod_neg_add_swap
"The map `(x, y) ↦ (y, - y + x)` sends `μ × ν` to `ν × μ`."]
theorem measurePreserving_prod_inv_mul_swap :
    MeasurePreserving (fun z : G × G => (z.2, z.2⁻¹ * z.1)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, -z.2 + z.1)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_mul_prod_inv
code: /-- The map `(x, y) ↦ (yx, x⁻¹)` is measure-preserving.
This is the function `S⁻¹RSR` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_add_prod_neg
"The map `(x, y) ↦ (y + x, - x)` is measure-preserving."]
theorem measurePreserving_mul_prod_inv [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.2 * z.1, z.1⁻¹)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2 * z.1, z.1⁻¹)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_add_prod_neg
code: /-- The map `(x, y) ↦ (yx, x⁻¹)` is measure-preserving.
This is the function `S⁻¹RSR` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)` and `R` is `Prod.swap`. -/
@[to_additive measurePreserving_add_prod_neg
"The map `(x, y) ↦ (y + x, - x)` is measure-preserving."]
theorem measurePreserving_mul_prod_inv [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.2 * z.1, z.1⁻¹)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2 + z.1, -z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.quasiMeasurePreserving_inv
code: @[to_additive]
theorem quasiMeasurePreserving_inv : QuasiMeasurePreserving (Inv.inv : G → G) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Inv.inv μ μ

full_name: MeasureTheory.quasiMeasurePreserving_neg
code: @[to_additive]
theorem quasiMeasurePreserving_inv : QuasiMeasurePreserving (Inv.inv : G → G) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Neg.neg μ μ

full_name: MeasureTheory.measure_neg_null
code: @[to_additive (attr := simp)]
theorem measure_inv_null : μ s⁻¹ = 0 ↔ μ s = 0 
goal: μ (-s) = 0 ↔ μ s = 0

full_name: MeasureTheory.measure_inv_null
code: @[to_additive (attr := simp)]
theorem measure_inv_null : μ s⁻¹ = 0 ↔ μ s = 0 
goal: μ s⁻¹ = 0 ↔ μ s = 0

full_name: MeasureTheory.neg_ae
code: @[to_additive (attr := simp)]
theorem inv_ae : (ae μ)⁻¹ = ae μ 
goal: -MeasureTheory.ae μ = MeasureTheory.ae μ

full_name: MeasureTheory.inv_ae
code: @[to_additive (attr := simp)]
theorem inv_ae : (ae μ)⁻¹ = ae μ 
goal: (MeasureTheory.ae μ)⁻¹ = MeasureTheory.ae μ

full_name: MeasureTheory.eventuallyConst_inv_set_ae
code: @[to_additive (attr := simp)]
theorem eventuallyConst_inv_set_ae :
    EventuallyConst (s⁻¹ : Set G) (ae μ) ↔ EventuallyConst s (ae μ) 
goal: Filter.EventuallyConst s⁻¹ (MeasureTheory.ae μ) ↔ Filter.EventuallyConst s (MeasureTheory.ae μ)

full_name: MeasureTheory.eventuallyConst_neg_set_ae
code: @[to_additive (attr := simp)]
theorem eventuallyConst_inv_set_ae :
    EventuallyConst (s⁻¹ : Set G) (ae μ) ↔ EventuallyConst s (ae μ) 
goal: Filter.EventuallyConst (-s) (MeasureTheory.ae μ) ↔ Filter.EventuallyConst s (MeasureTheory.ae μ)

full_name: MeasureTheory.neg_absolutelyContinuous
code: @[to_additive]
theorem inv_absolutelyContinuous : μ.inv ≪ μ 
goal: μ.neg ≪ μ

full_name: MeasureTheory.inv_absolutelyContinuous
code: @[to_additive]
theorem inv_absolutelyContinuous : μ.inv ≪ μ 
goal: μ.inv ≪ μ

full_name: MeasureTheory.absolutelyContinuous_neg
code: @[to_additive]
theorem absolutelyContinuous_inv : μ ≪ μ.inv 
goal: μ ≪ μ.neg

full_name: MeasureTheory.absolutelyContinuous_inv
code: @[to_additive]
theorem absolutelyContinuous_inv : μ ≪ μ.inv 
goal: μ ≪ μ.inv

full_name: MeasureTheory.lintegral_lintegral_add_neg
code: @[to_additive]
theorem lintegral_lintegral_mul_inv [IsMulLeftInvariant ν] (f : G → G → ℝ≥0∞)
    (hf : AEMeasurable (uncurry f) (μ.prod ν)) :
    (∫⁻ x, ∫⁻ y, f (y * x) x⁻¹ ∂ν ∂μ) = ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ 
goal: ∫⁻ (x : G), ∫⁻ (y : G), f (y + x) (-x) ∂ν ∂μ = ∫⁻ (x : G), ∫⁻ (y : G), f x y ∂ν ∂μ

full_name: MeasureTheory.lintegral_lintegral_mul_inv
code: @[to_additive]
theorem lintegral_lintegral_mul_inv [IsMulLeftInvariant ν] (f : G → G → ℝ≥0∞)
    (hf : AEMeasurable (uncurry f) (μ.prod ν)) :
    (∫⁻ x, ∫⁻ y, f (y * x) x⁻¹ ∂ν ∂μ) = ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ 
goal: ∫⁻ (x : G), ∫⁻ (y : G), f (y * x) x⁻¹ ∂ν ∂μ = ∫⁻ (x : G), ∫⁻ (y : G), f x y ∂ν ∂μ

full_name: MeasureTheory.measure_add_right_null
code: @[to_additive]
theorem measure_mul_right_null (y : G) : μ ((fun x => x * y) ⁻¹' s) = 0 ↔ μ s = 0 
goal: μ ((fun x => x + y) ⁻¹' s) = 0 ↔ μ s = 0

full_name: MeasureTheory.measure_mul_right_null
code: @[to_additive]
theorem measure_mul_right_null (y : G) : μ ((fun x => x * y) ⁻¹' s) = 0 ↔ μ s = 0 
goal: μ ((fun x => x * y) ⁻¹' s) = 0 ↔ μ s = 0

full_name: MeasureTheory.measure_add_right_ne_zero
code: @[to_additive]
theorem measure_mul_right_ne_zero (h2s : μ s ≠ 0) (y : G) : μ ((fun x => x * y) ⁻¹' s) ≠ 0 
goal: μ ((fun x => x + y) ⁻¹' s) ≠ 0

full_name: MeasureTheory.measure_mul_right_ne_zero
code: @[to_additive]
theorem measure_mul_right_ne_zero (h2s : μ s ≠ 0) (y : G) : μ ((fun x => x * y) ⁻¹' s) ≠ 0 
goal: μ ((fun x => x * y) ⁻¹' s) ≠ 0

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

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

full_name: MeasureTheory.absolutelyContinuous_map_sub_left
code: @[to_additive]
theorem absolutelyContinuous_map_div_left (g : G) : μ ≪ map (fun h => g / h) μ 
goal: μ ≪ MeasureTheory.Measure.map (fun h => g - h) μ

full_name: MeasureTheory.absolutelyContinuous_map_div_left
code: @[to_additive]
theorem absolutelyContinuous_map_div_left (g : G) : μ ≪ map (fun h => g / h) μ 
goal: μ ≪ MeasureTheory.Measure.map (fun h => g / h) μ

full_name: MeasureTheory.measure_mul_lintegral_eq
code: /-- This is the computation performed in the proof of [Halmos, §60 Th. A]. -/
@[to_additive "This is the computation performed in the proof of [Halmos, §60 Th. A]."]
theorem measure_mul_lintegral_eq [IsMulLeftInvariant ν] (sm : MeasurableSet s) (f : G → ℝ≥0∞)
    (hf : Measurable f) : (μ s * ∫⁻ y, f y ∂ν) = ∫⁻ x, ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ 
goal: μ s * ∫⁻ (y : G), f y ∂ν = ∫⁻ (x : G), ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ

full_name: MeasureTheory.measure_add_lintegral_eq
code: /-- This is the computation performed in the proof of [Halmos, §60 Th. A]. -/
@[to_additive "This is the computation performed in the proof of [Halmos, §60 Th. A]."]
theorem measure_mul_lintegral_eq [IsMulLeftInvariant ν] (sm : MeasurableSet s) (f : G → ℝ≥0∞)
    (hf : Measurable f) : (μ s * ∫⁻ y, f y ∂ν) = ∫⁻ x, ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ 
goal: μ s * ∫⁻ (y : G), f y ∂ν = ∫⁻ (x : G), ν ((fun z => z + x) ⁻¹' s) * f (-x) ∂μ

full_name: MeasureTheory.absolutelyContinuous_of_isAddLeftInvariant
code: /-- Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. -/
@[to_additive
" Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. "]
theorem absolutelyContinuous_of_isMulLeftInvariant [IsMulLeftInvariant ν] (hν : ν ≠ 0) : μ ≪ ν 
goal: μ ≪ ν

full_name: MeasureTheory.absolutelyContinuous_of_isMulLeftInvariant
code: /-- Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. -/
@[to_additive
" Any two nonzero left-invariant measures are absolutely continuous w.r.t. each other. "]
theorem absolutelyContinuous_of_isMulLeftInvariant [IsMulLeftInvariant ν] (hν : ν ≠ 0) : μ ≪ ν 
goal: μ ≪ ν

full_name: MeasureTheory.ae_measure_preimage_mul_right_lt_top
code: @[to_additive]
theorem ae_measure_preimage_mul_right_lt_top (hμs : μ' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((· * x) ⁻¹' s) < ∞ 
goal: ∀ᵐ (x : G) ∂μ', ν' ((fun x_1 => x_1 * x) ⁻¹' s) < ⊤

full_name: MeasureTheory.ae_measure_preimage_add_right_lt_top
code: @[to_additive]
theorem ae_measure_preimage_mul_right_lt_top (hμs : μ' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((· * x) ⁻¹' s) < ∞ 
goal: ∀ᵐ (x : G) ∂μ', ν' ((fun x_1 => x_1 + x) ⁻¹' s) < ⊤

full_name: MeasureTheory.ae_measure_preimage_add_right_lt_top_of_ne_zero
code: @[to_additive]
theorem ae_measure_preimage_mul_right_lt_top_of_ne_zero (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((fun y => y * x) ⁻¹' s) < ∞ 
goal: ∀ᵐ (x : G) ∂μ', ν' ((fun y => y + x) ⁻¹' s) < ⊤

full_name: MeasureTheory.ae_measure_preimage_mul_right_lt_top_of_ne_zero
code: @[to_additive]
theorem ae_measure_preimage_mul_right_lt_top_of_ne_zero (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((fun y => y * x) ⁻¹' s) < ∞ 
goal: ∀ᵐ (x : G) ∂μ', ν' ((fun y => y * x) ⁻¹' s) < ⊤

full_name: MeasureTheory.measure_lintegral_sub_measure
code: /-- A technical lemma relating two different measures. This is basically [Halmos, §60 Th. A].
  Note that if `f` is the characteristic function of a measurable set `t` this states that
  `μ t = c * μ s` for a constant `c` that does not depend on `μ`.

  Note: There is a gap in the last step of the proof in [Halmos].
  In the last line, the equality `g(x⁻¹)ν(sx⁻¹) = f(x)` holds if we can prove that
  `0 < ν(sx⁻¹) < ∞`. The first inequality follows from §59, Th. D, but the second inequality is
  not justified. We prove this inequality for almost all `x` in
  `MeasureTheory.ae_measure_preimage_mul_right_lt_top_of_ne_zero`. -/
@[to_additive
"A technical lemma relating two different measures. This is basically [Halmos, §60 Th. A]. Note that
if `f` is the characteristic function of a measurable set `t` this states that `μ t = c * μ s` for a
constant `c` that does not depend on `μ`.

Note: There is a gap in the last step of the proof in [Halmos]. In the last line, the equality
`g(-x) + ν(s - x) = f(x)` holds if we can prove that `0 < ν(s - x) < ∞`. The first inequality
follows from §59, Th. D, but the second inequality is not justified. We prove this inequality for
almost all `x` in `MeasureTheory.ae_measure_preimage_add_right_lt_top_of_ne_zero`."]
theorem measure_lintegral_div_measure (sm : MeasurableSet s) (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞)
    (f : G → ℝ≥0∞) (hf : Measurable f) :
    (μ' s * ∫⁻ y, f y⁻¹ / ν' ((· * y⁻¹) ⁻¹' s) ∂ν') = ∫⁻ x, f x ∂μ' 
goal: μ' s * ∫⁻ (y : G), f (-y) / ν' ((fun x => x + -y) ⁻¹' s) ∂ν' = ∫⁻ (x : G), f x ∂μ'

full_name: MeasureTheory.measure_lintegral_div_measure
code: /-- A technical lemma relating two different measures. This is basically [Halmos, §60 Th. A].
  Note that if `f` is the characteristic function of a measurable set `t` this states that
  `μ t = c * μ s` for a constant `c` that does not depend on `μ`.

  Note: There is a gap in the last step of the proof in [Halmos].
  In the last line, the equality `g(x⁻¹)ν(sx⁻¹) = f(x)` holds if we can prove that
  `0 < ν(sx⁻¹) < ∞`. The first inequality follows from §59, Th. D, but the second inequality is
  not justified. We prove this inequality for almost all `x` in
  `MeasureTheory.ae_measure_preimage_mul_right_lt_top_of_ne_zero`. -/
@[to_additive
"A technical lemma relating two different measures. This is basically [Halmos, §60 Th. A]. Note that
if `f` is the characteristic function of a measurable set `t` this states that `μ t = c * μ s` for a
constant `c` that does not depend on `μ`.

Note: There is a gap in the last step of the proof in [Halmos]. In the last line, the equality
`g(-x) + ν(s - x) = f(x)` holds if we can prove that `0 < ν(s - x) < ∞`. The first inequality
follows from §59, Th. D, but the second inequality is not justified. We prove this inequality for
almost all `x` in `MeasureTheory.ae_measure_preimage_add_right_lt_top_of_ne_zero`."]
theorem measure_lintegral_div_measure (sm : MeasurableSet s) (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞)
    (f : G → ℝ≥0∞) (hf : Measurable f) :
    (μ' s * ∫⁻ y, f y⁻¹ / ν' ((· * y⁻¹) ⁻¹' s) ∂ν') = ∫⁻ x, f x ∂μ' 
goal: μ' s * ∫⁻ (y : G), f y⁻¹ / ν' ((fun x => x * y⁻¹) ⁻¹' s) ∂ν' = ∫⁻ (x : G), f x ∂μ'

full_name: MeasureTheory.measure_add_measure_eq
code: @[to_additive]
theorem measure_mul_measure_eq (s t : Set G) (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    μ' s * ν' t = ν' s * μ' t 
goal: μ' s * ν' t = ν' s * μ' t

full_name: MeasureTheory.measure_mul_measure_eq
code: @[to_additive]
theorem measure_mul_measure_eq (s t : Set G) (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    μ' s * ν' t = ν' s * μ' t 
goal: μ' s * ν' t = ν' s * μ' t

full_name: MeasureTheory.measure_eq_div_smul
code: /-- Left invariant Borel measures on a measurable group are unique (up to a scalar). -/
@[to_additive
" Left invariant Borel measures on an additive measurable group are unique (up to a scalar). "]
theorem measure_eq_div_smul (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    μ' = (μ' s / ν' s) • ν' 
goal: μ' = (μ' s / ν' s) • ν'

full_name: MeasureTheory.measure_eq_sub_vadd
code: /-- Left invariant Borel measures on a measurable group are unique (up to a scalar). -/
@[to_additive
" Left invariant Borel measures on an additive measurable group are unique (up to a scalar). "]
theorem measure_eq_div_smul (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    μ' = (μ' s / ν' s) • ν' 
goal: μ' = (μ' s / ν' s) • ν'

full_name: MeasureTheory.measurePreserving_prod_mul_right
code: @[to_additive measurePreserving_prod_add_right]
theorem measurePreserving_prod_mul_right [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.2 * z.1)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.2 * z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_add_right
code: @[to_additive measurePreserving_prod_add_right]
theorem measurePreserving_prod_mul_right [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.2 * z.1)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.2 + z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_add_swap_right
code: /-- The map `(x, y) ↦ (y, xy)` sends the measure `μ × ν` to `ν × μ`. -/
@[to_additive measurePreserving_prod_add_swap_right
" The map `(x, y) ↦ (y, x + y)` sends the measure `μ × ν` to `ν × μ`. "]
theorem measurePreserving_prod_mul_swap_right [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.1 * z.2)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 + z.2)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_prod_mul_swap_right
code: /-- The map `(x, y) ↦ (y, xy)` sends the measure `μ × ν` to `ν × μ`. -/
@[to_additive measurePreserving_prod_add_swap_right
" The map `(x, y) ↦ (y, x + y)` sends the measure `μ × ν` to `ν × μ`. "]
theorem measurePreserving_prod_mul_swap_right [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.1 * z.2)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 * z.2)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_add_prod
code: /-- The map `(x, y) ↦ (xy, y)` preserves the measure `μ × ν`. -/
@[to_additive measurePreserving_add_prod
" The map `(x, y) ↦ (x + y, y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_mul_prod [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.1 * z.2, z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 + z.2, z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_mul_prod
code: /-- The map `(x, y) ↦ (xy, y)` preserves the measure `μ × ν`. -/
@[to_additive measurePreserving_add_prod
" The map `(x, y) ↦ (x + y, y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_mul_prod [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.1 * z.2, z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 * z.2, z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_div
code: /-- The map `(x, y) ↦ (x, y / x)` is measure-preserving. -/
@[to_additive measurePreserving_prod_sub "The map `(x, y) ↦ (x, y - x)` is measure-preserving."]
theorem measurePreserving_prod_div [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.2 / z.1)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.2 / z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_sub
code: /-- The map `(x, y) ↦ (x, y / x)` is measure-preserving. -/
@[to_additive measurePreserving_prod_sub "The map `(x, y) ↦ (x, y - x)` is measure-preserving."]
theorem measurePreserving_prod_div [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.2 / z.1)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1, z.2 - z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_prod_div_swap
code: /-- The map `(x, y) ↦ (y, x / y)` sends `μ × ν` to `ν × μ`. -/
@[to_additive measurePreserving_prod_sub_swap
      "The map `(x, y) ↦ (y, x - y)` sends `μ × ν` to `ν × μ`."]
theorem measurePreserving_prod_div_swap [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_prod_sub_swap
code: /-- The map `(x, y) ↦ (y, x / y)` sends `μ × ν` to `ν × μ`. -/
@[to_additive measurePreserving_prod_sub_swap
      "The map `(x, y) ↦ (y, x - y)` sends `μ × ν` to `ν × μ`."]
theorem measurePreserving_prod_div_swap [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.2, z.1 / z.2)) (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.2, z.1 - z.2)) (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.measurePreserving_sub_prod
code: /-- The map `(x, y) ↦ (x / y, y)` preserves the measure `μ × ν`. -/
@[to_additive measurePreserving_sub_prod
" The map `(x, y) ↦ (x - y, y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_div_prod [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.1 / z.2, z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 - z.2, z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_div_prod
code: /-- The map `(x, y) ↦ (x / y, y)` preserves the measure `μ × ν`. -/
@[to_additive measurePreserving_sub_prod
" The map `(x, y) ↦ (x - y, y)` preserves the measure `μ × ν`. "]
theorem measurePreserving_div_prod [IsMulRightInvariant μ] :
    MeasurePreserving (fun z : G × G => (z.1 / z.2, z.2)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 / z.2, z.2)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_add_prod_neg_right
code: /-- The map `(x, y) ↦ (xy, x⁻¹)` is measure-preserving. -/
@[to_additive measurePreserving_add_prod_neg_right
"The map `(x, y) ↦ (x + y, - x)` is measure-preserving."]
theorem measurePreserving_mul_prod_inv_right [IsMulRightInvariant μ] [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1 * z.2, z.1⁻¹)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 + z.2, -z.1)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_mul_prod_inv_right
code: /-- The map `(x, y) ↦ (xy, x⁻¹)` is measure-preserving. -/
@[to_additive measurePreserving_add_prod_neg_right
"The map `(x, y) ↦ (x + y, - x)` is measure-preserving."]
theorem measurePreserving_mul_prod_inv_right [IsMulRightInvariant μ] [IsMulRightInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1 * z.2, z.1⁻¹)) (μ.prod ν) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (fun z => (z.1 * z.2, z.1⁻¹)) (μ.prod ν) (μ.prod ν)

full_name: MeasureTheory.quasiMeasurePreserving_neg_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_inv_of_right_invariant [IsMulRightInvariant μ] :
    QuasiMeasurePreserving (Inv.inv : G → G) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Neg.neg μ μ

full_name: MeasureTheory.quasiMeasurePreserving_inv_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_inv_of_right_invariant [IsMulRightInvariant μ] :
    QuasiMeasurePreserving (Inv.inv : G → G) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Inv.inv μ μ

full_name: MeasureTheory.quasiMeasurePreserving_div_left
code: @[to_additive]
theorem quasiMeasurePreserving_div_left [IsMulLeftInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g / h) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_sub_left
code: @[to_additive]
theorem quasiMeasurePreserving_div_left [IsMulLeftInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g - h) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_sub_left_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_div_left_of_right_invariant [IsMulRightInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g - h) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_div_left_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_div_left_of_right_invariant [IsMulRightInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g / h) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_sub_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_div_of_right_invariant [IsMulRightInvariant μ] :
    QuasiMeasurePreserving (fun p : G × G => p.1 / p.2) (μ.prod ν) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun p => p.1 - p.2) (μ.prod ν) μ

full_name: MeasureTheory.quasiMeasurePreserving_div_of_right_invariant
code: @[to_additive]
theorem quasiMeasurePreserving_div_of_right_invariant [IsMulRightInvariant μ] :
    QuasiMeasurePreserving (fun p : G × G => p.1 / p.2) (μ.prod ν) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun p => p.1 / p.2) (μ.prod ν) μ

full_name: MeasureTheory.quasiMeasurePreserving_sub
code: @[to_additive]
theorem quasiMeasurePreserving_div [IsMulLeftInvariant μ] :
    QuasiMeasurePreserving (fun p : G × G => p.1 / p.2) (μ.prod ν) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun p => p.1 - p.2) (μ.prod ν) μ

full_name: MeasureTheory.quasiMeasurePreserving_div
code: @[to_additive]
theorem quasiMeasurePreserving_div [IsMulLeftInvariant μ] :
    QuasiMeasurePreserving (fun p : G × G => p.1 / p.2) (μ.prod ν) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun p => p.1 / p.2) (μ.prod ν) μ

full_name: MeasureTheory.quasiMeasurePreserving_add_right
code: /-- A *left*-invariant measure is quasi-preserved by *right*-multiplication.
This should not be confused with `(measurePreserving_mul_right μ g).quasiMeasurePreserving`. -/
@[to_additive
"A *left*-invariant measure is quasi-preserved by *right*-addition.
This should not be confused with `(measurePreserving_add_right μ g).quasiMeasurePreserving`. "]
theorem quasiMeasurePreserving_mul_right [IsMulLeftInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => h * g) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => h + g) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_mul_right
code: /-- A *left*-invariant measure is quasi-preserved by *right*-multiplication.
This should not be confused with `(measurePreserving_mul_right μ g).quasiMeasurePreserving`. -/
@[to_additive
"A *left*-invariant measure is quasi-preserved by *right*-addition.
This should not be confused with `(measurePreserving_add_right μ g).quasiMeasurePreserving`. "]
theorem quasiMeasurePreserving_mul_right [IsMulLeftInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => h * g) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => h * g) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_mul_left
code: /-- A *right*-invariant measure is quasi-preserved by *left*-multiplication.
This should not be confused with `(measurePreserving_mul_left μ g).quasiMeasurePreserving`. -/
@[to_additive
"A *right*-invariant measure is quasi-preserved by *left*-addition.
This should not be confused with `(measurePreserving_add_left μ g).quasiMeasurePreserving`. "]
theorem quasiMeasurePreserving_mul_left [IsMulRightInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g * h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g * h) μ μ

full_name: MeasureTheory.quasiMeasurePreserving_add_left
code: /-- A *right*-invariant measure is quasi-preserved by *left*-multiplication.
This should not be confused with `(measurePreserving_mul_left μ g).quasiMeasurePreserving`. -/
@[to_additive
"A *right*-invariant measure is quasi-preserved by *left*-addition.
This should not be confused with `(measurePreserving_add_left μ g).quasiMeasurePreserving`. "]
theorem quasiMeasurePreserving_mul_left [IsMulRightInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g * h) μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (fun h => g + h) μ μ