ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: spectrum.resolvent_isBigO_inv
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
⊢ (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
state_after: no goals
tactic: simpa [Function.comp_def, resolvent] using
      (NormedRing.inverse_one_sub_norm (R := A)).comp_tendsto
        (by simpa using (tendsto_inv₀_cobounded (α := 𝕜)).smul_const a)
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
h : (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
⊢ resolvent a =ᶠ[cobounded 𝕜] fun z => z⁻¹ • resolvent (z⁻¹ • a) 1
state_after: case h
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
h : (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
z : 𝕜
hz : z ∈ {0}ᶜ
⊢ resolvent a z = z⁻¹ • resolvent (z⁻¹ • a) 1
tactic: filter_upwards [isBounded_singleton (x := 0)] with z hz
state_before: case h
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
h : (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
z : 𝕜
hz : z ∈ {0}ᶜ
⊢ resolvent a z = z⁻¹ • resolvent (z⁻¹ • a) 1
state_after: case h.intro
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
h : (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
z : 𝕜ˣ
hz : ↑z ∈ {0}ᶜ
⊢ resolvent a ↑z = (↑z)⁻¹ • resolvent ((↑z)⁻¹ • a) 1
tactic: lift z to 𝕜ˣ using Ne.isUnit hz
state_before: case h.intro
𝕜 : Type u_1
A : Type u_2
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra 𝕜 A
inst✝ : CompleteSpace A
a : A
h : (fun z => resolvent (z⁻¹ • a) 1) =O[cobounded 𝕜] fun x => 1
z : 𝕜ˣ
hz : ↑z ∈ {0}ᶜ
⊢ resolvent a ↑z = (↑z)⁻¹ • resolvent ((↑z)⁻¹ • a) 1
state_after: no goals
tactic: simpa [Units.smul_def] using congr(z⁻¹ • $(units_smul_resolvent_self (r := z) (a := a)))
Theorem: QPF.liftp_iff'
File: Mathlib/Data/QPF/Univariate/Basic.lean

Proof steps:
state_before: F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ Liftp p x ↔ ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)
state_after: case mp
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ Liftp p x → ∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)

case mpr
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ (∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)) → Liftp p x
tactic: constructor
state_before: case mpr
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
⊢ (∃ u, abs u = x ∧ ∀ (i : (P F).B u.fst), p (u.snd i)) → Liftp p x
state_after: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B ⟨a, f⟩.fst), p (⟨a, f⟩.snd i)
⊢ Liftp p x
tactic: rintro ⟨⟨a, f⟩, h₀, h₁⟩
state_before: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B ⟨a, f⟩.fst), p (⟨a, f⟩.snd i)
⊢ Liftp p x
state_after: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Liftp p x
tactic: dsimp at *
state_before: case mpr.intro.mk.intro
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Liftp p x
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Subtype.val <$> abs ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x
tactic: use abs ⟨a, fun i => ⟨f i, h₁ i⟩⟩
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ Subtype.val <$> abs ⟨a, fun i => ⟨f i, ⋯⟩⟩ = x
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ abs ((P F).map Subtype.val ⟨a, fun i => ⟨f i, ⋯⟩⟩) = abs ⟨a, f⟩
tactic: rw [← abs_map, ← h₀]
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
p : α → Prop
x : F α
a : (P F).A
f : (P F).B a → α
h₀ : abs ⟨a, f⟩ = x
h₁ : ∀ (i : (P F).B a), p (f i)
⊢ abs ((P F).map Subtype.val ⟨a, fun i => ⟨f i, ⋯⟩⟩) = abs ⟨a, f⟩
state_after: no goals
tactic: rfl
Theorem: Mathlib.Tactic.Ring.add_mul
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ d : R
x✝² : a₁ * b = c₁
x✝¹ : a₂ * b = c₂
x✝ : c₁ + c₂ = d
⊢ (a₁ + a₂) * b = d
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c : R
⊢ (a₁ + a₂) * b = a₁ * b + a₂ * b
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c : R
⊢ (a₁ + a₂) * b = a₁ * b + a₂ * b
state_after: no goals
tactic: simp [_root_.add_mul]
Theorem: NFA.mem_stepSet
File: Mathlib/Computability/NFA.lean

