ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IntermediateField.isAlgebraic_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
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
S : Set L
hS : ∀ x ∈ S, IsIntegral K x
⊢ Algebra.IsAlgebraic K ↥(adjoin K S)
state_after: F : Type u_1
inst✝⁶ : Field F
E : Type u_2
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
S : Set L
hS : ∀ x ∈ S, IsIntegral K x
⊢ Algebra.IsAlgebraic K ↥(⨆ i, K⟮↑i⟯)
tactic: rw [← biSup_adjoin_simple, ← iSup_subtype'']
state_before: F : Type u_1
inst✝⁶ : Field F
E : Type u_2
inst✝⁵ : Field E
inst✝⁴ : Algebra F E
α : E
K : Type u
inst✝³ : Field K
inst✝² : Algebra F K
L : Type u_3
inst✝¹ : Field L
inst✝ : Algebra K L
S : Set L
hS : ∀ x ∈ S, IsIntegral K x
⊢ Algebra.IsAlgebraic K ↥(⨆ i, K⟮↑i⟯)
state_after: no goals
tactic: exact isAlgebraic_iSup fun x ↦ isAlgebraic_adjoin_simple (hS x x.2)
Theorem: AddMonoidAlgebra.opRingEquiv_symm_single
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCommMonoid G
r : kᵐᵒᵖ
x : Gᵐᵒᵖ
⊢ AddMonoidAlgebra.opRingEquiv.symm (single x r) = op (single x (unop r))
state_after: no goals
tactic: simp
Theorem: add_neg_lt_iff_lt_add
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a * b⁻¹ < c ↔ a < c * b
state_after: no goals
tactic: rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
Theorem: AddSubmonoid.fromCommLeftNeg_apply
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

Proof steps:
state_before: M : Type u_1
inst✝ : CommMonoid M
S : Submonoid M
x y : ↥S.leftInv
⊢ ↑({ toFun := S.fromLeftInv, map_one' := ⋯ }.toFun (x * y)) =
    ↑({ toFun := S.fromLeftInv, map_one' := ⋯ }.toFun x * { toFun := S.fromLeftInv, map_one' := ⋯ }.toFun y)
state_after: no goals
tactic: rw [fromLeftInv_eq_iff, mul_comm x, Submonoid.coe_mul, Submonoid.coe_mul, mul_assoc, ←
        mul_assoc (x : M), mul_fromLeftInv, one_mul, mul_fromLeftInv]
Theorem: Ordinal.mk_initialSeg
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
⊢ #↑{o' | o' < o} = Cardinal.lift.{u + 1, u} o.card
state_after: no goals
tactic: rw [lift_card, ← type_subrel_lt, card_type]
Theorem: CompleteLatticeHom.cancel_left
File: Mathlib/Order/Hom/CompleteLattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ι : Sort u_6
κ : ι → Sort u_7
inst✝⁴ : FunLike F α β
inst✝³ : CompleteLattice α
inst✝² : CompleteLattice β
inst✝¹ : CompleteLattice γ
inst✝ : CompleteLattice δ
g : CompleteLatticeHom β γ
f₁ f₂ : CompleteLatticeHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
tactic: rw [← comp_apply, h, comp_apply]
Theorem: LocallyConstant.exists_eq_const
File: Mathlib/Topology/LocallyConstant/Basic.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
⊢ ∃ y, f = const X y
state_after: case inl.intro
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
x : X
⊢ ∃ y, f = const X y

case inr
X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
hX : ¬Nonempty X
⊢ ∃ y, f = const X y
tactic: rcases Classical.em (Nonempty X) with (⟨⟨x⟩⟩ | hX)
Theorem: Fin.comp_tail
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
β : Type u_2
g : α → β
q : Fin n.succ → α
⊢ g ∘ tail q = tail (g ∘ q)
state_after: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
β : Type u_2
g : α → β
q : Fin n.succ → α
j : Fin n
⊢ (g ∘ tail q) j = tail (g ∘ q) j
tactic: ext j
state_before: case h
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q✝ : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
β : Type u_2
g : α → β
q : Fin n.succ → α
j : Fin n
⊢ (g ∘ tail q) j = tail (g ∘ q) j
state_after: no goals
tactic: simp [tail]
Theorem: hasLineDerivAt_iff_isLittleO_nhds_zero
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f f₁ : E → F
f' f₀' f₁' : F
s t : Set E
x v : E
⊢ HasLineDerivAt 𝕜 f f' x v ↔ (fun t => f (x + t • v) - f x - t • f') =o[𝓝 0] fun t => t
state_after: no goals
tactic: simp only [HasLineDerivAt, hasDerivAt_iff_isLittleO_nhds_zero, zero_add, zero_smul, add_zero]
Theorem: Polynomial.isNilpotent_reflect_iff
File: Mathlib/RingTheory/Polynomial/Nilpotent.lean

Proof steps:
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ IsNilpotent (reflect N P) ↔ IsNilpotent P
state_after: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ (∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)) ↔ ∀ (i : ℕ), IsNilpotent (P.coeff i)
tactic: simp only [Polynomial.isNilpotent_iff, coeff_reverse]
state_before: R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
⊢ (∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)) ↔ ∀ (i : ℕ), IsNilpotent (P.coeff i)
state_after: case refine_1.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent (P.coeff i)

