1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: subset_succChain
File: Mathlib/Order/Chain.lean

tactic: rw [exists_and_left] at h
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ¬∃ t, IsChain r s ∧ SuperChain r s t
⊢ s ⊆ SuccChain r s
state_after: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ¬(IsChain r s ∧ ∃ x, SuperChain r s x)
⊢ s ⊆ SuccChain r s

tactic: simp [SuccChain, dif_neg, h, Subset.rfl]
state_before: α : Type u_1
β : Type u_2
r : α → α → Prop
c c₁ c₂ c₃ s t : Set α
a b x y : α
h : ¬(IsChain r s ∧ ∃ x, SuperChain r s x)
⊢ s ⊆ SuccChain r s
state_after: no goals
Theorem: CategoryTheory.Iso.isIso_hom
File: Mathlib/CategoryTheory/Iso.lean

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
e : X ≅ Y
⊢ e.hom ≫ e.inv = 𝟙 X
state_after: no goals

tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
e : X ≅ Y
⊢ e.inv ≫ e.hom = 𝟙 Y
state_after: no goals
Theorem: SimpleGraph.sInf_adj_of_nonempty
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: obtain ⟨G, hG⟩ := hs
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (SimpleGraph V)
hs : s.Nonempty
⊢ (∀ G ∈ s, G.Adj a b) → a ≠ b
state_after: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (SimpleGraph V)
G : SimpleGraph V
hG : G ∈ s
⊢ (∀ G ∈ s, G.Adj a b) → a ≠ b

