l3lab/ntp-mathlib huggingface dataset:
@[to_additive]
instance (priority := 100) measurableDiv_of_mul_inv (G : Type*) [MeasurableSpace G]
    [DivInvMonoid G] [MeasurableMul G] [MeasurableInv G] : MeasurableDiv G where
  measurable_const_div c := by
    convert measurable_inv.const_mul c using 1
    ext1
    apply div_eq_mul_inv
  measurable_div_const c := by
    

Proof state:
α : Type u_1
G : Type u_2
inst✝³ : MeasurableSpace G
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableMul G
inst✝ : MeasurableInv G
c : G
⊢ Measurable fun x => x / c

Next tactic:
convert measurable_id.mul_const c⁻¹ using 1
@[to_additive]
instance (priority := 100) measurableDiv_of_mul_inv (G : Type*) [MeasurableSpace G]
    [DivInvMonoid G] [MeasurableMul G] [MeasurableInv G] : MeasurableDiv G where
  measurable_const_div c := by
    convert measurable_inv.const_mul c using 1
    ext1
    apply div_eq_mul_inv
  measurable_div_const c := by
    convert measurable_id.mul_const c⁻¹ using 1
    

Proof state:
case h.e'_5
α : Type u_1
G : Type u_2
inst✝³ : MeasurableSpace G
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableMul G
inst✝ : MeasurableInv G
c : G
⊢ (fun x => x / c) = fun x => id x * c⁻¹

Next tactic:
ext1
@[to_additive]
instance (priority := 100) measurableDiv_of_mul_inv (G : Type*) [MeasurableSpace G]
    [DivInvMonoid G] [MeasurableMul G] [MeasurableInv G] : MeasurableDiv G where
  measurable_const_div c := by
    convert measurable_inv.const_mul c using 1
    ext1
    apply div_eq_mul_inv
  measurable_div_const c := by
    convert measurable_id.mul_const c⁻¹ using 1
    ext1
    

Proof state:
case h.e'_5.h
α : Type u_1
G : Type u_2
inst✝³ : MeasurableSpace G
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableMul G
inst✝ : MeasurableInv G
c x✝ : G
⊢ x✝ / c = id x✝ * c⁻¹

Next tactic:
apply div_eq_mul_inv
@[to_additive (attr := simp)]
theorem measurable_inv_iff {G : Type*} [Group G] [MeasurableSpace G] [MeasurableInv G]
    {f : α → G} : (Measurable fun x => (f x)⁻¹) ↔ Measurable f :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
G✝ : Type u_2
α : Type u_3
inst✝⁵ : Inv G✝
inst✝⁴ : MeasurableSpace G✝
inst✝³ : MeasurableInv G✝
m : MeasurableSpace α
f✝ : α → G✝
μ : Measure α
G : Type u_4
inst✝² : Group G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableInv G
f : α → G
h : Measurable fun x => (f x)⁻¹
⊢ Measurable f

Next tactic:
simpa only [inv_inv] using h.inv
@[to_additive (attr := simp)]
theorem aemeasurable_inv_iff {G : Type*} [Group G] [MeasurableSpace G] [MeasurableInv G]
    {f : α → G} : AEMeasurable (fun x => (f x)⁻¹) μ ↔ AEMeasurable f μ :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
G✝ : Type u_2
α : Type u_3
inst✝⁵ : Inv G✝
inst✝⁴ : MeasurableSpace G✝
inst✝³ : MeasurableInv G✝
m : MeasurableSpace α
f✝ : α → G✝
μ : Measure α
G : Type u_4
inst✝² : Group G
inst✝¹ : MeasurableSpace G
inst✝ : MeasurableInv G
f : α → G
h : AEMeasurable fun x => (f x)⁻¹
⊢ AEMeasurable f

