ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Convex_subadditive_le
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝² : LinearOrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
f : E → 𝕜
hf1 : ∀ (x y : E), f (x + y) ≤ f x + f y
hf2 : ∀ ⦃c : 𝕜⦄ (x : E), 0 ≤ c → f (c • x) ≤ c * f x
B : 𝕜
⊢ Convex 𝕜 {x | f x ≤ B}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝² : LinearOrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
f : E → 𝕜
hf1 : ∀ (x y : E), f (x + y) ≤ f x + f y
hf2 : ∀ ⦃c : 𝕜⦄ (x : E), 0 ≤ c → f (c • x) ≤ c * f x
B : 𝕜
⊢ ∀ ⦃x : E⦄, x ∈ {x | f x ≤ B} → ∀ ⦃y : E⦄, y ∈ {x | f x ≤ B} → [x-[𝕜]y] ⊆ {x | f x ≤ B}
tactic: rw [convex_iff_segment_subset]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝² : LinearOrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
f : E → 𝕜
hf1 : ∀ (x y : E), f (x + y) ≤ f x + f y
hf2 : ∀ ⦃c : 𝕜⦄ (x : E), 0 ≤ c → f (c • x) ≤ c * f x
B : 𝕜
⊢ ∀ ⦃x : E⦄, x ∈ {x | f x ≤ B} → ∀ ⦃y : E⦄, y ∈ {x | f x ≤ B} → [x-[𝕜]y] ⊆ {x | f x ≤ B}
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝² : LinearOrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
f : E → 𝕜
hf1 : ∀ (x y : E), f (x + y) ≤ f x + f y
hf2 : ∀ ⦃c : 𝕜⦄ (x : E), 0 ≤ c → f (c • x) ≤ c * f x
B : 𝕜
x : E
hx : x ∈ {x | f x ≤ B}
y : E
hy : y ∈ {x | f x ≤ B}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hs : a + b = 1
⊢ a • x + b • y ∈ {x | f x ≤ B}
tactic: rintro x hx y hy z ⟨a, b, ha, hb, hs, rfl⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
inst✝² : LinearOrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
f : E → 𝕜
hf1 : ∀ (x y : E), f (x + y) ≤ f x + f y
hf2 : ∀ ⦃c : 𝕜⦄ (x : E), 0 ≤ c → f (c • x) ≤ c * f x
B : 𝕜
x : E
hx : x ∈ {x | f x ≤ B}
y : E
hy : y ∈ {x | f x ≤ B}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hs : a + b = 1
⊢ a • x + b • y ∈ {x | f x ≤ B}
state_after: no goals
tactic: calc
    _ ≤ a • (f x) + b • (f y) := le_trans (hf1 _ _) (add_le_add (hf2 x ha) (hf2 y hb))
    _ ≤ a • B + b • B :=
        add_le_add (smul_le_smul_of_nonneg_left hx ha) (smul_le_smul_of_nonneg_left hy hb)
    _ ≤ B := by rw [← add_smul, hs, one_smul]