tactic: exact fun h => (h _ hG).ne
state_before: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (SimpleGraph V)
G : SimpleGraph V
hG : G ∈ s
⊢ (∀ G ∈ s, G.Adj a b) → a ≠ b
state_after: no goals
Theorem: ContinuousLinearEquiv.comp_hasStrictFDerivAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: refine ⟨fun H => ?_, fun H => iso.hasStrictFDerivAt.comp x H⟩
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
⊢ HasStrictFDerivAt (⇑iso ∘ f) ((↑iso).comp f') x ↔ HasStrictFDerivAt f f' x
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
H : HasStrictFDerivAt (⇑iso ∘ f) ((↑iso).comp f') x
⊢ HasStrictFDerivAt f f' x

tactic: convert iso.symm.hasStrictFDerivAt.comp x H using 1 <;>
  ext z <;> apply (iso.symm_apply_apply _).symm
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
f' : G →L[𝕜] E
H : HasStrictFDerivAt (⇑iso ∘ f) ((↑iso).comp f') x
⊢ HasStrictFDerivAt f f' x
state_after: no goals
Theorem: Matrix.det_updateRow_add_smul_self
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: simp [det_updateRow_add, det_updateRow_smul,
  det_zero_of_row_eq hij (updateRow_self.trans (updateRow_ne hij.symm).symm)]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ (A.updateRow i (A i + c • A j)).det = A.det
state_after: no goals
Theorem: inv_zpow'
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [inv_zpow, zpow_neg]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a✝ b c d a : α
n : ℤ
⊢ a⁻¹ ^ n = a ^ (-n)
state_after: no goals
Theorem: Matrix.toLinearMap₂_compl₁₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: simp only [LinearMap.toMatrix₂_compl₁₂ b₁ b₂, LinearMap.toMatrix₂_toLinearMap₂,
  toMatrix_toLin]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
M✝ : Type u_4
M₁ : Type u_5
M₂ : Type u_6
M₁' : Type u_7
M₂' : Type u_8
n : Type u_9
m : Type u_10
n' : Type u_11
m' : Type u_12
ι : Type u_13
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : AddCommMonoid M₁
inst✝¹⁴ : Module R M₁
inst✝¹³ : AddCommMonoid M₂
inst✝¹² : Module R M₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
M : Matrix n m R
P : Matrix n n' R
Q : Matrix m m' R
⊢ (toMatrix₂ b₁' b₂') (((toLinearMap₂ b₁ b₂) M).compl₁₂ ((toLin b₁' b₁) P) ((toLin b₂' b₂) Q)) =
    (toMatrix₂ b₁' b₂') ((toLinearMap₂ b₁' b₂') (Pᵀ * M * Q))
state_after: no goals
Theorem: lTensor_mkQ
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

tactic: rw [← exact_iff]
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ ker (lTensor Q N.mkQ) = range (lTensor Q N.subtype)
state_after: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(lTensor Q N.subtype) ⇑(lTensor Q N.mkQ)

tactic: exact lTensor_exact Q (LinearMap.exact_subtype_mkQ N) (Submodule.mkQ_surjective N)
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(lTensor Q N.subtype) ⇑(lTensor Q N.mkQ)
state_after: no goals
Theorem: AddSubmonoid.mul_mem_mul
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

tactic: rfl
state_before: α : Type u_1
G : Type u_2
M✝ : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
M N : AddSubmonoid R
m n : R
hm : m ∈ M
hn : n ∈ N
⊢ (AddMonoidHom.mul ↑⟨m, hm⟩) n = m * n
state_after: no goals
Theorem: Real.log_le_iff_le_exp
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← exp_le_exp, exp_log hx]
state_before: x y : ℝ
hx : 0 < x
⊢ log x ≤ y ↔ x ≤ rexp y
state_after: no goals
Theorem: Int.cast_le
File: Mathlib/Algebra/Order/Ring/Cast.lean

tactic: rw [← sub_nonneg, ← cast_sub, cast_nonneg, sub_nonneg]
state_before: R : Type u_1
inst✝¹ : OrderedRing R
inst✝ : Nontrivial R
m n : ℤ
⊢ ↑m ≤ ↑n ↔ m ≤ n
state_after: no goals
Theorem: CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_snd
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: refine Iff.trans ?_ (BinaryFan.isLimit_iff_isIso_fst h (BinaryFan.mk c.snd c.fst))
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal X
c : BinaryFan X Y
⊢ Nonempty (IsLimit c) ↔ IsIso c.snd
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal X
c : BinaryFan X Y
⊢ Nonempty (IsLimit c) ↔ Nonempty (IsLimit (mk c.snd c.fst))

tactic: exact
  ⟨fun h => ⟨BinaryFan.isLimitFlip h.some⟩, fun h =>
    ⟨(BinaryFan.isLimitFlip h.some).ofIsoLimit (isoBinaryFanMk c).symm⟩⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal X
c : BinaryFan X Y
⊢ Nonempty (IsLimit c) ↔ Nonempty (IsLimit (mk c.snd c.fst))
state_after: no goals
Theorem: LieSubmodule.mk_eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← coe_toSubmodule_eq_iff, bot_coeSubmodule]
state_before: R : Type u
L : Type v
M : Type w
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
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : Submodule R M
h : ∀ {x : L} {m : M}, m ∈ N.carrier → ⁅x, m⁆ ∈ N.carrier
⊢ { toSubmodule := N, lie_mem := h } = ⊥ ↔ N = ⊥
state_after: no goals
Theorem: CompletePartialOrder.scottContinuous
File: Mathlib/Order/CompletePartialOrder.lean

tactic: refine ⟨fun h d hd₁ hd₂ ↦ h hd₁ hd₂ hd₂.isLUB_sSup, fun h d hne hd a hda ↦ ?_⟩
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompletePartialOrder α
inst✝ : Preorder β
f✝ : ι → α
d : Set α
a : α
f : α → β
⊢ ScottContinuous f ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompletePartialOrder α
inst✝ : Preorder β
f✝ : ι → α
d✝ : Set α
a✝ : α
f : α → β
h : ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
d : Set α
hne : d.Nonempty
hd : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
⊢ IsLUB (f '' d) (f a)

tactic: rw [hda.unique hd.isLUB_sSup]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompletePartialOrder α
inst✝ : Preorder β
f✝ : ι → α
d✝ : Set α
a✝ : α
f : α → β
h : ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
d : Set α
hne : d.Nonempty
hd : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
⊢ IsLUB (f '' d) (f a)
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompletePartialOrder α
inst✝ : Preorder β
f✝ : ι → α
d✝ : Set α
a✝ : α
f : α → β
h : ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
d : Set α
hne : d.Nonempty
hd : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
⊢ IsLUB (f '' d) (f (sSup d))

tactic: exact h hne hd
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝¹ : CompletePartialOrder α
inst✝ : Preorder β
f✝ : ι → α
d✝ : Set α
a✝ : α
f : α → β
h : ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (fun x x_1 => x ≤ x_1) d → IsLUB (f '' d) (f (sSup d))
d : Set α
hne : d.Nonempty
hd : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
⊢ IsLUB (f '' d) (f (sSup d))
state_after: no goals
Theorem: Polynomial.toLaurent_C
File: Mathlib/Algebra/Polynomial/Laurent.lean

tactic: convert Polynomial.toLaurent_C_mul_T 0 r
state_before: R : Type u_1
inst✝ : Semiring R
r : R
⊢ toLaurent (Polynomial.C r) = C r
state_after: case h.e'_3
R : Type u_1
inst✝ : Semiring R
r : R
⊢ C r = C r * T ↑0

tactic: simp only [Int.ofNat_zero, T_zero, mul_one]
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
r : R
⊢ C r = C r * T ↑0
state_after: no goals
Theorem: Traversable.id_sequence
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: simp [sequence, traverse_map, id_traverse]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ sequence (pure <$> x) = pure x
state_after: no goals
Theorem: Set.countable_union
File: Mathlib/Data/Set/Countable.lean

tactic: simp [union_eq_iUnion, and_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s t : Set α
⊢ (s ∪ t).Countable ↔ s.Countable ∧ t.Countable
state_after: no goals
Theorem: Stirling.second_wallis_limit
File: Mathlib/Analysis/SpecialFunctions/Stirling.lean

tactic: refine Tendsto.congr' (eventually_atTop.mpr ⟨1, fun n hn =>
  stirlingSeq_pow_four_div_stirlingSeq_pow_two_eq n (one_le_iff_ne_zero.mp hn)⟩) ?_
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto Wallis.W atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))