case refine_1.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent ((reflect N P).coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent (P.coeff i)

case refine_2.inl
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : i ≤ N
⊢ IsNilpotent ((reflect N P).coeff i)

case refine_2.inr
R : Type u_1
r : R
inst✝ : CommRing R
P✝ P : R[X]
N : ℕ
hN : P.natDegree ≤ N
h : ∀ (i : ℕ), IsNilpotent (P.coeff i)
i : ℕ
hi : N < i
⊢ IsNilpotent ((reflect N P).coeff i)
tactic: refine ⟨fun h i ↦ ?_, fun h i ↦ ?_⟩ <;> rcases le_or_lt i N with hi | hi
Theorem: SemiconjBy.sub_right
File: Mathlib/Algebra/Ring/Semiconj.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing R
a b x y x' y' : R
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x - x') (y - y')
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using h.add_right h'.neg_right
Theorem: MvPolynomial.bind₂_comp_bind₂
File: Mathlib/Algebra/MvPolynomial/Monad.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
T : Type u_5
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
g : S →+* MvPolynomial σ T
⊢ (bind₂ g).comp (bind₂ f) = bind₂ ((bind₂ g).comp f)
state_after: no goals
tactic: ext : 2 <;> simp
Theorem: EllipticCurve.variableChange_a₂
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
E : EllipticCurve R
C : WeierstrassCurve.VariableChange R
⊢ ↑(C.u⁻¹ ^ 12 * E.Δ') = (E.variableChange C).Δ
state_after: no goals
tactic: rw [Units.val_mul, Units.val_pow_eq_pow_val, coe_Δ', E.variableChange_Δ]
Theorem: IsExposed.inter_left
File: Mathlib/Analysis/Convex/Exposed.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 A C
hCB : C ⊆ B
⊢ IsExposed 𝕜 (A ∩ B) C
state_after: case intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 A C
hCB : C ⊆ B
w : E
hw : w ∈ C
⊢ ∃ l, C = {x | x ∈ A ∩ B ∧ ∀ y ∈ A ∩ B, l y ≤ l x}
tactic: rintro ⟨w, hw⟩
state_before: case intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l : E →L[𝕜] 𝕜
A B C : Set E
X : Finset E
x : E
hC : IsExposed 𝕜 A C
hCB : C ⊆ B
w : E
hw : w ∈ C
⊢ ∃ l, C = {x | x ∈ A ∩ B ∧ ∀ y ∈ A ∩ B, l y ≤ l x}
state_after: case intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A B : Set E
X : Finset E
x w : E
l : E →L[𝕜] 𝕜
hC : IsExposed 𝕜 A {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x}
hCB : {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x} ⊆ B
hw : w ∈ {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x}
⊢ ∃ l_1, {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x} = {x | x ∈ A ∩ B ∧ ∀ y ∈ A ∩ B, l_1 y ≤ l_1 x}
tactic: obtain ⟨l, rfl⟩ := hC ⟨w, hw⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : OrderedRing 𝕜
inst✝² : AddCommMonoid E
inst✝¹ : TopologicalSpace E
inst✝ : Module 𝕜 E
l✝ : E →L[𝕜] 𝕜
A B : Set E
X : Finset E
x w : E
l : E →L[𝕜] 𝕜
hC : IsExposed 𝕜 A {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x}
hCB : {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x} ⊆ B
hw : w ∈ {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x}
⊢ ∃ l_1, {x | x ∈ A ∧ ∀ y ∈ A, l y ≤ l x} = {x | x ∈ A ∩ B ∧ ∀ y ∈ A ∩ B, l_1 y ≤ l_1 x}
state_after: no goals
tactic: exact ⟨l, Subset.antisymm (fun x hx => ⟨⟨hx.1, hCB hx⟩, fun y hy => hx.2 y hy.1⟩)
    fun x ⟨⟨hxC, _⟩, hx⟩ => ⟨hxC, fun y hy => (hw.2 y hy).trans (hx w ⟨hC.subset hw, hCB hw⟩)⟩⟩
Theorem: mul_self_zpow
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✝ : Group G
a✝ b c d : G
n✝ : ℤ
a : G
n : ℤ
⊢ a * a ^ n = a ^ (n + 1)
state_after: no goals
tactic: rw [Int.add_comm, zpow_add, zpow_one]
Theorem: ENNReal.summable_toNNReal_of_tsum_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f✝ g : α✝ → ℝ≥0∞
α : Type u_4
f : α → ℝ≥0∞
hf : ∑' (i : α), f i ≠ ⊤
⊢ Summable (ENNReal.toNNReal ∘ f)
state_after: no goals
tactic: simpa only [← tsum_coe_ne_top_iff_summable, toNNReal_apply_of_tsum_ne_top hf] using hf
Theorem: IntermediateField.sepDegree_bot
File: Mathlib/FieldTheory/SeparableClosure.lean

Proof steps:
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: 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
this : Cardinal.lift.{u, v} (sepDegree F ↥⊥) = Cardinal.lift.{v, u} (sepDegree F F)
⊢ sepDegree F ↥⊥ = 1
state_after: no goals
tactic: rwa [sepDegree_self, Cardinal.lift_one, ← Cardinal.lift_one.{v, u}, Cardinal.lift_inj] at this
Theorem: LieModule.chainTop_isNonZero'
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
hα' : weightSpace M α ≠ ⊥
⊢ (chainTop α β).IsNonZero
state_after: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
hα' : weightSpace M α ≠ ⊥
e : (chainTop α β).IsZero
⊢ False
tactic: by_contra e
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
hα' : weightSpace M α ≠ ⊥
e : (chainTop α β).IsZero
⊢ False
state_after: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
hα' : weightSpace M α ≠ ⊥
e : (chainTop α β).IsZero
⊢ weightSpace M α = ⊥
tactic: apply hα'
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
hα' : weightSpace M α ≠ ⊥
e : (chainTop α β).IsZero
⊢ weightSpace M α = ⊥
state_after: no goals
tactic: rw [← add_zero (α : L → R), ← e, weightSpace_add_chainTop _ _ hα]
Theorem: CategoryTheory.Limits.isLimitConeUnopOfCocone_lift
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.unop
j : J
⊢ ((fun s => (hc.desc (coconeOfConeUnop s)).unop) s ≫ (coneUnopOfCocone c).π.app j).op = (s.π.app j).op
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.unop
m : s.pt ⟶ (coneUnopOfCocone c).pt
w : ∀ (j : J), m ≫ (coneUnopOfCocone c).π.app j = s.π.app j
⊢ m = (fun s => (hc.desc (coconeOfConeUnop s)).unop) s
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.unop
m : s.pt ⟶ (coneUnopOfCocone c).pt
w : ∀ (j : J), m ≫ (coneUnopOfCocone c).π.app j = s.π.app j
j : Jᵒᵖ
⊢ (c.ι.app j ≫ m.op).unop = (c.ι.app j ≫ ((fun s => (hc.desc (coconeOfConeUnop s)).unop) s).op).unop
tactic: refine Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ Cᵒᵖ
c : Cocone F
hc : IsColimit c
s : Cone F.unop
m : s.pt ⟶ (coneUnopOfCocone c).pt
w : ∀ (j : J), m ≫ (coneUnopOfCocone c).π.app j = s.π.app j
j : Jᵒᵖ
⊢ (c.ι.app j ≫ m.op).unop = (c.ι.app j ≫ ((fun s => (hc.desc (coconeOfConeUnop s)).unop) s).op).unop
state_after: no goals
tactic: simpa only [Quiver.Hom.op_unop, IsColimit.fac] using w (unop j)
Theorem: AlgebraicGeometry.LocallyRingedSpace.stalkMap_hom_inv
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean

Proof steps:
state_before: X✝ X Y Z : LocallyRingedSpace
f : X ⟶ Y
g : Y ⟶ Z
e : X ≅ Y
y : ↑Y.toTopCat
⊢ y = e.hom.val.base (e.inv.val.base y)
state_after: no goals
tactic: simp
state_before: X✝ X Y Z : LocallyRingedSpace
f : X ⟶ Y
g : Y ⟶ Z
e : X ≅ Y
y : ↑Y.toTopCat
⊢ Hom.stalkMap e.hom (e.inv.val.base y) ≫ Hom.stalkMap e.inv y = Y.presheaf.stalkSpecializes ⋯
state_after: X✝ X Y Z : LocallyRingedSpace
f : X ⟶ Y
g : Y ⟶ Z
e : X ≅ Y
y : ↑Y.toTopCat
⊢ Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap (𝟙 Y) y = Y.presheaf.stalkSpecializes ⋯
tactic: rw [← stalkMap_comp, LocallyRingedSpace.stalkMap_congr_hom (e.inv ≫ e.hom) (𝟙 _) (by simp)]
state_before: X✝ X Y Z : LocallyRingedSpace
f : X ⟶ Y
g : Y ⟶ Z
e : X ≅ Y
y : ↑Y.toTopCat
⊢ Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap (𝟙 Y) y = Y.presheaf.stalkSpecializes ⋯
state_after: no goals
tactic: simp
Theorem: ExteriorAlgebra.liftAlternating_ι_mul
File: Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
x : ExteriorAlgebra R M
⊢ (liftAlternating f) ((ι R) m * x) = (liftAlternating fun i => (f i.succ).curryLeft m) x
state_after: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
x : ExteriorAlgebra R M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) f) ((ι R) m * x) 0) 0 =
    (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) fun i => (f (i + 1)).curryLeft m) x
        0)
      0
