1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Order.IsPredLimit.pred_ne
File: Mathlib/Order/SuccPred/Limit.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝² : Preorder α
a : α
inst✝¹ : PredOrder α
inst✝ : NoMinOrder α
h : IsPredLimit a
b : α
⊢ pred b ≠ a
state_after: α : Type u_1
inst✝² : Preorder α
inst✝¹ : PredOrder α
inst✝ : NoMinOrder α
b : α
h : IsPredLimit (pred b)
⊢ False

tactic: exact not_isMin _ h.isMin
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : PredOrder α
inst✝ : NoMinOrder α
b : α
h : IsPredLimit (pred b)
⊢ False
state_after: no goals
Theorem: Complex.arg_eq_arg_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp only [ext_abs_arg_iff, map_mul, map_div₀, abs_ofReal, abs_abs,
  div_mul_cancel₀ _ (abs.ne_zero hx), eq_self_iff_true, true_and_iff]
state_before: a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x.arg = y.arg ↔ ↑(abs y) / ↑(abs x) * x = y
state_after: a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x.arg = y.arg ↔ (↑(abs y) / ↑(abs x) * x).arg = y.arg

tactic: rw [← ofReal_div, arg_real_mul]
state_before: a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ x.arg = y.arg ↔ (↑(abs y) / ↑(abs x) * x).arg = y.arg
state_after: case hr
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ 0 < abs y / abs x

tactic: exact div_pos (abs.pos hy) (abs.pos hx)
state_before: case hr
a x✝ z x y : ℂ
hx : x ≠ 0
hy : y ≠ 0
⊢ 0 < abs y / abs x
state_after: no goals
Theorem: Finset.Colex.toColex_lt_toColex_iff_exists_forall_lt
File: Mathlib/Combinatorics/Colex.lean

tactic: rw [← not_le, toColex_le_toColex, not_forall]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
⊢ { ofColex := s } < { ofColex := t } ↔ ∃ a ∈ t, a ∉ s ∧ ∀ b ∈ s, b ∉ t → b < a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
⊢ (∃ x, ¬(x ∈ t → x ∉ s → ∃ b ∈ s, b ∉ t ∧ x ≤ b)) ↔ ∃ a ∈ t, a ∉ s ∧ ∀ b ∈ s, b ∉ t → b < a

tactic: simp only [not_forall, not_exists, not_and, not_le, exists_prop, exists_and_left]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
r : ℕ
⊢ (∃ x, ¬(x ∈ t → x ∉ s → ∃ b ∈ s, b ∉ t ∧ x ≤ b)) ↔ ∃ a ∈ t, a ∉ s ∧ ∀ b ∈ s, b ∉ t → b < a
state_after: no goals
Theorem: MeasureTheory.TendstoInMeasure.exists_seq_tendstoInMeasure_atTop
File: Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean

tactic: obtain ⟨ns, h_tendsto_ns⟩ : ∃ ns : ℕ → ι, Tendsto ns atTop u := exists_seq_tendsto u
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g
state_after: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ns : ℕ → ι
h_tendsto_ns : Tendsto ns atTop u
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g

