ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContinuousLinearMap.hasDerivAt_of_bilinear
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
B : E →L[𝕜] F →L[𝕜] G
u : 𝕜 → E
v : 𝕜 → F
u' : E
v' : F
hu : HasDerivAt u u' x
hv : HasDerivAt v v' x
⊢ HasDerivAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) x
state_after: no goals
tactic: simpa using (B.hasFDerivAt_of_bilinear hu.hasFDerivAt hv.hasFDerivAt).hasDerivAt
Theorem: CategoryTheory.NonPreadditiveAbelian.add_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 [add_def, sub_comp, neg_def, sub_comp, zero_comp, add_def, neg_def]
Theorem: List.mem_rtakeWhile_imp
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
hx : x ∈ rtakeWhile p l
⊢ p x = true
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
hx : x ∈ takeWhile p l.reverse
⊢ p x = true
tactic: rw [rtakeWhile, mem_reverse] at hx
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
hx : x ∈ takeWhile p l.reverse
⊢ p x = true
state_after: no goals
tactic: exact mem_takeWhile_imp hx
Theorem: WeierstrassCurve.Affine.Point.map_id
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝²³ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝²² : CommRing R
W : Affine R
S : Type s
inst✝²¹ : CommRing S
inst✝²⁰ : Algebra R S
A : Type u
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Algebra R A
inst✝¹⁷ : Algebra S A
inst✝¹⁶ : IsScalarTower R S A
B : Type v
inst✝¹⁵ : CommRing B
inst✝¹⁴ : Algebra R B
inst✝¹³ : Algebra S B
inst✝¹² : IsScalarTower R S B
f✝ : A →ₐ[S] B
F : Type u
inst✝¹¹ : Field F
inst✝¹⁰ : Algebra R F
inst✝⁹ : Algebra S F
inst✝⁸ : IsScalarTower R S F
K : Type v
inst✝⁷ : Field K
inst✝⁶ : Algebra R K
inst✝⁵ : Algebra S K
inst✝⁴ : IsScalarTower R S K
f : F →ₐ[S] K
L : Type w
inst✝³ : Field L
inst✝² : Algebra R L
inst✝¹ : Algebra S L
inst✝ : IsScalarTower R S L
g : K →ₐ[S] L
P : W⟮F⟯
⊢ (map W (Algebra.ofId F F)) P = P
state_after: no goals
tactic: cases P <;> rfl
Theorem: CommGrp.epi_iff_surjective
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : CommGrp
f : A ⟶ B
⊢ Epi f ↔ Function.Surjective ⇑f
state_after: no goals
tactic: rw [epi_iff_range_eq_top, MonoidHom.range_top_iff_surjective]
Theorem: Real.sin_half_eq_neg_sqrt
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) = -√((1 - cos x) / 2)
state_after: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) ≤ 0
tactic: rw [← abs_sin_half, abs_of_nonpos, neg_neg]
state_before: x : ℝ
hl : -(2 * π) ≤ x
hr : x ≤ 0
⊢ sin (x / 2) ≤ 0
state_after: no goals
tactic: apply sin_nonpos_of_nonnpos_of_neg_pi_le <;> linarith
Theorem: ENNReal.exp_log
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean

Proof steps:
state_before: x : ℝ≥0∞
⊢ x.log.exp = x
state_after: case pos
x : ℝ≥0∞
hx_top : x = ⊤
⊢ x.log.exp = x

case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
⊢ x.log.exp = x
tactic: by_cases hx_top : x = ∞
state_before: case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
⊢ x.log.exp = x
state_after: case pos
x : ℝ≥0∞
hx_top : ¬x = ⊤
hx_zero : x = 0
⊢ x.log.exp = x

