ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Asymptotics.IsTheta.isBoundedUnder_le_iff
File: Mathlib/Analysis/Asymptotics/Theta.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
R : Type u_12
R' : Type u_13
𝕜 : Type u_14
𝕜' : Type u_15
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
h : f' =Θ[l] g'
⊢ IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ f') ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ g')
state_after: no goals
tactic: simp only [← isBigO_const_of_ne (one_ne_zero' ℝ), h.isBigO_congr_left]
Theorem: CoxeterSystem.IsReflection.isLeftInversion_mul_right_iff
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
t : W
ht : cs.IsReflection t
w : W
⊢ cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t
state_after: no goals
tactic: rw [← isRightInversion_inv_iff, ← isRightInversion_inv_iff, mul_inv_rev, ht.inv,
    ht.isRightInversion_mul_left_iff]
Theorem: Matrix.inv_sub_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B✝ A B : Matrix n n α
h : IsUnit A ↔ IsUnit B
⊢ A⁻¹ - B⁻¹ = A⁻¹ * (B - A) * B⁻¹
state_after: no goals
tactic: simpa only [nonsing_inv_eq_ring_inverse] using Ring.inverse_sub_inverse h
Theorem: WeierstrassCurve.Jacobian.dblZ_smul
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
u : R
⊢ W'.dblZ (u • P) = u ^ 4 * W'.dblZ P
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ u * P z * (u ^ 3 * P y - u ^ 3 * W'.negY P) = u ^ 4 * (P z * (P y - W'.negY P))
tactic: simp only [dblZ, negY_smul, smul_fin3_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ u * P z * (u ^ 3 * P y - u ^ 3 * W'.negY P) = u ^ 4 * (P z * (P y - W'.negY P))
state_after: no goals
tactic: ring1
Theorem: Nat.even_sub'
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ (Odd m ↔ Odd n)
state_after: no goals
tactic: rw [even_sub h, even_iff_not_odd, even_iff_not_odd, not_iff_not]
Theorem: IsOrderRightAdjoint.comp_orderIso
File: Mathlib/Order/SemiconjSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
⊢ IsOrderRightAdjoint (f ∘ ⇑e) (⇑e.symm ∘ g)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB {x | (f ∘ ⇑e) x ≤ y} ((⇑e.symm ∘ g) y)
tactic: intro y
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB {x | (f ∘ ⇑e) x ≤ y} ((⇑e.symm ∘ g) y)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB (⇑e ⁻¹' {x | f x ≤ y}) (e.symm (g y))
tactic: change IsLUB (e ⁻¹' { x | f x ≤ y }) (e.symm (g y))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB (⇑e ⁻¹' {x | f x ≤ y}) (e.symm (g y))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB {x | f x ≤ y} (g y)
tactic: rw [e.isLUB_preimage, e.apply_symm_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
g : β → α
h : IsOrderRightAdjoint f g
e : γ ≃o α
y : β
⊢ IsLUB {x | f x ≤ y} (g y)
state_after: no goals
tactic: exact h y
Theorem: Units.continuousOn_zpow₀_spectrum
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹¹ : Semifield R
inst✝¹⁰ : StarRing R
inst✝⁹ : MetricSpace R
inst✝⁸ : TopologicalSemiring R
inst✝⁷ : ContinuousStar R
inst✝⁶ : HasContinuousInv₀ R
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra R A
inst✝¹ : ContinuousFunctionalCalculus R p
f : R → R
a✝ : A
inst✝ : UniqueContinuousFunctionalCalculus R A
a : Aˣ
n : ℤ
⊢ spectrum R ↑a ⊆ {0}ᶜ
state_after: no goals
tactic: simpa only [Set.subset_compl_singleton_iff] using spectrum.zero_not_mem R a.isUnit
Theorem: HasDerivAtFilter.congr_of_eventuallyEq
File: Mathlib/Analysis/Calculus/Deriv/Basic.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
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
h : HasDerivAtFilter f f' x L
hL : f₁ =ᶠ[L] f
hx : f₁ x = f x
⊢ HasDerivAtFilter f₁ f' x L
state_after: no goals
tactic: rwa [hL.hasDerivAtFilter_iff hx rfl]
Theorem: LieSubmodule.mk_eq_top_iff
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
N : Submodule R M
h : ∀ {x : L} {m : M}, m ∈ N.carrier → ⁅x, m⁆ ∈ N.carrier
⊢ { toSubmodule := N, lie_mem := h } = ⊤ ↔ N = ⊤
state_after: no goals
tactic: rw [← coe_toSubmodule_eq_iff, top_coeSubmodule]
Theorem: one_geom_sum
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Semiring α
n : ℕ
⊢ ∑ i ∈ range n, 1 ^ i = ↑n
state_after: no goals
tactic: simp
Theorem: RingQuot.Rel.sub_right
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R✝ : Type uR
inst✝⁴ : Semiring R✝
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
R : Type uR
inst✝ : Ring R
r : R → R → Prop
a b c : R
h : Rel r b c
⊢ Rel r (a - b) (a - c)
state_after: no goals
tactic: simp only [sub_eq_add_neg, h.neg.add_right]
Theorem: Ordinal.lt_nmul_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c d : Ordinal.{u}
⊢ c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
state_after: case refine_1
a b c d : Ordinal.{u}
h : c < a ⨳ b
⊢ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'

case refine_2
a b c d : Ordinal.{u}
⊢ (∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b') → c < a ⨳ b
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: mem_rootsOfUnity_iff_mem_nthRoots
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ+
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : Rˣ
⊢ ζ ∈ rootsOfUnity k R ↔ ↑ζ ∈ nthRoots (↑k) 1
state_after: no goals
tactic: simp only [mem_rootsOfUnity, mem_nthRoots k.pos, Units.ext_iff, Units.val_one,
    Units.val_pow_eq_pow_val]
Theorem: CategoryTheory.IsIso.of_isIso_fac_right
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso h
w : f ≫ g = h
⊢ IsIso f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
⊢ IsIso f
tactic: rw [← w] at hh
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
⊢ IsIso f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
this : IsIso (f ≫ g)
⊢ IsIso f
tactic: haveI := hh
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ g✝ : X✝ ⟶ Y✝
h✝ : Y✝ ⟶ Z✝
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
h : X ⟶ Z
inst✝ : IsIso g
hh : IsIso (f ≫ g)
w : f ≫ g = h
this : IsIso (f ≫ g)
⊢ IsIso f
state_after: no goals
tactic: exact of_isIso_comp_right f g
Theorem: Function.Periodic.const_add
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddSemigroup α
h : Periodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = (fun x => f (a + x)) x
state_after: no goals
tactic: simpa [add_assoc] using h (a + x)
Theorem: minpoly.ker_aeval_eq_span_minpoly
File: Mathlib/FieldTheory/Minpoly/Field.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
⊢ RingHom.ker (Polynomial.aeval x) = Submodule.span A[X] {minpoly A x}
state_after: case h
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
⊢ p ∈ RingHom.ker (Polynomial.aeval x) ↔ p ∈ Submodule.span A[X] {minpoly A x}
tactic: ext p
state_before: case h
A : Type u_1
B : Type u_2
inst✝² : Field A
inst✝¹ : Ring B
inst✝ : Algebra A B
x : B
p : A[X]
⊢ p ∈ RingHom.ker (Polynomial.aeval x) ↔ p ∈ Submodule.span A[X] {minpoly A x}
state_after: no goals
tactic: simp_rw [RingHom.mem_ker, ← minpoly.dvd_iff, Submodule.mem_span_singleton,
    dvd_iff_exists_eq_mul_left, smul_eq_mul, eq_comm (a := p)]
Theorem: Polynomial.degree_C_mul_X_pow_le
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
a : R
⊢ (C a * X ^ n).degree ≤ ↑n
state_after: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
a : R
⊢ ((monomial n) a).degree ≤ ↑n
tactic: rw [C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
a : R
⊢ ((monomial n) a).degree ≤ ↑n
state_after: no goals
tactic: apply degree_monomial_le
Theorem: CategoryTheory.ShortComplex.liftCycles_comp_cyclesMap
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.210393, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝¹ : S.HasLeftHomology
φ : S ⟶ S₁
inst✝ : S₁.HasLeftHomology
⊢ (k ≫ φ.τ₂) ≫ S₁.g = 0
state_after: no goals
tactic: rw [assoc, φ.comm₂₃, reassoc_of% hk, zero_comp]
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝¹ : S.HasLeftHomology
φ : S ⟶ S₁
inst✝ : S₁.HasLeftHomology
⊢ S.liftCycles k hk ≫ cyclesMap φ = S₁.liftCycles (k ≫ φ.τ₂) ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Nat.frequently_odd
File: Mathlib/Order/Filter/ModEq.lean

Proof steps:
state_before: ⊢ ∃ᶠ (m : ℕ) in atTop, Odd m
state_after: no goals
tactic: simpa only [odd_iff] using frequently_mod_eq one_lt_two
Theorem: List.mem_eraseIdx_iff_get
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

Proof steps:
state_before: α : Type u
β : Type v
x : α
l : List α
k : Nat
⊢ x ∈ l.eraseIdx k ↔ ∃ i, ↑i ≠ k ∧ l.get i = x
state_after: no goals
tactic: simp [mem_eraseIdx_iff_getElem]
Theorem: three'_nsmul
File: Mathlib/Algebra/Group/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
⊢ a ^ 3 = a * a * a
state_after: no goals
tactic: rw [pow_succ, pow_two]
Theorem: SimpleGraph.Walk.isPath_iff_eq_nil
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v w u : V
p : G.Walk u u
⊢ p.IsPath ↔ p = nil
state_after: no goals
tactic: cases p <;> simp [IsPath.nil]
Theorem: exists_succ_iterate_iff_le
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (∃ n, succ^[n] a = b) ↔ a ≤ b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (∃ n, succ^[n] a = b) → a ≤ b
tactic: refine ⟨?_, exists_succ_iterate_of_le⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (∃ n, succ^[n] a = b) → a ≤ b
state_after: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a : α
n : ℕ
⊢ a ≤ succ^[n] a
tactic: rintro ⟨n, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a : α
n : ℕ
⊢ a ≤ succ^[n] a
state_after: no goals
tactic: exact id_le_iterate_of_id_le le_succ n a
Theorem: MeasureTheory.Lp.coeFn_negPart
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
g : E → F
c : ℝ≥0
f : ↥(Lp ℝ p μ)
a : α
h : ↑↑(negPart f) a = max (-↑↑f a) 0
⊢ ↑↑(negPart f) a = -min (↑↑f a) 0
state_after: no goals
tactic: rw [h, ← max_neg_neg, neg_zero]
Theorem: IsCyclotomicExtension.numberField
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
h : NumberField K
inst✝¹ : Finite ↑S
inst✝ : IsCyclotomicExtension S K L
⊢ FiniteDimensional ℚ L
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
h : NumberField K
inst✝¹ : Finite ↑S
inst✝ : IsCyclotomicExtension S K L
this : CharZero L
⊢ FiniteDimensional ℚ L
tactic: haveI := charZero_of_injective_algebraMap (algebraMap K L).injective
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
h : NumberField K
inst✝¹ : Finite ↑S
inst✝ : IsCyclotomicExtension S K L
this : CharZero L
⊢ FiniteDimensional ℚ L
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
h : NumberField K
inst✝¹ : Finite ↑S
inst✝ : IsCyclotomicExtension S K L
this✝ : CharZero L
this : Module.Finite K L
⊢ FiniteDimensional ℚ L
tactic: haveI := IsCyclotomicExtension.finite S K L
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
h : NumberField K
inst✝¹ : Finite ↑S
inst✝ : IsCyclotomicExtension S K L
this✝ : CharZero L
this : Module.Finite K L
⊢ FiniteDimensional ℚ L
state_after: no goals
tactic: exact Module.Finite.trans K _
Theorem: CategoryTheory.ShortComplex.HomotopyEquiv.refl_hom
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.237910, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
S : ShortComplex C
⊢ 𝟙 S ≫ 𝟙 S = 𝟙 S
state_after: no goals
tactic: simp
Theorem: Finsupp.neLocus_self_sub_right
File: Mathlib/Data/Finsupp/NeLocus.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ f.neLocus (f - g) = g.support
state_after: no goals
tactic: rw [sub_eq_add_neg, neLocus_self_add_right, support_neg]
Theorem: HurwitzZeta.hasSum_int_cosKernel
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) ↑(cosKernel (↑a) t)
state_after: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) (jacobiTheta₂ (↑a) (I * ↑t))
tactic: rw [cosKernel_def a t]
state_before: a t : ℝ
ht : 0 < t
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) (jacobiTheta₂ (↑a) (I * ↑t))
state_after: a t : ℝ
ht : 0 < t
this : ∀ (n : ℤ), cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂_term n (↑a) (I * ↑t)
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) (jacobiTheta₂ (↑a) (I * ↑t))
tactic: have (n : ℤ) : cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) =
      jacobiTheta₂_term n (↑a) (I * ↑t) := by
    rw [jacobiTheta₂_term, ofReal_exp, ← Complex.exp_add]
    push_cast
    ring_nf
    simp only [I_sq, mul_neg, neg_mul, mul_one, sub_eq_add_neg]
