ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: quasispectrum_eq_spectrum_union_zero
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

Proof steps:
state_before: R✝ : Type u_1
A✝ : Type u_2
inst✝⁷ : CommSemiring R✝
inst✝⁶ : NonUnitalRing A✝
inst✝⁵ : Module R✝ A✝
inst✝⁴ : IsScalarTower R✝ A✝ A✝
inst✝³ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝² : Semifield R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
⊢ quasispectrum R a = spectrum R a ∪ {0}
state_after: case h.e'_3.h.e'_4
R✝ : Type u_1
A✝ : Type u_2
inst✝⁷ : CommSemiring R✝
inst✝⁶ : NonUnitalRing A✝
inst✝⁵ : Module R✝ A✝
inst✝⁴ : IsScalarTower R✝ A✝ A✝
inst✝³ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝² : Semifield R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
⊢ {0} = {r | ¬IsUnit r}
tactic: convert quasispectrum_eq_spectrum_union R a
state_before: case h.e'_3.h.e'_4
R✝ : Type u_1
A✝ : Type u_2
inst✝⁷ : CommSemiring R✝
inst✝⁶ : NonUnitalRing A✝
inst✝⁵ : Module R✝ A✝
inst✝⁴ : IsScalarTower R✝ A✝ A✝
inst✝³ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝² : Semifield R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
⊢ {0} = {r | ¬IsUnit r}
state_after: case h.e'_3.h.e'_4.h
R✝ : Type u_1
A✝ : Type u_2
inst✝⁷ : CommSemiring R✝
inst✝⁶ : NonUnitalRing A✝
inst✝⁵ : Module R✝ A✝
inst✝⁴ : IsScalarTower R✝ A✝ A✝
inst✝³ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝² : Semifield R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
x : R
⊢ x ∈ {0} ↔ x ∈ {r | ¬IsUnit r}
tactic: ext x
state_before: case h.e'_3.h.e'_4.h
R✝ : Type u_1
A✝ : Type u_2
inst✝⁷ : CommSemiring R✝
inst✝⁶ : NonUnitalRing A✝
inst✝⁵ : Module R✝ A✝
inst✝⁴ : IsScalarTower R✝ A✝ A✝
inst✝³ : SMulCommClass R✝ A✝ A✝
R : Type u_3
A : Type u_4
inst✝² : Semifield R
inst✝¹ : Ring A
inst✝ : Algebra R A
a : A
x : R
⊢ x ∈ {0} ↔ x ∈ {r | ¬IsUnit r}
state_after: no goals
tactic: simp
Theorem: even_iff_exists_two_mul
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ Even a ↔ ∃ b, a = 2 * b
state_after: no goals
tactic: simp [even_iff_exists_two_nsmul]
Theorem: Option.forall_some_ne_iff_eq_none
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o : Option α
⊢ (∀ (x : α), some x ≠ o) ↔ o = none
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o : Option α
⊢ (¬∀ (x : α), some x ≠ o) ↔ ¬o = none
tactic: apply not_iff_not.1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o : Option α
⊢ (¬∀ (x : α), some x ≠ o) ↔ ¬o = none
state_after: no goals
tactic: simpa only [not_forall, not_not] using Option.ne_none_iff_exists.symm
Theorem: List.splitOnP.go_ne_nil
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs✝ ys : List α
ls : List (List α)
f : List α → List α
xs acc : List α
⊢ go p xs acc ≠ []
state_after: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (acc : List α), go p tail✝ acc ≠ []
acc : List α
⊢ ¬(if p head✝ = true then acc.reverse :: go p tail✝ [] else go p tail✝ (head✝ :: acc)) = []
tactic: induction xs generalizing acc <;> simp [go]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (acc : List α), go p tail✝ acc ≠ []
acc : List α
⊢ ¬(if p head✝ = true then acc.reverse :: go p tail✝ [] else go p tail✝ (head✝ :: acc)) = []
state_after: no goals
tactic: split <;> simp [*]
Theorem: Substring.ValidFor.extract
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l m r ml mm mr : List Char
b e : Pos
⊢ ∃ l' r',
    ValidFor l' mm r'
      ({ str := { data := l ++ (ml ++ mm ++ mr) ++ r }, startPos := { byteIdx := utf8Len l },
            stopPos := { byteIdx := utf8Len l + utf8Len (ml ++ mm ++ mr) } }.extract
        { byteIdx := utf8Len ml } { byteIdx := utf8Len ml + utf8Len mm })
