ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.withDensity_add_measure
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
⊢ (μ + ν).withDensity f = μ.withDensity f + ν.withDensity f
state_after: case h
α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ ((μ + ν).withDensity f) s = (μ.withDensity f + ν.withDensity f) s
tactic: ext1 s hs
state_before: case h
α : Type u_1
m0 : MeasurableSpace α
μ✝ : Measure α
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ ((μ + ν).withDensity f) s = (μ.withDensity f + ν.withDensity f) s
state_after: no goals
tactic: simp only [withDensity_apply f hs, restrict_add, lintegral_add_measure, Measure.add_apply]
Theorem: CategoryTheory.comp_ite
File: Mathlib/CategoryTheory/Category/Basic.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
X Y Z : C
f : X ⟶ Y
g g' : Y ⟶ Z
⊢ (f ≫ if P then g else g') = if P then f ≫ g else f ≫ g'
state_after: no goals
tactic: aesop
Theorem: Complex.abs_mul_cos_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
⊢ abs x * Real.cos x.arg = x.re
state_after: no goals
tactic: simpa [-abs_mul_cos_add_sin_mul_I] using congr_arg re (abs_mul_cos_add_sin_mul_I x)
Theorem: LowerSet.prod_eq_bot
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ s ×ˢ t = ⊥ ↔ s = ⊥ ∨ t = ⊥
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ ↑(s ×ˢ t) = ↑⊥ ↔ ↑s = ↑⊥ ∨ ↑t = ↑⊥
tactic: simp_rw [SetLike.ext'_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ ↑(s ×ˢ t) = ↑⊥ ↔ ↑s = ↑⊥ ∨ ↑t = ↑⊥
state_after: no goals
tactic: exact prod_eq_empty_iff
Theorem: Rat.MulRingNorm.equiv_on_nat_iff_equiv
File: Mathlib/NumberTheory/Ostrowski.lean

Proof steps:
state_before: f g : MulRingNorm ℚ
⊢ (∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n) ↔ f.equiv g
state_after: f g : MulRingNorm ℚ
x✝ : ∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n
c : ℝ
hc : 0 < c
h : ∀ (n : ℕ), f ↑n ^ c = g ↑n
⊢ (fun x => f x ^ c) = ⇑g
tactic: refine ⟨fun ⟨c, hc, h⟩ ↦ ⟨c, ⟨hc, ?_⟩⟩, fun ⟨c, hc, h⟩ ↦ ⟨c, ⟨hc, fun n ↦ by rw [← h]⟩⟩⟩
state_before: f g : MulRingNorm ℚ
x✝ : ∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n
c : ℝ
hc : 0 < c
h : ∀ (n : ℕ), f ↑n ^ c = g ↑n
⊢ (fun x => f x ^ c) = ⇑g
state_after: case h
f g : MulRingNorm ℚ
x✝ : ∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n
c : ℝ
hc : 0 < c
h : ∀ (n : ℕ), f ↑n ^ c = g ↑n
x : ℚ
⊢ f x ^ c = g x
tactic: ext x
state_before: case h
f g : MulRingNorm ℚ
x✝ : ∃ c, 0 < c ∧ ∀ (n : ℕ), f ↑n ^ c = g ↑n
c : ℝ
hc : 0 < c
h : ∀ (n : ℕ), f ↑n ^ c = g ↑n
x : ℚ
⊢ f x ^ c = g x
state_after: no goals
tactic: rw [← Rat.num_div_den x, map_div₀, map_div₀, Real.div_rpow (apply_nonneg f _)
      (apply_nonneg f _), h x.den, ← MulRingNorm.apply_natAbs_eq,← MulRingNorm.apply_natAbs_eq,
      h (natAbs x.num)]
Theorem: Nat.periodic_mod
File: Mathlib/Data/Nat/Periodic.lean

Proof steps:
state_before: a : ℕ
⊢ Periodic (fun n => n % a) a
state_after: no goals
tactic: simp only [forall_const, eq_self_iff_true, add_mod_right, Periodic]
Theorem: Subgroup.card_eq_card_quotient_mul_card_subgroup
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card (α ⧸ s) * Nat.card ↥s
state_after: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)
tactic: rw [← Nat.card_prod]
state_before: α : Type u_1
inst✝ : Group α
s✝ t s : Subgroup α
⊢ Nat.card α = Nat.card ((α ⧸ s) × ↥s)
state_after: no goals
tactic: exact Nat.card_congr Subgroup.groupEquivQuotientProdSubgroup
Theorem: UpperHalfPlane.modular_T_zpow_smul
File: Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean

Proof steps:
state_before: z : ℍ
n : ℤ
⊢ ModularGroup.T ^ n • z = ↑n +ᵥ z
state_after: z : ℍ
n : ℤ
⊢ (↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 0 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 0 1))) /
      (↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 1 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 1 1))) =
    ↑z + ↑↑n
