1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: linear_isometry_complex_aux
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: simp only [ext_iff, ← and_or_left, neg_re, I_re, neg_im, neg_zero]
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ f I = I ∨ f I = -I
state_after: f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = 0 ∧ ((f I).im = I.im ∨ (f I).im = -I.im)

tactic: constructor
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = 0 ∧ ((f I).im = I.im ∨ (f I).im = -I.im)
state_after: case left
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = 0

case right
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).im = I.im ∨ (f I).im = -I.im

tactic: rw [← I_re]
state_before: case left
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = 0
state_after: case left
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = I.re

tactic: exact @LinearIsometry.re_apply_eq_re f.toLinearIsometry h I
state_before: case left
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).re = I.re
state_after: no goals

tactic: apply @LinearIsometry.im_apply_eq_im_or_neg_of_re_apply_eq_re f.toLinearIsometry
state_before: case right
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ (f I).im = I.im ∨ (f I).im = -I.im
state_after: case right.h₂
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ ∀ (z : ℂ), (f.toLinearIsometry z).re = z.re

tactic: intro z
state_before: case right.h₂
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
⊢ ∀ (z : ℂ), (f.toLinearIsometry z).re = z.re
state_after: case right.h₂
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
z : ℂ
⊢ (f.toLinearIsometry z).re = z.re

tactic: rw [@LinearIsometry.re_apply_eq_re f.toLinearIsometry h]
state_before: case right.h₂
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
z : ℂ
⊢ (f.toLinearIsometry z).re = z.re
state_after: no goals

tactic: apply LinearIsometryEquiv.toLinearEquiv_injective
state_before: case refine_2
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
⊢ f = conjLIE
state_after: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
⊢ f.toLinearEquiv = conjLIE.toLinearEquiv

tactic: apply Complex.basisOneI.ext'
state_before: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
⊢ f.toLinearEquiv = conjLIE.toLinearEquiv
state_after: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
⊢ ∀ (i : Fin 2), f.toLinearEquiv (basisOneI i) = conjLIE.toLinearEquiv (basisOneI i)

tactic: intro i
state_before: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
⊢ ∀ (i : Fin 2), f.toLinearEquiv (basisOneI i) = conjLIE.toLinearEquiv (basisOneI i)
state_after: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
i : Fin 2
⊢ f.toLinearEquiv (basisOneI i) = conjLIE.toLinearEquiv (basisOneI i)

