ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isOpen_iff_ultrafilter'
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f : Filter X
inst✝ : CompactSpace X
U : Set X
⊢ IsOpen U ↔ ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f : Filter X
inst✝ : CompactSpace X
U : Set X
⊢ (∀ x ∈ U, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → U ∈ l) ↔ ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
tactic: rw [isOpen_iff_ultrafilter]
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f : Filter X
inst✝ : CompactSpace X
U : Set X
⊢ (∀ x ∈ U, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → U ∈ l) ↔ ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f : Filter X
inst✝ : CompactSpace X
U : Set X
⊢ (∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F) → ∀ x ∈ U, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → U ∈ l
tactic: refine ⟨fun h F hF => h F.lim hF F F.le_nhds_lim, ?_⟩
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f : Filter X
inst✝ : CompactSpace X
U : Set X
⊢ (∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F) → ∀ x ∈ U, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → U ∈ l
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f✝ : Filter X
inst✝ : CompactSpace X
U : Set X
cond : ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
x : X
hx : x ∈ U
f : Ultrafilter X
h : ↑f ≤ 𝓝 x
⊢ U ∈ f
tactic: intro cond x hx f h
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f✝ : Filter X
inst✝ : CompactSpace X
U : Set X
cond : ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
x : X
hx : x ∈ U
f : Ultrafilter X
h : ↑f ≤ 𝓝 x
⊢ U ∈ f
state_after: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f✝ : Filter X
inst✝ : CompactSpace X
U : Set X
cond : ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
x : X
f : Ultrafilter X
hx : f.lim ∈ U
h : ↑f ≤ 𝓝 x
⊢ U ∈ f
tactic: rw [← Ultrafilter.lim_eq_iff_le_nhds.2 h] at hx
state_before: X : Type u_1
Y : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : FirstCountableTopology X
inst✝¹ : T2Space X
f✝ : Filter X
inst✝ : CompactSpace X
U : Set X
cond : ∀ (F : Ultrafilter X), F.lim ∈ U → U ∈ ↑F
x : X
f : Ultrafilter X
hx : f.lim ∈ U
h : ↑f ≤ 𝓝 x
⊢ U ∈ f
state_after: no goals
tactic: exact cond _ hx
Theorem: Polynomial.rootSet_C_mul_X_pow
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
a : R
ha : a ≠ 0
⊢ (C a * X ^ n).rootSet S = {0}
state_after: no goals
tactic: rw [C_mul_X_pow_eq_monomial, rootSet_monomial hn ha]
Theorem: Set.Nontrivial.ne_singleton
File: Mathlib/Data/Set/Subsingleton.lean