tactic: rw [UpperHalfPlane.ext_iff, coe_vadd, add_comm, specialLinearGroup_apply, coe_mk]
state_before: z : ℍ
n : ℤ
⊢ (↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 0 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 0 1))) /
      (↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 1 0)) * ↑z + ↑((algebraMap ℤ ℝ) (↑↑(ModularGroup.T ^ n) 1 1))) =
    ↑z + ↑↑n
state_after: no goals
tactic: simp [coeToGL, ModularGroup.coe_T_zpow,
    of_apply, cons_val_zero, algebraMap.coe_one, Complex.ofReal_one, one_mul, cons_val_one,
    head_cons, algebraMap.coe_zero, zero_mul, zero_add, div_one]
Theorem: MeasureTheory.restrict_dirac
File: Mathlib/MeasureTheory/Measure/Dirac.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : MeasurableSingletonClass α
inst✝ : Decidable (a ∈ s)
⊢ (dirac a).restrict s = if a ∈ s then dirac a else 0
state_after: case pos
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : MeasurableSingletonClass α
inst✝ : Decidable (a ∈ s)
has : a ∈ s
⊢ (dirac a).restrict s = dirac a

case neg
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
s : Set α
a : α
inst✝¹ : MeasurableSingletonClass α
inst✝ : Decidable (a ∈ s)
has : a ∉ s
⊢ (dirac a).restrict s = 0
tactic: split_ifs with has
Theorem: List.length_sublistsLen
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ (sublistsLen 0 l).length = l.length.choose 0
state_after: no goals
tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
n✝ : ℕ
⊢ (sublistsLen (n✝ + 1) []).length = [].length.choose (n✝ + 1)
state_after: no goals
tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l : List α
⊢ (sublistsLen (n + 1) (a :: l)).length = (a :: l).length.choose (n + 1)
state_after: no goals
tactic: rw [sublistsLen_succ_cons, length_append, length_sublistsLen (n+1) l,
      length_map, length_sublistsLen n l, length_cons, Nat.choose_succ_succ, Nat.add_comm]
Theorem: Set.exists_mem_image
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s✝ t : Set α
f : α → β
s : Set α
p : β → Prop
⊢ (∃ y ∈ f '' s, p y) ↔ ∃ x ∈ s, p (f x)
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.NumberTheory.FermatPsp.0.Nat.b_id_helper
File: Mathlib/NumberTheory/FermatPsp.lean

Proof steps:
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 < b
⊢ 2 ≤ (a ^ b + 1) / (a + 1)
state_after: a b : ℕ
ha : 2 ≤ a
hb : 2 < b
⊢ 2 * a.succ ≤ a ^ b + 1
tactic: rw [Nat.le_div_iff_mul_le (Nat.zero_lt_succ _)]
state_before: a b : ℕ
ha : 2 ≤ a
hb : 2 < b
⊢ 2 * a.succ ≤ a ^ b + 1
state_after: case a
a b : ℕ
ha : 2 ≤ a
hb : 2 < b
⊢ Nat.mul 2 a + 1 ≤ a ^ b
tactic: apply Nat.succ_le_succ
state_before: case a
a b : ℕ
ha : 2 ≤ a
hb : 2 < b
⊢ Nat.mul 2 a + 1 ≤ a ^ b
state_after: no goals
tactic: calc
    2 * a + 1 ≤ a ^ 2 * a := by nlinarith
    _ = a ^ 3 := by rw [Nat.pow_succ a 2]
    _ ≤ a ^ b := pow_le_pow_right (Nat.le_of_succ_le ha) hb
