ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddSubgroup.mem_closure_singleton
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
⊢ y ∈ closure {x} ↔ ∃ n, x ^ n = y
state_after: case refine_1
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ x_1 ∈ {x}, ∃ n, x ^ n = x_1

case refine_2
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∃ n, x ^ n = 1

case refine_3
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 y : G), (∃ n, x ^ n = x_1) → (∃ n, x ^ n = y) → ∃ n, x ^ n = x_1 * y

case refine_4
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 : G), (∃ n, x ^ n = x_1) → ∃ n, x ^ n = x_1⁻¹
tactic: refine
    ⟨fun hy => closure_induction hy ?_ ?_ ?_ ?_, fun ⟨n, hn⟩ =>
      hn ▸ zpow_mem (subset_closure <| mem_singleton x) n⟩
state_before: case refine_4
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 : G), (∃ n, x ^ n = x_1) → ∃ n, x ^ n = x_1⁻¹
state_after: case refine_4.intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
n : ℤ
⊢ ∃ n_1, x ^ n_1 = (x ^ n)⁻¹
tactic: rintro _ ⟨n, rfl⟩
state_before: case refine_4.intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
n : ℤ
⊢ ∃ n_1, x ^ n_1 = (x ^ n)⁻¹
state_after: no goals
tactic: exact ⟨-n, zpow_neg x n⟩
Theorem: List.coe_le_maximum_iff
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
⊢ ↑a ≤ l.maximum ↔ ∃ b, b ∈ l ∧ a ≤ b
state_after: no goals
tactic: induction l with
  | nil => simp
  | cons h t ih =>
    simp [maximum_cons, ih]
Theorem: Basis.mem_submodule_iff'
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
S : Type u_10
inst✝³ : Semiring S
inst✝² : Module S M'
inst✝¹ : SMulCommClass R S M'
inst✝ : Fintype ι
P : Submodule R M
b : Basis ι R ↥P
x : M
c : ι → R
⊢ (x = (Finsupp.equivFunOnFinite.symm c).sum fun i x => x • ↑(b i)) ↔ x = ∑ i : ι, c i • ↑(b i)
state_after: no goals
tactic: simp [Finsupp.sum_fintype, Finsupp.equivFunOnFinite]
Theorem: CategoryTheory.IsHomLift.domain_eq
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
inst✝ : p.IsHomLift f φ
⊢ p.obj a = R
state_after: case map
𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a✝ b✝ : 𝒳
φ : a✝ ⟶ b✝
R S : 𝒮
a b : 𝒳
inst✝ : p.IsHomLift (p.map φ) φ
⊢ p.obj a✝ = p.obj a✝
tactic: subst_hom_lift p f φ
state_before: case map
𝒮 : Type u₁
𝒳 : Type u₂
inst✝² : Category.{v₁, u₂} 𝒳
inst✝¹ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a✝ b✝ : 𝒳
φ : a✝ ⟶ b✝
R S : 𝒮
a b : 𝒳
inst✝ : p.IsHomLift (p.map φ) φ
⊢ p.obj a✝ = p.obj a✝
state_after: no goals
tactic: rfl
Theorem: Subgroup.IsComplement.equiv_fst_eq_self_iff_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
⊢ ↑(hST.equiv g).1 = g ↔ g ∈ S
state_after: case mp
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
⊢ ↑(hST.equiv g).1 = g → g ∈ S

case mpr
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
⊢ g ∈ S → ↑(hST.equiv g).1 = g
tactic: constructor
Theorem: Set.image_comp
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
f : β → γ
g : α → β
a : Set α
⊢ f ∘ g '' a = f '' (g '' a)
state_after: no goals
tactic: aesop
Theorem: SetTheory.PGame.powHalf_moveLeft
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: n : ℕ
i : (powHalf n).LeftMoves
⊢ (powHalf n).moveLeft i = 0
state_after: no goals
tactic: cases n <;> cases i <;> rfl
Theorem: CovBy.exists_finset_erase
File: Mathlib/Data/Finset/Grade.lean

