ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Set.MapsTo.iterate_restrict
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
⊢ (restrict f s s h)^[n] = restrict f^[n] s s ⋯
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ (restrict f s s h)^[n] x = restrict f^[n] s s ⋯ x
tactic: funext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ (restrict f s s h)^[n] x = restrict f^[n] s s ⋯ x
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ ↑((restrict f s s h)^[n] x) = f^[n] ↑x
tactic: rw [Subtype.ext_iff, MapsTo.val_restrict_apply]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
x : ↑s
⊢ ↑((restrict f s s h)^[n] x) = f^[n] ↑x
state_after: case h.zero
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
x : ↑s
⊢ ↑((restrict f s s h)^[0] x) = f^[0] ↑x

case h.succ
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s✝ s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → α
s : Set α
h : MapsTo f s s
n : ℕ
ihn : ∀ (x : ↑s), ↑((restrict f s s h)^[n] x) = f^[n] ↑x
x : ↑s
⊢ ↑((restrict f s s h)^[n + 1] x) = f^[n + 1] ↑x
tactic: induction' n with n ihn generalizing x
Theorem: PiNat.eq_of_dist_eq_zero
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
hxy : dist x y = 0
⊢ x = y
state_after: case inl
E : ℕ → Type u_1
x : (n : ℕ) → E n
hxy : dist x x = 0
⊢ x = x

case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
hxy : dist x y = 0
h : x ≠ y
⊢ x = y
tactic: rcases eq_or_ne x y with (rfl | h)
state_before: case inr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
hxy : dist x y = 0
h : x ≠ y
⊢ x = y
state_after: no goals
tactic: simp [dist_eq_of_ne h] at hxy
Theorem: lt_of_mul_self_lt_mul_self
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a * a < b * b → a < b
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a ^ 2 < b ^ 2 → a < b
tactic: simp_rw [← sq]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
hb : 0 ≤ b
⊢ a ^ 2 < b ^ 2 → a < b
state_after: no goals
tactic: exact lt_of_pow_lt_pow_left _ hb
Theorem: Nat.minFac_dvd
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n✝ n : ℕ
n1 : n = 1
⊢ n.minFac ∣ n
state_after: no goals
tactic: simp [n1]
Theorem: sq_lt_sq
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ a ^ 2 < b ^ 2 ↔ |a| < |b|
state_after: no goals
tactic: simpa only [sq_abs] using
    (pow_left_strictMonoOn two_ne_zero).lt_iff_lt (abs_nonneg a) (abs_nonneg b)
Theorem: PartENat.card_le_one_iff_subsingleton
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ Subsingleton α
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ #α ≤ 1
tactic: rw [← le_one_iff_subsingleton]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ #α ≤ 1
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ #α ≤ ↑1
tactic: conv_rhs => rw [← Nat.cast_one]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ #α ≤ ↑1
state_after: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ toPartENat #α ≤ ↑1
tactic: rw [← Cardinal.toPartENat_le_natCast_iff]
state_before: α✝ : Type u_1
β : Type u_2
α : Type u_3
⊢ card α ≤ 1 ↔ toPartENat #α ≤ ↑1
state_after: no goals
tactic: simp only [PartENat.card, Nat.cast_one]
Theorem: ContinuousLinearMapWOT.neg_apply
File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E →WOT[𝕜]F
x : E
⊢ (-f) x = -f x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E →WOT[𝕜]F
x : E
⊢ (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm (-f))).toFun x =
    -(↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm f)).toFun x
tactic: simp only [DFunLike.coe]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E →WOT[𝕜]F
x : E
⊢ (↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm (-f))).toFun x =
    -(↑(EquivLike.coe (ContinuousLinearMap.toWOT 𝕜 E F).symm f)).toFun x
state_after: no goals
tactic: rfl
Theorem: Nonneg.toNonneg_lt
File: Mathlib/Algebra/Order/Ring/Unbundled/Nonneg.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : { x // 0 ≤ x }
b : α
⊢ a < toNonneg b ↔ ↑a < b
state_after: case mk
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
b a : α
ha : 0 ≤ a
⊢ ⟨a, ha⟩ < toNonneg b ↔ ↑⟨a, ha⟩ < b
tactic: cases' a with a ha
state_before: case mk
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
b a : α
ha : 0 ≤ a
⊢ ⟨a, ha⟩ < toNonneg b ↔ ↑⟨a, ha⟩ < b
state_after: no goals
tactic: simp [toNonneg, ha.not_lt]
Theorem: MvPolynomial.mem_vars
File: Mathlib/Algebra/MvPolynomial/Variables.lean

Proof steps:
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
⊢ i ∈ p.vars ↔ ∃ d ∈ p.support, i ∈ d.support
state_after: no goals
tactic: classical simp only [vars_def, Multiset.mem_toFinset, mem_degrees, mem_support_iff, exists_prop]
Theorem: iteratedFDeriv_eq_equiv_comp
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedFDeriv 𝕜 n f = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F) ∘ iteratedDeriv n f
state_after: no goals
tactic: rw [iteratedDeriv_eq_equiv_comp, ← Function.comp.assoc, LinearIsometryEquiv.self_comp_symm,
    Function.id_comp]