Theorem: CategoryTheory.Functor.map_isZero
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
inst✝¹ : HasZeroMorphisms E
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
X : C
hX : IsZero X
⊢ IsZero (F.obj X)
state_after: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
inst✝¹ : HasZeroMorphisms E
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
X : C
hX : 𝟙 X = 0
⊢ 𝟙 (F.obj X) = 0
tactic: simp only [IsZero.iff_id_eq_zero] at hX ⊢
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroMorphisms D
inst✝¹ : HasZeroMorphisms E
F : C ⥤ D
inst✝ : F.PreservesZeroMorphisms
X : C
hX : 𝟙 X = 0
⊢ 𝟙 (F.obj X) = 0
state_after: no goals
tactic: rw [← F.map_id, hX, F.map_zero]
Theorem: Profinite.NobelingProof.e_mem_of_eq_true
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
x : ↑(π C fun x => x ∈ s)
a : I
hx : ↑x a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s x
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s ⟨Proj (fun x => x ∈ s) z, ⋯⟩
tactic: rcases x with ⟨_, z, hz, rfl⟩
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ e (π C fun x => x ∈ s) a ∈ factors C s ⟨Proj (fun x => x ∈ s) z, ⋯⟩
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ ∃ a_1 ∈ s,
    (if Proj (fun x => x ∈ s) z a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      e (π C fun x => x ∈ s) a
tactic: simp only [factors, List.mem_map, Finset.mem_sort]
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ ∃ a_1 ∈ s,
    (if Proj (fun x => x ∈ s) z a_1 = true then e (π C fun x => x ∈ s) a_1 else 1 - e (π C fun x => x ∈ s) a_1) =
      e (π C fun x => x ∈ s) a
state_after: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s
tactic: refine ⟨a, ?_, if_pos hx⟩
state_before: case mk.intro.intro
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
s : Finset I
a : I
z : I → Bool
hz : z ∈ C
hx : ↑⟨Proj (fun x => x ∈ s) z, ⋯⟩ a = true
⊢ a ∈ s
state_after: no goals
tactic: aesop (add simp Proj)
Theorem: Finset.prod_powerset_cons
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
ha : a ∉ s
f : Finset α → β
⊢ ∏ t ∈ (cons a s ha).powerset, f t = (∏ t ∈ s.powerset, f t) * ∏ t ∈ s.powerset.attach, f (cons a ↑t ⋯)
state_after: no goals
tactic: classical
  simp_rw [cons_eq_insert]
  rw [prod_powerset_insert ha, prod_attach _ fun t ↦ f (insert a t)]
Theorem: Subgroup.isComplement_univ_left
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ IsComplement univ S ↔ ∃ g, S = {g}
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
⊢ S.Nonempty

case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement univ S
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b

case refine_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement univ S
tactic: refine
    ⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
Theorem: MvPowerSeries.coeff_monomial_ne
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n : σ →₀ ℕ
h : m ≠ n
a : R
⊢ (coeff R m) ((monomial R n) a) = 0
state_after: no goals
tactic: classical
  rw [monomial_def]
  exact LinearMap.stdBasis_ne R (fun _ ↦ R) _ _ h a
Theorem: Set.Ioo_insert_left
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : PartialOrder α
a b c : α
h : a < b
⊢ insert a (Ioo a b) = Ico a b
state_after: no goals
tactic: rw [insert_eq, union_comm, Ioo_union_left h]
Theorem: Nat.multinomial_univ_three
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ multinomial univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !)
state_after: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ (![a, b, c] 0 + ![a, b, c] 1 + ![a, b, c] 2)! / ((![a, b, c] 0)! * (![a, b, c] 1)! * (![a, b, c] 2)!) =
    (a + b + c)! / (a ! * b ! * c !)
tactic: rw [multinomial, Fin.sum_univ_three, Fin.prod_univ_three]
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b c : ℕ
⊢ (![a, b, c] 0 + ![a, b, c] 1 + ![a, b, c] 2)! / ((![a, b, c] 0)! * (![a, b, c] 1)! * (![a, b, c] 2)!) =
    (a + b + c)! / (a ! * b ! * c !)