Proof steps:
state_before: α : Type u_1
s t : Finset α
a : α
inst✝ : DecidableEq α
h : s ⋖ t
⊢ ∃ a ∈ t, t.erase a = s
state_after: no goals
tactic: simpa only [← coe_inj, coe_erase] using h.finset_coe.exists_set_sdiff_singleton
Theorem: ContinuousLinearEquiv.arrowCongrEquiv_apply
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝³¹ : Semiring R₁
inst✝³⁰ : Semiring R₂
inst✝²⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²⁸ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁷ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝²⁶ : RingHomInvPair σ₂₃ σ₃₂
inst✝²⁵ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝²⁴ : RingHomInvPair σ₁₃ σ₃₁
inst✝²³ : RingHomInvPair σ₃₁ σ₁₃
inst✝²² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝²¹ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_4
inst✝²⁰ : TopologicalSpace M₁
inst✝¹⁹ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁸ : TopologicalSpace M'₁
inst✝¹⁷ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁶ : TopologicalSpace M₂
inst✝¹⁵ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁴ : TopologicalSpace M₃
inst✝¹³ : AddCommMonoid M₃
M₄ : Type u_8
inst✝¹² : TopologicalSpace M₄
inst✝¹¹ : AddCommMonoid M₄
inst✝¹⁰ : Module R₁ M₁
inst✝⁹ : Module R₁ M'₁
inst✝⁸ : Module R₂ M₂
inst✝⁷ : Module R₃ M₃
R₄ : Type u_9
inst✝⁶ : Semiring R₄
inst✝⁵ : Module R₄ M₄
σ₃₄ : R₃ →+* R₄
σ₄₃ : R₄ →+* R₃
inst✝⁴ : RingHomInvPair σ₃₄ σ₄₃
inst✝³ : RingHomInvPair σ₄₃ σ₃₄
σ₂₄ : R₂ →+* R₄
σ₁₄ : R₁ →+* R₄
inst✝² : RingHomCompTriple σ₂₁ σ₁₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₂₄ σ₄₃ σ₂₃
inst✝ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
e₁₂ : M₁ ≃SL[σ₁₂] M₂
e₄₃ : M₄ ≃SL[σ₄₃] M₃
f : M₁ →SL[σ₁₄] M₄
x : M₁
⊢ ((fun f => (↑e₄₃.symm).comp (f.comp ↑e₁₂)) ((fun f => (↑e₄₃).comp (f.comp ↑e₁₂.symm)) f)) x = f x
state_after: no goals
tactic: simp only [ContinuousLinearMap.comp_apply, symm_apply_apply, coe_coe]
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝³¹ : Semiring R₁
inst✝³⁰ : Semiring R₂
inst✝²⁹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₁ : R₂ →+* R₁
inst✝²⁸ : RingHomInvPair σ₁₂ σ₂₁
inst✝²⁷ : RingHomInvPair σ₂₁ σ₁₂
σ₂₃ : R₂ →+* R₃
σ₃₂ : R₃ →+* R₂
inst✝²⁶ : RingHomInvPair σ₂₃ σ₃₂
inst✝²⁵ : RingHomInvPair σ₃₂ σ₂₃
σ₁₃ : R₁ →+* R₃
σ₃₁ : R₃ →+* R₁
inst✝²⁴ : RingHomInvPair σ₁₃ σ₃₁
inst✝²³ : RingHomInvPair σ₃₁ σ₁₃
inst✝²² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝²¹ : RingHomCompTriple σ₃₂ σ₂₁ σ₃₁
M₁ : Type u_4
inst✝²⁰ : TopologicalSpace M₁
inst✝¹⁹ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹⁸ : TopologicalSpace M'₁
inst✝¹⁷ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁶ : TopologicalSpace M₂
inst✝¹⁵ : AddCommMonoid M₂
M₃ : Type u_7
inst✝¹⁴ : TopologicalSpace M₃
inst✝¹³ : AddCommMonoid M₃
M₄ : Type u_8
inst✝¹² : TopologicalSpace M₄
inst✝¹¹ : AddCommMonoid M₄
inst✝¹⁰ : Module R₁ M₁
inst✝⁹ : Module R₁ M'₁
inst✝⁸ : Module R₂ M₂
inst✝⁷ : Module R₃ M₃
R₄ : Type u_9
inst✝⁶ : Semiring R₄
inst✝⁵ : Module R₄ M₄
σ₃₄ : R₃ →+* R₄
σ₄₃ : R₄ →+* R₃
inst✝⁴ : RingHomInvPair σ₃₄ σ₄₃
inst✝³ : RingHomInvPair σ₄₃ σ₃₄
σ₂₄ : R₂ →+* R₄
σ₁₄ : R₁ →+* R₄
inst✝² : RingHomCompTriple σ₂₁ σ₁₄ σ₂₄
inst✝¹ : RingHomCompTriple σ₂₄ σ₄₃ σ₂₃
inst✝ : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄
e₁₂ : M₁ ≃SL[σ₁₂] M₂
e₄₃ : M₄ ≃SL[σ₄₃] M₃
f : M₂ →SL[σ₂₃] M₃
x : M₂
⊢ ((fun f => (↑e₄₃).comp (f.comp ↑e₁₂.symm)) ((fun f => (↑e₄₃.symm).comp (f.comp ↑e₁₂)) f)) x = f x
state_after: no goals
tactic: simp only [ContinuousLinearMap.comp_apply, apply_symm_apply, coe_coe]
Theorem: exists_linearIndependent
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
state_after: case intro.intro.intro.intro
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
b : Set V
hb₁ : b ⊆ t
hb₂ : t ⊆ ↑(span K b)
hb₃ : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
tactic: obtain ⟨b, hb₁, -, hb₂, hb₃⟩ :=
    exists_linearIndependent_extension (linearIndependent_empty K V) (Set.empty_subset t)