Next tactic:
simpa only [inv_inv] using h.inv
@[simp]
theorem measurable_inv_iff₀ {G₀ : Type*} [GroupWithZero G₀] [MeasurableSpace G₀]
    [MeasurableInv G₀] {f : α → G₀} : (Measurable fun x => (f x)⁻¹) ↔ Measurable f :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : Inv G
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableInv G
m : MeasurableSpace α
f✝ : α → G
μ : Measure α
G₀ : Type u_4
inst✝² : GroupWithZero G₀
inst✝¹ : MeasurableSpace G₀
inst✝ : MeasurableInv G₀
f : α → G₀
h : Measurable fun x => (f x)⁻¹
⊢ Measurable f

Next tactic:
simpa only [inv_inv] using h.inv
@[simp]
theorem aemeasurable_inv_iff₀ {G₀ : Type*} [GroupWithZero G₀] [MeasurableSpace G₀]
    [MeasurableInv G₀] {f : α → G₀} : AEMeasurable (fun x => (f x)⁻¹) μ ↔ AEMeasurable f μ :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁵ : Inv G
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableInv G
m : MeasurableSpace α
f✝ : α → G
μ : Measure α
G₀ : Type u_4
inst✝² : GroupWithZero G₀
inst✝¹ : MeasurableSpace G₀
inst✝ : MeasurableInv G₀
f : α → G₀
h : AEMeasurable fun x => (f x)⁻¹
⊢ AEMeasurable f

Next tactic:
simpa only [inv_inv] using h.inv
/-- `DivInvMonoid.Pow` is measurable. -/
instance DivInvMonoid.measurableZPow (G : Type u) [DivInvMonoid G] [MeasurableSpace G]
    [MeasurableMul₂ G] [MeasurableInv G] : MeasurablePow G ℤ :=
  ⟨measurable_from_prod_countable fun n => by
      

Proof state:
α : Type u_1
G : Type u
inst✝³ : DivInvMonoid G
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
n : ℤ
⊢ Measurable fun x => (x, n).1 ^ (x, n).2

Next tactic:
cases' n with n n
/-- `DivInvMonoid.Pow` is measurable. -/
instance DivInvMonoid.measurableZPow (G : Type u) [DivInvMonoid G] [MeasurableSpace G]
    [MeasurableMul₂ G] [MeasurableInv G] : MeasurablePow G ℤ :=
  ⟨measurable_from_prod_countable fun n => by
      cases' n with n n
      · 

Proof state:
case ofNat
α : Type u_1
G : Type u
inst✝³ : DivInvMonoid G
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
n : ℕ
⊢ Measurable fun x => (x, Int.ofNat n).1 ^ (x, Int.ofNat n).2

Next tactic:
simp_rw [Int.ofNat_eq_coe, zpow_ofNat]
/-- `DivInvMonoid.Pow` is measurable. -/
instance DivInvMonoid.measurableZPow (G : Type u) [DivInvMonoid G] [MeasurableSpace G]
    [MeasurableMul₂ G] [MeasurableInv G] : MeasurablePow G ℤ :=
  ⟨measurable_from_prod_countable fun n => by
      cases' n with n n
      · simp_rw [Int.ofNat_eq_coe, zpow_ofNat]
        

Proof state:
case ofNat
α : Type u_1
G : Type u
inst✝³ : DivInvMonoid G
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
n : ℕ
⊢ Measurable fun x => x ^ n

Next tactic:
exact measurable_id.pow_const _
/-- `DivInvMonoid.Pow` is measurable. -/
instance DivInvMonoid.measurableZPow (G : Type u) [DivInvMonoid G] [MeasurableSpace G]
    [MeasurableMul₂ G] [MeasurableInv G] : MeasurablePow G ℤ :=
  ⟨measurable_from_prod_countable fun n => by
      cases' n with n n
      · simp_rw [Int.ofNat_eq_coe, zpow_ofNat]
        exact measurable_id.pow_const _
      · 

Proof state:
case negSucc
α : Type u_1
G : Type u
inst✝³ : DivInvMonoid G
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
n : ℕ
⊢ Measurable fun x => (x, Int.negSucc n).1 ^ (x, Int.negSucc n).2