tactic: fin_cases i <;> simp [h, h']
state_before: case refine_2.a
f : ℂ ≃ₗᵢ[ℝ] ℂ
h : f 1 = 1
h0 : f I = I ∨ f I = -I
h' : f I = -I
i : Fin 2
⊢ f.toLinearEquiv (basisOneI i) = conjLIE.toLinearEquiv (basisOneI i)
state_after: no goals
Theorem: NonUnitalAlgebra.sInf_toNonUnitalSubsemiring
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

tactic: simp
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
S : Set (NonUnitalSubalgebra R A)
⊢ ↑(sInf S).toNonUnitalSubsemiring = ↑(sInf (NonUnitalSubalgebra.toNonUnitalSubsemiring '' S))
state_after: no goals
Theorem: Filter.nhds_atTop
File: Mathlib/Topology/Filter.lean

tactic: simp only [atTop, nhds_iInf, nhds_principal]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
inst✝ : Preorder α
⊢ 𝓝 atTop = ⨅ x, 𝓟 (Iic (𝓟 (Ici x)))
state_after: no goals
Theorem: atBot_le_nhds_bot
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [OrderBot.atBot_eq]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : OrderBot α
⊢ atBot ≤ 𝓝 ⊥
state_after: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : OrderBot α
⊢ pure ⊥ ≤ 𝓝 ⊥

tactic: apply pure_le_nhds
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : OrderBot α
⊢ pure ⊥ ≤ 𝓝 ⊥
state_after: no goals
Theorem: CategoryTheory.Abelian.Exact.op_iff
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: rw [← IsEquivalence.exact_iff _ _ (opOpEquivalence C).inverse]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e : Exact g.op f.op
⊢ Exact f g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e : Exact g.op f.op
⊢ Exact ((opOpEquivalence C).inverse.map f) ((opOpEquivalence C).inverse.map g)

tactic: exact Exact.op _ _ e
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
e : Exact g.op f.op
⊢ Exact ((opOpEquivalence C).inverse.map f) ((opOpEquivalence C).inverse.map g)
state_after: no goals
Theorem: List.foldr_eq_of_comm'
File: Mathlib/Data/List/Basic.lean

tactic: rw [foldr, foldr, foldr, hf, ← foldr_eq_of_comm' ..]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → β
hf : ∀ (a b : α) (c : β), f a (f b c) = f b (f a c)
a : β
b c : α
l : List α
⊢ foldr f a (b :: c :: l) = foldr f (f b a) (c :: l)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → β
hf : ∀ (a b : α) (c : β), f a (f b c) = f b (f a c)
a : β
b c : α
l : List α
⊢ f c (f b (foldr f a l)) = f c (foldr f a (b :: l))

tactic: rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → β
hf : ∀ (a b : α) (c : β), f a (f b c) = f b (f a c)
a : β
b c : α
l : List α
⊢ f c (f b (foldr f a l)) = f c (foldr f a (b :: l))
state_after: no goals
Theorem: Batteries.RBNode.Ordered.balRight
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: rw [← reverse_reverse (balRight ..), reverse_balRight]
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (l.balRight v r)
state_after: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (r.reverse.balLeft v l.reverse).reverse

tactic: exact .reverse <| hr.reverse.balLeft
  ((All.reverse.2 vr).imp cmpLT.flip) ((All.reverse.2 lv).imp cmpLT.flip) hl.reverse
state_before: α : Type u_1
cmp : α → α → Ordering
l : RBNode α
v : α
r : RBNode α
lv : All (fun x => cmpLT cmp x v) l
vr : All (fun x => cmpLT cmp v x) r
hl : Ordered cmp l
hr : Ordered cmp r
⊢ Ordered cmp (r.reverse.balLeft v l.reverse).reverse
state_after: no goals
Theorem: Homeomorph.image_interior
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← preimage_symm, preimage_interior]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
s : Set X
⊢ ⇑h '' interior s = interior (⇑h '' s)
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.pentagon_inv_hom_hom_hom_hom
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp [← cancel_epi ((α_ W X Y).hom ▷ Z)]
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X Y Z : C
⊢ (α_ W X Y).inv ▷ Z ≫ (α_ (W ⊗ X) Y Z).hom ≫ (α_ W X (Y ⊗ Z)).hom = (α_ W (X ⊗ Y) Z).hom ≫ W ◁ (α_ X Y Z).hom
state_after: no goals
Theorem: Real.rpow_le_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases eq_or_lt_of_le h₁ with (rfl | h₁')
state_before: x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
⊢ x ^ z ≤ y ^ z
state_after: case inl
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
h : 0 ≤ x
h₂ : 0 ≤ z
h₁ : x ≤ x
⊢ x ^ z ≤ x ^ z

case inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
⊢ x ^ z ≤ y ^ z

tactic: rcases eq_or_lt_of_le h₂ with (rfl | h₂')
state_before: case inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
⊢ x ^ z ≤ y ^ z
state_after: case inr.inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₁' : x < y
h₂ : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0

case inr.inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
h₂' : 0 < z
⊢ x ^ z ≤ y ^ z

tactic: exact le_of_lt (rpow_lt_rpow h h₁' h₂')
state_before: case inr.inr
x✝ y✝ z✝ : ℝ
n : ℕ
x y z : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₂ : 0 ≤ z
h₁' : x < y
h₂' : 0 < z
⊢ x ^ z ≤ y ^ z
state_after: no goals

tactic: rfl
state_before: case inl
x✝ y z✝ : ℝ
n : ℕ
x z : ℝ
h : 0 ≤ x
h₂ : 0 ≤ z
h₁ : x ≤ x
⊢ x ^ z ≤ x ^ z
state_after: no goals

tactic: simp
state_before: case inr.inl
x✝ y✝ z : ℝ
n : ℕ
x y : ℝ
h : 0 ≤ x
h₁ : x ≤ y
h₁' : x < y
h₂ : 0 ≤ 0
⊢ x ^ 0 ≤ y ^ 0
state_after: no goals
Theorem: Metric.emetric_ball_nnreal
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [← Metric.emetric_ball]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = ball x ↑ε
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = EMetric.ball x (ENNReal.ofReal ↑ε)

tactic: simp
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : α
ε : ℝ≥0
⊢ EMetric.ball x ↑ε = EMetric.ball x (ENNReal.ofReal ↑ε)
state_after: no goals
Theorem: Polynomial.nextCoeff_eq_zero_of_eraseLead_eq_zero
File: Mathlib/Algebra/Polynomial/EraseLead.lean

tactic: by_contra h₂
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
⊢ f.nextCoeff = 0
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
h₂ : ¬f.nextCoeff = 0
⊢ False

tactic: exact leadingCoeff_ne_zero.mp (leadingCoeff_eraseLead_eq_nextCoeff h₂ ▸ h₂) h
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
h₂ : ¬f.nextCoeff = 0
⊢ False
state_after: no goals
Theorem: isSquare_inv
File: Mathlib/Algebra/Group/Even.lean

tactic: constructor <;> intro h
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
⊢ IsSquare a⁻¹ ↔ IsSquare a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a
⊢ IsSquare a⁻¹

tactic: rw [← isSquare_op_iff, ← inv_inv a]
state_before: case mp
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare (op a⁻¹⁻¹)

tactic: exact h.map (MulEquiv.inv' α)
state_before: case mp
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare (op a⁻¹⁻¹)
state_after: no goals

tactic: exact (isSquare_op_iff.mpr h).map (MulEquiv.inv' α).symm
state_before: case mpr
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
h : IsSquare a
⊢ IsSquare a⁻¹
state_after: no goals
Theorem: LSeries.hasDerivAt_term
File: Mathlib/NumberTheory/LSeries/Deriv.lean

tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: f : ℕ → ℂ
n : ℕ
s : ℂ
⊢ HasDerivAt (fun z => term f z n) (-term (logMul f) s n) s
state_after: case inl
f : ℕ → ℂ
s : ℂ
⊢ HasDerivAt (fun z => term f z 0) (-term (logMul f) s 0) s

case inr
f : ℕ → ℂ
n : ℕ
s : ℂ
hn : n ≠ 0
⊢ HasDerivAt (fun z => term f z n) (-term (logMul f) s n) s

tactic: simp_rw [term_of_ne_zero hn, ← neg_div, ← neg_mul, mul_comm, mul_div_assoc, div_eq_mul_inv,
  ← cpow_neg]
state_before: case inr
f : ℕ → ℂ
n : ℕ
s : ℂ
hn : n ≠ 0
⊢ HasDerivAt (fun z => term f z n) (-term (logMul f) s n) s
state_after: case inr
f : ℕ → ℂ
n : ℕ
s : ℂ
hn : n ≠ 0
⊢ HasDerivAt (fun z => f n * ↑n ^ (-z)) (f n * (-log ↑n * ↑n ^ (-s))) s

tactic: exact HasDerivAt.const_mul (f n) (by simpa only [mul_comm, ← mul_neg_one (log n), ← mul_assoc]
  using (hasDerivAt_neg' s).const_cpow (Or.inl <| Nat.cast_ne_zero.mpr hn))
state_before: case inr
f : ℕ → ℂ
n : ℕ
s : ℂ
hn : n ≠ 0
⊢ HasDerivAt (fun z => f n * ↑n ^ (-z)) (f n * (-log ↑n * ↑n ^ (-s))) s
state_after: no goals

tactic: simp only [term_zero, neg_zero, hasDerivAt_const]
state_before: case inl
f : ℕ → ℂ
s : ℂ
⊢ HasDerivAt (fun z => term f z 0) (-term (logMul f) s 0) s
state_after: no goals

tactic: simpa only [mul_comm, ← mul_neg_one (log n), ← mul_assoc]
using (hasDerivAt_neg' s).const_cpow (Or.inl <| Nat.cast_ne_zero.mpr hn)
state_before: f : ℕ → ℂ
n : ℕ
s : ℂ
hn : n ≠ 0
⊢ HasDerivAt (fun z => ↑n ^ (-z)) (-log ↑n * ↑n ^ (-s)) s
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.mono'
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

tactic: gcongr
state_before: α : Type u_1
β : Type u_2
m✝ m : OuterMeasure α
s₁ s₂ : Set α
h : s₁ ⊆ s₂
⊢ m s₁ ≤ m s₂
state_after: no goals
Theorem: QuotientGroup.eq_one_iff
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: refine QuotientGroup.eq.trans ?_
state_before: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x : G
⊢ ↑x = 1 ↔ x ∈ N
state_after: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x : G
⊢ x⁻¹ * 1 ∈ N ↔ x ∈ N

tactic: rw [mul_one, Subgroup.inv_mem_iff]
state_before: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x : G
⊢ x⁻¹ * 1 ∈ N ↔ x ∈ N
state_after: no goals
Theorem: SimpleGraph.Subgraph.deleteVerts_deleteVerts
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext <;> simp (config := { contextual := true }) [not_or, and_assoc]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' : G.Subgraph
s✝ s s' : Set V
⊢ (G'.deleteVerts s).deleteVerts s' = G'.deleteVerts (s ∪ s')
state_after: no goals
Theorem: WeierstrassCurve.map_preΨ₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: simp only [preΨ₄, map_b₂, map_b₄, map_b₆, map_b₈]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
⊢ (W.map f).preΨ₄ = Polynomial.map f W.preΨ₄
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
⊢ 2 * X ^ 6 + C (f W.b₂) * X ^ 5 + 5 * C (f W.b₄) * X ^ 4 + 10 * C (f W.b₆) * X ^ 3 + 10 * C (f W.b₈) * X ^ 2 +
        C (f W.b₂ * f W.b₈ - f W.b₄ * f W.b₆) * X +
      C (f W.b₄ * f W.b₈ - f W.b₆ ^ 2) =
    Polynomial.map f
      (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2))

tactic: map_simp
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
⊢ 2 * X ^ 6 + C (f W.b₂) * X ^ 5 + 5 * C (f W.b₄) * X ^ 4 + 10 * C (f W.b₆) * X ^ 3 + 10 * C (f W.b₈) * X ^ 2 +
        C (f W.b₂ * f W.b₈ - f W.b₄ * f W.b₆) * X +
      C (f W.b₄ * f W.b₈ - f W.b₆ ^ 2) =
    Polynomial.map f
      (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2))
state_after: no goals
Theorem: Turing.BlankExtends.below_of_le
File: Mathlib/Computability/TuringMachine.lean

tactic: rintro ⟨i, rfl⟩ ⟨j, rfl⟩ h
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
l l₁ l₂ : List Γ
⊢ BlankExtends l l₁ → BlankExtends l l₂ → l₁.length ≤ l₂.length → BlankExtends l₁ l₂
state_after: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : (l ++ List.replicate i default).length ≤ (l ++ List.replicate j default).length
⊢ BlankExtends (l ++ List.replicate i default) (l ++ List.replicate j default)

tactic: use j - i
state_before: case intro.intro
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : (l ++ List.replicate i default).length ≤ (l ++ List.replicate j default).length
⊢ BlankExtends (l ++ List.replicate i default) (l ++ List.replicate j default)
state_after: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : (l ++ List.replicate i default).length ≤ (l ++ List.replicate j default).length
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default

tactic: simp only [List.length_append, Nat.add_le_add_iff_left, List.length_replicate] at h
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : (l ++ List.replicate i default).length ≤ (l ++ List.replicate j default).length
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default
state_after: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : i ≤ j
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default

tactic: simp only [← List.replicate_add, Nat.add_sub_cancel' h, List.append_assoc]
state_before: case h
Γ : Type u_1
inst✝ : Inhabited Γ
l : List Γ
i j : ℕ
h : i ≤ j
⊢ l ++ List.replicate j default = l ++ List.replicate i default ++ List.replicate (j - i) default
state_after: no goals
Theorem: CategoryTheory.Limits.Cotrident.coequalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

tactic: rw [← s.app_one (Classical.arbitrary J), Category.assoc, Category.assoc, h]
state_before: J : Type w
C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
inst✝ : Nonempty J
s : Cotrident f
W : C
k l : s.pt ⟶ W
h : s.π ≫ k = s.π ≫ l
⊢ s.ι.app zero ≫ k = s.ι.app zero ≫ l
state_after: no goals
Theorem: HurwitzZeta.cosKernel_undef
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

tactic: induction' a using QuotientAddGroup.induction_on' with a'
state_before: a : UnitAddCircle
x : ℝ
hx : x ≤ 0
⊢ cosKernel a x = 0
state_after: case H
x : ℝ
hx : x ≤ 0
a' : ℝ
⊢ cosKernel (↑a') x = 0

tactic: rw [← ofReal_inj, cosKernel_def, jacobiTheta₂_undef _ (by rwa [I_mul_im, ofReal_re]), ofReal_zero]
state_before: case H
x : ℝ
hx : x ≤ 0
a' : ℝ
⊢ cosKernel (↑a') x = 0
state_after: no goals

tactic: rwa [I_mul_im, ofReal_re]
state_before: x : ℝ
hx : x ≤ 0
a' : ℝ
⊢ (I * ↑x).im ≤ 0
state_after: no goals
Theorem: Rel.interedges_disjoint_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [Finset.disjoint_left] at hs ⊢
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : Disjoint s s'
t : Finset β
⊢ Disjoint (interedges r s t) (interedges r s' t)
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s' t

tactic: intro _ hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s' t
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s' t
⊢ False

tactic: rw [mem_interedges_iff] at hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s' t
⊢ False
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s' ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
⊢ False

tactic: exact hs hx.1 hy.1
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s s' : Finset α
hs : ∀ ⦃a : α⦄, a ∈ s → a ∉ s'
t : Finset β
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s' ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
⊢ False
state_after: no goals
Theorem: Batteries.RBNode.Path.insert_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp [insert]
state_before: α : Type u_1
t : RBNode α
v : α
p : Path α
⊢ (p.insert t v).toList = p.withList (setRoot v t).toList
state_after: α : Type u_1
t : RBNode α
v : α
p : Path α
⊢ (match t with
      | nil => p.insertNew v
      | node c a v_1 b => p.fill (node c a v b)).toList =
    p.listL ++ ((setRoot v t).toList ++ p.listR)

tactic: split <;> simp [setRoot]
state_before: α : Type u_1
t : RBNode α
v : α
p : Path α
⊢ (match t with
      | nil => p.insertNew v
      | node c a v_1 b => p.fill (node c a v b)).toList =
    p.listL ++ ((setRoot v t).toList ++ p.listR)
state_after: no goals
Theorem: Function.Injective.sSameSide_map_iff
File: Mathlib/Analysis/Convex/Side.lean

tactic: simp_rw [SSameSide, hf.wSameSide_map_iff, mem_map_iff_mem_of_injective hf]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
f : P →ᵃ[R] P'
hf : Function.Injective ⇑f
⊢ (map f s).SSameSide (f x) (f y) ↔ s.SSameSide x y
state_after: no goals
Theorem: Finset.image₂_right_identity
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [image₂_singleton_right, funext h, image_id']
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b✝ b' : β
c : γ
f : γ → β → γ
b : β
h : ∀ (a : γ), f a b = a
s : Finset γ
⊢ image₂ f s {b} = s
state_after: no goals