state_before: case intro.intro.intro.intro
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
b : Set V
hb₁ : b ⊆ t
hb₂ : t ⊆ ↑(span K b)
hb₃ : LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
⊢ ∃ b ⊆ t, span K b = span K t ∧ LinearIndependent (ι := { x // x ∈ b }) K Subtype.val
state_after: no goals
tactic: exact ⟨b, hb₁, (span_eq_of_le _ hb₂ (Submodule.span_mono hb₁)).symm, hb₃⟩
Theorem: Cardinal.aleph'_limit
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph' o = ⨆ a, aleph' ↑a
state_after: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph' o ≤ ⨆ a, aleph' ↑a
tactic: refine le_antisymm ?_ (ciSup_le' fun i => aleph'_le.2 (le_of_lt i.2))
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ aleph' o ≤ ⨆ a, aleph' ↑a
state_after: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ o' < o, aleph' o' ≤ ⨆ a, aleph' ↑a
tactic: rw [aleph'_le_of_limit ho]
state_before: o : Ordinal.{u_1}
ho : o.IsLimit
⊢ ∀ o' < o, aleph' o' ≤ ⨆ a, aleph' ↑a
state_after: no goals
tactic: exact fun a ha => le_ciSup (bddAbove_of_small _) (⟨a, ha⟩ : Iio o)
Theorem: real_inner_self_eq_norm_mul_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
⊢ ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
h : re ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
⊢ ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
tactic: have h := @inner_self_eq_norm_mul_norm ℝ F _ _ _ x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : F
h : re ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
⊢ ⟪x, x⟫_ℝ = ‖x‖ * ‖x‖
state_after: no goals
tactic: simpa using h
Theorem: CategoryTheory.shiftFunctorComm_symm
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorComm C i j).symm = shiftFunctorComm C j i
state_after: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorComm C i j).symm.hom = (shiftFunctorComm C j i).hom
tactic: ext1
state_before: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorComm C i j).symm.hom = (shiftFunctorComm C j i).hom
state_after: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorComm C i j).inv = (shiftFunctorComm C j i).hom
tactic: dsimp
state_before: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ (shiftFunctorComm C i j).inv = (shiftFunctorComm C j i).hom
state_after: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ ((shiftFunctorAdd' C i j (i + j) ⋯).symm ≪≫ shiftFunctorAdd' C j i (i + j) ⋯).inv =
    ((shiftFunctorAdd' C j i (i + j) ⋯).symm ≪≫ shiftFunctorAdd' C i j (i + j) ⋯).hom
tactic: rw [shiftFunctorComm_eq C i j (i+j) rfl, shiftFunctorComm_eq C j i (i+j) (add_comm j i)]
state_before: case w
C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
i j : A
⊢ ((shiftFunctorAdd' C i j (i + j) ⋯).symm ≪≫ shiftFunctorAdd' C j i (i + j) ⋯).inv =
    ((shiftFunctorAdd' C j i (i + j) ⋯).symm ≪≫ shiftFunctorAdd' C i j (i + j) ⋯).hom
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.Multicoequalizer.hom_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
⊢ ∀ (j_1 : WalkingMultispan I.fstFrom I.sndFrom), colimit.ι I.multispan j_1 ≫ i = colimit.ι I.multispan j_1 ≫ j
state_after: case left
C : Type u
inst✝¹ : Category.{v, u} C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
a : I.L
⊢ colimit.ι I.multispan (WalkingMultispan.left a) ≫ i = colimit.ι I.multispan (WalkingMultispan.left a) ≫ j

case right
C : Type u
inst✝¹ : Category.{v, u} C
I : MultispanIndex C
inst✝ : HasMulticoequalizer I
W : C
i j : multicoequalizer I ⟶ W
h : ∀ (b : I.R), π I b ≫ i = π I b ≫ j
b : I.R
⊢ colimit.ι I.multispan (WalkingMultispan.right b) ≫ i = colimit.ι I.multispan (WalkingMultispan.right b) ≫ j
tactic: rintro (a | b)
Theorem: MulEquiv.mulDissociated_preimage
File: Mathlib/Combinatorics/Additive/Dissociation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CommGroup α
inst✝ : CommGroup β
s : Set α
t u : Finset α
d : ℕ
a : α
e : β ≃* α
⊢ MulDissociated (⇑e ⁻¹' s) ↔ MulDissociated s
state_after: no goals
tactic: simp [MulDissociated, InjOn, ← e.finsetCongr.forall_congr_right, ← e.apply_eq_iff_eq,
    (Finset.map_injective _).eq_iff]
Theorem: contDiffWithinAt_top
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ (∀ (m : ℕ), ↑m ≤ ⊤ → ContDiffWithinAt 𝕜 (↑m) f s x) ↔ ∀ (n : ℕ), ContDiffWithinAt 𝕜 (↑n) f s x
state_after: no goals
tactic: simp only [forall_prop_of_true, le_top]
Theorem: Set.encard_diff_singleton_add_one
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b : α
h : a ∈ s
⊢ (s \ {a}).encard + 1 = s.encard
state_after: no goals
tactic: rw [← encard_insert_of_not_mem (fun h ↦ h.2 rfl), insert_diff_singleton, insert_eq_of_mem h]
Theorem: Polynomial.cardinal_mk_le_max
File: Mathlib/Algebra/Polynomial/Cardinal.lean

Proof steps:
state_before: R : Type u
inst✝ : Semiring R
⊢ #R[X] ≤ max #R ℵ₀
state_after: case inl
R : Type u
inst✝ : Semiring R
h✝ : Subsingleton R
⊢ #R[X] ≤ max #R ℵ₀

case inr
R : Type u
inst✝ : Semiring R
h✝ : Nontrivial R
⊢ #R[X] ≤ max #R ℵ₀
tactic: cases subsingleton_or_nontrivial R
Theorem: CategoryTheory.Limits.IsInitial.hasInitial
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
h : IsInitial X
F : Discrete PEmpty.{1} ⥤ C
⊢ (X_1 : Discrete PEmpty.{1}) → F.obj X_1 ⟶ ((Functor.const (Discrete PEmpty.{1})).obj X).obj X_1
state_after: no goals
tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X : C
h : IsInitial X
F : Discrete PEmpty.{1} ⥤ C
⊢ ∀ ⦃X_1 Y : Discrete PEmpty.{1}⦄ (f : X_1 ⟶ Y),
    F.map f ≫ id (Discrete.casesOn Y fun as => ⋯.elim) =
      id (Discrete.casesOn X_1 fun as => ⋯.elim) ≫ ((Functor.const (Discrete PEmpty.{1})).obj X).map f
state_after: no goals
tactic: aesop_cat
Theorem: AnalyticOn.iteratedFDeriv
File: Mathlib/Analysis/Calculus/FDeriv/Analytic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
n : ℕ
⊢ AnalyticOn 𝕜 (_root_.iteratedFDeriv 𝕜 n f) s
state_after: case zero
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
⊢ AnalyticOn 𝕜 (_root_.iteratedFDeriv 𝕜 0 f) s

case succ
𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
inst✝ : CompleteSpace F
h : AnalyticOn 𝕜 f s
n : ℕ
IH : AnalyticOn 𝕜 (_root_.iteratedFDeriv 𝕜 n f) s
⊢ AnalyticOn 𝕜 (_root_.iteratedFDeriv 𝕜 (n + 1) f) s
tactic: induction' n with n IH
Theorem: TopologicalSpace.Opens.isCoatom_iff
File: Mathlib/Topology/Sets/Closeds.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsCoatom s ↔ ∃ x, s = (Closeds.singleton x).compl
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom (toDual s.compl.compl) ↔ ∃ x, s.compl.compl = (Closeds.singleton x).compl
tactic: rw [← s.compl_compl, ← isAtom_dual_iff_isCoatom]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom (toDual s.compl.compl) ↔ ∃ x, s.compl.compl = (Closeds.singleton x).compl
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom ((Closeds.complOrderIso α) s.compl) ↔ ∃ x, s.compl.compl = (Closeds.singleton x).compl
tactic: change IsAtom (Closeds.complOrderIso α s.compl) ↔ _
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Opens α
⊢ IsAtom ((Closeds.complOrderIso α) s.compl) ↔ ∃ x, s.compl.compl = (Closeds.singleton x).compl
state_after: no goals
tactic: simp only [(Closeds.complOrderIso α).isAtom_iff, Closeds.isAtom_iff,
    Closeds.compl_bijective.injective.eq_iff]
Theorem: Prefunctor.congr_map
File: Mathlib/Combinatorics/Quiver/Basic.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
inst✝¹ : Quiver U
inst✝ : Quiver V
F : U ⥤q V
X Y : U
f g : X ⟶ Y
h : f = g
⊢ F.map f = F.map g
state_after: no goals
tactic: rw [h]
Theorem: Ordnode.Sized.rotateL_size
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hm : r.Sized
⊢ (l.rotateL x r).size = l.size + r.size + 1
state_after: case node
α : Type u_1
l : Ordnode α
x : α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).size = l.size + size✝ + 1
tactic: cases r <;> simp [Ordnode.rotateL]
state_before: case node
α : Type u_1
l : Ordnode α
x : α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).size = l.size + size✝ + 1
state_after: case node
α : Type u_1
l : Ordnode α
x : α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).size =
    l.size + (l✝.size + r✝.size + 1) + 1
tactic: simp only [hm.1]
state_before: case node
α : Type u_1
l : Ordnode α
x : α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ (if l✝.size < ratio * r✝.size then l.node3L x l✝ x✝ r✝ else l.node4L x l✝ x✝ r✝).size =
    l.size + (l✝.size + r✝.size + 1) + 1
state_after: no goals
tactic: split_ifs <;> simp [node3L_size, node4L_size hm.2.1] <;> abel
Theorem: Rat.inv_mkRat
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q : ℚ
a : ℤ
b : ℕ
⊢ (mkRat a b)⁻¹ = ↑b /. a
state_after: no goals
tactic: rw [mkRat_eq_divInt, inv_divInt']
Theorem: CategoryTheory.StructuredArrow.IsUniversal.hom_ext
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
f g : StructuredArrow S T
h : f.IsUniversal
c : C
η η' : f.right ⟶ c
w : f.hom ≫ T.map η = f.hom ≫ T.map η'
⊢ η = η'
state_after: no goals
tactic: rw [h.hom_desc η, h.hom_desc η', w]
Theorem: div_eq_div_iff_comm
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✝ : DivisionMonoid α
a b c d : α
⊢ (a / b)⁻¹ = (c / d)⁻¹ ↔ b / a = d / c
state_after: no goals
tactic: simp only [inv_div]
Theorem: Submodule.IsPrincipal.generator_mem
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ S
state_after: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ span R {generator S}
tactic: conv_rhs => rw [← span_singleton_generator S]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ span R {generator S}
state_after: no goals
tactic: exact subset_span (mem_singleton _)