ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsGLB.mul_left
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha : 0 ≤ a
hs : IsGLB s b
⊢ IsGLB ((fun b => a * b) '' s) (a * b)
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
s : Set α
ha✝ : 0 ≤ a
hs : IsGLB s b
ha : 0 < a
⊢ IsGLB ((fun b => a * b) '' s) (a * b)

case inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
b c d e : α
m n : ℤ
s : Set α
hs : IsGLB s b
ha : 0 ≤ 0
⊢ IsGLB ((fun b => 0 * b) '' s) (0 * b)
tactic: rcases lt_or_eq_of_le ha with (ha | rfl)
Theorem: inner_map_complex
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁶ : _root_.RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
G : Type u_4
inst✝¹ : NormedAddCommGroup G
inst✝ : InnerProductSpace ℝ G
f : G ≃ₗᵢ[ℝ] ℂ
x y : G
⊢ ⟪x, y⟫_ℝ = ((starRingEnd ℂ) (f x) * f y).re
state_after: no goals
tactic: rw [← Complex.inner, f.inner_map_map]
Theorem: EReal.div_mul_cancel
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a / b * b = a
state_after: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * b⁻¹ * b = a
tactic: change (a * b⁻¹) * b = a
state_before: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * b⁻¹ * b = a
state_after: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * (b * b⁻¹) = a
tactic: rw [mul_assoc, mul_comm b⁻¹ b]
state_before: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * (b * b⁻¹) = a
state_after: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * (b / b) = a
tactic: change a * (b / b) = a
state_before: a b : EReal
h₁ : b ≠ ⊥
h₂ : b ≠ ⊤
h₃ : b ≠ 0
⊢ a * (b / b) = a
state_after: no goals
tactic: rw [div_self h₁ h₂ h₃, mul_one]
Theorem: HasDerivAt.pow
File: Mathlib/Analysis/Calculus/Deriv/Pow.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
hc : HasDerivAt c c' x
⊢ HasDerivAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') x
state_after: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
hc : HasDerivWithinAt c c' univ x
⊢ HasDerivWithinAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') univ x
tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
c : 𝕜 → 𝕜
c' : 𝕜
n : ℕ
hc : HasDerivWithinAt c c' univ x
⊢ HasDerivWithinAt (fun y => c y ^ n) (↑n * c x ^ (n - 1) * c') univ x
state_after: no goals
tactic: exact hc.pow n
Theorem: List.modifyLast_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
f : α → α
l₁ l₂ : List α
x✝ : l₂ ≠ []
⊢ modifyLast f (l₁ ++ l₂) = l₁ ++ modifyLast f l₂
state_after: no goals
tactic: cases l₂ with
  | nil => contradiction
  | cons hd tl =>
    cases tl with
    | nil => exact modifyLast_append_one _ hd _
    | cons hd' tl' =>
      rw [append_cons, ← nil_append (hd :: hd' :: tl'), append_cons [], nil_append,
        modifyLast_append _ (l₁ ++ [hd]) (hd' :: tl') _, modifyLast_append _ [hd] (hd' :: tl') _,
        append_assoc]
      all_goals { exact cons_ne_nil _ _ }
Theorem: UpperSet.Ici_inf_erase
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : UpperSet α
t : Set α
a : α
ha : a ∈ s
has : ∀ b ∈ s, b ≤ a → b = a
⊢ Ici a ⊓ s.erase a = s
state_after: no goals
tactic: rw [inf_comm, erase_inf_Ici ha has]
Theorem: Fin.succAbove_last_apply
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
p : Fin (n + 1)
i✝ j i : Fin n
⊢ (last n).succAbove i = i.castSucc
state_after: no goals
tactic: rw [succAbove_last]
Theorem: EuclideanGeometry.concyclic_or_collinear_of_two_zsmul_oangle_eq
File: Mathlib/Geometry/Euclidean/Angle/Sphere.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ : P
h : 2 • ∡ p₁ p₂ p₄ = 2 • ∡ p₁ p₃ p₄
⊢ Concyclic {p₁, p₂, p₃, p₄} ∨ Collinear ℝ {p₁, p₂, p₃, p₄}
state_after: case inl
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ : P
h : 2 • ∡ p₁ p₂ p₄ = 2 • ∡ p₁ p₃ p₄
hc : Cospherical {p₁, p₂, p₃, p₄}
⊢ Concyclic {p₁, p₂, p₃, p₄} ∨ Collinear ℝ {p₁, p₂, p₃, p₄}

case inr
V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ : P
h : 2 • ∡ p₁ p₂ p₄ = 2 • ∡ p₁ p₃ p₄
hc : Collinear ℝ {p₁, p₂, p₃, p₄}
⊢ Concyclic {p₁, p₂, p₃, p₄} ∨ Collinear ℝ {p₁, p₂, p₃, p₄}
tactic: rcases cospherical_or_collinear_of_two_zsmul_oangle_eq h with (hc | hc)
Theorem: Mathlib.Tactic.Monoidal.evalWhiskerRight_nil
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
f f' g g' h✝ i j : C
α : f ⟶ g
h : C
⊢ α ▷ h = α ▷ h
state_after: no goals
tactic: simp
Theorem: List.lookupAll_sublist
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ map (Sigma.mk a) (lookupAll a []) <+ []
state_after: no goals
tactic: simp
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
⊢ map (Sigma.mk a) (lookupAll a (⟨a', b'⟩ :: l)) <+ ⟨a', b'⟩ :: l
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : a = a'
⊢ map (Sigma.mk a) (lookupAll a (⟨a', b'⟩ :: l)) <+ ⟨a', b'⟩ :: l

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ map (Sigma.mk a) (lookupAll a (⟨a', b'⟩ :: l)) <+ ⟨a', b'⟩ :: l
tactic: by_cases h : a = a'
Theorem: Nat.ModEq.mul_left'
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c✝ d c : ℕ
h : a ≡ b [MOD n]
⊢ c * a ≡ c * b [MOD c * n]
state_after: m n a b c✝ d c : ℕ
h : a % n = b % n
⊢ c * a % (c * n) = c * b % (c * n)
tactic: unfold ModEq at *
state_before: m n a b c✝ d c : ℕ
h : a % n = b % n
⊢ c * a % (c * n) = c * b % (c * n)
state_after: no goals
tactic: rw [mul_mod_mul_left, mul_mod_mul_left, h]
Theorem: SimpleGraph.Walk.map_isTrail_iff_of_injective
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''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
hinj : Injective ⇑f
⊢ (Walk.map f p).IsTrail ↔ p.IsTrail
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons _ _ ih =>
    rw [map_cons, cons_isTrail_iff, ih, cons_isTrail_iff]
    apply and_congr_right'
    rw [← Sym2.map_pair_eq, edges_map, ← List.mem_map_of_injective (Sym2.map.injective hinj)]
Theorem: Nat.Coprime.gcd_mul_right_cancel
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: k n m : Nat
H : k.Coprime n
⊢ (m * k).gcd n = m.gcd n
state_after: no goals
tactic: rw [Nat.mul_comm m k, H.gcd_mul_left_cancel m]
Theorem: Cardinal.aleph0_le_lift
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u}
⊢ ℵ₀ ≤ lift.{v, u} c ↔ ℵ₀ ≤ c
state_after: no goals
tactic: rw [← lift_aleph0.{v, u}, lift_le]
Theorem: WithBot.coe_mul_eq_bind
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithBot α
a : α
ha : a ≠ 0
⊢ ↑a * ⊥ = Option.bind ⊥ fun b => Option.some (a * b)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithBot α
a : α
ha : a ≠ 0
⊢ ⊥ = Option.bind ⊥ fun b => Option.some (a * b)
tactic: simp only [ne_eq, coe_eq_zero, ha, not_false_eq_true, mul_bot]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b : WithBot α
a : α
ha : a ≠ 0
⊢ ⊥ = Option.bind ⊥ fun b => Option.some (a * b)
state_after: no goals
tactic: rfl
Theorem: Finpartition.mk_mem_nonUniforms
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε δ : 𝕜
u v : Finset α
⊢ (u, v) ∈ P.nonUniforms G ε ↔ u ∈ P.parts ∧ v ∈ P.parts ∧ u ≠ v ∧ ¬G.IsUniform ε u v
state_after: no goals
tactic: rw [nonUniforms, mem_filter, mem_offDiag, and_assoc, and_assoc]
Theorem: mem_ball_iff_norm'''
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₂ : ℝ
⊢ b ∈ ball a r ↔ ‖a / b‖ < r
state_after: no goals
tactic: rw [mem_ball', dist_eq_norm_div]
Theorem: WithBot.preimage_coe_Ico
File: Mathlib/Order/Interval/Set/WithBotTop.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
a b : α
⊢ some ⁻¹' Ico ↑a ↑b = Ico a b
state_after: no goals
tactic: simp [← Ici_inter_Iio]
Theorem: MeasureTheory.measure_mul_right_null
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
y : G
⊢ μ ((fun x => x * y) ⁻¹' s) = 0 ↔ μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0
state_after: no goals
tactic: simp_rw [← inv_preimage, preimage_preimage, mul_inv_rev, inv_inv]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
y : G
⊢ μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0 ↔ μ s = 0
state_after: no goals
tactic: simp only [measure_inv_null μ, measure_preimage_mul]
Theorem: map_symmDiff
File: Mathlib/Order/Heyting/Hom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : FunLike F α β
inst✝² : CoheytingAlgebra α
inst✝¹ : CoheytingAlgebra β
inst✝ : CoheytingHomClass F α β
f : F
a b : α
⊢ f (a ∆ b) = f a ∆ f b
state_after: no goals
tactic: simp_rw [symmDiff, map_sup, map_sdiff]
Theorem: ChainComplex.chainComplex_d_succ_succ_zero
File: Mathlib/Algebra/Homology/Augment.lean

Proof steps:
state_before: V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i : ℕ
⊢ C.d (i + 2) 0 = 0
state_after: case a
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i : ℕ
⊢ ¬(ComplexShape.down ℕ).Rel (i + 2) 0
tactic: rw [C.shape]
state_before: case a
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
C : ChainComplex V ℕ
i : ℕ
⊢ ¬(ComplexShape.down ℕ).Rel (i + 2) 0
state_after: no goals
tactic: exact i.succ_succ_ne_one.symm
Theorem: map_nonneg
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ 0 ≤ f a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ f 0 ≤ f a
tactic: rw [← map_zero f]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁶ : FunLike F α β
inst✝⁵ : Preorder α
inst✝⁴ : Zero α
inst✝³ : Preorder β
inst✝² : Zero β
inst✝¹ : OrderHomClass F α β
inst✝ : ZeroHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ f 0 ≤ f a
state_after: no goals
tactic: exact OrderHomClass.mono _ ha
Theorem: EReal.nhds_top
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
⊢ ⨅ l, ⨅ (_ : l < ⊤), 𝓟 (Ioi l) = ⨅ a, ⨅ (_ : a ≠ ⊤), 𝓟 (Ioi a)
state_after: no goals
tactic: simp only [lt_top_iff_ne_top]
Theorem: FirstOrder.Language.BoundedFormula.realize_castLE_of_eq
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✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
m n : ℕ
h : m = n
h' : m ≤ n
φ : L.BoundedFormula α m
v : α → M
xs : Fin n → M
⊢ (castLE h' φ).Realize v xs ↔ φ.Realize v (xs ∘ Fin.cast h)
state_after: 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 l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
m : ℕ
φ : L.BoundedFormula α m
v : α → M
h' : m ≤ m
xs : Fin m → M
⊢ (castLE h' φ).Realize v xs ↔ φ.Realize v (xs ∘ Fin.cast ⋯)
tactic: subst h
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 l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
m : ℕ
φ : L.BoundedFormula α m
v : α → M
h' : m ≤ m
xs : Fin m → M
⊢ (castLE h' φ).Realize v xs ↔ φ.Realize v (xs ∘ Fin.cast ⋯)
state_after: no goals
tactic: simp only [castLE_rfl, cast_refl, OrderIso.coe_refl, Function.comp_id]
Theorem: SetTheory.PGame.numeric_def
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: x : PGame
⊢ x.Numeric ↔
    (∀ (i : x.LeftMoves) (j : x.RightMoves), x.moveLeft i < x.moveRight j) ∧
      (∀ (i : x.LeftMoves), (x.moveLeft i).Numeric) ∧ ∀ (j : x.RightMoves), (x.moveRight j).Numeric
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝).Numeric ↔
    (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves) (j : (mk α✝ β✝ a✝¹ a✝).RightMoves),
        (mk α✝ β✝ a✝¹ a✝).moveLeft i < (mk α✝ β✝ a✝¹ a✝).moveRight j) ∧
      (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves), ((mk α✝ β✝ a✝¹ a✝).moveLeft i).Numeric) ∧
        ∀ (j : (mk α✝ β✝ a✝¹ a✝).RightMoves), ((mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric
tactic: cases x
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝).Numeric ↔
    (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves) (j : (mk α✝ β✝ a✝¹ a✝).RightMoves),
        (mk α✝ β✝ a✝¹ a✝).moveLeft i < (mk α✝ β✝ a✝¹ a✝).moveRight j) ∧
      (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves), ((mk α✝ β✝ a✝¹ a✝).moveLeft i).Numeric) ∧
        ∀ (j : (mk α✝ β✝ a✝¹ a✝).RightMoves), ((mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric
state_after: no goals
tactic: rfl
Theorem: OrderEmbedding.image_Ici
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
p : α → Prop
a✝ : α
e : α ↪o β
he : IsUpperSet (range ⇑e)
a : α
⊢ ⇑e '' Ici a = Ici (e a)
state_after: no goals
tactic: rw [← e.preimage_Ici, image_preimage_eq_inter_range,
    inter_eq_left.2 <| he.Ici_subset (mem_range_self _)]
Theorem: Mathlib.Meta.NormNum.minFacHelper_3
File: Mathlib/Tactic/NormNum/Prime.lean

Proof steps:
state_before: n k k' : ℕ
e : k + 2 = k'
nk : (n % k).beq 0 = false
h : MinFacHelper n k
⊢ MinFacHelper n k'
state_after: n k k' : ℕ
e : k + 2 = k'
nk : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
⊢ False
tactic: refine minFacHelper_1 e h λ h2 ↦ ?_
state_before: n k k' : ℕ
e : k + 2 = k'
nk : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
⊢ False
state_after: n k k' : ℕ
e : k + 2 = k'
nk✝ : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
nk : ¬n % k = 0
⊢ False
tactic: have nk := Nat.ne_of_beq_eq_false nk
state_before: n k k' : ℕ
e : k + 2 = k'
nk✝ : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
nk : ¬n % k = 0
⊢ False
state_after: n k k' : ℕ
e : k + 2 = k'
nk✝ : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
nk : ¬n.minFac ∣ n
⊢ False
tactic: rw [← Nat.dvd_iff_mod_eq_zero, ← h2] at nk
state_before: n k k' : ℕ
e : k + 2 = k'
nk✝ : (n % k).beq 0 = false
h : MinFacHelper n k
h2 : n.minFac = k
nk : ¬n.minFac ∣ n
⊢ False
state_after: no goals
tactic: exact nk <| minFac_dvd n
Theorem: meas_lt_essInf
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : ConditionallyCompleteLinearOrder β
x : β
f : α → β
inst✝² : TopologicalSpace β
inst✝¹ : FirstCountableTopology β
inst✝ : OrderTopology β
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) (ae μ) f) _auto✝
⊢ μ {y | f y < essInf f μ} = 0
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : ConditionallyCompleteLinearOrder β
x : β
f : α → β
inst✝² : TopologicalSpace β
inst✝¹ : FirstCountableTopology β
inst✝ : OrderTopology β
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) (ae μ) f) _auto✝
⊢ μ {y | ¬essInf f μ ≤ f y} = 0
tactic: simp_rw [← not_le]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : ConditionallyCompleteLinearOrder β
x : β
f : α → β
inst✝² : TopologicalSpace β
inst✝¹ : FirstCountableTopology β
inst✝ : OrderTopology β
hf : autoParam (IsBoundedUnder (fun x x_1 => x ≥ x_1) (ae μ) f) _auto✝
⊢ μ {y | ¬essInf f μ ≤ f y} = 0
state_after: no goals
tactic: exact ae_essInf_le hf
Theorem: AddCancelMonoid.toAddLeftCancelMonoid_injective
File: Mathlib/Algebra/Group/Ext.lean

Proof steps:
state_before: M : Type u
⊢ Injective (@toLeftCancelMonoid M)
state_after: case mk.mk
M : Type u
toLeftCancelMonoid✝¹ : LeftCancelMonoid M
mul_right_cancel✝¹ : ∀ (a b c : M), a * b = c * b → a = c
toLeftCancelMonoid✝ : LeftCancelMonoid M
mul_right_cancel✝ : ∀ (a b c : M), a * b = c * b → a = c
h : toLeftCancelMonoid = toLeftCancelMonoid
⊢ mk mul_right_cancel✝¹ = mk mul_right_cancel✝
tactic: rintro ⟨⟩ ⟨⟩ h
state_before: case mk.mk
M : Type u
toLeftCancelMonoid✝¹ : LeftCancelMonoid M
mul_right_cancel✝¹ : ∀ (a b c : M), a * b = c * b → a = c
toLeftCancelMonoid✝ : LeftCancelMonoid M
mul_right_cancel✝ : ∀ (a b c : M), a * b = c * b → a = c
h : toLeftCancelMonoid = toLeftCancelMonoid
⊢ mk mul_right_cancel✝¹ = mk mul_right_cancel✝
state_after: no goals
tactic: congr
Theorem: ConvexOn.monotoneOn_derivWithin
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
⊢ MonotoneOn (derivWithin f S) S
state_after: S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x ≤ y
⊢ derivWithin f S x ≤ derivWithin f S y
tactic: intro x hx y hy hxy
state_before: S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x ≤ y
⊢ derivWithin f S x ≤ derivWithin f S y
state_after: case inl
S : Set ℝ
f : ℝ → ℝ
x✝ y f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx hy : x ∈ S
hxy : x ≤ x
⊢ derivWithin f S x ≤ derivWithin f S x

case inr
S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x ≤ y
hxy' : x < y
⊢ derivWithin f S x ≤ derivWithin f S y
tactic: rcases eq_or_lt_of_le hxy with rfl | hxy'
state_before: case inr
S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : ConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x ≤ y
hxy' : x < y
⊢ derivWithin f S x ≤ derivWithin f S y
state_after: no goals
tactic: exact (hfc.derivWithin_le_slope hx hy hxy' (hfd x hx)).trans
    (hfc.slope_le_derivWithin hx hy hxy' (hfd y hy))
Theorem: symmDiff_of_ge
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a ∆ b = a \ b
state_after: no goals
tactic: rw [symmDiff, sdiff_eq_bot_iff.2 h, sup_bot_eq]
Theorem: CategoryTheory.ShortComplex.LeftHomologyMapData.homologyMap_comm
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ homologyMap φ ≫ h₂.homologyIso.hom = h₁.homologyIso.hom ≫ γ.φH
state_after: no goals
tactic: simp only [γ.homologyMap_eq, assoc, Iso.inv_hom_id, comp_id]
Theorem: Nat.image_fst_divisorsAntidiagonal
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
⊢ image Prod.fst n.divisorsAntidiagonal = n.divisors
state_after: case a
n a✝ : ℕ
⊢ a✝ ∈ image Prod.fst n.divisorsAntidiagonal ↔ a✝ ∈ n.divisors
tactic: ext
state_before: case a
n a✝ : ℕ
⊢ a✝ ∈ image Prod.fst n.divisorsAntidiagonal ↔ a✝ ∈ n.divisors
state_after: no goals
tactic: simp [Dvd.dvd, @eq_comm _ n (_ * _)]
Theorem: Real.exists_convs_eq_rat
File: Mathlib/NumberTheory/DiophantineApproximation.lean

Proof steps:
state_before: ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h✝ : ContfracLegendre.Ass ξ u v
q : ℚ
h : |ξ - ↑q| < 1 / (2 * ↑q.den ^ 2)
⊢ ∃ n, (GenContFract.of ξ).convs n = ↑q
state_after: case intro
ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h✝ : ContfracLegendre.Ass ξ u v
q : ℚ
h : |ξ - ↑q| < 1 / (2 * ↑q.den ^ 2)
n : ℕ
hn : q = ξ.convergent n
⊢ ∃ n, (GenContFract.of ξ).convs n = ↑q
tactic: obtain ⟨n, hn⟩ := exists_rat_eq_convergent h
state_before: case intro
ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h✝ : ContfracLegendre.Ass ξ u v
q : ℚ
h : |ξ - ↑q| < 1 / (2 * ↑q.den ^ 2)
n : ℕ
hn : q = ξ.convergent n
⊢ ∃ n, (GenContFract.of ξ).convs n = ↑q
state_after: no goals
tactic: exact ⟨n, hn.symm ▸ convs_eq_convergent ξ n⟩