ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.FullyFaithful.preimageIso_hom
File: Mathlib/CategoryTheory/Functor/FullyFaithful.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u_1
inst✝ : Category.{?u.10067, u_1} E
X✝¹ Y✝¹ : C
F : C ⥤ D
X✝ Y✝ Z : C
hF : F.FullyFaithful
X Y : C
e : F.obj X ≅ F.obj Y
⊢ F.map (hF.preimage e.hom ≫ hF.preimage e.inv) = F.map (𝟙 X)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u_1
inst✝ : Category.{?u.10067, u_1} E
X✝¹ Y✝¹ : C
F : C ⥤ D
X✝ Y✝ Z : C
hF : F.FullyFaithful
X Y : C
e : F.obj X ≅ F.obj Y
⊢ F.map (hF.preimage e.inv ≫ hF.preimage e.hom) = F.map (𝟙 Y)
state_after: no goals
tactic: simp
Theorem: IsAddUnit.neg_add_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
⊢ IsUnit a → a⁻¹ * a = 1
state_after: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1
tactic: rintro ⟨u, rfl⟩
state_before: case intro
α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
b c : α
u : αˣ
⊢ (↑u)⁻¹ * ↑u = 1
state_after: no goals
tactic: rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
Theorem: rat_add_continuous_lemma
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
ε : α
ε0 : 0 < ε
a₁ a₂ b₁ b₂ : β
h₁ : abv (a₁ - b₁) < ε / 2
h₂ : abv (a₂ - b₂) < ε / 2
⊢ abv (a₁ + a₂ - (b₁ + b₂)) < ε
state_after: no goals
tactic: simpa [add_halves, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using
      lt_of_le_of_lt (abv_add abv _ _) (add_lt_add h₁ h₂)
Theorem: CategoryTheory.eqToIso_trans
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y Z : C
p : X = Y
q : Y = Z
⊢ eqToIso p ≪≫ eqToIso q = eqToIso ⋯
state_after: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y Z : C
p : X = Y
q : Y = Z
⊢ (eqToIso p ≪≫ eqToIso q).hom = (eqToIso ⋯).hom
tactic: ext
state_before: case w
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y Z : C
p : X = Y
q : Y = Z
⊢ (eqToIso p ≪≫ eqToIso q).hom = (eqToIso ⋯).hom
state_after: no goals
tactic: simp
Theorem: List.length_erase_of_mem
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l : List α
h : a ∈ l
⊢ (l.erase a).length = l.length.pred
state_after: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l : List α
h : a ∈ l
⊢ (eraseP (fun x => a == x) l).length = l.length.pred
tactic: rw [erase_eq_eraseP]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l : List α
h : a ∈ l
⊢ (eraseP (fun x => a == x) l).length = l.length.pred
state_after: no goals
tactic: exact length_eraseP_of_mem h (beq_self_eq_true a)
Theorem: Finset.diag_mem_sym2_iff
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
m : Sym2 α
⊢ Sym2.diag a ∈ s.sym2 ↔ a ∈ s
state_after: no goals
tactic: simp [diag_mem_sym2_mem_iff]
Theorem: GroupFilterBasis.nhds_one_eq
File: Mathlib/Topology/Algebra/FilterBasis.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ 𝓝 1 = toFilterBasis.filter
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ B.N 1 = toFilterBasis.filter
tactic: rw [B.nhds_eq]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ B.N 1 = toFilterBasis.filter
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ map (fun y => y) toFilterBasis.filter = toFilterBasis.filter
tactic: simp only [N, one_mul]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
⊢ map (fun y => y) toFilterBasis.filter = toFilterBasis.filter
state_after: no goals
tactic: exact map_id
Theorem: MeasureTheory.integrable_withDensity_iff_integrable_coe_smul
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : MeasurableSpace δ
inst✝³ : NormedAddCommGroup β
inst✝² : NormedAddCommGroup γ
E : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α → ℝ≥0
hf : Measurable f
g : α → E
⊢ Integrable g (μ.withDensity fun x => ↑(f x)) ↔ Integrable (fun x => ↑(f x) • g x) μ
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : MeasurableSpace δ
inst✝³ : NormedAddCommGroup β
inst✝² : NormedAddCommGroup γ
E : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α → ℝ≥0
hf : Measurable f
g : α → E
H : AEStronglyMeasurable (fun x => ↑(f x) • g x) μ
⊢ Integrable g (μ.withDensity fun x => ↑(f x)) ↔ Integrable (fun x => ↑(f x) • g x) μ

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : MeasurableSpace δ
inst✝³ : NormedAddCommGroup β
inst✝² : NormedAddCommGroup γ
E : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : α → ℝ≥0
hf : Measurable f
g : α → E
H : ¬AEStronglyMeasurable (fun x => ↑(f x) • g x) μ
⊢ Integrable g (μ.withDensity fun x => ↑(f x)) ↔ Integrable (fun x => ↑(f x) • g x) μ
tactic: by_cases H : AEStronglyMeasurable (fun x : α => (f x : ℝ) • g x) μ
Theorem: Pell.xy_succ_succ
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
this : pellZd a1 (n + 2) + pellZd a1 n = ↑(2 * a) * pellZd a1 (n + 1)
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
tactic: have := pellZd_succ_succ a1 n
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this : pellZd a1 (n + 2) + pellZd a1 n = ↑(2 * a) * pellZd a1 (n + 1)
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    ↑(2 * a) * { re := ↑(xn a1 (n + 1)), im := ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
tactic: unfold pellZd at this
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    ↑(2 * a) * { re := ↑(xn a1 (n + 1)), im := ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    { re := ↑(2 * a) * ↑(xn a1 (n + 1)), im := ↑(2 * a) * ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
tactic: erw [Zsqrtd.smul_val (2 * a : ℕ)] at this
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    { re := ↑(2 * a) * ↑(xn a1 (n + 1)), im := ↑(2 * a) * ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
h₁ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.re + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.re =
    ↑(2 * a) * ↑(xn a1 (n + 1))
h₂ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.im + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.im =
    ↑(2 * a) * ↑(yn a1 (n + 1))
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
tactic: injection this with h₁ h₂
state_before: a : ℕ
a1 : 1 < a
n : ℕ
h₁ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.re + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.re =
    ↑(2 * a) * ↑(xn a1 (n + 1))
h₂ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.im + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.im =
    ↑(2 * a) * ↑(yn a1 (n + 1))
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
state_after: no goals
tactic: constructor <;> apply Int.ofNat.inj <;> [simpa using h₁; simpa using h₂]
Theorem: Nat.findGreatest_mono_right
File: Mathlib/Data/Nat/Find.lean

Proof steps:
state_before: a b c d m✝ n✝¹ k : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n : ℕ
hmn : m ≤ n
⊢ findGreatest P m ≤ findGreatest P n
state_after: case refl
a b c d m✝ n✝¹ k : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n : ℕ
⊢ findGreatest P m ≤ findGreatest P m

case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ findGreatest P k.succ
tactic: induction' hmn with k hmk ih
state_before: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ findGreatest P k.succ
state_after: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ if P (k + 1) then k + 1 else findGreatest P k
tactic: rw [findGreatest_succ]
state_before: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ if P (k + 1) then k + 1 else findGreatest P k
state_after: case pos
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : P (k + 1)
⊢ findGreatest P m ≤ k + 1

case neg
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : ¬P (k + 1)
⊢ findGreatest P m ≤ findGreatest P k
tactic: split_ifs
Theorem: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = K.ι (I.sndTo b) ≫ I.snd b
state_after: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.sndTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.snd b) =
    K.ι (I.sndTo b) ≫ I.snd b
tactic: rw [← K.w (WalkingMulticospan.Hom.snd b)]
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (I.sndTo b)) ≫ I.multicospan.map (WalkingMulticospan.Hom.snd b) =
    K.ι (I.sndTo b) ≫ I.snd b
state_after: no goals
tactic: rfl
Theorem: AddSubmonoid.closure_induction'
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
one : p 1 ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ p x hx
state_after: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
one : p 1 ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1
tactic: refine Exists.elim ?_ fun (hx : x ∈ closure s) (hc : p x hx) => hc
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : MulOneClass M
s✝ : Set M
inst✝ : AddZeroClass A
t : Set A
S : Submonoid M
s : Set M
p : (x : M) → x ∈ closure s → Prop
mem : ∀ (x : M) (h : x ∈ s), p x ⋯
one : p 1 ⋯
mul : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ closure s), p x hx → p y hy → p (x * y) ⋯
x : M
hx : x ∈ closure s
⊢ ∃ (x_1 : x ∈ closure s), p x x_1
state_after: no goals
tactic: exact
    closure_induction hx (fun x hx => ⟨_, mem x hx⟩) ⟨_, one⟩ fun x y ⟨hx', hx⟩ ⟨hy', hy⟩ =>
      ⟨_, mul _ _ _ _ hx hy⟩
Theorem: Wbtw.left_ne_right_of_ne_left
File: Mathlib/Analysis/Convex/Between.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✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
h : Wbtw R x y z
hne : y ≠ x
⊢ x ≠ z
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : Wbtw R x y x
⊢ False
tactic: rintro rfl
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : Wbtw R x y x
⊢ False
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : y = x
⊢ False
tactic: rw [wbtw_self_iff] at h
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y : P
hne : y ≠ x
h : y = x
⊢ False
state_after: no goals
tactic: exact hne h
Theorem: Polynomial.monic_of_injective
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
hp : (map f p).Monic
⊢ p.Monic
state_after: case a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
hp : (map f p).Monic
⊢ f p.leadingCoeff = f 1
tactic: apply hf
state_before: case a
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
hp : (map f p).Monic
⊢ f p.leadingCoeff = f 1
state_after: no goals
tactic: rw [← leadingCoeff_of_injective hf, hp.leadingCoeff, f.map_one]
Theorem: Stream'.mem_map
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
s : Stream' α
x✝ : a ∈ s
n : ℕ
h : (fun b => a = b) (s.get n)
⊢ (fun b => f a = b) ((map f s).get n)
state_after: no goals
tactic: rw [get_map, h]
Theorem: sub_one_zsmul
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 : G
n : ℤ
⊢ a ^ (n - 1) * a * a⁻¹ = a ^ n * a⁻¹
state_after: no goals
tactic: rw [← zpow_add_one, Int.sub_add_cancel]
Theorem: mul_le_of_le_one_left
File: Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean

Proof steps:
state_before: α : Type u_1
a b c d : α
inst✝³ : MulOneClass α
inst✝² : Zero α
inst✝¹ : Preorder α
inst✝ : MulPosMono α
hb : 0 ≤ b
h : a ≤ 1
⊢ a * b ≤ b
state_after: no goals
tactic: simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
Theorem: Asymptotics.SuperpolynomialDecay.mul_const
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : CommSemiring β
inst✝ : ContinuousMul β
hf : SuperpolynomialDecay l k f
c : β
z : ℕ
⊢ Tendsto (fun a => k a ^ z * (fun n => f n * c) a) l (𝓝 0)
state_after: no goals
tactic: simpa only [← mul_assoc, zero_mul] using Tendsto.mul_const c (hf z)
Theorem: ite_eq_iff
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
σ : α → Sort u_2
P Q R : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ ((∃ h, a = c) ∨ ∃ h, b = c) ↔ P ∧ a = c ∨ ¬P ∧ b = c
state_after: no goals
tactic: rw [exists_prop, exists_prop]
Theorem: SimplicialObject.Splitting.comp_PInfty_eq_zero_iff
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Z : C
n : ℕ
f : Z ⟶ X _[n]
⊢ f ≫ PInfty.f n = 0 ↔ f ≫ s.πSummand (IndexSet.id (op [n])) = 0
state_after: case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Z : C
n : ℕ
f : Z ⟶ X _[n]
⊢ f ≫ PInfty.f n = 0 → f ≫ s.πSummand (IndexSet.id (op [n])) = 0

case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
X : SimplicialObject C
s : Splitting X
inst✝ : Preadditive C
Z : C
n : ℕ
f : Z ⟶ X _[n]
⊢ f ≫ s.πSummand (IndexSet.id (op [n])) = 0 → f ≫ PInfty.f n = 0
tactic: constructor
Theorem: Equiv.Perm.card_support_ne_one
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ f.support.card ≠ 1
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f = 1
⊢ f.support.card ≠ 1

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : ¬f = 1
⊢ f.support.card ≠ 1
tactic: by_cases h : f = 1
Theorem: isSemisimpleModule_of_isSemisimpleModule_submodule
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
s : Set ι
p : ι → Submodule R M
hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)
hp' : ⨆ i ∈ s, p i = ⊤
⊢ IsSemisimpleModule R M
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
s : Set ι
p : ι → Submodule R M
hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)
hp' : ⨆ i ∈ s, p i = ⊤
i : ι
hi : i ∈ s
⊢ ComplementedLattice ↑(Set.Iic (p i))
tactic: refine complementedLattice_of_complementedLattice_Iic (fun i hi ↦ ?_) hp'
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁵ : Ring R
inst✝⁴ : Ring S
M : Type u_4
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type u_5
inst✝¹ : AddCommGroup N
inst✝ : Module R N
s : Set ι
p : ι → Submodule R M
hp : ∀ i ∈ s, IsSemisimpleModule R ↥(p i)
hp' : ⨆ i ∈ s, p i = ⊤
i : ι
hi : i ∈ s
⊢ ComplementedLattice ↑(Set.Iic (p i))
state_after: no goals
tactic: simpa only [← (p i).mapIic.complementedLattice_iff] using hp i hi
Theorem: Matroid.Basis.basis_sUnion
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃₀ Xs)
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃ i, ↑i)
tactic: rw [sUnion_eq_iUnion]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
⊢ M.Basis I (⋃ i, ↑i)
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
this : Nonempty ↑Xs
⊢ M.Basis I (⋃ i, ↑i)
tactic: have := Iff.mpr nonempty_coe_sort hne
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
Xs : Set (Set α)
hne : Xs.Nonempty
h : ∀ X ∈ Xs, M.Basis I X
this : Nonempty ↑Xs
⊢ M.Basis I (⋃ i, ↑i)
state_after: no goals
tactic: exact Basis.basis_iUnion _ fun X ↦ (h X X.prop)
Theorem: CategoryTheory.Limits.colimit_map_colimitObjIsoColimitCompEvaluation_hom
File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
⊢ (colimit F).map f ≫ (colimitObjIsoColimitCompEvaluation F j).hom =
    (colimitObjIsoColimitCompEvaluation F i).hom ≫ colimMap (whiskerLeft F ((evaluation K C).map f))