Proof steps:
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
s : σ
S : Set σ
a : α
⊢ s ∈ M.stepSet S a ↔ ∃ t ∈ S, s ∈ M.step t a
state_after: no goals
tactic: simp [stepSet]
Theorem: NonUnitalRingHom.prod_unique
File: Mathlib/Algebra/Ring/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
f✝ : R →ₙ+* S
g : R →ₙ+* T
f : R →ₙ+* S × T
x : R
⊢ (((fst S T).comp f).prod ((snd S T).comp f)) x = f x
state_after: no goals
tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply]
Theorem: DFinsupp.update_eq_single_add_erase
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ update i f b = single i b + erase i f
state_after: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
⊢ (update i f b) j = (single i b + erase i f) j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
⊢ (update i f b) j = (single i b + erase i f) j
state_after: case h.inl
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ (update i f b) i = (single i b + erase i f) i

case h.inr
ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j✝ : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddZeroClass (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
j : ι
h : i ≠ j
⊢ (update i f b) j = (single i b + erase i f) j
tactic: rcases eq_or_ne i j with (rfl | h)
Theorem: List.TProd.ext
File: Mathlib/Data/Prod/TProd.lean

Proof steps:
state_before: ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v = w
state_after: case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.1 = w.1

case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.2 = w.2
tactic: apply Prod.ext
state_before: case a
ι : Type u
α : ι → Type v
i✝ j : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
⊢ v.2 = w.2
state_after: case a
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
j : ι
hj : j ∈ is
⊢ TProd.elim v.2 hj = TProd.elim w.2 hj
tactic: refine ext (nodup_cons.mp hl).2 fun j hj => ?_
state_before: case a
ι : Type u
α : ι → Type v
i✝ j✝ : ι
l : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
i : ι
is : List ι
hl : (i :: is).Nodup
v w : TProd α (i :: is)
hvw : ∀ (i_1 : ι) (hi : i_1 ∈ i :: is), v.elim hi = w.elim hi
j : ι
hj : j ∈ is
⊢ TProd.elim v.2 hj = TProd.elim w.2 hj
state_after: no goals
tactic: rw [← elim_of_mem hl, hvw, elim_of_mem hl]
Theorem: Filter.tendsto_const_sub_iff
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✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b c : G
f : α → G
l : Filter α
⊢ Tendsto (fun k => b / f k) l (𝓝 (b / c)) ↔ Tendsto f l (𝓝 c)
state_after: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b c : G
f : α → G
l : Filter α
h : Tendsto (fun k => b / f k) l (𝓝 (b / c))
⊢ Tendsto f l (𝓝 c)
tactic: refine ⟨fun h ↦ ?_, Filter.Tendsto.const_div' b⟩
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroup G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b c : G
f : α → G
l : Filter α
h : Tendsto (fun k => b / f k) l (𝓝 (b / c))
⊢ Tendsto f l (𝓝 c)
state_after: no goals
tactic: convert h.const_div' b with k <;> rw [div_div_cancel]
Theorem: RCLike.div_re_ofReal
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
r : ℝ
⊢ re (z / ↑r) = re z / r
state_after: no goals
tactic: rw [div_eq_inv_mul, div_eq_inv_mul, ← ofReal_inv, re_ofReal_mul]
Theorem: mem_rightAddCoset_rightAddCoset
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ s
state_after: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ op a • ↑s
tactic: rw [← SetLike.mem_coe, ← ha]
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ op a • ↑s
state_after: no goals
tactic: exact mem_own_rightCoset s a
Theorem: Set.image2_assoc
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : δ → γ → ε
g : α → β → δ
f' : α → ε' → ε
g' : β → γ → ε'
h_assoc : ∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)
x✝ : Set ε
⊢ image2 f (image2 g s t) u ⊆ x✝ ↔ image2 f' s (image2 g' t u) ⊆ x✝
state_after: no goals
tactic: simp only [image2_subset_iff, forall_image2_iff, h_assoc]
Theorem: mul_tsub_one
File: Mathlib/Algebra/Order/Ring/Canonical.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝⁴ : CanonicallyOrderedCommSemiring α
a✝ b✝ c : α
inst✝³ : Sub α
inst✝² : OrderedSub α
inst✝¹ : IsTotal α fun x x_1 => x ≤ x_1
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ a * (b - 1) = a * b - a
state_after: no goals
tactic: rw [mul_tsub, mul_one]
Theorem: SimpleGraph.Subgraph.induce_union_connected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
s t : Set V
sconn : (H.induce s).Connected
tconn : (H.induce t).Connected
sintert : (s ⊓ t).Nonempty
⊢ (H.induce (s ∪ t)).Connected
state_after: case refine_1
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
s t : Set V
sconn : (H.induce s).Connected
tconn : (H.induce t).Connected
sintert : (s ⊓ t).Nonempty
⊢ H.induce s ⊔ H.induce t ≤ H.induce (s ∪ t)