state_after: l m r ml mm mr : List Char
b e : Pos
⊢ ∃ l' r',
    ValidFor l' mm r'
      (if utf8Len ml + utf8Len mm ≤ utf8Len ml then { str := "", startPos := 0, stopPos := 0 }
      else
        { str := { data := l ++ (ml ++ (mm ++ (mr ++ r))) },
          startPos :=
            { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
              ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml }),
          stopPos :=
            { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
              ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml + utf8Len mm }) })
tactic: simp only [Substring.extract, ge_iff_le, Pos.mk_le_mk, List.append_assoc, utf8Len_append]
state_before: l m r ml mm mr : List Char
b e : Pos
⊢ ∃ l' r',
    ValidFor l' mm r'
      (if utf8Len ml + utf8Len mm ≤ utf8Len ml then { str := "", startPos := 0, stopPos := 0 }
      else
        { str := { data := l ++ (ml ++ (mm ++ (mr ++ r))) },
          startPos :=
            { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
              ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml }),
          stopPos :=
            { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
              ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml + utf8Len mm }) })
state_after: case isTrue
l m r ml mm mr : List Char
b e : Pos
h✝ : utf8Len ml + utf8Len mm ≤ utf8Len ml
⊢ ∃ l' r', ValidFor l' mm r' { str := "", startPos := 0, stopPos := 0 }

case isFalse
l m r ml mm mr : List Char
b e : Pos
h✝ : ¬utf8Len ml + utf8Len mm ≤ utf8Len ml
⊢ ∃ l' r',
    ValidFor l' mm r'
      { str := { data := l ++ (ml ++ (mm ++ (mr ++ r))) },
        startPos :=
          { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
            ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml }),
        stopPos :=
          { byteIdx := utf8Len l + (utf8Len ml + (utf8Len mm + utf8Len mr)) }.min
            ({ byteIdx := utf8Len l } + { byteIdx := utf8Len ml + utf8Len mm }) }
tactic: split
Theorem: LocallyBoundedVariationOn.ae_differentiableAt
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : LinearOrder α
E : Type u_2
inst✝³ : PseudoEMetricSpace E
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
⊢ ∀ᵐ (x : ℝ), DifferentiableAt ℝ f x
state_after: case h
α : Type u_1
inst✝⁴ : LinearOrder α
E : Type u_2
inst✝³ : PseudoEMetricSpace E
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableWithinAt ℝ f univ x
⊢ DifferentiableAt ℝ f x
tactic: filter_upwards [h.ae_differentiableWithinAt_of_mem] with x hx
state_before: case h
α : Type u_1
inst✝⁴ : LinearOrder α
E : Type u_2
inst✝³ : PseudoEMetricSpace E
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableWithinAt ℝ f univ x
⊢ DifferentiableAt ℝ f x
state_after: case h
α : Type u_1
inst✝⁴ : LinearOrder α
E : Type u_2
inst✝³ : PseudoEMetricSpace E
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableAt ℝ f x
⊢ DifferentiableAt ℝ f x
tactic: rw [differentiableWithinAt_univ] at hx
state_before: case h
α : Type u_1
inst✝⁴ : LinearOrder α
E : Type u_2
inst✝³ : PseudoEMetricSpace E
V : Type u_3
inst✝² : NormedAddCommGroup V
inst✝¹ : NormedSpace ℝ V
inst✝ : FiniteDimensional ℝ V
f : ℝ → V
h : LocallyBoundedVariationOn f univ
x : ℝ
hx : x ∈ univ → DifferentiableAt ℝ f x
⊢ DifferentiableAt ℝ f x
state_after: no goals
tactic: exact hx (mem_univ _)
Theorem: LinearPMap.IsClosable.graph_closure_eq_closure_graph
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

