ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.empty_vecAlt0
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α✝ : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
α : Type u_4
h : 0 = 0 + 0
⊢ vecAlt0 h ![] = ![]
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
Theorem: Complex.arg_cos_add_sin_mul_I_coe_angle
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
θ : Real.Angle
⊢ ↑(↑θ.cos + ↑θ.sin * I).arg = θ
state_after: no goals
tactic: rw [← one_mul (_ + _), ← ofReal_one, arg_mul_cos_add_sin_mul_I_coe_angle zero_lt_one]
Theorem: Equiv.Perm.IsCycleOn.apply_mem_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
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
hx : f x ∈ s
⊢ x ∈ s
state_after: case h.e'_4
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hx : f x ∈ s
⊢ x = f⁻¹ (f x)
tactic: convert hf.1.perm_inv.1 hx
state_before: case h.e'_4
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
s t : Set α
a b x y : α
hf : f.IsCycleOn s
hx : f x ∈ s
⊢ x = f⁻¹ (f x)
state_after: no goals
tactic: rw [inv_apply_self]
Theorem: CategoryTheory.Limits.biproduct.eqToHom_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ f j = f j'
state_after: no goals
tactic: simp [w]
state_before: J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j j' : J
w : j = j'
⊢ eqToHom ⋯ ≫ ι f j' = ι f j
state_after: case refl
J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ eqToHom ⋯ ≫ ι f j = ι f j
tactic: cases w
state_before: case refl
J : Type w
K : Type u_1
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
f : J → C
inst✝ : HasBiproduct f
j : J
⊢ eqToHom ⋯ ≫ ι f j = ι f j
state_after: no goals
tactic: simp
Theorem: le_add_neg_iff_le
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ 1 ≤ a * b⁻¹ ↔ b ≤ a
state_after: no goals
tactic: rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right]
Theorem: groupCohomology.dOne_apply
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : G → CoeSort.coe A
g : G × G
⊢ (fun f g => (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1) (x + y) g =
    ((fun f g => (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1) x +
        (fun f g => (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1) y)
      g
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : G → CoeSort.coe A
g : G × G
⊢ (A.ρ g.1) (x g.2 + y g.2) - (x (g.1 * g.2) + y (g.1 * g.2)) + (x g.1 + y g.1) =
    (A.ρ g.1) (x g.2) - x (g.1 * g.2) + x g.1 + ((A.ρ g.1) (y g.2) - y (g.1 * g.2) + y g.1)
tactic: dsimp
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
x y : G → CoeSort.coe A
g : G × G
⊢ (A.ρ g.1) (x g.2 + y g.2) - (x (g.1 * g.2) + y (g.1 * g.2)) + (x g.1 + y g.1) =
    (A.ρ g.1) (x g.2) - x (g.1 * g.2) + x g.1 + ((A.ρ g.1) (y g.2) - y (g.1 * g.2) + y g.1)
state_after: no goals
tactic: rw [map_add, add_add_add_comm, add_sub_add_comm]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : G → CoeSort.coe A
g : G × G
⊢ { toFun := fun f g => (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1, map_add' := ⋯ }.toFun (r • x) g =
    ((RingHom.id k) r • { toFun := fun f g => (A.ρ g.1) (f g.2) - f (g.1 * g.2) + f g.1, map_add' := ⋯ }.toFun x) g
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : G → CoeSort.coe A
g : G × G
⊢ (A.ρ g.1) (r • x g.2) - r • x (g.1 * g.2) + r • x g.1 = r • ((A.ρ g.1) (x g.2) - x (g.1 * g.2) + x g.1)
tactic: dsimp
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
r : k
x : G → CoeSort.coe A
g : G × G
⊢ (A.ρ g.1) (r • x g.2) - r • x (g.1 * g.2) + r • x g.1 = r • ((A.ρ g.1) (x g.2) - x (g.1 * g.2) + x g.1)
state_after: no goals
tactic: rw [map_smul, smul_add, smul_sub]
Theorem: MeasureTheory.IsAddFundamentalDomain.addQuotientMeasureEqMeasurePreimage_addQuotientMeasure
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace α
ν : Measure α
inst✝³ : Countable G
inst✝² : MeasurableSpace G
inst✝¹ : SMulInvariantMeasure G α ν
inst✝ : MeasurableSMul G α
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
t : Set α
fund_dom_t : IsFundamentalDomain G t ν
⊢ Measure.map (Quotient.mk α_mod_G) (ν.restrict s) = Measure.map (Quotient.mk α_mod_G) (ν.restrict t)
state_after: no goals
tactic: rw [fund_dom_s.quotientMeasure_eq _ fund_dom_t]
Theorem: MeasureTheory.withDensity_smul'
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
⊢ μ.withDensity (r • f) = r • μ.withDensity f
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s
tactic: refine Measure.ext fun s hs => ?_
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
s : Set α
hs : MeasurableSet s
⊢ (μ.withDensity (r • f)) s = (r • μ.withDensity f) s
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ
tactic: rw [withDensity_apply _ hs, Measure.coe_smul, Pi.smul_apply, withDensity_apply _ hs,
    smul_eq_mul, ← lintegral_const_mul' r f hr]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hr : r ≠ ⊤
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (a : α) in s, (r • f) a ∂μ = ∫⁻ (a : α) in s, r * f a ∂μ
state_after: no goals
tactic: simp only [Pi.smul_apply, smul_eq_mul]
Theorem: Filter.hasBasis_self
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l : Filter α
P : Set α → Prop
⊢ l.HasBasis (fun s => s ∈ l ∧ P s) id ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l : Filter α
P : Set α → Prop
⊢ (∀ (t : Set α), t ∈ l ↔ ∃ i ∈ l, P i ∧ i ⊆ t) ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t
tactic: simp only [hasBasis_iff, id, and_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l✝ l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
l : Filter α
P : Set α → Prop
⊢ (∀ (t : Set α), t ∈ l ↔ ∃ i ∈ l, P i ∧ i ⊆ t) ↔ ∀ t ∈ l, ∃ r ∈ l, P r ∧ r ⊆ t
state_after: no goals
tactic: exact forall_congr' fun s =>
    ⟨fun h => h.1, fun h => ⟨h, fun ⟨t, hl, _, hts⟩ => mem_of_superset hl hts⟩⟩
Theorem: CliffordAlgebra.ofProd_comp_toProd
File: Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
⊢ (ofProd Q₁ Q₂).comp (toProd Q₁ Q₂) = AlgHom.id R (evenOdd Q₁ ᵍ⊗[R] evenOdd Q₂)
state_after: no goals
tactic: ext <;> (dsimp; simp)
Theorem: AlgebraicGeometry.Scheme.Pullback.pullbackP1Iso_inv_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i : 𝒰.J
⊢ (pullbackP1Iso 𝒰 f g i).inv ≫ pullback.fst (p1 𝒰 f g) (𝒰.map i) = (gluing 𝒰 f g).ι i
state_after: no goals
tactic: simp_rw [pullbackP1Iso, pullback.lift_fst]
Theorem: Ideal.Polynomial.mem_closure_X_union_C
File: Mathlib/RingTheory/Jacobson.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ p ∈ Subring.closure (insert X {f | f.degree ≤ 0})
state_after: case refine_1
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (a : R), C a ∈ Subring.closure (insert X {f | f.degree ≤ 0})

case refine_2
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (p q : R[X]),
    p ∈ Subring.closure (insert X {f | f.degree ≤ 0}) →
      q ∈ Subring.closure (insert X {f | f.degree ≤ 0}) → p + q ∈ Subring.closure (insert X {f | f.degree ≤ 0})

case refine_3
R : Type u_1
inst✝ : Ring R
p : R[X]
⊢ ∀ (n : ℕ) (a : R),
    C a * X ^ n ∈ Subring.closure (insert X {f | f.degree ≤ 0}) →
      C a * X ^ (n + 1) ∈ Subring.closure (insert X {f | f.degree ≤ 0})
tactic: refine Polynomial.induction_on p ?_ ?_ ?_
Theorem: nhdsWithin_insert_of_ne
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
⊢ 𝓝[insert y s] x = 𝓝[s] x
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
⊢ t ∈ 𝓝[insert y s] x
tactic: refine le_antisymm (Filter.le_def.2 fun t ht => ?_) (nhdsWithin_mono x <| subset_insert y s)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
⊢ t ∈ 𝓝[insert y s] x
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ t ∈ 𝓝[insert y s] x
tactic: obtain ⟨o, ho, hxo, host⟩ := mem_nhdsWithin.mp ht
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ t ∈ 𝓝[insert y s] x
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ o \ {y} ∩ insert y s ⊆ t
tactic: refine mem_nhdsWithin.mpr ⟨o \ {y}, ho.sdiff isClosed_singleton, ⟨hxo, hxy⟩, ?_⟩
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ o \ {y} ∩ insert y s ⊆ t
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ o \ {y} ∩ s ⊆ t
tactic: rw [inter_insert_of_not_mem <| not_mem_diff_of_mem (mem_singleton y)]
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s : Set X
hxy : x ≠ y
t : Set X
ht : t ∈ 𝓝[s] x
o : Set X
ho : IsOpen o
hxo : x ∈ o
host : o ∩ s ⊆ t
⊢ o \ {y} ∩ s ⊆ t
state_after: no goals
tactic: exact (inter_subset_inter diff_subset Subset.rfl).trans host
Theorem: inv_eq_of_mul_eq_one_left
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b : G
h : a * b = 1
⊢ b⁻¹ = a
state_after: no goals
tactic: rw [← inv_eq_of_mul_eq_one_right h, inv_inv]
Theorem: catalan_three
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

Proof steps:
state_before: ⊢ catalan 3 = 5
state_after: no goals
tactic: norm_num [catalan_eq_centralBinom_div, Nat.centralBinom, Nat.choose]
Theorem: Finmap.disjoint_union_right
File: Mathlib/Data/Finmap.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
x y z : Finmap β
⊢ x.Disjoint (y ∪ z) ↔ x.Disjoint y ∧ x.Disjoint z
state_after: no goals
tactic: rw [Disjoint.symm_iff, disjoint_union_left, Disjoint.symm_iff _ x, Disjoint.symm_iff _ x]
Theorem: sub_smul_slope_vadd
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
⊢ (b - a) • slope f a b +ᵥ f a = f b
state_after: no goals
tactic: rw [sub_smul_slope, vsub_vadd]
Theorem: MeasureTheory.Lp.simpleFunc.dense
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
inst✝ : Fact (1 ≤ p)
hp_ne_top : p ≠ ⊤
⊢ Dense ↑(simpleFunc E p μ)
state_after: no goals
tactic: simpa only [denseRange_subtype_val] using simpleFunc.denseRange (E := E) (μ := μ) hp_ne_top
Theorem: one_lt_natDegree_of_irrational_root
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: x : ℝ
p : ℤ[X]
hx : Irrational x
p_nonzero : p ≠ 0
x_is_root : (aeval x) p = 0
⊢ 1 < p.natDegree
state_after: x : ℝ
p : ℤ[X]
hx : Irrational x
p_nonzero : p ≠ 0
x_is_root : (aeval x) p = 0
rid : ¬1 < p.natDegree
⊢ False
tactic: by_contra rid
state_before: x : ℝ
p : ℤ[X]
hx : Irrational x
p_nonzero : p ≠ 0
x_is_root : (aeval x) p = 0
rid : ¬1 < p.natDegree
⊢ False
state_after: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
rid : ¬1 < (C a * X + C b).natDegree
⊢ False
tactic: rcases exists_eq_X_add_C_of_natDegree_le_one (not_lt.1 rid) with ⟨a, b, rfl⟩
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
rid : ¬1 < (C a * X + C b).natDegree
⊢ False
state_after: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
⊢ False
tactic: clear rid
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
⊢ False
state_after: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
this : ↑a * x = -↑b
⊢ False
tactic: have : (a : ℝ) * x = -b := by simpa [eq_neg_iff_add_eq_zero] using x_is_root
state_before: case intro.intro
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
this : ↑a * x = -↑b
⊢ False
state_after: case intro.intro.inl
x : ℝ
hx : Irrational x
b : ℤ
p_nonzero : C 0 * X + C b ≠ 0
x_is_root : (aeval x) (C 0 * X + C b) = 0
this : ↑0 * x = -↑b
⊢ False

case intro.intro.inr
x : ℝ
hx : Irrational x
a b : ℤ
p_nonzero : C a * X + C b ≠ 0
x_is_root : (aeval x) (C a * X + C b) = 0
this : ↑a * x = -↑b
ha : ¬a = 0
⊢ False
tactic: rcases em (a = 0) with (rfl | ha)
Theorem: CategoryTheory.Limits.BinaryFan.isLimit_iff_isIso_fst
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal Y
c : BinaryFan X Y
⊢ Nonempty (IsLimit c) ↔ IsIso c.fst
state_after: case mp
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal Y
c : BinaryFan X Y
⊢ Nonempty (IsLimit c) → IsIso c.fst

case mpr
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ X Y : C
h : IsTerminal Y
c : BinaryFan X Y
⊢ IsIso c.fst → Nonempty (IsLimit c)
tactic: constructor
Theorem: Hyperreal.IsSt.map
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
r : ℝ
hxr : x.IsSt r
f : ℝ → ℝ
hf : ContinuousAt f r
⊢ IsSt (Germ.map f x) (f r)
state_after: case intro
r : ℝ
f : ℝ → ℝ
hf : ContinuousAt f r
g : ℕ → ℝ
hxr : (ofSeq g).IsSt r
⊢ IsSt (Germ.map f (ofSeq g)) (f r)
tactic: rcases ofSeq_surjective x with ⟨g, rfl⟩
state_before: case intro
r : ℝ
f : ℝ → ℝ
hf : ContinuousAt f r
g : ℕ → ℝ
hxr : (ofSeq g).IsSt r
⊢ IsSt (Germ.map f (ofSeq g)) (f r)
state_after: no goals
tactic: exact isSt_ofSeq_iff_tendsto.2 <| hf.tendsto.comp (isSt_ofSeq_iff_tendsto.1 hxr)
Theorem: List.join_drop_length_sub_one
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List (List α)
h : L ≠ []
⊢ (drop (L.length - 1) L).join = L.getLast h
state_after: case nil
α : Type u_1
β : Type u_2
h : [] ≠ []
⊢ (drop ([].length - 1) []).join = [].getLast h

case append_singleton
α : Type u_1
β : Type u_2
l✝ : List (List α)
a✝¹ : List α
a✝ : ∀ (h : l✝ ≠ []), (drop (l✝.length - 1) l✝).join = l✝.getLast h
h : l✝ ++ [a✝¹] ≠ []
⊢ (drop ((l✝ ++ [a✝¹]).length - 1) (l✝ ++ [a✝¹])).join = (l✝ ++ [a✝¹]).getLast h
tactic: induction L using List.reverseRecOn
Theorem: Polynomial.isNilpotent_X_mul_iff
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

Proof steps:
state_before: R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
⊢ IsNilpotent (X * P) ↔ IsNilpotent P
state_after: case refine_1
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
h : IsNilpotent (X * P)
⊢ IsNilpotent P

case refine_2
R : Type u_1
r : R
inst✝ : Semiring R
P : R[X]
⊢ IsNilpotent P → IsNilpotent (X * P)
tactic: refine ⟨fun h ↦ ?_, ?_⟩
Theorem: descPochhammer_int_eq_ascFactorial
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
a b : ℕ
⊢ eval (↑a + ↑b) (descPochhammer ℤ b) = ↑((a + 1).ascFactorial b)
state_after: no goals
tactic: rw [← Nat.cast_add, descPochhammer_eval_eq_descFactorial ℤ (a + b) b,
    Nat.add_descFactorial_eq_ascFactorial]
Theorem: WittVector.truncateFun_pow
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
x : 𝕎 R
m : ℕ
⊢ truncateFun n (x ^ m) = truncateFun n x ^ m
state_after: no goals
tactic: witt_truncateFun_tac
Theorem: CategoryTheory.Idempotents.Karoubi.comp_proof
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q R : Karoubi C
g : Q.Hom R
f : P.Hom Q
⊢ f.f ≫ g.f = P.p ≫ (f.f ≫ g.f) ≫ R.p
state_after: no goals
tactic: rw [assoc, comp_p, ← assoc, p_comp]
Theorem: LinearMap.trace_mul_cycle'
File: Mathlib/LinearAlgebra/Trace.lean

Proof steps:
state_before: R : Type u
inst✝⁶ : CommSemiring R
M : Type v
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
ι : Type w
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
κ : Type u_1
inst✝¹ : DecidableEq κ
inst✝ : Fintype κ
b : Basis ι R M
c : Basis κ R M
f g h : M →ₗ[R] M
⊢ (trace R M) (f * (g * h)) = (trace R M) (h * (f * g))
state_after: no goals
tactic: rw [← mul_assoc, LinearMap.trace_mul_comm]
Theorem: CategoryTheory.Iso.map_hom_inv_id_eval
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{u_6, u_2} D
inst✝ : Category.{?u.8873, u_3} E
X Y : GradedObject J C
e : X ≅ Y
F : C ⥤ D
j : J
⊢ F.map (e.hom j) ≫ F.map (e.inv j) = 𝟙 (F.obj (X j))
state_after: no goals
tactic: rw [← F.map_comp, ← GradedObject.categoryOfGradedObjects_comp, e.hom_inv_id,
    GradedObject.categoryOfGradedObjects_id, Functor.map_id]
Theorem: Polynomial.degree_mul_X
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
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
⊢ (p * X).degree = p.degree + 1
state_after: no goals
tactic: simp [monic_X.degree_mul]
Theorem: Function.Antiperiodic.add_nat_mul_eq
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : Ring β
h : Antiperiodic f c
n : ℕ
⊢ f (x + ↑n * c) = (-1) ^ n * f x
state_after: no goals
tactic: simpa only [nsmul_eq_mul, zsmul_eq_mul, Int.cast_pow, Int.cast_neg,
    Int.cast_one] using h.add_nsmul_eq n
Theorem: Set.ncard_diff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
h : s ⊆ t
ht : autoParam t.Finite _auto✝
⊢ (t \ s).ncard = t.ncard - s.ncard
state_after: no goals
tactic: rw [← ncard_diff_add_ncard_of_subset h ht, add_tsub_cancel_right]
Theorem: tendsto_rpow_abs_mul_exp_neg_mul_sq_cocompact
File: Mathlib/Analysis/SpecialFunctions/Gaussian/PoissonSummation.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun x => |x| ^ s * rexp (-a * x ^ 2)) (cocompact ℝ) (𝓝 0)
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun x => |x| ^ s * rexp (-a * |x| ^ 2)) (cocompact ℝ) (𝓝 0)
tactic: conv in rexp _ => rw [← sq_abs]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun x => |x| ^ s * rexp (-a * |x| ^ 2)) (cocompact ℝ) (𝓝 0)
state_after: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun y => y ^ s * rexp (-a * y ^ 2)) atTop (𝓝 0)
tactic: erw [cocompact_eq_atBot_atTop, ← comap_abs_atTop,
    @tendsto_comap'_iff _ _ _ (fun y => y ^ s * rexp (-a * y ^ 2)) _ _ _
      (mem_atTop_sets.mpr ⟨0, fun b hb => ⟨b, abs_of_nonneg hb⟩⟩)]
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
a : ℝ
ha : 0 < a
s : ℝ
⊢ Tendsto (fun y => y ^ s * rexp (-a * y ^ 2)) atTop (𝓝 0)
state_after: no goals
tactic: exact
    (rpow_mul_exp_neg_mul_sq_isLittleO_exp_neg ha s).tendsto_zero_of_tendsto
      (tendsto_exp_atBot.comp <| tendsto_id.const_mul_atTop_of_neg (neg_lt_zero.mpr one_half_pos))
Theorem: CategoryTheory.Abelian.epi_of_mono_of_epi_of_mono
File: Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
R₁ R₂ : ComposableArrows C 2
φ : R₁ ⟶ R₂
hR₁ : R₁.Exact
hR₂ : R₂.Exact
hR₂' : Mono (R₂.map' 0 1 ⋯ ⋯)
h₀ : Epi (app' φ 1 ⋯)
h₁ : Mono (app' φ 2 ⋯)
⊢ R₂.map' 0 2 ⋯ ⋯ = 0
state_after: no goals
tactic: simpa only [map'_comp R₂ 0 1 2] using hR₂.toIsComplex.zero 0
Theorem: FirstOrder.Language.Hom.range_eq_top
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
S : L.Substructure M
f : M →[L] N
⊢ f.range = ⊤ ↔ Function.Surjective ⇑f
state_after: no goals
tactic: rw [SetLike.ext'_iff, range_coe, coe_top, Set.range_iff_surjective]
Theorem: IntermediateField.extendScalars_adjoin
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
K : IntermediateField F E
S : Set E
h : K ≤ adjoin F S
⊢ restrictScalars F (extendScalars h) = restrictScalars F (adjoin (↥K) S)
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
K : IntermediateField F E
S : Set E
h : K ≤ adjoin F S
⊢ adjoin F S = adjoin F (↑K ∪ S)
tactic: rw [extendScalars_restrictScalars, restrictScalars_adjoin]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
K : IntermediateField F E
S : Set E
h : K ≤ adjoin F S
⊢ adjoin F S = adjoin F (↑K ∪ S)
state_after: no goals
tactic: exact le_antisymm (adjoin.mono F S _ Set.subset_union_right) <| adjoin_le_iff.2 <|
    Set.union_subset h (subset_adjoin F S)
Theorem: Function.support_smul_subset_right
File: Mathlib/Algebra/Module/Basic.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
M : Type u_3
M₂ : Type u_4
inst✝¹ : Zero M
inst✝ : SMulZeroClass R M
f : α → R
g : α → M
x : α
hbf : x ∈ support (f • g)
hf : g x = 0
⊢ (f • g) x = 0
state_after: no goals
tactic: rw [Pi.smul_apply', hf, smul_zero]