ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.coeff_eq_esymm_roots_of_card
File: Mathlib/RingTheory/Polynomial/Vieta.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ p.coeff k = p.leadingCoeff * (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ (C p.leadingCoeff * (map (fun a => X - C a) p.roots).prod).coeff k =
    p.leadingCoeff * (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
tactic: conv_lhs => rw [← C_leadingCoeff_mul_prod_multiset_X_sub_C hroots]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ (C p.leadingCoeff * (map (fun a => X - C a) p.roots).prod).coeff k =
    p.leadingCoeff * (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ p.leadingCoeff * (map (fun a => X - C a) p.roots).prod.coeff k =
    p.leadingCoeff * ((-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k))
tactic: rw [coeff_C_mul, mul_assoc]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ p.leadingCoeff * (map (fun a => X - C a) p.roots).prod.coeff k =
    p.leadingCoeff * ((-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k))
state_after: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ (map (fun a => X - C a) p.roots).prod.coeff k = (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
tactic: congr
state_before: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
⊢ (map (fun a => X - C a) p.roots).prod.coeff k = (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
state_after: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
this : k ≤ card p.roots
⊢ (map (fun a => X - C a) p.roots).prod.coeff k = (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
tactic: have : k ≤ card (roots p) := by rw [hroots]; exact h
state_before: case e_a
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hroots : card p.roots = p.natDegree
k : ℕ
h : k ≤ p.natDegree
this : k ≤ card p.roots
⊢ (map (fun a => X - C a) p.roots).prod.coeff k = (-1) ^ (p.natDegree - k) * p.roots.esymm (p.natDegree - k)
state_after: no goals
tactic: convert p.roots.prod_X_sub_C_coeff this using 3 <;> rw [hroots]
Theorem: Subgroup.unop_closure
File: Mathlib/Algebra/Group/Subgroup/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ (closure s).unop = closure (MulOpposite.op ⁻¹' s)
state_after: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
tactic: simp_rw [closure, unop_sInf, Set.preimage_setOf_eq, Subgroup.op_coe]
state_before: ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
state_after: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
a : Subgroup G
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
a : Subgroup G
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {K | MulOpposite.op ⁻¹' s ⊆ ↑K}
state_after: no goals
tactic: exact MulOpposite.op_surjective.forall
Theorem: Finset.powerset_card_biUnion
File: Mathlib/Data/Finset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.30699
s✝ t : Finset α
inst✝ : DecidableEq (Finset α)
s : Finset α
⊢ s.powerset = (range (s.card + 1)).biUnion fun i => powersetCard i s
state_after: no goals
tactic: simpa only [disjiUnion_eq_biUnion] using powerset_card_disjiUnion s
Theorem: List.Sublist.filterMap
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l₁ l₂ : List α
f : α → Option β
s : l₁ <+ l₂
⊢ filterMap f l₁ <+ filterMap f l₂
state_after: no goals
tactic: induction s <;> simp [filterMap_cons] <;> split <;> simp [*, cons, cons₂]
Theorem: Set.Finite.toFinset_image
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht : t.Finite
inst✝ : DecidableEq β
f : α → β
hs : s.Finite
h : (f '' s).Finite
⊢ h.toFinset = Finset.image f hs.toFinset
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht : t.Finite
inst✝ : DecidableEq β
f : α → β
hs : s.Finite
h : (f '' s).Finite
a✝ : β
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f hs.toFinset
tactic: ext
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
a : α
hs✝ : s.Finite
ht : t.Finite
inst✝ : DecidableEq β
f : α → β
hs : s.Finite
h : (f '' s).Finite
a✝ : β
⊢ a✝ ∈ h.toFinset ↔ a✝ ∈ Finset.image f hs.toFinset
state_after: no goals
tactic: simp
Theorem: Function.support_update_of_ne_zero
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x : α
y : M
hy : y ≠ 1
⊢ mulSupport (update f x y) = insert x (mulSupport f)
state_after: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x : α
y : M
hy : y ≠ 1
a : α
⊢ a ∈ mulSupport (update f x y) ↔ a ∈ insert x (mulSupport f)
tactic: ext a
state_before: case h
α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝³ : One M
inst✝² : One N
inst✝¹ : One P
inst✝ : DecidableEq α
f : α → M
x : α
y : M
hy : y ≠ 1
a : α
⊢ a ∈ mulSupport (update f x y) ↔ a ∈ insert x (mulSupport f)
state_after: no goals
tactic: rcases eq_or_ne a x with rfl | hne <;> simp [*]
Theorem: IsPrimitiveRoot.one_right_iff
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 : ℕ
ζ : M
f : F
h : IsPrimitiveRoot ζ k
⊢ IsPrimitiveRoot ζ 1 ↔ ζ = 1
state_after: 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 : ℕ
ζ : M
f : F
⊢ IsPrimitiveRoot ζ 1 ↔ ζ = 1
tactic: clear h
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 : ℕ
ζ : M
f : F
⊢ IsPrimitiveRoot ζ 1 ↔ ζ = 1
state_after: case mp
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 : ℕ
ζ : M
f : F
⊢ IsPrimitiveRoot ζ 1 → ζ = 1

case mpr
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 : ℕ
ζ : M
f : F
⊢ ζ = 1 → IsPrimitiveRoot ζ 1
tactic: constructor
Theorem: npow_mul
File: Mathlib/Algebra/Group/NatPowAssoc.lean

Proof steps:
state_before: M : Type u_1
inst✝² : MulOneClass M
inst✝¹ : Pow M ℕ
inst✝ : NatPowAssoc M
x : M
m n : ℕ
⊢ x ^ (m * n) = (x ^ m) ^ n
state_after: no goals
tactic: induction n with
  | zero => rw [npow_zero, Nat.mul_zero, npow_zero]
  | succ n ih => rw [mul_add, npow_add, ih, mul_one, npow_add, npow_one]
Theorem: Part.div_get_eq
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Div α
a b : Part α
hab : (a / b).Dom
⊢ (a / b).get hab = a.get ⋯ / b.get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Div α
a b : Part α
hab : (a / b).Dom
⊢ (a.bind fun y => map (fun x => y / x) b).get ⋯ = a.get ⋯ / b.get ⋯
tactic: simp [div_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Div α
a b : Part α
hab : (a / b).Dom
⊢ (a.bind fun y => map (fun x => y / x) b).get ⋯ = a.get ⋯ / b.get ⋯
state_after: no goals
tactic: aesop
Theorem: isIntegralCurveAt_iff
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

Proof steps:
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
⊢ IsIntegralCurveAt γ v t₀ ↔ ∃ s ∈ 𝓝 t₀, IsIntegralCurveOn γ v s
state_after: no goals
tactic: simp_rw [IsIntegralCurveOn, ← Filter.eventually_iff_exists_mem, IsIntegralCurveAt]
Theorem: _private.Mathlib.MeasureTheory.Function.L2Space.0.MeasureTheory.L2.add_left'
File: Mathlib/MeasureTheory/Function/L2Space.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
⊢ ⟪f + f', g⟫_𝕜 = ⟪f, g⟫_𝕜 + ⟪f', g⟫_𝕜
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
⊢ ∫ (a : α), ⟪↑↑(f + f') a, ↑↑g a⟫_𝕜 ∂μ = ∫ (a : α), ⟪↑↑f a + ↑↑f' a, ↑↑g a⟫_𝕜 ∂μ
tactic: simp_rw [inner_def, ← integral_add (integrable_inner f g) (integrable_inner f' g), ←
    inner_add_left]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
⊢ ∫ (a : α), ⟪↑↑(f + f') a, ↑↑g a⟫_𝕜 ∂μ = ∫ (a : α), ⟪↑↑f a + ↑↑f' a, ↑↑g a⟫_𝕜 ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ (fun a => ⟪↑↑(f + f') a, ↑↑g a⟫_𝕜) x = (fun a => ⟪↑↑f a + ↑↑f' a, ↑↑g a⟫_𝕜) x
tactic: refine integral_congr_ae ((coeFn_add f f').mono fun x hx => ?_)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ (fun a => ⟪↑↑(f + f') a, ↑↑g a⟫_𝕜) x = (fun a => ⟪↑↑f a + ↑↑f' a, ↑↑g a⟫_𝕜) x
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ ⟪↑↑(f + f') x, ↑↑g x⟫_𝕜 = ⟪↑↑f x + ↑↑f' x, ↑↑g x⟫_𝕜
tactic: simp only
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁴ : RCLike 𝕜
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : NormedAddCommGroup F
f f' g : ↥(Lp E 2 μ)
x : α
hx : ↑↑(f + f') x = (↑↑f + ↑↑f') x
⊢ ⟪↑↑(f + f') x, ↑↑g x⟫_𝕜 = ⟪↑↑f x + ↑↑f' x, ↑↑g x⟫_𝕜
state_after: no goals
tactic: rw [hx, Pi.add_apply]
Theorem: CliffordAlgebra.commute_map_mul_map_of_isOrtho_of_mem_evenOdd_zero_left
File: Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean

Proof steps:
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
N : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : AddCommGroup N
inst✝² : Module R M₁
inst✝¹ : Module R M₂
inst✝ : Module R N
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
Qₙ : QuadraticForm R N
f₁ : Q₁ →qᵢ Qₙ
f₂ : Q₂ →qᵢ Qₙ
hf : ∀ (x : M₁) (y : M₂), QuadraticMap.IsOrtho Qₙ (f₁ x) (f₂ y)
m₁ : CliffordAlgebra Q₁
m₂ : CliffordAlgebra Q₂
i₂ : ZMod 2
hm₁ : m₁ ∈ evenOdd Q₁ 0
hm₂ : m₂ ∈ evenOdd Q₂ i₂
⊢ (-1) ^ (i₂ * 0) • ((map f₂) m₂ * (map f₁) m₁) = (map f₂) m₂ * (map f₁) m₁
state_after: no goals
tactic: simp
Theorem: HasStrictFDerivAt.sub_const
File: Mathlib/Analysis/Calculus/FDeriv/Add.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
hf : HasStrictFDerivAt f f' x
c : F
⊢ HasStrictFDerivAt (fun x => f x - c) f' x
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add_const (-c)
Theorem: map_ratCast_smul
File: Mathlib/Algebra/Module/Rat.lean

Proof steps:
state_before: M : Type u_1
M₂ : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M₂
F : Type u_3
inst✝⁵ : FunLike F M M₂
inst✝⁴ : AddMonoidHomClass F M M₂
f : F
R : Type u_4
S : Type u_5
inst✝³ : DivisionRing R
inst✝² : DivisionRing S
inst✝¹ : Module R M
inst✝ : Module S M₂
c : ℚ
x : M
⊢ f (↑c • x) = ↑c • f x
state_after: no goals
tactic: rw [Rat.cast_def, Rat.cast_def, div_eq_mul_inv, div_eq_mul_inv, mul_smul, mul_smul,
    map_intCast_smul f R S, map_inv_natCast_smul f R S]
Theorem: Cycle.Chain.imp
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
p : Chain r₁ s
⊢ Chain r₂ s
state_after: case H0
α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
p : Chain r₁ Cycle.nil
⊢ Chain r₂ Cycle.nil

case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
a✝¹ : α
l✝ : List α
a✝ : Chain r₁ ↑l✝ → Chain r₂ ↑l✝
p : Chain r₁ ↑(a✝¹ :: l✝)
⊢ Chain r₂ ↑(a✝¹ :: l✝)
tactic: induction s
Theorem: CategoryTheory.Pretriangulated.rotate_map_hom₁
File: Mathlib/CategoryTheory/Triangulated/Rotate.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasShift C ℤ
X : C
X✝ Y✝ : Triangle C
f : X✝ ⟶ Y✝
⊢ X✝.rotate.mor₃ ≫ (shiftFunctor C 1).map f.hom₂ = (shiftFunctor C 1).map f.hom₁ ≫ Y✝.rotate.mor₃
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasShift C ℤ
X : C
X✝ Y✝ : Triangle C
f : X✝ ⟶ Y✝
⊢ (-(shiftFunctor C 1).map X✝.mor₁) ≫ (shiftFunctor C 1).map f.hom₂ =
    (shiftFunctor C 1).map f.hom₁ ≫ (-(shiftFunctor C 1).map Y✝.mor₁)
tactic: dsimp
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
inst✝ : HasShift C ℤ
X : C
X✝ Y✝ : Triangle C
f : X✝ ⟶ Y✝
⊢ (-(shiftFunctor C 1).map X✝.mor₁) ≫ (shiftFunctor C 1).map f.hom₂ =
    (shiftFunctor C 1).map f.hom₁ ≫ (-(shiftFunctor C 1).map Y✝.mor₁)
state_after: no goals
tactic: simp only [comp_neg, neg_comp, ← Functor.map_comp, f.comm₁]
Theorem: List.splitOnP_cons
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
x : α
xs : List α
⊢ splitOnP p (x :: xs) = if p x = true then [] :: splitOnP p xs else modifyHead (cons x) (splitOnP p xs)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
x : α
xs : List α
⊢ (if p x = true then [].reverse :: splitOnP.go p xs [] else splitOnP.go p xs [x]) =
    if p x = true then [] :: splitOnP p xs else modifyHead (cons x) (splitOnP p xs)
tactic: rw [splitOnP, splitOnP.go]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
x : α
xs : List α
⊢ (if p x = true then [].reverse :: splitOnP.go p xs [] else splitOnP.go p xs [x]) =
    if p x = true then [] :: splitOnP p xs else modifyHead (cons x) (splitOnP p xs)
state_after: no goals
tactic: split <;> [rfl; simp [splitOnP.go_acc]]
Theorem: CategoryTheory.Limits.IsImage.isoExt_inv_m
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.isoExt hF').inv ≫ F.m = F'.m
state_after: no goals
tactic: simp
Theorem: MeasureTheory.right_measure_le_of_levyProkhorovEDist_lt
File: Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean

Proof steps:
state_before: ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
⊢ ν B ≤ μ (thickening c.toReal B) + c
state_after: case intro.intro
ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
c' : ℝ≥0∞
hc' :
  c' ∈ {ε | ∀ (B : Set Ω), MeasurableSet B → μ B ≤ ν (thickening ε.toReal B) + ε ∧ ν B ≤ μ (thickening ε.toReal B) + ε}
lt_c : c' < c
⊢ ν B ≤ μ (thickening c.toReal B) + c
tactic: obtain ⟨c', ⟨hc', lt_c⟩⟩ := sInf_lt_iff.mp h
state_before: case intro.intro
ι : Type u_1
Ω : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : PseudoEMetricSpace Ω
μ ν : Measure Ω
c : ℝ≥0∞
h : levyProkhorovEDist μ ν < c
B : Set Ω
B_mble : MeasurableSet B
c' : ℝ≥0∞
hc' :
  c' ∈ {ε | ∀ (B : Set Ω), MeasurableSet B → μ B ≤ ν (thickening ε.toReal B) + ε ∧ ν B ≤ μ (thickening ε.toReal B) + ε}
lt_c : c' < c
⊢ ν B ≤ μ (thickening c.toReal B) + c
state_after: no goals
tactic: exact meas_le_of_le_of_forall_le_meas_thickening_add ν μ lt_c.le (hc' B B_mble).2
Theorem: SimpleGraph.Walk.tail_support_append
File: Mathlib/Combinatorics/SimpleGraph/Walk.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 : V
p : G.Walk u v
p' : G.Walk v w
⊢ (p.append p').support.tail = p.support.tail ++ p'.support.tail
state_after: no goals
tactic: rw [support_append, List.tail_append_of_ne_nil _ _ (support_ne_nil _)]
Theorem: List.isEmpty_iff_eq_nil
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ l : List α
⊢ l.isEmpty = true ↔ l = []
state_after: no goals
tactic: cases l <;> simp [isEmpty]
Theorem: Relation.TransGen.tail'_iff
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ TransGen r a c ↔ ∃ b, ReflTransGen r a b ∧ r b c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
tactic: refine ⟨fun h ↦ ?_, fun ⟨b, hab, hbc⟩ ↦ tail' hab hbc⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : TransGen r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
state_after: case single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
hac : r a c
⊢ ∃ b, ReflTransGen r a b ∧ r b c

case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c d b : α
hab : TransGen r a b
hbc : r b c
⊢ ∃ b, ReflTransGen r a b ∧ r b c
tactic: cases' h with _ hac b _ hab hbc
Theorem: PowerSeries.rescale_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ rescale 0 = (C R).comp (constantCoeff R)
state_after: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ((rescale 0) x) = (coeff R n) (((C R).comp (constantCoeff R)) x)
tactic: ext x n
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ((rescale 0) x) = (coeff R n) (((C R).comp (constantCoeff R)) x)
state_after: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ({ toFun := fun f => mk fun n => 0 ^ n * (coeff R n) f, map_one' := ⋯, map_mul' := ⋯ } x) =
    if n = 0 then (constantCoeff R) x else 0
tactic: simp only [Function.comp_apply, RingHom.coe_comp, rescale, RingHom.coe_mk,
    PowerSeries.coeff_mk _ _, coeff_C]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ({ toFun := fun f => mk fun n => 0 ^ n * (coeff R n) f, map_one' := ⋯, map_mul' := ⋯ } x) =
    if n = 0 then (constantCoeff R) x else 0
state_after: no goals
tactic: split_ifs with h <;> simp [h]
Theorem: LinearEquiv.piRing_symm_apply
File: Mathlib/LinearAlgebra/Pi.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝¹³ : Semiring R
φ : ι → Type u_1
ψ : ι → Type u_2
χ : ι → Type u_3
inst✝¹² : (i : ι) → AddCommMonoid (φ i)
inst✝¹¹ : (i : ι) → Module R (φ i)
inst✝¹⁰ : (i : ι) → AddCommMonoid (ψ i)
inst✝⁹ : (i : ι) → Module R (ψ i)
inst✝⁸ : (i : ι) → AddCommMonoid (χ i)
inst✝⁷ : (i : ι) → Module R (χ i)
S : Type u_4
inst✝⁶ : Fintype ι
inst✝⁵ : DecidableEq ι
inst✝⁴ : Semiring S
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : SMulCommClass R S M
f : ι → M
g : ι → R
⊢ ((piRing R M ι S).symm f) g = ∑ i : ι, g i • f i
state_after: no goals
tactic: simp [piRing, LinearMap.lsum_apply]
Theorem: Filter.HasBasis.uniformContinuous_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
ι' : Sort u_2
inst✝ : UniformSpace β
p : ι → Prop
s : ι → Set (α × α)
ha : (𝓤 α).HasBasis p s
q : ι' → Prop
t : ι' → Set (β × β)
hb : (𝓤 β).HasBasis q t
f : α → β
⊢ (∀ (ib : ι'), q ib → ∃ ia, p ia ∧ ∀ x ∈ s ia, (f x.1, f x.2) ∈ t ib) ↔
    ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ t i
state_after: no goals
tactic: simp only [Prod.forall]
Theorem: Finset.image_ssubset_image
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ image f s ⊂ image f t ↔ s ⊂ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ image f s < image f t ↔ s < t
tactic: simp_rw [← lt_iff_ssubset]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t✝ : Finset β
a : α
b c : β
t : Finset α
hf : Injective f
⊢ image f s < image f t ↔ s < t
state_after: no goals
tactic: exact lt_iff_lt_of_le_iff_le' (image_subset_image_iff hf) (image_subset_image_iff hf)
Theorem: AffineSubspace.direction_bot
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.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
p₁ p₂ : P
⊢ ⊥.direction = ⊥
state_after: no goals
tactic: rw [direction_eq_vectorSpan, bot_coe, vectorSpan_def, vsub_empty, Submodule.span_empty]