Proof steps:
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ f.graph.topologicalClosure = f.closure.graph
state_after: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ f.graph.topologicalClosure = (Exists.choose hf).graph
tactic: rw [closure_def hf]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ f.graph.topologicalClosure = (Exists.choose hf).graph
state_after: no goals
tactic: exact hf.choose_spec
Theorem: Pell.y_dvd_iff
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
⊢ False
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
⊢ False
tactic: have co : Nat.Coprime (yn a1 m) (xn a1 (m * (n / m))) :=
          Nat.Coprime.symm <| (xy_coprime a1 _).coprime_dvd_right (y_mul_dvd a1 m (n / m))
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
⊢ False
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False
tactic: have m0 : 0 < m :=
          m.eq_zero_or_pos.resolve_left fun e => by
            rw [e, Nat.mod_zero] at hp;rw [e] at h
            exact _root_.ne_of_lt (strictMono_y a1 hp) (eq_zero_of_zero_dvd h).symm
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ yn a1 n
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ xn a1 (n % m) * yn a1 (m * (n / m)) + yn a1 (n % m) * xn a1 (m * (n / m))
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False
tactic: rw [← Nat.mod_add_div n m, yn_add] at h
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : yn a1 m ∣ xn a1 (n % m) * yn a1 (m * (n / m)) + yn a1 (n % m) * xn a1 (m * (n / m))
hp : n % m > 0
co : (yn a1 m).Coprime (xn a1 (m * (n / m)))
m0 : 0 < m
⊢ False
state_after: no goals
tactic: exact
          not_le_of_gt (strictMono_y _ <| Nat.mod_lt n m0)
            (Nat.le_of_dvd (strictMono_y _ hp) <|
              co.dvd_of_dvd_mul_right <|
                (Nat.dvd_add_iff_right <| (y_mul_dvd _ _ _).mul_left _).2 h)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ yn a1 m ∣ yn a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ yn a1 m ∣ yn a1 (m * k)
tactic: rw [e]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
x✝ : m ∣ n
k : ℕ
e : n = m * k
⊢ yn a1 m ∣ yn a1 (m * k)
state_after: no goals
tactic: apply y_mul_dvd
Theorem: Ultrafilter.le_sup_iff
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ g✝ : Ultrafilter α
s t : Set α
p q : α → Prop
u : Ultrafilter α
f g : Filter α
⊢ ¬↑u ≤ f ⊔ g ↔ ¬(↑u ≤ f ∨ ↑u ≤ g)
state_after: no goals
tactic: simp only [← disjoint_iff_not_le, not_or, disjoint_sup_right]
Theorem: discrim_lt_zero_of_neg
File: Mathlib/Algebra/QuadraticDiscriminant.lean

Proof steps:
state_before: K : Type u_1
inst✝ : LinearOrderedField K
a b c : K
ha : a ≠ 0
h : ∀ (x : K), a * x * x + b * x + c < 0
⊢ ∀ (x : K), 0 < -a * x * x + -b * x + -c
state_after: no goals
tactic: simpa only [neg_mul, ← neg_add, neg_pos]
Theorem: List.inter_cons_of_not_mem
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l l₁✝ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₁ : List α
h : ¬a ∈ l₂
⊢ (a :: l₁) ∩ l₂ = l₁ ∩ l₂
state_after: no goals
tactic: simp [Inter.inter, List.inter, h]
Theorem: List.get?_modifyNth
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
m : Nat
⊢ (modifyNth f n l).get? m = (fun a => if n = m then f a else a) <$> l.get? m
state_after: no goals
tactic: simp [getElem?_modifyNth]
Theorem: Finsupp.erase_ne
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
f : α →₀ M
h : a' ≠ a
⊢ (erase a f) a' = f a'
state_after: no goals
tactic: classical simp only [erase, coe_mk, h, ite_false]
Theorem: Finset.inv_smul_finset_distrib₀
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ (a • s)⁻¹ = op a⁻¹ • s⁻¹
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : DecidableEq α
s : Finset α
⊢ (0 • s)⁻¹ = op 0⁻¹ • s⁻¹

case inr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a✝ : α
b : β
inst✝ : DecidableEq α
a : α
s : Finset α
ha : a ≠ 0
⊢ (a • s)⁻¹ = op a⁻¹ • s⁻¹
tactic: obtain rfl | ha := eq_or_ne a 0
Theorem: FirstOrder.Language.BoundedFormula.realize_alls
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
φ : L.BoundedFormula α n
v : α → M
⊢ φ.alls.Realize v ↔ ∀ (xs : Fin n → M), φ.Realize v xs
state_after: case zero
L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
v : α → M
φ : L.BoundedFormula α 0
⊢ φ.alls.Realize v ↔ ∀ (xs : Fin 0 → M), φ.Realize v xs