Theorem: Doset.mk_eq_of_doset_eq
File: Mathlib/GroupTheory/DoubleCoset.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : doset a ↑H ↑K = doset b ↑H ↑K
⊢ mk H K a = mk H K b
state_after: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : doset a ↑H ↑K = doset b ↑H ↑K
⊢ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k
tactic: rw [eq]
state_before: G : Type u_1
inst✝¹ : Group G
α : Type u_2
inst✝ : Mul α
J : Subgroup G
g : G
H K : Subgroup G
a b : G
h : doset a ↑H ↑K = doset b ↑H ↑K
⊢ ∃ h ∈ H, ∃ k ∈ K, b = h * a * k
state_after: no goals
tactic: exact mem_doset.mp (h.symm ▸ mem_doset_self H K b)
Theorem: neg_le_self_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrderedCommGroup α
a b c : α
⊢ a⁻¹ ≤ a ↔ 1 ≤ a
state_after: no goals
tactic: simp [inv_le_iff_one_le_mul']
Theorem: Set.compl_cIcc
File: Mathlib/Order/Circular.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CircularOrder α
a b : α
⊢ (cIcc a b)ᶜ = cIoo b a
state_after: case h
α : Type u_1
inst✝ : CircularOrder α
a b x✝ : α
⊢ x✝ ∈ (cIcc a b)ᶜ ↔ x✝ ∈ cIoo b a
tactic: ext
state_before: case h
α : Type u_1
inst✝ : CircularOrder α
a b x✝ : α
⊢ x✝ ∈ (cIcc a b)ᶜ ↔ x✝ ∈ cIoo b a
state_after: no goals
tactic: rw [Set.mem_cIoo, sbtw_iff_not_btw, cIcc, mem_compl_iff, mem_setOf]
Theorem: NNReal.lipschitzWith_sub
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 fun p => p.1 - p.2
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
tactic: rw [← isometry_subtype_coe.lipschitzWith_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
tactic: have : Isometry (Prod.map ((↑) : ℝ≥0 → ℝ) ((↑) : ℝ≥0 → ℝ)) :=
    isometry_subtype_coe.prod_map isometry_subtype_coe
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ LipschitzWith 2 (Subtype.val ∘ fun p => p.1 - p.2)
state_after: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ 2 = 1 * 1 + 1 * 1
tactic: convert (((LipschitzWith.prod_fst.comp this.lipschitz).sub
    (LipschitzWith.prod_snd.comp this.lipschitz)).max_const 0)
state_before: case h.e'_5
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
this : Isometry (Prod.map toReal toReal)
⊢ 2 = 1 * 1 + 1 * 1
state_after: no goals
tactic: norm_num
Theorem: IntermediateField.exists_finset_of_mem_supr'
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, F⟮↑i.snd⟯
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
i : ι
⊢ f i ≤ ⨆ i, F⟮↑i.snd⟯
tactic: refine exists_finset_of_mem_iSup (SetLike.le_def.mp (iSup_le fun i ↦ ?_) hx)
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
i : ι
⊢ f i ≤ ⨆ i, F⟮↑i.snd⟯
state_after: no goals
tactic: exact fun x h ↦ SetLike.le_def.mp (le_iSup_of_le ⟨i, x, h⟩ (by simp)) (mem_adjoin_simple_self F x)
Theorem: ZMod.cast_zero
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: n : ℕ
R : Type u_1
inst✝ : AddGroupWithOne R
⊢ cast 0 = 0
state_after: n : ℕ
R : Type u_1
inst✝ : AddGroupWithOne R
⊢ (match (motive := (x : ℕ) → ZMod x → R) n with
      | 0 => Int.cast
      | n.succ => fun i => ↑i.val)
      0 =
    0
tactic: delta ZMod.cast
state_before: n : ℕ
R : Type u_1
inst✝ : AddGroupWithOne R
⊢ (match (motive := (x : ℕ) → ZMod x → R) n with
      | 0 => Int.cast
      | n.succ => fun i => ↑i.val)
      0 =
    0
state_after: case zero
R : Type u_1
inst✝ : AddGroupWithOne R
⊢ (match (motive := (x : ℕ) → ZMod x → R) 0 with
      | 0 => Int.cast
      | n.succ => fun i => ↑i.val)
      0 =
    0

case succ
R : Type u_1
inst✝ : AddGroupWithOne R
n✝ : ℕ
⊢ (match (motive := (x : ℕ) → ZMod x → R) n✝ + 1 with
      | 0 => Int.cast
      | n.succ => fun i => ↑i.val)
      0 =
    0
tactic: cases n
Theorem: Submonoid.nontrivial_iff_exists_ne_one
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S✝ : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
S : Submonoid M
⊢ (∃ x, ∃ (hx : x ∈ S), ⟨x, hx⟩ ≠ ⟨1, ⋯⟩) ↔ ∃ x ∈ S, x ≠ 1
state_after: no goals
tactic: simp [Ne]
Theorem: Finset.shadow_compls
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ ∂ 𝒜ᶜˢ = (∂⁺ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂ 𝒜ᶜˢ ↔ s ∈ (∂⁺ 𝒜)ᶜˢ
tactic: ext s
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂ 𝒜ᶜˢ ↔ s ∈ (∂⁺ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
tactic: simp only [mem_image, exists_prop, mem_shadow_iff, mem_upShadow_iff, mem_compls]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∈ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b).erase a = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
tactic: refine (compl_involutive.toPerm _).exists_congr_left.trans ?_
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∈ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b).erase a = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
state_after: no goals
tactic: simp [← compl_involutive.eq_iff]
Theorem: Multiset.cons_inj_right
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a : α
⊢ ∀ {s t : Multiset α}, a ::ₘ s = a ::ₘ t ↔ s = t
state_after: case mk.mk
α : Type u_1
β : Type v
γ : Type u_2
a : α
s✝ : Multiset α
l₁ : List α
t✝ : Multiset α
l₂ : List α
⊢ a ::ₘ Quot.mk Setoid.r l₁ = a ::ₘ Quot.mk Setoid.r l₂ ↔ Quot.mk Setoid.r l₁ = Quot.mk Setoid.r l₂
tactic: rintro ⟨l₁⟩ ⟨l₂⟩
state_before: case mk.mk
α : Type u_1
β : Type v
γ : Type u_2
a : α
s✝ : Multiset α
l₁ : List α
t✝ : Multiset α
l₂ : List α
⊢ a ::ₘ Quot.mk Setoid.r l₁ = a ::ₘ Quot.mk Setoid.r l₂ ↔ Quot.mk Setoid.r l₁ = Quot.mk Setoid.r l₂
state_after: no goals
tactic: simp
Theorem: Bornology.isVonNBounded_insert
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι : Type u_6
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : TopologicalSpace E
inst✝ : ContinuousSMul 𝕜 E
x : E
s : Set E
⊢ IsVonNBounded 𝕜 (insert x s) ↔ IsVonNBounded 𝕜 s
state_after: no goals
tactic: simp only [← singleton_union, isVonNBounded_union, isVonNBounded_singleton, true_and]
Theorem: Real.diam_eq
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
s : Set ℝ
h : Bornology.IsBounded s
⊢ Metric.diam s = sSup s - sInf s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
s : Set ℝ
h : Bornology.IsBounded s
⊢ 0 ≤ sSup s - sInf s
tactic: rw [Metric.diam, Real.ediam_eq h, ENNReal.toReal_ofReal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
s : Set ℝ
h : Bornology.IsBounded s
⊢ 0 ≤ sSup s - sInf s
state_after: no goals
tactic: exact sub_nonneg.2 (Real.sInf_le_sSup s h.bddBelow h.bddAbove)
Theorem: ZMod.natCast_eq_natCast_iff
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n a b c : ℕ
⊢ ↑a = ↑b ↔ a ≡ b [MOD c]
state_after: no goals
tactic: simpa [Int.natCast_modEq_iff] using ZMod.intCast_eq_intCast_iff a b c
Theorem: PartialHomeomorph.map_nhdsWithin_preimage_eq
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
x : X
hx : x ∈ e.source
s : Set Y
⊢ map (↑e) (𝓝[↑e ⁻¹' s] x) = 𝓝[s] ↑e x
state_after: no goals
tactic: rw [e.map_nhdsWithin_eq hx, e.image_source_inter_eq', e.target_inter_inv_preimage_preimage,
    e.nhdsWithin_target_inter (e.map_source hx)]
Theorem: Balanced.neg_mem_iff
File: Mathlib/Analysis/LocallyConvex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝³ : SeminormedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
inst✝ : NormOneClass 𝕜
h : Balanced 𝕜 s
x : E
hx : -x ∈ s
⊢ x ∈ s
state_after: no goals
tactic: simpa using h.smul_mem (a := -1) (by simp) hx
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝³ : SeminormedRing 𝕜
inst✝² : AddCommGroup E
inst✝¹ : Module 𝕜 E
s s₁ s₂ t t₁ t₂ : Set E
inst✝ : NormOneClass 𝕜
h : Balanced 𝕜 s
x : E
hx : x ∈ s
⊢ -x ∈ s
state_after: no goals
tactic: simpa using h.smul_mem (a := -1) (by simp) hx
Theorem: Mathlib.Tactic.Abel.term_add_termg
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
n₁ : ℤ
x a₁ : α
n₂ : ℤ
a₂ : α
n' : ℤ
a' : α
h₁ : n₁ + n₂ = n'
h₂ : a₁ + a₂ = a'
⊢ termg n₁ x a₁ + termg n₂ x a₂ = termg n' x a'
state_after: α : Type u_1
inst✝ : AddCommGroup α
n₁ : ℤ
x a₁ : α
n₂ : ℤ
a₂ : α
n' : ℤ
a' : α
h₁ : n₁ + n₂ = n'
h₂ : a₁ + a₂ = a'
⊢ n₁ • x + a₁ + (n₂ • x + a₂) = n₁ • x + n₂ • x + (a₁ + a₂)
tactic: simp only [termg, h₁.symm, add_zsmul, h₂.symm]
state_before: α : Type u_1
inst✝ : AddCommGroup α
n₁ : ℤ
x a₁ : α
n₂ : ℤ
a₂ : α
n' : ℤ
a' : α
h₁ : n₁ + n₂ = n'
h₂ : a₁ + a₂ = a'
⊢ n₁ • x + a₁ + (n₂ • x + a₂) = n₁ • x + n₂ • x + (a₁ + a₂)
state_after: no goals
tactic: exact add_add_add_comm (n₁ • x) a₁ (n₂ • x) a₂
Theorem: Finset.Colex.forall_le_mono
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
hst : { ofColex := s } ≤ { ofColex := t }
ht : ∀ b ∈ t, b ≤ a
⊢ ∀ b ∈ s, b ≤ a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ : α
hst : { ofColex := s } ≤ { ofColex := t }
ht : ∀ b ∈ t, b ≤ a
b : α
hb : b ∈ s
⊢ b ≤ a
tactic: rintro b hb
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ : α
hst : { ofColex := s } ≤ { ofColex := t }
ht : ∀ b ∈ t, b ≤ a
b : α
hb : b ∈ s
⊢ b ≤ a
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ : α
hst : { ofColex := s } ≤ { ofColex := t }
ht : ∀ b ∈ t, b ≤ a
b : α
hb : b ∈ s
h✝ : b ∈ t
⊢ b ≤ a

case neg
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b✝ : α
hst : { ofColex := s } ≤ { ofColex := t }
ht : ∀ b ∈ t, b ≤ a
b : α
hb : b ∈ s
h✝ : b ∉ t
⊢ b ≤ a
tactic: by_cases b ∈ t
Theorem: dist_triangle4_left
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₂ y₂ ≤ dist x₁ y₁ + (dist x₁ x₂ + dist y₁ y₂)
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₂ y₂ ≤ dist x₂ x₁ + dist x₁ y₁ + dist y₁ y₂
tactic: rw [add_left_comm, dist_comm x₁, ← add_assoc]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₂ y₂ ≤ dist x₂ x₁ + dist x₁ y₁ + dist y₁ y₂
state_after: no goals
tactic: apply dist_triangle4
Theorem: MonoidHom.transfer_eq_pow
File: Mathlib/GroupTheory/Transfer.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
A : Type u_2
inst✝¹ : CommGroup A
ϕ : ↥H →* A
T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
g : G
key : ∀ (k : ℕ) (g₀ : G), g₀⁻¹ * g ^ k * g₀ ∈ H → g₀⁻¹ * g ^ k * g₀ = g ^ k
⊢ ϕ.transfer g = ϕ ⟨g ^ H.index, ⋯⟩
state_after: no goals
tactic: classical
    letI := H.fintypeQuotientOfFiniteIndex
    change ∀ (k g₀) (hk : g₀⁻¹ * g ^ k * g₀ ∈ H), ↑(⟨g₀⁻¹ * g ^ k * g₀, hk⟩ : H) = g ^ k at key
    rw [transfer_eq_prod_quotient_orbitRel_zpowers_quot, ← Finset.prod_to_list]
    refine (List.prod_map_hom _ _ _).trans ?_ -- Porting note: this used to be in the `rw`
    refine congrArg ϕ (Subtype.coe_injective ?_)
    simp only -- Porting note: added `simp only`
    rw [H.coe_mk, ← (zpowers g).coe_mk g (mem_zpowers g), ← (zpowers g).coe_pow, index_eq_card,
      Nat.card_eq_fintype_card, Fintype.card_congr (selfEquivSigmaOrbits (zpowers g) (G ⧸ H)),
      Fintype.card_sigma, ← Finset.prod_pow_eq_pow_sum, ← Finset.prod_to_list]
    simp only [Subgroup.val_list_prod, List.map_map, ← minimalPeriod_eq_card]
    congr
    funext
    apply key
Theorem: Ordinal.lt_bsup
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}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
a : Ordinal.{max u v}
⊢ a < o.bsup f ↔ ∃ i, ∃ (hi : i < o), a < f i hi
state_after: no goals
tactic: simpa only [not_forall, not_le] using not_congr (@bsup_le_iff.{_, v} _ f a)
Theorem: AlgebraicGeometry.Scheme.restrictFunctor_map_base
File: Mathlib/AlgebraicGeometry/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
⊢ (X.restrictFunctor.map i).left.val.base = (Opens.toTopCat ↑X.toPresheafedSpace).map i
state_after: case w
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
a : (forget TopCat).obj ↑(X.restrictFunctor.obj U).left.toPresheafedSpace
⊢ (X.restrictFunctor.map i).left.val.base a = ((Opens.toTopCat ↑X.toPresheafedSpace).map i) a
tactic: ext a
state_before: case w
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
a : (forget TopCat).obj ↑(X.restrictFunctor.obj U).left.toPresheafedSpace
⊢ (X.restrictFunctor.map i).left.val.base a = ((Opens.toTopCat ↑X.toPresheafedSpace).map i) a
state_after: case w
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
a : (forget TopCat).obj ↑(X.restrictFunctor.obj U).left.toPresheafedSpace
⊢ ↑((X.restrictFunctor.map i).left.val.base a) = ↑(((Opens.toTopCat ↑X.toPresheafedSpace).map i) a)
tactic: refine Subtype.ext ?_
state_before: case w
C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
a : (forget TopCat).obj ↑(X.restrictFunctor.obj U).left.toPresheafedSpace
⊢ ↑((X.restrictFunctor.map i).left.val.base a) = ↑(((Opens.toTopCat ↑X.toPresheafedSpace).map i) a)
state_after: no goals
tactic: exact (congr_arg (fun f : X.restrict U.openEmbedding ⟶ X => f.val.base a)
        (X.restrictFunctor_map_ofRestrict i))
Theorem: MeasureTheory.Lp.norm_const_le
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ ‖(Lp.const p μ) c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ ‖indicatorConstLp p ⋯ ⋯ c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
tactic: rw [← indicatorConstLp_univ]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ ‖indicatorConstLp p ⋯ ⋯ c‖ ≤ ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: no goals
tactic: exact norm_indicatorConstLp_le
Theorem: MeasureTheory.lintegral_one
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
⊢ ∫⁻ (x : α), 1 ∂μ = μ univ
state_after: no goals
tactic: rw [lintegral_const, one_mul]
Theorem: Turing.TM1.stmts₁_self
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
q : Stmt₁
⊢ q ∈ stmts₁ q
state_after: no goals
tactic: cases q <;> simp only [stmts₁, Finset.mem_insert_self, Finset.mem_singleton_self]
Theorem: Polynomial.degree_erase_lt
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hp : p ≠ 0
⊢ (erase p.natDegree p).degree < p.degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hp : p ≠ 0
⊢ (erase p.natDegree p).degree ≠ p.degree
tactic: apply lt_of_le_of_ne (degree_erase_le _ _)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hp : p ≠ 0
⊢ (erase p.natDegree p).degree ≠ p.degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hp : p ≠ 0
⊢ (p.support.erase p.natDegree).max ≠ ↑p.natDegree
tactic: rw [degree_eq_natDegree hp, degree, support_erase]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hp : p ≠ 0
⊢ (p.support.erase p.natDegree).max ≠ ↑p.natDegree
state_after: no goals
tactic: exact fun h => not_mem_erase _ _ (mem_of_max h)
Theorem: Finset.inter_left_comm
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ (s₂ ∩ s₃) ↔ x✝ ∈ s₂ ∩ (s₁ ∩ s₃)
state_after: no goals
tactic: simp only [mem_inter, and_left_comm]
Theorem: Stream'.map_iterate
File: Mathlib/Data/Stream/Init.lean

Proof steps:
state_before: α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ iterate f (f a) = map f (iterate f a)
state_after: case h
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ iterate f (f a) n = map f (iterate f a) n
tactic: funext n
state_before: case h
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n : ℕ
⊢ iterate f (f a) n = map f (iterate f a) n
state_after: case h.zero
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
⊢ iterate f (f a) 0 = map f (iterate f a) 0

case h.succ
α : Type u
β : Type v
δ : Type w
f : α → α
a : α
n' : ℕ
ih : iterate f (f a) n' = map f (iterate f a) n'
⊢ iterate f (f a) (n' + 1) = map f (iterate f a) (n' + 1)
tactic: induction' n with n' ih
Theorem: WeierstrassCurve.Jacobian.Point.toAffine_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
u : F
hu : IsUnit u
⊢ toAffine W (u • P) = toAffine W P
state_after: case pos
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
u : F
hu : IsUnit u
hP : W.Nonsingular P
⊢ toAffine W (u • P) = toAffine W P

case neg
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
u : F
hu : IsUnit u
hP : ¬W.Nonsingular P
⊢ toAffine W (u • P) = toAffine W P
tactic: by_cases hP : W.Nonsingular P