ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.compl_neighborSet_disjoint
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
G : SimpleGraph V
v : V
⊢ Disjoint (G.neighborSet v) (Gᶜ.neighborSet v)
state_after: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
G : SimpleGraph V
v : V
⊢ G.neighborSet v ∩ Gᶜ.neighborSet v ⊆ ∅
tactic: rw [Set.disjoint_iff]
state_before: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w : V
e : Sym2 V
G : SimpleGraph V
v : V
⊢ G.neighborSet v ∩ Gᶜ.neighborSet v ⊆ ∅
state_after: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : w ∈ G.neighborSet v
h' : w ∈ Gᶜ.neighborSet v
⊢ w ∈ ∅
tactic: rintro w ⟨h, h'⟩
state_before: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : w ∈ G.neighborSet v
h' : w ∈ Gᶜ.neighborSet v
⊢ w ∈ ∅
state_after: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : w ∈ G.neighborSet v
h' : v ≠ w ∧ ¬G.Adj v w
⊢ w ∈ ∅
tactic: rw [mem_neighborSet, compl_adj] at h'
state_before: case intro
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
G : SimpleGraph V
v w : V
h : w ∈ G.neighborSet v
h' : v ≠ w ∧ ¬G.Adj v w
⊢ w ∈ ∅
state_after: no goals
tactic: exact h'.2 h
Theorem: WeierstrassCurve.Affine.CoordinateRing.map_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (map W f) (x • y) = Polynomial.map f x • (map W f) y
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (mk (WeierstrassCurve.map W f)) (C ((mapRingHom f) x)) * (map W f) y =
    (mk (WeierstrassCurve.map W f).toAffine) (C (Polynomial.map f x)) * (map W f) y
tactic: rw [smul, _root_.map_mul, map_mk, map_C, smul]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
x : R[X]
y : W.CoordinateRing
⊢ (mk (WeierstrassCurve.map W f)) (C ((mapRingHom f) x)) * (map W f) y =
    (mk (WeierstrassCurve.map W f).toAffine) (C (Polynomial.map f x)) * (map W f) y
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Subgroupoid.map_objs_eq
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
⊢ (map φ hφ S).objs = φ.obj '' S.objs
state_after: case h
C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
x : D
⊢ x ∈ (map φ hφ S).objs ↔ x ∈ φ.obj '' S.objs
tactic: ext x
state_before: case h
C : Type u
inst✝¹ : Groupoid C
S : Subgroupoid C
D : Type u_1
inst✝ : Groupoid D
φ : C ⥤ D
hφ : Function.Injective φ.obj
x : D
⊢ x ∈ (map φ hφ S).objs ↔ x ∈ φ.obj '' S.objs
state_after: no goals
tactic: convert mem_map_objs_iff S φ hφ x
Theorem: NormedAddGroupHom.Equalizer.comm_sq₂
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_6
W₂ : Type u_7
W₃ : Type u_8
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
hf : ψ.comp f₁ = f₂.comp φ
hf' : ψ'.comp f₂ = f₃.comp φ'
⊢ (ψ'.comp ψ).comp f₁ = f₃.comp (φ'.comp φ)
state_after: no goals
tactic: rw [comp_assoc, hf, ← comp_assoc, hf', comp_assoc]
Theorem: Finset.affineCombination_filter_of_ne
File: Mathlib/LinearAlgebra/AffineSpace/Combination.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
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : ι → P
pred : ι → Prop
inst✝ : DecidablePred pred
h : ∀ i ∈ s, w i ≠ 0 → pred i
⊢ (affineCombination k (filter pred s) p) w = (affineCombination k s p) w
state_after: no goals
tactic: rw [affineCombination_apply, affineCombination_apply,
    s.weightedVSubOfPoint_filter_of_ne _ _ _ h]
Theorem: AddUnits.neg_add_eq_iff_eq_add
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : ↑a⁻¹ * b = c
⊢ b = ↑a * c
state_after: no goals
tactic: rw [← h, mul_inv_cancel_left]
state_before: α : Type u
inst✝ : Monoid α
a b✝ c✝ u : αˣ
b c : α
h : b = ↑a * c
⊢ ↑a⁻¹ * b = c
state_after: no goals
tactic: rw [h, inv_mul_cancel_left]
Theorem: Subgroup.codisjoint_subgroupOf_sup
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
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K))
state_after: case hH
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
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
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
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
tactic: rw [codisjoint_iff, sup_subgroupOf_eq, subgroupOf_self]
state_before: case hH
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
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
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
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
state_after: no goals
tactic: exacts [le_sup_left, le_sup_right]
Theorem: subset_iterate_compRel
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s t : Set (α × α)
h : idRel ⊆ s
n : ℕ
⊢ t ⊆ (fun x => s ○ x)^[n] t
state_after: case zero
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (α × α)
h : idRel ⊆ s
t : Set (α × α)
⊢ t ⊆ (fun x => s ○ x)^[0] t

