ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.Sorted.rel_of_mem_take_of_mem_drop
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x y : α
hx : x ∈ take k l
hy : y ∈ drop k l
⊢ r x y
state_after: case intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x : α
hx : x ∈ take k l
iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
⊢ r x (drop k l)[iy]
tactic: obtain ⟨iy, hiy, rfl⟩ := getElem_of_mem hy
state_before: case intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k : ℕ
x : α
hx : x ∈ take k l
iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
⊢ r x (drop k l)[iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r (take k l)[ix] (drop k l)[iy]
tactic: obtain ⟨ix, hix, rfl⟩ := getElem_of_mem hx
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r (take k l)[ix] (drop k l)[iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
tactic: rw [getElem_take', getElem_drop']
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix : ix < (take k l).length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
state_after: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix✝ : ix < (take k l).length
hix : ix < min k l.length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
tactic: rw [length_take] at hix
state_before: case intro.intro.intro.intro
α : Type u
r : α → α → Prop
a : α
l✝ l : List α
h : Sorted r l
k iy : ℕ
hiy : iy < (drop k l).length
hy : (drop k l)[iy] ∈ drop k l
ix : ℕ
hix✝ : ix < (take k l).length
hix : ix < min k l.length
hx : (take k l)[ix] ∈ take k l
⊢ r l[ix] l[k + iy]
state_after: no goals
tactic: exact h.rel_get_of_lt (Nat.lt_add_right _ (Nat.lt_min.mp hix).left)
Theorem: Int.csSup_mem
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

Proof steps:
state_before: s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s ∈ s
state_after: case h.e'_4
s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s = ↑((Classical.choose h2).greatestOfBdd ⋯ h1)
tactic: convert (greatestOfBdd _ (Classical.choose_spec h2) h1).2.1
state_before: case h.e'_4
s : Set ℤ
h1 : s.Nonempty
h2 : BddAbove s
⊢ sSup s = ↑((Classical.choose h2).greatestOfBdd ⋯ h1)
state_after: no goals
tactic: exact dif_pos ⟨h1, h2⟩
Theorem: Set.kernImage_compl
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : Set α
⊢ kernImage f sᶜ = (f '' s)ᶜ
state_after: no goals
tactic: rw [kernImage_eq_compl, compl_compl]
Theorem: WeierstrassCurve.Affine.CoordinateRing.basis_apply
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
n : Fin 2
⊢ (CoordinateRing.basis W) n = (AdjoinRoot.powerBasis' ⋯).gen ^ ↑n
state_after: no goals
tactic: classical
  nontriviality R
  rw [CoordinateRing.basis, Or.by_cases, dif_neg <| not_subsingleton R, Basis.reindex_apply,
    PowerBasis.basis_eq_pow]
  rfl
Theorem: Polynomial.image_rootSet
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
i : K →+* L
inst✝¹ : Algebra R K
inst✝ : Algebra R L
p : R[X]
h : Splits (algebraMap R K) p
f : K →ₐ[R] L
⊢ ⇑f '' p.rootSet K = p.rootSet L
state_after: no goals
tactic: classical
    rw [rootSet, ← Finset.coe_image, ← Multiset.toFinset_map, ← f.coe_toRingHom,
      ← roots_map _ ((splits_id_iff_splits (algebraMap R K)).mpr h), map_map, f.comp_algebraMap,
      ← rootSet]
Theorem: Finsupp.domLCongr_single
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
α₁ : Type u_7
α₂ : Type u_8
e : α₁ ≃ α₂
i : α₁
m : M
⊢ (Finsupp.domLCongr e) (single i m) = single (e i) m
state_after: no goals
tactic: simp
Theorem: MeasureTheory.withDensityᵥ_neg
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
⊢ μ.withDensityᵥ (-f) = -μ.withDensityᵥ f
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : Integrable f μ
⊢ μ.withDensityᵥ (-f) = -μ.withDensityᵥ f

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f g : α → E
hf : ¬Integrable f μ
⊢ μ.withDensityᵥ (-f) = -μ.withDensityᵥ f
tactic: by_cases hf : Integrable f μ
Theorem: HurwitzZeta.sinZeta_neg
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ sinZeta (-a) s = -sinZeta a s
state_after: no goals
tactic: simp_rw [sinZeta, completedSinZeta_neg, neg_div]
Theorem: Real.arcsin_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arcsin x = 0 ↔ x = 0
state_after: no goals
tactic: simp [le_antisymm_iff]
Theorem: Real.iInf_mul_of_nonpos
File: Mathlib/Data/Real/Pointwise.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝ : LinearOrderedField α
r : ℝ
ha : r ≤ 0
f : ι → ℝ
⊢ (⨅ i, f i) * r = ⨆ i, f i * r
state_after: no goals
tactic: simp only [Real.mul_iInf_of_nonpos ha, mul_comm]
Theorem: sub_eq_of_eq_add'
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✝ : CommGroup G
a✝ b✝ c✝ d a b c : G
h : a = b * c
⊢ a / b = c
state_after: no goals
tactic: rw [h, div_eq_mul_inv, mul_comm, inv_mul_cancel_left]
Theorem: Rat.mul_nonneg
File: Mathlib/Algebra/Order/Ring/Rat.lean

Proof steps:
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ * (n₂ /. ↑d₂)
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ * (n₂ /. ↑d₂)
tactic: have d₁0 : 0 < (d₁ : ℤ) := mod_cast Nat.pos_of_ne_zero h₁
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ * (n₂ /. ↑d₂)
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ * (n₂ /. ↑d₂)
tactic: have d₂0 : 0 < (d₂ : ℤ) := mod_cast Nat.pos_of_ne_zero h₂
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ /. ↑d₁ → 0 ≤ n₂ /. ↑d₂ → 0 ≤ n₁ /. ↑d₁ * (n₂ /. ↑d₂)
state_after: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ → 0 ≤ n₂ → 0 ≤ n₁ * n₂
tactic: simp only [d₁0, d₂0, mul_pos, divInt_nonneg_iff_of_pos_right,
        divInt_mul_divInt _ _ d₁0.ne' d₂0.ne']
state_before: a b c p q : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
d₁0 : 0 < ↑d₁
d₂0 : 0 < ↑d₂
⊢ 0 ≤ n₁ → 0 ≤ n₂ → 0 ≤ n₁ * n₂
state_after: no goals
tactic: apply mul_nonneg
Theorem: Finsupp.single_eq_zero
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
⊢ single a b = 0 ↔ b = 0
state_after: no goals
tactic: simp [DFunLike.ext_iff, single_eq_set_indicator]
Theorem: Real.logb_mul
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hx : x ≠ 0
hy : y ≠ 0
⊢ logb b (x * y) = logb b x + logb b y
state_after: no goals
tactic: simp_rw [logb, log_mul hx hy, add_div]
Theorem: padicNorm.div
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : r = 0
⊢ padicNorm p (q / r) = padicNorm p q / padicNorm p r
state_after: no goals
tactic: simp [hr]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : ¬r = 0
⊢ padicNorm p (q / r) * padicNorm p r = padicNorm p q
state_after: no goals
tactic: rw [← padicNorm.mul, div_mul_cancel₀ _ hr]
Theorem: Rat.cast_nonneg
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ 0 ≤ ↑q ↔ 0 ≤ q
state_after: no goals
tactic: norm_cast
Theorem: Subspace.finrank_add_finrank_dualCoannihilator_eq
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualCoannihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
tactic: rw [finrank_dualCoannihilator_eq]
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
tactic: let equiv := W.quotEquivAnnihilator
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
eq : finrank K (Module.Dual K V ⧸ W) = finrank K ↥(dualAnnihilator W)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
tactic: have eq := LinearEquiv.finrank_eq (R := K) (M := (Module.Dual K V) ⧸ W)
    (M₂ := { x // x ∈ dualAnnihilator W }) equiv
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W✝ : Subspace K V
inst✝ : FiniteDimensional K V
W : Subspace K (Module.Dual K V)
equiv : (Module.Dual K V ⧸ W) ≃ₗ[K] ↥(dualAnnihilator W) := W.quotEquivAnnihilator
eq : finrank K (Module.Dual K V ⧸ W) = finrank K ↥(dualAnnihilator W)
⊢ finrank K ↥W + finrank K ↥(dualAnnihilator W) = finrank K V
state_after: no goals
tactic: rw [eq.symm, add_comm, Submodule.finrank_quotient_add_finrank, Subspace.dual_finrank_eq]
Theorem: List.getLastI_eq_getLast?
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
⊢ [].getLastI = [].getLast?.iget
state_after: no goals
tactic: simp [getLastI, Inhabited.default]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
head✝¹ head✝ c : α
l : List α
⊢ (head✝¹ :: head✝ :: c :: l).getLastI = (head✝¹ :: head✝ :: c :: l).getLast?.iget
state_after: no goals
tactic: simp [getLastI, getLastI_eq_getLast? (c :: l)]
Theorem: CategoryTheory.Limits.HasZeroMorphisms.ext
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
⊢ I = J
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
⊢ ∀ (X Y : C), Zero.zero = Zero.zero
tactic: apply ext_aux
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
⊢ ∀ (X Y : C), Zero.zero = Zero.zero
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
⊢ Zero.zero = Zero.zero
tactic: intro X Y
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
⊢ Zero.zero = Zero.zero
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
tactic: have : (I.zero X Y).zero ≫ (J.zero Y Y).zero = (I.zero X Y).zero := by
    apply I.zero_comp X (J.zero Y Y).zero
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
that : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
tactic: have that : (I.zero X Y).zero ≫ (J.zero Y Y).zero = (J.zero X Y).zero := by
    apply J.comp_zero (I.zero X Y).zero Y
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
that : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
state_after: no goals
tactic: rw [← this, ← that]
Theorem: PosNum.lt_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : PosNum
h : Ordering.casesOn Ordering.lt (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ ↑m < ↑n ↔ Ordering.lt = Ordering.lt
state_after: α : Type u_1
m n : PosNum
h : ↑m < ↑n
⊢ ↑m < ↑n ↔ Ordering.lt = Ordering.lt
tactic: simp only at h
state_before: α : Type u_1
m n : PosNum
h : ↑m < ↑n
⊢ ↑m < ↑n ↔ Ordering.lt = Ordering.lt
state_after: no goals
tactic: simp [h]
state_before: α : Type u_1
m n : PosNum
h : Ordering.casesOn Ordering.eq (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ ↑m < ↑n ↔ Ordering.eq = Ordering.lt
state_after: α : Type u_1
m n : PosNum
h : m = n
⊢ ↑m < ↑n ↔ Ordering.eq = Ordering.lt
tactic: simp only at h
state_before: α : Type u_1
m n : PosNum
h : m = n
⊢ ↑m < ↑n ↔ Ordering.eq = Ordering.lt
state_after: no goals
tactic: simp [h, lt_irrefl]
state_before: α : Type u_1
m n : PosNum
h : Ordering.casesOn Ordering.gt (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ ↑m < ↑n ↔ Ordering.gt = Ordering.lt
state_after: no goals
tactic: simp [not_lt_of_gt h]
Theorem: Nat.lcm_mul_left
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n k : ℕ
⊢ (m * n).lcm (m * k) = m * n.lcm k
state_after: case a
m n k : ℕ
⊢ (m * n).lcm (m * k) ∣ m * n.lcm k

case a
m n k : ℕ
⊢ m * n.lcm k ∣ (m * n).lcm (m * k)
tactic: apply dvd_antisymm
Theorem: support_subset_support_matPolyEquiv
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
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
⊢ (m i j).support ⊆ (matPolyEquiv m).support
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ k ∈ (m i j).support → k ∈ (matPolyEquiv m).support
tactic: intro k
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ k ∈ (m i j).support → k ∈ (matPolyEquiv m).support
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ k ∉ (matPolyEquiv m).support → k ∉ (m i j).support
tactic: contrapose
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ k ∉ (matPolyEquiv m).support → k ∉ (m i j).support
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ (matPolyEquiv m).coeff k = 0 → (m i j).coeff k = 0
tactic: simp only [not_mem_support_iff]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
⊢ (matPolyEquiv m).coeff k = 0 → (m i j).coeff k = 0
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
hk : (matPolyEquiv m).coeff k = 0
⊢ (m i j).coeff k = 0
tactic: intro hk
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
hk : (matPolyEquiv m).coeff k = 0
⊢ (m i j).coeff k = 0
state_after: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
hk : (matPolyEquiv m).coeff k = 0
⊢ 0 i j = 0
tactic: rw [← matPolyEquiv_coeff_apply, hk]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
m : Matrix n n R[X]
i j : n
k : ℕ
hk : (matPolyEquiv m).coeff k = 0
⊢ 0 i j = 0
state_after: no goals
tactic: rfl
Theorem: HasSum.div_const
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
R : Type u_3
α : Type u_4
inst✝² : DivisionSemiring α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSemiring α
f g : ι → α
a a₁ a₂ : α
h : HasSum f a
b : α
⊢ HasSum (fun i => f i / b) (a / b)
state_after: no goals
tactic: simp only [div_eq_mul_inv, h.mul_right b⁻¹]
Theorem: AkraBazziRecurrence.GrowsPolynomially.neg_iff
File: Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean

Proof steps:
state_before: f✝ f : ℝ → ℝ
hf : GrowsPolynomially (-f)
⊢ GrowsPolynomially f
state_after: f✝ f : ℝ → ℝ
hf : GrowsPolynomially (-f)
⊢ GrowsPolynomially (- -f)
tactic: rw [← neg_neg f]
state_before: f✝ f : ℝ → ℝ
hf : GrowsPolynomially (-f)
⊢ GrowsPolynomially (- -f)
state_after: no goals
tactic: exact hf.neg
Theorem: forall₃_true_iff
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
β✝ : Sort u_2
p q : α → Prop
β : α → Sort u_3
γ : (a : α) → β a → Sort u_4
⊢ (∀ (a : α) (b : β a), γ a b → True) ↔ True
state_after: no goals
tactic: simp
Theorem: starConvex_sUnion
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
S : Set (Set E)
hS : ∀ s ∈ S, StarConvex 𝕜 x s
⊢ StarConvex 𝕜 x (⋃₀ S)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
S : Set (Set E)
hS : ∀ s ∈ S, StarConvex 𝕜 x s
⊢ StarConvex 𝕜 x (⋃ i, ↑i)
tactic: rw [sUnion_eq_iUnion]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
S : Set (Set E)
hS : ∀ s ∈ S, StarConvex 𝕜 x s
⊢ StarConvex 𝕜 x (⋃ i, ↑i)
state_after: no goals
tactic: exact starConvex_iUnion fun s => hS _ s.2
Theorem: Set.preimage_sub_const_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) ⁻¹' Ioo b c = Ioo (b + a) (c + a)
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: clusterPt_iff_ultrafilter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
f : Filter X
⊢ ClusterPt x f ↔ ∃ u, ↑u ≤ f ∧ ↑u ≤ 𝓝 x
state_after: no goals
tactic: simp_rw [ClusterPt, ← le_inf_iff, exists_ultrafilter_iff, inf_comm]
Theorem: Function.Exact.iff_of_ladder_addEquiv
File: Mathlib/Algebra/Exact.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁸ : AddGroup M
inst✝⁷ : AddGroup N
inst✝⁶ : AddGroup P
f : M →+ N
g : N →+ P
X₁ : Type u_8
X₂ : Type u_9
X₃ : Type u_10
Y₁ : Type u_11
Y₂ : Type u_12
Y₃ : Type u_13
inst✝⁵ : AddCommMonoid X₁
inst✝⁴ : AddCommMonoid X₂
inst✝³ : AddCommMonoid X₃
inst✝² : AddCommMonoid Y₁
inst✝¹ : AddCommMonoid Y₂
inst✝ : AddCommMonoid Y₃
e₁ : X₁ ≃+ Y₁
e₂ : X₂ ≃+ Y₂
e₃ : X₃ ≃+ Y₃
f₁₂ : X₁ →+ X₂
f₂₃ : X₂ →+ X₃
g₁₂ : Y₁ →+ Y₂
g₂₃ : Y₂ →+ Y₃
comm₁₂ : g₁₂.comp ↑e₁ = (↑e₂).comp f₁₂
comm₂₃ : g₂₃.comp ↑e₂ = (↑e₃).comp f₂₃
⊢ Exact ⇑g₁₂ ⇑g₂₃ ↔ Exact ⇑f₁₂ ⇑f₂₃
state_after: case mp
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁸ : AddGroup M
inst✝⁷ : AddGroup N
inst✝⁶ : AddGroup P
f : M →+ N
g : N →+ P
X₁ : Type u_8
X₂ : Type u_9
X₃ : Type u_10
Y₁ : Type u_11
Y₂ : Type u_12
Y₃ : Type u_13
inst✝⁵ : AddCommMonoid X₁
inst✝⁴ : AddCommMonoid X₂
inst✝³ : AddCommMonoid X₃
inst✝² : AddCommMonoid Y₁
inst✝¹ : AddCommMonoid Y₂
inst✝ : AddCommMonoid Y₃
e₁ : X₁ ≃+ Y₁
e₂ : X₂ ≃+ Y₂
e₃ : X₃ ≃+ Y₃
f₁₂ : X₁ →+ X₂
f₂₃ : X₂ →+ X₃
g₁₂ : Y₁ →+ Y₂
g₂₃ : Y₂ →+ Y₃
comm₁₂ : g₁₂.comp ↑e₁ = (↑e₂).comp f₁₂
comm₂₃ : g₂₃.comp ↑e₂ = (↑e₃).comp f₂₃
⊢ Exact ⇑g₁₂ ⇑g₂₃ → Exact ⇑f₁₂ ⇑f₂₃

case mpr
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁸ : AddGroup M
inst✝⁷ : AddGroup N
inst✝⁶ : AddGroup P
f : M →+ N
g : N →+ P
X₁ : Type u_8
X₂ : Type u_9
X₃ : Type u_10
Y₁ : Type u_11
Y₂ : Type u_12
Y₃ : Type u_13
inst✝⁵ : AddCommMonoid X₁
inst✝⁴ : AddCommMonoid X₂
inst✝³ : AddCommMonoid X₃
inst✝² : AddCommMonoid Y₁
inst✝¹ : AddCommMonoid Y₂
inst✝ : AddCommMonoid Y₃
e₁ : X₁ ≃+ Y₁
e₂ : X₂ ≃+ Y₂
e₃ : X₃ ≃+ Y₃
f₁₂ : X₁ →+ X₂
f₂₃ : X₂ →+ X₃
g₁₂ : Y₁ →+ Y₂
g₂₃ : Y₂ →+ Y₃
comm₁₂ : g₁₂.comp ↑e₁ = (↑e₂).comp f₁₂
comm₂₃ : g₂₃.comp ↑e₂ = (↑e₃).comp f₂₃
⊢ Exact ⇑f₁₂ ⇑f₂₃ → Exact ⇑g₁₂ ⇑g₂₃
tactic: constructor
Theorem: Nat.gcdB_zero_left
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: s : ℕ
⊢ gcdB 0 s = 1
state_after: s : ℕ
⊢ (xgcd 0 s).2 = 1
tactic: unfold gcdB
state_before: s : ℕ
⊢ (xgcd 0 s).2 = 1
state_after: no goals
tactic: rw [xgcd, xgcd_zero_left]