ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: measurableSet_eq_fun'
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

Proof steps:
state_before: α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
β : Type u_4
inst✝⁴ : CanonicallyOrderedAddCommMonoid β
inst✝³ : Sub β
inst✝² : OrderedSub β
x✝ : MeasurableSpace β
inst✝¹ : MeasurableSub₂ β
inst✝ : MeasurableSingletonClass β
f g : α → β
hf : Measurable f
hg : Measurable g
⊢ MeasurableSet {x | f x = g x}
state_after: α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
β : Type u_4
inst✝⁴ : CanonicallyOrderedAddCommMonoid β
inst✝³ : Sub β
inst✝² : OrderedSub β
x✝ : MeasurableSpace β
inst✝¹ : MeasurableSub₂ β
inst✝ : MeasurableSingletonClass β
f g : α → β
hf : Measurable f
hg : Measurable g
this : {a | f a = g a} = {a | (f - g) a = 0} ∩ {a | (g - f) a = 0}
⊢ MeasurableSet {x | f x = g x}
tactic: have : {a | f a = g a} = {a | (f - g) a = 0} ∩ {a | (g - f) a = 0} := by
    ext
    simp only [Set.mem_setOf_eq, Pi.sub_apply, tsub_eq_zero_iff_le, Set.mem_inter_iff]
    exact ⟨fun h ↦ ⟨h.le, h.symm.le⟩, fun h ↦ le_antisymm h.1 h.2⟩
state_before: α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
β : Type u_4
inst✝⁴ : CanonicallyOrderedAddCommMonoid β
inst✝³ : Sub β
inst✝² : OrderedSub β
x✝ : MeasurableSpace β
inst✝¹ : MeasurableSub₂ β
inst✝ : MeasurableSingletonClass β
f g : α → β
hf : Measurable f
hg : Measurable g
this : {a | f a = g a} = {a | (f - g) a = 0} ∩ {a | (g - f) a = 0}
⊢ MeasurableSet {x | f x = g x}
state_after: α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
β : Type u_4
inst✝⁴ : CanonicallyOrderedAddCommMonoid β
inst✝³ : Sub β
inst✝² : OrderedSub β
x✝ : MeasurableSpace β
inst✝¹ : MeasurableSub₂ β
inst✝ : MeasurableSingletonClass β
f g : α → β
hf : Measurable f
hg : Measurable g
this : {a | f a = g a} = {a | (f - g) a = 0} ∩ {a | (g - f) a = 0}
⊢ MeasurableSet ({a | (f - g) a = 0} ∩ {a | (g - f) a = 0})
tactic: rw [this]
state_before: α✝ : Type u_1
G : Type u_2
α : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Div G
m : MeasurableSpace α
f✝ g✝ : α → G
μ : Measure α
β : Type u_4
inst✝⁴ : CanonicallyOrderedAddCommMonoid β
inst✝³ : Sub β
inst✝² : OrderedSub β
x✝ : MeasurableSpace β
inst✝¹ : MeasurableSub₂ β
inst✝ : MeasurableSingletonClass β
f g : α → β
hf : Measurable f
hg : Measurable g
this : {a | f a = g a} = {a | (f - g) a = 0} ∩ {a | (g - f) a = 0}
⊢ MeasurableSet ({a | (f - g) a = 0} ∩ {a | (g - f) a = 0})
state_after: no goals
tactic: exact ((hf.sub hg) (measurableSet_singleton 0)).inter ((hg.sub hf) (measurableSet_singleton 0))
Theorem: List.indexOf_append_of_mem
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : a ∈ l₁
⊢ indexOf a (l₁ ++ l₂) = indexOf a l₁
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : a ∈ []
⊢ indexOf a ([] ++ l₂) = indexOf a []

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = indexOf a (d₁ :: t₁)
tactic: induction' l₁ with d₁ t₁ ih
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = indexOf a (d₁ :: t₁)
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)
tactic: rw [List.cons_append]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)
state_after: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : d₁ = a
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)

