ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.Measure.addHaarMeasure_self
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
⊢ (haarMeasure K₀) ↑K₀ = 1
state_after: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarMeasure K₀) ↑K₀ = 1
tactic: haveI : LocallyCompactSpace G := K₀.locallyCompactSpace_of_group
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarMeasure K₀) ↑K₀ = 1
state_after: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ ((haarContent K₀).measure ↑K₀)⁻¹ * (haarContent K₀).measure ↑K₀ = 1
tactic: simp only [haarMeasure, coe_smul, Pi.smul_apply, smul_eq_mul]
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ ((haarContent K₀).measure ↑K₀)⁻¹ * (haarContent K₀).measure ↑K₀ = 1
state_after: case h0
G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarContent K₀).outerMeasure (closure ↑K₀) ≠ 0

case ht
G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarContent K₀).outerMeasure (closure ↑K₀) ≠ ⊤
tactic: rw [← K₀.isCompact.measure_closure,
    Content.measure_apply _ isClosed_closure.measurableSet, ENNReal.inv_mul_cancel]
Theorem: Matrix.trace_mul_cycle
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

Proof steps:
state_before: ι : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : Fintype p
inst✝ : NonUnitalCommSemiring R
A : Matrix m n R
B : Matrix n p R
C : Matrix p m R
⊢ (A * B * C).trace = (C * A * B).trace
state_after: no goals
tactic: rw [trace_mul_comm, Matrix.mul_assoc]
Theorem: Polynomial.roots_multiset_prod_X_sub_C
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (Multiset.map (fun a => X - C a) s).prod.roots = s
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (s.bind fun a => (X - C a).roots) = s

case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ 0 ∉ Multiset.map (fun a => X - C a) s
tactic: rw [roots_multiset_prod, Multiset.bind_map]
Theorem: PFunctor.iget_map
File: Mathlib/Data/PFunctor/Univariate/Basic.lean

Proof steps:
state_before: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).iget i = f (x.iget i)
state_after: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).snd (cast ⋯ i.snd) = f (x.snd (cast ⋯ i.snd))
tactic: simp only [Obj.iget, fst_map, *, dif_pos, eq_self_iff_true]
state_before: P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x : ↑P α
f : α → β
i : P.Idx
h : i.fst = x.fst
⊢ (P.map f x).snd (cast ⋯ i.snd) = f (x.snd (cast ⋯ i.snd))
state_after: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β
i : P.Idx
fst✝ : P.A
snd✝ : P.B fst✝ → α
h : i.fst = ⟨fst✝, snd✝⟩.fst
⊢ (P.map f ⟨fst✝, snd✝⟩).snd (cast ⋯ i.snd) = f (⟨fst✝, snd✝⟩.snd (cast ⋯ i.snd))
tactic: cases x
state_before: case mk
P : PFunctor.{u}
α : Type v₁
β : Type v₂
γ : Type v₃
inst✝² : DecidableEq P.A
inst✝¹ : Inhabited α
inst✝ : Inhabited β
f : α → β
i : P.Idx
fst✝ : P.A
snd✝ : P.B fst✝ → α
h : i.fst = ⟨fst✝, snd✝⟩.fst
⊢ (P.map f ⟨fst✝, snd✝⟩).snd (cast ⋯ i.snd) = f (⟨fst✝, snd✝⟩.snd (cast ⋯ i.snd))
state_after: no goals
tactic: rfl
Theorem: Polynomial.iterate_derivative_X_pow_eq_smul
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
⊢ (⇑derivative)^[k] (X ^ n) = ↑(n.descFactorial k) • X ^ (n - k)
state_after: no goals
tactic: rw [iterate_derivative_X_pow_eq_C_mul n k, smul_eq_C_mul]
Theorem: SimpleGraph.Walk.toDeleteEdges_copy
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v✝ w v u u' v' : V
s : Set (Sym2 V)
p : G.Walk u v
hu : u = u'
hv : v = v'
h : ∀ e ∈ (p.copy hu hv).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s
tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ ∀ e ∈ p.edges, e ∉ s
state_after: no goals
tactic: exact h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v✝ w v u u' v' : V
s : Set (Sym2 V)
p : G.Walk u v
hu : u = u'
hv : v = v'
h : ∀ e ∈ (p.copy hu hv).edges, e ∉ s
⊢ toDeleteEdges s (p.copy hu hv) h = (toDeleteEdges s p ⋯).copy hu hv
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ toDeleteEdges s (p.copy ⋯ ⋯) h = (toDeleteEdges s p ⋯).copy ⋯ ⋯
tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v w u' v' : V
s : Set (Sym2 V)
p : G.Walk u' v'
h : ∀ e ∈ (p.copy ⋯ ⋯).edges, e ∉ s
⊢ toDeleteEdges s (p.copy ⋯ ⋯) h = (toDeleteEdges s p ⋯).copy ⋯ ⋯
state_after: no goals
tactic: rfl
Theorem: List.prod_set
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ x : M
xs : List M
a : M
⊢ ((x :: xs).set 0 a).prod =
    ((take 0 (x :: xs)).prod * if 0 < (x :: xs).length then a else 1) * (drop (0 + 1) (x :: xs)).prod