case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
hx_zero : ¬x = 0
⊢ x.log.exp = x
tactic: by_cases hx_zero : x = 0
state_before: case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
hx_zero : ¬x = 0
⊢ x.log.exp = x
state_after: case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
hx_zero : ¬x = 0
hx_pos : 0 < x.toReal
⊢ x.log.exp = x
tactic: have hx_pos : 0 < x.toReal := ENNReal.toReal_pos hx_zero hx_top
state_before: case neg
x : ℝ≥0∞
hx_top : ¬x = ⊤
hx_zero : ¬x = 0
hx_pos : 0 < x.toReal
⊢ x.log.exp = x
state_after: no goals
tactic: rw [← ENNReal.ofReal_toReal hx_top, log_ofReal_of_pos hx_pos, exp_coe, Real.exp_log hx_pos]
Theorem: nhds_translation_sub
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
x : G
⊢ comap (fun x_1 => x_1 / x) (𝓝 1) = 𝓝 x
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using nhds_translation_mul_inv x
Theorem: Basis.mem_span_repr_support
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : 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
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x m : M
⊢ b.repr m ∈ Finsupp.supported R R ↑(b.repr m).support ∧ (Finsupp.total ι M R ⇑b) (b.repr m) = m
state_after: no goals
tactic: simp [Finsupp.mem_supported_support]
Theorem: abs_sub_le_of_nonneg_of_le
File: Mathlib/Algebra/Order/Group/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ |a - b| ≤ n
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ a ≤ n + b ∧ b ≤ n + a
tactic: rw [abs_sub_le_iff, sub_le_iff_le_add, sub_le_iff_le_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a✝ b✝ c d a b n : α
a_nonneg : 0 ≤ a
a_le_n : a ≤ n
b_nonneg : 0 ≤ b
b_le_n : b ≤ n
⊢ a ≤ n + b ∧ b ≤ n + a
state_after: no goals
tactic: exact ⟨le_add_of_le_of_nonneg a_le_n b_nonneg, le_add_of_le_of_nonneg b_le_n a_nonneg⟩
Theorem: circleIntegral.norm_integral_le_of_norm_le_const
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 ≤ R
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
this : |R| = R
⊢ ∀ z ∈ sphere c |R|, ‖f z‖ ≤ C
state_after: no goals
tactic: rwa [this]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
c : ℂ
R C : ℝ
hR : 0 ≤ R
hf : ∀ z ∈ sphere c R, ‖f z‖ ≤ C
this : |R| = R
⊢ 2 * π * |R| * C = 2 * π * R * C
state_after: no goals
tactic: rw [this]
Theorem: Set.union_distrib_iInter₂_right
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋂ i, ⋂ j, s i j) ∪ t = ⋂ i, ⋂ j, s i j ∪ t
state_after: no goals
tactic: simp_rw [union_distrib_iInter_right]
Theorem: AdjoinRoot.Minpoly.toAdjoin.apply_X
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
⊢ (toAdjoin R x) ((mk (minpoly R x)) X) = ⟨x, ⋯⟩
state_after: no goals
tactic: simp [toAdjoin]
Theorem: QuotientGroup.quotientKerEquivOfRightInverse_apply
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
ψ : H → G
hφ : Function.RightInverse ψ ⇑φ
x : G ⧸ φ.ker
⊢ (kerLift φ) ((mk ∘ ψ) ((kerLift φ) x)) = (kerLift φ) x
state_after: no goals
tactic: rw [Function.comp_apply, kerLift_mk', hφ]
Theorem: ENNReal.le_toReal_sub
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb : b ≠ ⊤
⊢ a.toReal - b.toReal ≤ (a - b).toReal
state_after: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
⊢ a.toReal - (↑b).toReal ≤ (a - ↑b).toReal
tactic: lift b to ℝ≥0 using hb
state_before: case intro
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
⊢ a.toReal - (↑b).toReal ≤ (a - ↑b).toReal
state_after: case intro.top
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
⊢ ⊤.toReal - (↑b).toReal ≤ (⊤ - ↑b).toReal

case intro.coe
a b✝ c d : ℝ≥0∞
r p q b x✝ : ℝ≥0
⊢ (↑x✝).toReal - (↑b).toReal ≤ (↑x✝ - ↑b).toReal
tactic: induction a
Theorem: Nat.exists_lt_card_finite_nth_eq
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
hf : (setOf p).Finite
x : ℕ
h : p x
⊢ ∃ n < hf.toFinset.card, nth p n = x
state_after: no goals
tactic: rwa [← @Set.mem_setOf_eq _ _ p, ← image_nth_Iio_card hf] at h
Theorem: ProbabilityTheory.cgf_zero_measure
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
⊢ cgf X 0 t = 0
state_after: no goals
tactic: simp only [cgf, log_zero, mgf_zero_measure]
Theorem: ContractingWith.edist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
this : edist x y ≤ edist x (f x) + edist y (f y) + ↑K * edist x y
⊢ edist x y ≤ (edist x (f x) + edist y (f y)) / (1 - ↑K)
state_after: no goals
tactic: rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
      mul_comm, ENNReal.sub_mul fun _ _ ↦ h, one_mul, tsub_le_iff_right]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