case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : ¬d₁ = a
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)
tactic: by_cases hh : d₁ = a
state_before: case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : a ∈ t₁ → indexOf a (t₁ ++ l₂) = indexOf a t₁
h : a ∈ d₁ :: t₁
hh : ¬d₁ = a
⊢ indexOf a (d₁ :: (t₁ ++ l₂)) = indexOf a (d₁ :: t₁)
state_after: no goals
tactic: rw [indexOf_cons_ne _ hh, indexOf_cons_ne _ hh, ih (mem_of_ne_of_mem (Ne.symm hh) h)]
Theorem: deriv_tsum
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg : ∀ (n : α), Differentiable 𝕜 (g n)
hg' : ∀ (n : α) (y : 𝕜), ‖deriv (g n) y‖ ≤ u n
hg0 : Summable fun n => g n y₀
⊢ (deriv fun y => ∑' (n : α), g n y) = fun y => ∑' (n : α), deriv (g n) y
state_after: case h
α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝ : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg : ∀ (n : α), Differentiable 𝕜 (g n)
hg' : ∀ (n : α) (y : 𝕜), ‖deriv (g n) y‖ ≤ u n
hg0 : Summable fun n => g n y₀
x : 𝕜
⊢ deriv (fun y => ∑' (n : α), g n y) x = ∑' (n : α), deriv (g n) x
tactic: ext1 x
state_before: case h
α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x✝ : E
y₀ y : 𝕜
N : ℕ∞
hu : Summable u
hg : ∀ (n : α), Differentiable 𝕜 (g n)
hg' : ∀ (n : α) (y : 𝕜), ‖deriv (g n) y‖ ≤ u n
hg0 : Summable fun n => g n y₀
x : 𝕜
⊢ deriv (fun y => ∑' (n : α), g n y) x = ∑' (n : α), deriv (g n) x
state_after: no goals
tactic: exact deriv_tsum_apply hu hg hg' hg0 x
Theorem: Real.Angle.toReal_coe_eq_self_add_two_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : ℝ
⊢ (↑θ).toReal = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π)
state_after: no goals
tactic: convert @toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) using 2 <;> norm_num
Theorem: CochainComplex.shiftShortComplexFunctorIso_inv_app_τ₂
File: Mathlib/Algebra/Homology/HomotopyCategory/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).prev i = (up ℤ).prev i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
tactic: simp only [prev]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i - 1) = i' - 1
state_after: no goals
tactic: omega
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (up ℤ).next i = (up ℤ).next i'
state_after: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
tactic: simp only [next]
state_before: C : Type u_1
inst✝¹ : Category.{?u.71408, u_1} C
inst✝ : Preadditive C
n i i' : ℤ
hi : n + i = i'
⊢ n + (i + 1) = i' + 1
state_after: no goals
tactic: omega
Theorem: IsCyclotomicExtension.discr_prime_pow
File: Mathlib/NumberTheory/Cyclotomic/Discriminant.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
hcycl : IsCyclotomicExtension {p ^ k} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
hirr : Irreducible (cyclotomic (↑(p ^ k)) K)
⊢ discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis = (-1) ^ (φ (↑p ^ k) / 2) * ↑↑p ^ (↑p ^ (k - 1) * ((↑p - 1) * k - 1))
state_after: case zero
p : ℕ+
K : Type u
L : Type v
ζ : L
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p ^ 0} K L
hζ : IsPrimitiveRoot ζ ↑(p ^ 0)
hirr : Irreducible (cyclotomic (↑(p ^ 0)) K)
⊢ discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis = (-1) ^ (φ (↑p ^ 0) / 2) * ↑↑p ^ (↑p ^ (0 - 1) * ((↑p - 1) * 0 - 1))

case succ
p : ℕ+
K : Type u
L : Type v
ζ : L
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Algebra K L
hp : Fact (Nat.Prime ↑p)
k : ℕ
hcycl : IsCyclotomicExtension {p ^ (k + 1)} K L
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hirr : Irreducible (cyclotomic (↑(p ^ (k + 1))) K)
⊢ discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis =
    (-1) ^ (φ (↑p ^ (k + 1)) / 2) * ↑↑p ^ (↑p ^ (k + 1 - 1) * ((↑p - 1) * (k + 1) - 1))
tactic: cases' k with k k
Theorem: Part.mem_toFinset
File: Mathlib/Data/Finset/PImage.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
o : Part α
inst✝ : Decidable o.Dom
x : α
⊢ x ∈ o.toFinset ↔ x ∈ o
state_after: no goals
tactic: simp [toFinset]
Theorem: Sum.isSome_getRight?_iff_isRight
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ x.getRight?.isSome = true ↔ x.isRight = true
state_after: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ (∃ a, x.getRight? = some a) ↔ ∃ y, x = inr y
tactic: rw [isRight_iff, Option.isSome_iff_exists]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ (∃ a, x.getRight? = some a) ↔ ∃ y, x = inr y
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.isColimitCoconeUnopOfCone_desc
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.unop
j : J
⊢ ((coconeUnopOfCone c).ι.app j ≫ (fun s => (hc.lift (coneOfCoconeUnop s)).unop) s).op = (s.ι.app j).op
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.unop
m : (coconeUnopOfCone c).pt ⟶ s.pt
w : ∀ (j : J), (coconeUnopOfCone c).ι.app j ≫ m = s.ι.app j
⊢ m = (fun s => (hc.lift (coneOfCoconeUnop s)).unop) s
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.unop
m : (coconeUnopOfCone c).pt ⟶ s.pt
w : ∀ (j : J), (coconeUnopOfCone c).ι.app j ≫ m = s.ι.app j
j : Jᵒᵖ
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneOfCoconeUnop s)).unop) s).op ≫ c.π.app j).unop
tactic: refine Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cone F
hc : IsLimit c
s : Cocone F.unop
m : (coconeUnopOfCone c).pt ⟶ s.pt
w : ∀ (j : J), (coconeUnopOfCone c).ι.app j ≫ m = s.ι.app j
j : Jᵒᵖ
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneOfCoconeUnop s)).unop) s).op ≫ c.π.app j).unop
state_after: no goals
tactic: simpa only [Quiver.Hom.op_unop, IsLimit.fac] using w (unop j)
Theorem: Function.Injective.sigma_map
File: Mathlib/Data/Sigma/Basic.lean