case succ
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (α × α)
h : idRel ⊆ s
n : ℕ
ihn : ∀ {t : Set (α × α)}, t ⊆ (fun x => s ○ x)^[n] t
t : Set (α × α)
⊢ t ⊆ (fun x => s ○ x)^[n + 1] t
tactic: induction' n with n ihn generalizing t
state_before: case zero
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (α × α)
h : idRel ⊆ s
t : Set (α × α)
⊢ t ⊆ (fun x => s ○ x)^[0] t

case succ
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
s : Set (α × α)
h : idRel ⊆ s
n : ℕ
ihn : ∀ {t : Set (α × α)}, t ⊆ (fun x => s ○ x)^[n] t
t : Set (α × α)
⊢ t ⊆ (fun x => s ○ x)^[n + 1] t
state_after: no goals
tactic: exacts [Subset.rfl, (right_subset_compRel h).trans ihn]
Theorem: Matroid.Basis.restrict_base
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
h : M.Basis I X
⊢ (M ↾ X).Base I
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
h : (M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) ∧ X ⊆ M.E
⊢ (M ↾ X).Base I
tactic: rw [basis_iff'] at h
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
h : (M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) ∧ X ⊆ M.E
⊢ (M ↾ X).Base I
state_after: α : Type u_1
M : Matroid α
R I J X Y : Set α
h : (M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) ∧ X ⊆ M.E
⊢ ∀ (I_1 : Set α), M.Indep I_1 → I_1 ⊆ X → I ⊆ I_1 → I = I_1
tactic: simp_rw [base_iff_maximal_indep, restrict_indep_iff, and_imp, and_assoc, and_iff_right h.1.1,
    and_iff_right h.1.2.1]
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
h : (M.Indep I ∧ I ⊆ X ∧ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J) ∧ X ⊆ M.E
⊢ ∀ (I_1 : Set α), M.Indep I_1 → I_1 ⊆ X → I ⊆ I_1 → I = I_1
state_after: no goals
tactic: exact fun J hJ hJX hIJ ↦ h.1.2.2 _ hJ hIJ hJX
Theorem: Filter.tendsto_prod_iff
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α × β → γ
x : Filter α
y : Filter β
z : Filter γ
⊢ Tendsto f (x ×ˢ y) z ↔ ∀ W ∈ z, ∃ U ∈ x, ∃ V ∈ y, ∀ (x : α) (y : β), x ∈ U → y ∈ V → f (x, y) ∈ W
state_after: no goals
tactic: simp only [tendsto_def, mem_prod_iff, prod_sub_preimage_iff, exists_prop, iff_self_iff]
Theorem: List.count_bagInter
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l l₁ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₂ : List α
⊢ count a ([].bagInter l₂) = min (count a []) (count a l₂)
state_after: no goals
tactic: simp
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ : List α
⊢ count a (l₁.bagInter []) = min (count a l₁) (count a [])
state_after: no goals
tactic: simp
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
⊢ count a ((b :: l₁).bagInter l₂) = min (count a (b :: l₁)) (count a l₂)
state_after: case pos
α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
hb : b ∈ l₂
⊢ count a ((b :: l₁).bagInter l₂) = min (count a (b :: l₁)) (count a l₂)

case neg
α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a b : α
l₁ l₂ : List α
hb : ¬b ∈ l₂
⊢ count a ((b :: l₁).bagInter l₂) = min (count a (b :: l₁)) (count a l₂)
tactic: by_cases hb : b ∈ l₂
Theorem: EuclideanDomain.zero_div
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
a0 : ¬a = 0
⊢ 0 / a = 0
state_after: no goals
tactic: simpa only [zero_mul] using mul_div_cancel_right₀ 0 a0
Theorem: Equiv.ofInjective_symm_apply
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Type u_2
f : α → β
hf : Injective f
a : α
⊢ (ofInjective f hf).symm ⟨f a, ⋯⟩ = a
state_after: case a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Type u_2
f : α → β
hf : Injective f
a : α
⊢ (ofInjective f hf) ((ofInjective f hf).symm ⟨f a, ⋯⟩) = (ofInjective f hf) a
tactic: apply (ofInjective f hf).injective
state_before: case a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Sort u_1
β : Type u_2
f : α → β
hf : Injective f
a : α
⊢ (ofInjective f hf) ((ofInjective f hf).symm ⟨f a, ⋯⟩) = (ofInjective f hf) a
state_after: no goals
tactic: simp [apply_ofInjective_symm hf]
Theorem: spectrum.add_mem_add_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

Proof steps:
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
r s : R
⊢ r + s ∈ σ (↑ₐ s + a) ↔ r ∈ σ a
state_after: no goals
tactic: rw [add_mem_iff, neg_add_cancel_left]
Theorem: Real.cos_arcsin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)

