ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.transvection_mul_apply_same
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
b : n
c : R
M : Matrix n n R
⊢ (transvection i j c * M) i b = M i b + c * M j b
state_after: no goals
tactic: simp [transvection, Matrix.add_mul]
Theorem: mk_mem_nonZeroDivisors_associates
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

Proof steps:
state_before: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ Associates.mk a ∈ (Associates M₀)⁰ ↔ a ∈ M₀⁰
state_after: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (¬∀ (x : Associates M₀), x * Associates.mk a = 0 → x = 0) ↔ ¬∀ (x : M₀), x * a = 0 → x = 0
tactic: rw [mem_nonZeroDivisors_iff, mem_nonZeroDivisors_iff, ← not_iff_not]
state_before: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (¬∀ (x : Associates M₀), x * Associates.mk a = 0 → x = 0) ↔ ¬∀ (x : M₀), x * a = 0 → x = 0
state_after: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (∃ x, x * Associates.mk a = 0 ∧ x ≠ 0) ↔ ∃ x, x * a = 0 ∧ x ≠ 0
tactic: push_neg
state_before: M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (∃ x, x * Associates.mk a = 0 ∧ x ≠ 0) ↔ ∃ x, x * a = 0 ∧ x ≠ 0
state_after: case mp
M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (∃ x, x * Associates.mk a = 0 ∧ x ≠ 0) → ∃ x, x * a = 0 ∧ x ≠ 0

case mpr
M₀✝ : Type u_1
inst✝¹ : MonoidWithZero M₀✝
M₀ : Type u_2
inst✝ : CommMonoidWithZero M₀
a : M₀
⊢ (∃ x, x * a = 0 ∧ x ≠ 0) → ∃ x, x * Associates.mk a = 0 ∧ x ≠ 0
tactic: constructor
Theorem: Nat.mem_range_succ
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
i : ℕ
⊢ i ∈ range Nat.succ → 0 < i
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
n : ℕ
⊢ 0 < n.succ
tactic: rintro ⟨n, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s t : Set α
n : ℕ
⊢ 0 < n.succ
state_after: no goals
tactic: exact Nat.succ_pos n
Theorem: dvd_cancel_left_mem_nonZeroDivisors
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

