ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: continuum_le_cardinal_of_module
File: Mathlib/Topology/Algebra/Module/Cardinality.lean

Proof steps:
state_before: 𝕜 : Type u
E : Type v
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : CompleteSpace 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : Nontrivial E
⊢ 𝔠 ≤ #E
state_after: 𝕜 : Type u
E : Type v
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : CompleteSpace 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : Nontrivial E
A : lift.{v, u} 𝔠 ≤ lift.{v, u} #𝕜
⊢ 𝔠 ≤ #E
tactic: have A : lift.{v} (𝔠 : Cardinal.{u}) ≤ lift.{v} (#𝕜) := by
    simpa using continuum_le_cardinal_of_nontriviallyNormedField 𝕜
state_before: 𝕜 : Type u
E : Type v
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : CompleteSpace 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
inst✝ : Nontrivial E
A : lift.{v, u} 𝔠 ≤ lift.{v, u} #𝕜
⊢ 𝔠 ≤ #E
state_after: no goals
tactic: simpa using A.trans (Cardinal.mk_le_of_module 𝕜 E)
Theorem: WeierstrassCurve.Jacobian.addX_self
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
⊢ W'.addX P P = 0
state_after: no goals
tactic: linear_combination (norm := (rw [addX]; ring1)) -2 * P z ^ 2 * (equation_iff _).mp hP
Theorem: FiniteField.X_pow_card_sub_X_natDegree_eq
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
inst✝² : Field K
inst✝¹ : Fintype K
K' : Type u_3
inst✝ : Field K'
p n : ℕ
hp : 1 < p
⊢ (X ^ p - X).natDegree = p
state_after: K : Type u_1
R : Type u_2
inst✝² : Field K
inst✝¹ : Fintype K
K' : Type u_3
inst✝ : Field K'
p n : ℕ
hp : 1 < p
h1 : X.degree < (X ^ p).degree
⊢ (X ^ p - X).natDegree = p
tactic: have h1 : (X : K'[X]).degree < (X ^ p : K'[X]).degree := by
    rw [degree_X_pow, degree_X]
    exact mod_cast hp
state_before: K : Type u_1
R : Type u_2
inst✝² : Field K
inst✝¹ : Fintype K
K' : Type u_3
inst✝ : Field K'
p n : ℕ
hp : 1 < p
h1 : X.degree < (X ^ p).degree
⊢ (X ^ p - X).natDegree = p
state_after: no goals
tactic: rw [natDegree_eq_of_degree_eq (degree_sub_eq_left_of_degree_lt h1), natDegree_X_pow]
Theorem: harmonic_not_int
File: Mathlib/NumberTheory/Harmonic/Int.lean

Proof steps:
state_before: n : ℕ
h : 2 ≤ n
⊢ ¬(harmonic n).isInt = true
state_after: n : ℕ
h : 2 ≤ n
⊢ 1 < padicNorm 2 (harmonic n)
tactic: apply padicNorm.not_int_of_not_padic_int 2
state_before: n : ℕ
h : 2 ≤ n
⊢ 1 < padicNorm 2 (harmonic n)
state_after: n : ℕ
h : 2 ≤ n
⊢ 1 < ↑2 ^ Nat.log 2 n
tactic: rw [padicNorm.eq_zpow_of_nonzero (harmonic_pos (ne_zero_of_lt h)).ne',
      padicValRat_two_harmonic, neg_neg, zpow_natCast]
state_before: n : ℕ
h : 2 ≤ n
⊢ 1 < ↑2 ^ Nat.log 2 n
state_after: no goals
tactic: exact one_lt_pow one_lt_two (Nat.log_pos one_lt_two h).ne'
Theorem: Sum.eq_right_iff_getRight_eq
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
b : β
⊢ x = inr b ↔ ∃ h, x.getRight h = b
state_after: no goals
tactic: cases x <;> simp
Theorem: LinearMap.BilinForm.toLin_restrict_ker_eq_inf_orthogonal
File: Mathlib/LinearAlgebra/BilinearForm/Orthogonal.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R M₂'
B : BilinForm K V
W : Subspace K V
b : B.IsRefl
⊢ Submodule.map (Submodule.subtype W) (ker (domRestrict B W)) = W ⊓ B.orthogonal ⊤
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R M₂'
B : BilinForm K V
W : Subspace K V
b : B.IsRefl
x : V
⊢ x ∈ Submodule.map (Submodule.subtype W) (ker (domRestrict B W)) ↔ x ∈ W ⊓ B.orthogonal ⊤
tactic: ext x
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R M₂'
B : BilinForm K V
W : Subspace K V
b : B.IsRefl
x : V
⊢ x ∈ Submodule.map (Submodule.subtype W) (ker (domRestrict B W)) ↔ x ∈ W ⊓ B.orthogonal ⊤
state_after: case h.mp
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R M₂'
B : BilinForm K V
W : Subspace K V
b : B.IsRefl
x : V
hx : x ∈ Submodule.map (Submodule.subtype W) (ker (domRestrict B W))
⊢ x ∈ W ⊓ B.orthogonal ⊤

case h.mpr
R : Type u_1
M : Type u_2
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R₁ M₁
V : Type u_5
K : Type u_6
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
M₂' : Type u_7
inst✝¹ : AddCommMonoid M₂'
inst✝ : Module R M₂'
B : BilinForm K V
W : Subspace K V
b : B.IsRefl
x : V
hx : x ∈ W ⊓ B.orthogonal ⊤
⊢ x ∈ Submodule.map (Submodule.subtype W) (ker (domRestrict B W))
tactic: constructor <;> intro hx
Theorem: QuotientAddGroup.rightRel_apply
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, ↑a * y = x) ↔ ∃ a, y * x⁻¹ = ↑a⁻¹
state_after: no goals
tactic: simp only [mul_inv_eq_iff_eq_mul, Subgroup.coe_inv, eq_inv_mul_iff_mul_eq]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
x y : α
⊢ (∃ a, y * x⁻¹ = ↑a⁻¹) ↔ y * x⁻¹ ∈ s
state_after: no goals
tactic: simp [exists_inv_mem_iff_exists_mem]
Theorem: le_map_add_map_sub'
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Group α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : GroupSeminormClass F α β
f : F
x y : α
⊢ f x ≤ f y + f (y / x)
state_after: no goals
tactic: simpa only [add_comm, map_div_rev, div_mul_cancel] using map_mul_le_add f (x / y) y
Theorem: FirstOrder.Language.BoundedFormula.realize_exs
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
φ : L.BoundedFormula α n
v : α → M
⊢ φ.exs.Realize v ↔ ∃ xs, φ.Realize v xs
state_after: case zero
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
v : α → M
φ : L.BoundedFormula α 0
⊢ φ.exs.Realize v ↔ ∃ xs, φ.Realize v xs