case succ
L : Language
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
α : Type u'
β : Type v'
γ : Type u_3
n✝ : ℕ
T : L.Theory
v : α → M
n : ℕ
ih : ∀ {φ : L.BoundedFormula α n}, φ.alls.Realize v ↔ ∀ (xs : Fin n → M), φ.Realize v xs
φ : L.BoundedFormula α (n + 1)
⊢ φ.alls.Realize v ↔ ∀ (xs : Fin (n + 1) → M), φ.Realize v xs
tactic: induction' n with n ih
Theorem: Ordinal.le_bmex_of_forall
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
⊢ a ≤ o.bmex f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
h : o.bmex f < a
⊢ False
tactic: by_contra! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
f : (a : Ordinal.{u_4}) → a < o → Ordinal.{max u_4 u_5}
a : Ordinal.{max u_4 u_5}
H : ∀ b < a, ∃ i, ∃ (hi : i < o), f i hi = b
h : o.bmex f < a
⊢ False
state_after: no goals
tactic: exact bmex_not_mem_brange f (H _ h)
Theorem: Rat.toNNRat_lt_iff_lt_coe
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p✝ q : ℚ
p : ℚ≥0
hq : 0 ≤ q
⊢ q.toNNRat < p ↔ q < ↑p
state_after: no goals
tactic: rw [← coe_lt_coe, Rat.coe_toNNRat q hq]
Theorem: CategoryTheory.CostructuredArrow.unop_left_comp_underlyingIso_hom_unop
File: Mathlib/CategoryTheory/Subobject/Comma.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v, u₁} C
D : Type u₂
inst✝¹ : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
inst✝ : Mono f.unop.left.op
⊢ f.unop.left ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop = (Subobject.mk f.unop.left.op).arrow.unop
state_after: C : Type u₁
inst✝² : Category.{v, u₁} C
D : Type u₂
inst✝¹ : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
inst✝ : Mono f.unop.left.op
⊢ f.unop.left.op.unop ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop = (Subobject.mk f.unop.left.op).arrow.unop
tactic: conv_lhs =>
    congr
    rw [← Quiver.Hom.unop_op f.unop.left]
state_before: C : Type u₁
inst✝² : Category.{v, u₁} C
D : Type u₂
inst✝¹ : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
inst✝ : Mono f.unop.left.op
⊢ f.unop.left.op.unop ≫ (Subobject.underlyingIso f.unop.left.op).hom.unop = (Subobject.mk f.unop.left.op).arrow.unop
state_after: no goals
tactic: rw [← unop_comp, Subobject.underlyingIso_hom_comp_eq_mk]
Theorem: Real.strictAnti_eulerMascheroniSeq'
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

Proof steps:
state_before: ⊢ StrictAnti eulerMascheroniSeq'
state_after: n : ℕ
⊢ eulerMascheroniSeq' (n + 1) < eulerMascheroniSeq' n
tactic: refine strictAnti_nat_of_succ_lt (fun n ↦ ?_)
state_before: n : ℕ
⊢ eulerMascheroniSeq' (n + 1) < eulerMascheroniSeq' n
state_after: case inl

⊢ eulerMascheroniSeq' (0 + 1) < eulerMascheroniSeq' 0

case inr
n : ℕ
hn : n > 0
⊢ eulerMascheroniSeq' (n + 1) < eulerMascheroniSeq' n
tactic: rcases Nat.eq_zero_or_pos n with rfl | hn
state_before: case inr
n : ℕ
hn : n > 0
⊢ eulerMascheroniSeq' (n + 1) < eulerMascheroniSeq' n
state_after: case inr
n : ℕ
hn : n > 0
⊢ ↑(harmonic (n + 1)) - log ↑(n + 1) < ↑(harmonic n) - log ↑n
tactic: simp_rw [eulerMascheroniSeq', eq_false_intro hn.ne', if_false]
state_before: case inr
n : ℕ
hn : n > 0
⊢ ↑(harmonic (n + 1)) - log ↑(n + 1) < ↑(harmonic n) - log ↑n
state_after: case inr
n : ℕ
hn : n > 0
⊢ log (↑(n + 1) / ↑n)⁻¹ < -↑(↑(n + 1))⁻¹
tactic: rw [← sub_pos, sub_sub_sub_comm,
    harmonic_succ, Rat.cast_add, ← sub_sub, sub_self, zero_sub, sub_eq_add_neg, neg_sub,
    ← sub_eq_neg_add, sub_pos, ← log_div (by positivity) (by positivity), ← neg_lt_neg_iff,
    ← log_inv]