tactic: dsimp [liftAlternating]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
x : ExteriorAlgebra R M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) f) ((ι R) m * x) 0) 0 =
    (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) fun i => (f (i + 1)).curryLeft m) x
        0)
      0
state_after: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
x : ExteriorAlgebra R M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯)
          (((LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) m) f))
        x 0)
      0 =
    (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) fun i => (f (i + 1)).curryLeft m) x
        0)
      0
tactic: rw [foldl_mul, foldl_ι]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
x : ExteriorAlgebra R M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯)
          (((LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) m) f))
        x 0)
      0 =
    (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) fun i => (f (i + 1)).curryLeft m) x
        0)
      0
state_after: no goals
tactic: rfl
Theorem: PartENat.coe_add_get
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x : ℕ
y : PartENat
h : (↑x + y).Dom
⊢ (↑x + y).get h = x + y.get ⋯
state_after: no goals
tactic: rfl
Theorem: Rat.toNNRat_add
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q : ℚ
hq : 0 ≤ q
hp : 0 ≤ p
⊢ ↑(q + p).toNNRat = ↑(q.toNNRat + p.toNNRat)
state_after: no goals
tactic: simp [toNNRat, hq, hp, add_nonneg]
Theorem: LinearMapClass.ker_eq_bot
File: Mathlib/Algebra/Module/Submodule/Ker.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹¹ : Ring R
inst✝¹⁰ : Ring R₂
inst✝⁹ : Ring R₃
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : F
⊢ ker f = ⊥ ↔ Injective ⇑f
state_after: no goals
tactic: simpa [disjoint_iff_inf_le] using disjoint_ker' (f := f) (p := ⊤)
Theorem: Tree.numLeaves_pos
File: Mathlib/Data/Tree/Basic.lean