state_after: no goals
tactic: rfl
Theorem: TypeVec.nilFun_comp
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α₀ : TypeVec.{u_1} 0
f₀ : α₀ ⟹ Fin2.elim0
x : Fin2 0
⊢ (nilFun ⊚ f₀) x = f₀ x
state_after: no goals
tactic: apply Fin2.elim0 x
Theorem: LieAlgebra.ad_eq_lmul_left_sub_lmul_right
File: Mathlib/Algebra/Lie/OfAssociative.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
⊢ ⇑(ad R A) = LinearMap.mulLeft R - LinearMap.mulRight R
state_after: case h.h
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
a b : A
⊢ ((ad R A) a) b = ((LinearMap.mulLeft R - LinearMap.mulRight R) a) b
tactic: ext a b
state_before: case h.h
R : Type u
L : Type v
M : Type w
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
A : Type v
inst✝¹ : Ring A
inst✝ : Algebra R A
a b : A
⊢ ((ad R A) a) b = ((LinearMap.mulLeft R - LinearMap.mulRight R) a) b
state_after: no goals
tactic: simp [LieRing.of_associative_ring_bracket]
Theorem: ArithmeticFunction.LSeries_zeta_mul_Lseries_moebius
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ L (fun n => ↑(ζ n)) s * L (fun n => ↑(μ n)) s = 1
state_after: s : ℂ
hs : 1 < s.re
⊢ L ((fun x => ↑(ζ x)) ⍟ fun n => ↑(μ n)) s = 1
tactic: rw [← LSeries_convolution' (LSeriesSummable_zeta_iff.mpr hs)
    (LSeriesSummable_moebius_iff.mpr hs)]
state_before: s : ℂ
hs : 1 < s.re
⊢ L ((fun x => ↑(ζ x)) ⍟ fun n => ↑(μ n)) s = 1
state_after: no goals
tactic: simp only [← natCoe_apply, ← intCoe_apply, coe_mul, coe_zeta_mul_coe_moebius, one_eq_delta,
    LSeries_delta, Pi.one_apply]
Theorem: Equiv.sumPiEquivProdPi_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: ι : Type ?u.47766
ι' : Type ?u.47765
π : ι ⊕ ι' → Type u_1
f : (i : ι ⊕ ι') → π i
⊢ (fun g t => Sum.rec g.1 g.2 t) ((fun f => (fun i => f (inl i), fun i' => f (inr i'))) f) = f
state_after: no goals
tactic: ext (i | i) <;> rfl
Theorem: PosNum.to_nat_inj
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : PosNum
h : ↑m = ↑n
⊢ pos m = pos n
state_after: no goals
tactic: rw [← PosNum.of_to_nat, ← PosNum.of_to_nat, h]
Theorem: RegularExpression.one_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
x : List α
⊢ rmatch 1 x = true ↔ x = []
state_after: no goals
tactic: induction x <;> simp [rmatch, matchEpsilon, *]
Theorem: zsmul_induction_left
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n✝ : ℤ
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (g * a)
h_inv : ∀ (a : G), P a → P (g⁻¹ * a)
n : ℤ
⊢ P (g ^ n)
state_after: case hz
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (g * a)
h_inv : ∀ (a : G), P a → P (g⁻¹ * a)
⊢ P (g ^ 0)

case hp
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n✝ : ℤ
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (g * a)
h_inv : ∀ (a : G), P a → P (g⁻¹ * a)
n : ℕ
ih : P (g ^ ↑n)
⊢ P (g ^ (↑n + 1))

case hn
α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n✝ : ℤ
g : G
P : G → Prop
h_one : P 1
h_mul : ∀ (a : G), P a → P (g * a)
h_inv : ∀ (a : G), P a → P (g⁻¹ * a)
n : ℕ
ih : P (g ^ (-↑n))
⊢ P (g ^ (-↑n - 1))
tactic: induction' n using Int.induction_on with n ih n ih
Theorem: subset_piiUnionInter
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
⊢ π i ⊆ piiUnionInter π S
state_after: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π S
tactic: have h_ss : {i} ⊆ S := by
    intro j hj
    rw [mem_singleton_iff] at hj
    rwa [hj]
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π S
state_after: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π {i}
tactic: refine Subset.trans ?_ (piiUnionInter_mono_right h_ss)
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ piiUnionInter π {i}
state_after: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ π i ∪ {univ}
tactic: rw [piiUnionInter_singleton]
state_before: α : Type u_1
ι : Type u_2
π : ι → Set (Set α)
S : Set ι
i : ι
his : i ∈ S
h_ss : {i} ⊆ S
⊢ π i ⊆ π i ∪ {univ}
state_after: no goals
tactic: exact subset_union_left
Theorem: TopologicalGroup.t1Space
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsClosed {1}
x : G
⊢ IsClosed {x}
state_after: no goals
tactic: simpa using isClosedMap_mul_right x _ h
Theorem: isCoatomistic_dual_iff_isAtomistic
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsCoatomistic αᵒᵈ
b : α
⊢ ∃ s, b = sSup s ∧ ∀ a ∈ s, IsAtom a
state_after: no goals
tactic: apply h.eq_sInf_coatoms
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : CompleteLattice α
h : IsAtomistic α
b : αᵒᵈ
⊢ ∃ s, b = sInf s ∧ ∀ a ∈ s, IsCoatom a
state_after: no goals
tactic: apply h.eq_sSup_atoms
Theorem: Finset.aemeasurable_sum
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
s : Finset ι
hf : ∀ i ∈ s, AEMeasurable (f i) μ
⊢ AEMeasurable (fun a => ∏ i ∈ s, f i a) μ
state_after: no goals
tactic: simpa only [← Finset.prod_apply] using s.aemeasurable_prod' hf
Theorem: CategoryTheory.Subobject.prod_eq_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) = f₁ ⊓ f₂
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) ≤ f₁ ⊓ f₂