state_after: no goals
tactic: simp [set]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ x : M
xs : List M
i : ℕ
a : M
⊢ ((x :: xs).set (i + 1) a).prod =
    ((take (i + 1) (x :: xs)).prod * if i + 1 < (x :: xs).length then a else 1) * (drop (i + 1 + 1) (x :: xs)).prod
state_after: no goals
tactic: simp [set, prod_set xs i a, mul_assoc, Nat.add_lt_add_iff_right]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
x✝¹ : ℕ
x✝ : M
⊢ ([].set x✝¹ x✝).prod = ((take x✝¹ []).prod * if x✝¹ < [].length then x✝ else 1) * (drop (x✝¹ + 1) []).prod
state_after: no goals
tactic: simp [set, (Nat.zero_le _).not_lt, Nat.zero_le]
Theorem: CompleteLattice.IsSupClosedCompact.wellFounded
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
⊢ WellFounded fun x x_1 => x > x_1
state_after: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ False
tactic: refine RelEmbedding.wellFounded_iff_no_descending_seq.mpr ⟨fun a => ?_⟩
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ False
state_after: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ sSup (range ⇑a) ∈ range ⇑a
tactic: suffices sSup (Set.range a) ∈ Set.range a by
    obtain ⟨n, hn⟩ := Set.mem_range.mp this
    have h' : sSup (Set.range a) < a (n + 1) := by
      change _ > _
      simp [← hn, a.map_rel_iff]
    apply lt_irrefl (a (n + 1))
    apply lt_of_le_of_lt _ h'
    apply le_sSup
    apply Set.mem_range_self
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ sSup (range ⇑a) ∈ range ⇑a
state_after: case x
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ (range ⇑a).Nonempty

case a
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : IsSupClosedCompact α
a : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ SupClosed (range ⇑a)
tactic: apply h (Set.range a)
Theorem: LucasLehmer.sMod_nonneg
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: p : ℕ
hp : p ≠ 0
i : ℕ
⊢ 0 ≤ sMod p i
state_after: case zero
p : ℕ
hp : p ≠ 0
⊢ 0 ≤ 4 % (2 ^ p - 1)