Next tactic:
simp_rw [zpow_negSucc]
/-- `DivInvMonoid.Pow` is measurable. -/
instance DivInvMonoid.measurableZPow (G : Type u) [DivInvMonoid G] [MeasurableSpace G]
    [MeasurableMul₂ G] [MeasurableInv G] : MeasurablePow G ℤ :=
  ⟨measurable_from_prod_countable fun n => by
      cases' n with n n
      · simp_rw [Int.ofNat_eq_coe, zpow_ofNat]
        exact measurable_id.pow_const _
      · simp_rw [zpow_negSucc]
        

Proof state:
case negSucc
α : Type u_1
G : Type u
inst✝³ : DivInvMonoid G
inst✝² : MeasurableSpace G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
n : ℕ
⊢ Measurable fun x => (x ^ (n + 1))⁻¹

Next tactic:
exact (measurable_id.pow_const (n + 1)).inv
@[to_additive]
instance (priority := 100) measurableDiv₂_of_mul_inv (G : Type*) [MeasurableSpace G]
    [DivInvMonoid G] [MeasurableMul₂ G] [MeasurableInv G] : MeasurableDiv₂ G :=
  ⟨by
    

Proof state:
α : Type u_1
G : Type u_2
inst✝³ : MeasurableSpace G
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
⊢ Measurable fun p => p.1 / p.2

Next tactic:
simp only [div_eq_mul_inv]
@[to_additive]
instance (priority := 100) measurableDiv₂_of_mul_inv (G : Type*) [MeasurableSpace G]
    [DivInvMonoid G] [MeasurableMul₂ G] [MeasurableInv G] : MeasurableDiv₂ G :=
  ⟨by
    simp only [div_eq_mul_inv]
    

Proof state:
α : Type u_1
G : Type u_2
inst✝³ : MeasurableSpace G
inst✝² : DivInvMonoid G
inst✝¹ : MeasurableMul₂ G
inst✝ : MeasurableInv G
⊢ Measurable fun p => p.1 * p.2⁻¹

Next tactic:
exact measurable_fst.mul measurable_snd.inv
instance (priority := 100) MeasurableDiv.toMeasurableInv [MeasurableSpace α] [Group α]
    [MeasurableDiv α] : MeasurableInv α where
  measurable_inv := by 

Proof state:
α : Type u_1
inst✝² : MeasurableSpace α
inst✝¹ : Group α
inst✝ : MeasurableDiv α
⊢ Measurable Inv.inv

Next tactic:
simpa using measurable_const_div (1 : α)
@[to_additive]
instance Submonoid.measurableSMul {M α} [MeasurableSpace M] [MeasurableSpace α] [Monoid M]
    [MulAction M α] [MeasurableSMul M α] (s : Submonoid M) : MeasurableSMul s α :=
  ⟨fun c => by 

Proof state:
α✝ : Type u_1
M : Type ?u.51226
α : Type ?u.51229
inst✝⁴ : MeasurableSpace M
inst✝³ : MeasurableSpace α
inst✝² : Monoid M
inst✝¹ : MulAction M α
inst✝ : MeasurableSMul M α
s : Submonoid M
c : ↥s
⊢ Measurable fun x => c • x

Next tactic:
simpa only using measurable_const_smul (c : M)
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
⊢ Measurable (Function.uncurry fun x x_1 => x • x_1)

Next tactic:
suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by 

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
this : Measurable fun p => p.2 • p.1
⊢ Measurable (Function.uncurry fun x x_1 => x • x_1)

Next tactic:
apply this.comp measurable_swap
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
⊢ Measurable fun p => p.2 • p.1

Next tactic:
refine' measurable_from_prod_countable fun n => _
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
n : ℕ
⊢ Measurable fun x => (x, n).2 • (x, n).1

Next tactic:
induction' n with n ih
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n ih
    · 

Proof state:
case zero
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
⊢ Measurable fun x => (x, Nat.zero).2 • (x, Nat.zero).1