case neg
x✝ y x : ℝ
hx₁ : ¬-1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: by_cases hx₁ : -1 ≤ x
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)

case neg
x✝ y x : ℝ
hx₁ : ¬-1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case neg
x✝ y x : ℝ
hx₁ : ¬-1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)

case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: swap
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)

case neg
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: by_cases hx₂ : x ≤ 1
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)

case neg
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case neg
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : ¬x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)

case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: swap
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : sin (arcsin x) ^ 2 + cos (arcsin x) ^ 2 = 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: have : sin (arcsin x) ^ 2 + cos (arcsin x) ^ 2 = 1 := sin_sq_add_cos_sq (arcsin x)
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : sin (arcsin x) ^ 2 + cos (arcsin x) ^ 2 = 1
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : cos (arcsin x) = √(1 - sin (arcsin x) ^ 2)
⊢ cos (arcsin x) = √(1 - x ^ 2)
tactic: rw [← eq_sub_iff_add_eq', ← sqrt_inj (sq_nonneg _) (sub_nonneg.2 (sin_sq_le_one (arcsin x))), sq,
    sqrt_mul_self (cos_arcsin_nonneg _)] at this
state_before: case pos
x✝ y x : ℝ
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
this : cos (arcsin x) = √(1 - sin (arcsin x) ^ 2)
⊢ cos (arcsin x) = √(1 - x ^ 2)
state_after: no goals
tactic: rw [this, sin_arcsin hx₁ hx₂]
Theorem: Filter.isCountablyGenerated_of_seq
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
f : Filter α
h : ∃ x, f = ⨅ i, 𝓟 (x i)
⊢ f.IsCountablyGenerated
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
x : ℕ → Set α
⊢ (⨅ i, 𝓟 (x i)).IsCountablyGenerated
tactic: rcases h with ⟨x, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Sort u_5
x : ℕ → Set α
⊢ (⨅ i, 𝓟 (x i)).IsCountablyGenerated
state_after: no goals
tactic: apply isCountablyGenerated_seq
Theorem: Sublattice.coe_eq_empty
File: Mathlib/Order/Sublattice.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
⊢ ↑L = ∅ ↔ L = ⊥
state_after: no goals
tactic: rw [← coe_bot, coe_inj]
Theorem: CochainComplex.mappingCone.inl_v_descCochain_v
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.117700, u_1} C
inst✝³ : Category.{?u.117704, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
n m : ℤ
α : Cochain F K m
β : Cochain G K n
h : m + 1 = n
p₁ p₂ p₃ : ℤ
h₁₂ : p₁ + -1 = p₂
h₂₃ : p₂ + n = p₃
⊢ p₁ + m = p₃
state_after: no goals
tactic: rw [← h₂₃, ← h₁₂, ← h, add_comm m, add_assoc, neg_add_cancel_left]
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.117704, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
n m : ℤ
α : Cochain F K m
β : Cochain G K n
h : m + 1 = n
p₁ p₂ p₃ : ℤ
h₁₂ : p₁ + -1 = p₂
h₂₃ : p₂ + n = p₃
⊢ (inl φ).v p₁ p₂ h₁₂ ≫ (descCochain φ α β h).v p₂ p₃ h₂₃ = α.v p₁ p₃ ⋯
state_after: no goals
tactic: simpa only [Cochain.comp_v _ _ (show -1 + n = m by omega) p₁ p₂ p₃
    (by omega) (by omega)] using
      Cochain.congr_v (inl_descCochain φ α β h) p₁ p₃ (by omega)
Theorem: PiNat.dist_triangle_nonarch
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
⊢ dist x z ≤ max (dist x y) (dist y z)
state_after: case inl
E : ℕ → Type u_1
x y : (n : ℕ) → E n
⊢ dist x x ≤ max (dist x y) (dist y x)

case inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)
tactic: rcases eq_or_ne x z with (rfl | hxz)
state_before: case inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)
state_after: case inr.inl
E : ℕ → Type u_1
x z : (n : ℕ) → E n
hxz : x ≠ z
⊢ dist x z ≤ max (dist x x) (dist x z)

case inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
⊢ dist x z ≤ max (dist x y) (dist y z)
tactic: rcases eq_or_ne x y with (rfl | hxy)
state_before: case inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
⊢ dist x z ≤ max (dist x y) (dist y z)
state_after: case inr.inr.inl
E : ℕ → Type u_1
x y : (n : ℕ) → E n
hxy hxz : x ≠ y
⊢ dist x y ≤ max (dist x y) (dist y y)

case inr.inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
hyz : y ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)
tactic: rcases eq_or_ne y z with (rfl | hyz)
state_before: case inr.inr.inr
E : ℕ → Type u_1
x y z : (n : ℕ) → E n
hxz : x ≠ z
hxy : x ≠ y
hyz : y ≠ z
⊢ dist x z ≤ max (dist x y) (dist y z)
state_after: no goals
tactic: simp only [dist_eq_of_ne, hxz, hxy, hyz, inv_le_inv, one_div, inv_pow, zero_lt_two, Ne,
    not_false_iff, le_max_iff, pow_le_pow_iff_right, one_lt_two, pow_pos,
    min_le_iff.1 (min_firstDiff_le x y z hxz)]
Theorem: OrderIso.mulRight₀'_symm
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
⊢ (mulRight₀' ha).symm = mulRight₀' ⋯
state_after: case h.h
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
x✝ : α
⊢ (mulRight₀' ha).symm x✝ = (mulRight₀' ⋯) x✝
tactic: ext
state_before: case h.h
α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a✝ b c d : α
m n : ℕ
a : α
ha : a ≠ 0
x✝ : α
⊢ (mulRight₀' ha).symm x✝ = (mulRight₀' ⋯) x✝
state_after: no goals
tactic: rfl
Theorem: Nat.Ico_insert_succ_left
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
h : a < b
⊢ insert a (Ico a.succ b) = Ico a b
state_after: no goals
tactic: rw [Ico_succ_left, ← Ioo_insert_left h]
Theorem: Matrix.cons_mulVec
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
⊢ of (vecCons v A) *ᵥ w = vecCons (v ⬝ᵥ w) (of A *ᵥ w)
state_after: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
i : Fin m.succ
⊢ (of (vecCons v A) *ᵥ w) i = vecCons (v ⬝ᵥ w) (of A *ᵥ w) i
tactic: ext i
state_before: case h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n'
v : n' → α
A : Fin m → n' → α
w : n' → α
i : Fin m.succ
⊢ (of (vecCons v A) *ᵥ w) i = vecCons (v ⬝ᵥ w) (of A *ᵥ w) i
state_after: no goals
tactic: refine Fin.cases ?_ ?_ i <;> simp [mulVec]
Theorem: FirstOrder.Language.Hom.range_eq_map
File: Mathlib/ModelTheory/Substructures.lean

Proof steps:
state_before: 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
S : L.Substructure M
f : M →[L] N
⊢ f.range = Substructure.map f ⊤
state_after: case h
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
S : L.Substructure M
f : M →[L] N
x✝ : N
⊢ x✝ ∈ f.range ↔ x✝ ∈ Substructure.map f ⊤
tactic: ext
state_before: case h
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
S : L.Substructure M
f : M →[L] N
x✝ : N
⊢ x✝ ∈ f.range ↔ x✝ ∈ Substructure.map f ⊤
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.hasFiniteColimits_of_hasFiniteColimits_of_size
File: Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
⊢ HasColimitsOfShape J C
state_after: C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift.{w, 0} J)) C
⊢ HasColimitsOfShape J C
tactic: haveI := h (ULiftHom.{w} (ULift.{w} J)) <| @CategoryTheory.finCategoryUlift J hJ hhJ
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift.{w, 0} J)) C
⊢ HasColimitsOfShape J C
state_after: C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift.{w, 0} J)) C
l : J ≌ ULiftHom (ULift.{?u.2350, 0} J)
⊢ HasColimitsOfShape J C
tactic: have l : @Equivalence J (ULiftHom (ULift J)) hJ
                           (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) :=
      @ULiftHomULiftCategory.equiv J hJ