Proof steps:
state_before: α : Type u
a : α
s t : Set α
x : α
hs : s.Nontrivial
H : s = {x}
⊢ False
state_after: α : Type u
a : α
s t : Set α
x : α
hs : {x}.Nontrivial
H : s = {x}
⊢ False
tactic: rw [H] at hs
state_before: α : Type u
a : α
s t : Set α
x : α
hs : {x}.Nontrivial
H : s = {x}
⊢ False
state_after: no goals
tactic: exact not_nontrivial_singleton hs
Theorem: Polynomial.IsWeaklyEisensteinAt.pow_natDegree_le_of_aeval_zero_of_monic_mem_map
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : (aeval x) f = 0
hmo : f.Monic
⊢ ∀ (i : ℕ), (Polynomial.map (algebraMap R S) f).natDegree ≤ i → x ^ i ∈ Ideal.map (algebraMap R S) 𝓟
state_after: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : (aeval x) f = 0
hmo : f.Monic
⊢ x ^ (Polynomial.map (algebraMap R S) f).natDegree ∈ Ideal.map (algebraMap R S) 𝓟
tactic: suffices x ^ (f.map (algebraMap R S)).natDegree ∈ 𝓟.map (algebraMap R S) by
    intro i hi
    obtain ⟨k, hk⟩ := exists_add_of_le hi
    rw [hk, pow_add]
    exact mul_mem_right _ _ this
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : (aeval x) f = 0
hmo : f.Monic
⊢ x ^ (Polynomial.map (algebraMap R S) f).natDegree ∈ Ideal.map (algebraMap R S) 𝓟
state_after: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : (Polynomial.map (algebraMap R S) f).IsRoot x
hmo : f.Monic
⊢ x ^ (Polynomial.map (algebraMap R S) f).natDegree ∈ Ideal.map (algebraMap R S) 𝓟
tactic: rw [aeval_def, eval₂_eq_eval_map, ← IsRoot.def] at hx
state_before: R : Type u
inst✝² : CommRing R
𝓟 : Ideal R
f : R[X]
hf : f.IsWeaklyEisensteinAt 𝓟
S : Type v
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
hx : (Polynomial.map (algebraMap R S) f).IsRoot x
hmo : f.Monic
⊢ x ^ (Polynomial.map (algebraMap R S) f).natDegree ∈ Ideal.map (algebraMap R S) 𝓟
state_after: no goals
tactic: exact pow_natDegree_le_of_root_of_monic_mem (hf.map _) hx (hmo.map _) _ rfl.le
Theorem: AdicCompletion.ofTensorProduct_bijective_of_finite_of_isNoetherian
File: Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝⁹ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
⊢ Function.Bijective ⇑(ofTensorProduct I M)
state_after: case intro.intro
R✝ : Type u_1
inst✝⁹ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
n : ℕ
f : (Fin n → R) →ₗ[R] M
hf : Function.Surjective ⇑f
⊢ Function.Bijective ⇑(ofTensorProduct I M)
tactic: obtain ⟨n, f, hf⟩ := Module.Finite.exists_fin' R M
state_before: case intro.intro
R✝ : Type u_1
inst✝⁹ : CommRing R✝
I✝ : Ideal R✝
M✝ : Type u_2
inst✝⁸ : AddCommGroup M✝
inst✝⁷ : Module R✝ M✝
N : Type u_3
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R✝ N
R : Type u
inst✝⁴ : CommRing R
I : Ideal R
M : Type u
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : IsNoetherianRing R
inst✝ : Module.Finite R M
n : ℕ
f : (Fin n → R) →ₗ[R] M
hf : Function.Surjective ⇑f
⊢ Function.Bijective ⇑(ofTensorProduct I M)
state_after: no goals
tactic: exact ofTensorProduct_bijective_of_map_from_fin I M f hf
Theorem: Real.sqrt_ne_zero
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
h : 0 ≤ x
⊢ √x ≠ 0 ↔ x ≠ 0
state_after: no goals
tactic: rw [not_iff_not, sqrt_eq_zero h]
Theorem: one_div_le
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ 1 / a ≤ b ↔ 1 / b ≤ a
state_after: no goals
tactic: simpa using inv_le ha hb
Theorem: WeierstrassCurve.Affine.map_negPolynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ (map W f).toAffine.negPolynomial = Polynomial.map (mapRingHom f) W.negPolynomial
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ -Y - C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (-Y - C (C W.a₁ * X + C W.a₃))
tactic: simp only [negPolynomial]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ -Y - C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (-Y - C (C W.a₁ * X + C W.a₃))
state_after: no goals
tactic: map_simp
Theorem: frontier_Ioi'
File: Mathlib/Topology/Order/DenselyOrdered.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
ha : (Ioi a).Nonempty
⊢ frontier (Ioi a) = {a}
state_after: no goals
tactic: simp [frontier, closure_Ioi' ha, Iic_diff_Iio, Icc_self]
Theorem: SetTheory.PGame.birthday_one
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: ⊢ birthday 1 = 1
state_after: ⊢ max (lsub fun i => (moveLeft 1 i).birthday) (lsub fun i => (moveRight 1 i).birthday) = 1
tactic: rw [birthday_def]
state_before: ⊢ max (lsub fun i => (moveLeft 1 i).birthday) (lsub fun i => (moveRight 1 i).birthday) = 1
state_after: no goals
tactic: simp
Theorem: Filter.tendsto_comp_val_Iio_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : NoMinOrder α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atBot l ↔ Tendsto f atBot l
state_after: no goals
tactic: rw [← map_val_Iio_atBot a, tendsto_map'_iff, Function.comp_def]
Theorem: MvPolynomial.monomial_dvd_monomial
File: Mathlib/Algebra/MvPolynomial/Division.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
r s : R
i j : σ →₀ ℕ
⊢ (monomial i) r ∣ (monomial j) s ↔ (s = 0 ∨ i ≤ j) ∧ r ∣ s
state_after: case mp
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
r s : R
i j : σ →₀ ℕ
⊢ (monomial i) r ∣ (monomial j) s → (s = 0 ∨ i ≤ j) ∧ r ∣ s

case mpr
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
r s : R
i j : σ →₀ ℕ
⊢ (s = 0 ∨ i ≤ j) ∧ r ∣ s → (monomial i) r ∣ (monomial j) s
tactic: constructor
Theorem: Nat.gcd_self_sub_right
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
h : m ≤ n
⊢ n.gcd (n - m) = n.gcd m
state_after: no goals
tactic: rw [gcd_comm, gcd_self_sub_left h, gcd_comm]
Theorem: RCLike.nonpos_iff
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
⊢ z ≤ 0 ↔ re z ≤ 0 ∧ im z = 0
state_after: no goals
tactic: simpa only [map_zero] using le_iff_re_im (z := z) (w := 0)
Theorem: inv_sub_inv
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : Field K
a b : K
ha : a ≠ 0
hb : b ≠ 0
⊢ a⁻¹ - b⁻¹ = (b - a) / (a * b)
state_after: no goals
tactic: rw [inv_eq_one_div, inv_eq_one_div, div_sub_div _ _ ha hb, one_mul, mul_one]
Theorem: CategoryTheory.cosimplicialToSimplicialAugmented_obj
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟭 (SimplicialObject C)).map (NatTrans.leftOp f.right) ≫ X✝.leftOp.hom =
    Y✝.leftOp.hom ≫ (SimplicialObject.const C).map f.left.unop
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject C)).map (NatTrans.leftOp f.right) ≫ X✝.leftOp.hom).app x =
    (Y✝.leftOp.hom ≫ (SimplicialObject.const C).map f.left.unop).app x
