ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: EMetric.NonemptyCompacts.isClosed_in_closeds
File: Mathlib/Topology/MetricSpace/Closeds.lean

Proof steps:
state_before: α : Type u
inst✝¹ : EMetricSpace α
s : Set α
inst✝ : CompleteSpace α
⊢ IsClosed (range NonemptyCompacts.toCloseds)
state_after: α : Type u
inst✝¹ : EMetricSpace α
s : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ IsClosed (range NonemptyCompacts.toCloseds)
tactic: have :
    range NonemptyCompacts.toCloseds =
      { s : Closeds α | (s : Set α).Nonempty ∧ IsCompact (s : Set α) } := by
    ext s
    refine ⟨?_, fun h => ⟨⟨⟨s, h.2⟩, h.1⟩, Closeds.ext rfl⟩⟩
    rintro ⟨s, hs, rfl⟩
    exact ⟨s.nonempty, s.isCompact⟩
state_before: α : Type u
inst✝¹ : EMetricSpace α
s : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ IsClosed (range NonemptyCompacts.toCloseds)
state_after: α : Type u
inst✝¹ : EMetricSpace α
s : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ IsClosed {s | (↑s).Nonempty ∧ IsCompact ↑s}
tactic: rw [this]
state_before: α : Type u
inst✝¹ : EMetricSpace α
s : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ IsClosed {s | (↑s).Nonempty ∧ IsCompact ↑s}
state_after: case refine_1
α : Type u
inst✝¹ : EMetricSpace α
s✝ : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
s : Closeds α
hs : s ∈ closure {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ (↑s).Nonempty

case refine_2
α : Type u
inst✝¹ : EMetricSpace α
s✝ : Set α
inst✝ : CompleteSpace α
this : range NonemptyCompacts.toCloseds = {s | (↑s).Nonempty ∧ IsCompact ↑s}
s : Closeds α
hs : s ∈ closure {s | (↑s).Nonempty ∧ IsCompact ↑s}
⊢ IsCompact ↑s
tactic: refine isClosed_of_closure_subset fun s hs => ⟨?_, ?_⟩
Theorem: Ideal.map_le_comap_of_inv_on
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
⊢ map f I ≤ comap g I
state_after: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
⊢ ⇑f '' ↑I ⊆ ↑(comap g I)
tactic: refine Ideal.span_le.2 ?_
state_before: R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
⊢ ⇑f '' ↑I ⊆ ↑(comap g I)
state_after: case intro.intro
R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
x : R
hx : x ∈ ↑I
⊢ f x ∈ ↑(comap g I)
tactic: rintro x ⟨x, hx, rfl⟩
state_before: case intro.intro
R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
x : R
hx : x ∈ ↑I
⊢ f x ∈ ↑(comap g I)
state_after: case intro.intro
R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
x : R
hx : x ∈ ↑I
⊢ x ∈ I
tactic: rw [SetLike.mem_coe, mem_comap, hf hx]
state_before: case intro.intro
R : Type u
S : Type v
F : Type u_1
inst✝³ : Semiring R
inst✝² : Semiring S
inst✝¹ : FunLike F R S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_2
inst✝ : FunLike G S R
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ⇑g ⇑f ↑I
x : R
hx : x ∈ ↑I
⊢ x ∈ I
state_after: no goals
tactic: exact hx
Theorem: Subsemigroup.prod_eq_top_iff
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝⁴ : Mul M
inst✝³ : Mul N
inst✝² : Mul P
S : Subsemigroup M
inst✝¹ : Nonempty M
inst✝ : Nonempty N
s : Subsemigroup M
t : Subsemigroup N
⊢ s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤
state_after: no goals
tactic: simp only [eq_top_iff, le_prod_iff, ← (gc_map_comap _).le_iff_le, ← srange_eq_map, srange_fst,
    srange_snd]
Theorem: Nat.lt_mul_div_succ
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a < b * (a / b + 1)
state_after: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a / b < a / b + 1
tactic: rw [Nat.mul_comm, ← Nat.div_lt_iff_lt_mul' hb]
state_before: a✝ b c d m n k : ℕ
p q : ℕ → Prop
a : ℕ
hb : 0 < b
⊢ a / b < a / b + 1
state_after: no goals
tactic: exact lt_succ_self _
Theorem: Fin.range_castSucc
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
⊢ n ≤ n + 1
state_after: no goals
tactic: omega
Theorem: image_toPullbackDiag
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: X : Type u_1
Y : Sort u_2
Z : ?m.78418
f : X → Y
s : Set X
⊢ toPullbackDiag f '' s = pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s
state_after: case h
X : Type u_1
Y : Sort u_2
Z : ?m.78418
f : X → Y
s : Set X
x : Pullback f f
⊢ x ∈ toPullbackDiag f '' s ↔ x ∈ pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s
tactic: ext x
state_before: case h
X : Type u_1
Y : Sort u_2
Z : ?m.78418
f : X → Y
s : Set X
x : Pullback f f
⊢ x ∈ toPullbackDiag f '' s ↔ x ∈ pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s
state_after: case h.mp
X : Type u_1
Y : Sort u_2
Z : ?m.78418
f : X → Y
s : Set X
x : Pullback f f
⊢ x ∈ toPullbackDiag f '' s → x ∈ pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s

case h.mpr
X : Type u_1
Y : Sort u_2
Z : ?m.78418
f : X → Y
s : Set X
x : Pullback f f
⊢ x ∈ pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s → x ∈ toPullbackDiag f '' s
tactic: constructor
Theorem: CharP.CharOne.subsingleton
File: Mathlib/Algebra/CharP/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : CharP R 1
this : ∀ (r : R), r = 0
a b : R
⊢ a = b
state_after: no goals
tactic: rw [this a, this b]
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : CharP R 1
r : R
⊢ r = 1 * r
state_after: no goals
tactic: rw [one_mul]
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : CharP R 1
r : R
⊢ 1 * r = ↑1 * r
state_after: no goals
tactic: rw [Nat.cast_one]
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : CharP R 1
r : R
⊢ ↑1 * r = 0 * r
state_after: no goals
tactic: rw [CharP.cast_eq_zero]
state_before: R : Type u_1
inst✝¹ : NonAssocSemiring R
inst✝ : CharP R 1
r : R
⊢ 0 * r = 0
state_after: no goals
tactic: rw [zero_mul]
Theorem: CochainComplex.shiftFunctorZero_eq
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
⊢ shiftFunctorZero (CochainComplex C ℤ) ℤ = shiftFunctorZero' C 0 ⋯
state_after: case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ ((shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app x✝).f i✝ = ((shiftFunctorZero' C 0 ⋯).hom.app x✝).f i✝
tactic: ext
state_before: case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ ((shiftFunctorZero (CochainComplex C ℤ) ℤ).hom.app x✝).f i✝ = ((shiftFunctorZero' C 0 ⋯).hom.app x✝).f i✝
state_after: no goals
tactic: rw [shiftFunctorZero_hom_app_f, shiftFunctorZero'_hom_app_f]
Theorem: AlgebraicGeometry.PresheafedSpace.ofRestrict_c_app
File: Mathlib/Geometry/RingedSpace/PresheafedSpace.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.60184, u_1} C
U✝ : TopCat
X : PresheafedSpace C
f✝ : U✝ ⟶ ↑X
h : OpenEmbedding ⇑f✝
U V : (Opens ↑↑X)ᵒᵖ
f : U ⟶ V
⊢ X.presheaf.map f ≫ (fun V => X.presheaf.map (⋯.adjunction.counit.app (unop V)).op) V =
    (fun V => X.presheaf.map (⋯.adjunction.counit.app (unop V)).op) U ≫
      X.presheaf.map (⋯.functor.op.map ((Opens.map f✝).op.map f))
state_after: C : Type u_1
inst✝ : Category.{?u.60184, u_1} C
U✝ : TopCat
X : PresheafedSpace C
f✝ : U✝ ⟶ ↑X
h : OpenEmbedding ⇑f✝
U V : (Opens ↑↑X)ᵒᵖ
f : U ⟶ V
⊢ X.presheaf.map (f ≫ (⋯.adjunction.counit.app (unop V)).op) =
    X.presheaf.map ((⋯.adjunction.counit.app (unop U)).op ≫ ⋯.functor.op.map ((Opens.map f✝).op.map f))
tactic: rw [← map_comp, ← map_comp]
state_before: C : Type u_1
inst✝ : Category.{?u.60184, u_1} C
U✝ : TopCat
X : PresheafedSpace C
f✝ : U✝ ⟶ ↑X
h : OpenEmbedding ⇑f✝
U V : (Opens ↑↑X)ᵒᵖ
f : U ⟶ V
⊢ X.presheaf.map (f ≫ (⋯.adjunction.counit.app (unop V)).op) =
    X.presheaf.map ((⋯.adjunction.counit.app (unop U)).op ≫ ⋯.functor.op.map ((Opens.map f✝).op.map f))
state_after: no goals
tactic: rfl
Theorem: List.head!_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
t s : List α
h : s ≠ []
⊢ (s ++ t).head! = s.head!
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
t : List α
h : [] ≠ []
⊢ ([] ++ t).head! = [].head!

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : Inhabited α
t : List α
head✝ : α
tail✝ : List α
tail_ih✝ : tail✝ ≠ [] → (tail✝ ++ t).head! = tail✝.head!
h : head✝ :: tail✝ ≠ []
⊢ (head✝ :: tail✝ ++ t).head! = (head✝ :: tail✝).head!
tactic: induction s
Theorem: Finset.powerset_univ
File: Mathlib/Data/Fintype/Powerset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Fintype α
s : Finset α
k : ℕ
⊢ ↑univ.powerset = ↑univ
state_after: no goals
tactic: simp [-coe_eq_univ]
Theorem: NormedRing.inverse_one_sub_nth_order
File: Mathlib/Analysis/Normed/Ring/Units.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
n : ℕ
t : R
ht : dist t 0 < 1
⊢ ‖t‖ < 1
state_after: no goals
tactic: rwa [← dist_zero_right]
Theorem: Commute.pow_dvd_add_pow_of_pow_eq_zero_right
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

Proof steps:
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
⊢ x ^ m ∣ (x + y) ^ p
state_after: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
⊢ x ^ m ∣ ∑ m ∈ Finset.antidiagonal p, p.choose m.1 • (x ^ m.1 * y ^ m.2)
tactic: rw [h_comm.add_pow']
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
⊢ x ^ m ∣ ∑ m ∈ Finset.antidiagonal p, p.choose m.1 • (x ^ m.1 * y ^ m.2)
state_after: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : (i, j) ∈ Finset.antidiagonal p
⊢ x ^ m ∣ p.choose (i, j).1 • (x ^ (i, j).1 * y ^ (i, j).2)
tactic: refine Finset.dvd_sum fun ⟨i, j⟩ hij ↦ ?_
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : (i, j) ∈ Finset.antidiagonal p
⊢ x ^ m ∣ p.choose (i, j).1 • (x ^ (i, j).1 * y ^ (i, j).2)
state_after: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
⊢ x ^ m ∣ p.choose (i, j).1 • (x ^ (i, j).1 * y ^ (i, j).2)
tactic: replace hij : i + j = p := by simpa using hij
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
⊢ x ^ m ∣ p.choose (i, j).1 • (x ^ (i, j).1 * y ^ (i, j).2)
state_after: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
⊢ x ^ m ∣ x ^ (i, j).1 * y ^ (i, j).2
tactic: apply dvd_nsmul_of_dvd
state_before: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
⊢ x ^ m ∣ x ^ (i, j).1 * y ^ (i, j).2
state_after: case h.inl
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
hi : m ≤ i
⊢ x ^ m ∣ x ^ (i, j).1 * y ^ (i, j).2

case h.inr
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Semiring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hy : y ^ n = 0
x✝ : ℕ × ℕ
i j : ℕ
hij : i + j = p
hi : i + 1 ≤ m
⊢ x ^ m ∣ x ^ (i, j).1 * y ^ (i, j).2
tactic: rcases le_or_lt m i with (hi : m ≤ i) | (hi : i + 1 ≤ m)
Theorem: CategoryTheory.Functor.shiftIso_add'_inv_app
File: Mathlib/CategoryTheory/Shift/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{?u.63403, u_1} C
inst✝⁵ : Category.{?u.63407, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
n m mn : M
hnm : m + n = mn
a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ mn + a = a''
state_after: no goals
tactic: rw [← hnm, ← ha'', ← ha', add_assoc]
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{u_6, u_1} C
inst✝⁵ : Category.{u_5, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
n m mn : M
hnm : m + n = mn
a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ (F.shiftIso mn a a'' ⋯).inv.app X =
    (F.shiftIso m a' a'' ha'').inv.app X ≫
      (F.shiftIso n a a' ha').inv.app ((shiftFunctor C m).obj X) ≫
        (F.shift a).map ((shiftFunctorAdd' C m n mn hnm).inv.app X)
state_after: no goals
tactic: simp [F.shiftIso_add' n m mn hnm a a' a'' ha' ha'']
Theorem: PrimeSpectrum.closure_singleton
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x : PrimeSpectrum R
⊢ closure {x} = zeroLocus ↑x.asIdeal
state_after: no goals
tactic: rw [← zeroLocus_vanishingIdeal_eq_closure, vanishingIdeal_singleton]
Theorem: CategoryTheory.Limits.kernelSubobjectIso_comp_kernel_map
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
sq : Arrow.mk f ⟶ Arrow.mk f'
⊢ (kernelSubobjectIso f).hom ≫ kernel.map f f' sq.left sq.right ⋯ = kernelSubobjectMap sq ≫ (kernelSubobjectIso f').hom
state_after: no goals
tactic: simp [← Iso.comp_inv_eq, kernel_map_comp_kernelSubobjectIso_inv]
Theorem: SimplexCategory.epi_iff_surjective
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi f ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalEquivalence.functor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
tactic: rw [← Functor.epi_map_iff_epi skeletalEquivalence.functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalEquivalence.functor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalFunctor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
tactic: dsimp only [skeletalEquivalence, Functor.asEquivalence_functor]
state_before: n m : SimplexCategory
f : n ⟶ m
⊢ Epi (skeletalFunctor.map f) ↔ Function.Surjective ⇑(Hom.toOrderHom f)
state_after: no goals
tactic: simp only [skeletalFunctor_obj, skeletalFunctor_map,
    NonemptyFinLinOrd.epi_iff_surjective, NonemptyFinLinOrd.coe_of]
Theorem: CochainComplex.mappingCone.lift_snd
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.221973, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
α : Cocycle K F 1
β : Cochain K G 0
eq : δ 0 1 β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
⊢ (Cochain.ofHom (lift φ α β eq)).comp (snd φ) ⋯ = β
state_after: no goals
tactic: simp
Theorem: Bool.apply_apply_apply
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: f : Bool → Bool
x : Bool
⊢ f (f (f x)) = f x
state_after: no goals
tactic: cases x <;> cases h₁ : f true <;> cases h₂ : f false <;> simp only [h₁, h₂]
Theorem: tsum_eq_tsum_of_ne_zero_bij
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a a₁ a₂ : α
g : γ → α
i : ↑(mulSupport g) → β
hi : Injective i
hf : mulSupport f ⊆ Set.range i
hfg : ∀ (x : ↑(mulSupport g)), f (i x) = g ↑x
⊢ ∏' (x : β), f x = ∏' (y : γ), g y
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a a₁ a₂ : α
g : γ → α
i : ↑(mulSupport g) → β
hi : Injective i
hf : mulSupport f ⊆ Set.range i
hfg : ∀ (x : ↑(mulSupport g)), f (i x) = g ↑x
⊢ ∏' (c : ↑(mulSupport g)), f (i c) = ∏' (x : ↑(mulSupport g)), g ↑x
tactic: rw [← tprod_subtype_mulSupport g, ← hi.tprod_eq hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g✝ : β → α
a a₁ a₂ : α
g : γ → α
i : ↑(mulSupport g) → β
hi : Injective i
hf : mulSupport f ⊆ Set.range i
hfg : ∀ (x : ↑(mulSupport g)), f (i x) = g ↑x
⊢ ∏' (c : ↑(mulSupport g)), f (i c) = ∏' (x : ↑(mulSupport g)), g ↑x
state_after: no goals
tactic: simp only [hfg]
Theorem: List.mapIdx_cons
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
l : List α
f : ℕ → α → β
a : α
⊢ mapIdx f (a :: l) = f 0 a :: mapIdx (fun i => f (i + 1)) l
state_after: no goals
tactic: simp [mapIdx_eq_enum_map, enum_eq_zip_range, map_uncurry_zip_eq_zipWith,
    range_succ_eq_map, zipWith_map_left]
Theorem: Submodule.apply_mem_span_image_iff_mem_span
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
x✝ : M
p p' : Submodule R M
inst✝⁵ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R₂ M₂
F : Type u_8
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝ : RingHomSurjective σ₁₂
f : F
x : M
s : Set M
hf : Injective ⇑f
⊢ f x ∈ span R₂ (⇑f '' s) ↔ x ∈ span R s
state_after: no goals
tactic: rw [← Submodule.mem_comap, ← Submodule.map_span, Submodule.comap_map_eq_of_injective hf]
Theorem: CategoryTheory.Limits.Bicone.whisker_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (fun k => c.ι (g k)) k ≫ (fun k => c.π (g k)) k' = if h : k = k' then eqToHom ⋯ else 0
state_after: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (if h : g k = g k' then eqToHom ⋯ else 0) = if h : k = k' then eqToHom ⋯ else 0
tactic: simp only [c.ι_π]
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (if h : g k = g k' then eqToHom ⋯ else 0) = if h : k = k' then eqToHom ⋯ else 0
state_after: no goals
tactic: split_ifs with h h' h' <;> simp [Equiv.apply_eq_iff_eq g] at h h' <;> tauto
Theorem: Nat.div_ne_zero_iff_of_dvd
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : b ∣ a
⊢ a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0
state_after: no goals
tactic: obtain rfl | hb := eq_or_ne b 0 <;> simp [Nat.div_ne_zero_iff, Nat.le_iff_ne_zero_of_dvd, *]
Theorem: Polynomial.rootMultiplicity_mul'
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
hpq : eval x (p /ₘ (X - C x) ^ rootMultiplicity x p) * eval x (q /ₘ (X - C x) ^ rootMultiplicity x q) ≠ 0
⊢ rootMultiplicity x (p * q) = rootMultiplicity x p + rootMultiplicity x q
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
hpq : (p.comp (X + C x)).trailingCoeff * (q.comp (X + C x)).trailingCoeff ≠ 0
⊢ rootMultiplicity x (p * q) = rootMultiplicity x p + rootMultiplicity x q
tactic: simp_rw [eval_divByMonic_eq_trailingCoeff_comp] at hpq
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
hpq : (p.comp (X + C x)).trailingCoeff * (q.comp (X + C x)).trailingCoeff ≠ 0
⊢ rootMultiplicity x (p * q) = rootMultiplicity x p + rootMultiplicity x q
state_after: no goals
tactic: simp_rw [rootMultiplicity_eq_natTrailingDegree, mul_comp, natTrailingDegree_mul' hpq]
Theorem: Real.cos_pi_div_thirty_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ cos (π / 32) = √(2 + √(2 + √(2 + √2))) / 2
state_after: x : ℝ
⊢ cos (π / 32) = cos (π / 2 ^ 5)

x : ℝ
⊢ cos (π / 2 ^ 5) = √(2 + √(2 + √(2 + √2))) / 2
tactic: trans cos (π / 2 ^ 5)
Theorem: FormalMultilinearSeries.leftInv_eq_rightInv
File: Mathlib/Analysis/Analytic/Inverse.lean

Proof steps:
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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.leftInv i = p.removeZero.leftInv i
state_after: no goals
tactic: rw [leftInv_removeZero]
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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.removeZero.leftInv i = p.removeZero.rightInv i
state_after: case h
𝕜 : 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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
tactic: apply leftInv_eq_rightInv_aux <;> simp
state_before: case h
𝕜 : 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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
state_after: no goals
tactic: exact 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
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
h : p 1 = (continuousMultilinearCurryFin1 𝕜 E F).symm ↑i
⊢ p.removeZero.rightInv i = p.rightInv i
state_after: no goals
tactic: rw [rightInv_removeZero]