ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AdjoinRoot.mk_eq_zero
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
f g : R[X]
⊢ f ∣ g - 0 ↔ f ∣ g
state_after: no goals
tactic: rw [sub_zero]
Theorem: FormalMultilinearSeries.id_comp
File: Mathlib/Analysis/Analytic/Composition.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
p : FormalMultilinearSeries 𝕜 E F
h : p 0 = 0
⊢ (id 𝕜 F).comp p = p
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
p : FormalMultilinearSeries 𝕜 E F
h : p 0 = 0
n : ℕ
⊢ (id 𝕜 F).comp p n = p n
tactic: ext1 n
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
p : FormalMultilinearSeries 𝕜 E F
h : p 0 = 0
n : ℕ
⊢ (id 𝕜 F).comp p n = p n
state_after: case pos
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
p : FormalMultilinearSeries 𝕜 E F
h : p 0 = 0
n : ℕ
hn : n = 0
⊢ (id 𝕜 F).comp p n = p n

case neg
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
p : FormalMultilinearSeries 𝕜 E F
h : p 0 = 0
n : ℕ
hn : ¬n = 0
⊢ (id 𝕜 F).comp p n = p n
tactic: by_cases hn : n = 0
Theorem: List.formPerm_reverse
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x a b : α
l : List α
⊢ (a :: b :: l).reverse.formPerm = (a :: b :: l).formPerm⁻¹
state_after: no goals
tactic: simp [formPerm_append_pair, swap_comm, ← formPerm_reverse (b::l)]
Theorem: Complex.nndist_conj_self
File: Mathlib/Analysis/Complex/Basic.lean