tactic: have h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2) := by
  rw [mul_one_div, ← mul_one_div (a ^ 4) (a ^ 2), one_div, ← pow_sub_of_lt a]
  norm_num
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))

tactic: rw [h]
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop (𝓝 (a ^ 2 / 2))
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop
    (𝓝 (a ^ 4 / a ^ 2 * (1 / 2)))

tactic: exact ((ha.pow 4).div ((ha.comp (tendsto_id.const_mul_atTop' two_pos)).pow 2)
  (pow_ne_zero 2 hane)).mul tendsto_self_div_two_mul_self_add_one
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
h : a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
⊢ Tendsto (fun n => stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (↑n / (2 * ↑n + 1))) atTop
    (𝓝 (a ^ 4 / a ^ 2 * (1 / 2)))
state_after: no goals

tactic: rw [mul_one_div, ← mul_one_div (a ^ 4) (a ^ 2), one_div, ← pow_sub_of_lt a]
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ a ^ 2 / 2 = a ^ 4 / a ^ 2 * (1 / 2)
state_after: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ 2 < 4

tactic: norm_num
state_before: a : ℝ
hane : a ≠ 0
ha : Tendsto stirlingSeq atTop (𝓝 a)
⊢ 2 < 4
state_after: no goals
Theorem: HasDerivWithinAt.log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: rw [div_eq_inv_mul]
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) (f' / f x) s x
state_after: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') s x

tactic: exact (hasDerivAt_log hx).comp_hasDerivWithinAt x hf
state_before: f : ℝ → ℝ
x f' : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0
⊢ HasDerivWithinAt (fun y => Real.log (f y)) ((f x)⁻¹ * f') s x
state_after: no goals
Theorem: EuclideanDomain.gcd_val
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [gcd]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ gcd a b = gcd (b % a) a
state_after: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ (if a0 : a = 0 then b
    else
      let_fun x := ⋯;
      gcd (b % a) a) =
    gcd (b % a) a

tactic: split_ifs with h <;> [simp only [h, mod_zero, gcd_zero_right]; rfl]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
a b : R
⊢ (if a0 : a = 0 then b
    else
      let_fun x := ⋯;
      gcd (b % a) a) =
    gcd (b % a) a
state_after: no goals
Theorem: Int.not_even_iff
File: Mathlib/Algebra/Group/Int.lean

tactic: rw [even_iff, emod_two_ne_zero]
state_before: u v m n : ℤ
⊢ ¬Even n ↔ n % 2 = 1
state_after: no goals
Theorem: Rep.diagonalHomEquiv_apply
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

tactic: change f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) = _
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ (diagonalHomEquiv n A) f x = f.hom (Finsupp.single (Fin.partialProd x) 1)
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) =
    f.hom (Finsupp.single (Fin.partialProd x) 1)

tactic: rw [diagonalSucc_inv_single_single, one_smul, one_mul]
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) =
    f.hom (Finsupp.single (Fin.partialProd x) 1)
state_after: no goals
Theorem: List.nthLe_reverse'
File: Mathlib/Data/List/Basic.lean

tactic: rw [eq_comm]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.reverse.nthLe n hn = l.nthLe (l.length - 1 - n) hn'
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.nthLe n hn

tactic: convert nthLe_reverse l.reverse n (by simpa) hn using 1
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.nthLe n hn
state_after: case h.e'_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.reverse.nthLe (l.reverse.length - 1 - n) ⋯

tactic: simp
state_before: case h.e'_2
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.nthLe (l.length - 1 - n) hn' = l.reverse.reverse.nthLe (l.reverse.length - 1 - n) ⋯
state_after: no goals

tactic: simpa
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
n : ℕ
hn : n < l.reverse.length
hn' : l.length - 1 - n < l.length
⊢ l.reverse.length - 1 - n < l.reverse.reverse.length
state_after: no goals
Theorem: mul_neg_one_pow_eq_zero_iff
File: Mathlib/Algebra/Ring/Commute.lean

tactic: obtain h | h := neg_one_pow_eq_or R n <;> simp [h]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring R
a b : R
n : ℕ
⊢ a * (-1) ^ n = 0 ↔ a = 0
state_after: no goals
Theorem: Option.elim_comp
File: Mathlib/Data/Option/Basic.lean

tactic: cases i <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
h : α → β
f : γ → α
x : α
i : Option γ
⊢ (i.elim (h x) fun j => h (f j)) = h (i.elim x f)
state_after: no goals
Theorem: T0Space.of_cover
File: Mathlib/Topology/Separation.lean

tactic: refine ⟨fun x y hxy => ?_⟩
state_before: X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
⊢ T0Space X
state_after: X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
x y : X
hxy : Inseparable x y
⊢ x = y

tactic: rcases h x y hxy with ⟨s, hxs, hys, hs⟩
state_before: X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
x y : X
hxy : Inseparable x y
⊢ x = y
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
x y : X
hxy : Inseparable x y
s : Set X
hxs : x ∈ s
hys : y ∈ s
hs : T0Space ↑s
⊢ x = y

tactic: lift x to s using hxs
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
x y : X
hxy : Inseparable x y
s : Set X
hxs : x ∈ s
hys : y ∈ s
hs : T0Space ↑s
⊢ x = y
state_after: case intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
y : X
s : Set X
hys : y ∈ s
hs : T0Space ↑s
x : { x // x ∈ s }
hxy : Inseparable (↑x) y
⊢ ↑x = y

tactic: lift y to s using hys
state_before: case intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
y : X
s : Set X
hys : y ∈ s
hs : T0Space ↑s
x : { x // x ∈ s }
hxy : Inseparable (↑x) y
⊢ ↑x = y
state_after: case intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
s : Set X
hs : T0Space ↑s
x y : { x // x ∈ s }
hxy : Inseparable ↑x ↑y
⊢ ↑x = ↑y

tactic: rw [← subtype_inseparable_iff] at hxy
state_before: case intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
s : Set X
hs : T0Space ↑s
x y : { x // x ∈ s }
hxy : Inseparable ↑x ↑y
⊢ ↑x = ↑y
state_after: case intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
s : Set X
hs : T0Space ↑s
x y : { x // x ∈ s }
hxy : Inseparable x y
⊢ ↑x = ↑y

tactic: exact congr_arg Subtype.val hxy.eq
state_before: case intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
h : ∀ (x y : X), Inseparable x y → ∃ s, x ∈ s ∧ y ∈ s ∧ T0Space ↑s
s : Set X
hs : T0Space ↑s
x y : { x // x ∈ s }
hxy : Inseparable x y
⊢ ↑x = ↑y
state_after: no goals
Theorem: Polynomial.natDegree_derivative_le
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: by_cases p0 : p.natDegree = 0
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
⊢ (derivative p).natDegree ≤ p.natDegree - 1
state_after: case pos
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
p0 : p.natDegree = 0
⊢ (derivative p).natDegree ≤ p.natDegree - 1

case neg
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
p0 : ¬p.natDegree = 0
⊢ (derivative p).natDegree ≤ p.natDegree - 1

tactic: simp [p0, derivative_of_natDegree_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
p0 : p.natDegree = 0
⊢ (derivative p).natDegree ≤ p.natDegree - 1
state_after: no goals

tactic: exact Nat.le_sub_one_of_lt (natDegree_derivative_lt p0)
state_before: case neg
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
p0 : ¬p.natDegree = 0
⊢ (derivative p).natDegree ≤ p.natDegree - 1
state_after: no goals
Theorem: CochainComplex.shiftFunctorAdd_eq
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

tactic: rw [← CategoryTheory.shiftFunctorAdd'_eq_shiftFunctorAdd, shiftFunctorAdd'_eq]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b : ℤ
⊢ shiftFunctorAdd (CochainComplex C ℤ) a b = shiftFunctorAdd' C a b (a + b) ⋯
state_after: no goals
Theorem: PartialEquiv.restr_trans
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: simp [trans_source, inter_comm, inter_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ ((e.restr s).trans e').source = ((e.trans e').restr s).source
state_after: no goals