ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: cthickening_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 ≤ δ
x : E
⊢ cthickening ε (Metric.closedBall x δ) = Metric.closedBall x (ε + δ)
state_after: no goals
tactic: rw [← cthickening_singleton _ hδ, cthickening_cthickening hε hδ,
      cthickening_singleton _ (add_nonneg hε hδ)]
Theorem: AffineSubspace.wSameSide_smul_vsub_vadd_left
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
p₁ p₂ x : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : 0 ≤ t
⊢ s.WSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
p₁ p₂ x : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : 0 ≤ t
⊢ SameRay R (t • (x -ᵥ p₁) +ᵥ p₂ -ᵥ p₂) (x -ᵥ p₁)
tactic: refine ⟨p₂, hp₂, p₁, hp₁, ?_⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
p₁ p₂ x : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : 0 ≤ t
⊢ SameRay R (t • (x -ᵥ p₁) +ᵥ p₂ -ᵥ p₂) (x -ᵥ p₁)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
p₁ p₂ x : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : 0 ≤ t
⊢ SameRay R (t • (x -ᵥ p₁)) (x -ᵥ p₁)
tactic: rw [vadd_vsub]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
p₁ p₂ x : P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : 0 ≤ t
⊢ SameRay R (t • (x -ᵥ p₁)) (x -ᵥ p₁)
state_after: no goals
tactic: exact SameRay.sameRay_nonneg_smul_left _ ht
Theorem: SimpleGraph.Walk.IsPath.transfer
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''
p✝ : ?m.46544
u v : V
H : SimpleGraph V
p : G.Walk u v
hp : ∀ e ∈ p.edges, e ∈ H.edgeSet
pp : p.IsPath
⊢ (p.transfer H hp).IsPath
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons _ _ ih =>
    simp only [Walk.transfer, cons_isPath_iff, support_transfer _ ] at pp ⊢
    exact ⟨ih _ pp.1, pp.2⟩
Theorem: List.concat_get_prefix
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ x ++ [y.get ⟨x.length, hl⟩] <+: y
state_after: case h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ x ++ [y.get ⟨x.length, hl⟩] ++ drop (x.length + 1) y = y
tactic: use y.drop (x.length + 1)
state_before: case h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ x ++ [y.get ⟨x.length, hl⟩] ++ drop (x.length + 1) y = y
state_after: case h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] ++ drop (x.length + 1) y = y
tactic: nth_rw 1 [List.prefix_iff_eq_take.mp h]
state_before: case h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] ++ drop (x.length + 1) y = y
state_after: case h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] = take (x.length + 1) y
tactic: convert List.take_append_drop (x.length + 1) y using 2
state_before: case h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] = take (x.length + 1) y
state_after: case h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] = take x.length y ++ [y[x.length]]

case h.e'_2.h.e'_5.h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ x.length < y.length
tactic: rw [← List.take_concat_get, List.concat_eq_append]
state_before: case h.e'_2.h.e'_5
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ take x.length y ++ [y.get ⟨x.length, hl⟩] = take x.length y ++ [y[x.length]]