Next tactic:
simp only [Nat.zero_eq, zero_smul, ← Pi.zero_def, measurable_zero]
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n ih
    · simp only [Nat.zero_eq, zero_smul, ← Pi.zero_def, measurable_zero]
    · 

Proof state:
case succ
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
n : ℕ
ih : Measurable fun x => (x, n).2 • (x, n).1
⊢ Measurable fun x => (x, Nat.succ n).2 • (x, Nat.succ n).1

Next tactic:
simp only [succ_nsmul]
/-- `AddMonoid.SMul` is measurable. -/
instance AddMonoid.measurableSMul_nat₂ (M : Type*) [AddMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] : MeasurableSMul₂ ℕ M :=
  ⟨by
    suffices Measurable fun p : M × ℕ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n ih
    · simp only [Nat.zero_eq, zero_smul, ← Pi.zero_def, measurable_zero]
    · simp only [succ_nsmul]
      

Proof state:
case succ
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁶ : MeasurableSpace M✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝³ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝² : AddMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableAdd₂ M
n : ℕ
ih : Measurable fun x => (x, n).2 • (x, n).1
⊢ Measurable fun x => x + n • x

Next tactic:
exact measurable_id.add ih
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
⊢ Measurable (Function.uncurry fun x x_1 => x • x_1)

Next tactic:
suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by 

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
this : Measurable fun p => p.2 • p.1
⊢ Measurable (Function.uncurry fun x x_1 => x • x_1)

Next tactic:
apply this.comp measurable_swap
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
⊢ Measurable fun p => p.2 • p.1

Next tactic:
refine' measurable_from_prod_countable fun n => _
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    

Proof state:
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
n : ℤ
⊢ Measurable fun x => (x, n).2 • (x, n).1

Next tactic:
induction' n with n n ih
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n n ih
    · 

Proof state:
case ofNat
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
n : ℕ
⊢ Measurable fun x => (x, Int.ofNat n).2 • (x, Int.ofNat n).1

Next tactic:
simp only [Int.ofNat_eq_coe, ofNat_zsmul]
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n n ih
    · simp only [Int.ofNat_eq_coe, ofNat_zsmul]
      

Proof state:
case ofNat
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
n : ℕ
⊢ Measurable fun x => n • x

Next tactic:
exact measurable_const_smul _
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n n ih
    · simp only [Int.ofNat_eq_coe, ofNat_zsmul]
      exact measurable_const_smul _
    · 

Proof state:
case negSucc
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
n : ℕ
⊢ Measurable fun x => (x, Int.negSucc n).2 • (x, Int.negSucc n).1

Next tactic:
simp only [negSucc_zsmul]
/-- `SubNegMonoid.SMulInt` is measurable. -/
instance SubNegMonoid.measurableSMul_int₂ (M : Type*) [SubNegMonoid M] [MeasurableSpace M]
    [MeasurableAdd₂ M] [MeasurableNeg M] : MeasurableSMul₂ ℤ M :=
  ⟨by
    suffices Measurable fun p : M × ℤ => p.2 • p.1 by apply this.comp measurable_swap
    refine' measurable_from_prod_countable fun n => _
    induction' n with n n ih
    · simp only [Int.ofNat_eq_coe, ofNat_zsmul]
      exact measurable_const_smul _
    · simp only [negSucc_zsmul]
      

Proof state:
case negSucc
α✝ : Type u_1
M✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝⁷ : MeasurableSpace M✝
inst✝⁶ : MeasurableSpace β
inst✝⁵ : SMul M✝ β
m : MeasurableSpace α
f : α → M✝
g : α → β
inst✝⁴ : MeasurableSMul M✝ β
μ : Measure α
M : Type u_5
inst✝³ : SubNegMonoid M
inst✝² : MeasurableSpace M
inst✝¹ : MeasurableAdd₂ M
inst✝ : MeasurableNeg M
n : ℕ
⊢ Measurable fun x => -((n + 1) • x)