⊢ edist x (f x) + edist (f x) (f y) + edist (f y) y = edist x (f x) + edist y (f y) + edist (f x) (f y)
state_after: no goals
tactic: rw [edist_comm y, add_right_comm]
Theorem: minpolyDiv_eq_zero
File: Mathlib/FieldTheory/Minpoly/MinpolyDiv.lean

Proof steps:
state_before: R : Type u_1
K : Type ?u.12922
L : Type ?u.12925
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : Algebra K L
x : S
hx✝ : IsIntegral R x
hx : ¬IsIntegral R x
⊢ minpolyDiv R x = 0
state_after: R : Type u_1
K : Type ?u.12922
L : Type ?u.12925
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : Algebra K L
x : S
hx✝ : IsIntegral R x
hx : ¬IsIntegral R x
⊢ map (algebraMap R S)
        (if hx : IsIntegral R x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap R S) x x_1 = 0) hx else 0) /ₘ
      (X - C x) =
    0
tactic: delta minpolyDiv minpoly
state_before: R : Type u_1
K : Type ?u.12922
L : Type ?u.12925
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : CommRing S
inst✝¹ : Algebra R S
inst✝ : Algebra K L
x : S
hx✝ : IsIntegral R x
hx : ¬IsIntegral R x
⊢ map (algebraMap R S)
        (if hx : IsIntegral R x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap R S) x x_1 = 0) hx else 0) /ₘ
      (X - C x) =
    0
state_after: no goals
tactic: rw [dif_neg hx, Polynomial.map_zero, zero_divByMonic]
Theorem: QuotSMulTop.map_comp_mkQ
File: Mathlib/RingTheory/QuotSMulTop.lean

Proof steps:
state_before: R : Type u_2
inst✝⁶ : CommRing R
r : R
M : Type u_1
M' : Type u_3
M'' : Type ?u.47044
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
f : M →ₗ[R] M'
⊢ (map r) f ∘ₗ (r • ⊤).mkQ = (r • ⊤).mkQ ∘ₗ f
state_after: case h
R : Type u_2
inst✝⁶ : CommRing R
r : R
M : Type u_1
M' : Type u_3
M'' : Type ?u.47044
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
f : M →ₗ[R] M'
x✝ : M
⊢ ((map r) f ∘ₗ (r • ⊤).mkQ) x✝ = ((r • ⊤).mkQ ∘ₗ f) x✝
tactic: ext
state_before: case h
R : Type u_2
inst✝⁶ : CommRing R
r : R
M : Type u_1
M' : Type u_3
M'' : Type ?u.47044
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : AddCommGroup M''
inst✝ : Module R M''
f : M →ₗ[R] M'
x✝ : M
⊢ ((map r) f ∘ₗ (r • ⊤).mkQ) x✝ = ((r • ⊤).mkQ ∘ₗ f) x✝
state_after: no goals
tactic: rfl
Theorem: Polynomial.smul_X_eq_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ a • X ^ n = (monomial n) a
state_after: no goals
tactic: rw [X_pow_eq_monomial, smul_monomial, smul_eq_mul, mul_one]
Theorem: TypeVec.const_nil
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
⊢ TypeVec.const x α = nilFun
state_after: case a
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
i : Fin2 0
⊢ TypeVec.const x α i = nilFun i
tactic: ext i : 1
state_before: case a
n : ℕ
β : Type u_1
x : β
α : TypeVec.{u_2} 0
i : Fin2 0
⊢ TypeVec.const x α i = nilFun i
state_after: no goals
tactic: cases i
Theorem: ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib₀
File: Mathlib/Probability/Kernel/CondDistrib.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hX : Measurable X
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
hf_int : Integrable (fun a => f (X a, Y a)) μ
⊢ Integrable f (Measure.map (fun a => (X a, Y a)) μ)
state_after: no goals
tactic: rwa [integrable_map_measure hf (hX.aemeasurable.prod_mk hY)]
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₂_fst
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y : C
f : X ⟶ Y
p : YonedaCollection F Y
⊢ (map₂ F f p).fst = yoneda.map f ≫ p.fst
state_after: no goals
tactic: simp [map₂]
Theorem: MeasureTheory.VectorMeasure.ext_iff
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ v = w ↔ ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i
state_after: case mp
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ v = w → ∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i