state_before: a t : ℝ
ht : 0 < t
this : ∀ (n : ℤ), cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂_term n (↑a) (I * ↑t)
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t))) (jacobiTheta₂ (↑a) (I * ↑t))
state_after: a t : ℝ
ht : 0 < t
this : ∀ (n : ℤ), cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂_term n (↑a) (I * ↑t)
⊢ HasSum (fun n => jacobiTheta₂_term n (↑a) (I * ↑t)) (jacobiTheta₂ (↑a) (I * ↑t))
tactic: simp only [this]
state_before: a t : ℝ
ht : 0 < t
this : ∀ (n : ℤ), cexp (2 * ↑π * I * ↑a * ↑n) * ↑(rexp (-π * ↑n ^ 2 * t)) = jacobiTheta₂_term n (↑a) (I * ↑t)
⊢ HasSum (fun n => jacobiTheta₂_term n (↑a) (I * ↑t)) (jacobiTheta₂ (↑a) (I * ↑t))
state_after: no goals
tactic: exact hasSum_jacobiTheta₂_term _ (by rwa [I_mul_im, ofReal_re])
Theorem: WithZero.covariantClass_add_le
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Preorder α
a b : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
⊢ CovariantClass (WithZero α) (WithZero α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
state_after: α : Type u_1
inst✝² : Preorder α
a✝ b✝ : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
a b c : WithZero α
hbc : b ≤ c
⊢ a + b ≤ a + c
tactic: refine ⟨fun a b c hbc => ?_⟩
state_before: α : Type u_1
inst✝² : Preorder α
a✝ b✝ : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
a b c : WithZero α
hbc : b ≤ c
⊢ a + b ≤ a + c
state_after: case h₁
α : Type u_1
inst✝² : Preorder α
a b✝ : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
b c : WithZero α
hbc : b ≤ c
⊢ 0 + b ≤ 0 + c

case h₂
α : Type u_1
inst✝² : Preorder α
a b✝ : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
b c : WithZero α
hbc : b ≤ c
a✝ : α
⊢ ↑a✝ + b ≤ ↑a✝ + c
tactic: induction a
state_before: case h₂
α : Type u_1
inst✝² : Preorder α
a b✝ : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
b c : WithZero α
hbc : b ≤ c
a✝ : α
⊢ ↑a✝ + b ≤ ↑a✝ + c
state_after: case h₂.h₁
α : Type u_1
inst✝² : Preorder α
a b : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
c : WithZero α
a✝ : α
hbc : 0 ≤ c
⊢ ↑a✝ + 0 ≤ ↑a✝ + c

case h₂.h₂
α : Type u_1
inst✝² : Preorder α
a b : α
inst✝¹ : AddZeroClass α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
h : ∀ (a : α), 0 ≤ a
c : WithZero α
a✝¹ a✝ : α
hbc : ↑a✝ ≤ c
⊢ ↑a✝¹ + ↑a✝ ≤ ↑a✝¹ + c
tactic: induction b
Theorem: HomologicalComplex₂.totalAux.d₂_eq
File: Mathlib/Algebra/Homology/TotalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ : I₁
i₂ i₂' : I₂
h : c₂.Rel i₂ i₂'
i₁₂ : I₁₂
h' : c₁.π c₂ c₁₂ (i₁, i₂') = i₁₂
⊢ K.d₂ c₁₂ i₁ i₂ i₁₂ =
    c₁.ε₂ c₂ c₁₂ (i₁, i₂) • (K.X i₁).d i₂ i₂' ≫ K.toGradedObject.ιMapObj (c₁.π c₂ c₁₂) (i₁, i₂') i₁₂ h'
state_after: no goals
tactic: rw [d₂_eq' K c₁₂ i₁ h i₁₂, K.toGradedObject.ιMapObjOrZero_eq]
Theorem: Submonoid.LocalizationMap.map_left_cancel
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
c : ↥S
h : f.toMap (x * ↑c) = f.toMap (y * ↑c)
⊢ f.toMap (↑c * x) = f.toMap (↑c * y)
state_after: no goals
tactic: rw [mul_comm _ x, mul_comm _ y, h]
Theorem: CategoryTheory.Quotient.comp_right
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_2
inst✝ : Category.{u_1, u_2} C
r : HomRel C
a b c : C
g : b ⟶ c
a✝ b✝ : C
x : a ⟶ a✝
m₁ m₂ : a✝ ⟶ b✝
y : b✝ ⟶ b
h : r m₁ m₂
⊢ CompClosure r ((x ≫ m₁ ≫ y) ≫ g) ((x ≫ m₂ ≫ y) ≫ g)
state_after: no goals
tactic: simpa using CompClosure.intro x m₁ m₂ (y ≫ g) h
Theorem: Finset.sum_smul_vsub_const_eq_weightedVSubOfPoint_sub
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p₁ : ι → P
p₂ b : P
⊢ ∑ i ∈ s, w i • (p₁ i -ᵥ p₂) = (s.weightedVSubOfPoint p₁ b) w - (∑ i ∈ s, w i) • (p₂ -ᵥ b)
state_after: no goals
tactic: rw [sum_smul_vsub_eq_weightedVSubOfPoint_sub, weightedVSubOfPoint_apply_const]
Theorem: t0Space_iff_uniformity'
File: Mathlib/Topology/UniformSpace/Separation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ T0Space α ↔ Pairwise fun x y => ∃ r ∈ 𝓤 α, (x, y) ∉ r
state_after: no goals
tactic: simp [t0Space_iff_not_inseparable, inseparable_iff_ker_uniformity]