Proof steps:
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
j : α₁
y : β₁ j
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨j, y⟩
⊢ ⟨i, x⟩ = ⟨j, y⟩
state_after: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x y : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, y⟩
⊢ ⟨i, x⟩ = ⟨i, y⟩
tactic: obtain rfl : i = j := h₁ (Sigma.mk.inj_iff.mp h).1
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x y : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, y⟩
⊢ ⟨i, x⟩ = ⟨i, y⟩
state_after: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, x⟩
⊢ ⟨i, x⟩ = ⟨i, x⟩
tactic: obtain rfl : x = y := h₂ i (sigma_mk_injective h)
state_before: α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
h : Sigma.map f₁ f₂ ⟨i, x⟩ = Sigma.map f₁ f₂ ⟨i, x⟩
⊢ ⟨i, x⟩ = ⟨i, x⟩
state_after: no goals
tactic: rfl
Theorem: Distrib.ext
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : Distrib R
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ inst₁ = inst₂
state_after: case mk.mk.mk
R : Type u
inst₂ : Distrib R
mul✝ add✝ : R → R → R
left_distrib✝ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝ : ∀ (a b c : R), (a + b) * c = a * c + b * c
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ mk left_distrib✝ right_distrib✝ = inst₂
tactic: rcases inst₁ with @⟨⟨⟩, ⟨⟩⟩
state_before: case mk.mk.mk
R : Type u
inst₂ : Distrib R
mul✝ add✝ : R → R → R
left_distrib✝ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝ : ∀ (a b c : R), (a + b) * c = a * c + b * c
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ mk left_distrib✝ right_distrib✝ = inst₂
state_after: case mk.mk.mk.mk.mk.mk
R : Type u
mul✝¹ add✝¹ : R → R → R
left_distrib✝¹ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝¹ : ∀ (a b c : R), (a + b) * c = a * c + b * c
mul✝ add✝ : R → R → R
left_distrib✝ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝ : ∀ (a b c : R), (a + b) * c = a * c + b * c
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ mk left_distrib✝¹ right_distrib✝¹ = mk left_distrib✝ right_distrib✝
tactic: rcases inst₂ with @⟨⟨⟩, ⟨⟩⟩
state_before: case mk.mk.mk.mk.mk.mk
R : Type u
mul✝¹ add✝¹ : R → R → R
left_distrib✝¹ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝¹ : ∀ (a b c : R), (a + b) * c = a * c + b * c
mul✝ add✝ : R → R → R
left_distrib✝ : ∀ (a b c : R), a * (b + c) = a * b + a * c
right_distrib✝ : ∀ (a b c : R), (a + b) * c = a * c + b * c
h_add : HAdd.hAdd = HAdd.hAdd
h_mul : HMul.hMul = HMul.hMul
⊢ mk left_distrib✝¹ right_distrib✝¹ = mk left_distrib✝ right_distrib✝
state_after: no goals
tactic: congr
Theorem: CFC.exp_log
File: Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean

Proof steps:
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
⊢ exp ℝ (log a) = a
state_after: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
ha₃ : ContinuousOn Real.log (spectrum ℝ a)
⊢ exp ℝ (log a) = a
tactic: have ha₃ : ContinuousOn Real.log (spectrum ℝ a) := by
    have : ∀ x ∈ spectrum ℝ a, x ≠ 0 := by peel ha₂ with x hx h; exact h.ne'
    fun_prop (disch := assumption)
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
ha₃ : ContinuousOn Real.log (spectrum ℝ a)
⊢ exp ℝ (log a) = a
state_after: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
ha₃ : ContinuousOn Real.log (spectrum ℝ a)
⊢ cfc (fun x => Real.exp (Real.log x)) a = a
tactic: rw [← real_exp_eq_normedSpace_exp .log, log, ← cfc_comp' Real.exp Real.log a (by fun_prop) ha₃]
state_before: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
ha₃ : ContinuousOn Real.log (spectrum ℝ a)
⊢ cfc (fun x => Real.exp (Real.log x)) a = a
state_after: A : Type u_1
inst✝⁸ : PartialOrder A
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : StarOrderedRing A
inst✝⁴ : TopologicalRing A
inst✝³ : NormedAlgebra ℝ A
inst✝² : CompleteSpace A
inst✝¹ : ContinuousFunctionalCalculus ℝ IsSelfAdjoint
inst✝ : UniqueContinuousFunctionalCalculus ℝ A
a : A
ha₂ : ∀ x ∈ spectrum ℝ a, 0 < x
ha₁ : autoParam (IsSelfAdjoint a) _auto✝
ha₃ : ContinuousOn Real.log (spectrum ℝ a)
⊢ cfc (fun x => Real.exp (Real.log x)) a = cfc id a
tactic: conv_rhs => rw [← cfc_id (R := ℝ) a ha₁]
Theorem: comap_map_eq_map_adjoin_of_coprime_conductor
File: Mathlib/NumberTheory/KummerDedekind.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
I : Ideal R
hx : comap (algebraMap R S) (conductor R x) ⊔ I = ⊤
h_alg : Function.Injective ⇑(algebraMap (↥(adjoin R {x})) S)
⊢ comap (algebraMap (↥(adjoin R {x})) S) (Ideal.map (algebraMap R S) I) = Ideal.map (algebraMap R ↥(adjoin R {x})) I
state_after: case a
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
I : Ideal R
hx : comap (algebraMap R S) (conductor R x) ⊔ I = ⊤
h_alg : Function.Injective ⇑(algebraMap (↥(adjoin R {x})) S)
⊢ comap (algebraMap (↥(adjoin R {x})) S) (Ideal.map (algebraMap R S) I) ≤ Ideal.map (algebraMap R ↥(adjoin R {x})) I

case a
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
I : Ideal R
hx : comap (algebraMap R S) (conductor R x) ⊔ I = ⊤
h_alg : Function.Injective ⇑(algebraMap (↥(adjoin R {x})) S)
⊢ Ideal.map (algebraMap R ↥(adjoin R {x})) I ≤ comap (algebraMap (↥(adjoin R {x})) S) (Ideal.map (algebraMap R S) I)
tactic: apply le_antisymm
Theorem: RingHom.isIntegralElem_map
File: Mathlib/RingTheory/IntegralClosure/IsIntegral/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
A : Type u_3
inst✝³ : CommRing R
inst✝² : Ring A
inst✝¹ : Ring S
f : R →+* S
inst✝ : Algebra R A
x : R
⊢ eval₂ f (f x) (X - C x) = 0
state_after: no goals
tactic: simp
Theorem: CancelDenoms.cancel_factors_eq_div
File: Mathlib/Tactic/CancelDenoms/Core.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Field α
n e e' : α
h : n * e = e'
h2 : n ≠ 0
⊢ e * n = e'
state_after: no goals
tactic: rwa [mul_comm] at h
Theorem: MeasureTheory.VectorMeasure.restrict_univ
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.restrict univ) i = ↑v i
state_after: no goals
tactic: rw [restrict_apply v MeasurableSet.univ hi, Set.inter_univ]
Theorem: WithTop.LinearOrderedAddCommGroup.top_sub
File: Mathlib/Algebra/Order/AddGroupWithTop.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedAddCommGroup α
a✝ b c d : α
a : WithTop α
⊢ ⊤ - a = ⊤
state_after: no goals
tactic: cases a <;> rfl
Theorem: List.sum_replicate
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ : M
n : ℕ
a : M
⊢ (replicate n a).prod = a ^ n
state_after: case zero
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
⊢ (replicate 0 a).prod = a ^ 0

case succ
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
n : ℕ
ih : (replicate n a).prod = a ^ n
⊢ (replicate (n + 1) a).prod = a ^ (n + 1)
tactic: induction' n with n ih
Theorem: range_circleMap
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
⊢ range (circleMap c R) = c +ᵥ R • range fun θ => cexp (↑θ * I)
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) only [← image_vadd, ← image_smul, ← range_comp,
        vadd_eq_add, circleMap, Function.comp_def, real_smul]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
⊢ (c +ᵥ R • range fun θ => cexp (↑θ * I)) = sphere c |R|
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
⊢ c +ᵥ sphere (R • 0) (‖R‖ * 1) = sphere c |R|
tactic: rw [Complex.range_exp_mul_I, smul_sphere R 0 zero_le_one]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
⊢ c +ᵥ sphere (R • 0) (‖R‖ * 1) = sphere c |R|
state_after: no goals
tactic: simp