ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Sym2.GameAdd.fix_eq
File: Mathlib/Order/GameAdd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ fix hr IH a b = IH a b fun a' b' x => fix hr IH a' b'
state_after: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a, b) =
    IH a b fun a' b' x => ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a', b')
tactic: dsimp [GameAdd.fix]
state_before: α : Type u_1
β : Type u_2
rα : α → α → Prop
rβ : β → β → Prop
a✝ : α
b✝ : β
C : α → α → Sort u_3
hr : WellFounded rα
IH : (a₁ b₁ : α) → ((a₂ b₂ : α) → GameAdd rα s(a₂, b₂) s(a₁, b₁) → C a₂ b₂) → C a₁ b₁
a b : α
⊢ ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a, b) =
    IH a b fun a' b' x => ⋯.fix (fun x IH' => IH x.1 x.2 fun a' b' => IH' (a', b')) (a', b')
state_after: no goals
tactic: exact WellFounded.fix_eq _ _ _
Theorem: SimpleGraph.Connected.dist_triangle
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
⊢ G.dist u w ≤ G.dist u v + G.dist v w
state_after: case intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
⊢ G.dist u w ≤ G.dist u v + G.dist v w
tactic: obtain ⟨p, hp⟩ := hconn.exists_walk_length_eq_dist u v
state_before: case intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
⊢ G.dist u w ≤ G.dist u v + G.dist v w
state_after: case intro.intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
q : G.Walk v w
hq : q.length = G.dist v w
⊢ G.dist u w ≤ G.dist u v + G.dist v w
tactic: obtain ⟨q, hq⟩ := hconn.exists_walk_length_eq_dist v w
state_before: case intro.intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
q : G.Walk v w
hq : q.length = G.dist v w
⊢ G.dist u w ≤ G.dist u v + G.dist v w
state_after: case intro.intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
q : G.Walk v w
hq : q.length = G.dist v w
⊢ G.dist u w ≤ (p.append q).length
tactic: rw [← hp, ← hq, ← Walk.length_append]
state_before: case intro.intro
V : Type u_1
G : SimpleGraph V
u v w : V
hconn : G.Connected
p : G.Walk u v
hp : p.length = G.dist u v
q : G.Walk v w
hq : q.length = G.dist v w
⊢ G.dist u w ≤ (p.append q).length
state_after: no goals
tactic: apply dist_le
Theorem: ArithmeticFunction.abscissaOfAbsConv_zeta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: ⊢ (abscissaOfAbsConv fun n => ↑(ζ n)) = 1
state_after: no goals
tactic: rw [abscissaOfAbsConv_congr (g := 1) fun hn ↦ by simp [hn], abscissaOfAbsConv_one]
Theorem: List.get_attach
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ L : List α
i : Fin L.attach.length
⊢ ↑(L.attach.get i) = L.get ⟨↑i, ⋯⟩
state_after: no goals
tactic: simp
Theorem: sup_eq_maxDefault
File: Mathlib/Order/Lattice.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
⊢ (fun x x_1 => x ⊔ x_1) = maxDefault
state_after: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = maxDefault x y
tactic: ext x y
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = maxDefault x y
state_after: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = if x ≤ y then y else x
tactic: unfold maxDefault
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = if x ≤ y then y else x
state_after: case pos
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
h' : x ≤ y
⊢ x ⊔ y = y

case neg
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
h' : ¬x ≤ y
⊢ x ⊔ y = x
tactic: split_ifs with h'
Theorem: List.Chain'.two_mul_count_bool_eq_ite
File: Mathlib/Data/Bool/Count.lean

Proof steps:
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1
state_after: case pos
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
h2 : Even l.length
⊢ 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1