state_before: C : Type u
inst✝ : Category.{v, u} C
h : ∀ (J : Type w) {𝒥 : SmallCategory J}, FinCategory J → HasColimitsOfShape J C
J : Type
hJ : SmallCategory J
hhJ : FinCategory J
this : HasColimitsOfShape (ULiftHom (ULift.{w, 0} J)) C
l : J ≌ ULiftHom (ULift.{?u.2350, 0} J)
⊢ HasColimitsOfShape J C
state_after: no goals
tactic: apply @hasColimitsOfShape_of_equivalence (ULiftHom (ULift J))
      (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) C _ J hJ
      (@Equivalence.symm J hJ (ULiftHom (ULift J))
      (@ULiftHom.category (ULift J) (@uliftCategory J hJ)) l) _
Theorem: csInf_mem_of_not_isPredLimit
File: Mathlib/Order/SuccPred/CompleteLinearOrder.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
⊢ sInf s ∈ s
state_after: case intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s
tactic: obtain ⟨y, hy⟩ := not_forall_not.mp hlim
state_before: case intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
⊢ sInf s ∈ s
state_after: case intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder α
inst✝ : Nonempty ι
f : ι → α
s : Set α
x : α
hne : s.Nonempty
hbdd : BddBelow s
hlim : ¬IsPredLimit (sInf s)
y : α
hy : sInf s ⋖ y
i : α
his : i ∈ s
hi : i < y
⊢ sInf s ∈ s
tactic: obtain ⟨i, his, hi⟩ := exists_lt_of_csInf_lt hne hy.lt
Theorem: Multiset.lcm_add
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s₁ s₂ : Multiset α
⊢ (s₁ + s₂).lcm = fold GCDMonoid.lcm (GCDMonoid.lcm 1 1) (s₁ + s₂)
state_after: no goals
tactic: simp [lcm]