tactic: ext x
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject C)).map (NatTrans.leftOp f.right) ≫ X✝.leftOp.hom).app x =
    (Y✝.leftOp.hom ≫ (SimplicialObject.const C).map f.left.unop).app x
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (f.right.app (unop x)).unop ≫ (X✝.hom.app (unop x)).unop = (Y✝.hom.app (unop x)).unop ≫ f.left.unop
tactic: dsimp
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (f.right.app (unop x)).unop ≫ (X✝.hom.app (unop x)).unop = (Y✝.hom.app (unop x)).unop ≫ f.left.unop
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (X✝.hom.app (unop x) ≫ f.right.app (unop x)).unop = (f.left ≫ Y✝.hom.app (unop x)).unop
tactic: simp_rw [← unop_comp]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (X✝.hom.app (unop x) ≫ f.right.app (unop x)).unop = (f.left ≫ Y✝.hom.app (unop x)).unop
state_after: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ X✝.hom.app (unop x) ≫ f.right.app (unop x) = f.left ≫ Y✝.hom.app (unop x)
tactic: congr 1
state_before: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ X✝.hom.app (unop x) ≫ f.right.app (unop x) = f.left ≫ Y✝.hom.app (unop x)
state_after: no goals
tactic: exact (congr_app f.w (unop x)).symm
Theorem: Nat.lt_size
File: Mathlib/Data/Nat/Size.lean

