ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.epi_iff_inl_eq_inr
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f ↔ c.inl = c.inr
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f → c.inl = c.inr

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ c.inl = c.inr → Epi f
tactic: constructor
Theorem: denselyOrdered_orderDual
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LT α
⊢ DenselyOrdered αᵒᵈ → DenselyOrdered α
state_after: no goals
tactic: convert @OrderDual.denselyOrdered αᵒᵈ _
Theorem: Ordinal.nadd_le_nadd_left
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a✝ b c : Ordinal.{u}
h : b ≤ c
a : Ordinal.{u}
⊢ a ♯ b ≤ a ♯ c
state_after: case inl
a✝ b c : Ordinal.{u}
h✝ : b ≤ c
a : Ordinal.{u}
h : b < c
⊢ a ♯ b ≤ a ♯ c

case inr
a✝ b a : Ordinal.{u}
h : b ≤ b
⊢ a ♯ b ≤ a ♯ b
tactic: rcases lt_or_eq_of_le h with (h | rfl)
Theorem: Ordinal.mem_closure_iff_sup
File: Mathlib/SetTheory/Ordinal/Topology.lean

Proof steps:
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
⊢ (∃ ι, Nonempty ι ∧ ∃ f, (∀ (i : ι), f i ∈ s) ∧ sup f = a) ↔
    ∃ ι, ∃ (_ : Nonempty ι), ∃ f, (∀ (i : ι), f i ∈ s) ∧ sup f = a
state_after: no goals
tactic: simp only [exists_prop]
Theorem: Cardinal.alephIdx_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
⊢ a.alephIdx ≤ b.alephIdx ↔ a ≤ b
state_after: no goals
tactic: rw [← not_lt, ← not_lt, alephIdx_lt]
Theorem: Action.ρAut_apply_hom
File: Mathlib/RepresentationTheory/Action/Basic.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : Grp
A : Action V (MonCat.of ↑G)
g : ↑G
⊢ A.ρ (g⁻¹ * g) = 𝟙 A.V
state_after: no goals
tactic: rw [inv_mul_self, ρ_one]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : Grp
A : Action V (MonCat.of ↑G)
g : ↑G
⊢ A.ρ (g * g⁻¹) = 𝟙 A.V
state_after: no goals
tactic: rw [mul_inv_self, ρ_one]
Theorem: CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.IsWide ↔ S.objs = univ
state_after: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.IsWide → S.objs = univ