case succ
p : ℕ
hp : p ≠ 0
n✝ : ℕ
⊢ 0 ≤ (sMod p n✝ ^ 2 - 2) % (2 ^ p - 1)
tactic: cases i <;> dsimp [sMod]
Theorem: isPiSystem_Icc
File: Mathlib/MeasureTheory/PiSystem.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
ι' : Sort u_3
inst✝ : LinearOrder α
f : ι → α
g : ι' → α
⊢ ∀ {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: ENNReal.le_of_forall_pos_le_add
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : ∀ (ε : ℝ≥0), 0 < ε → b < ⊤ → a ≤ b + ↑ε
⊢ a ≤ b
state_after: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
tactic: contrapose! h
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
state_after: case intro.intro
α : Type u_1
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
h : b < a
r : ℝ≥0
hr0 : 0 < r
hr : b + ↑r < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
tactic: rcases lt_iff_exists_add_pos_lt.1 h with ⟨r, hr0, hr⟩
state_before: case intro.intro
α : Type u_1
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
h : b < a
r : ℝ≥0
hr0 : 0 < r
hr : b + ↑r < a
⊢ ∃ ε, 0 < ε ∧ b < ⊤ ∧ b + ↑ε < a
state_after: no goals
tactic: exact ⟨r, hr0, h.trans_le le_top, hr⟩
Theorem: Batteries.HashMap.Imp.Buckets.update_update
File: .lake/packages/batteries/Batteries/Data/HashMap/WF.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d d' : AssocList α β
h : i.toNat < self.val.size
h' : i.toNat < (self.update i d h).val.size
⊢ (self.update i d h).update i d' h' = self.update i d' h
state_after: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d d' : AssocList α β
h : i.toNat < self.val.size
h' : i.toNat < (self.update i d h).val.size
⊢ ⟨(self.val.set ⟨i.toNat, h⟩ d).set ⟨i.toNat, h'⟩ d', ⋯⟩ = ⟨self.val.set ⟨i.toNat, h⟩ d', ⋯⟩
tactic: simp only [update, Array.uset, Array.data_length]
state_before: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d d' : AssocList α β
h : i.toNat < self.val.size
h' : i.toNat < (self.update i d h).val.size
⊢ ⟨(self.val.set ⟨i.toNat, h⟩ d).set ⟨i.toNat, h'⟩ d', ⋯⟩ = ⟨self.val.set ⟨i.toNat, h⟩ d', ⋯⟩
state_after: case e_val
α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d d' : AssocList α β
h : i.toNat < self.val.size
h' : i.toNat < (self.update i d h).val.size
⊢ (self.val.set ⟨i.toNat, h⟩ d).set ⟨i.toNat, h'⟩ d' = self.val.set ⟨i.toNat, h⟩ d'
tactic: congr 1
state_before: case e_val
α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d d' : AssocList α β
h : i.toNat < self.val.size
h' : i.toNat < (self.update i d h).val.size
⊢ (self.val.set ⟨i.toNat, h⟩ d).set ⟨i.toNat, h'⟩ d' = self.val.set ⟨i.toNat, h⟩ d'
state_after: no goals
tactic: rw [Array.set_set]
Theorem: CategoryTheory.Iso.unop_inv_hom_id_app
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y : C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
F G : C ⥤ Dᵒᵖ
e : F ≅ G
X : C
⊢ (e.inv.app X).unop ≫ (e.hom.app X).unop = 𝟙 (Opposite.unop (F.obj X))
state_after: no goals
tactic: rw [← unop_comp, hom_inv_id_app, unop_id]
Theorem: Set.image_swap_prod
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 : Set α
t : Set β
⊢ Prod.swap '' s ×ˢ t = t ×ˢ s
state_after: no goals
tactic: rw [image_swap_eq_preimage_swap, preimage_swap_prod]
Theorem: EuclideanGeometry.collinear_of_sin_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.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
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
h : sin (∠ p₁ p₂ p₃) = 0
⊢ Collinear ℝ {p₁, 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
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ sin (∠ p₁ p₂ p₃) = 0 → Collinear ℝ {p₁, p₂, p₃}
tactic: revert h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ sin (∠ p₁ p₂ p₃) = 0 → Collinear ℝ {p₁, 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
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ ¬Collinear ℝ {p₁, p₂, p₃} → ¬sin (∠ p₁ p₂ p₃) = 0
tactic: contrapose
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p p₀ p₁✝ p₂✝ p₁ p₂ p₃ : P
⊢ ¬Collinear ℝ {p₁, p₂, p₃} → ¬sin (∠ p₁ p₂ p₃) = 0
state_after: no goals
tactic: exact sin_ne_zero_of_not_collinear
Theorem: Matroid.Indep.base_of_forall_insert
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
⊢ M.Base B
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
⊢ False
tactic: refine by_contra fun hnb ↦ ?_
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
⊢ False
state_after: case intro
α : Type u_1
M : Matroid α
B B'✝ I J D X : Set α
e f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
⊢ False
tactic: obtain ⟨B', hB'⟩ := M.exists_base
state_before: case intro
α : Type u_1
M : Matroid α
B B'✝ I J D X : Set α
e f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
⊢ False
state_after: case intro.intro.intro
α : Type u_1
M : Matroid α
B B'✝ I J D X : Set α
e✝ f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
e : α
he : e ∈ B' \ B
h : M.Indep (insert e B)
⊢ False
tactic: obtain ⟨e, he, h⟩ := hB.exists_insert_of_not_base hnb hB'
state_before: case intro.intro.intro
α : Type u_1
M : Matroid α
B B'✝ I J D X : Set α
e✝ f : α
hB : M.Indep B
hBmax : ∀ e ∈ M.E \ B, ¬M.Indep (insert e B)
hnb : ¬M.Base B
B' : Set α
hB' : M.Base B'
e : α
he : e ∈ B' \ B
h : M.Indep (insert e B)
⊢ False
state_after: no goals
tactic: exact hBmax e ⟨hB'.subset_ground he.1, he.2⟩ h
Theorem: interior_pi_set
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
⊢ interior (I.pi s) = I.pi fun i => interior (s i)
state_after: case h
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
a : (i : ι) → π i
⊢ a ∈ interior (I.pi s) ↔ a ∈ I.pi fun i => interior (s i)
tactic: ext a
state_before: case h
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
I : Set ι
hI : I.Finite
s : (i : ι) → Set (π i)
a : (i : ι) → π i
⊢ a ∈ interior (I.pi s) ↔ a ∈ I.pi fun i => interior (s i)
state_after: no goals
tactic: simp only [Set.mem_pi, mem_interior_iff_mem_nhds, set_pi_mem_nhds_iff hI]
Theorem: AddCircle.ergodic_nsmul
File: Mathlib/Dynamics/Ergodic/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
n : ℕ
hn : 1 < n
⊢ 1 < |↑n|
state_after: no goals
tactic: simp [hn]
Theorem: FreeAddGroup.Red.Step.sublist
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
H : Step L₁ L₂
⊢ L₂ <+ L₁
state_after: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₁✝ ++ L₂✝ <+ L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
tactic: cases H
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₁✝ ++ L₂✝ <+ L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
state_after: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
tactic: simp
state_before: case not
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, b✝) :: (x✝, !b✝) :: L₂✝
state_after: case not.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, !b✝) :: L₂✝
tactic: constructor
state_before: case not.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ (x✝, !b✝) :: L₂✝
state_after: case not.a.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ L₂✝
tactic: constructor
state_before: case not.a.a
α : Type u
L L₃ L₄ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ L₂✝ <+ L₂✝
state_after: no goals
tactic: rfl
Theorem: NormedAddGroupHom.coe_injective
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
⊢ Function.Injective toFun
state_after: no goals
tactic: apply coe_inj
Theorem: char_zero_of_expChar_one
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p : ℕ
hp : CharP R p
hq : ExpChar R 1
⊢ p = 0
state_after: case zero
R : Type u
inst✝² : Semiring R
inst✝¹ : Nontrivial R
p : ℕ
hp : CharP R p
inst✝ : CharZero R
⊢ p = 0

case prime
R : Type u
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p : ℕ
hp : CharP R p
hprime✝ : Nat.Prime 1
hchar✝ : CharP R 1
⊢ p = 0
tactic: cases hq
Theorem: Pi.update_eq_sub_add_single
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → Group (f i)
g : (i : I) → f i
x : f i
⊢ Function.update g i x = g / mulSingle i (g i) * mulSingle i x
state_after: case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → Group (f i)
g : (i : I) → f i
x : f i
j : I
⊢ Function.update g i x j = (g / mulSingle i (g i) * mulSingle i x) j
tactic: ext j
state_before: case h
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → Group (f i)
g : (i : I) → f i
x : f i
j : I
⊢ Function.update g i x j = (g / mulSingle i (g i) * mulSingle i x) j
state_after: case h.inl
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → Group (f i)
g : (i : I) → f i
x : f i
⊢ Function.update g i x i = (g / mulSingle i (g i) * mulSingle i x) i

case h.inr
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → Group (f i)
g : (i : I) → f i
x : f i
j : I
h : i ≠ j
⊢ Function.update g i x j = (g / mulSingle i (g i) * mulSingle i x) j
tactic: rcases eq_or_ne i j with (rfl | h)
Theorem: CategoryTheory.IsFiltered.cocone_nonempty
File: Mathlib/CategoryTheory/Filtered/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : IsFiltered C
O : Finset C
H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))
J : Type w
inst✝¹ : SmallCategory J
inst✝ : FinCategory J
F : J ⥤ C
⊢ Nonempty (Cocone F)
state_after: no goals
tactic: classical
  let O := Finset.univ.image F.obj
  let H : Finset (Σ' (X Y : C) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) :=
    Finset.univ.biUnion   fun X : J =>
      Finset.univ.biUnion fun Y : J =>
        Finset.univ.image fun f : X ⟶ Y => ⟨F.obj X, F.obj Y, by simp [O], by simp [O], F.map f⟩
  obtain ⟨Z, f, w⟩ := sup_exists O H
  refine ⟨⟨Z, ⟨fun X => f (by simp [O]), ?_⟩⟩⟩
  intro j j' g
  dsimp
  simp only [Category.comp_id]
  apply w
  simp only [O, H, Finset.mem_biUnion, Finset.mem_univ, Finset.mem_image, PSigma.mk.injEq,
    true_and, exists_and_left]
  exact ⟨j, rfl, j', g, by simp⟩
Theorem: CategoryTheory.Limits.hasStrictTerminalObjects_of_terminal_is_strict
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : C
h : ∀ (A : C) (f : I ⟶ A), IsIso f
I' A : C
f : I' ⟶ A
hI' : IsTerminal I'
this : IsIso (hI'.from I ≫ f)
⊢ (inv (hI'.from I ≫ f) ≫ hI'.from I) ≫ f = 𝟙 A
state_after: no goals
tactic: rw [assoc, IsIso.inv_hom_id]
Theorem: CategoryTheory.eqToHom_naturality
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ⟶ g b
j j' : β
w : j = j'
⊢ g j = g j'
state_after: no goals
tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ⟶ g b
j j' : β
w : j = j'
⊢ f j = f j'
state_after: no goals
tactic: simp [w]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ⟶ g b
j j' : β
w : j = j'
⊢ z j ≫ eqToHom ⋯ = eqToHom ⋯ ≫ z j'
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ⟶ g b
j : β
⊢ z j ≫ eqToHom ⋯ = eqToHom ⋯ ≫ z j
tactic: cases w
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
f g : β → C
z : (b : β) → f b ⟶ g b
j : β
⊢ z j ≫ eqToHom ⋯ = eqToHom ⋯ ≫ z j
state_after: no goals
tactic: simp
Theorem: NonUnitalNonAssocCommRing.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonUnitalNonAssocCommRing R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonUnitalNonAssocCommRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : NonUnitalNonAssocCommRing R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl