ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PEquiv.single_mul_single_of_ne
File: Mathlib/Data/Matrix/PEquiv.lean

Proof steps:
state_before: k : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type v
inst✝⁴ : Fintype n
inst✝³ : DecidableEq n
inst✝² : DecidableEq k
inst✝¹ : DecidableEq m
inst✝ : Semiring α
b₁ b₂ : n
hb : b₁ ≠ b₂
a : m
c : k
⊢ (single a b₁).toMatrix * (single b₂ c).toMatrix = 0
state_after: no goals
tactic: rw [← toMatrix_trans, single_trans_single_of_ne hb, toMatrix_bot]
Theorem: Grp.surjective_of_epi
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

Proof steps:
state_before: A B : Grp
f : A ⟶ B
inst✝ : Epi f
⊢ Function.Surjective ⇑f
state_after: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ¬Function.Surjective ⇑f
⊢ False
tactic: by_contra r
state_before: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ¬Function.Surjective ⇑f
⊢ False
state_after: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ¬∀ (b : ↑B), ∃ a, f a = b
⊢ False
tactic: dsimp [Function.Surjective] at r
state_before: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ¬∀ (b : ↑B), ∃ a, f a = b
⊢ False
state_after: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ∃ b, ∀ (a : ↑A), f a ≠ b
⊢ False
tactic: push_neg at r
state_before: A B : Grp
f : A ⟶ B
inst✝ : Epi f
r : ∃ b, ∀ (a : ↑A), f a ≠ b
⊢ False
state_after: case intro
A B : Grp
f : A ⟶ B
inst✝ : Epi f
b : ↑B
hb : ∀ (a : ↑A), f a ≠ b
⊢ False
tactic: rcases r with ⟨b, hb⟩
state_before: case intro
A B : Grp
f : A ⟶ B
inst✝ : Epi f
b : ↑B
hb : ∀ (a : ↑A), f a ≠ b
⊢ False
state_after: no goals
tactic: exact
    SurjectiveOfEpiAuxs.g_ne_h f b (fun ⟨c, hc⟩ => hb _ hc)
      ((cancel_epi f).1 (SurjectiveOfEpiAuxs.comp_eq f))
Theorem: DirichletCharacter.toUnitHom_eq_iff
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ ψ : DirichletCharacter R n
⊢ toUnitHom χ = toUnitHom ψ ↔ χ = ψ
state_after: no goals
tactic: simp
Theorem: LowerSemicontinuousAt.comp_continuousAt_of_eq
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : LowerSemicontinuousAt f y
hg : ContinuousAt g x
hy : g x = y
⊢ LowerSemicontinuousAt (fun x => f (g x)) x
state_after: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : LowerSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ LowerSemicontinuousAt (fun x => f (g x)) x
tactic: rw [← hy] at hf
state_before: α : Type u_1
inst✝⁸ : TopologicalSpace α
β : Type u_2
inst✝⁷ : Preorder β
f✝ g✝ : α → β
x✝ : α
s t : Set α
y✝ z : β
γ : Type u_3
inst✝⁶ : LinearOrder γ
inst✝⁵ : TopologicalSpace γ
inst✝⁴ : OrderTopology γ
δ : Type u_4
inst✝³ : LinearOrder δ
inst✝² : TopologicalSpace δ
inst✝¹ : OrderTopology δ
ι : Type u_5
inst✝ : TopologicalSpace ι
f : α → β
g : ι → α
y : α
x : ι
hf : LowerSemicontinuousAt f (g x)
hg : ContinuousAt g x
hy : g x = y
⊢ LowerSemicontinuousAt (fun x => f (g x)) x
state_after: no goals
tactic: exact comp_continuousAt hf hg
Theorem: Finset.Colex.cons_le_cons
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
ha : a ∉ s
hb : b ∉ s
⊢ { ofColex := cons a s ha } ≤ { ofColex := cons b s hb } ↔ a ≤ b
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a : α
ha hb : a ∉ s
⊢ { ofColex := cons a s ha } ≤ { ofColex := cons a s hb } ↔ a ≤ a

case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
ha : a ∉ s
hb : b ∉ s
hab : a ≠ b
⊢ { ofColex := cons a s ha } ≤ { ofColex := cons b s hb } ↔ a ≤ b
tactic: obtain rfl | hab := eq_or_ne a b
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
ha : a ∉ s
hb : b ∉ s
hab : a ≠ b
⊢ { ofColex := cons a s ha } ≤ { ofColex := cons b s hb } ↔ a ≤ b
state_after: no goals
tactic: classical
  rw [← toColex_sdiff_le_toColex_sdiff', cons_sdiff_cons hab, cons_sdiff_cons hab.symm,
    singleton_le_singleton]
