File: Mathlib/MeasureTheory/Group/Action.lean

full_name: MeasureTheory.VAddInvariantMeasure.measure_preimage_vadd
code: /-- A measure `μ : Measure α` is invariant under an additive action of `M` on `α` if for any
measurable set `s : Set α` and `c : M`, the measure of its preimage under `fun x => c +ᵥ x` is equal
to the measure of `s`. -/
class VAddInvariantMeasure (M α : Type*) [VAdd M α] {_ : MeasurableSpace α} (μ : Measure α) :
  Prop where
  measure_preimage_vadd : ∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [self : MeasureTheory.VAddInvariantMeasure M α μ] (c : M)
  ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s

full_name: MeasureTheory.VAddInvariantMeasure
code: /-- A measure `μ : Measure α` is invariant under an additive action of `M` on `α` if for any
measurable set `s : Set α` and `c : M`, the measure of its preimage under `fun x => c +ᵥ x` is equal
to the measure of `s`. -/
class VAddInvariantMeasure (M α : Type*) [VAdd M α] {_ : MeasurableSpace α} (μ : Measure α) :
  Prop where
  measure_preimage_vadd : ∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → Prop

full_name: MeasureTheory.SMulInvariantMeasure
code: /-- A measure `μ : Measure α` is invariant under a multiplicative action of `M` on `α` if for any
measurable set `s : Set α` and `c : M`, the measure of its preimage under `fun x => c • x` is equal
to the measure of `s`. -/
@[to_additive]
class SMulInvariantMeasure (M α : Type*) [SMul M α] {_ : MeasurableSpace α} (μ : Measure α) :
  Prop where
  measure_preimage_smul : ∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → Prop

full_name: MeasureTheory.SMulInvariantMeasure.measure_preimage_smul
code: /-- A measure `μ : Measure α` is invariant under a multiplicative action of `M` on `α` if for any
measurable set `s : Set α` and `c : M`, the measure of its preimage under `fun x => c • x` is equal
to the measure of `s`. -/
@[to_additive]
class SMulInvariantMeasure (M α : Type*) [SMul M α] {_ : MeasurableSpace α} (μ : Measure α) :
  Prop where
  measure_preimage_smul : ∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [self : MeasureTheory.SMulInvariantMeasure M α μ] (c : M)
  ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s

full_name: MeasureTheory.SMulInvariantMeasure.zero
code: @[to_additive]
instance zero [MeasurableSpace α] [SMul M α] : SMulInvariantMeasure M α (0 : Measure α) 
goal: MeasureTheory.SMulInvariantMeasure M α 0

full_name: MeasureTheory.VAddInvariantMeasure.zero
code: @[to_additive]
instance zero [MeasurableSpace α] [SMul M α] : SMulInvariantMeasure M α (0 : Measure α) 
goal: MeasureTheory.VAddInvariantMeasure M α 0

full_name: MeasureTheory.SMulInvariantMeasure.add
code: @[to_additive]
instance add [SMulInvariantMeasure M α μ] [SMulInvariantMeasure M α ν] :
    SMulInvariantMeasure M α (μ + ν) 
goal: MeasureTheory.SMulInvariantMeasure M α (μ + ν)

full_name: MeasureTheory.VAddInvariantMeasure.add
code: @[to_additive]
instance add [SMulInvariantMeasure M α μ] [SMulInvariantMeasure M α ν] :
    SMulInvariantMeasure M α (μ + ν) 
goal: MeasureTheory.VAddInvariantMeasure M α (μ + ν)

full_name: MeasureTheory.VAddInvariantMeasure.vadd
code: @[to_additive]
instance smul [SMulInvariantMeasure M α μ] (c : ℝ≥0∞) : SMulInvariantMeasure M α (c • μ) 
goal: MeasureTheory.VAddInvariantMeasure M α (c • μ)

full_name: MeasureTheory.SMulInvariantMeasure.smul
code: @[to_additive]
instance smul [SMulInvariantMeasure M α μ] (c : ℝ≥0∞) : SMulInvariantMeasure M α (c • μ) 
goal: MeasureTheory.SMulInvariantMeasure M α (c • μ)

