ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: sub_div_sub_smul_slope_add_sub_div_sub_smul_slope
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c
state_after: case pos
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : a = b
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c

case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c
tactic: by_cases hab : a = b
state_before: case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c
state_after: case pos
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
hbc : b = c
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c

case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
hbc : ¬b = c
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c
tactic: by_cases hbc : b = c
state_before: case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
hbc : ¬b = c
⊢ ((b - a) / (c - a)) • slope f a b + ((c - b) / (c - a)) • slope f b c = slope f a c
state_after: case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
hbc : ¬b = c
⊢ ((c - b) / (c - a)) • slope f b c + ((b - a) / (c - a)) • slope f a b = slope f a c
tactic: rw [add_comm]
state_before: case neg
k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b c : k
hab : ¬a = b
hbc : ¬b = c
⊢ ((c - b) / (c - a)) • slope f b c + ((b - a) / (c - a)) • slope f a b = slope f a c
state_after: no goals
tactic: simp_rw [slope, div_eq_inv_mul, mul_smul, ← smul_add,
    smul_inv_smul₀ (sub_ne_zero.2 <| Ne.symm hab), smul_inv_smul₀ (sub_ne_zero.2 <| Ne.symm hbc),
    vsub_add_vsub_cancel]
Theorem: padicValNat.eq_zero_iff
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p n : ℕ
⊢ padicValNat p n = 0 ↔ p = 1 ∨ n = 0 ∨ ¬p ∣ n
state_after: no goals
tactic: simp only [padicValNat, dite_eq_right_iff, PartENat.get_eq_iff_eq_coe, Nat.cast_zero,
    multiplicity_eq_zero, and_imp, pos_iff_ne_zero, Ne, ← or_iff_not_imp_left]