Proof steps:
state_before: m n : ℕ
⊢ m < n.size ↔ 2 ^ m ≤ n
state_after: no goals
tactic: rw [← not_lt, Decidable.iff_not_comm, not_lt, size_le]
Theorem: isAlgebraic_algHom_iff
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
A : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Ring A
inst✝⁵ : Algebra R A
inst✝⁴ : Algebra R S
inst✝³ : Algebra S A
inst✝² : IsScalarTower R S A
B : Type u_2
inst✝¹ : Ring B
inst✝ : Algebra R B
f : A →ₐ[R] B
hf : Function.Injective ⇑f
a : A
x✝ : IsAlgebraic R (f a)
p : R[X]
hp0 : p ≠ 0
hp : (aeval (f a)) p = 0
⊢ f ((aeval a) p) = f 0
state_after: no goals
tactic: rwa [map_zero, ← f.comp_apply, ← aeval_algHom]
Theorem: multipliable_int_iff_multipliable_nat_and_neg_add_one
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
⊢ Multipliable f ↔ (Multipliable fun n => f ↑n) ∧ Multipliable fun n => f (-(↑n + 1))
state_after: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -(↑n + 1)
tactic: refine ⟨fun p ↦ ⟨?_, ?_⟩, fun ⟨hf₁, hf₂⟩ ↦ Multipliable.of_nat_of_neg_add_one hf₁ hf₂⟩ <;>
  apply p.comp_injective
state_before: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -(↑n + 1)
state_after: no goals
tactic: exacts [Nat.cast_injective, @Int.negSucc.inj]
Theorem: Complex.re_eq_neg_abs
File: Mathlib/Data/Complex/Order.lean

Proof steps:
state_before: z : ℂ
⊢ z.re = -abs z ↔ z ≤ 0
state_after: no goals
tactic: rw [← neg_eq_iff_eq_neg, neg_re_eq_abs]
Theorem: HasDerivAt.ofReal_comp
File: Mathlib/Analysis/Complex/RealDeriv.lean

Proof steps:
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℝ
u : ℝ
hf : HasDerivAt f u z
⊢ HasDerivAt (fun y => ↑(f y)) (↑u) z
state_after: no goals
tactic: simpa only [ofRealCLM_apply, ofReal_one, real_smul, mul_one] using
    ofRealCLM.hasDerivAt.scomp z hf
Theorem: Fin.foldl_zero
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

Proof steps:
state_before: α : Sort u_1
f : α → Fin 0 → α
x : α
⊢ foldl 0 f x = x
state_after: no goals
tactic: simp [foldl, foldl.loop]
Theorem: Polynomial.degree_le_degree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : q.coeff p.natDegree ≠ 0
⊢ p.degree ≤ q.degree
state_after: case pos
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : q.coeff p.natDegree ≠ 0
hp : p = 0
⊢ p.degree ≤ q.degree

case neg
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : q.coeff p.natDegree ≠ 0
hp : ¬p = 0
⊢ p.degree ≤ q.degree
tactic: by_cases hp : p = 0
Theorem: MeasureTheory.JordanDecomposition.real_smul_negPart_nonneg
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ
hr : 0 ≤ r
⊢ (r • j).negPart = r.toNNReal • j.negPart
state_after: no goals
tactic: rw [real_smul_def, ← smul_negPart, if_pos hr]
Theorem: eq_div_of_mul_eq''
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 : G
h : c * a = b
⊢ a = b / c
state_after: no goals
tactic: simp [h.symm]
Theorem: CategoryTheory.NonPreadditiveAbelian.sub_comp
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
⊢ (f - g) ≫ h = f ≫ h - g ≫ h
state_after: no goals
tactic: rw [sub_def, Category.assoc, σ_comp, ← Category.assoc, prod.lift_map, sub_def]
Theorem: Filter.lift_iInf_of_map_univ
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
⊢ (iInf f).lift g = ⨅ i, (f i).lift g
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : IsEmpty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
f : ι → Filter α
g : Set α → Filter β
hg : ∀ (s t : Set α), g (s ∩ t) = g s ⊓ g t
hg' : g univ = ⊤
h✝ : Nonempty ι
⊢ (iInf f).lift g = ⨅ i, (f i).lift g
tactic: cases isEmpty_or_nonempty ι
Theorem: CategoryTheory.Subobject.lowerEquivalence_inverse
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ 𝟭 (Subobject A) ≅ lower e.functor ⋙ lower e.inverse
state_after: case p
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ 𝟭 (Subobject A) = lower e.functor ⋙ lower e.inverse
tactic: apply eqToIso
state_before: case p
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ 𝟭 (Subobject A) = lower e.functor ⋙ lower e.inverse
state_after: case h.e'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ 𝟭 (Subobject A) = ThinSkeleton.map (𝟭 (MonoOver A))