Theorem: TopologicalAddGroup.of_comm_of_nhds_zero
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : CommGroup G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ∀ (x₀ : G), Tendsto (fun x => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)
state_after: no goals
tactic: simpa using tendsto_id
Theorem: Matrix.ext_iff
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
M N : Matrix m n α
h : M = N
⊢ ∀ (i : m) (j : n), M i j = N i j
state_after: no goals
tactic: simp [h]
Theorem: vectorSpan_range_eq_span_range_vsub_right
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ vectorSpan k (range p) = Submodule.span k (range fun i => p i -ᵥ p i0)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => x -ᵥ p i0) ∘ p)) = Submodule.span k (range fun i => p i -ᵥ p i0)
tactic: rw [vectorSpan_eq_span_vsub_set_right k (Set.mem_range_self i0), ← Set.range_comp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => x -ᵥ p i0) ∘ p)) = Submodule.span k (range fun i => p i -ᵥ p i0)
state_after: no goals
tactic: congr
Theorem: LieModule.iSup_weightSpace_eq_top'
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : LieAlgebra.IsNilpotent R L
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : LieRingModule L M
inst✝⁷ : LieModule R L M
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : Module K M
inst✝³ : LieModule K L M
inst✝² : LieAlgebra.IsNilpotent K L
inst✝¹ : FiniteDimensional K M
inst✝ : IsTriangularizable K L M
⊢ ⨆ χ, weightSpace M ⇑χ = ⊤
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : LieAlgebra.IsNilpotent R L
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : LieRingModule L M
inst✝⁷ : LieModule R L M
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : Module K M
inst✝³ : LieModule K L M
inst✝² : LieAlgebra.IsNilpotent K L
inst✝¹ : FiniteDimensional K M
inst✝ : IsTriangularizable K L M
this : ⨆ χ, weightSpace M χ = ⊤
⊢ ⨆ χ, weightSpace M ⇑χ = ⊤
tactic: have := iSup_weightSpace_eq_top K L M
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : LieAlgebra.IsNilpotent R L
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : LieRingModule L M
inst✝⁷ : LieModule R L M
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : Module K M
inst✝³ : LieModule K L M
inst✝² : LieAlgebra.IsNilpotent K L
inst✝¹ : FiniteDimensional K M
inst✝ : IsTriangularizable K L M
this : ⨆ χ, weightSpace M χ = ⊤
⊢ ⨆ χ, weightSpace M ⇑χ = ⊤
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : LieAlgebra.IsNilpotent R L
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : LieRingModule L M
inst✝⁷ : LieModule R L M
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : Module K M
inst✝³ : LieModule K L M
inst✝² : LieAlgebra.IsNilpotent K L
inst✝¹ : FiniteDimensional K M
inst✝ : IsTriangularizable K L M
this : ⨆ x, weightSpace M ↑((Weight.equivSetOf K L M) x) = ⊤
⊢ ⨆ χ, weightSpace M ⇑χ = ⊤
tactic: erw [← iSup_ne_bot_subtype, ← (Weight.equivSetOf K L M).iSup_comp] at this
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁴ : CommRing R
inst✝¹³ : LieRing L
inst✝¹² : LieAlgebra R L
inst✝¹¹ : LieAlgebra.IsNilpotent R L
inst✝¹⁰ : AddCommGroup M
inst✝⁹ : Module R M
inst✝⁸ : LieRingModule L M
inst✝⁷ : LieModule R L M
inst✝⁶ : Field K
inst✝⁵ : LieAlgebra K L
inst✝⁴ : Module K M
inst✝³ : LieModule K L M
inst✝² : LieAlgebra.IsNilpotent K L
inst✝¹ : FiniteDimensional K M
inst✝ : IsTriangularizable K L M
this : ⨆ x, weightSpace M ↑((Weight.equivSetOf K L M) x) = ⊤
⊢ ⨆ χ, weightSpace M ⇑χ = ⊤
state_after: no goals
tactic: exact this
Theorem: CategoryTheory.Linear.comp_apply
File: Mathlib/CategoryTheory/Linear/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
⊢ ∀ (x y : X ⟶ Y), (fun f => leftComp S Z f) (x + y) = (fun f => leftComp S Z f) x + (fun f => leftComp S Z f) y
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
x✝ y✝ : X ⟶ Y
⊢ (fun f => leftComp S Z f) (x✝ + y✝) = (fun f => leftComp S Z f) x✝ + (fun f => leftComp S Z f) y✝
tactic: intros
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
x✝ y✝ : X ⟶ Y
⊢ (fun f => leftComp S Z f) (x✝ + y✝) = (fun f => leftComp S Z f) x✝ + (fun f => leftComp S Z f) y✝
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
x✝¹ y✝ : X ⟶ Y
x✝ : Y ⟶ Z
⊢ ((fun f => leftComp S Z f) (x✝¹ + y✝)) x✝ = ((fun f => leftComp S Z f) x✝¹ + (fun f => leftComp S Z f) y✝) x✝
tactic: ext
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
x✝¹ y✝ : X ⟶ Y
x✝ : Y ⟶ Z
⊢ ((fun f => leftComp S Z f) (x✝¹ + y✝)) x✝ = ((fun f => leftComp S Z f) x✝¹ + (fun f => leftComp S Z f) y✝) x✝
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
⊢ ∀ (m : S) (x : X ⟶ Y),
    { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun (m • x) =
      (RingHom.id S) m • { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun x
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
m✝ : S
x✝ : X ⟶ Y
⊢ { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun (m✝ • x✝) =
    (RingHom.id S) m✝ • { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun x✝
tactic: intros
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
m✝ : S
x✝ : X ⟶ Y
⊢ { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun (m✝ • x✝) =
    (RingHom.id S) m✝ • { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun x✝
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
m✝ : S
x✝¹ : X ⟶ Y
x✝ : Y ⟶ Z
⊢ ({ toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun (m✝ • x✝¹)) x✝ =
    ((RingHom.id S) m✝ • { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun x✝¹) x✝
tactic: ext
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
S : Type w
inst✝¹ : CommSemiring S
inst✝ : Linear S C
X Y Z : C
m✝ : S
x✝¹ : X ⟶ Y
x✝ : Y ⟶ Z
⊢ ({ toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun (m✝ • x✝¹)) x✝ =
    ((RingHom.id S) m✝ • { toFun := fun f => leftComp S Z f, map_add' := ⋯ }.toFun x✝¹) x✝
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Adjunction.leftAdjointOfEquiv_obj
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), (e X Y') (h ≫ g) = (e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ { obj := F_obj, map := fun {X X'} f => (e X (F_obj X')).symm (f ≫ (e X' (F_obj X')) (𝟙 (F_obj X'))) }.map (f ≫ f') =
    { obj := F_obj, map := fun {X X'} f => (e X (F_obj X')).symm (f ≫ (e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f ≫
      { obj := F_obj, map := fun {X X'} f => (e X (F_obj X')).symm (f ≫ (e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f'
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), (e X Y') (h ≫ g) = (e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ (e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => (e X (F_obj X')).symm (f ≫ (e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
tactic: rw [Equiv.symm_apply_eq, he, Equiv.apply_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), (e X Y') (h ≫ g) = (e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) =
    (f ≫ (e Y✝ (F_obj Y✝)) (𝟙 (F_obj Y✝))) ≫
      G.map
        ({ obj := F_obj, map := fun {X X'} f => (e X (F_obj X')).symm (f ≫ (e X' (F_obj X')) (𝟙 (F_obj X'))) }.map f')
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), (e X Y') (h ≫ g) = (e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) = f ≫ f' ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝))
tactic: conv =>
      rhs
      rw [assoc, ← he, id_comp, Equiv.apply_symm_apply]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
F_obj : C → D
e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
he : ∀ (X : C) (Y Y' : D) (g : Y ⟶ Y') (h : F_obj X ⟶ Y), (e X Y') (h ≫ g) = (e X Y) h ≫ G.map g
X✝ Y✝ Z✝ : C
f : X✝ ⟶ Y✝
f' : Y✝ ⟶ Z✝
⊢ (f ≫ f') ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝)) = f ≫ f' ≫ (e Z✝ (F_obj Z✝)) (𝟙 (F_obj Z✝))
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Formula.realize_rel₁
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
R : L.Relations 1
t : L.Term α
⊢ (R.formula₁ t).Realize v ↔ RelMap R ![Term.realize v t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
R : L.Relations 1
t : L.Term α
⊢ (RelMap R fun i => Term.realize v (![t] i)) = RelMap R ![Term.realize v t]
tactic: rw [Relations.formula₁, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
R : L.Relations 1
t : L.Term α
⊢ (RelMap R fun i => Term.realize v (![t] i)) = RelMap R ![Term.realize v t]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
R : L.Relations 1
t : L.Term α
x✝ : Fin 1
⊢ Term.realize v (![t] x✝) = ![Term.realize v t] x✝
tactic: refine congr rfl (funext fun _ => ?_)
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
R : L.Relations 1
t : L.Term α
x✝ : Fin 1
⊢ Term.realize v (![t] x✝) = ![Term.realize v t] x✝
state_after: no goals
tactic: simp only [Matrix.cons_val_fin_one]
Theorem: CategoryTheory.Limits.terminal.comp_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : HasTerminal C
P Q : C
f : P ⟶ Q
⊢ f ≫ from Q = from P
state_after: no goals
tactic: simp [eq_iff_true_of_subsingleton]
Theorem: LeftOrdContinuous.id
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
s : Set α
x : α
h : IsLUB s x
⊢ IsLUB (id '' s) (id x)
state_after: no goals
tactic: simpa only [image_id] using h
Theorem: Submodule.mul_one
File: Mathlib/Algebra/Algebra/Operations.lean

Proof steps:
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ M * 1 = M
state_after: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ span R ↑M * span R {1} = M
tactic: conv_lhs => rw [one_eq_span, ← span_eq M]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ span R ↑M * span R {1} = M
state_after: no goals
tactic: erw [span_mul_span, mul_one, span_eq]
Theorem: Tree.numLeaves_eq_numNodes_succ
File: Mathlib/Data/Tree/Basic.lean

Proof steps:
state_before: α : Type u
x : Tree α
⊢ x.numLeaves = x.numNodes + 1
state_after: no goals
tactic: induction x <;> simp [*, Nat.add_comm, Nat.add_assoc, Nat.add_left_comm]
Theorem: Set.LeftInvOn.image_image
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f' '' (f '' s) = s
state_after: no goals
tactic: rw [Set.image_image, image_congr hf, image_id']
Theorem: Cardinal.aleph_one_le_continuum
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: ⊢ aleph 1 ≤ 𝔠
state_after: ⊢ Order.succ ℵ₀ ≤ 𝔠
tactic: rw [← succ_aleph0]
state_before: ⊢ Order.succ ℵ₀ ≤ 𝔠
state_after: no goals
tactic: exact Order.succ_le_of_lt aleph0_lt_continuum
Theorem: QuotientAddGroup.mk_add_of_mem
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
a✝ b a : α
hb : b ∈ s
⊢ ↑(a * b) = ↑a
state_after: no goals
tactic: rwa [eq', mul_inv_rev, inv_mul_cancel_right, s.inv_mem_iff]
Theorem: Complex.abs_re_lt_abs
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: z : ℂ
⊢ |z.re| < abs z ↔ z.im ≠ 0
state_after: no goals
tactic: rw [Complex.abs, AbsoluteValue.coe_mk, MulHom.coe_mk, Real.lt_sqrt (abs_nonneg _), normSq_apply,
    _root_.sq_abs, ← sq, lt_add_iff_pos_right, mul_self_pos]
Theorem: Ordinal.log_of_not_one_lt_left
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b : Ordinal.{u_1}
h : ¬1 < b
x : Ordinal.{u_1}
⊢ log b x = 0
state_after: no goals
tactic: simp only [log, dif_neg h]
Theorem: Polynomial.degree_derivative_le
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
this : DecidableEq R := Classical.decEq R
H : p = 0
⊢ (derivative p).degree = p.degree
state_after: no goals
tactic: rw [H, derivative_zero]
Theorem: AddSubgroup.card_mul_index
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ Nat.card ↥H * H.index = Nat.card G
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ ⊥.relindex H * H.index = ⊥.index
tactic: rw [← relindex_bot_left, ← index_bot]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
⊢ ⊥.relindex H * H.index = ⊥.index
state_after: no goals
tactic: exact relindex_mul_index bot_le
Theorem: List.Lex.isTrichotomous.aux
File: Mathlib/Data/List/Lex.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝ : IsTrichotomous α r
a : α
l₁ : List α
b : α
l₂ : List α
⊢ Lex r (a :: l₁) (b :: l₂) ∨ a :: l₁ = b :: l₂ ∨ Lex r (b :: l₂) (a :: l₁)
state_after: case inl
α : Type u
r : α → α → Prop
inst✝ : IsTrichotomous α r
a : α
l₁ : List α
b : α
l₂ : List α
ab : r a b
⊢ Lex r (a :: l₁) (b :: l₂) ∨ a :: l₁ = b :: l₂ ∨ Lex r (b :: l₂) (a :: l₁)

case inr.inl
α : Type u
r : α → α → Prop
inst✝ : IsTrichotomous α r
a : α
l₁ l₂ : List α
⊢ Lex r (a :: l₁) (a :: l₂) ∨ a :: l₁ = a :: l₂ ∨ Lex r (a :: l₂) (a :: l₁)

case inr.inr
α : Type u
r : α → α → Prop
inst✝ : IsTrichotomous α r
a : α
l₁ : List α
b : α
l₂ : List α
ab : r b a
⊢ Lex r (a :: l₁) (b :: l₂) ∨ a :: l₁ = b :: l₂ ∨ Lex r (b :: l₂) (a :: l₁)
tactic: rcases trichotomous_of r a b with (ab | rfl | ab)