case mpr
α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v w : VectorMeasure α M
⊢ (∀ (i : Set α), MeasurableSet i → ↑v i = ↑w i) → v = w
tactic: constructor
Theorem: Nat.even_add
File: Mathlib/Algebra/Group/Nat.lean

Proof steps:
state_before: m n : ℕ
⊢ Even (m + n) ↔ (Even m ↔ Even n)
state_after: no goals
tactic: cases' mod_two_eq_zero_or_one m with h₁ h₁ <;> cases' mod_two_eq_zero_or_one n with h₂ h₂ <;>
    simp [even_iff, h₁, h₂, Nat.add_mod]
Theorem: Polynomial.monic_geom_sum_X
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
⊢ (∑ i ∈ range n, X ^ i).Monic
state_after: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
a✝ : Nontrivial R
⊢ (∑ i ∈ range n, X ^ i).Monic
tactic: nontriviality R
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
a✝ : Nontrivial R
⊢ (∑ i ∈ range n, X ^ i).Monic
state_after: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
a✝ : Nontrivial R
⊢ 0 < X.natDegree
tactic: apply monic_X.geom_sum _ hn
state_before: R : Type u
S : Type u_1
inst✝ : Semiring R
n : ℕ
hn : n ≠ 0
a✝ : Nontrivial R
⊢ 0 < X.natDegree
state_after: no goals
tactic: simp only [natDegree_X, zero_lt_one]
Theorem: MonoidHom.toOpposite_apply
File: Mathlib/Algebra/Group/Opposite.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
inst✝¹ : MulOneClass M
inst✝ : MulOneClass N
f : M →* N
hf : ∀ (x y : M), Commute (f x) (f y)
x y : M
⊢ { toFun := op ∘ ⇑f, map_one' := ⋯ }.toFun (x * y) =
    { toFun := op ∘ ⇑f, map_one' := ⋯ }.toFun x * { toFun := op ∘ ⇑f, map_one' := ⋯ }.toFun y
state_after: no goals
tactic: simp [(hf x y).eq]
Theorem: IsFractionRing.num_zero
File: Mathlib/RingTheory/Localization/NumDen.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ num A 0 = 0
state_after: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
this : (algebraMap A K) (num A 0) / (algebraMap A K) ↑(den A 0) = 0
⊢ num A 0 = 0
tactic: have := mk'_num_den' A (0 : K)
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
this : (algebraMap A K) (num A 0) / (algebraMap A K) ↑(den A 0) = 0
⊢ num A 0 = 0
state_after: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
this : (algebraMap A K) (num A 0) = 0 ∨ (algebraMap A K) ↑(den A 0) = 0
⊢ num A 0 = 0
tactic: simp only [div_eq_zero_iff] at this
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
this : (algebraMap A K) (num A 0) = 0 ∨ (algebraMap A K) ↑(den A 0) = 0
⊢ num A 0 = 0
state_after: case inl
R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : (algebraMap A K) (num A 0) = 0
⊢ num A 0 = 0

case inr
R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : (algebraMap A K) ↑(den A 0) = 0
⊢ num A 0 = 0
tactic: rcases this with h | h
Theorem: CategoryTheory.ShortComplex.unopMap_τ₁
File: Mathlib/Algebra/Homology/ShortComplex/Basic.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₃.unop ≫ S₁.unop.f = S₂.unop.f ≫ φ.τ₂.unop
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₃.unop ≫ S₁.g.unop = S₂.g.unop ≫ φ.τ₂.unop
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₃.unop ≫ S₁.g.unop = S₂.g.unop ≫ φ.τ₂.unop
state_after: no goals
tactic: simp only [← unop_comp, φ.comm₂₃]
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₂.unop ≫ S₁.unop.g = S₂.unop.g ≫ φ.τ₁.unop
state_after: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₂.unop ≫ S₁.f.unop = S₂.f.unop ≫ φ.τ₁.unop
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{?u.61158, u_1} C
inst✝² : Category.{?u.61162, u_2} D
inst✝¹ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ : ShortComplex C
inst✝ : HasZeroMorphisms D
S₁ S₂ : ShortComplex Cᵒᵖ
φ : S₁ ⟶ S₂
⊢ φ.τ₂.unop ≫ S₁.f.unop = S₂.f.unop ≫ φ.τ₁.unop
state_after: no goals
tactic: simp only [← unop_comp, φ.comm₁₂]
Theorem: Mathlib.Meta.NormNum.isInt_rpow_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: a b : ℝ
nb ne : ℕ
pb : IsNat b nb
pe' : IsInt (a ^ nb) (Int.negOfNat ne)
⊢ IsInt (a ^ b) (Int.negOfNat ne)
state_after: no goals
tactic: rwa [pb.out, rpow_natCast]
Theorem: CategoryTheory.Limits.prod.rightUnitor_inv
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y : C
inst✝¹ : HasTerminal C
P : C
inst✝ : HasBinaryProduct P (⊤_ C)
⊢ fst ≫ lift (𝟙 P) (terminal.from P) = 𝟙 (P ⨯ ⊤_ C)
state_after: no goals
tactic: apply prod.hom_ext <;> simp [eq_iff_true_of_subsingleton]
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y : C
inst✝¹ : HasTerminal C
P : C
inst✝ : HasBinaryProduct P (⊤_ C)
⊢ lift (𝟙 P) (terminal.from P) ≫ fst = 𝟙 P
state_after: no goals
tactic: simp
Theorem: SetTheory.PGame.mulOption_neg_neg
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.mulOption y i j = x.mulOption (- -y) i (toLeftMovesNeg (toRightMovesNeg j))
state_after: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j =
    x.moveLeft i * - -y + x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j)) -
      x.moveLeft i * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
tactic: dsimp only [mulOption]
state_before: x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y + x * y.moveLeft j - x.moveLeft i * y.moveLeft j =
    x.moveLeft i * - -y + x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j)) -
      x.moveLeft i * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x.moveLeft i * y = x.moveLeft i * - -y

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
tactic: congr 2
state_before: case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ x * y.moveLeft j = x * (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))

case e_a.e_a
x y : PGame
i : x.LeftMoves
j : y.LeftMoves
⊢ y.moveLeft j = (- -y).moveLeft (toLeftMovesNeg (toRightMovesNeg j))
state_after: no goals
tactic: iterate 2 rw [moveLeft_neg, moveRight_neg, neg_neg]
Theorem: Nat.dvd_prime_pow
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n p : ℕ
pp : Prime p
m i : ℕ
⊢ i ∣ p ^ m ↔ ∃ k ≤ m, i = p ^ k
state_after: no goals
tactic: simp_rw [_root_.dvd_prime_pow (prime_iff.mp pp) m, associated_eq_eq]