Theorem: LinearMap.BilinForm.coe_injective
File: Mathlib/LinearAlgebra/BilinearForm/Basic.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
D✝ : BilinForm R M
D₁ : BilinForm R₁ M₁
B D : BilinForm R M
h : (fun B x y => (B x) y) B = (fun B x y => (B x) y) D
⊢ B = D
state_after: case h.h
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
D✝ : BilinForm R M
D₁ : BilinForm R₁ M₁
B D : BilinForm R M
h : (fun B x y => (B x) y) B = (fun B x y => (B x) y) D
x y : M
⊢ (B x) y = (D x) y
tactic: ext x y
state_before: case h.h
R : Type u_1
M : Type u_2
inst✝¹² : CommSemiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
S : Type u_3
inst✝⁹ : CommSemiring S
inst✝⁸ : Algebra S R
inst✝⁷ : Module S M
inst✝⁶ : IsScalarTower S R M
R₁ : Type u_4
M₁ : Type u_5
inst✝⁵ : CommRing R₁
inst✝⁴ : AddCommGroup M₁
inst✝³ : Module R₁ M₁
V : Type u_6
K : Type u_7
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
D✝ : BilinForm R M
D₁ : BilinForm R₁ M₁
B D : BilinForm R M
h : (fun B x y => (B x) y) B = (fun B x y => (B x) y) D
x y : M
⊢ (B x) y = (D x) y
state_after: no goals
tactic: apply congrFun₂ h
Theorem: Stream'.WSeq.mem_rec_on
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
⊢ C s
state_after: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
⊢ ∀ (b : Option α) (s' : Seq (Option α)), some a = b ∨ C s' → C (Seq.cons b s')
tactic: apply Seq.mem_rec_on M
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
⊢ ∀ (b : Option α) (s' : Seq (Option α)), some a = b ∨ C s' → C (Seq.cons b s')
state_after: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
o : Option α
s' : Seq (Option α)
h : some a = o ∨ C s'
⊢ C (Seq.cons o s')
tactic: intro o s' h
state_before: α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
o : Option α
s' : Seq (Option α)
h : some a = o ∨ C s'
⊢ C (Seq.cons o s')
state_after: case none
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
s' : Seq (Option α)
h : some a = none ∨ C s'
⊢ C (Seq.cons none s')

case some
α : Type u
β : Type v
γ : Type w
C : WSeq α → Prop
a : α
s : WSeq α
M : a ∈ s
h1 : ∀ (b : α) (s' : WSeq α), a = b ∨ C s' → C (cons b s')
h2 : ∀ (s : WSeq α), C s → C s.think
s' : Seq (Option α)
b : α
h : some a = some b ∨ C s'
⊢ C (Seq.cons (some b) s')
tactic: cases' o with b
Theorem: GenContFract.convs'Aux_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
n_le_m : n ≤ m
terminatedAt_n : s.TerminatedAt n
⊢ convs'Aux s m = convs'Aux s n
state_after: case refl
K : Type u_1
g : GenContFract K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminatedAt_n : s.TerminatedAt n
⊢ convs'Aux s n = convs'Aux s n

case step
K : Type u_1
g : GenContFract K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminatedAt_n : s.TerminatedAt n
m : ℕ
n_le_m : n.le m
IH : convs'Aux s m = convs'Aux s n
⊢ convs'Aux s m.succ = convs'Aux s n
tactic: induction' n_le_m with m n_le_m IH
Theorem: normalize_idem
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
x : α
⊢ normalize (normalize x) = normalize x
state_after: no goals
tactic: simp
Theorem: Mathlib.Meta.NormNum.intPow_negOfNat_bit0
File: Mathlib/Tactic/NormNum/Pow.lean

Proof steps:
state_before: a b c b' c' : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ (Int.negOfNat a).pow b = Int.ofNat c
state_after: a b c b' c' : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ Int.ofNat a ^ b' * Int.ofNat a ^ b' = Int.ofNat (a.pow b' * a.pow b')
tactic: rw [← hb, Int.negOfNat_eq, Int.pow_eq, pow_mul, neg_pow_two, ← pow_mul, two_mul, pow_add, ← hc,
    ← h1]
state_before: a b c b' c' : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ Int.ofNat a ^ b' * Int.ofNat a ^ b' = Int.ofNat (a.pow b' * a.pow b')
state_after: no goals
tactic: simp
Theorem: Nat.bit_cases_on_injective
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n : ℕ
C : ℕ → Sort u
⊢ Function.Injective fun H n => n.bitCasesOn H
state_after: m n : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
⊢ H₁ = H₂
tactic: intro H₁ H₂ h
state_before: m n : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
⊢ H₁ = H₂
state_after: case h.h
m n✝ : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
b : Bool
n : ℕ
⊢ H₁ b n = H₂ b n
tactic: ext b n
state_before: case h.h
m n✝ : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
b : Bool
n : ℕ
⊢ H₁ b n = H₂ b n
state_after: no goals
tactic: simpa only [bitCasesOn_bit] using congr_fun h (bit b n)
Theorem: Set.disjoint_singleton_left
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ Disjoint {a} s ↔ a ∉ s
state_after: no goals
tactic: simp [Set.disjoint_iff, subset_def]
Theorem: EuclideanGeometry.angle_eq_arctan_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
    inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₃ ≠ p₂
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
tactic: rw [ne_comm, ← @vsub_ne_zero V] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
h0 : p₂ -ᵥ p₃ ≠ 0
⊢ ∠ p₂ p₃ p₁ = Real.arctan (dist p₁ p₂ / dist p₃ p₂)
state_after: no goals
tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub' V p₃ p₂, ← vsub_add_vsub_cancel p₁ p₂ p₃,
    add_comm, angle_add_eq_arctan_of_inner_eq_zero h h0]
Theorem: CategoryTheory.Sheaf.le_finestTopology
File: Mathlib/CategoryTheory/Sites/Canonical.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type v
X Y : C
S : Sieve X
R : Presieve X
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ P ∈ Ps, Presieve.IsSheaf J P
⊢ J ≤ finestTopology Ps
state_after: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ P ∈ Ps, Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ J.sieves X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
⊢ S ∈ (fun f => ↑f X) ⟨(finestTopologySingle P).sieves, ⋯⟩
tactic: rintro X S hS _ ⟨⟨_, _, ⟨P, hP, rfl⟩, rfl⟩, rfl⟩
state_before: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ P ∈ Ps, Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ J.sieves X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
⊢ S ∈ (fun f => ↑f X) ⟨(finestTopologySingle P).sieves, ⋯⟩
state_after: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y✝ : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ P ∈ Ps, Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ J.sieves X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
Y : C
f : Y ⟶ X
⊢ Presieve.IsSheafFor P (Sieve.pullback f S).arrows
tactic: intro Y f
state_before: case intro.mk.intro.intro.intro.intro
C : Type u
inst✝ : Category.{v, u} C
P✝ : Cᵒᵖ ⥤ Type v
X✝ Y✝ : C
S✝ : Sieve X✝
R : Presieve X✝
J✝ J₂ : GrothendieckTopology C
Ps : Set (Cᵒᵖ ⥤ Type v)
J : GrothendieckTopology C
hJ : ∀ P ∈ Ps, Presieve.IsSheaf J P
X : C
S : Sieve X
hS : S ∈ J.sieves X
P : Cᵒᵖ ⥤ Type v
hP : P ∈ Ps
Y : C
f : Y ⟶ X
⊢ Presieve.IsSheafFor P (Sieve.pullback f S).arrows
state_after: no goals
tactic: exact hJ P hP (S.pullback f) (J.pullback_stable f hS)
Theorem: Real.tan_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ tan (-x) = -tan x
state_after: no goals
tactic: simp [tan, neg_div]
Theorem: Complex.abs_ofReal
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: r : ℝ
⊢ abs ↑r = |r|
state_after: no goals
tactic: simp [Complex.abs, normSq_ofReal, Real.sqrt_mul_self_eq_abs]
Theorem: RegularExpression.map_map
File: Mathlib/Computability/RegularExpressions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R S : RegularExpression α
⊢ map g (map f (R + S)) = map (g ∘ f) (R + S)
state_after: no goals
tactic: simp only [map, Function.comp_apply, map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R S : RegularExpression α
⊢ map g (map f (R.comp S)) = map (g ∘ f) (R.comp S)
state_after: no goals
tactic: simp only [map, Function.comp_apply, map_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
g : β → γ
f : α → β
R : RegularExpression α
⊢ map g (map f R.star) = map (g ∘ f) R.star
state_after: no goals
tactic: simp only [map, Function.comp_apply, map_map]
Theorem: SMulPosReflectLE.lift
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosReflectLE α γ
hf : ∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂
smul : ∀ (a : α) (b : β), f (a • b) = a • f b
zero : f 0 = 0
b : β
hb : 0 < b
a₁ a₂ : α
h : a₁ • b ≤ a₂ • b
⊢ a₁ ≤ a₂
state_after: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosReflectLE α γ
b : β
a₁ a₂ : α
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 < f b
h : a₁ • f b ≤ a₂ • f b
⊢ a₁ ≤ a₂
tactic: simp only [← hf, ← lt_iff_lt_of_le_iff_le' hf hf, zero, smul] at *
state_before: α : Type u_1
β : Type u_2
a a₁✝ a₂✝ : α
b✝ b₁ b₂ : β
γ : Type u_3
inst✝⁸ : Zero α
inst✝⁷ : Preorder α
inst✝⁶ : Zero β
inst✝⁵ : Preorder β
inst✝⁴ : Zero γ
inst✝³ : Preorder γ
inst✝² : SMul α β
inst✝¹ : SMul α γ
f : β → γ
inst✝ : SMulPosReflectLE α γ
b : β
a₁ a₂ : α
hf : ∀ {b₁ b₂ : β}, True
smul : α → β → True
zero : True
hb : 0 < f b
h : a₁ • f b ≤ a₂ • f b
⊢ a₁ ≤ a₂
state_after: no goals
tactic: exact le_of_smul_le_smul_right h hb
Theorem: CoxeterSystem.IsReflection.inv
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
⊢ t⁻¹ = t
state_after: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ (w * cs.simple i * w⁻¹)⁻¹ = w * cs.simple i * w⁻¹
tactic: rcases ht with ⟨w, i, rfl⟩
state_before: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ (w * cs.simple i * w⁻¹)⁻¹ = w * cs.simple i * w⁻¹
state_after: no goals
tactic: simp [mul_assoc]
Theorem: WeierstrassCurve.b_relation
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ 4 * W.b₈ = W.b₂ * W.b₆ - W.b₄ ^ 2
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ 4 * (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2) =
    (W.a₁ ^ 2 + 4 * W.a₂) * (W.a₃ ^ 2 + 4 * W.a₆) - (2 * W.a₄ + W.a₁ * W.a₃) ^ 2
tactic: simp only [b₂, b₄, b₆, b₈]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ 4 * (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2) =
    (W.a₁ ^ 2 + 4 * W.a₂) * (W.a₃ ^ 2 + 4 * W.a₆) - (2 * W.a₄ + W.a₁ * W.a₃) ^ 2
state_after: no goals
tactic: ring1
Theorem: ite_add_ite
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Add α
P : Prop
inst✝ : Decidable P
a b c d : α
⊢ ((if P then a else b) + if P then c else d) = if P then a + c else b + d
state_after: case isTrue
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Add α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : P
⊢ a + c = a + c

case isFalse
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Add α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : ¬P
⊢ b + d = b + d
tactic: split
state_before: case isTrue
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Add α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : P
⊢ a + c = a + c

case isFalse
α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Add α
P : Prop
inst✝ : Decidable P
a b c d : α
h✝ : ¬P
⊢ b + d = b + d
state_after: no goals
tactic: repeat rfl
Theorem: RingQuot.ringQuot_ext
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f g : RingQuot r →+* T
w : f.comp (mkRingHom r) = g.comp (mkRingHom r)
⊢ f = g
state_after: case a
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f g : RingQuot r →+* T
w : f.comp (mkRingHom r) = g.comp (mkRingHom r)
x : RingQuot r
⊢ f x = g x
tactic: ext x
state_before: case a
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f g : RingQuot r →+* T
w : f.comp (mkRingHom r) = g.comp (mkRingHom r)
x : RingQuot r
⊢ f x = g x
state_after: case a.intro
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f g : RingQuot r →+* T
w : f.comp (mkRingHom r) = g.comp (mkRingHom r)
x : R
⊢ f ((mkRingHom r) x) = g ((mkRingHom r) x)
tactic: rcases mkRingHom_surjective r x with ⟨x, rfl⟩
state_before: case a.intro
R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
r : R → R → Prop
f g : RingQuot r →+* T
w : f.comp (mkRingHom r) = g.comp (mkRingHom r)
x : R
⊢ f ((mkRingHom r) x) = g ((mkRingHom r) x)
state_after: no goals
tactic: exact (RingHom.congr_fun w x : _)
Theorem: Part.mem_restrict
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ a ∈ restrict p o h ↔ p ∧ a ∈ o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) ↔ p ∧ ∃ (h : o.Dom), o.get h = a
tactic: dsimp [restrict, mem_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) ↔ p ∧ ∃ (h : o.Dom), o.get h = a
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) → p ∧ ∃ (h : o.Dom), o.get h = a

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (p ∧ ∃ (h : o.Dom), o.get h = a) → ∃ (h_1 : p), o.get ⋯ = a
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (p ∧ ∃ (h : o.Dom), o.get h = a) → ∃ (h_1 : p), o.get ⋯ = a
state_after: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
w✝ : o.Dom
h₂ : o.get w✝ = a
⊢ ∃ (h_1 : p), o.get ⋯ = a
tactic: rintro ⟨h₀, _, h₂⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
w✝ : o.Dom
h₂ : o.get w✝ = a
⊢ ∃ (h_1 : p), o.get ⋯ = a
state_after: no goals
tactic: exact ⟨h₀, h₂⟩
Theorem: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_homOfCone
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ coneOfHom h (homOfCone h s) = s
state_after: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ { pt := s.pt, π := h.hom.app (op s.pt) { down := (h.inv.app (op s.pt) s.π).down } } = s
tactic: dsimp [coneOfHom, homOfCone]
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ { pt := s.pt, π := h.hom.app (op s.pt) { down := (h.inv.app (op s.pt) s.π).down } } = s
state_after: no goals
tactic: match s with
  | .mk s_pt s_π =>
    congr; dsimp
    convert congrFun (congrFun (congrArg NatTrans.app h.inv_hom_id) (op s_pt)) s_π using 1
Theorem: Int.toNat_lt'
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
hn : n ≠ 0
⊢ m.toNat < n ↔ m < ↑n
state_after: a b c d m n✝ : ℤ
n : ℕ
hn : n ≠ 0
⊢ 0 < ↑n
tactic: rw [← toNat_lt_toNat, toNat_natCast]
state_before: a b c d m n✝ : ℤ
n : ℕ
hn : n ≠ 0
⊢ 0 < ↑n
state_after: no goals
tactic: omega
Theorem: CoalgebraCat.Hom.toCoalgHom_injective
File: Mathlib/Algebra/Category/CoalgebraCat/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
V W : CoalgebraCat R
x✝² x✝¹ : V.Hom W
f g : ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat
x✝ : { toCoalgHom := f }.toCoalgHom = { toCoalgHom := g }.toCoalgHom
⊢ { toCoalgHom := f } = { toCoalgHom := g }
state_after: no goals
tactic: congr