case h.e'_3
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ lower e.functor ⋙ lower e.inverse = ThinSkeleton.map (e.functor ⋙ e.inverse)
tactic: convert ThinSkeleton.map_iso_eq e.unitIso
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ lower e.inverse ⋙ lower e.functor ≅ 𝟭 (Subobject B)
state_after: case p
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ lower e.inverse ⋙ lower e.functor = 𝟭 (Subobject B)
tactic: apply eqToIso
state_before: case p
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ lower e.inverse ⋙ lower e.functor = 𝟭 (Subobject B)
state_after: case h.e'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ lower e.inverse ⋙ lower e.functor = ThinSkeleton.map (e.inverse ⋙ e.functor)

case h.e'_3
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A : C
B : D
e : MonoOver A ≌ MonoOver B
⊢ 𝟭 (Subobject B) = ThinSkeleton.map (𝟭 (MonoOver B))
tactic: convert ThinSkeleton.map_iso_eq e.counitIso
Theorem: div_le_div_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
b0 : 0 < b
d0 : 0 < d
⊢ a / b ≤ c / d ↔ a * d ≤ c * b
state_after: no goals
tactic: rw [le_div_iff d0, div_mul_eq_mul_div, div_le_iff b0]
Theorem: tendsto_atBot_isLUB
File: Mathlib/Topology/Order/MonotoneConvergence.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
ha : IsLUB (range f) a
⊢ Tendsto f atBot (𝓝 a)
state_after: no goals
tactic: convert tendsto_atTop_isLUB h_anti.dual_left ha using 1
Theorem: Filter.eventually_prod_principal_iff
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ (∀ᶠ (x : α × β) in f ×ˢ 𝓟 s, p x) ↔ ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ {a | ∀ b ∈ s, (a, b) ∈ {x | p x}} ∈ f ↔ {x | ∀ y ∈ s, p (x, y)} ∈ f
tactic: rw [eventually_iff, eventually_iff, mem_prod_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s✝ : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
s : Set β
⊢ {a | ∀ b ∈ s, (a, b) ∈ {x | p x}} ∈ f ↔ {x | ∀ y ∈ s, p (x, y)} ∈ f
state_after: no goals
tactic: simp only [mem_setOf_eq]
Theorem: WittVector.ghostComponent_zero_verschiebungFun
File: Mathlib/RingTheory/WittVector/Verschiebung.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
⊢ (ghostComponent 0) x.verschiebungFun = 0
state_after: no goals
tactic: rw [ghostComponent_apply, aeval_wittPolynomial, Finset.range_one, Finset.sum_singleton,
    verschiebungFun_coeff_zero, pow_zero, pow_zero, pow_one, one_mul]
Theorem: List.join_singleton
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
⊢ [l].join = l
state_after: no goals
tactic: rw [join, join, append_nil]
Theorem: Finset.disjoint_singleton_left
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s t u : Finset α
a b : α
⊢ _root_.Disjoint {a} s ↔ a ∉ s
state_after: no goals
tactic: simp only [disjoint_left, mem_singleton, forall_eq]