case succ
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ : ℕ
T : L.Theory
v : α → M
n : ℕ
ih : ∀ {φ : L.BoundedFormula α n}, φ.exs.Realize v ↔ ∃ xs, φ.Realize v xs
φ : L.BoundedFormula α (n + 1)
⊢ φ.exs.Realize v ↔ ∃ xs, φ.Realize v xs
tactic: induction' n with n ih
Theorem: Combinatorics.Line.vertical_apply
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
v : ι → α
l : Line α ι'
x : α
⊢ (fun x i => ((vertical v l).idxFun i).getD x) x = Sum.elim v ((fun x i => (l.idxFun i).getD x) x)
state_after: case h
η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i✝ : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
v : ι → α
l : Line α ι'
x : α
i : ι ⊕ ι'
⊢ (fun x i => ((vertical v l).idxFun i).getD x) x i = Sum.elim v ((fun x i => (l.idxFun i).getD x) x) i
tactic: funext i
state_before: case h
η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i✝ : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
v : ι → α
l : Line α ι'
x : α
i : ι ⊕ ι'
⊢ (fun x i => ((vertical v l).idxFun i).getD x) x i = Sum.elim v ((fun x i => (l.idxFun i).getD x) x) i
state_after: no goals
tactic: cases i <;> rfl
Theorem: IsLowerSet.card_inter_le_finset
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜
hℬ : IsUpperSet ↑ℬ
⊢ 2 ^ Fintype.card α * (𝒜 ∩ ℬ).card ≤ 𝒜.card * ℬ.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜
hℬ : IsUpperSet ↑ℬ
⊢ 2 ^ Fintype.card α * (ℬ ∩ 𝒜).card ≤ ℬ.card * 𝒜.card
tactic: rw [inter_comm, mul_comm 𝒜.card]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s : Finset α
a : α
inst✝ : Fintype α
h𝒜 : IsLowerSet ↑𝒜
hℬ : IsUpperSet ↑ℬ
⊢ 2 ^ Fintype.card α * (ℬ ∩ 𝒜).card ≤ ℬ.card * 𝒜.card
state_after: no goals
tactic: exact hℬ.card_inter_le_finset h𝒜
Theorem: CategoryTheory.Functor.final_iff_isFiltered_structuredArrow
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final ↔ ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final → ∀ (d : D), IsFiltered (StructuredArrow d F)
tactic: refine ⟨?_, fun h => final_of_isFiltered_structuredArrow F⟩
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ F.Final → ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
      ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t) →
    ∀ (d : D), IsFiltered (StructuredArrow d F)
