ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddMonoidAlgebra.finiteType_iff_fg
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
⊢ FiniteType R R[M] ↔ AddMonoid.FG M
state_after: R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
⊢ AddMonoid.FG M
tactic: refine ⟨fun h => ?_, fun h => @AddMonoidAlgebra.finiteType_of_fg _ _ _ _ h⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
⊢ AddMonoid.FG M
state_after: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
⊢ AddMonoid.FG M
tactic: obtain ⟨S, hS⟩ := @exists_finset_adjoin_eq_top R M _ _ h
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
⊢ AddMonoid.FG M
state_after: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
⊢ m ∈ closure ↑S
tactic: refine AddMonoid.fg_def.2 ⟨S, (eq_top_iff' _).2 fun m => ?_⟩
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
⊢ m ∈ closure ↑S
state_after: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
hm : of' R M m ∈ Subalgebra.toSubmodule (adjoin R (of' R M '' ↑S))
⊢ m ∈ closure ↑S
tactic: have hm : of' R M m ∈ Subalgebra.toSubmodule (adjoin R (of' R M '' ↑S)) := by
    simp only [hS, top_toSubmodule, Submodule.mem_top]
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
hm : of' R M m ∈ Subalgebra.toSubmodule (adjoin R (of' R M '' ↑S))
⊢ m ∈ closure ↑S
state_after: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
hm : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' ↑S))
⊢ m ∈ closure ↑S
tactic: rw [adjoin_eq_span] at hm
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : AddMonoid M
inst✝¹ : CommRing R
inst✝ : Nontrivial R
h : FiniteType R R[M]
S : Finset M
hS : adjoin R (of' R M '' ↑S) = ⊤
m : M
hm : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' ↑S))
⊢ m ∈ closure ↑S
state_after: no goals
tactic: exact mem_closure_of_mem_span_closure hm
Theorem: Polynomial.exists_irreducible_of_natDegree_pos
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R✝ : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : WfDvdMonoid R
f : R[X]
hf : 0 < f.natDegree
⊢ 0 < f.degree
state_after: R✝ : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : WfDvdMonoid R
f : R[X]
hf : f.degree ≤ 0
⊢ f.natDegree ≤ 0
tactic: contrapose! hf
state_before: R✝ : Type u
S : Type u_1
σ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : WfDvdMonoid R
f : R[X]
hf : f.degree ≤ 0
⊢ f.natDegree ≤ 0
state_after: no goals
tactic: exact natDegree_le_of_degree_le hf
Theorem: Unitization.mem_spectrum_inr_of_not_isUnit
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

Proof steps:
state_before: R✝ : Type u_1
A✝ : Type u_2
inst✝⁹ : CommSemiring R✝
inst✝⁸ : NonUnitalRing A✝
inst✝⁷ : Module R✝ A✝
inst✝⁶ : IsScalarTower R✝ A✝ A✝
inst✝⁵ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝⁴ : CommRing R
inst✝³ : NonUnitalRing A
inst✝² : Module R A
inst✝¹ : IsScalarTower R A A
inst✝ : SMulCommClass R A A
a : A
r : R
hr : ¬IsUnit r
h : r ∈ resolventSet R ↑a
⊢ IsUnit r
state_after: no goals
tactic: simpa using h.map (fstHom R A)
Theorem: nilpotencyClass_zero_iff_subsingleton
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
inst✝ : Group.IsNilpotent G
⊢ Group.nilpotencyClass G = 0 ↔ Subsingleton G
state_after: no goals
tactic: rw [Group.nilpotencyClass, @Nat.find_eq_zero _ (Classical.decPred _), upperCentralSeries_zero,
    subsingleton_iff_bot_eq_top, Subgroup.subsingleton_iff]
Theorem: MeasureTheory.submartingale_of_condexp_sub_nonneg_nat
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
⊢ Submartingale f 𝒢 μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ f i ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i]
tactic: refine submartingale_nat hadp hint fun i => ?_
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ f i ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i]
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ 0 ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i] - μ[f i|↑𝒢 i]
tactic: rw [← condexp_of_stronglyMeasurable (𝒢.le _) (hadp _) (hint _), ← eventually_sub_nonneg]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁴ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ g : ι → Ω → E
ℱ : Filtration ι m0
𝒢 : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
f : ℕ → Ω → ℝ
hadp : Adapted 𝒢 f
hint : ∀ (i : ℕ), Integrable (f i) μ
hf : ∀ (i : ℕ), 0 ≤ᶠ[ae μ] μ[f (i + 1) - f i|↑𝒢 i]
i : ℕ
⊢ 0 ≤ᶠ[ae μ] μ[f (i + 1)|↑𝒢 i] - μ[f i|↑𝒢 i]
state_after: no goals
tactic: exact EventuallyLE.trans (hf i) (condexp_sub (hint _) (hint _)).le
Theorem: CategoryTheory.ShortComplex.RightHomologyData.exact_iff
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2467, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.RightHomologyData
⊢ S.Exact ↔ IsZero h.H
state_after: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2467, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.RightHomologyData
⊢ IsZero S.homology ↔ IsZero h.H
tactic: rw [S.exact_iff_isZero_homology]
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2467, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.RightHomologyData
⊢ IsZero S.homology ↔ IsZero h.H
state_after: no goals
tactic: exact Iso.isZero_iff h.homologyIso
Theorem: List.replaceF_eq_replaceFTR
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @replaceF = @replaceFTR
state_after: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR p l
tactic: funext α p l
state_before: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR p l
state_after: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR.go p l #[]
tactic: simp [replaceFTR]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
⊢ replaceFTR.go p [] acc = acc.data ++ replaceF p []
state_after: no goals
tactic: simp [replaceFTR.go, replaceF]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ replaceFTR.go p (x :: xs) acc = acc.data ++ replaceF p (x :: xs)
state_after: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ (match p x with
    | none => replaceFTR.go p xs (acc.push x)
    | some a' => acc.data ++ a' :: xs) =
    acc.data ++
      match p x with
      | none => x :: replaceF p xs
      | some a => a :: xs