state_after: no goals
tactic: rw [← Iso.inv_comp_eq, ← Category.assoc, ← Iso.eq_comp_inv,
    colimitObjIsoColimitCompEvaluation_inv_colimit_map]
Theorem: ValuationSubring.toSubring_injective
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A x y : ValuationSubring K
h : x.toSubring = y.toSubring
⊢ x = y
state_after: case mk
K : Type u
inst✝ : Field K
A y : ValuationSubring K
toSubring✝ : Subring K
mem_or_inv_mem'✝ : ∀ (x : K), x ∈ toSubring✝.carrier ∨ x⁻¹ ∈ toSubring✝.carrier
h : { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }.toSubring = y.toSubring
⊢ { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ } = y
tactic: cases x
state_before: case mk
K : Type u
inst✝ : Field K
A y : ValuationSubring K
toSubring✝ : Subring K
mem_or_inv_mem'✝ : ∀ (x : K), x ∈ toSubring✝.carrier ∨ x⁻¹ ∈ toSubring✝.carrier
h : { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }.toSubring = y.toSubring
⊢ { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ } = y
state_after: case mk.mk
K : Type u
inst✝ : Field K
A : ValuationSubring K
toSubring✝¹ : Subring K
mem_or_inv_mem'✝¹ : ∀ (x : K), x ∈ toSubring✝¹.carrier ∨ x⁻¹ ∈ toSubring✝¹.carrier
toSubring✝ : Subring K
mem_or_inv_mem'✝ : ∀ (x : K), x ∈ toSubring✝.carrier ∨ x⁻¹ ∈ toSubring✝.carrier
h :
  { toSubring := toSubring✝¹, mem_or_inv_mem' := mem_or_inv_mem'✝¹ }.toSubring =
    { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }.toSubring