Proof steps:
state_before: z✝ : ℂ
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z : ℂ
⊢ ↑(nndist ((starRingEnd ℂ) z) z) = ↑(2 * Real.nnabs z.im)
state_after: no goals
tactic: rw [← dist_nndist, NNReal.coe_mul, NNReal.coe_two, Real.coe_nnabs, dist_conj_self]
Theorem: Right.nonneg_neg_iff
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⁻¹ ↔ a ≤ 1
state_after: α : 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 ≤ a⁻¹ * a ↔ a ≤ 1
tactic: rw [← mul_le_mul_iff_right a]
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 ≤ a⁻¹ * a ↔ a ≤ 1
state_after: no goals
tactic: simp
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₂_id
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 : C
⊢ map₂ F (𝟙 X) = id
state_after: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
x✝¹ : YonedaCollection F X
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (𝟙 X) x✝¹).fst.app x✝ a✝ = (id x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
x✝ : YonedaCollection F X
⊢ F.map (eqToHom ⋯) (id x✝).snd = (map₂ F (𝟙 X) x✝).snd
tactic: ext
state_before: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
x✝¹ : YonedaCollection F X
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (𝟙 X) x✝¹).fst.app x✝ a✝ = (id x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
x✝ : YonedaCollection F X
⊢ F.map (eqToHom ⋯) (id x✝).snd = (map₂ F (𝟙 X) x✝).snd
state_after: no goals
tactic: all_goals simp
Theorem: Real.summable_nat_pow_inv
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: p : ℕ
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p
state_after: no goals
tactic: simp only [← rpow_natCast, summable_nat_rpow_inv, Nat.one_lt_cast]
Theorem: AddSubgroup.sup_eq_closure_add
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
H K : Subgroup G
⊢ closure ↑H ⊔ closure ↑K ≤ H ⊔ K
state_after: no goals
tactic: rw [closure_eq, closure_eq]
Theorem: Finset.left_mem_Icc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Icc a b ↔ a ≤ b
state_after: no goals
tactic: simp only [mem_Icc, true_and_iff, le_rfl]
Theorem: Nat.multiplicity_eq_factorization
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
pp : Prime p
hn : n ≠ 0
⊢ multiplicity p n = ↑(n.factorization p)
state_after: no goals
tactic: simp [factorization, pp, padicValNat_def' pp.ne_one hn.bot_lt]
Theorem: Filter.smallSets_bot
File: Mathlib/Order/Filter/SmallSets.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ ⊥.smallSets = pure ∅
state_after: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ Monotone powerset
tactic: rw [smallSets, lift'_bot, powerset_empty, principal_singleton]
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ Monotone powerset
state_after: no goals
tactic: exact monotone_powerset
Theorem: Polynomial.smeval_C
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ (C r).smeval x = r • x ^ 0
state_after: no goals
tactic: simp only [smeval_eq_sum, smul_pow, zero_smul, sum_C_index]
Theorem: CategoryTheory.Functor.mapArrow_obj_right
File: Mathlib/CategoryTheory/Comma/Arrow.lean

Proof steps:
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : (𝟭 C).map f.left ≫ Y✝.hom = X✝.hom ≫ (𝟭 C).map f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
tactic: let w := f.w
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : (𝟭 C).map f.left ≫ Y✝.hom = X✝.hom ≫ (𝟭 C).map f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
tactic: simp only [id_map] at w
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ (𝟭 D).map (F.map f.left) ≫ ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) Y✝).hom =
    ((fun a => { left := F.obj a.left, right := F.obj a.right, hom := F.map a.hom }) X✝).hom ≫ (𝟭 D).map (F.map f.right)
state_after: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ F.map f.left ≫ F.map Y✝.hom = F.map X✝.hom ≫ F.map f.right
tactic: dsimp
state_before: T : Type u
inst✝² : Category.{v, u} T
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y✝ : Arrow C
f : X✝ ⟶ Y✝
w : f.left ≫ Y✝.hom = X✝.hom ≫ f.right := f.w
⊢ F.map f.left ≫ F.map Y✝.hom = F.map X✝.hom ≫ F.map f.right
state_after: no goals
tactic: simp only [← F.map_comp, w]
Theorem: Nat.card_sum
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Finite α
inst✝ : Finite β
⊢ Nat.card (α ⊕ β) = Nat.card α + Nat.card β
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Nat.card (α ⊕ β) = Nat.card α + Nat.card β
tactic: have := Fintype.ofFinite α
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Nat.card (α ⊕ β) = Nat.card α + Nat.card β
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Nat.card (α ⊕ β) = Nat.card α + Nat.card β
tactic: have := Fintype.ofFinite β
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Nat.card (α ⊕ β) = Nat.card α + Nat.card β
state_after: no goals
tactic: simp_rw [Nat.card_eq_fintype_card, Fintype.card_sum]
Theorem: CompositionAsSet.length_lt_card_boundaries
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : CompositionAsSet n
⊢ c.length < c.boundaries.card
state_after: n : ℕ
c : CompositionAsSet n
⊢ c.length < c.length + 1
tactic: rw [c.card_boundaries_eq_succ_length]
state_before: n : ℕ
c : CompositionAsSet n
⊢ c.length < c.length + 1
state_after: no goals
tactic: exact lt_add_one _
Theorem: AlgebraicGeometry.StructureSheaf.localizationToStalk_mk'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
x : ↑(PrimeSpectrum.Top R)
f : R
s : ↥x.asIdeal.primeCompl
⊢ (toStalk R x) f =
    (toStalk R x) ↑s * ((structureSheaf R).presheaf.germ ⟨x, ⋯⟩) (const R f (↑s) (PrimeSpectrum.basicOpen ↑s) ⋯)
state_after: no goals
tactic: erw [← germ_toOpen R (PrimeSpectrum.basicOpen s) ⟨x, s.2⟩,
      ← germ_toOpen R (PrimeSpectrum.basicOpen s) ⟨x, s.2⟩, ← RingHom.map_mul, toOpen_eq_const,
      toOpen_eq_const, const_mul_cancel']
Theorem: Nat.Partrec.Code.eval_id
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: n : ℕ
⊢ Code.id.eval n = Part.some n
state_after: no goals
tactic: simp! [Seq.seq]
Theorem: commutator_eq_normalClosure
File: Mathlib/GroupTheory/Abelianization.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
⊢ commutator G = Subgroup.normalClosure (commutatorSet G)
state_after: no goals
tactic: simp [commutator, Subgroup.commutator_def', commutatorSet]
Theorem: OrthogonalFamily.eq_ite
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
ι : Type u_4
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : DecidableEq ι
i j : ι
v : G i
w : G j
⊢ ⟪(V i) v, (V j) w⟫_𝕜 = if i = j then ⟪(V i) v, (V j) w⟫_𝕜 else 0
state_after: case pos
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
ι : Type u_4
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : DecidableEq ι
i j : ι
v : G i
w : G j
h : i = j
⊢ ⟪(V i) v, (V j) w⟫_𝕜 = ⟪(V i) v, (V j) w⟫_𝕜

case neg
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
ι : Type u_4
G : ι → Type u_5
inst✝² : (i : ι) → NormedAddCommGroup (G i)
inst✝¹ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
hV : OrthogonalFamily 𝕜 G V
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
inst✝ : DecidableEq ι
i j : ι
v : G i
w : G j
h : ¬i = j
⊢ ⟪(V i) v, (V j) w⟫_𝕜 = 0
tactic: split_ifs with h
Theorem: memℓp_infty_iff
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ Memℓp f ⊤ ↔ BddAbove (Set.range fun i => ‖f i‖)
state_after: no goals
tactic: simp [Memℓp]
Theorem: induction_on_primes
File: Mathlib/Data/Nat/Factorization/Induction.lean

Proof steps:
state_before: a b m n p : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
⊢ ∀ (n : ℕ), P n
state_after: a b m n p : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
⊢ ∀ (a p n : ℕ), Prime p → ¬p ∣ a → 0 < n → P a → P (p ^ n * a)
tactic: refine recOnPrimePow h₀ h₁ ?_
state_before: a b m n p : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
⊢ ∀ (a p n : ℕ), Prime p → ¬p ∣ a → 0 < n → P a → P (p ^ n * a)
state_after: a✝ b m n✝ p✝ : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
a p n : ℕ
hp : Prime p
ha : P a
⊢ P (p ^ n * a)
tactic: rintro a p n hp - - ha
state_before: a✝ b m n✝ p✝ : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
a p n : ℕ
hp : Prime p
ha : P a
⊢ P (p ^ n * a)
state_after: case zero
a✝ b m n p✝ : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
a p : ℕ
hp : Prime p
ha : P a
⊢ P (p ^ 0 * a)

case succ
a✝ b m n✝ p✝ : ℕ
P : ℕ → Prop
h₀ : P 0
h₁ : P 1
h : ∀ (p a : ℕ), Prime p → P a → P (p * a)
a p : ℕ
hp : Prime p
ha : P a
n : ℕ
ih : P (p ^ n * a)
⊢ P (p ^ (n + 1) * a)
tactic: induction' n with n ih
Theorem: Rat.mul_den_eq_num
File: Mathlib/Algebra/Ring/Rat.lean

Proof steps:
state_before: q : ℚ
⊢ q * ↑q.den = ↑q.num
state_after: q : ℚ
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
tactic: suffices (q.num /. ↑q.den) * (↑q.den /. 1) = q.num /. 1 by
    conv => pattern (occs := 1) q; (rw [← num_divInt_den q])
    simp only [intCast_eq_divInt, natCast_eq_divInt, num_divInt_den] at this ⊢; assumption
state_before: q : ℚ
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
state_after: q : ℚ
this : ↑q.den ≠ 0
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
tactic: have : (q.den : ℤ) ≠ 0 := mod_cast q.den_ne_zero
state_before: q : ℚ
this : ↑q.den ≠ 0
⊢ q.num /. ↑q.den * (↑q.den /. 1) = q.num /. 1
state_after: no goals
tactic: rw [divInt_mul_divInt _ _ this Int.one_ne_zero, mul_comm (q.den : ℤ) 1, divInt_mul_right this]
Theorem: Set.sized_singleton
File: Mathlib/Data/Finset/Slice.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
A B : Set (Finset α)
s : Finset α
r : ℕ
⊢ Sized r {s} ↔ s.card = r
state_after: no goals
tactic: simp [Sized]
Theorem: Int.csSup_of_not_bdd_above
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

Proof steps:
state_before: s : Set ℤ
h : ¬BddAbove s
⊢ ¬(s.Nonempty ∧ BddAbove s)
state_after: no goals
tactic: simp [h]
Theorem: NonUnitalAlgebra.adjoin_eq_span
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
s : Set A
⊢ (adjoin R s).toSubmodule = span R ↑(Subsemigroup.closure s)
state_after: case a
F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
s : Set A
⊢ (adjoin R s).toSubmodule ≤ span R ↑(Subsemigroup.closure s)

case a
F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
s : Set A
⊢ span R ↑(Subsemigroup.closure s) ≤ (adjoin R s).toSubmodule
tactic: apply le_antisymm
Theorem: EReal.add_lt_add_of_lt_of_le'
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y z t : EReal
h : x < y
h' : z ≤ t
hbot : t ≠ ⊥
htop : t = ⊤ → z = ⊤ → x = ⊥
⊢ x + z < y + t
state_after: case inl
x y z : EReal
h : x < y
h' : z ≤ z
hbot : z ≠ ⊥
htop : z = ⊤ → z = ⊤ → x = ⊥
⊢ x + z < y + z

case inr
x y z t : EReal
h : x < y
h' : z ≤ t
hbot : t ≠ ⊥
htop : t = ⊤ → z = ⊤ → x = ⊥
hlt : z < t
⊢ x + z < y + t
tactic: rcases h'.eq_or_lt with (rfl | hlt)
Theorem: Algebra.Generators.baseChange_vars
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Generators T (T ⊗[R] S)
state_after: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Function.Surjective ⇑(aeval fun x => 1 ⊗ₜ[R] P.val x)
tactic: apply Generators.ofSurjective (fun x ↦ 1 ⊗ₜ[R] P.val x)
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
⊢ Function.Surjective ⇑(aeval fun x => 1 ⊗ₜ[R] P.val x)
state_after: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
x : T ⊗[R] S
⊢ ∃ a, (aeval fun x => 1 ⊗ₜ[R] P.val x) a = x
tactic: intro x
state_before: R : Type u
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
inst✝⁶ : Algebra R S
P✝ : Generators R S
T✝ : Type ?u.93774
inst✝⁵ : CommRing T✝
inst✝⁴ : Algebra R T✝
inst✝³ : Algebra S T✝
inst✝² : IsScalarTower R S T✝
T : Type ?u.94985
inst✝¹ : CommRing T
inst✝ : Algebra R T
P : Generators R S
x : T ⊗[R] S
⊢ ∃ a, (aeval fun x => 1 ⊗ₜ[R] P.val x) a = x
state_after: no goals
tactic: induction x using TensorProduct.induction_on with
  | zero => exact ⟨0, map_zero _⟩
  | tmul a b =>
    let X := P.σ b
    use a • MvPolynomial.map (algebraMap R T) X
    simp only [LinearMapClass.map_smul, X, aeval_map_algebraMap]
    have : ∀ y : P.Ring,
      aeval (fun x ↦ (1 ⊗ₜ[R] P.val x : T ⊗[R] S)) y = 1 ⊗ₜ aeval (fun x ↦ P.val x) y := by
      intro y
      induction y using MvPolynomial.induction_on with
      | h_C a =>
        rw [aeval_C, aeval_C, TensorProduct.algebraMap_apply, algebraMap_eq_smul_one, smul_tmul,
          algebraMap_eq_smul_one]
      | h_add p q hp hq => simp [map_add, tmul_add, hp, hq]
      | h_X p i hp => simp [hp]
    rw [this, P.aeval_val_σ, smul_tmul', smul_eq_mul, mul_one]
  | add x y ex ey =>
    obtain ⟨a, ha⟩ := ex
    obtain ⟨b, hb⟩ := ey
    use (a + b)
    rw [map_add, ha, hb]
Theorem: SimpleGraph.minDegree_le_degree
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
⊢ G.minDegree ≤ G.degree v
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : (image (fun v => G.degree v) univ).min = ↑t
⊢ G.minDegree ≤ G.degree v
tactic: obtain ⟨t, ht⟩ := Finset.min_of_mem (mem_image_of_mem (fun v => G.degree v) (mem_univ v))
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : (image (fun v => G.degree v) univ).min = ↑t
⊢ G.minDegree ≤ G.degree v
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : (image (fun v => G.degree v) univ).min = ↑t
this : t ≤ G.degree v
⊢ G.minDegree ≤ G.degree v
tactic: have := Finset.min_le_of_eq (mem_image_of_mem _ (mem_univ v)) ht
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
t : ℕ
ht : (image (fun v => G.degree v) univ).min = ↑t
this : t ≤ G.degree v
⊢ G.minDegree ≤ G.degree v
state_after: no goals
tactic: rwa [minDegree, ht]
Theorem: Nat.ord_proj_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a✝ b✝ m n p✝ a b p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ p ^ (a * b).factorization p = p ^ a.factorization p * p ^ b.factorization p
state_after: no goals
tactic: simp [factorization_mul ha hb, pow_add]