case neg
l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
h2 : ¬Even l.length
⊢ 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1
tactic: by_cases h2 : Even (length l)
Theorem: Finset.eraseNone_none
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
⊢ eraseNone {none} = ∅
state_after: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone {none} ↔ a✝ ∈ ∅
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
a✝ : α
⊢ a✝ ∈ eraseNone {none} ↔ a✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: toIocMod_eq_iff
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ toIocMod hp a b = c ↔ c ∈ Set.Ioc a (a + p) ∧ ∃ z, b = c + z • p
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ioc a (a + p) ∧ ∃ z, b = c + z • p) → toIocMod hp a b = c
tactic: refine
    ⟨fun h =>
      ⟨h ▸ toIocMod_mem_Ioc hp a b, toIocDiv hp a b, h ▸ (toIocMod_add_toIocDiv_zsmul hp _ _).symm⟩,
      ?_⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ioc a (a + p) ∧ ∃ z, b = c + z • p) → toIocMod hp a b = c
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ioc a (a + p) ∧ ∃ z, b - z • p = c) → toIocMod hp a b = c
tactic: simp_rw [← @sub_eq_iff_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
⊢ (c ∈ Set.Ioc a (a + p) ∧ ∃ z, b - z • p = c) → toIocMod hp a b = c
state_after: case intro.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
n✝ n : ℤ
hc : b - n • p ∈ Set.Ioc a (a + p)
⊢ toIocMod hp a b = b - n • p
tactic: rintro ⟨hc, n, rfl⟩
state_before: case intro.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b : α
n✝ n : ℤ
hc : b - n • p ∈ Set.Ioc a (a + p)
⊢ toIocMod hp a b = b - n • p
state_after: no goals
tactic: rw [← toIocDiv_eq_of_sub_zsmul_mem_Ioc hp hc, toIocMod]
Theorem: Path.Homotopic.comp_pi_eq_pi_comp
File: Mathlib/Topology/Homotopy/Product.lean

Proof steps:
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ₀ : (i : ι) → Homotopic.Quotient (as i) (bs i)
γ₁ : (i : ι) → Homotopic.Quotient (bs i) (cs i)
⊢ pi γ₀ ⬝ pi γ₁ = pi fun i => γ₀ i ⬝ γ₁ i
state_after: no goals
tactic: induction γ₁ using Quotient.induction_on_pi with | _ a =>
  induction γ₀ using Quotient.induction_on_pi
  simp only [pi_lift]
  rw [← Path.Homotopic.comp_lift, Path.trans_pi_eq_pi_trans, ← pi_lift]
  rfl
Theorem: circleIntegrable_sub_zpow_iff
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
n : ℤ
⊢ CircleIntegrable (fun z => (z - w) ^ n) c R ↔ R = 0 ∨ 0 ≤ n ∨ w ∉ sphere c |R|
state_after: case mp
E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
n : ℤ
⊢ CircleIntegrable (fun z => (z - w) ^ n) c R → R = 0 ∨ 0 ≤ n ∨ w ∉ sphere c |R|

case mpr
E : Type u_1
inst✝ : NormedAddCommGroup E
c w : ℂ
R : ℝ
n : ℤ
⊢ R = 0 ∨ 0 ≤ n ∨ w ∉ sphere c |R| → CircleIntegrable (fun z => (z - w) ^ n) c R
tactic: constructor
Theorem: Finset.min'_mem
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.min = ↑(s.min' H)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.inf WithTop.some = s.inf (WithTop.some ∘ fun x => x)
tactic: simp only [Finset.min, min', id_eq, coe_inf']
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
⊢ s.inf WithTop.some = s.inf (WithTop.some ∘ fun x => x)
state_after: no goals
tactic: rfl
Theorem: Nat.lcm_pos
File: Mathlib/Data/Nat/GCD/Basic.lean

Proof steps:
state_before: m n : ℕ
⊢ 0 < m → 0 < n → 0 < m.lcm n
state_after: m n : ℕ
⊢ m ≠ 0 → n ≠ 0 → m.lcm n ≠ 0
tactic: simp_rw [Nat.pos_iff_ne_zero]
state_before: m n : ℕ
⊢ m ≠ 0 → n ≠ 0 → m.lcm n ≠ 0
state_after: no goals
tactic: exact lcm_ne_zero
Theorem: WeierstrassCurve.map_Φ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (W.map f).Φ n = Polynomial.map f (W.Φ n)
state_after: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (X * (mapRingHom f) (W.ΨSq n) -
      (mapRingHom f) (W.preΨ (n + 1)) * (mapRingHom f) (W.preΨ (n - 1)) * if Even n then 1 else (mapRingHom f) W.Ψ₂Sq) =
    (mapRingHom f) (X * W.ΨSq n - W.preΨ (n + 1) * W.preΨ (n - 1) * if Even n then 1 else W.Ψ₂Sq)
tactic: simp only [Φ, map_ΨSq, map_preΨ, map_Ψ₂Sq, ← coe_mapRingHom]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
f : R →+* S
n : ℤ
⊢ (X * (mapRingHom f) (W.ΨSq n) -
      (mapRingHom f) (W.preΨ (n + 1)) * (mapRingHom f) (W.preΨ (n - 1)) * if Even n then 1 else (mapRingHom f) W.Ψ₂Sq) =
    (mapRingHom f) (X * W.ΨSq n - W.preΨ (n + 1) * W.preΨ (n - 1) * if Even n then 1 else W.Ψ₂Sq)
state_after: no goals
tactic: map_simp
Theorem: CategoryTheory.Limits.PushoutCocone.unop_fst
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : Cᵒᵖ
f : X ⟶ Y
g : X ⟶ Z
c : PushoutCocone f g
⊢ c.unop.fst = c.inl.unop
state_after: no goals
tactic: simp
Theorem: Set.image_const_add_Ioc
File: Mathlib/Algebra/Order/Interval/Set/Monoid.lean

Proof steps:
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ioc b c = Ioc (a + b) (a + c)
state_after: no goals
tactic: simp only [add_comm a, image_add_const_Ioc]
Theorem: AddConstMapClass.map_sub_nat'
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroupWithOne G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H 1 b
f : F
x : G
n : ℕ
⊢ f (x - ↑n) = f x - n • b
state_after: no goals
tactic: simpa using map_sub_nsmul f x n
Theorem: TopologicalSpace.Opens.inclusion_top_functor
File: Mathlib/Topology/Category/TopCat/Opens.lean

Proof steps:
state_before: X : TopCat
⊢ ⋯.functor = map (inclusionTopIso X).inv
state_after: case refine_1
X : TopCat
⊢ ∀ (X_1 : Opens ↑((toTopCat X).obj ⊤)), ⋯.functor.obj X_1 = (map (inclusionTopIso X).inv).obj X_1

case refine_2
X : TopCat
⊢ ∀ (X_1 Y : Opens ↑((toTopCat X).obj ⊤)) (f : X_1 ⟶ Y),
    ⋯.functor.map f = eqToHom ⋯ ≫ (map (inclusionTopIso X).inv).map f ≫ eqToHom ⋯
tactic: refine CategoryTheory.Functor.ext ?_ ?_
Theorem: Finset.Nat.prod_antidiagonal_subst
File: Mathlib/Algebra/BigOperators/NatAntidiagonal.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : AddCommMonoid N
n : ℕ
f : ℕ × ℕ → ℕ → M
p : ℕ × ℕ
hp : p ∈ antidiagonal n
⊢ f p n = f p (p.1 + p.2)
state_after: no goals
tactic: rw [mem_antidiagonal.mp hp]
Theorem: Complex.normSq_eq_abs
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: x : ℂ
⊢ normSq x = abs x ^ 2
state_after: no goals
tactic: simp [abs, sq, abs_def, Real.mul_self_sqrt (normSq_nonneg _)]
Theorem: List.cons_sublist_cons'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
⊢ a :: l₁ <+ b :: l₂ ↔ a :: l₁ <+ l₂ ∨ a = b ∧ l₁ <+ l₂
state_after: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
⊢ a :: l₁ <+ b :: l₂ → a :: l₁ <+ l₂ ∨ a = b ∧ l₁ <+ l₂

case mpr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
⊢ a :: l₁ <+ l₂ ∨ a = b ∧ l₁ <+ l₂ → a :: l₁ <+ b :: l₂
tactic: constructor
Theorem: ne_zero_of_nnnorm_ne_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
a : E
⊢ a = 1 → ‖a‖₊ = 0
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ ‖1‖₊ = 0
tactic: rintro rfl
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
⊢ ‖1‖₊ = 0
state_after: no goals
tactic: exact nnnorm_one'
Theorem: CategoryTheory.MonoidalCategory.id_tensor_rightUnitor_inv
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : MonoidalCategory C
X Y : C
⊢ 𝟙 X ⊗ (ρ_ Y).inv = (ρ_ (X ⊗ Y)).inv ≫ (α_ X Y (𝟙_ C)).hom
state_after: no goals
tactic: coherence
Theorem: SimpleGraph.card_commonNeighbors_top
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v w : V
h : v ≠ w
⊢ Fintype.card ↑(⊤.commonNeighbors v w) = Fintype.card V - 2
state_after: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v w : V
h : v ≠ w
⊢ (Set.univ.toFinset \ {v, w}.toFinset).card = Fintype.card V - 2
tactic: simp only [commonNeighbors_top_eq, ← Set.toFinset_card, Set.toFinset_diff]
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v w : V
h : v ≠ w
⊢ (Set.univ.toFinset \ {v, w}.toFinset).card = Fintype.card V - 2
state_after: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v w : V
h : v ≠ w
⊢ Set.univ.toFinset.card - {v, w}.toFinset.card = Fintype.card V - 2

V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝¹ : Fintype V
inst✝ : DecidableEq V
v w : V
h : v ≠ w
⊢ {v, w}.toFinset ⊆ Set.univ.toFinset
tactic: rw [Finset.card_sdiff]
Theorem: Nat.factorial_mul_pow_sub_le_factorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
⊢ n ! * n ^ (m - n) ≤ m !
state_after: no goals
tactic: calc
    _ ≤ n ! * (n + 1) ^ (m - n) := Nat.mul_le_mul_left _ (Nat.pow_le_pow_left n.le_succ _)
    _ ≤ _ := by simpa [hnm] using @Nat.factorial_mul_pow_le_factorial n (m - n)
Theorem: Bool.not_eq_true_eq_eq_false
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: a : Bool
⊢ ((!a) = true) = (a = false)
state_after: no goals
tactic: cases a <;> simp
Theorem: MeasureTheory.FinStronglyMeasurable.const_smul
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
⊢ FinStronglyMeasurable (c • f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support ↑((fun n => c • hf.approx n) n)) < ⊤
tactic: refine ⟨fun n => c • hf.approx n, fun n => ?_, fun x => (hf.tendsto_approx x).const_smul c⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support ↑((fun n => c • hf.approx n) n)) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support (c • ↑(hf.approx n))) < ⊤
tactic: rw [SimpleFunc.coe_smul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁶ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝⁵ : TopologicalSpace β
𝕜 : Type u_5
inst✝⁴ : TopologicalSpace 𝕜
inst✝³ : AddMonoid β
inst✝² : Monoid 𝕜
inst✝¹ : DistribMulAction 𝕜 β
inst✝ : ContinuousSMul 𝕜 β
hf : FinStronglyMeasurable f μ
c : 𝕜
n : ℕ
⊢ μ (support (c • ↑(hf.approx n))) < ⊤
state_after: no goals
tactic: exact (measure_mono (support_const_smul_subset c _)).trans_lt (hf.fin_support_approx n)
Theorem: CategoryTheory.Abelian.mono_inl_of_isColimit
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
⊢ Mono s.inl
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.left)
⊢ Mono s.inl
tactic: haveI : Mono (NatTrans.app (colimit.cocone (span f g)).ι WalkingCospan.left) :=
    Abelian.mono_pushout_of_mono_g f g
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono g
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.left)
⊢ Mono s.inl
state_after: no goals
tactic: apply
    mono_of_mono_fac (IsColimit.comp_coconePointUniqueUpToIso_hom hs (colimit.isColimit _) _)