tactic: simp [replaceFTR.go, replaceF]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ (match p x with
    | none => replaceFTR.go p xs (acc.push x)
    | some a' => acc.data ++ a' :: xs) =
    acc.data ++
      match p x with
      | none => x :: replaceF p xs
      | some a => a :: xs
state_after: case none
α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ replaceFTR.go p xs (acc.push x) = acc.data ++ x :: replaceF p xs
tactic: cases p x <;> simp
state_before: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR.go p l #[]
state_after: no goals
tactic: exact (go #[] _).symm
Theorem: MeasureTheory.Measure.setLIntegral_condKernel_univ_right
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in s ×ˢ Set.univ, f x ∂ρ
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
tactic: rw [← setLIntegral_condKernel hf hs MeasurableSet.univ]
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
inst✝¹ : CountableOrCountablyGenerated α β
ρ : Measure (β × Ω)
inst✝ : IsFiniteMeasure ρ
f : β × Ω → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst =
    ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in Set.univ, f (b, ω) ∂ρ.condKernel b ∂ρ.fst
state_after: no goals
tactic: simp_rw [Measure.restrict_univ]
Theorem: List.perm_replicate_append_replicate
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ l ~ replicate m a ++ replicate n b ↔ count a l = m ∧ count b l = n ∧ l ⊆ [a, b]
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ (count a l = count a (replicate m a ++ replicate n b) ∧
      (b ≠ a → count b l = count b (replicate m a ++ replicate n b)) ∧
        ∀ (b_1 : α), b_1 ≠ b → b_1 ≠ a → count b_1 l = count b_1 (replicate m a ++ replicate n b)) ↔
    count a l = m ∧ count b l = n ∧ l ⊆ [a, b]
tactic: rw [perm_iff_count, ← Decidable.and_forall_ne a, ← Decidable.and_forall_ne b]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ (count a l = count a (replicate m a ++ replicate n b) ∧
      (b ≠ a → count b l = count b (replicate m a ++ replicate n b)) ∧
        ∀ (b_1 : α), b_1 ≠ b → b_1 ≠ a → count b_1 l = count b_1 (replicate m a ++ replicate n b)) ↔
    count a l = m ∧ count b l = n ∧ l ⊆ [a, b]
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ l ⊆ [a, b] ↔ ∀ (c : α), c ≠ b → c ≠ a → c ∉ l
tactic: suffices l ⊆ [a, b] ↔ ∀ c, c ≠ b → c ≠ a → c ∉ l by
    simp (config := { contextual := true }) [count_replicate, h, h.symm, this, count_eq_zero]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ l ⊆ [a, b] ↔ ∀ (c : α), c ≠ b → c ≠ a → c ∉ l
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ l ⊆ [a, b] ↔ ∀ c ∈ l, c = b ∨ c = a

α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a✝ : α
inst✝ : DecidableEq α
l : List α
a b : α
m n : ℕ
h : a ≠ b
⊢ (∀ c ∈ l, c = b ∨ c = a) ↔ ∀ (c : α), c ≠ b → c ≠ a → c ∉ l
tactic: trans ∀ c, c ∈ l → c = b ∨ c = a
Theorem: Computation.orElse_pure
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ (HOrElse.hOrElse c₁.think fun x => pure a).destruct = Sum.inl a
state_after: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ (c₁.think.orElse fun x => pure a).destruct = Sum.inl a
tactic: unfold_projs
state_before: α : Type u
β : Type v
γ : Type w
c₁ : Computation α
a : α
⊢ (c₁.think.orElse fun x => pure a).destruct = Sum.inl a
state_after: no goals
tactic: simp [orElse]
Theorem: Subgroup.zpowers_eq_bot
File: Mathlib/Algebra/Group/Subgroup/ZPowers.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
s : Set G
g✝ g : G
⊢ zpowers g = ⊥ ↔ g = 1
state_after: no goals
tactic: rw [eq_bot_iff, zpowers_le, mem_bot]
Theorem: CategoryTheory.Limits.Fork.ofι_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f g : X✝ ⟶ Y
P : C
ι : P ⟶ X✝
w : ι ≫ f = ι ≫ g
X : WalkingParallelPair
⊢ ((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f g).obj X
state_after: case zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj zero ⟶ (parallelPair f g).obj zero

case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj one ⟶ (parallelPair f g).obj one
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
f✝ g : X✝ ⟶ Y✝
P : C
ι : P ⟶ X✝
w : ι ≫ f✝ = ι ≫ g
X Y : WalkingParallelPair
f : X ⟶ Y
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X (fun h => ⋯ ▸ ι)
            (fun h => ⋯ ▸ ι ≫ f✝) ⋯)
        Y =
    (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X (fun h => ⋯ ▸ ι)
            (fun h => ⋯ ▸ ι ≫ f✝) ⋯)
        X ≫
      (parallelPair f✝ g).map f
state_after: case zero.one.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ι ≫ f = ι ≫ g
tactic: cases X <;> cases Y <;> cases f <;> dsimp <;> simp
state_before: case zero.one.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ι ≫ f = ι ≫ g
state_after: no goals
tactic: assumption
Theorem: Con.multiset_prod
File: Mathlib/GroupTheory/Congruence/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
h : ∀ x ∈ s, c (f x) (g x)
⊢ c (Multiset.map f s).prod (Multiset.map g s).prod
state_after: case mk
ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
a✝ : List ι
h : ∀ x ∈ Quot.mk Setoid.r a✝, c (f x) (g x)
⊢ c (Multiset.map f (Quot.mk Setoid.r a✝)).prod (Multiset.map g (Quot.mk Setoid.r a✝)).prod
tactic: rcases s
state_before: case mk
ι : Type u_1
M : Type u_2
inst✝ : CommMonoid M
c : Con M
s : Multiset ι
f g : ι → M
a✝ : List ι
h : ∀ x ∈ Quot.mk Setoid.r a✝, c (f x) (g x)
⊢ c (Multiset.map f (Quot.mk Setoid.r a✝)).prod (Multiset.map g (Quot.mk Setoid.r a✝)).prod
state_after: no goals
tactic: simpa using c.list_prod h
Theorem: MvPolynomial.sum_homogeneousComponent
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
⊢ ∑ i ∈ range (φ.totalDegree + 1), (homogeneousComponent i) φ = φ
state_after: case a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d (∑ i ∈ range (φ.totalDegree + 1), (homogeneousComponent i) φ) = coeff d φ
tactic: ext1 d
state_before: case a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ coeff d (∑ i ∈ range (φ.totalDegree + 1), (homogeneousComponent i) φ) = coeff d φ
state_after: case a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ φ.totalDegree < d.support.sum ⇑d → 0 = coeff d φ
tactic: suffices φ.totalDegree < d.support.sum d → 0 = coeff d φ by
    simpa [coeff_sum, coeff_homogeneousComponent]
state_before: case a
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
d : σ →₀ ℕ
⊢ φ.totalDegree < d.support.sum ⇑d → 0 = coeff d φ
state_after: no goals
tactic: exact fun h => (coeff_eq_zero_of_totalDegree_lt h).symm
Theorem: Zsqrtd.norm_eq_zero_iff
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ z.norm = 0 ↔ z = 0
state_after: case mp
d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ z.norm = 0 → z = 0

case mpr
d✝ d : ℤ
hd : d < 0
z : ℤ√d
⊢ z = 0 → z.norm = 0
tactic: constructor
Theorem: Int.negOnePow_even
File: Mathlib/Algebra/Ring/NegOnePow.lean

Proof steps:
state_before: n : ℤ
hn : Even n
⊢ n.negOnePow = 1
state_after: case intro
k : ℤ
⊢ (k + k).negOnePow = 1
tactic: obtain ⟨k, rfl⟩ := hn
state_before: case intro
k : ℤ
⊢ (k + k).negOnePow = 1
state_after: no goals
tactic: rw [negOnePow_add, units_mul_self]
Theorem: RatFunc.num_denom_mul
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = (algebraMap K[X] (RatFunc K)) (x.num * y.num) / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: no goals
tactic: conv_lhs =>
      rw [← num_div_denom x, ← num_div_denom y, div_mul_div_comm, ← RingHom.map_mul, ←
        RingHom.map_mul]
Theorem: Finset.sup_product_right
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s✝ s₁ s₂ : Finset β
f✝ g : β → α
a : α
s : Finset β
t : Finset γ
f : β × γ → α
⊢ (s ×ˢ t).sup f = t.sup fun i' => s.sup fun i => f (i, i')
state_after: no goals
tactic: rw [sup_product_left, Finset.sup_comm]
Theorem: Finset.tsum_subtype
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Finset β
f : β → α
⊢ ∏' (x : { x // x ∈ s }), f ↑x = ∏ x ∈ s, f x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Finset β
f : β → α
⊢ ∏' (x : { x // x ∈ s }), f ↑x = ∏ x ∈ s.attach, f ↑x
tactic: rw [← prod_attach]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a a₁ a₂ : α
s : Finset β
f : β → α
⊢ ∏' (x : { x // x ∈ s }), f ↑x = ∏ x ∈ s.attach, f ↑x
state_after: no goals
tactic: exact tprod_fintype _
Theorem: Function.Surjective.lieAlgebra_isNilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
⊢ ∃ k, lowerCentralSeries R L' L' k = ⊥
state_after: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ ∃ k, lowerCentralSeries R L' L' k = ⊥
tactic: obtain ⟨k, hk⟩ := id h₁
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ ∃ k, lowerCentralSeries R L' L' k = ⊥
state_after: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ lowerCentralSeries R L' L' k = ⊥
tactic: use k
state_before: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ lowerCentralSeries R L' L' k = ⊥
state_after: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ LieIdeal.map f ⊥ = ⊥
tactic: rw [← LieIdeal.lowerCentralSeries_map_eq k h₂, hk]
state_before: case h
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
h₁ : LieAlgebra.IsNilpotent R L
f : L →ₗ⁅R⁆ L'
h₂ : Surjective ⇑f
k : ℕ
hk : lowerCentralSeries R L L k = ⊥
⊢ LieIdeal.map f ⊥ = ⊥
state_after: no goals
tactic: simp only [LieIdeal.map_eq_bot_iff, bot_le]
Theorem: Finset.filter_card_add_filter_neg_card_eq_card
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
⊢ (filter p s).card + (filter (fun a => ¬p a) s).card = s.card
state_after: no goals
tactic: classical
  rw [← card_union_of_disjoint (disjoint_filter_filter_neg _ _ _), filter_union_filter_neg_eq]