Proof steps:
state_before: M₀ : Type u_1
inst✝⁵ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R'
hr : r ∈ R'⁰
x✝ : r * x ∣ r * y
z : R'
h✝ : r * y = r * x * z
⊢ y = x * z
state_after: no goals
tactic: rwa [← mul_cancel_left_mem_nonZeroDivisors hr, ← mul_assoc]
state_before: M₀ : Type u_1
inst✝⁵ : MonoidWithZero M₀
M : Type u_2
M' : Type u_3
M₁ : Type u_4
R : Type u_5
R' : Type u_6
F : Type u_7
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R'
hr : r ∈ R'⁰
x✝ : x ∣ y
z : R'
h : y = x * z
⊢ r * y = r * x * z
state_after: no goals
tactic: rw [h, ← mul_assoc]
Theorem: Matroid.uniqueBaseOn_indep_iff'
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ (uniqueBaseOn I E).Indep J ↔ J ⊆ I ∩ E
state_after: no goals
tactic: rw [uniqueBaseOn, restrict_indep_iff, freeOn_indep_iff, subset_inter_iff]
Theorem: addOrderOf_nsmul'
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : n ≠ 0
⊢ orderOf (x ^ n) = orderOf x / (orderOf x).gcd n
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : n ≠ 0
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
tactic: unfold orderOf
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : n ≠ 0
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
state_after: no goals
tactic: rw [← minimalPeriod_iterate_eq_div_gcd h, mul_left_iterate]
Theorem: SimpleGraph.incidenceSetEquivNeighborSet_symm_apply_coe
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
inst✝ : DecidableEq V
v : V
x : ↑(G.incidenceSet v)
⊢ (fun w => ⟨s(v, ↑w), ⋯⟩) ((fun e => ⟨G.otherVertexOfIncident ⋯, ⋯⟩) x) = x
state_after: no goals
tactic: simp [otherVertexOfIncident]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
inst✝ : DecidableEq V
v : V
x✝ : ↑(G.neighborSet v)
w : V
hw : w ∈ G.neighborSet v
⊢ (fun e => ⟨G.otherVertexOfIncident ⋯, ⋯⟩) ((fun w => ⟨s(v, ↑w), ⋯⟩) ⟨w, hw⟩) = ⟨w, hw⟩
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
inst✝ : DecidableEq V
v : V
x✝ : ↑(G.neighborSet v)
w : V
hw : w ∈ G.neighborSet v
⊢ G.otherVertexOfIncident ⋯ = w
tactic: simp only [mem_neighborSet, Subtype.mk.injEq]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
inst✝ : DecidableEq V
v : V
x✝ : ↑(G.neighborSet v)
w : V
hw : w ∈ G.neighborSet v
⊢ G.otherVertexOfIncident ⋯ = w
state_after: no goals
tactic: exact incidence_other_neighbor_edge _ hw
Theorem: ContinuousLinearMap.adjointAux_inner_right
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace G
A : E →L[𝕜] F
x : E
y : F
⊢ ⟪x, (adjointAux A) y⟫_𝕜 = ⟪A x, y⟫_𝕜
state_after: no goals
tactic: rw [← inner_conj_symm, adjointAux_inner_left, inner_conj_symm]
Theorem: Set.range_list_getD
File: Mathlib/Data/Set/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List α
d : α
⊢ (fun o => o.getD d) '' range l.get? = insert d {x | x ∈ l}
state_after: no goals
tactic: simp only [range_list_get?, image_insert_eq, Option.getD, image_image, image_id']
Theorem: Finset.Nonempty.zero_smul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Zero α
inst✝² : Zero β
inst✝¹ : SMulWithZero α β
inst✝ : DecidableEq β
s : Finset α
t : Finset β
ht : t.Nonempty
⊢ 0 ⊆ 0 • t
state_after: no goals
tactic: simpa [mem_smul] using ht
Theorem: CategoryTheory.Presieve.Arrows.Compatible.exists_familyOfElements
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
⊢ ∃ x', ∀ (i : I), x' (π i) ⋯ = x i
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
i : {Z : C} → (g : Z ⟶ B) → ofArrows X π g → I
h : ∀ {Z : C} (g : Z ⟶ B) (hg : ofArrows X π g), X (i g hg) = Z
h' : ∀ {Z : C} (g : Z ⟶ B) (hg : ofArrows X π g), g = eqToHom ⋯ ≫ π (i g hg)
⊢ ∃ x', ∀ (i : I), x' (π i) ⋯ = x i
tactic: choose i h h' using @ofArrows_surj _ _ _ _ _ π
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
x : (i : I) → P.obj (op (X i))
hx : Compatible P π x
i : {Z : C} → (g : Z ⟶ B) → ofArrows X π g → I
h : ∀ {Z : C} (g : Z ⟶ B) (hg : ofArrows X π g), X (i g hg) = Z
h' : ∀ {Z : C} (g : Z ⟶ B) (hg : ofArrows X π g), g = eqToHom ⋯ ≫ π (i g hg)
⊢ ∃ x', ∀ (i : I), x' (π i) ⋯ = x i
state_after: no goals
tactic: exact ⟨fun Y f hf ↦ P.map (eqToHom (h f hf).symm).op (x _),
    fun j ↦ (hx _ j (X j) _ (𝟙 _) <| by rw [← h', id_comp]).trans <| by simp⟩
Theorem: bernoulli'_spec
File: Mathlib/NumberTheory/Bernoulli.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ range n.succ, ↑(n.choose (n - k)) / (↑n - ↑k + 1) * bernoulli' k = 1
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ range n, (↑(n.choose x) / (↑n - ↑x + 1) * bernoulli' x - ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x) = 0
tactic: rw [sum_range_succ_comm, bernoulli'_def n, tsub_self, choose_zero_right, sub_self, zero_add,
    div_one, cast_one, one_mul, sub_add, ← sum_sub_distrib, ← sub_eq_zero, sub_sub_cancel_left,
    neg_eq_zero]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ range n, (↑(n.choose x) / (↑n - ↑x + 1) * bernoulli' x - ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x) = 0
state_after: no goals
tactic: exact Finset.sum_eq_zero (fun x hx => by rw [choose_symm (le_of_lt (mem_range.1 hx)), sub_self])
Theorem: autAdjoinRootXPowSubC_root
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
η : ↥(rootsOfUnity ⟨n, hn⟩ K)
⊢ ((autAdjoinRootXPowSubC hn a) η) (root (X ^ n - C a)) = ↑↑η • root (X ^ n - C a)
state_after: K : Type u
inst✝ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
η : ↥(rootsOfUnity ⟨n, hn⟩ K)
⊢ (liftHom (X ^ n - C a) (↑↑η • root (X ^ n - C a)) ⋯) (root (X ^ n - C a)) = ↑↑η • root (X ^ n - C a)
tactic: dsimp [autAdjoinRootXPowSubC, autAdjoinRootXPowSubCHom, AlgEquiv.algHomUnitsEquiv]
state_before: K : Type u
inst✝ : Field K
n : ℕ
hζ : (primitiveRoots n K).Nonempty
hn : 0 < n
a : K
H : Irreducible (X ^ n - C a)
η : ↥(rootsOfUnity ⟨n, hn⟩ K)
⊢ (liftHom (X ^ n - C a) (↑↑η • root (X ^ n - C a)) ⋯) (root (X ^ n - C a)) = ↑↑η • root (X ^ n - C a)
state_after: no goals
tactic: apply liftHom_root
Theorem: Equiv.pprodCongr_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort ?u.213
β : Sort ?u.212
γ : Sort ?u.217
δ : Sort ?u.216
e₁ : α ≃ β
e₂ : γ ≃ δ
x✝ : PProd α γ
x : α
y : γ
⊢ (fun x => ⟨e₁.symm x.fst, e₂.symm x.snd⟩) ((fun x => ⟨e₁ x.fst, e₂ x.snd⟩) ⟨x, y⟩) = ⟨x, y⟩
state_after: no goals
tactic: simp
state_before: α : Sort ?u.213
β : Sort ?u.212
γ : Sort ?u.217
δ : Sort ?u.216
e₁ : α ≃ β
e₂ : γ ≃ δ
x✝ : PProd β δ
x : β
y : δ
⊢ (fun x => ⟨e₁ x.fst, e₂ x.snd⟩) ((fun x => ⟨e₁.symm x.fst, e₂.symm x.snd⟩) ⟨x, y⟩) = ⟨x, y⟩
state_after: no goals
tactic: simp
Theorem: isClosed_set_pi
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
i : Set ι
s : (a : ι) → Set (π a)
hs : ∀ a ∈ i, IsClosed (s a)
⊢ IsClosed (i.pi s)
state_after: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
i : Set ι
s : (a : ι) → Set (π a)
hs : ∀ a ∈ i, IsClosed (s a)
⊢ IsClosed (⋂ a ∈ i, eval a ⁻¹' s a)
tactic: rw [pi_def]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
i : Set ι
s : (a : ι) → Set (π a)
hs : ∀ a ∈ i, IsClosed (s a)
⊢ IsClosed (⋂ a ∈ i, eval a ⁻¹' s a)
state_after: no goals
tactic: exact isClosed_biInter fun a ha => (hs _ ha).preimage (continuous_apply _)
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_tensor'
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : MonoidalCategory C
X Y : C
⊢ (λ_ (X ⊗ Y)).hom = (α_ (𝟙_ C) X Y).inv ≫ ((λ_ X).hom ⊗ 𝟙 Y)
state_after: no goals
tactic: coherence
Theorem: Set.countable_insert
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
a : α
⊢ (insert a s).Countable ↔ s.Countable
state_after: no goals
tactic: simp only [insert_eq, countable_union, countable_singleton, true_and_iff]
Theorem: CategoryTheory.Functor.isZero_rightDerived_obj_injective_succ
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u_1
inst✝⁵ : Category.{u_2, u_1} D
inst✝⁴ : Abelian C
inst✝³ : HasInjectiveResolutions C
inst✝² : Abelian D
F : C ⥤ D
inst✝¹ : F.Additive
n : ℕ
X : C
inst✝ : Injective X
⊢ IsZero ((F.rightDerived (n + 1)).obj X)
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u_1
inst✝⁵ : Category.{u_2, u_1} D
inst✝⁴ : Abelian C
inst✝³ : HasInjectiveResolutions C
inst✝² : Abelian D
F : C ⥤ D
inst✝¹ : F.Additive
n : ℕ
X : C
inst✝ : Injective X
⊢ IsZero
    ((HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) (n + 1)).obj
      ((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj (InjectiveResolution.self X).cocomplex))
tactic: refine IsZero.of_iso ?_ ((InjectiveResolution.self X).isoRightDerivedObj F (n + 1))
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u_1
inst✝⁵ : Category.{u_2, u_1} D
inst✝⁴ : Abelian C
inst✝³ : HasInjectiveResolutions C
inst✝² : Abelian D
F : C ⥤ D
inst✝¹ : F.Additive
n : ℕ
X : C
inst✝ : Injective X
⊢ IsZero
    ((HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) (n + 1)).obj
      ((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj (InjectiveResolution.self X).cocomplex))
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u_1
inst✝⁵ : Category.{u_2, u_1} D
inst✝⁴ : Abelian C
inst✝³ : HasInjectiveResolutions C
inst✝² : Abelian D
F : C ⥤ D
inst✝¹ : F.Additive
n : ℕ
X : C
inst✝ : Injective X
⊢ ((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj (InjectiveResolution.self X).cocomplex).ExactAt (n + 1)
tactic: erw [← HomologicalComplex.exactAt_iff_isZero_homology]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u_1
inst✝⁵ : Category.{u_2, u_1} D
inst✝⁴ : Abelian C
inst✝³ : HasInjectiveResolutions C
inst✝² : Abelian D
F : C ⥤ D
inst✝¹ : F.Additive
n : ℕ
X : C
inst✝ : Injective X
⊢ ((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj (InjectiveResolution.self X).cocomplex).ExactAt (n + 1)
state_after: no goals
tactic: exact ShortComplex.exact_of_isZero_X₂ _ (F.map_isZero (by apply isZero_zero))
Theorem: BoxIntegral.Box.not_disjoint_coe_iff_nonempty_inter
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J : Box ι
x y : ι → ℝ
⊢ ¬Disjoint ↑I ↑J ↔ (↑I ∩ ↑J).Nonempty
state_after: no goals
tactic: rw [disjoint_coe, Set.not_disjoint_iff_nonempty_inter]
Theorem: Cardinal.ord_aleph_eq_enum_card
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: ⊢ ord ∘ aleph = enumOrd {b | b.card.ord = b ∧ ω ≤ b}
state_after: ⊢ StrictMono (ord ∘ aleph) ∧ range (ord ∘ aleph) = {b | b.card.ord = b ∧ ω ≤ b}
tactic: rw [← eq_enumOrd _ ord_card_unbounded']
state_before: ⊢ StrictMono (ord ∘ aleph) ∧ range (ord ∘ aleph) = {b | b.card.ord = b ∧ ω ≤ b}
state_after: case right

⊢ range (ord ∘ aleph) = {b | b.card.ord = b ∧ ω ≤ b}
tactic: use aleph_isNormal.strictMono
state_before: case right

⊢ range (ord ∘ aleph) = {b | b.card.ord = b ∧ ω ≤ b}
state_after: case right

⊢ (∀ (a : Ordinal.{u_1}), (ord ∘ aleph) a ∈ {b | b.card.ord = b ∧ ω ≤ b}) ∧
    ∀ b ∈ {b | b.card.ord = b ∧ ω ≤ b}, ∃ a, (ord ∘ aleph) a = b
tactic: rw [range_eq_iff]
state_before: case right

⊢ (∀ (a : Ordinal.{u_1}), (ord ∘ aleph) a ∈ {b | b.card.ord = b ∧ ω ≤ b}) ∧
    ∀ b ∈ {b | b.card.ord = b ∧ ω ≤ b}, ∃ a, (ord ∘ aleph) a = b
state_after: case right.refine_1
a : Ordinal.{u_1}
⊢ ((ord ∘ aleph) a).card.ord = (ord ∘ aleph) a

case right.refine_2
a : Ordinal.{u_1}
⊢ ω ≤ (ord ∘ aleph) a
tactic: refine ⟨fun a => ⟨?_, ?_⟩, fun b hb => eq_aleph_of_eq_card_ord hb.1 hb.2⟩
Theorem: Complex.GammaSeq_add_one_left
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

Proof steps:
state_before: s : ℂ
n : ℕ
hn : n ≠ 0
⊢ (s + 1).GammaSeq n / s = ↑n / (↑n + 1 + s) * s.GammaSeq n
state_after: s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ^ (s + 1) * ↑n ! / ((∏ x ∈ Finset.range n, (s + 1 + ↑x)) * (s + 1 + ↑n) * s) = ↑n / (↑n + 1 + s) * s.GammaSeq n
tactic: conv_lhs => rw [GammaSeq, Finset.prod_range_succ, div_div]
state_before: s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ^ (s + 1) * ↑n ! / ((∏ x ∈ Finset.range n, (s + 1 + ↑x)) * (s + 1 + ↑n) * s) = ↑n / (↑n + 1 + s) * s.GammaSeq n
state_after: s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ^ (s + 1) * ↑n ! / ((∏ x ∈ Finset.range n, (s + 1 + ↑x)) * (s + 1 + ↑n) * s) =
    ↑n * ↑n ^ s * ↑n ! / ((∏ k ∈ Finset.range n, (s + ↑(k + 1))) * (↑n + 1 + s) * s)
tactic: conv_rhs =>
    rw [GammaSeq, Finset.prod_range_succ', Nat.cast_zero, add_zero, div_mul_div_comm, ← mul_assoc,
      ← mul_assoc, mul_comm _ (Finset.prod _ _)]
state_before: s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ^ (s + 1) * ↑n ! / ((∏ x ∈ Finset.range n, (s + 1 + ↑x)) * (s + 1 + ↑n) * s) =
    ↑n * ↑n ^ s * ↑n ! / ((∏ k ∈ Finset.range n, (s + ↑(k + 1))) * (↑n + 1 + s) * s)
state_after: case e_a.e_a
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ↑n ^ (s + 1) = ↑n * ↑n ^ s

case e_a.e_a.e_a
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ∏ x ∈ Finset.range n, (s + 1 + ↑x) = ∏ k ∈ Finset.range n, (s + ↑(k + 1))

case e_a.e_a.e_a
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ s + 1 + ↑n = ↑n + 1 + s
tactic: congr 3
Theorem: Set.vadd_set_compl
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s t A B : Set β
a : α
x : β
⊢ a • sᶜ = (a • s)ᶜ
state_after: no goals
tactic: simp_rw [Set.compl_eq_univ_diff, smul_set_sdiff, smul_set_univ]
Theorem: Real.arcsin_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x y : ℝ
⊢ sin (-(π / 2)) = -1
state_after: no goals
tactic: rw [sin_neg, sin_pi_div_two]
Theorem: LucasLehmer.two_lt_q
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: p' : ℕ
⊢ 2 < q (p' + 2)
state_after: case refine_1
p' : ℕ
⊢ 1 < p' + 2

case refine_2
p' : ℕ
⊢ (mersenne (p' + 2)).minFac ≠ 2
tactic: refine (minFac_prime (one_lt_mersenne.2 ?_).ne').two_le.lt_of_ne' ?_
Theorem: Set.range_pair_subset
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
⊢ (range fun x => (f x, g x)) ⊆ range f ×ˢ range g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
this : (fun x => (f x, g x)) = Prod.map f g ∘ fun x => (x, x)
⊢ (range fun x => (f x, g x)) ⊆ range f ×ˢ range g
tactic: have : (fun x => (f x, g x)) = Prod.map f g ∘ fun x => (x, x) := funext fun x => rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
this : (fun x => (f x, g x)) = Prod.map f g ∘ fun x => (x, x)
⊢ (range fun x => (f x, g x)) ⊆ range f ×ˢ range g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
this : (fun x => (f x, g x)) = Prod.map f g ∘ fun x => (x, x)
⊢ range (Prod.map f g ∘ fun x => (x, x)) ⊆ range (Prod.map f g)
tactic: rw [this, ← range_prod_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
f : α → β
g : α → γ
this : (fun x => (f x, g x)) = Prod.map f g ∘ fun x => (x, x)
⊢ range (Prod.map f g ∘ fun x => (x, x)) ⊆ range (Prod.map f g)
state_after: no goals
tactic: apply range_comp_subset_range
Theorem: Nat.base_pow_length_digits_le'
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b m : ℕ
hm : m ≠ 0
⊢ (b + 2) ^ ((b + 2).digits m).length ≤ (b + 2) * m
state_after: n b m : ℕ
hm : m ≠ 0
this : (b + 2).digits m ≠ []
⊢ (b + 2) ^ ((b + 2).digits m).length ≤ (b + 2) * m
tactic: have : digits (b + 2) m ≠ [] := digits_ne_nil_iff_ne_zero.mpr hm
state_before: n b m : ℕ
hm : m ≠ 0
this : (b + 2).digits m ≠ []
⊢ (b + 2) ^ ((b + 2).digits m).length ≤ (b + 2) * m
state_after: case h.e'_4.h.e'_6
n b m : ℕ
hm : m ≠ 0
this : (b + 2).digits m ≠ []
⊢ m = ofDigits (b + 2) ((b + 2).digits m)
tactic: convert @pow_length_le_mul_ofDigits b (digits (b+2) m)
    this (getLast_digit_ne_zero _ hm)
state_before: case h.e'_4.h.e'_6
n b m : ℕ
hm : m ≠ 0
this : (b + 2).digits m ≠ []
⊢ m = ofDigits (b + 2) ((b + 2).digits m)
state_after: no goals
tactic: rw [ofDigits_digits]
Theorem: strictMonoOn_of_deriv_pos
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
⊢ StrictMonoOn f D
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
⊢ x < y → f x < f y
tactic: intro x hx y hy
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
⊢ x < y → f x < f y
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
this : DifferentiableOn ℝ f (interior D)
⊢ x < y → f x < f y
tactic: have : DifferentiableOn ℝ f (interior D) := fun z hz =>
    (differentiableAt_of_deriv_ne_zero (hf' z hz).ne').differentiableWithinAt
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : ∀ x ∈ interior D, 0 < deriv f x
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
this : DifferentiableOn ℝ f (interior D)
⊢ x < y → f x < f y
state_after: no goals
tactic: simpa only [zero_mul, sub_pos] using
    hD.mul_sub_lt_image_sub_of_lt_deriv hf this hf' x hx y hy
Theorem: MvPowerSeries.one_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n✝ : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
n : σ →₀ ℕ
⊢ (coeff R n) (1 * φ) = (coeff R n) φ
state_after: no goals
tactic: simpa using coeff_add_monomial_mul 0 n φ 1
Theorem: CategoryTheory.Subgroupoid.IsNormal.vertexSubgroup
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * x * y⁻¹ ∈ S.vertexSubgroup cS
state_after: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * (x * y⁻¹) ∈ S.vertexSubgroup cS
tactic: rw [mul_assoc]
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
Sn : S.IsNormal
c : C
cS : c ∈ S.objs
x : c ⟶ c
hx : x ∈ S.vertexSubgroup cS
y : c ⟶ c
⊢ y * (x * y⁻¹) ∈ S.vertexSubgroup cS
state_after: no goals
tactic: exact Sn.conj' y hx