⊢ { toSubring := toSubring✝¹, mem_or_inv_mem' := mem_or_inv_mem'✝¹ } =
    { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }
tactic: cases y
state_before: case mk.mk
K : Type u
inst✝ : Field K
A : ValuationSubring K
toSubring✝¹ : Subring K
mem_or_inv_mem'✝¹ : ∀ (x : K), x ∈ toSubring✝¹.carrier ∨ x⁻¹ ∈ toSubring✝¹.carrier
toSubring✝ : Subring K
mem_or_inv_mem'✝ : ∀ (x : K), x ∈ toSubring✝.carrier ∨ x⁻¹ ∈ toSubring✝.carrier
h :
  { toSubring := toSubring✝¹, mem_or_inv_mem' := mem_or_inv_mem'✝¹ }.toSubring =
    { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }.toSubring
⊢ { toSubring := toSubring✝¹, mem_or_inv_mem' := mem_or_inv_mem'✝¹ } =
    { toSubring := toSubring✝, mem_or_inv_mem' := mem_or_inv_mem'✝ }
state_after: no goals
tactic: congr
Theorem: CategoryTheory.Idempotents.Karoubi.p_comp
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : Karoubi C
f : P.Hom Q
⊢ P.p ≫ f.f = f.f
state_after: no goals
tactic: rw [f.comm, ← assoc, P.idem]
Theorem: Batteries.RBNode.reverse_setRed
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
t : RBNode α
⊢ t.setRed.reverse = t.reverse.setRed
state_after: α : Type u_1
t : RBNode α
⊢ (match t with
      | node c a v b => node red a v b
      | nil => nil).reverse =
    match t.reverse with
    | node c a v b => node red a v b
    | nil => nil
tactic: unfold setRed
state_before: α : Type u_1
t : RBNode α
⊢ (match t with
      | node c a v b => node red a v b
      | nil => nil).reverse =
    match t.reverse with
    | node c a v b => node red a v b
    | nil => nil
state_after: no goals
tactic: split <;> simp