case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)
tactic: apply le_antisymm
Theorem: MeasureTheory.VectorMeasure.of_add_of_diff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : T2Space M
v : VectorMeasure α M
f : ℕ → Set α
A B : Set α
hA : MeasurableSet A
hB : MeasurableSet B
h : A ⊆ B
⊢ ↑v A + ↑v (B \ A) = ↑v B
state_after: no goals
tactic: rw [← of_union (@Set.disjoint_sdiff_right _ A B) hA (hB.diff hA), Set.union_diff_cancel h]
Theorem: Prefunctor.symmetrifyCostar
File: Mathlib/Combinatorics/Quiver/Covering.lean

Proof steps:
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.7311
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ φ.symmetrify.costar u = ⇑(symmetrifyCostar (φ.obj u)).symm ∘ Sum.map (φ.costar u) (φ.star u) ∘ ⇑(symmetrifyCostar u)
state_after: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.7311
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ ⇑(symmetrifyCostar (φ.obj u)) ∘ φ.symmetrify.costar u = Sum.map (φ.costar u) (φ.star u) ∘ ⇑(symmetrifyCostar u)
tactic: erw [Equiv.eq_symm_comp]
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.7311
inst✝ : Quiver W
ψ : V ⥤q W
u : U
⊢ ⇑(symmetrifyCostar (φ.obj u)) ∘ φ.symmetrify.costar u = Sum.map (φ.costar u) (φ.star u) ∘ ⇑(symmetrifyCostar u)
state_after: no goals
tactic: ext ⟨v, f | g⟩ <;>
    -- porting note (#10745): was `simp [Quiver.symmetrifyCostar]`
    simp only [Quiver.symmetrifyCostar, Function.comp_apply] <;>
    erw [Equiv.sigmaSumDistrib_apply, Equiv.sigmaSumDistrib_apply] <;>
    simp
Theorem: Real.IsConjExponent.inv_inv
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ
h : p.IsConjExponent q
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a < 1
state_after: no goals
tactic: linarith
state_before: a b p q : ℝ
h : p.IsConjExponent q
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a⁻¹⁻¹ + b⁻¹⁻¹ = 1
state_after: no goals
tactic: simpa only [inv_inv]
Theorem: Equiv.removeNone_aux_none
File: Mathlib/Logic/Equiv/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Option α ≃ Option β
x : α
h : e (some x) = none
⊢ some (e.removeNone_aux x) = e none
state_after: no goals
tactic: simp [removeNone_aux, Option.not_isSome_iff_eq_none.mpr h]
Theorem: Cardinal.lift_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β✝ : Type u
a b : Cardinal.{v}
α β : Type v
⊢ lift.{u, v} #α ≤ lift.{u, v} #β ↔ #α ≤ #β
state_after: α✝ β✝ : Type u
a b : Cardinal.{v}
α β : Type v
⊢ lift.{max v u, v} #α ≤ lift.{max v u, v} #β ↔ #α ≤ #β
tactic: rw [← lift_umax]
state_before: α✝ β✝ : Type u
a b : Cardinal.{v}
α β : Type v
⊢ lift.{max v u, v} #α ≤ lift.{max v u, v} #β ↔ #α ≤ #β
state_after: no goals
tactic: exact lift_mk_le.{u}