Proof steps:
state_before: α : Type u
x : Tree α
⊢ 0 < x.numLeaves
state_after: α : Type u
x : Tree α
⊢ 0 < x.numNodes + 1
tactic: rw [numLeaves_eq_numNodes_succ]
state_before: α : Type u
x : Tree α
⊢ 0 < x.numNodes + 1
state_after: no goals
tactic: exact x.numNodes.zero_lt_succ
Theorem: HasLineDerivWithinAt.hasLineDerivAt
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : HasLineDerivWithinAt 𝕜 f f' s x v
hs : s ∈ 𝓝 x
⊢ Continuous fun t => x + t • v
state_after: no goals
tactic: fun_prop
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : HasLineDerivWithinAt 𝕜 f f' s x v
hs : s ∈ 𝓝 x
⊢ x + 0 • v = x
state_after: no goals
tactic: simp
Theorem: QuotientGroup.preimage_image_mk_eq_iUnion_image
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
⊢ ∀ (x : ↥N), (fun x_1 => x_1 * ↑x⁻¹) '' s = (fun x_1 => x_1 * ↑x) ⁻¹' s
state_after: no goals
tactic: exact fun x ↦ image_mul_right'
Theorem: Filter.rtendsto'_def
File: Mathlib/Order/Filter/Partial.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ RTendsto' r l₁ l₂ ↔ ∀ s ∈ l₂, r.preimage s ∈ l₁
state_after: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ l₁ ≤
      { sets := Rel.image (fun s t => r.preimage s ⊆ t) l₂.sets, univ_sets := ⋯, sets_of_superset := ⋯,
        inter_sets := ⋯ } ↔
    ∀ s ∈ l₂, r.preimage s ∈ l₁