case refine_2
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
H : G.Subgraph
s t : Set V
sconn : (H.induce s).Connected
tconn : (H.induce t).Connected
sintert : (s ⊓ t).Nonempty
⊢ (H.induce s ⊔ H.induce t).verts = (H.induce (s ∪ t)).verts
tactic: refine (sconn.sup tconn sintert).mono ?_ ?_
Theorem: Real.lt_rpow_of_log_lt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 < y
h : log x < z * log y
⊢ x < y ^ z
state_after: case inl
x y z : ℝ
n : ℕ
hx✝ : 0 ≤ x
hy : 0 < y
h : log x < z * log y
hx : 0 < x
⊢ x < y ^ z

case inr
y z : ℝ
n : ℕ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 < z * log y
⊢ 0 < y ^ z
tactic: obtain hx | rfl := hx.lt_or_eq
state_before: case inr
y z : ℝ
n : ℕ
hy : 0 < y
hx : 0 ≤ 0
h : log 0 < z * log y
⊢ 0 < y ^ z
state_after: no goals
tactic: exact Real.rpow_pos_of_pos hy z
Theorem: CategoryTheory.IsSubterminal.isIso_diag
File: Mathlib/CategoryTheory/Subterminal.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ diag A ≫ prod.fst = 𝟙 A
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : IsSubterminal A
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
tactic: rw [IsSubterminal.def] at hA
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
A : C
hA : ∀ ⦃Z : C⦄ (f g : Z ⟶ A), f = g
inst✝ : HasBinaryProduct A A
⊢ prod.fst ≫ diag A = 𝟙 (A ⨯ A)
state_after: no goals
tactic: aesop_cat
Theorem: LowerSet.coe_iInf₂
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : (i : ι) → κ i → LowerSet α
⊢ ↑(⨅ i, ⨅ j, f i j) = ⋂ i, ⋂ j, ↑(f i j)
state_after: no goals
tactic: simp_rw [coe_iInf]
Theorem: CategoryTheory.Bicategory.whisker_assoc_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g g' : b ⟶ c
η : g ⟶ g'
h : c ⟶ d
⊢ f ◁ η ▷ h = (α_ f g h).inv ≫ (f ◁ η) ▷ h ≫ (α_ f g' h).hom
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.card_support_cycleOf_pos_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝³ : DecidableRel f.SameCycle
inst✝² : DecidableRel g.SameCycle
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ 0 < (f.cycleOf x).support.card ↔ f x ≠ x
state_after: no goals
tactic: rw [card_pos, support_cycleOf_nonempty]
Theorem: Matrix.dotProduct_pUnit
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
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
v w : PUnit.{u_10 + 1} → α
⊢ v ⬝ᵥ w = v PUnit.unit * w PUnit.unit
state_after: no goals
tactic: simp [dotProduct]
Theorem: CoxeterSystem.simple_induction
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
⊢ p w
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
this : w ∈ Submonoid.closure (Set.range cs.simple)
⊢ p w
tactic: have := cs.submonoid_closure_range_simple.symm ▸ Submonoid.mem_top w
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
this : w ∈ Submonoid.closure (Set.range cs.simple)
⊢ p w
state_after: no goals
tactic: exact Submonoid.closure_induction this (fun x ⟨i, hi⟩ ↦ hi ▸ simple i) one mul
Theorem: SimpleGraph.edist_eq_top_of_not_reachable
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
h : ¬G.Reachable u v
⊢ G.edist u v = ⊤
state_after: no goals
tactic: simp [edist, not_reachable_iff_isEmpty_walk.mp h]
Theorem: PartialEquiv.EqOnSource.symm'
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
h : e ≈ e'
⊢ e.symm ≈ e'.symm
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
h : e ≈ e'
⊢ RightInvOn (↑e'.symm) (↑e) e'.target
tactic: refine ⟨target_eq h, eqOn_of_leftInvOn_of_rightInvOn e.leftInvOn ?_ ?_⟩ <;>
    simp only [symm_source, target_eq h, source_eq h, e'.symm_mapsTo]
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
h : e ≈ e'
⊢ RightInvOn (↑e'.symm) (↑e) e'.target
state_after: no goals
tactic: exact e'.rightInvOn.congr_right e'.symm_mapsTo (source_eq h ▸ h.eqOn.symm)
Theorem: LinearLocallyFiniteOrder.isMax_of_succFn_le
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

Proof steps:
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
⊢ IsMax i
state_after: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
⊢ False
tactic: refine fun j _ ↦ not_lt.mp fun hij_lt ↦ ?_
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
⊢ False
state_after: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
⊢ False
tactic: have h_succFn_eq : succFn i = i := le_antisymm hi (le_succFn i)
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
⊢ False
state_after: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
⊢ False
tactic: have h_glb : IsGLB (Finset.Ioc i j : Set ι) i := by
    rw [Finset.coe_Ioc]
    have h := succFn_spec i
    rw [h_succFn_eq] at h
    exact isGLB_Ioc_of_isGLB_Ioi hij_lt h
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
⊢ False
state_after: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
hi_mem : i ∈ Finset.Ioc i j
⊢ False
tactic: have hi_mem : i ∈ Finset.Ioc i j := by
    refine Finset.isGLB_mem _ h_glb ?_
    exact ⟨_, Finset.mem_Ioc.mpr ⟨hij_lt, le_rfl⟩⟩
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
hi_mem : i ∈ Finset.Ioc i j
⊢ False
state_after: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
hi_mem : i < i ∧ i ≤ j
⊢ False
tactic: rw [Finset.mem_Ioc] at hi_mem
state_before: ι : Type u_1
inst✝¹ : LinearOrder ι
inst✝ : LocallyFiniteOrder ι
i : ι
hi : succFn i ≤ i
j : ι
x✝ : i ≤ j
hij_lt : i < j
h_succFn_eq : succFn i = i
h_glb : IsGLB (↑(Finset.Ioc i j)) i
hi_mem : i < i ∧ i ≤ j
⊢ False
state_after: no goals
tactic: exact lt_irrefl i hi_mem.1
Theorem: Submodule.mem_annihilator_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N P : Submodule R M
g : M
r : R
⊢ r ∈ (span R {g}).annihilator ↔ r • g = 0
state_after: no goals
tactic: simp [mem_annihilator_span]