Next tactic:
exact (measurable_const_smul _).neg
@[to_additive]
theorem measurable_const_smul_iff (c : G) : (Measurable fun x => c • f x) ↔ Measurable f :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
M : Type u_2
β : Type u_3
α : Type u_4
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : Measure α
G : Type u_5
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : Measurable fun x => c • f x
⊢ Measurable f

Next tactic:
simpa only [inv_smul_smul] using h.const_smul' c⁻¹
@[to_additive]
theorem aemeasurable_const_smul_iff (c : G) :
    AEMeasurable (fun x => c • f x) μ ↔ AEMeasurable f μ :=
  ⟨fun h => by 

Proof state:
α✝ : Type u_1
M : Type u_2
β : Type u_3
α : Type u_4
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : Measure α
G : Type u_5
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : AEMeasurable fun x => c • f x
⊢ AEMeasurable f

Next tactic:
simpa only [inv_smul_smul] using h.const_smul' c⁻¹
/-- If a scalar is central, then its right action is measurable when its left action is. -/
nonrec instance MeasurableSMul.op {M α} [MeasurableSpace M] [MeasurableSpace α] [SMul M α]
    [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] [MeasurableSMul M α] : MeasurableSMul Mᵐᵒᵖ α :=
  ⟨MulOpposite.rec' fun c =>
      show Measurable fun x => op c • x by
        

Proof state:
α✝ : Type u_1
M : Type ?u.177899
α : Type ?u.177902
inst✝⁵ : MeasurableSpace M
inst✝⁴ : MeasurableSpace α
inst✝³ : SMul M α
inst✝² : SMul Mᵐᵒᵖ α
inst✝¹ : IsCentralScalar M α
inst✝ : MeasurableSMul M α
c : M
⊢ Measurable fun x => MulOpposite.op c • x

Next tactic:
simpa only [op_smul_eq_smul] using measurable_const_smul c
/-- If a scalar is central, then its right action is measurable when its left action is. -/
nonrec instance MeasurableSMul.op {M α} [MeasurableSpace M] [MeasurableSpace α] [SMul M α]
    [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] [MeasurableSMul M α] : MeasurableSMul Mᵐᵒᵖ α :=
  ⟨MulOpposite.rec' fun c =>
      show Measurable fun x => op c • x by
        simpa only [op_smul_eq_smul] using measurable_const_smul c,
    fun x =>
    show Measurable fun c => op (unop c) • x by
      

Proof state:
α✝ : Type u_1
M : Type ?u.177899
α : Type ?u.177902
inst✝⁵ : MeasurableSpace M
inst✝⁴ : MeasurableSpace α
inst✝³ : SMul M α
inst✝² : SMul Mᵐᵒᵖ α
inst✝¹ : IsCentralScalar M α
inst✝ : MeasurableSMul M α
x : α
⊢ Measurable fun c => MulOpposite.op (unop c) • x

Next tactic:
simpa only [op_smul_eq_smul] using (measurable_smul_const x).comp measurable_mul_unop
/-- If a scalar is central, then its right action is measurable when its left action is. -/
nonrec instance MeasurableSMul₂.op {M α} [MeasurableSpace M] [MeasurableSpace α] [SMul M α]
    [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] [MeasurableSMul₂ M α] : MeasurableSMul₂ Mᵐᵒᵖ α :=
  ⟨show Measurable fun x : Mᵐᵒᵖ × α => op (unop x.1) • x.2 by
      

Proof state:
α✝ : Type u_1
M : Type ?u.179926
α : Type ?u.179929
inst✝⁵ : MeasurableSpace M
inst✝⁴ : MeasurableSpace α
inst✝³ : SMul M α
inst✝² : SMul Mᵐᵒᵖ α
inst✝¹ : IsCentralScalar M α
inst✝ : MeasurableSMul₂ M α
⊢ Measurable fun x => MulOpposite.op (unop x.1) • x.2

Next tactic:
simp_rw [op_smul_eq_smul]