case h.e'_2.h.e'_5.h
α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x y : List α
h : x <+: y
hl : x.length < y.length
⊢ x.length < y.length
state_after: no goals
tactic: rfl
Theorem: posTangentConeAt_mono
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
⊢ Monotone fun s => posTangentConeAt s a
state_after: case intro.intro.intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s✝ : Set E
a x y✝ : E
s t : Set E
hst : s ≤ t
y : E
c : ℕ → ℝ
d : ℕ → E
hd : ∀ᶠ (n : ℕ) in atTop, a + d n ∈ s
hc : Tendsto c atTop atTop
hcd : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ (fun s => posTangentConeAt s a) t
tactic: rintro s t hst y ⟨c, d, hd, hc, hcd⟩
state_before: case intro.intro.intro.intro
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s✝ : Set E
a x y✝ : E
s t : Set E
hst : s ≤ t
y : E
c : ℕ → ℝ
d : ℕ → E
hd : ∀ᶠ (n : ℕ) in atTop, a + d n ∈ s
hc : Tendsto c atTop atTop
hcd : Tendsto (fun n => c n • d n) atTop (𝓝 y)
⊢ y ∈ (fun s => posTangentConeAt s a) t
state_after: no goals
tactic: exact ⟨c, d, mem_of_superset hd fun h hn => hst hn, hc, hcd⟩
Theorem: Algebra.traceForm_toMatrix
File: Mathlib/RingTheory/Trace/Defs.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : CommRing T
inst✝³ : Algebra R S
inst✝² : Algebra R T
ι κ : Type w
inst✝¹ : Fintype ι
b : Basis ι R S
inst✝ : DecidableEq ι
i j : ι
⊢ (BilinForm.toMatrix b) (traceForm R S) i j = (trace R S) (b i * b j)
state_after: no goals
tactic: rw [BilinForm.toMatrix_apply, traceForm_apply]
Theorem: ExteriorAlgebra.ι_leftInverse
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
⊢ ιInv ((ι R) x) = x
state_after: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
this : Module Rᵐᵒᵖ M := Module.compHom M ((RingHom.id R).fromOpposite ⋯)
⊢ ιInv ((ι R) x) = x
tactic: letI : Module Rᵐᵒᵖ M := Module.compHom _ ((RingHom.id R).fromOpposite mul_comm)
state_before: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
this : Module Rᵐᵒᵖ M := Module.compHom M ((RingHom.id R).fromOpposite ⋯)
⊢ ιInv ((ι R) x) = x
state_after: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
this✝ : Module Rᵐᵒᵖ M := Module.compHom M ((RingHom.id R).fromOpposite ⋯)
this : IsCentralScalar R M
⊢ ιInv ((ι R) x) = x
tactic: haveI : IsCentralScalar R M := ⟨fun r m => rfl⟩
state_before: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
this✝ : Module Rᵐᵒᵖ M := Module.compHom M ((RingHom.id R).fromOpposite ⋯)
this : IsCentralScalar R M
⊢ ιInv ((ι R) x) = x
state_after: no goals
tactic: simp [ιInv]
Theorem: orderOf_inv
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✝ : Group G
x✝ y : G
i : ℤ
x : G
⊢ orderOf x⁻¹ = orderOf x
state_after: no goals
tactic: simp [orderOf_eq_orderOf_iff]
Theorem: NormedAddGroupHom.ker_zero
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
⊢ ker 0 = ⊤
state_after: case h
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ x✝ ∈ ker 0 ↔ x✝ ∈ ⊤
tactic: ext
state_before: case h
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
x✝ : V₁
⊢ x✝ ∈ ker 0 ↔ x✝ ∈ ⊤
state_after: no goals
tactic: simp [mem_ker]
Theorem: MvPolynomial.expand_bind₁
File: Mathlib/Algebra/MvPolynomial/Expand.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
φ : MvPolynomial σ R
⊢ (expand p) ((bind₁ f) φ) = (bind₁ fun i => (expand p) (f i)) φ
state_after: no goals
tactic: rw [← AlgHom.comp_apply, expand_comp_bind₁]
Theorem: List.pairwise_iff_get
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ Pairwise R l ↔ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
state_after: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]) ↔
    ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
tactic: rw [pairwise_iff_getElem]
state_before: α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
⊢ (∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]) ↔
    ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
state_after: case mp
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
⊢ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)