state_before: case inr
n : ℕ
hn : n > 0
⊢ log (↑(n + 1) / ↑n)⁻¹ < -↑(↑(n + 1))⁻¹
state_after: case inr.refine_1
n : ℕ
hn : n > 0
⊢ 0 < (↑(n + 1) / ↑n)⁻¹

case inr.refine_2
n : ℕ
hn : n > 0
⊢ (↑(n + 1) / ↑n)⁻¹ ≠ 1

case inr.refine_3
n : ℕ
hn : n > 0
⊢ (↑(n + 1) / ↑n)⁻¹ - 1 = -↑(↑(n + 1))⁻¹
tactic: refine (log_lt_sub_one_of_pos ?_ ?_).trans_le (le_of_eq ?_)
Theorem: Real.sInf_empty
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: ⊢ sInf ∅ = 0
state_after: no goals
tactic: simp [sInf_def, sSup_empty]
Theorem: CategoryTheory.Localization.SmallHom.equiv_mk
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
D' : Type u₃
inst✝² : Category.{v₃, u₃} D'
L : C ⥤ D
inst✝¹ : L.IsLocalization W
X Y : C
inst✝ : HasSmallLocalizedHom W X Y
f : X ⟶ Y
⊢ (equiv W L) (mk W f) = L.map f
state_after: no goals
tactic: simp [equiv, mk]
Theorem: Nat.multinomial_univ_two
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
s : Finset α
f : α → ℕ
a✝ b✝ : α
n a b : ℕ
⊢ multinomial univ ![a, b] = (a + b)! / (a ! * b !)
state_after: no goals
tactic: rw [multinomial, Fin.sum_univ_two, Fin.prod_univ_two, Matrix.cons_val_zero, Matrix.cons_val_one,
    Matrix.head_cons]
Theorem: Function.Semiconj₂.isAssociative_left
File: Mathlib/Logic/Function/Conjugate.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
ga : α → α → α
gb : β → β → β
inst✝ : Std.Associative gb
h : Semiconj₂ f ga gb
h_inj : Injective f
x₁ x₂ x₃ : α
⊢ f (ga (ga x₁ x₂) x₃) = f (ga x₁ (ga x₂ x₃))
state_after: no goals
tactic: simp only [h.eq, Std.Associative.assoc (op := gb)]
Theorem: HasCompactSupport.continuous_extend_zero
File: Mathlib/Topology/Support.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt (extend Subtype.val f 1) x
state_after: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt f ⟨x, ⋯⟩
tactic: rw [show x = ↑(⟨x, Subtype.coe_image_subset _ _
      (supp.mulTSupport_extend_one_subset continuous_subtype_val h)⟩ : U) by rfl,
      ← (hU.openEmbedding_subtype_val).continuousAt_iff, extend_comp Subtype.val_injective]
state_before: X : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
M : Type u_7
E : Type u_8
R : Type u_9
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace α'
inst✝⁴ : One β
inst✝³ : One γ
inst✝² : One δ
g✝ : β → γ
f✝ : α → β
f₂ : α → γ
m : β → γ → δ
x✝ : α
inst✝¹ : T2Space α'
hf : HasCompactMulSupport f✝
g : α → α'
cont✝ : Continuous g
inst✝ : TopologicalSpace β
U : Set α'
hU : IsOpen U
f : ↑U → β
cont : Continuous f
supp : HasCompactMulSupport f
x : α'
h : x ∈ mulTSupport (extend Subtype.val f 1)
⊢ ContinuousAt f ⟨x, ⋯⟩
state_after: no goals
tactic: exact cont.continuousAt
Theorem: Submodule.colon_top
File: Mathlib/RingTheory/Ideal/Colon.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N N₁ N₂ P P₁ P₂ : Submodule R M
I : Ideal R
⊢ colon I ⊤ = I
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N N₁ N₂ P P₁ P₂ : Submodule R M
I : Ideal R
⊢ ∀ (x : R), (∀ p ∈ ⊤, x * p ∈ I) ↔ x ∈ I
tactic: simp_rw [SetLike.ext_iff, mem_colon, smul_eq_mul]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
F : Type u_4
G : Type u_5
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
N N₁ N₂ P P₁ P₂ : Submodule R M
I : Ideal R
⊢ ∀ (x : R), (∀ p ∈ ⊤, x * p ∈ I) ↔ x ∈ I
state_after: no goals
tactic: exact fun x ↦ ⟨fun h ↦ mul_one x ▸ h 1 trivial, fun h _ _ ↦ I.mul_mem_right _ h⟩