tactic: rw [final_iff_of_isFiltered]
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsFilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (d ⟶ F.obj c)) ∧
      ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c), ∃ c' t, s ≫ F.map t = s' ≫ F.map t) →
    ∀ (d : D), IsFiltered (StructuredArrow d F)
state_after: no goals
tactic: exact fun h => isFiltered_structuredArrow_of_isFiltered_of_exists F h.1 h.2
Theorem: Set.Iic_iInf₂
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
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Iic (⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, Iic (f i j)
state_after: no goals
tactic: simp_rw [Iic_iInf]
Theorem: MeasureTheory.Measure.compProd_zero_left
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ✝ η κ : Kernel α β
⊢ 0 ⊗ₘ κ = 0
state_after: no goals
tactic: simp [compProd]
Theorem: Complex.Gammaℝ_add_two
File: Mathlib/Analysis/SpecialFunctions/Gamma/Deligne.lean

Proof steps:
state_before: s : ℂ
hs : s ≠ 0
⊢ (s + 2).Gammaℝ = s.Gammaℝ * s / 2 / ↑π
state_after: s : ℂ
hs : s ≠ 0
⊢ ↑π ^ (-(s / 2)) * (↑π)⁻¹ * (s / 2 * Gamma (s / 2)) = ↑π ^ (-s / 2) * Gamma (s / 2) * s / 2 / ↑π
tactic: rw [Gammaℝ_def, Gammaℝ_def, neg_div, add_div, neg_add, div_self two_ne_zero,
    Gamma_add_one _ (div_ne_zero hs two_ne_zero),
    cpow_add _ _ (ofReal_ne_zero.mpr pi_ne_zero), cpow_neg_one]
state_before: s : ℂ
hs : s ≠ 0
⊢ ↑π ^ (-(s / 2)) * (↑π)⁻¹ * (s / 2 * Gamma (s / 2)) = ↑π ^ (-s / 2) * Gamma (s / 2) * s / 2 / ↑π
state_after: s : ℂ
hs : s ≠ 0
⊢ ↑π ^ (-s / 2) * (s * Gamma (s / 2)) * (2 * ↑π) = ↑π ^ (-s / 2) * Gamma (s / 2) * s * (↑π * 2)
tactic: field_simp [pi_ne_zero]
state_before: s : ℂ
hs : s ≠ 0
⊢ ↑π ^ (-s / 2) * (s * Gamma (s / 2)) * (2 * ↑π) = ↑π ^ (-s / 2) * Gamma (s / 2) * s * (↑π * 2)
state_after: no goals
tactic: ring
Theorem: GenLoop.homotopyFrom_apply
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

Proof steps:
state_before: N : Type u_1
X : Type u_2
inst✝¹ : TopologicalSpace X
x : X
inst✝ : DecidableEq N
i : N
p q : ↑(Ω^ N X x)
H : Path.Homotopy (toLoop i p) (toLoop i q)
⊢ Continuous Subtype.val
state_after: no goals
tactic: continuity
Theorem: Set.encard_diff_add_encard
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s \ t).encard + t.encard = (s ∪ t).encard
state_after: no goals
tactic: rw [← encard_union_eq disjoint_sdiff_left, diff_union_self]
Theorem: PowerBasis.mem_span_pow
File: Mathlib/RingTheory/PowerBasis.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : IsDomain B
inst✝¹ : Algebra A B
K : Type u_6
inst✝ : Field K
x y : S
d : ℕ
hd : d ≠ 0
⊢ y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.natDegree < d ∧ y = (aeval x) f
state_after: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Ring S
inst✝⁵ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : IsDomain B
inst✝¹ : Algebra A B
K : Type u_6
inst✝ : Field K
x y : S
d : ℕ
hd : d ≠ 0
⊢ (∃ f, f.degree < ↑d ∧ y = (aeval x) f) ↔ ∃ f, f.natDegree < d ∧ y = (aeval x) f
tactic: rw [mem_span_pow']
Theorem: MeasureTheory.Measure.le_sum
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f : α → β
μ : ι → Measure α
i : ι
s : Set α
hs : MeasurableSet s
⊢ (μ i) s ≤ (sum μ) s
state_after: no goals
tactic: simpa only [sum_apply μ hs] using ENNReal.le_tsum i
Theorem: val_div_eq_divp
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b c : α
u₁ u₂ : αˣ
⊢ ↑(u₁ / u₂) = ↑u₁ /ₚ u₂
state_after: no goals
tactic: rw [divp, division_def, Units.val_mul]
Theorem: IsOfFinOrder.mono
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 : ℕ
inst✝ : Monoid β
y : β
hx : IsOfFinOrder x
h : orderOf y ∣ orderOf x
⊢ IsOfFinOrder y
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 : ℕ
inst✝ : Monoid β
y : β
hx : 0 < orderOf x
h : orderOf y ∣ orderOf x
⊢ 0 < orderOf y
tactic: rw [← orderOf_pos_iff] at hx ⊢
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 : ℕ
inst✝ : Monoid β
y : β
hx : 0 < orderOf x
h : orderOf y ∣ orderOf x
⊢ 0 < orderOf y
state_after: no goals
tactic: exact Nat.pos_of_dvd_of_pos h hx
Theorem: countable_cover_nhds_of_sigma_compact
File: Mathlib/Topology/Compactness/SigmaCompact.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
f : X → Set X
hf : ∀ (x : X), f x ∈ 𝓝 x
⊢ ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = univ
state_after: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
f : X → Set X
hf : ∀ (x : X), f x ∈ 𝓝[univ] x
⊢ ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = univ
tactic: simp only [← nhdsWithin_univ] at hf
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : SigmaCompactSpace X
f : X → Set X
hf : ∀ (x : X), f x ∈ 𝓝[univ] x
⊢ ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = univ
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : SigmaCompactSpace X
f : X → Set X
hf : ∀ (x : X), f x ∈ 𝓝[univ] x
s : Set X
hsc : s.Countable
hsU : univ ⊆ ⋃ x ∈ s, f x
⊢ ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = univ
tactic: rcases countable_cover_nhdsWithin_of_sigma_compact isClosed_univ fun x _ => hf x with
    ⟨s, -, hsc, hsU⟩
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s✝ t : Set X
inst✝ : SigmaCompactSpace X
f : X → Set X
hf : ∀ (x : X), f x ∈ 𝓝[univ] x
s : Set X
hsc : s.Countable
hsU : univ ⊆ ⋃ x ∈ s, f x
⊢ ∃ s, s.Countable ∧ ⋃ x ∈ s, f x = univ
state_after: no goals
tactic: exact ⟨s, hsc, univ_subset_iff.1 hsU⟩
Theorem: CategoryTheory.Equivalence.funInvIdAssoc_inv_app
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (e.funInvIdAssoc F).inv.app X = F.map (e.unit.app X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (𝟙 (F.obj X) ≫ F.map (e.unitIso.hom.app X)) ≫ 𝟙 (F.obj (e.inverse.obj (e.functor.obj X))) = F.map (e.unit.app X)
tactic: dsimp [funInvIdAssoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : C ⥤ E
X : C
⊢ (𝟙 (F.obj X) ≫ F.map (e.unitIso.hom.app X)) ≫ 𝟙 (F.obj (e.inverse.obj (e.functor.obj X))) = F.map (e.unit.app X)
state_after: no goals
tactic: aesop_cat
Theorem: Nat.Partition.indiscrete_parts
File: Mathlib/Combinatorics/Enumerative/Partition.lean

Proof steps:
state_before: n✝ : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
n : ℕ
hn : n ≠ 0
⊢ (indiscrete n).parts = {n}
state_after: no goals
tactic: simp [indiscrete, filter_eq_self, hn]
Theorem: HurwitzZeta.hasSum_int_evenKernel₀
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t - if ↑a = 0 then 1 else 0)
state_after: a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t - if ↑a = 0 then 1 else 0)
tactic: haveI := Classical.propDecidable
state_before: a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t - if ↑a = 0 then 1 else 0)
state_after: a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t))
    (evenKernel (↑a) t - if ∃ n, ↑n = a then 1 else 0)