case mpr
α✝ : Type u_1
R : α✝ → α✝ → Prop
l : List α✝
h : ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
⊢ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
tactic: constructor <;> intro h
Theorem: LucasLehmer.norm_num_ext.sMod'_eq_sMod
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: p k : ℕ
hp : 2 ≤ p
⊢ ↑(sMod' (2 ^ p - 1) k) = sMod p k
state_after: p k : ℕ
hp : 2 ≤ p
h1 : 4 ≤ 2 ^ p
⊢ ↑(sMod' (2 ^ p - 1) k) = sMod p k
tactic: have h1 := calc
    4 = 2 ^ 2 := by norm_num
    _ ≤ 2 ^ p := Nat.pow_le_pow_of_le_right (by norm_num) hp
state_before: p k : ℕ
hp : 2 ≤ p
h1 : 4 ≤ 2 ^ p
⊢ ↑(sMod' (2 ^ p - 1) k) = sMod p k
state_after: p k : ℕ
hp : 2 ≤ p
h1 : 4 ≤ 2 ^ p
h2 : 1 ≤ 2 ^ p
⊢ ↑(sMod' (2 ^ p - 1) k) = sMod p k
tactic: have h2 : 1 ≤ 2 ^ p := by omega
state_before: p k : ℕ
hp : 2 ≤ p
h1 : 4 ≤ 2 ^ p
h2 : 1 ≤ 2 ^ p
⊢ ↑(sMod' (2 ^ p - 1) k) = sMod p k
state_after: no goals
tactic: induction k with
  | zero =>
    rw [sMod', sMod, Int.ofNat_emod]
    simp [h2]
  | succ k ih =>
    rw [sMod', sMod, ← ih]
    have h3 : 2 ≤ 2 ^ p - 1 := by
      zify [h2]
      calc
        (2 : Int) ≤ 4 - 1 := by norm_num
        _         ≤ 2 ^ p - 1 := by zify at h1; exact Int.sub_le_sub_right h1 _
    zify [h2, h3]
    rw [← add_sub_assoc, sub_eq_add_neg, add_assoc, add_comm _ (-2), ← add_assoc,
      Int.add_emod_self, ← sub_eq_add_neg]
Theorem: NumberField.mixedEmbedding.convexBodySum_mem
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : K
⊢ (mixedEmbedding K) x ∈ convexBodySum K B ↔ ∑ w : InfinitePlace K, ↑w.mult * ↑w x ≤ B
state_after: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : K
⊢ ∑ x_1 : InfinitePlace K, ↑x_1.mult * x_1 x ≤ B ↔ ∑ w : InfinitePlace K, ↑w.mult * ↑w x ≤ B
tactic: simp_rw [Set.mem_setOf_eq, convexBodySumFun, normAtPlace_apply]
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
x : K
⊢ ∑ x_1 : InfinitePlace K, ↑x_1.mult * x_1 x ≤ B ↔ ∑ w : InfinitePlace K, ↑w.mult * ↑w x ≤ B
state_after: no goals
tactic: rfl
Theorem: List.inits_append
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ ([] ++ []).inits = [].inits ++ map (fun l => [] ++ l) [].inits.tail
state_after: no goals
tactic: simp
Theorem: CstarRing.mul_star_le_algebraMap_norm_sq
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean

Proof steps:
state_before: A : Type u_1
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : CstarRing A
inst✝⁴ : CompleteSpace A
inst✝³ : NormedAlgebra ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : PartialOrder A
inst✝ : StarOrderedRing A
a : A
⊢ a * star a ≤ (algebraMap ℝ A) (‖a‖ ^ 2)
state_after: A : Type u_1
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : CstarRing A
inst✝⁴ : CompleteSpace A
inst✝³ : NormedAlgebra ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : PartialOrder A
inst✝ : StarOrderedRing A
a : A
this : a * star a ≤ (algebraMap ℝ A) ‖a * star a‖
⊢ a * star a ≤ (algebraMap ℝ A) (‖a‖ ^ 2)
tactic: have : a * star a ≤ algebraMap ℝ A ‖a * star a‖ := IsSelfAdjoint.le_algebraMap_norm_self
state_before: A : Type u_1
inst✝⁷ : NormedRing A
inst✝⁶ : StarRing A
inst✝⁵ : CstarRing A
inst✝⁴ : CompleteSpace A
inst✝³ : NormedAlgebra ℂ A
inst✝² : StarModule ℂ A
inst✝¹ : PartialOrder A
inst✝ : StarOrderedRing A
a : A
this : a * star a ≤ (algebraMap ℝ A) ‖a * star a‖
⊢ a * star a ≤ (algebraMap ℝ A) (‖a‖ ^ 2)
state_after: no goals
tactic: rwa [CstarRing.norm_self_mul_star, ← pow_two] at this
Theorem: invOf_sub_invOf
File: Mathlib/Algebra/Ring/Invertible.lean

Proof steps:
state_before: α : Type u
inst✝² : Ring α
a b : α
inst✝¹ : Invertible a
inst✝ : Invertible b
⊢ ⅟a - ⅟b = ⅟a * (b - a) * ⅟b
state_after: no goals
tactic: rw [mul_sub, invOf_mul_self, sub_mul, one_mul, mul_assoc, mul_invOf_self, mul_one]
Theorem: Real.mk_neg
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
f : CauSeq ℚ abs
⊢ mk (-f) = -mk f
state_after: no goals
tactic: simp [mk, ← ofCauchy_neg]
Theorem: Polynomial.eval₂_pow'
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝² : CommSemiring R
inst✝¹ : Semiring S
inst✝ : Algebra R S
x : S
p q : R[X]
n : ℕ
⊢ eval₂ (algebraMap R S) x (p ^ n) = eval₂ (algebraMap R S) x p ^ n
state_after: no goals
tactic: induction n with
  | zero => simp only [Nat.zero_eq, pow_zero, eval₂_one]
  | succ n ih => rw [pow_succ, pow_succ, eval₂_mul', ih]
Theorem: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₃
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ (inverse C ⋙ functor C).obj T ≅ (𝟭 (Triangle Cᵒᵖ)).obj T
state_after: case refine_1
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₁ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₁

case refine_2
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₂ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₂

case refine_3
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₃ ≫ (shiftFunctor Cᵒᵖ 1).map (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₃
tactic: refine Triangle.isoMk _ _ (Iso.refl _) (Iso.refl _) (Iso.refl _) ?_ ?_ ?_
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
⊢ ∀ {X Y : Triangle Cᵒᵖ} (f : X ⟶ Y),
    (inverse C ⋙ functor C).map f ≫
        ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            X).hom ≫
        (𝟭 (Triangle Cᵒᵖ)).map f
state_after: no goals
tactic: aesop_cat
Theorem: List.dedup_eq_nil
File: Mathlib/Data/List/Dedup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
⊢ l.dedup = [] ↔ l = []
state_after: case nil
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
⊢ [].dedup = [] ↔ [] = []

case cons
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
a : α
l : List α
hl : l.dedup = [] ↔ l = []
⊢ (a :: l).dedup = [] ↔ a :: l = []
tactic: induction' l with a l hl
Theorem: hasFDerivAtFilter_id
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L✝ L₁ L₂ : Filter E
x : E
L : Filter E
⊢ ∀ (x_1 : E), 0 = _root_.id x_1 - _root_.id x - (ContinuousLinearMap.id 𝕜 E) (x_1 - x)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.le_lintegral_add
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
⊢ ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ ≤ ∫⁻ (a : α), f a + g a ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
⊢ (⨆ g, ⨆ (_ : ↑g ≤ fun a => f a), g.lintegral μ) + ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => g a), g_1.lintegral μ ≤
    ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a + g a), g_1.lintegral μ
tactic: simp only [lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
⊢ (⨆ g, ⨆ (_ : ↑g ≤ fun a => f a), g.lintegral μ) + ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => g a), g_1.lintegral μ ≤
    ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a + g a), g_1.lintegral μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
f' : α →ₛ ℝ≥0∞
hf' : (fun h => ↑h ≤ f) f'
g' : α →ₛ ℝ≥0∞
hg' : (fun h => ↑h ≤ g) g'
⊢ f'.lintegral μ + g'.lintegral μ ≤ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a + g a), g_1.lintegral μ
tactic: refine ENNReal.biSup_add_biSup_le' (p := fun h : α →ₛ ℝ≥0∞ => h ≤ f)
    (q := fun h : α →ₛ ℝ≥0∞ => h ≤ g) ⟨0, zero_le f⟩ ⟨0, zero_le g⟩ fun f' hf' g' hg' => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f g : α → ℝ≥0∞
f' : α →ₛ ℝ≥0∞
hf' : (fun h => ↑h ≤ f) f'
g' : α →ₛ ℝ≥0∞
hg' : (fun h => ↑h ≤ g) g'
⊢ f'.lintegral μ + g'.lintegral μ ≤ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a + g a), g_1.lintegral μ
state_after: no goals
tactic: exact le_iSup₂_of_le (f' + g') (add_le_add hf' hg') (add_lintegral _ _).ge
Theorem: exists_lt_of_lt_csSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
hs : s.Nonempty
hb : b < sSup s
⊢ ∃ a ∈ s, b < a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
hs : s.Nonempty
hb : ∀ a ∈ s, a ≤ b
⊢ sSup s ≤ b
tactic: contrapose! hb
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
hs : s.Nonempty
hb : ∀ a ∈ s, a ≤ b
⊢ sSup s ≤ b
state_after: no goals
tactic: exact csSup_le hs hb
Theorem: latticeClosure_singleton
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Lattice α
s t : Set α
a : α
⊢ latticeClosure {a} = {a}
state_after: no goals
tactic: simp
Theorem: mul_div_cancel_right
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c d : G
n : ℤ
a b : G
⊢ a * b / b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_inv_cancel_right a b]
Theorem: Ctop.Realizer.ext'
File: Mathlib/Data/Analysis/Topology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
⊢ F.toTopsp = T
state_after: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
⊢ 𝓝 x = 𝓝 x
tactic: refine TopologicalSpace.ext_nhds fun x ↦ ?_
state_before: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
⊢ 𝓝 x = 𝓝 x
state_after: case h
α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ 𝓝 x
tactic: ext s
state_before: case h
α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ 𝓝 x
state_after: no goals
tactic: rw [mem_nhds_toTopsp, H]
Theorem: ArithmeticFunction.IsMultiplicative.intCast
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : f.IsMultiplicative
⊢ ↑f 1 = 1
state_after: no goals
tactic: simp [h]
state_before: R : Type u_1
f : ArithmeticFunction ℤ
inst✝ : Ring R
h : f.IsMultiplicative
m n : ℕ
cop : m.Coprime n
⊢ ↑f (m * n) = ↑f m * ↑f n
state_after: no goals
tactic: simp [h.2 cop]