Theorem: IsCoprime.pow_left
File: Mathlib/RingTheory/Coprime/Lemmas.lean

Proof steps:
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (x ^ m) y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (∏ _x ∈ range m, x) y
tactic: rw [← Finset.card_range m, ← Finset.prod_const]
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
H : IsCoprime x y
⊢ IsCoprime (∏ _x ∈ range m, x) y
state_after: no goals
tactic: exact IsCoprime.prod_left fun _ _ ↦ H
Theorem: inv_nhdsWithin_Ioi_zero
File: Mathlib/Topology/Algebra/Order/Field.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
⊢ (𝓝[>] 0)⁻¹ = atTop
state_after: no goals
tactic: rw [← inv_atTop₀, inv_inv]
Theorem: CategoryTheory.Iso.toAlgEquiv_apply
File: Mathlib/Algebra/Category/AlgebraCat/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑X
⊢ i.inv (i.hom x) = x
state_after: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑X
⊢ (i.hom ≫ i.inv) x = x
tactic: change (i.hom ≫ i.inv) x = x
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑X
⊢ (i.hom ≫ i.inv) x = x
state_after: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑X
⊢ (𝟙 X) x = x
tactic: simp only [hom_inv_id]
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑X
⊢ (𝟙 X) x = x
state_after: no goals
tactic: erw [id_apply]
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑Y
⊢ i.hom (i.inv x) = x
state_after: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑Y
⊢ (i.inv ≫ i.hom) x = x
tactic: change (i.inv ≫ i.hom) x = x
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑Y
⊢ (i.inv ≫ i.hom) x = x
state_after: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑Y
⊢ (𝟙 Y) x = x
tactic: simp only [inv_hom_id]
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
X Y : AlgebraCat R
i : X ≅ Y
x : ↑Y
⊢ (𝟙 Y) x = x
state_after: no goals
tactic: erw [id_apply]
Theorem: Complex.normSq_neg
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ normSq (-z) = normSq z
state_after: no goals
tactic: simp [normSq]
Theorem: Mathlib.Vector.mem_succ_iff
File: Mathlib/Data/Vector/Mem.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α (n + 1)
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
state_after: case intro.intro
α : Type u_1
β : Type u_2
n : ℕ
a a'✝ : α
v : Vector α (n + 1)
a' : α
v' : Vector α n
h : v = a' ::ᵥ v'
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
tactic: obtain ⟨a', v', h⟩ := exists_eq_cons v
state_before: case intro.intro
α : Type u_1
β : Type u_2
n : ℕ
a a'✝ : α
v : Vector α (n + 1)
a' : α
v' : Vector α n
h : v = a' ::ᵥ v'
⊢ a ∈ v.toList ↔ a = v.head ∨ a ∈ v.tail.toList
state_after: no goals
tactic: simp_rw [h, Vector.mem_cons_iff, Vector.head_cons, Vector.tail_cons]
Theorem: mul_inv_lt_mul_inv_iff'
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b
state_after: no goals
tactic: rw [mul_comm c, mul_inv_lt_inv_mul_iff, mul_comm]
Theorem: CategoryTheory.essentiallySmall_iff
File: Mathlib/CategoryTheory/EssentiallySmall.lean

Proof steps:
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
C : Type u
inst✝ : Category.{v, u} C
⊢ EssentiallySmall.{w, v, u} C ↔ Small.{w, u} (Skeleton C) ∧ LocallySmall.{w, v, u} C
state_after: case mp
C✝ : Type u
inst✝¹ : Category.{v, u} C✝
C : Type u
inst✝ : Category.{v, u} C
⊢ EssentiallySmall.{w, v, u} C → Small.{w, u} (Skeleton C) ∧ LocallySmall.{w, v, u} C

case mpr
C✝ : Type u
inst✝¹ : Category.{v, u} C✝
C : Type u
inst✝ : Category.{v, u} C
⊢ Small.{w, u} (Skeleton C) ∧ LocallySmall.{w, v, u} C → EssentiallySmall.{w, v, u} C
tactic: fconstructor