full_name: MeasureTheory.VAddInvariantMeasure.vadd_nnreal
code: @[to_additive]
instance smul_nnreal [SMulInvariantMeasure M α μ] (c : ℝ≥0) : SMulInvariantMeasure M α (c • μ) 
goal: MeasureTheory.VAddInvariantMeasure M α (c • μ)

full_name: MeasureTheory.SMulInvariantMeasure.smul_nnreal
code: @[to_additive]
instance smul_nnreal [SMulInvariantMeasure M α μ] (c : ℝ≥0) : SMulInvariantMeasure M α (c • μ) 
goal: MeasureTheory.SMulInvariantMeasure M α (c • μ)

full_name: MeasureTheory.measure_preimage_smul_le
code: /-- See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`. -/
@[to_additive "See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`."]
theorem measure_preimage_smul_le (c : G) (s : Set α) : μ ((c • ·) ⁻¹' s) ≤ μ s 
goal: μ ((fun x => c • x) ⁻¹' s) ≤ μ s

full_name: MeasureTheory.measure_preimage_vadd_le
code: /-- See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`. -/
@[to_additive "See also `measure_preimage_smul_of_nullMeasurableSet` and `measure_preimage_smul`."]
theorem measure_preimage_smul_le (c : G) (s : Set α) : μ ((c • ·) ⁻¹' s) ≤ μ s 
goal: μ ((fun x => c +ᵥ x) ⁻¹' s) ≤ μ s

full_name: MeasureTheory.tendsto_vadd_ae
code: /-- See also `smul_ae`. -/
@[to_additive "See also `vadd_ae`."]
theorem tendsto_smul_ae (c : G) : Filter.Tendsto (c • ·) (ae μ) (ae μ) 
goal: Filter.Tendsto (fun x => c +ᵥ x) (MeasureTheory.ae μ) (MeasureTheory.ae μ)

full_name: MeasureTheory.tendsto_smul_ae
code: /-- See also `smul_ae`. -/
@[to_additive "See also `vadd_ae`."]
theorem tendsto_smul_ae (c : G) : Filter.Tendsto (c • ·) (ae μ) (ae μ) 
goal: Filter.Tendsto (fun x => c • x) (MeasureTheory.ae μ) (MeasureTheory.ae μ)

full_name: MeasureTheory.measure_preimage_vadd_null
code: @[to_additive]
theorem measure_preimage_smul_null (h : μ s = 0) (c : G) : μ ((c • ·) ⁻¹' s) = 0 
goal: μ ((fun x => c +ᵥ x) ⁻¹' s) = 0

full_name: MeasureTheory.measure_preimage_smul_null
code: @[to_additive]
theorem measure_preimage_smul_null (h : μ s = 0) (c : G) : μ ((c • ·) ⁻¹' s) = 0 
goal: μ ((fun x => c • x) ⁻¹' s) = 0

full_name: MeasureTheory.measure_preimage_vadd_of_nullMeasurableSet
code: @[to_additive]
theorem measure_preimage_smul_of_nullMeasurableSet (hs : NullMeasurableSet s μ) (c : G) :
    μ ((c • ·) ⁻¹' s) = μ s 
goal: μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s

full_name: MeasureTheory.measure_preimage_smul_of_nullMeasurableSet
code: @[to_additive]
theorem measure_preimage_smul_of_nullMeasurableSet (hs : NullMeasurableSet s μ) (c : G) :
    μ ((c • ·) ⁻¹' s) = μ s 
goal: μ ((fun x => c • x) ⁻¹' s) = μ s

full_name: MeasureTheory.measure_preimage_vadd
code: @[to_additive (attr := simp)]
theorem measure_preimage_smul (c : G) (s : Set α) : μ ((c • ·) ⁻¹' s) = μ s 
goal: μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s

full_name: MeasureTheory.measure_preimage_smul
code: @[to_additive (attr := simp)]
theorem measure_preimage_smul (c : G) (s : Set α) : μ ((c • ·) ⁻¹' s) = μ s 
goal: μ ((fun x => c • x) ⁻¹' s) = μ s

full_name: MeasureTheory.measure_smul
code: @[to_additive (attr := simp)]
theorem measure_smul (c : G) (s : Set α) : μ (c • s) = μ s 
goal: μ (c • s) = μ s

full_name: MeasureTheory.measure_vadd
code: @[to_additive (attr := simp)]
theorem measure_smul (c : G) (s : Set α) : μ (c • s) = μ s 
goal: μ (c +ᵥ s) = μ s

full_name: MeasureTheory.measure_smul_eq_zero_iff
code: @[to_additive]
theorem measure_smul_eq_zero_iff {s} (c : G) : μ (c • s) = 0 ↔ μ s = 0 
goal: μ (c • s) = 0 ↔ μ s = 0

full_name: MeasureTheory.measure_vadd_eq_zero_iff
code: @[to_additive]
theorem measure_smul_eq_zero_iff {s} (c : G) : μ (c • s) = 0 ↔ μ s = 0 
goal: μ (c +ᵥ s) = 0 ↔ μ s = 0

full_name: MeasureTheory.measure_vadd_null
code: @[to_additive]
theorem measure_smul_null {s} (h : μ s = 0) (c : G) : μ (c • s) = 0 
goal: μ (c +ᵥ s) = 0

full_name: MeasureTheory.measure_smul_null
code: @[to_additive]
theorem measure_smul_null {s} (h : μ s = 0) (c : G) : μ (c • s) = 0 
goal: μ (c • s) = 0

full_name: MeasureTheory.vadd_mem_ae
code: @[to_additive (attr := simp)]
theorem smul_mem_ae (c : G) {s : Set α} : c • s ∈ ae μ ↔ s ∈ ae μ 
goal: c +ᵥ s ∈ MeasureTheory.ae μ ↔ s ∈ MeasureTheory.ae μ

full_name: MeasureTheory.smul_mem_ae
code: @[to_additive (attr := simp)]
theorem smul_mem_ae (c : G) {s : Set α} : c • s ∈ ae μ ↔ s ∈ ae μ 
goal: c • s ∈ MeasureTheory.ae μ ↔ s ∈ MeasureTheory.ae μ

full_name: MeasureTheory.vadd_ae
code: @[to_additive (attr := simp)]
theorem smul_ae (c : G) : c • ae μ = ae μ 
goal: c +ᵥ MeasureTheory.ae μ = MeasureTheory.ae μ

full_name: MeasureTheory.smul_ae
code: @[to_additive (attr := simp)]
theorem smul_ae (c : G) : c • ae μ = ae μ 
goal: c • MeasureTheory.ae μ = MeasureTheory.ae μ

full_name: MeasureTheory.eventuallyConst_vadd_set_ae
code: @[to_additive (attr := simp)]
theorem eventuallyConst_smul_set_ae (c : G) {s : Set α} :
    EventuallyConst (c • s : Set α) (ae μ) ↔ EventuallyConst s (ae μ) 
goal: Filter.EventuallyConst (c +ᵥ s) (MeasureTheory.ae μ) ↔ Filter.EventuallyConst s (MeasureTheory.ae μ)

full_name: MeasureTheory.eventuallyConst_smul_set_ae
code: @[to_additive (attr := simp)]
theorem eventuallyConst_smul_set_ae (c : G) {s : Set α} :
    EventuallyConst (c • s : Set α) (ae μ) ↔ EventuallyConst s (ae μ) 
goal: Filter.EventuallyConst (c • s) (MeasureTheory.ae μ) ↔ Filter.EventuallyConst s (MeasureTheory.ae μ)

full_name: MeasureTheory.vadd_set_ae_le
code: @[to_additive (attr := simp)]
theorem smul_set_ae_le (c : G) {s t : Set α} : c • s ≤ᵐ[μ] c • t ↔ s ≤ᵐ[μ] t 
goal: c +ᵥ s ≤ᵐ[μ] c +ᵥ t ↔ s ≤ᵐ[μ] t

full_name: MeasureTheory.smul_set_ae_le
code: @[to_additive (attr := simp)]
theorem smul_set_ae_le (c : G) {s t : Set α} : c • s ≤ᵐ[μ] c • t ↔ s ≤ᵐ[μ] t 
goal: c • s ≤ᵐ[μ] c • t ↔ s ≤ᵐ[μ] t

full_name: MeasureTheory.smul_set_ae_eq
code: @[to_additive (attr := simp)]
theorem smul_set_ae_eq (c : G) {s t : Set α} : c • s =ᵐ[μ] c • t ↔ s =ᵐ[μ] t 
goal: c • s =ᵐ[μ] c • t ↔ s =ᵐ[μ] t

full_name: MeasureTheory.vadd_set_ae_eq
code: @[to_additive (attr := simp)]
theorem smul_set_ae_eq (c : G) {s t : Set α} : c • s =ᵐ[μ] c • t ↔ s =ᵐ[μ] t 
goal: c +ᵥ s =ᵐ[μ] c +ᵥ t ↔ s =ᵐ[μ] t

full_name: MeasureTheory.measurePreserving_vadd
code: @[to_additive (attr := simp)]
theorem measurePreserving_smul : MeasurePreserving (c • ·) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => c +ᵥ x) μ μ

full_name: MeasureTheory.measurePreserving_smul
code: @[to_additive (attr := simp)]
theorem measurePreserving_smul : MeasurePreserving (c • ·) μ μ 
goal: MeasureTheory.MeasurePreserving (fun x => c • x) μ μ

full_name: MeasureTheory.map_vadd
code: @[to_additive (attr := simp)]
theorem map_smul : map (c • ·) μ = μ 
goal: MeasureTheory.Measure.map (fun x => c +ᵥ x) μ = μ

full_name: MeasureTheory.map_smul
code: @[to_additive (attr := simp)]
theorem map_smul : map (c • ·) μ = μ 
goal: MeasureTheory.Measure.map (fun x => c • x) μ = μ

full_name: MeasureTheory.smulInvariantMeasure_map
code: @[to_additive]
theorem smulInvariantMeasure_map [SMul M α] [SMul M β]
    [MeasurableSMul M β]
    (μ : Measure α) [SMulInvariantMeasure M α μ] (f : α → β)
    (hsmul : ∀ (m : M) a, f (m • a) = m • f a) (hf : Measurable f) :
    SMulInvariantMeasure M β (map f μ) 
goal: MeasureTheory.SMulInvariantMeasure M β (MeasureTheory.Measure.map f μ)

full_name: MeasureTheory.vaddInvariantMeasure_map
code: @[to_additive]
theorem smulInvariantMeasure_map [SMul M α] [SMul M β]
    [MeasurableSMul M β]
    (μ : Measure α) [SMulInvariantMeasure M α μ] (f : α → β)
    (hsmul : ∀ (m : M) a, f (m • a) = m • f a) (hf : Measurable f) :
    SMulInvariantMeasure M β (map f μ) 
goal: MeasureTheory.VAddInvariantMeasure M β (MeasureTheory.Measure.map f μ)

full_name: MeasureTheory.smulInvariantMeasure_map_smul
code: @[to_additive]
instance smulInvariantMeasure_map_smul [SMul M α] [SMul N α] [SMulCommClass N M α]
    [MeasurableSMul M α] [MeasurableSMul N α]
    (μ : Measure α) [SMulInvariantMeasure M α μ] (n : N) :
    SMulInvariantMeasure M α (map (n • ·) μ) 
goal: MeasureTheory.SMulInvariantMeasure M α (MeasureTheory.Measure.map (fun x => n • x) μ)

full_name: MeasureTheory.vaddInvariantMeasure_map_vadd
code: @[to_additive]
instance smulInvariantMeasure_map_smul [SMul M α] [SMul N α] [SMulCommClass N M α]
    [MeasurableSMul M α] [MeasurableSMul N α]
    (μ : Measure α) [SMulInvariantMeasure M α μ] (n : N) :
    SMulInvariantMeasure M α (map (n • ·) μ) 
goal: MeasureTheory.VAddInvariantMeasure M α (MeasureTheory.Measure.map (fun x => n +ᵥ x) μ)

full_name: MeasureTheory.vaddInvariantMeasure_tfae
code: /-- Equivalent definitions of a measure invariant under a multiplicative action of a group.

- 0: `SMulInvariantMeasure G α μ`;

- 1: for every `c : G` and a measurable set `s`, the measure of the preimage of `s` under scalar
     multiplication by `c` is equal to the measure of `s`;

- 2: for every `c : G` and a measurable set `s`, the measure of the image `c • s` of `s` under
     scalar multiplication by `c` is equal to the measure of `s`;

- 3, 4: properties 2, 3 for any set, including non-measurable ones;

- 5: for any `c : G`, scalar multiplication by `c` maps `μ` to `μ`;

- 6: for any `c : G`, scalar multiplication by `c` is a measure preserving map. -/
@[to_additive]
theorem smulInvariantMeasure_tfae :
    List.TFAE
      [SMulInvariantMeasure G α μ,
        ∀ (c : G) (s), MeasurableSet s → μ ((c • ·) ⁻¹' s) = μ s,
        ∀ (c : G) (s), MeasurableSet s → μ (c • s) = μ s,
        ∀ (c : G) (s), μ ((c • ·) ⁻¹' s) = μ s,
        ∀ (c : G) (s), μ (c • s) = μ s,
        ∀ c : G, Measure.map (c • ·) μ = μ,
        ∀ c : G, MeasurePreserving (c • ·) μ μ] 
goal: [MeasureTheory.VAddInvariantMeasure G α μ, ∀ (c : G) (s : Set α), MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s,
    ∀ (c : G) (s : Set α), MeasurableSet s → μ (c +ᵥ s) = μ s, ∀ (c : G) (s : Set α), μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s,
    ∀ (c : G) (s : Set α), μ (c +ᵥ s) = μ s, ∀ (c : G), MeasureTheory.Measure.map (fun x => c +ᵥ x) μ = μ,
    ∀ (c : G), MeasureTheory.MeasurePreserving (fun x => c +ᵥ x) μ μ].TFAE

full_name: MeasureTheory.smulInvariantMeasure_tfae
code: /-- Equivalent definitions of a measure invariant under a multiplicative action of a group.

- 0: `SMulInvariantMeasure G α μ`;

- 1: for every `c : G` and a measurable set `s`, the measure of the preimage of `s` under scalar
     multiplication by `c` is equal to the measure of `s`;

- 2: for every `c : G` and a measurable set `s`, the measure of the image `c • s` of `s` under
     scalar multiplication by `c` is equal to the measure of `s`;

- 3, 4: properties 2, 3 for any set, including non-measurable ones;

- 5: for any `c : G`, scalar multiplication by `c` maps `μ` to `μ`;

- 6: for any `c : G`, scalar multiplication by `c` is a measure preserving map. -/
@[to_additive]
theorem smulInvariantMeasure_tfae :
    List.TFAE
      [SMulInvariantMeasure G α μ,
        ∀ (c : G) (s), MeasurableSet s → μ ((c • ·) ⁻¹' s) = μ s,
        ∀ (c : G) (s), MeasurableSet s → μ (c • s) = μ s,
        ∀ (c : G) (s), μ ((c • ·) ⁻¹' s) = μ s,
        ∀ (c : G) (s), μ (c • s) = μ s,
        ∀ c : G, Measure.map (c • ·) μ = μ,
        ∀ c : G, MeasurePreserving (c • ·) μ μ] 
goal: [MeasureTheory.SMulInvariantMeasure G α μ, ∀ (c : G) (s : Set α), MeasurableSet s → μ ((fun x => c • x) ⁻¹' s) = μ s,
    ∀ (c : G) (s : Set α), MeasurableSet s → μ (c • s) = μ s, ∀ (c : G) (s : Set α), μ ((fun x => c • x) ⁻¹' s) = μ s,
    ∀ (c : G) (s : Set α), μ (c • s) = μ s, ∀ (c : G), MeasureTheory.Measure.map (fun x => c • x) μ = μ,
    ∀ (c : G), MeasureTheory.MeasurePreserving (fun x => c • x) μ μ].TFAE

full_name: MeasureTheory.NullMeasurableSet.smul
code: @[to_additive]
theorem NullMeasurableSet.smul {s} (hs : NullMeasurableSet s μ) (c : G) :
    NullMeasurableSet (c • s) μ 
goal: MeasureTheory.NullMeasurableSet (c • s) μ

full_name: MeasureTheory.NullMeasurableSet.vadd
code: @[to_additive]
theorem NullMeasurableSet.smul {s} (hs : NullMeasurableSet s μ) (c : G) :
    NullMeasurableSet (c • s) μ 
goal: MeasureTheory.NullMeasurableSet (c +ᵥ s) μ

full_name: MeasureTheory.measure_isOpen_pos_of_vaddInvariant_of_compact_ne_zero
code: /-- If measure `μ` is invariant under a group action and is nonzero on a compact set `K`, then it is
positive on any nonempty open set. In case of a regular measure, one can assume `μ ≠ 0` instead of
`μ K ≠ 0`, see `MeasureTheory.measure_isOpen_pos_of_smulInvariant_of_ne_zero`. -/
@[to_additive]
theorem measure_isOpen_pos_of_smulInvariant_of_compact_ne_zero (hK : IsCompact K) (hμK : μ K ≠ 0)
    (hU : IsOpen U) (hne : U.Nonempty) : 0 < μ U 
goal: 0 < μ U

full_name: MeasureTheory.measure_isOpen_pos_of_smulInvariant_of_compact_ne_zero
code: /-- If measure `μ` is invariant under a group action and is nonzero on a compact set `K`, then it is
positive on any nonempty open set. In case of a regular measure, one can assume `μ ≠ 0` instead of
`μ K ≠ 0`, see `MeasureTheory.measure_isOpen_pos_of_smulInvariant_of_ne_zero`. -/
@[to_additive]
theorem measure_isOpen_pos_of_smulInvariant_of_compact_ne_zero (hK : IsCompact K) (hμK : μ K ≠ 0)
    (hU : IsOpen U) (hne : U.Nonempty) : 0 < μ U 
goal: 0 < μ U

full_name: MeasureTheory.isLocallyFiniteMeasure_of_smulInvariant
code: @[to_additive]
theorem isLocallyFiniteMeasure_of_smulInvariant (hU : IsOpen U) (hne : U.Nonempty) (hμU : μ U ≠ ∞) :
    IsLocallyFiniteMeasure μ 
goal: MeasureTheory.IsLocallyFiniteMeasure μ

full_name: MeasureTheory.isLocallyFiniteMeasure_of_vaddInvariant
code: @[to_additive]
theorem isLocallyFiniteMeasure_of_smulInvariant (hU : IsOpen U) (hne : U.Nonempty) (hμU : μ U ≠ ∞) :
    IsLocallyFiniteMeasure μ 
goal: MeasureTheory.IsLocallyFiniteMeasure μ

full_name: MeasureTheory.measure_isOpen_pos_of_vaddInvariant_of_ne_zero
code: @[to_additive]
theorem measure_isOpen_pos_of_smulInvariant_of_ne_zero (hμ : μ ≠ 0) (hU : IsOpen U)
    (hne : U.Nonempty) : 0 < μ U 
goal: 0 < μ U

full_name: MeasureTheory.measure_isOpen_pos_of_smulInvariant_of_ne_zero
code: @[to_additive]
theorem measure_isOpen_pos_of_smulInvariant_of_ne_zero (hμ : μ ≠ 0) (hU : IsOpen U)
    (hne : U.Nonempty) : 0 < μ U 
goal: 0 < μ U

full_name: MeasureTheory.measure_pos_iff_nonempty_of_smulInvariant
code: @[to_additive]
theorem measure_pos_iff_nonempty_of_smulInvariant (hμ : μ ≠ 0) (hU : IsOpen U) :
    0 < μ U ↔ U.Nonempty 
goal: 0 < μ U ↔ U.Nonempty

full_name: MeasureTheory.measure_pos_iff_nonempty_of_vaddInvariant
code: @[to_additive]
theorem measure_pos_iff_nonempty_of_smulInvariant (hμ : μ ≠ 0) (hU : IsOpen U) :
    0 < μ U ↔ U.Nonempty 
goal: 0 < μ U ↔ U.Nonempty

full_name: MeasureTheory.measure_eq_zero_iff_eq_empty_of_vaddInvariant
code: @[to_additive]
theorem measure_eq_zero_iff_eq_empty_of_smulInvariant (hμ : μ ≠ 0) (hU : IsOpen U) :
    μ U = 0 ↔ U = ∅ 
goal: μ U = 0 ↔ U = ∅

full_name: MeasureTheory.measure_eq_zero_iff_eq_empty_of_smulInvariant
code: @[to_additive]
theorem measure_eq_zero_iff_eq_empty_of_smulInvariant (hμ : μ ≠ 0) (hU : IsOpen U) :
    μ U = 0 ↔ U = ∅ 
goal: μ U = 0 ↔ U = ∅