case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
⊢ S.objs = univ → S.IsWide
tactic: constructor
Theorem: Set.prod_singleton
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ {b} = (fun a => (a, b)) '' s
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ (fun a => (a, b)) '' s
tactic: ext ⟨x, y⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ (fun a => (a, b)) '' s
state_after: no goals
tactic: simp [and_left_comm, eq_comm]
Theorem: Mathlib.Tactic.Group.zsmul_trick_zero
File: Mathlib/Tactic/Group.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a b : G
m : ℤ
⊢ a * b * b ^ m = a * b ^ (m + 1)
state_after: no goals
tactic: rw [mul_assoc, mul_self_zpow]
Theorem: div_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / 0 = 0
state_after: no goals
tactic: rw [div_eq_mul_inv, inv_zero, mul_zero]
Theorem: compl_eq_iff_isCompl
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
h : xᶜ = y
⊢ IsCompl x y
state_after: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
h : xᶜ = y
⊢ IsCompl x xᶜ
tactic: rw [← h]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
h : xᶜ = y
⊢ IsCompl x xᶜ
state_after: no goals
tactic: exact isCompl_compl
Theorem: CompleteSublattice.comap_carrier
File: Mathlib/Order/CompleteSublattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L✝ : CompleteSublattice α
L : CompleteSublattice β
s : Set α
hs : s ⊆ { carrier := ⇑f ⁻¹' ↑L, supClosed' := ⋯, infClosed' := ⋯ }.carrier
⊢ sSup s ∈ { carrier := ⇑f ⁻¹' ↑L, supClosed' := ⋯, infClosed' := ⋯ }.carrier
state_after: no goals
tactic: simpa only [mem_preimage, map_sSup, SetLike.mem_coe] using sSupClosed <| mapsTo'.mp hs
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L✝ : CompleteSublattice α
L : CompleteSublattice β
s : Set α
hs : s ⊆ { carrier := ⇑f ⁻¹' ↑L, supClosed' := ⋯, infClosed' := ⋯ }.carrier
⊢ sInf s ∈ { carrier := ⇑f ⁻¹' ↑L, supClosed' := ⋯, infClosed' := ⋯ }.carrier
state_after: no goals
tactic: simpa only [mem_preimage, map_sInf, SetLike.mem_coe] using sInfClosed <| mapsTo'.mp hs
Theorem: Ordinal.blsub_nadd_of_mono
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ (a ♯ b).blsub f = max (a.blsub fun a' ha' => f (a' ♯ b) ⋯) (b.blsub fun b' hb' => f (a ♯ b') ⋯)
state_after: a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ ∀ (i : Ordinal.{u}) (h : i < a ♯ b),
    f i h < max (a.blsub fun a' ha' => f (a' ♯ b) ⋯) (b.blsub fun b' hb' => f (a ♯ b') ⋯)

a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ (a.blsub fun a' ha' => f (a' ♯ b) ⋯) ≤ (a ♯ b).blsub f

a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ (b.blsub fun b' hb' => f (a ♯ b') ⋯) ≤ (a ♯ b).blsub f
tactic: apply (blsub_le_iff.2 fun i h => _).antisymm (max_le _ _)
state_before: a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ (a.blsub fun a' ha' => f (a' ♯ b) ⋯) ≤ (a ♯ b).blsub f

a b c : Ordinal.{u}
f : (c : Ordinal.{u}) → c < a ♯ b → Ordinal.{max u v}
hf : ∀ {i j : Ordinal.{u}} (hi : i < a ♯ b) (hj : j < a ♯ b), i ≤ j → f i hi ≤ f j hj
⊢ (b.blsub fun b' hb' => f (a ♯ b') ⋯) ≤ (a ♯ b).blsub f
state_after: no goals
tactic: all_goals
    apply blsub_le_of_brange_subset.{u, u, v}
    rintro c ⟨d, hd, rfl⟩
    apply mem_brange_self
Theorem: Complex.ofReal_mul
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: r s : ℝ
⊢ (↑(r * s)).re = (↑r * ↑s).re ∧ (↑(r * s)).im = (↑r * ↑s).im
state_after: no goals
tactic: simp [ofReal']
Theorem: Function.minimalPeriod_pos_of_mem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hx : x ∈ periodicPts f
⊢ 0 < minimalPeriod f x
state_after: no goals
tactic: simp only [minimalPeriod, dif_pos hx, (Nat.find_spec hx).1.lt]
Theorem: AddLocalization.Away.mk_eq_addMonoidOf_mk'
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x : M
⊢ mk = Submonoid.LocalizationMap.mk' (monoidOf x)
state_after: no goals
tactic: simp
Theorem: Finset.ofColex_inj
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Colex α
⊢ s.ofColex = t.ofColex ↔ s = t
state_after: case toColex
α : Type u_1
β : Type u_2
t : Colex α
ofColex✝ : Finset α
⊢ { ofColex := ofColex✝ }.ofColex = t.ofColex ↔ { ofColex := ofColex✝ } = t
tactic: cases s
state_before: case toColex
α : Type u_1
β : Type u_2
t : Colex α
ofColex✝ : Finset α
⊢ { ofColex := ofColex✝ }.ofColex = t.ofColex ↔ { ofColex := ofColex✝ } = t
state_after: case toColex.toColex
α : Type u_1
β : Type u_2
ofColex✝¹ ofColex✝ : Finset α
⊢ { ofColex := ofColex✝¹ }.ofColex = { ofColex := ofColex✝ }.ofColex ↔
    { ofColex := ofColex✝¹ } = { ofColex := ofColex✝ }
tactic: cases t
state_before: case toColex.toColex
α : Type u_1
β : Type u_2
ofColex✝¹ ofColex✝ : Finset α
⊢ { ofColex := ofColex✝¹ }.ofColex = { ofColex := ofColex✝ }.ofColex ↔
    { ofColex := ofColex✝¹ } = { ofColex := ofColex✝ }
state_after: no goals
tactic: simp
Theorem: LaurentPolynomial.support_C_mul_T_of_ne_zero
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (C a * T n).support = {n}
state_after: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (Finsupp.single n a).support = {n}
tactic: rw [← single_eq_C_mul_T]
state_before: R : Type u_1
inst✝ : Semiring R
a : R
a0 : a ≠ 0
n : ℤ
⊢ (Finsupp.single n a).support = {n}
state_after: no goals
tactic: exact support_single_ne_zero _ a0
Theorem: Units.isUnit_mul_units
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a : M
u : Mˣ
x✝ : IsUnit (a * ↑u)
v : Mˣ
hv : ↑v = a * ↑u
⊢ IsUnit a
state_after: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a : M
u : Mˣ
x✝ : IsUnit (a * ↑u)
v : Mˣ
hv : ↑v = a * ↑u
this : IsUnit (a * ↑u * ↑u⁻¹)
⊢ IsUnit a
tactic: have : IsUnit (a * ↑u * ↑u⁻¹) := by exists v * u⁻¹; rw [← hv, Units.val_mul]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : Monoid M
a : M
u : Mˣ
x✝ : IsUnit (a * ↑u)
v : Mˣ
hv : ↑v = a * ↑u
this : IsUnit (a * ↑u * ↑u⁻¹)
⊢ IsUnit a
state_after: no goals
tactic: rwa [mul_assoc, Units.mul_inv, mul_one] at this
Theorem: isPiSystem_Icc_mem
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
s t : Set α
⊢ ∀ {a₁ b₁ a₂ b₂ : α}, Icc a₁ b₁ ∩ Icc a₂ b₂ = Icc (max a₁ a₂) (min b₁ b₂)
state_after: no goals
tactic: exact Icc_inter_Icc
Theorem: AffineSubspace.direction_perpBisector
File: Mathlib/Geometry/Euclidean/PerpBisector.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
⊢ (perpBisector p₁ p₂).direction = (Submodule.span ℝ {p₂ -ᵥ p₁})ᗮ
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
⊢ LinearMap.ker ((innerₛₗ ℝ) (p₂ -ᵥ p₁)) = (Submodule.span ℝ {p₂ -ᵥ p₁})ᗮ
tactic: erw [perpBisector, comap_symm, map_direction, Submodule.map_id,
    Submodule.toAffineSubspace_direction]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
⊢ LinearMap.ker ((innerₛₗ ℝ) (p₂ -ᵥ p₁)) = (Submodule.span ℝ {p₂ -ᵥ p₁})ᗮ
state_after: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
x : V
⊢ x ∈ LinearMap.ker ((innerₛₗ ℝ) (p₂ -ᵥ p₁)) ↔ x ∈ (Submodule.span ℝ {p₂ -ᵥ p₁})ᗮ
tactic: ext x
state_before: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
c c₁ c₂ p₁✝ p₂✝ p₁ p₂ : P
x : V
⊢ x ∈ LinearMap.ker ((innerₛₗ ℝ) (p₂ -ᵥ p₁)) ↔ x ∈ (Submodule.span ℝ {p₂ -ᵥ p₁})ᗮ
state_after: no goals
tactic: exact Submodule.mem_orthogonal_singleton_iff_inner_right.symm
Theorem: AkraBazziRecurrence.isTheta_deriv_rpow_p_mul_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (fun x => ‖deriv (fun z => z ^ p * (1 - ε z)) x‖) =Θ[atTop] fun z => z ^ (p - 1)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 - ε z)) =Θ[atTop] fun z => z ^ (p - 1)
tactic: refine IsTheta.norm_left ?_
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
p : ℝ
hp : p ≠ 0
⊢ (deriv fun z => z ^ p * (1 - ε z)) =Θ[atTop] fun z => z ^ (p - 1)
state_after: no goals
tactic: calc (fun x => deriv (fun z => z ^ p * (1 - ε z)) x) =Θ[atTop] fun z => p * z ^ (p-1) :=
            (isEquivalent_deriv_rpow_p_mul_one_sub_smoothingFn hp).isTheta
    _ =Θ[atTop] fun z => z ^ (p-1) :=
            IsTheta.const_mul_left hp <| isTheta_refl _ _
Theorem: Set.op_vadd_inter_ne_empty_iff
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ x • s ∩ t ≠ ∅ ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ (x • s ∩ t).Nonempty ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x
tactic: rw [← nonempty_iff_ne_empty]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ (x • s ∩ t).Nonempty ↔ ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ (x • s ∩ t).Nonempty → ∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t✝ A B : Set β
a : α
x✝ : β
s t : Set α
x : αᵐᵒᵖ
⊢ (∃ a b, (a ∈ s ∧ b ∈ t) ∧ a⁻¹ * b = unop x) → (x • s ∩ t).Nonempty
tactic: constructor
Theorem: map_seq
File: Mathlib/Control/Basic.lean

Proof steps:
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
f : β → γ
x : F (α → β)
y : F α
⊢ (f <$> Seq.seq x fun x => y) = Seq.seq ((fun x => f ∘ x) <$> x) fun x => y
state_after: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
f : β → γ
x : F (α → β)
y : F α
⊢ (Seq.seq (pure f) fun x_1 => Seq.seq x fun x => y) = Seq.seq (Seq.seq (pure fun x => f ∘ x) fun x_1 => x) fun x => y
tactic: simp only [← pure_seq]
state_before: α β γ : Type u
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
f : β → γ
x : F (α → β)
y : F α
⊢ (Seq.seq (pure f) fun x_1 => Seq.seq x fun x => y) = Seq.seq (Seq.seq (pure fun x => f ∘ x) fun x_1 => x) fun x => y
state_after: no goals
tactic: simp [seq_assoc]
Theorem: PrincipalSeg.topLTTop
File: Mathlib/Order/InitialSeg.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s✝ : β → β → Prop
t✝ : γ → γ → Prop
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t h.top g.top
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s✝ : β → β → Prop
t✝ : γ → γ → Prop
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t (f.trans g).top g.top
tactic: rw [Subsingleton.elim h (f.trans g)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s✝ : β → β → Prop
t✝ : γ → γ → Prop
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
inst✝ : IsWellOrder γ t
f : r ≺i s
g : s ≺i t
h : r ≺i t
⊢ t (f.trans g).top g.top
state_after: no goals
tactic: apply PrincipalSeg.lt_top
Theorem: InnerProductSpace.Core.inner_mul_inner_self_le
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✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ ‖⟪x, y⟫_𝕜‖ * ‖⟪y, x⟫_𝕜‖ ≤ re ⟪x, x⟫_𝕜 * re ⟪y, y⟫_𝕜
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
y : F
⊢ ‖⟪0, y⟫_𝕜‖ * ‖⟪y, 0⟫_𝕜‖ ≤ re ⟪0, 0⟫_𝕜 * re ⟪y, y⟫_𝕜

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : _root_.RCLike 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
hx : x ≠ 0
⊢ ‖⟪x, y⟫_𝕜‖ * ‖⟪y, x⟫_𝕜‖ ≤ re ⟪x, x⟫_𝕜 * re ⟪y, y⟫_𝕜
tactic: rcases eq_or_ne x 0 with (rfl | hx)
Theorem: AddMonoidHomClass.lipschitz_of_bound
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝¹ : FunLike 𝓕 E F
inst✝ : MonoidHomClass 𝓕 E F
f : 𝓕
C : ℝ
h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖
x y : E
⊢ dist (f x) (f y) ≤ C * dist x y
state_after: no goals
tactic: simpa only [dist_eq_norm_div, map_div] using h (x / y)
Theorem: Stream'.even_interleave
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = (s₁ ⋈ s₂).even
⊢ s₁'.head = s₁.head ∧ (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁'.tail s₁.tail
state_after: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = (s₁ ⋈ s₂).even
⊢ (s₁ ⋈ s₂).even.head = s₁.head ∧ (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) (s₁ ⋈ s₂).even.tail s₁.tail
tactic: rw [h₁]
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = (s₁ ⋈ s₂).even
⊢ (s₁ ⋈ s₂).even.head = s₁.head ∧ (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) (s₁ ⋈ s₂).even.tail s₁.tail
state_after: case left
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = (s₁ ⋈ s₂).even
⊢ (s₁ ⋈ s₂).even.head = s₁.head

case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ s₁' s₁ : Stream' α
x✝ : (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) s₁' s₁
s₂ : Stream' α
h₁ : s₁' = (s₁ ⋈ s₂).even
⊢ (fun s₁' s₁ => ∃ s₂, s₁' = (s₁ ⋈ s₂).even) (s₁ ⋈ s₂).even.tail s₁.tail
tactic: constructor
Theorem: Rack.self_invAct_eq_iff_eq
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
state_after: R : Type u_1
inst✝ : Rack R
x y : R
h : op x ◃ op x = op y ◃ op y ↔ op x = op y
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
tactic: have h := @self_act_eq_iff_eq _ _ (op x) (op y)
state_before: R : Type u_1
inst✝ : Rack R
x y : R
h : op x ◃ op x = op y ◃ op y ↔ op x = op y
⊢ x ◃⁻¹ x = y ◃⁻¹ y ↔ x = y
state_after: no goals
tactic: simpa using h
Theorem: finrank_span_eq_card
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Nontrivial R
ι : Type u_2
inst✝ : Fintype ι
b : ι → M
hb : LinearIndependent R b
⊢ Module.rank R ↥(span R (range b)) = ↑(Fintype.card ι)
state_after: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Nontrivial R
ι : Type u_2
inst✝ : Fintype ι
b : ι → M
hb : LinearIndependent R b
this : Module.rank R ↥(span R (range b)) = #↑(range b)
⊢ Module.rank R ↥(span R (range b)) = ↑(Fintype.card ι)
tactic: have : Module.rank R (span R (Set.range b)) = #(Set.range b) := rank_span hb
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι✝ : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : StrongRankCondition R
inst✝¹ : Nontrivial R
ι : Type u_2
inst✝ : Fintype ι
b : ι → M
hb : LinearIndependent R b
this : Module.rank R ↥(span R (range b)) = #↑(range b)
⊢ Module.rank R ↥(span R (range b)) = ↑(Fintype.card ι)
state_after: no goals
tactic: rwa [← lift_inj, mk_range_eq_of_injective hb.injective, Cardinal.mk_fintype, lift_natCast,
        lift_eq_nat_iff] at this
Theorem: Polynomial.coeff_contract
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
⊢ (contract p f).coeff n = f.coeff (n * p)
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
⊢ f.natDegree + 1 ≤ n → 0 = f.coeff (n * p)
tactic: simp only [contract, coeff_monomial, sum_ite_eq', finset_sum_coeff, mem_range, not_lt,
    ite_eq_left_iff]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
⊢ f.natDegree + 1 ≤ n → 0 = f.coeff (n * p)
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
hn : f.natDegree + 1 ≤ n
⊢ 0 = f.coeff (n * p)
tactic: intro hn
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
hn : f.natDegree + 1 ≤ n
⊢ 0 = f.coeff (n * p)
state_after: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
hn : f.natDegree + 1 ≤ n
⊢ f.natDegree < n * p
tactic: apply (coeff_eq_zero_of_natDegree_lt _).symm
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
hp : p ≠ 0
f : R[X]
n : ℕ
hn : f.natDegree + 1 ≤ n
⊢ f.natDegree < n * p
state_after: no goals
tactic: calc
    f.natDegree < f.natDegree + 1 := Nat.lt_succ_self _
    _ ≤ n * 1 := by simpa only [mul_one] using hn
    _ ≤ n * p := mul_le_mul_of_nonneg_left (show 1 ≤ p from hp.bot_lt) (zero_le n)
Theorem: CategoryTheory.Comonad.coalgebra_iso_of_iso
File: Mathlib/CategoryTheory/Monad/Algebra.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
G : Comonad C
A B : G.Coalgebra
f : A ⟶ B
inst✝ : IsIso f.f
⊢ B.a ≫ G.map (inv f.f) = inv f.f ≫ A.a
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
G : Comonad C
A B : G.Coalgebra
f : A ⟶ B
inst✝ : IsIso f.f
⊢ A.a ≫ G.map f.f ≫ G.map (inv f.f) = A.a
tactic: rw [IsIso.eq_inv_comp f.f, ← f.h_assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
G : Comonad C
A B : G.Coalgebra
f : A ⟶ B
inst✝ : IsIso f.f
⊢ A.a ≫ G.map f.f ≫ G.map (inv f.f) = A.a
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
G : Comonad C
A B : G.Coalgebra
f : A ⟶ B
inst✝ : IsIso f.f
⊢ f ≫ { f := inv f.f, h := ⋯ } = 𝟙 A ∧ { f := inv f.f, h := ⋯ } ≫ f = 𝟙 B
state_after: no goals
tactic: aesop_cat