ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.initial_iff_isCofiltered_costructuredArrow
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
⊢ F.Initial ↔ ∀ (d : D), IsCofiltered (CostructuredArrow F d)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
⊢ F.Initial → ∀ (d : D), IsCofiltered (CostructuredArrow F d)
tactic: refine ⟨?_, fun h => initial_of_isCofiltered_costructuredArrow F⟩
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
⊢ F.Initial → ∀ (d : D), IsCofiltered (CostructuredArrow F d)
state_after: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)) ∧
      ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s') →
    ∀ (d : D), IsCofiltered (CostructuredArrow F d)
tactic: rw [initial_iff_of_isCofiltered]
state_before: C : Type v₁
inst✝² : Category.{v₁, v₁} C
D : Type u₂
inst✝¹ : Category.{v₁, u₂} D
F : C ⥤ D
inst✝ : IsCofilteredOrEmpty C
⊢ ((∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)) ∧
      ∀ {d : D} {c : C} (s s' : F.obj c ⟶ d), ∃ c' t, F.map t ≫ s = F.map t ≫ s') →
    ∀ (d : D), IsCofiltered (CostructuredArrow F d)
state_after: no goals
tactic: exact fun h => isCofiltered_costructuredArrow_of_isCofiltered_of_exists F h.1 h.2
Theorem: finsum_sub_distrib
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f✝ g✝ : α → M
a b : α
s t : Set α
inst✝ : DivisionCommMonoid G
f g : α → G
hf : (mulSupport f).Finite
hg : (mulSupport g).Finite
⊢ ∏ᶠ (i : α), f i / g i = (∏ᶠ (i : α), f i) / ∏ᶠ (i : α), g i
state_after: no goals
tactic: simp only [div_eq_mul_inv, finprod_mul_distrib hf ((mulSupport_inv g).symm.rec hg),
    finprod_inv_distrib]
Theorem: ContDiffBump.one_of_mem_closedBall
File: Mathlib/Analysis/Calculus/BumpFunction/Basic.lean

Proof steps:
state_before: E : Type u_1
X : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
hx : x ∈ closedBall c f.rIn
⊢ ↑f x = 1
state_after: case a
E : Type u_1
X : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
hx : x ∈ closedBall c f.rIn
⊢ ‖(fun x => f.rIn⁻¹ • (x - c)) x‖ ≤ 1
tactic: apply ContDiffBumpBase.eq_one _ _ f.one_lt_rOut_div_rIn
state_before: case a
E : Type u_1
X : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
hx : x ∈ closedBall c f.rIn
⊢ ‖(fun x => f.rIn⁻¹ • (x - c)) x‖ ≤ 1
state_after: no goals
tactic: simpa only [norm_smul, Real.norm_eq_abs, abs_inv, abs_of_nonneg f.rIn_pos.le, ← div_eq_inv_mul,
    div_le_one f.rIn_pos] using mem_closedBall_iff_norm.1 hx
Theorem: Polynomial.factor_dvd_of_not_isUnit
File: Mathlib/FieldTheory/SplittingField/Construction.lean

Proof steps:
state_before: F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
⊢ f.factor ∣ f
state_after: case pos
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
hf2 : f = 0
⊢ f.factor ∣ f

case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
hf2 : ¬f = 0
⊢ f.factor ∣ f
tactic: by_cases hf2 : f = 0
state_before: case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
hf2 : ¬f = 0
⊢ f.factor ∣ f
state_after: case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
hf2 : ¬f = 0
⊢ Classical.choose ⋯ ∣ f
tactic: rw [factor, dif_pos (WfDvdMonoid.exists_irreducible_factor hf1 hf2)]
state_before: case neg
F : Type u
K : Type v
L : Type w
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
f : K[X]
hf1 : ¬IsUnit f
hf2 : ¬f = 0
⊢ Classical.choose ⋯ ∣ f
state_after: no goals
tactic: exact (Classical.choose_spec <| WfDvdMonoid.exists_irreducible_factor hf1 hf2).2
Theorem: Nat.one_le_pow
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ k : ℕ
p q : ℕ → Prop
n m : ℕ
h : 0 < m
⊢ 1 ≤ m ^ n
state_after: no goals
tactic: simpa using Nat.pow_le_pow_of_le_left h n
Theorem: Finset.univ_eq_empty_iff
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s t : Finset α
⊢ univ = ∅ ↔ IsEmpty α
state_after: no goals
tactic: rw [← not_nonempty_iff, ← univ_nonempty_iff, not_nonempty_iff_eq_empty]
Theorem: eq_zero_of_sameRay_self_neg
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
⊢ x = 0
tactic: nontriviality M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ x = 0
tactic: haveI : Nontrivial R := Module.nontrivial R M
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ x = 0
state_after: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ SameRay R x (-1 • x)
tactic: refine eq_zero_of_sameRay_neg_smul_right (neg_lt_zero.2 (zero_lt_one' R)) ?_
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝⁴ : AddCommGroup M
inst✝³ : AddCommGroup N
inst✝² : Module R M
inst✝¹ : Module R N
x y : M
inst✝ : NoZeroSMulDivisors R M
h : SameRay R x (-x)
a✝ : Nontrivial M
this : Nontrivial R
⊢ SameRay R x (-1 • x)
state_after: no goals
tactic: rwa [neg_one_smul]
Theorem: Nat.NormDigits.digits_succ
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l ∧ 1 < b ∧ 0 < m
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
state_after: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
tactic: rcases h with ⟨h, b2, m0⟩
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
state_after: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
tactic: have b0 : 0 < b := by omega
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
state_after: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
tactic: have n0 : 0 < n := by linarith [mul_pos b0 m0]
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ b.digits n = r :: l ∧ 1 < b ∧ 0 < n
state_after: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ b.digits n = r :: l
tactic: refine ⟨?_, b2, n0⟩
state_before: case intro.intro
n✝ b n m r : ℕ
l : List ℕ
e : r + b * m = n
hr : r < b
h : b.digits m = l
b2 : 1 < b
m0 : 0 < m
b0 : 0 < b
n0 : 0 < n
⊢ b.digits n = r :: l
state_after: case intro.intro.intro
n✝ b n : ℕ
l : List ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
h : b.digits (n / b) = l
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ b.digits n = n % b :: l
tactic: obtain ⟨rfl, rfl⟩ := (Nat.div_mod_unique b0).2 ⟨e, hr⟩
state_before: case intro.intro.intro
n✝ b n : ℕ
l : List ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
h : b.digits (n / b) = l
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ b.digits n = n % b :: l
state_after: case intro.intro.intro
n✝ b n : ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ b.digits n = n % b :: b.digits (n / b)
tactic: subst h
state_before: case intro.intro.intro
n✝ b n : ℕ
b2 : 1 < b
b0 : 0 < b
n0 : 0 < n
m0 : 0 < n / b
hr : n % b < b
e : n % b + b * (n / b) = n
⊢ b.digits n = n % b :: b.digits (n / b)
state_after: no goals
tactic: exact Nat.digits_def' b2 n0
Theorem: Order.le_succ_of_wcovBy
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ⩿ b
⊢ b ≤ succ a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ⩿ b
hab : a ⋖ b
⊢ b ≤ succ a

case inr.intro
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ⩿ b
hba : b ≤ a
⊢ b ≤ succ a
tactic: obtain hab | ⟨-, hba⟩ := h.covBy_or_le_and_le
Theorem: AmpleSet.of_one_lt_codim
File: Mathlib/Analysis/Convex/AmpleSet.lean

Proof steps:
state_before: F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
⊢ (convexHull ℝ) (connectedComponentIn (↑E)ᶜ x) = univ
state_after: F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
⊢ ∀ (x : F), x ∈ (convexHull ℝ) (↑E)ᶜ
tactic: rw [E.connectedComponentIn_eq_self_of_one_lt_codim hcodim hx, eq_univ_iff_forall]
state_before: F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
⊢ ∀ (x : F), x ∈ (convexHull ℝ) (↑E)ᶜ
state_after: F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
y : F
⊢ y ∈ (convexHull ℝ) (↑E)ᶜ
tactic: intro y
state_before: F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
y : F
⊢ y ∈ (convexHull ℝ) (↑E)ᶜ
state_after: case pos
F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
y : F
h : y ∈ E
⊢ y ∈ (convexHull ℝ) (↑E)ᶜ

case neg
F : Type u_1
inst✝⁷ : AddCommGroup F
inst✝⁶ : Module ℝ F
inst✝⁵ : TopologicalSpace F
E✝ : Type u_2
inst✝⁴ : AddCommGroup E✝
inst✝³ : Module ℝ E✝
inst✝² : TopologicalSpace E✝
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousSMul ℝ F
E : Submodule ℝ F
hcodim : 1 < Module.rank ℝ (F ⧸ E)
x : F
hx : x ∈ (↑E)ᶜ
y : F
h : y ∉ E
⊢ y ∈ (convexHull ℝ) (↑E)ᶜ
tactic: by_cases h : y ∈ E
Theorem: List.perm_of_mem_permutationsAux
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ ∀ {ts is l : List α}, l ∈ ts.permutationsAux is → l ~ ts ++ is
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ ∀ (ts is l : List α), l ∈ ts.permutationsAux is → l ~ ts ++ is
tactic: show ∀ (ts is l : List α), l ∈ permutationsAux ts is → l ~ ts ++ is
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ ∀ (ts is l : List α), l ∈ ts.permutationsAux is → l ~ ts ++ is
state_after: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ ∀ (t : α) (ts is : List α),
    (∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is) →
      (∀ l ∈ is.permutationsAux [], l ~ is ++ []) → ∀ l ∈ (t :: ts).permutationsAux is, l ~ t :: ts ++ is
tactic: refine permutationsAux.rec (by simp) ?_
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
⊢ ∀ (t : α) (ts is : List α),
    (∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is) →
      (∀ l ∈ is.permutationsAux [], l ~ is ++ []) → ∀ l ∈ (t :: ts).permutationsAux is, l ~ t :: ts ++ is
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l : List α
m : l ∈ (t :: ts).permutationsAux is
⊢ l ~ t :: ts ++ is
tactic: introv IH1 IH2 m
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l : List α
m : l ∈ (t :: ts).permutationsAux is
⊢ l ~ t :: ts ++ is
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l : List α
m :
  l ∈ ts.permutationsAux (t :: is) ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ is :: is.permutationsAux [] ∧ l₂ ≠ [] ∧ l = l₁ ++ t :: l₂ ++ ts
⊢ l ~ t :: ts ++ is
tactic: rw [permutationsAux_cons, permutations, mem_foldr_permutationsAux2] at m
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l : List α
m :
  l ∈ ts.permutationsAux (t :: is) ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ is :: is.permutationsAux [] ∧ l₂ ≠ [] ∧ l = l₁ ++ t :: l₂ ++ ts
⊢ l ~ t :: ts ++ is
state_after: case inl
α : Type u_1
β : Type u_2
l✝ l₁ l₂ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l : List α
m : l ∈ ts.permutationsAux (t :: is)
⊢ l ~ t :: ts ++ is

case inr.intro.intro.intro.intro
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a t : α
ts is : List α
IH1 : ∀ l ∈ ts.permutationsAux (t :: is), l ~ ts ++ t :: is
IH2 : ∀ l ∈ is.permutationsAux [], l ~ is ++ []
l₁ l₂ : List α
m : l₁ ++ l₂ ∈ is :: is.permutationsAux []
left✝ : l₂ ≠ []
⊢ l₁ ++ t :: l₂ ++ ts ~ t :: ts ++ is
tactic: rcases m with (m | ⟨l₁, l₂, m, _, rfl⟩)
Theorem: List.get_iterate
File: Mathlib/Data/List/Iterate.lean

Proof steps:
state_before: α : Type u_1
f : α → α
a : α
n : ℕ
i : Fin (iterate f a n).length
⊢ (iterate f a n).get i = f^[↑i] a
state_after: no goals
tactic: simp
Theorem: normEDS_odd
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ normEDS b c d (2 * (↑m + 2) + 1) =
    normEDS b c d (↑m + 4) * normEDS b c d (↑m + 2) ^ 3 - normEDS b c d (↑m + 1) * normEDS b c d (↑m + 3) ^ 3
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (preNormEDS' (b ^ 4) c d (2 * (m + 2) + 1) * if Even (2 * (m + 2) + 1) then b else 1) =
    (preNormEDS' (b ^ 4) c d (m + 4) * if Even (m + 4) then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 2) * if Even (m + 2) then b else 1) ^ 3 -
      (preNormEDS' (b ^ 4) c d (m + 1) * if Even (m + 1) then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 3) * if Even (m + 3) then b else 1) ^ 3
tactic: repeat erw [normEDS_ofNat]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ (preNormEDS' (b ^ 4) c d (2 * (m + 2) + 1) * if Even (2 * (m + 2) + 1) then b else 1) =
    (preNormEDS' (b ^ 4) c d (m + 4) * if Even (m + 4) then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 2) * if Even (m + 2) then b else 1) ^ 3 -
      (preNormEDS' (b ^ 4) c d (m + 1) * if Even (m + 1) then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 3) * if Even (m + 3) then b else 1) ^ 3
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ ((preNormEDS' (b ^ 4) c d (m + 4) * preNormEDS' (b ^ 4) c d (m + 2) ^ 3 * if Even m then b ^ 4 else 1) -
        preNormEDS' (b ^ 4) c d (m + 1) * preNormEDS' (b ^ 4) c d (m + 3) ^ 3 * if Even m then 1 else b ^ 4) *
      1 =
    (preNormEDS' (b ^ 4) c d (m + 4) * if Even m then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 2) * if Even m then b else 1) ^ 3 -
      (preNormEDS' (b ^ 4) c d (m + 1) * if Even m then 1 else b) *
        (preNormEDS' (b ^ 4) c d (m + 3) * if Even m then 1 else b) ^ 3
tactic: simp_rw [preNormEDS'_odd, if_neg (m + 2).not_even_two_mul_add_one, Nat.even_add_one, ite_not]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ ((preNormEDS' (b ^ 4) c d (m + 4) * preNormEDS' (b ^ 4) c d (m + 2) ^ 3 * if Even m then b ^ 4 else 1) -
        preNormEDS' (b ^ 4) c d (m + 1) * preNormEDS' (b ^ 4) c d (m + 3) ^ 3 * if Even m then 1 else b ^ 4) *
      1 =
    (preNormEDS' (b ^ 4) c d (m + 4) * if Even m then b else 1) *
        (preNormEDS' (b ^ 4) c d (m + 2) * if Even m then b else 1) ^ 3 -
      (preNormEDS' (b ^ 4) c d (m + 1) * if Even m then 1 else b) *
        (preNormEDS' (b ^ 4) c d (m + 3) * if Even m then 1 else b) ^ 3
state_after: no goals
tactic: split_ifs <;> ring1
Theorem: HomologicalComplex.unopSymm_d
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.22527, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c.symm
i j : ι
hij : ¬c.Rel i j
⊢ (fun i j => (X.d j i).unop) i j = 0
state_after: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.22527, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c.symm
i j : ι
hij : ¬c.Rel i j
⊢ (X.d j i).unop = 0
tactic: simp only
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.22527, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c.symm
i j : ι
hij : ¬c.Rel i j
⊢ (X.d j i).unop = 0
state_after: no goals
tactic: rw [X.shape j i hij, unop_zero]
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.22527, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X : HomologicalComplex Vᵒᵖ c.symm
x✝⁴ x✝³ x✝² : ι
x✝¹ : c.Rel x✝⁴ x✝³
x✝ : c.Rel x✝³ x✝²
⊢ (fun i j => (X.d j i).unop) x✝⁴ x✝³ ≫ (fun i j => (X.d j i).unop) x✝³ x✝² = 0
state_after: no goals
tactic: rw [← unop_comp, X.d_comp_d, unop_zero]
Theorem: inv_div_inv
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✝ : DivisionCommMonoid α
a b c d : α
⊢ a⁻¹ / b⁻¹ = b / a
state_after: no goals
tactic: simp
Theorem: boole_nsmul
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✝¹ : Monoid M
a✝ b c : M
m n : ℕ
P : Prop
inst✝ : Decidable P
a : M
⊢ (a ^ if P then 1 else 0) = if P then a else 1
state_after: no goals
tactic: simp only [pow_ite, pow_one, pow_zero]
Theorem: IsNoetherian.injective_of_surjective_of_injective
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
i f : N →ₗ[R] M
hi : Injective ⇑i
hf : Surjective ⇑f
⊢ Injective ⇑f
state_after: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
i f : N →ₗ[R] M
hi : Injective ⇑i
hf : Surjective ⇑f
this : IsNoetherian R N
⊢ Injective ⇑f
tactic: haveI := isNoetherian_of_injective i hi
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
i f : N →ₗ[R] M
hi : Injective ⇑i
hf : Surjective ⇑f
this : IsNoetherian R N
⊢ Injective ⇑f
state_after: case intro
R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
i f : N →ₗ[R] M
hi : Injective ⇑i
hf : Surjective ⇑f
this : IsNoetherian R N
n : ℕ
H :
  ∀ (m : ℕ),
    n ≤ m →
      { toFun := fun n => f.iterateMapComap i n ⊥, monotone' := ⋯ } n =
        { toFun := fun n => f.iterateMapComap i n ⊥, monotone' := ⋯ } m
⊢ Injective ⇑f
tactic: obtain ⟨n, H⟩ := monotone_stabilizes_iff_noetherian.2 ‹_›
    ⟨_, monotone_nat_of_le_succ <| f.iterateMapComap_le_succ i ⊥ (by simp)⟩
state_before: case intro
R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup N
inst✝³ : Module R N
inst✝² : AddCommGroup P
inst✝¹ : Module R P
inst✝ : IsNoetherian R M
i f : N →ₗ[R] M
hi : Injective ⇑i
hf : Surjective ⇑f
this : IsNoetherian R N
n : ℕ
H :
  ∀ (m : ℕ),
    n ≤ m →
      { toFun := fun n => f.iterateMapComap i n ⊥, monotone' := ⋯ } n =
        { toFun := fun n => f.iterateMapComap i n ⊥, monotone' := ⋯ } m
⊢ Injective ⇑f
state_after: no goals
tactic: exact LinearMap.ker_eq_bot.1 <| bot_unique <|
    f.ker_le_of_iterateMapComap_eq_succ i ⊥ n (H _ (Nat.le_succ _)) hf hi
Theorem: TypeVec.subtypeVal_diagSub
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} n
⊢ subtypeVal α.repeatEq ⊚ diagSub = prod.diag
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
tactic: ext i x
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} n
i : Fin2 n
x : α i
⊢ (subtypeVal α.repeatEq ⊚ diagSub) i x = prod.diag i x
state_after: case a.h.fz
n n✝ : ℕ
α : TypeVec.{u_1} (n✝ + 1)
x : α Fin2.fz
⊢ (subtypeVal α.repeatEq ⊚ diagSub) Fin2.fz x = prod.diag Fin2.fz x

case a.h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec.{u_1} n✝} (x : α a✝), (subtypeVal α.repeatEq ⊚ diagSub) a✝ x = prod.diag a✝ x
α : TypeVec.{u_1} (n✝ + 1)
x : α a✝.fs
⊢ (subtypeVal α.repeatEq ⊚ diagSub) a✝.fs x = prod.diag a✝.fs x
tactic: induction' i with _ _ _ i_ih