tactic: simp_rw [AddCircle.coe_eq_zero_iff, zsmul_one]
state_before: a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t))
    (evenKernel (↑a) t - if ∃ n, ↑n = a then 1 else 0)
state_after: case pos
a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
h : ∃ n, ↑n = a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t - 1)

case neg
a t : ℝ
ht : 0 < t
this : (a : Prop) → Decidable a
h : ¬∃ n, ↑n = a
⊢ HasSum (fun n => if ↑n + a = 0 then 0 else rexp (-π * (↑n + a) ^ 2 * t)) (evenKernel (↑a) t - 0)
tactic: split_ifs with h
Theorem: lTensor.inverse_apply
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
y : Q ⊗[R] N
⊢ (inverse Q hfg hg) ((lTensor Q g) y) = Submodule.Quotient.mk y
state_after: no goals
tactic: rw [lTensor.inverse, lTensor.inverse_of_rightInverse_apply]
Theorem: Subgroup.IsComplement.equiv_snd_eq_one_of_mem_of_one_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ (hST.equiv g).2 = ⟨1, h1⟩
state_after: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ ↑(hST.equiv g).2 = ↑⟨1, h1⟩
tactic: ext
state_before: case a
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
hg : g ∈ S
⊢ ↑(hST.equiv g).2 = ↑⟨1, h1⟩
state_after: no goals
tactic: rw [equiv_snd_eq_inv_mul, equiv_fst_eq_self_of_mem_of_one_mem _ h1 hg, inv_mul_self]
Theorem: Matrix.toMvPolynomial_zero
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
⊢ toMvPolynomial 0 = 0
state_after: case h.a
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x✝ : m
m✝ : n →₀ ℕ
⊢ coeff m✝ (toMvPolynomial 0 x✝) = coeff m✝ (0 x✝)
tactic: ext
state_before: case h.a
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
x✝ : m
m✝ : n →₀ ℕ
⊢ coeff m✝ (toMvPolynomial 0 x✝) = coeff m✝ (0 x✝)
state_after: no goals
tactic: simp only [toMvPolynomial, zero_apply, map_zero, Finset.sum_const_zero, Pi.zero_apply]
Theorem: Nat.sqrt_le_add
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ n ≤ n.sqrt * n.sqrt + n.sqrt + n.sqrt
state_after: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ n ≤ n.sqrt.succ * n.sqrt + n.sqrt
tactic: rw [← succ_mul]
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
⊢ n ≤ n.sqrt.succ * n.sqrt + n.sqrt
state_after: no goals
tactic: exact le_of_lt_succ (lt_succ_sqrt n)
Theorem: Cardinal.toNat_eq_zero
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c d : Cardinal.{u}
⊢ toNat c = 0 ↔ c = 0 ∨ ℵ₀ ≤ c
state_after: no goals
tactic: rw [← toNat_toENat, ENat.toNat_eq_zero, toENat_eq_zero, toENat_eq_top]