Theorem: mem_nhdsWithin_Ici_iff_exists_Ico_subset'
File: Mathlib/Topology/Order/LeftRightNhds.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a u' : α
s : Set α
hu' : a < u'
⊢ [s ∈ 𝓝[≥] a, s ∈ 𝓝[Icc a u'] a, s ∈ 𝓝[Ico a u'] a, ∃ u ∈ Ioc a u', Ico a u ⊆ s, ∃ u ∈ Ioi a, Ico a u ⊆ s].get? 0 =
    some (s ∈ 𝓝[≥] a)
state_after: no goals
tactic: norm_num
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a u' : α
s : Set α
hu' : a < u'
⊢ [s ∈ 𝓝[≥] a, s ∈ 𝓝[Icc a u'] a, s ∈ 𝓝[Ico a u'] a, ∃ u ∈ Ioc a u', Ico a u ⊆ s, ∃ u ∈ Ioi a, Ico a u ⊆ s].get? 4 =
    some (∃ u ∈ Ioi a, Ico a u ⊆ s)
state_after: no goals
tactic: norm_num
Theorem: Set.subset_eval_image_pi
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i✝ : ι
ht : (s.pi t).Nonempty
i : ι
⊢ t i ⊆ eval i '' s.pi t
state_after: no goals
tactic: classical
  obtain ⟨f, hf⟩ := ht
  refine fun y hy => ⟨update f i y, fun j hj => ?_, update_same _ _ _⟩
  obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
Theorem: Mathlib.Vector.toList_append
File: Mathlib/Data/Vector/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α n
w : Vector α m
⊢ (v.append w).toList = v.toList ++ w.toList
state_after: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
w : Vector α m
val✝ : List α
property✝ : val✝.length = n
⊢ (append ⟨val✝, property✝⟩ w).toList = toList ⟨val✝, property✝⟩ ++ w.toList
tactic: cases v
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
w : Vector α m
val✝ : List α
property✝ : val✝.length = n
⊢ (append ⟨val✝, property✝⟩ w).toList = toList ⟨val✝, property✝⟩ ++ w.toList
state_after: case mk.mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝¹ : List α
property✝¹ : val✝¹.length = n
val✝ : List α
property✝ : val✝.length = m
⊢ (append ⟨val✝¹, property✝¹⟩ ⟨val✝, property✝⟩).toList = toList ⟨val✝¹, property✝¹⟩ ++ toList ⟨val✝, property✝⟩
tactic: cases w
state_before: case mk.mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝¹ : List α
property✝¹ : val✝¹.length = n
val✝ : List α
property✝ : val✝.length = m
⊢ (append ⟨val✝¹, property✝¹⟩ ⟨val✝, property✝⟩).toList = toList ⟨val✝¹, property✝¹⟩ ++ toList ⟨val✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Comma.eqToHom_left
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ X.left = Y.left
state_after: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.left = X.left
tactic: cases H
state_before: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ X.left = X.left
state_after: no goals
tactic: rfl
state_before: A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X Y : Comma L R
H : X = Y
⊢ (eqToHom H).left = eqToHom ⋯
state_after: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom ⋯).left = eqToHom ⋯
tactic: cases H
state_before: case refl
A : Type u₁
inst✝⁵ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁴ : Category.{v₂, u₂} B
T : Type u₃
inst✝³ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝² : Category.{?u.17088, u_1} A'
inst✝¹ : Category.{?u.17092, u_2} B'
inst✝ : Category.{?u.17096, u_3} T'
L : A ⥤ T
R : B ⥤ T
X : Comma L R
⊢ (eqToHom ⋯).left = eqToHom ⋯
state_after: no goals
tactic: rfl
Theorem: Polynomial.hasseDeriv_apply
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (hasseDeriv k) f = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (f.sum fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)
tactic: dsimp [hasseDeriv]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (f.sum fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = f.sum fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: case e_f
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = fun i r => (monomial (i - k)) (↑(i.choose k) * r)
tactic: congr
state_before: case e_f
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (fun x x_1 => (monomial (x - k)) (x.choose k • x_1)) = fun i r => (monomial (i - k)) (↑(i.choose k) * r)
state_after: case e_f.h.h.a
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ ((monomial (x✝¹ - k)) (x✝¹.choose k • x✝)).coeff n✝ = ((monomial (x✝¹ - k)) (↑(x✝¹.choose k) * x✝)).coeff n✝
tactic: ext
state_before: case e_f.h.h.a
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ ((monomial (x✝¹ - k)) (x✝¹.choose k • x✝)).coeff n✝ = ((monomial (x✝¹ - k)) (↑(x✝¹.choose k) * x✝)).coeff n✝
state_after: case e_f.h.h.a.e_a.h.e_6.h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ x✝¹.choose k • x✝ = ↑(x✝¹.choose k) * x✝
tactic: congr
state_before: case e_f.h.h.a.e_a.h.e_6.h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ x✝¹.choose k • x✝ = ↑(x✝¹.choose k) * x✝
state_after: no goals
tactic: apply nsmul_eq_mul
Theorem: UniformEquiv.toEquiv_injective
File: Mathlib/Topology/UniformSpace/Equiv.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : UniformSpace δ
e : α ≃ β
h₁ : UniformContinuous e.toFun
h₂ : UniformContinuous e.invFun
e' : α ≃ β
h₁' : UniformContinuous e'.toFun
h₂' : UniformContinuous e'.invFun
h :
  { toEquiv := e, uniformContinuous_toFun := h₁, uniformContinuous_invFun := h₂ }.toEquiv =
    { toEquiv := e', uniformContinuous_toFun := h₁', uniformContinuous_invFun := h₂' }.toEquiv
⊢ { toEquiv := e, uniformContinuous_toFun := h₁, uniformContinuous_invFun := h₂ } =
    { toEquiv := e', uniformContinuous_toFun := h₁', uniformContinuous_invFun := h₂' }
state_after: no goals
tactic: simpa only [mk.injEq]
Theorem: Complex.exp_eq_exp_iff_exp_sub_eq_one
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x y : ℂ
⊢ cexp x = cexp y ↔ cexp (x - y) = 1
state_after: no goals
tactic: rw [exp_sub, div_eq_one_iff_eq (exp_ne_zero _)]
Theorem: MeasureTheory.AEEqFun.ext
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : α →ₘ[μ] β
h : ↑f =ᶠ[ae μ] ↑g
⊢ f = g
state_after: no goals
tactic: rwa [← f.mk_coeFn, ← g.mk_coeFn, mk_eq_mk]
Theorem: lt_mul_of_lt_one_right
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁵ : Semiring α
inst✝⁴ : PartialOrder α
a b c d : α
inst✝³ : ExistsAddOfLE α
inst✝² : PosMulStrictMono α
inst✝¹ : CovariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (swap fun x x_1 => x + x_1) fun x x_1 => x < x_1
ha : a < 0
h : b < 1
⊢ a < a * b
state_after: no goals
tactic: simpa only [mul_one] using mul_lt_mul_of_neg_left h ha
Theorem: CategoryTheory.MorphismProperty.LeftFraction.Localization.Q_obj
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{?u.59971, u_1} C
inst✝¹ : Category.{?u.59975, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map (f ≫ g) =
    { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map f ≫
      { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map g
state_after: C : Type u_1
D : Type u_2
inst✝² : Category.{?u.59971, u_1} C
inst✝¹ : Category.{?u.59975, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map (f ≫ g) =
    Hom.comp ({ obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map f)
      ({ obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map g)
tactic: change _ = Hom.comp _ _
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{?u.59971, u_1} C
inst✝¹ : Category.{?u.59975, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map (f ≫ g) =
    Hom.comp ({ obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map f)
      ({ obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map g)
state_after: C : Type u_1
D : Type u_2
inst✝² : Category.{?u.59971, u_1} C
inst✝¹ : Category.{?u.59975, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map (f ≫ g) =
    Hom.mk ((ofHom W f).comp₀ (ofHom W g) (ofHom W g))
tactic: rw [Hom.comp_eq, comp_eq (ofHom W f) (ofHom W g) (ofHom W g) (by simp)]
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{?u.59971, u_1} C
inst✝¹ : Category.{?u.59975, u_2} D
W : MorphismProperty C
inst✝ : W.HasLeftCalculusOfFractions
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => X, map := fun {X Y} f => Hom.mk (ofHom W f) }.map (f ≫ g) =
    Hom.mk ((ofHom W f).comp₀ (ofHom W g) (ofHom W g))
state_after: no goals
tactic: simp only [ofHom, comp₀, comp_id]
Theorem: _private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signAux_swap_zero_one
File: Mathlib/GroupTheory/Perm/Sign.lean

Proof steps:
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
hn : 2 ≤ n
⊢ 0 < 2
state_after: no goals
tactic: decide
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
hn : 2 ≤ n
⊢ 1 < 2
state_after: no goals
tactic: decide
state_before: α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
hn : 2 ≤ n
⊢ (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux = -1
state_after: case zero
α : Type u
inst✝ : DecidableEq α
β : Type v
hn : 2 ≤ 0
⊢ (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux = -1

case succ.zero
α : Type u
inst✝ : DecidableEq α
β : Type v
hn : 2 ≤ 0 + 1
⊢ (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux = -1

case succ.succ
α : Type u
inst✝ : DecidableEq α
β : Type v
n : ℕ
hn : 2 ≤ n + 1 + 1
⊢ (swap ⟨0, ⋯⟩ ⟨1, ⋯⟩).signAux = -1
tactic: rcases n with (_ | _ | n)
Theorem: IsSl2Triple.symm
File: Mathlib/Algebra/Lie/Sl2.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
h e f : L
ht : IsSl2Triple h e f
⊢ -h ≠ 0
state_after: no goals
tactic: simpa using ht.h_ne_zero
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
h e f : L
ht : IsSl2Triple h e f
⊢ ⁅f, e⁆ = -h
state_after: no goals
tactic: rw [← neg_eq_iff_eq_neg, lie_skew, ht.lie_e_f]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
h e f : L
ht : IsSl2Triple h e f
⊢ ⁅-h, f⁆ = 2 • f
state_after: no goals
tactic: rw [neg_lie, neg_eq_iff_eq_neg, ht.lie_h_f_nsmul]
state_before: R : Type u_1
L : Type u_2
M : Type u_3
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
h e f : L
ht : IsSl2Triple h e f
⊢ ⁅-h, e⁆ = -(2 • e)
state_after: no goals
tactic: rw [neg_lie, neg_inj, ht.lie_h_e_nsmul]
Theorem: PolyEquivTensor.toFunBilinear_apply_eq_sum
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ((toFunBilinear R A) a) p = p.sum fun n r => (monomial n) (a * (algebraMap R A) r)
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =
    ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))
tactic: simp only [toFunBilinear_apply_apply, aeval_def, eval₂_eq_sum, Polynomial.sum, Finset.smul_sum]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
⊢ ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =
    ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))
state_after: case e_f.h
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
i : ℕ
⊢ a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (p.coeff i))
tactic: congr with i : 1
state_before: case e_f.h
R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
p : R[X]
i : ℕ
⊢ a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (p.coeff i))
state_after: no goals
tactic: rw [← Algebra.smul_def, ← C_mul', mul_smul_comm, C_mul_X_pow_eq_monomial, ← Algebra.commutes,
    ← Algebra.smul_def, smul_monomial]
Theorem: Int.one_le_ceil_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ 1 ≤ ⌈a⌉ ↔ 0 < a
state_after: no goals
tactic: rw [← zero_add (1 : ℤ), add_one_le_ceil_iff, cast_zero]
Theorem: CliffordAlgebraRing.reverse_apply
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
x : CliffordAlgebra 0
⊢ reverse x = x
state_after: no goals
tactic: induction x using CliffordAlgebra.induction with
  | algebraMap r => exact reverse.commutes _
  | ι x => rw [ι_eq_zero, LinearMap.zero_apply, reverse.map_zero]
  | mul x₁ x₂ hx₁ hx₂ => rw [reverse.map_mul, mul_comm, hx₁, hx₂]
  | add x₁ x₂ hx₁ hx₂ => rw [reverse.map_add, hx₁, hx₂]
Theorem: Matrix.fromBlocks_one
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : Zero α
inst✝ : One α
⊢ fromBlocks 1 0 0 1 = 1
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : Zero α
inst✝ : One α
i j : l ⊕ m
⊢ fromBlocks 1 0 0 1 i j = 1 i j
tactic: ext i j
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : Zero α
inst✝ : One α
i j : l ⊕ m
⊢ fromBlocks 1 0 0 1 i j = 1 i j
state_after: no goals
tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp [one_apply]