tactic: exact ⟨ns, fun ε hε => (hfg ε hε).comp h_tendsto_ns⟩
state_before: case intro
α : Type u_1
ι : Type u_2
E : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝² : MetricSpace E
f✝ : ℕ → α → E
g✝ : α → E
u : Filter ι
inst✝¹ : u.NeBot
inst✝ : u.IsCountablyGenerated
f : ι → α → E
g : α → E
hfg : TendstoInMeasure μ f u g
ns : ℕ → ι
h_tendsto_ns : Tendsto ns atTop u
⊢ ∃ ns, TendstoInMeasure μ (fun n => f (ns n)) atTop g
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.homMk'_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ mk (S.map (𝟙 f.left) ≫ f.hom) = f
state_after: no goals

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ f.homMk' (𝟙 f.left) = eqToHom ⋯
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ (f.homMk' (𝟙 f.left)).left = (eqToHom ⋯).left

tactic: simp [eqToHom_left]
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ (f.homMk' (𝟙 f.left)).left = (eqToHom ⋯).left
state_after: no goals
Theorem: Filter.cofinite_eq_bot_iff
File: Mathlib/Order/Filter/Cofinite.lean

tactic: simp [← empty_mem_iff_bot, finite_univ_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
⊢ cofinite = ⊥ ↔ Finite α
state_after: no goals
Theorem: ext_nat
File: Mathlib/Data/Nat/Cast/Basic.lean

tactic: simp only [map_one f, map_one g]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
S : Type u_4
F : Type u_5
inst✝³ : NonAssocSemiring R
inst✝² : NonAssocSemiring S
inst✝¹ : FunLike F ℕ R
inst✝ : RingHomClass F ℕ R
f g : F
⊢ f 1 = g 1
state_after: no goals
Theorem: SimplicialObject.Splitting.cofan_inj_πSummand_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: dsimp [πSummand]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ (s.cofan Δ).inj A ≫ s.πSummand B = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ ((s.cofan Δ).inj A ≫ s.desc Δ fun B_1 => if h : B_1 = B then eqToHom ⋯ else 0) = 0

tactic: rw [ι_desc, dif_neg h.symm]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ ((s.cofan Δ).inj A ≫ s.desc Δ fun B_1 => if h : B_1 = B then eqToHom ⋯ else 0) = 0
state_after: no goals
Theorem: List.rdrop_eq_reverse_drop_reverse
File: Mathlib/Data/List/DropRight.lean

tactic: rw [rdrop]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ l.rdrop n = (drop n l.reverse).reverse
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ take (l.length - n) l = (drop n l.reverse).reverse

tactic: induction' l using List.reverseRecOn with xs x IH generalizing n
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ take (l.length - n) l = (drop n l.reverse).reverse
state_after: case nil
α : Type u_1
p : α → Bool
n : ℕ
⊢ take ([].length - n) [] = (drop n [].reverse).reverse

case append_singleton
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
n : ℕ
⊢ take ((xs ++ [x]).length - n) (xs ++ [x]) = (drop n (xs ++ [x]).reverse).reverse

tactic: simp
state_before: case nil
α : Type u_1
p : α → Bool
n : ℕ
⊢ take ([].length - n) [] = (drop n [].reverse).reverse
state_after: no goals

tactic: cases n
state_before: case append_singleton
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
n : ℕ
⊢ take ((xs ++ [x]).length - n) (xs ++ [x]) = (drop n (xs ++ [x]).reverse).reverse
state_after: case append_singleton.zero
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
⊢ take ((xs ++ [x]).length - 0) (xs ++ [x]) = (drop 0 (xs ++ [x]).reverse).reverse

case append_singleton.succ
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
n✝ : ℕ
⊢ take ((xs ++ [x]).length - (n✝ + 1)) (xs ++ [x]) = (drop (n✝ + 1) (xs ++ [x]).reverse).reverse

tactic: simp [take_append]
state_before: case append_singleton.zero
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
⊢ take ((xs ++ [x]).length - 0) (xs ++ [x]) = (drop 0 (xs ++ [x]).reverse).reverse
state_after: no goals

tactic: simp [take_append_eq_append_take, IH]
state_before: case append_singleton.succ
α : Type u_1
p : α → Bool
xs : List α
x : α
IH : ∀ (n : ℕ), take (xs.length - n) xs = (drop n xs.reverse).reverse
n✝ : ℕ
⊢ take ((xs ++ [x]).length - (n✝ + 1)) (xs ++ [x]) = (drop (n✝ + 1) (xs ++ [x]).reverse).reverse
state_after: no goals
Theorem: CliffordAlgebra.hom_ext
File: Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean

tactic: intro h
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
⊢ f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q → f = g
state_after: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ f = g

tactic: apply (lift Q).symm.injective
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ f = g
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ (lift Q).symm f = (lift Q).symm g

tactic: rw [lift_symm_apply, lift_symm_apply]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ (lift Q).symm f = (lift Q).symm g
state_after: case a
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ ⟨f.toLinearMap ∘ₗ ι Q, ⋯⟩ = ⟨g.toLinearMap ∘ₗ ι Q, ⋯⟩

tactic: simp only [h]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
n : ℕ
A✝ : Type u_3
inst✝³ : Semiring A✝
inst✝² : Algebra R A✝
A : Type u_4
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : CliffordAlgebra Q →ₐ[R] A
h : f.toLinearMap ∘ₗ ι Q = g.toLinearMap ∘ₗ ι Q
⊢ ⟨f.toLinearMap ∘ₗ ι Q, ⋯⟩ = ⟨g.toLinearMap ∘ₗ ι Q, ⋯⟩
state_after: no goals
Theorem: IsLocalization.isLocalization_isLocalization_atPrime_isLocalization
File: Mathlib/RingTheory/Localization/LocalizationLocalization.lean

tactic: apply localization_localization_isLocalization_of_has_all_units M p.primeCompl T
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ IsLocalization.AtPrime T (Ideal.comap (algebraMap R S) p)
state_after: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ ∀ (x : S), IsUnit x → x ∈ p.primeCompl

tactic: intro x hx hx'
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ ∀ (x : S), IsUnit x → x ∈ p.primeCompl
state_after: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
x : S
hx : IsUnit x
hx' : x ∈ ↑p
⊢ False

tactic: exact (Hp.1 : ¬_) (p.eq_top_of_isUnit_mem hx' hx)
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
x : S
hx : IsUnit x
hx' : x ∈ ↑p
⊢ False
state_after: no goals
Theorem: Equiv.Perm.IsCycleOn.isCycle_subtypePerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain ⟨a, ha⟩ := hs.nonempty
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
⊢ (f.subtypePerm ⋯).IsCycle
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a✝ b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
a : α
ha : a ∈ s
⊢ (f.subtypePerm ⋯).IsCycle

tactic: exact
  ⟨⟨a, ha⟩, ne_of_apply_ne ((↑) : s → α) (hf.apply_ne hs ha), fun b _ =>
    (hf.2 (⟨a, ha⟩ : s).2 b.2).subtypePerm⟩
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a✝ b x y : α
hf : f.IsCycleOn s
hs : s.Nontrivial
a : α
ha : a ∈ s
⊢ (f.subtypePerm ⋯).IsCycle
state_after: no goals
Theorem: Real.sinh_sub
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sub_eq_add_neg, sinh_add, sinh_neg, cosh_neg]
state_before: x y : ℝ
⊢ sinh (x - y) = sinh x * cosh y - cosh x * sinh y
state_after: no goals
Theorem: DenseInducing.closure_image_mem_nhds
File: Mathlib/Topology/DenseEmbedding.lean

tactic: rw [di.nhds_eq_comap a, ((nhds_basis_opens _).comap _).mem_iff] at hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : s ∈ 𝓝 a
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : ∃ i_1, (i a ∈ i_1 ∧ IsOpen i_1) ∧ i ⁻¹' i_1 ⊆ s
⊢ closure (i '' s) ∈ 𝓝 (i a)

tactic: rcases hs with ⟨U, ⟨haU, hUo⟩, sub : i ⁻¹' U ⊆ s⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
hs : ∃ i_1, (i a ∈ i_1 ∧ IsOpen i_1) ∧ i ⁻¹' i_1 ⊆ s
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ closure (i '' s) ∈ 𝓝 (i a)

tactic: refine mem_of_superset (hUo.mem_nhds haU) ?_
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ closure (i '' s) ∈ 𝓝 (i a)
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ U ⊆ closure (i '' s)

tactic: calc
  U ⊆ closure (i '' (i ⁻¹' U)) := di.dense.subset_closure_image_preimage_of_isOpen hUo
  _ ⊆ closure (i '' s) := closure_mono (image_subset i sub)
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
i : α → β
di✝ : DenseInducing i
s : Set α
a : α
di : DenseInducing i
U : Set β
sub : i ⁻¹' U ⊆ s
haU : i a ∈ U
hUo : IsOpen U
⊢ U ⊆ closure (i '' s)
state_after: no goals
Theorem: not_IntegrableOn_Ici_inv
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

tactic: have A : ∀ᶠ x in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x := by
  filter_upwards [Ioi_mem_atTop 0] with x hx using Real.hasDerivAt_log (ne_of_gt hx)
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume

tactic: have B : Tendsto (fun x => ‖Real.log x‖) atTop atTop :=
  tendsto_norm_atTop_atTop.comp Real.tendsto_log_atTop
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
B : Tendsto (fun x => ‖Real.log x‖) atTop atTop
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume

tactic: exact not_integrableOn_of_tendsto_norm_atTop_of_deriv_isBigO_filter atTop (Ici_mem_atTop a)
  (A.mono (fun x hx ↦ hx.differentiableAt)) B
  (Filter.EventuallyEq.isBigO (A.mono (fun x hx ↦ hx.deriv)))
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
A : ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
B : Tendsto (fun x => ‖Real.log x‖) atTop atTop
⊢ ¬IntegrableOn (fun x => x⁻¹) (Ici a) volume
state_after: no goals

tactic: filter_upwards [Ioi_mem_atTop 0] with x hx using Real.hasDerivAt_log (ne_of_gt hx)
state_before: E : Type u_1
F : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedAddCommGroup F
a : ℝ
⊢ ∀ᶠ (x : ℝ) in atTop, HasDerivAt (fun x => Real.log x) x⁻¹ x
state_after: no goals
Theorem: Complex.sin_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: unfold arg
state_before: a x✝ z x : ℂ
⊢ Real.sin x.arg = x.im / abs x
state_after: a x✝ z x : ℂ
⊢ Real.sin
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.im / abs x

tactic: split_ifs <;>
simp [sub_eq_add_neg, arg,
Real.sin_arcsin (abs_le.1 (abs_im_div_abs_le_one x)).1 (abs_le.1 (abs_im_div_abs_le_one x)).2,
Real.sin_add, neg_div, Real.arcsin_neg, Real.sin_neg]
state_before: a x✝ z x : ℂ
⊢ Real.sin
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.im / abs x
state_after: no goals
Theorem: ZMod.units_pow_card_sub_one_eq_one
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: rw [← card_units p, pow_card_eq_one]
state_before: K : Type u_1
R : Type u_2
p : ℕ
inst✝ : Fact (Nat.Prime p)
a : (ZMod p)ˣ
⊢ a ^ (p - 1) = 1
state_after: no goals
Theorem: preimage_coe_mem_nhds_subtype
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [← map_nhds_subtype_val, mem_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
s t : Set α
a : ↑s
⊢ Subtype.val ⁻¹' t ∈ 𝓝 a ↔ t ∈ 𝓝[s] ↑a
state_after: no goals
Theorem: MeasureTheory.integrableOn_empty
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp [IntegrableOn, integrable_zero_measure]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
⊢ IntegrableOn f ∅ μ
state_after: no goals
Theorem: IntermediateField.sepDegree_bot
File: Mathlib/FieldTheory/SeparableClosure.lean

tactic: have := lift_sepDegree_eq_of_equiv _ _ _ (botEquiv F E)
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
⊢ sepDegree F ↥⊥ = 1
state_after: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
this : Cardinal.lift.{u, v} (sepDegree F ↥⊥) = Cardinal.lift.{v, u} (sepDegree F F)
⊢ sepDegree F ↥⊥ = 1

tactic: rwa [sepDegree_self, Cardinal.lift_one, ← Cardinal.lift_one.{v, u}, Cardinal.lift_inj] at this
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
this : Cardinal.lift.{u, v} (sepDegree F ↥⊥) = Cardinal.lift.{v, u} (sepDegree F F)
⊢ sepDegree F ↥⊥ = 1
state_after: no goals
Theorem: Polynomial.iterate_derivative_X_pow_eq_C_mul
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: rw [iterate_derivative_X_pow_eq_natCast_mul n k, C_eq_natCast]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
⊢ (⇑derivative)^[k] (X ^ n) = C ↑(n.descFactorial k) * X ^ (n - k)
state_after: no goals
Theorem: dvd_sub_right
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

tactic: rw [sub_eq_add_neg, dvd_add_right h, dvd_neg (α := α)]
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ b
⊢ a ∣ b - c ↔ a ∣ c
state_after: no goals
Theorem: MvPolynomial.homogeneousComponent_eq_zero'
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: simp_rw [← weightedDegree_one] at h
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : ∀ d ∈ φ.support, degree d ≠ n
⊢ (homogeneousComponent n) φ = 0
state_after: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : ∀ d ∈ φ.support, (weightedDegree 1) d ≠ n
⊢ (homogeneousComponent n) φ = 0

tactic: exact weightedHomogeneousComponent_eq_zero' n φ h
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : ∀ d ∈ φ.support, (weightedDegree 1) d ≠ n
⊢ (homogeneousComponent n) φ = 0
state_after: no goals