tactic: unfold RTendsto' rcomap'
state_before: α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ l₁ ≤
      { sets := Rel.image (fun s t => r.preimage s ⊆ t) l₂.sets, univ_sets := ⋯, sets_of_superset := ⋯,
        inter_sets := ⋯ } ↔
    ∀ s ∈ l₂, r.preimage s ∈ l₁
state_after: case mp
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ l₁ ≤
      { sets := Rel.image (fun s t => r.preimage s ⊆ t) l₂.sets, univ_sets := ⋯, sets_of_superset := ⋯,
        inter_sets := ⋯ } →
    ∀ s ∈ l₂, r.preimage s ∈ l₁

case mpr
α : Type u
β : Type v
γ : Type w
r : Rel α β
l₁ : Filter α
l₂ : Filter β
⊢ (∀ s ∈ l₂, r.preimage s ∈ l₁) →
    l₁ ≤
      { sets := Rel.image (fun s t => r.preimage s ⊆ t) l₂.sets, univ_sets := ⋯, sets_of_superset := ⋯,
        inter_sets := ⋯ }
tactic: constructor
Theorem: Complex.equivRealProdLm_symm_apply_im
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: r : ℝ
c : ℂ
⊢ { toFun := __src✝.toFun, map_add' := ⋯ }.toFun (r • c) =
    (RingHom.id ℝ) r • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun c
state_after: no goals
tactic: simp [equivRealProdAddHom, Prod.smul_def, smul_eq_mul]