ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.chromaticNumber_le_of_forall_imp
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
⊢ G.chromaticNumber ≤ G'.chromaticNumber
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
⊢ ⨅ n ∈ setOf G.Colorable, ↑n ≤ ⨅ n ∈ setOf G'.Colorable, ↑n
tactic: rw [chromaticNumber, chromaticNumber]
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
⊢ ⨅ n ∈ setOf G.Colorable, ↑n ≤ ⨅ n ∈ setOf G'.Colorable, ↑n
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
⊢ ∀ (i : ℕ), G'.Colorable i → ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑i
tactic: simp only [Set.mem_setOf_eq, le_iInf_iff]
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
⊢ ∀ (i : ℕ), G'.Colorable i → ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑i
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
tactic: intro m hc
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.Colorable m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
tactic: have := h _ hc
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.Colorable m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
state_after: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.chromaticNumber ≤ ↑m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
tactic: rw [← chromaticNumber_le_iff_colorable] at this
state_before: V : Type u
G : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
V' : Type u_3
G' : SimpleGraph V'
h : ∀ (n : ℕ), G'.Colorable n → G.Colorable n
m : ℕ
hc : G'.Colorable m
this : G.chromaticNumber ≤ ↑m
⊢ ⨅ n, ⨅ (_ : G.Colorable n), ↑n ≤ ↑m
state_after: no goals
tactic: exact this
Theorem: Real.smoothTransition.projIcc
File: Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean

Proof steps:
state_before: x : ℝ
⊢ (↑(projIcc 0 1 ⋯ x)).smoothTransition = x.smoothTransition
state_after: case refine_1
x✝ x : ℝ
hx : x < 0
⊢ x.smoothTransition = smoothTransition 0

case refine_2
x✝ x : ℝ
hx : 1 < x
⊢ x.smoothTransition = smoothTransition 1
tactic: refine congr_fun
    (IccExtend_eq_self zero_le_one smoothTransition (fun x hx => ?_) fun x hx => ?_) x
Theorem: Turing.PartrecToTM2.trNormal_supports
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: S : Finset Λ'
c : Code
k : Cont'
Hk : codeSupp c k ⊆ S
⊢ Λ'.Supports S (trNormal c k)
state_after: no goals
tactic: induction c generalizing k with simp [Λ'.Supports, head]
  | zero' => exact Finset.union_subset_right Hk
  | succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  | tail => exact Finset.union_subset_right Hk
  | cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  | comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  | case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  | fix f IHf => apply IHf; rw [codeSupp_fix] at Hk; exact Finset.union_subset_right Hk
Theorem: CircleDeg1Lift.commute_int_add
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
n : ℤ
⊢ Function.Commute ⇑f fun x => ↑n + x
state_after: no goals
tactic: simpa only [add_comm _ (n : ℝ)] using f.commute_add_int n
Theorem: PowerSeries.coeff_one_mul
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R✝ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
ι : Type u_3
inst✝ : DecidableEq ι
φ ψ : R⟦X⟧
⊢ (coeff R 1) (φ * ψ) = (coeff R 1) φ * (constantCoeff R) ψ + (coeff R 1) ψ * (constantCoeff R) φ
state_after: R✝ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
ι : Type u_3
inst✝ : DecidableEq ι
φ ψ : R⟦X⟧
this : antidiagonal 1 = {(0, 1), (1, 0)}
⊢ (coeff R 1) (φ * ψ) = (coeff R 1) φ * (constantCoeff R) ψ + (coeff R 1) ψ * (constantCoeff R) φ
tactic: have : Finset.antidiagonal 1 = {(0, 1), (1, 0)} := by exact rfl
state_before: R✝ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
ι : Type u_3
inst✝ : DecidableEq ι
φ ψ : R⟦X⟧
this : antidiagonal 1 = {(0, 1), (1, 0)}
⊢ (coeff R 1) (φ * ψ) = (coeff R 1) φ * (constantCoeff R) ψ + (coeff R 1) ψ * (constantCoeff R) φ
state_after: R✝ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
ι : Type u_3
inst✝ : DecidableEq ι
φ ψ : R⟦X⟧
this : antidiagonal 1 = {(0, 1), (1, 0)}
⊢ (0, 1) ∉ {(1, 0)}
tactic: rw [coeff_mul, this, Finset.sum_insert, Finset.sum_singleton, coeff_zero_eq_constantCoeff,
    mul_comm, add_comm]
state_before: R✝ : Type u_1
R : Type u_2
inst✝¹ : CommSemiring R
ι : Type u_3
inst✝ : DecidableEq ι
φ ψ : R⟦X⟧
this : antidiagonal 1 = {(0, 1), (1, 0)}
⊢ (0, 1) ∉ {(1, 0)}
state_after: no goals
tactic: norm_num
Theorem: WithLp.edist_equiv_symm_snd
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
y₁ y₂ : β
⊢ edist ((WithLp.equiv p (α × β)).symm (0, y₁)) ((WithLp.equiv p (α × β)).symm (0, y₂)) = edist y₁ y₂
state_after: no goals
tactic: simp only [edist_nndist, nndist_equiv_symm_snd p α β y₁ y₂]
Theorem: UV.compression_idem
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b : α
inst✝ : DecidableEq α
u v : α
s : Finset α
h : filter (fun x => compress u v x ∉ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ 𝓒 u v (𝓒 u v s) = 𝓒 u v s
state_after: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b : α
inst✝ : DecidableEq α
u v : α
s : Finset α
h : filter (fun x => compress u v x ∉ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ filter (fun x => compress u v x ∈ 𝓒 u v s) (𝓒 u v s) ∪ filter (fun x => compress u v x ∉ 𝓒 u v s) (𝓒 u v s) = 𝓒 u v s
tactic: rw [compression, filter_image, h, image_empty, ← h]
state_before: α : Type u_1
inst✝³ : GeneralizedBooleanAlgebra α
inst✝² : DecidableRel Disjoint
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
s✝ : Finset α
u✝ v✝ a b : α
inst✝ : DecidableEq α
u v : α
s : Finset α
h : filter (fun x => compress u v x ∉ 𝓒 u v s) (𝓒 u v s) = ∅
⊢ filter (fun x => compress u v x ∈ 𝓒 u v s) (𝓒 u v s) ∪ filter (fun x => compress u v x ∉ 𝓒 u v s) (𝓒 u v s) = 𝓒 u v s
state_after: no goals
tactic: exact filter_union_filter_neg_eq _ (compression u v s)
Theorem: Subgroup.quotientEquivSigmaZMod_apply
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : orbitRel.Quotient (↥(zpowers g)) (G ⧸ H)
k : ℤ
⊢ (H.quotientEquivSigmaZMod g) (g ^ k • Quotient.out' q) = ⟨q, ↑k⟩
state_after: no goals
tactic: rw [apply_eq_iff_eq_symm_apply, quotientEquivSigmaZMod_symm_apply, ZMod.coe_intCast,
    zpow_smul_mod_minimalPeriod]
Theorem: ContinuousMap.Homotopy.hcomp_apply
File: Mathlib/Topology/Homotopy/Basic.lean

Proof steps:
state_before: F✝ : Type u_1
X : Type u
Y : Type v
Z : Type w
Z' : Type x
ι : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
g₀ g₁ : C(Y, Z)
F : f₀.Homotopy f₁
G : g₀.Homotopy g₁
⊢ ∀ (x : X), { toFun := fun x => G (x.1, F x), continuous_toFun := ⋯ }.toFun (0, x) = (g₀.comp f₀) x
state_after: no goals
tactic: simp
state_before: F✝ : Type u_1
X : Type u
Y : Type v
Z : Type w
Z' : Type x
ι : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
g₀ g₁ : C(Y, Z)
F : f₀.Homotopy f₁
G : g₀.Homotopy g₁
⊢ ∀ (x : X), { toFun := fun x => G (x.1, F x), continuous_toFun := ⋯ }.toFun (1, x) = (g₁.comp f₁) x
state_after: no goals
tactic: simp
Theorem: wittPolynomial_eq_sum_C_mul_X_pow
File: Mathlib/RingTheory/WittVector/WittPolynomial.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ wittPolynomial p R n = ∑ i ∈ range (n + 1), C (↑p ^ i) * X i ^ p ^ (n - i)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ ∀ x ∈ range (n + 1), (monomial (single x (p ^ (n - x)))) (↑p ^ x) = C (↑p ^ x) * X x ^ p ^ (n - x)
tactic: apply sum_congr rfl
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n : ℕ
⊢ ∀ x ∈ range (n + 1), (monomial (single x (p ^ (n - x)))) (↑p ^ x) = C (↑p ^ x) * X x ^ p ^ (n - x)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ (monomial (single i (p ^ (n - i)))) (↑p ^ i) = C (↑p ^ i) * X i ^ p ^ (n - i)
tactic: rintro i -
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ (monomial (single i (p ^ (n - i)))) (↑p ^ i) = C (↑p ^ i) * X i ^ p ^ (n - i)
state_after: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ X i ^ 0 = 1
tactic: rw [monomial_eq, Finsupp.prod_single_index]
state_before: p : ℕ
R : Type u_1
inst✝¹ : CommRing R
inst✝ : DecidableEq R
n i : ℕ
⊢ X i ^ 0 = 1
state_after: no goals
tactic: rw [pow_zero]
Theorem: Matroid.Base.exchange_mem
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B₁ B₂ : Set α
e : α
hB₁ : M.Base B₁
hB₂ : M.Base B₂
hxB₁ : e ∈ B₁
hxB₂ : e ∉ B₂
⊢ ∃ y, (y ∈ B₂ ∧ y ∉ B₁) ∧ M.Base (insert y (B₁ \ {e}))
state_after: no goals
tactic: simpa using hB₁.exchange hB₂ ⟨hxB₁, hxB₂⟩
Theorem: Rat.substr_num_den'
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: q r : ℚ
⊢ (q - r).num * ↑q.den * ↑r.den = (q.num * ↑r.den - r.num * ↑q.den) * ↑(q - r).den
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, ← neg_mul, ← num_neg_eq_neg_num, ← den_neg_eq_den r,
    add_num_den' q (-r)]
Theorem: AddSubgroup.leftTransversals.diff_add_diff
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
R S T : ↑(leftTransversals ↑H)
inst✝ : H.FiniteIndex
q : G ⧸ H
x✝ : q ∈ univ
⊢ ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩ *
      ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩ =
    ⟨(↑((MemLeftTransversals.toEquiv ⋯) q))⁻¹ * ↑((MemLeftTransversals.toEquiv ⋯) q), ⋯⟩
state_after: no goals
tactic: simp_rw [Subtype.ext_iff, coe_mul, mul_assoc, mul_inv_cancel_left]
Theorem: X_pow_sub_C_irreducible_of_prime_pow
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
p : ℕ
hp : Nat.Prime p
hp' : p ≠ 2
n : ℕ
a : K
ha : ∀ (b : K), b ^ p ≠ a
⊢ Irreducible (X ^ p ^ n - C a)
state_after: K : Type u
inst✝ : Field K
p : ℕ
hp : Nat.Prime p
hp' : p ≠ 2
n : ℕ
a : K
ha : ∀ (b : K), b ^ p ≠ a
⊢ ∀ (p_1 : ℕ), Nat.Prime p_1 → p_1 ∣ p ^ n → ∀ (b : K), b ^ p_1 ≠ a
tactic: apply X_pow_sub_C_irreducible_of_odd (hp.odd_of_ne_two hp').pow
state_before: K : Type u
inst✝ : Field K
p : ℕ
hp : Nat.Prime p
hp' : p ≠ 2
n : ℕ
a : K
ha : ∀ (b : K), b ^ p ≠ a
⊢ ∀ (p_1 : ℕ), Nat.Prime p_1 → p_1 ∣ p ^ n → ∀ (b : K), b ^ p_1 ≠ a
state_after: K : Type u
inst✝ : Field K
p : ℕ
hp : Nat.Prime p
hp' : p ≠ 2
n : ℕ
a : K
ha : ∀ (b : K), b ^ p ≠ a
q : ℕ
hq : Nat.Prime q
hq' : q ∣ p ^ n
⊢ ∀ (b : K), b ^ q ≠ a
tactic: intros q hq hq'
state_before: K : Type u
inst✝ : Field K
p : ℕ
hp : Nat.Prime p
hp' : p ≠ 2
n : ℕ
a : K
ha : ∀ (b : K), b ^ p ≠ a
q : ℕ
hq : Nat.Prime q
hq' : q ∣ p ^ n
⊢ ∀ (b : K), b ^ q ≠ a
state_after: no goals
tactic: simpa [(Nat.prime_dvd_prime_iff_eq hq hp).mp (hq.dvd_of_dvd_pow hq')] using ha
Theorem: _private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.sum_Ico_eq_card_lt
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: p q : ℕ
hp0 : p = 0
⊢ ∑ a ∈ Ico 1 (p / 2).succ, a * q / p =
    (filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ)).card
state_after: no goals
tactic: simp [hp0, Finset.ext_iff]
state_before: p q : ℕ
hp0 : ¬p = 0
x : ℕ
hx : x ∈ Ico 1 (p / 2).succ
⊢ x * q / p ≤ p / 2 * q / p
state_after: p q : ℕ
hp0 : ¬p = 0
x : ℕ
hx : x ∈ Ico 1 (p / 2).succ
this : x ≤ p / 2
⊢ x * q / p ≤ p / 2 * q / p
tactic: have := le_of_lt_succ (mem_Ico.mp hx).2
state_before: p q : ℕ
hp0 : ¬p = 0
x : ℕ
hx : x ∈ Ico 1 (p / 2).succ
this : x ≤ p / 2
⊢ x * q / p ≤ p / 2 * q / p
state_after: no goals
tactic: gcongr
state_before: p q : ℕ
hp0 : ¬p = 0
⊢ ∑ a ∈ Ico 1 (p / 2).succ, (filter (fun x => x * p ≤ a * q) (Ico 1 (q / 2).succ)).card =
    (filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ)).card
state_after: p q : ℕ
hp0 : ¬p = 0
⊢ ((Ico 1 (p / 2).succ).sigma fun a => filter (fun x => x * p ≤ a * q) (Ico 1 (q / 2).succ)).card =
    (filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ)).card
tactic: rw [← card_sigma]
state_before: p q : ℕ
hp0 : ¬p = 0
⊢ ((Ico 1 (p / 2).succ).sigma fun a => filter (fun x => x * p ≤ a * q) (Ico 1 (q / 2).succ)).card =
    (filter (fun x => x.2 * p ≤ x.1 * q) (Ico 1 (p / 2).succ ×ˢ Ico 1 (q / 2).succ)).card
state_after: no goals
tactic: exact card_nbij' (fun a ↦ ⟨a.1, a.2⟩) (fun a ↦ ⟨a.1, a.2⟩)
          (by simp (config := { contextual := true }) only [mem_filter, mem_sigma, and_self_iff,
            forall_true_iff, mem_product])
          (by simp (config := { contextual := true }) only [mem_filter, mem_sigma, and_self_iff,
            forall_true_iff, mem_product]) (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
Theorem: AdicCompletion.smul_mk
File: Mathlib/RingTheory/AdicCompletion/Algebra.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
I : Ideal R
M : Type u_2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m n : ℕ
hmn : m ≤ n
r : AdicCauchySequence I R
x : AdicCauchySequence I M
⊢ ↑r n • Submodule.Quotient.mk (↑x n) = ↑r m • Submodule.Quotient.mk (↑x m)
state_after: no goals
tactic: rw [← Submodule.Quotient.mk_smul, ← Module.Quotient.mk_smul_mk,
    AdicCauchySequence.mk_eq_mk hmn, Ideal.mk_eq_mk I hmn, Module.Quotient.mk_smul_mk,
    Submodule.Quotient.mk_smul]
Theorem: cocompact_le_atBot
File: Mathlib/Topology/Algebra/Order/Compact.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTop α
inst✝ : CompactIccSpace α
⊢ cocompact α ≤ atBot
state_after: case refine_1
α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTop α
inst✝ : CompactIccSpace α
x✝ : Set α
hs : x✝ ∈ atBot
h✝ : IsEmpty α
⊢ ∃ t, IsCompact t ∧ tᶜ ⊆ x✝

case refine_2
α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : OrderTop α
inst✝ : CompactIccSpace α
x✝ : Set α
hs : x✝ ∈ atBot
h✝ : Nonempty α
⊢ ∃ t, IsCompact t ∧ tᶜ ⊆ x✝
tactic: refine fun _ hs ↦ mem_cocompact.mpr <| (isEmpty_or_nonempty α).casesOn ?_ ?_ <;> intro
Theorem: SemiconjBy.conj_iff
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * b⁻¹ * (b * x * b⁻¹) = b * y * b⁻¹ * (b * a * b⁻¹) ↔ a * x = y * a
tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * b⁻¹ * (b * x * b⁻¹) = b * y * b⁻¹ * (b * a * b⁻¹) ↔ a * x = y * a
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * x * b⁻¹ = b * y * a * b⁻¹ ↔ a * x = y * a
tactic: simp only [← mul_assoc, inv_mul_cancel_right]
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * x * b⁻¹ = b * y * a * b⁻¹ ↔ a * x = y * a
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * (a * (x * b⁻¹)) = b * (y * (a * b⁻¹)) ↔ a * x = y * a
tactic: repeat rw [mul_assoc]
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * (a * (x * b⁻¹)) = b * (y * (a * b⁻¹)) ↔ a * x = y * a
state_after: no goals
tactic: rw [mul_left_cancel_iff, ← mul_assoc, ← mul_assoc, mul_right_cancel_iff]
Theorem: Finset.sup'_insert
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
inst✝ : DecidableEq β
b : β
⊢ (insert b s).sup' ⋯ f = f b ⊔ s.sup' H f
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
inst✝ : DecidableEq β
b : β
⊢ ↑((insert b s).sup' ⋯ f) = ↑(f b ⊔ s.sup' H f)
tactic: rw [← WithBot.coe_eq_coe]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
inst✝ : DecidableEq β
b : β
⊢ ↑((insert b s).sup' ⋯ f) = ↑(f b ⊔ s.sup' H f)
state_after: no goals
tactic: simp [WithBot.coe_sup]
Theorem: SzemerediRegularity.stepBound_mono
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Bound.lean

Proof steps:
state_before: a b : ℕ
h : a ≤ b
⊢ 4 > 0
state_after: no goals
tactic: norm_num
Theorem: Multiset.mk_mem_sym2_iff
File: Mathlib/Data/Multiset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Multiset α
a b : α
xs : List α
⊢ s(a, b) ∈ Multiset.sym2 ⟦xs⟧ ↔ a ∈ ⟦xs⟧ ∧ b ∈ ⟦xs⟧
state_after: no goals
tactic: simp [List.mk_mem_sym2_iff]
Theorem: gauge_norm_smul
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
⊢ gauge s (‖r‖ • x) = gauge s (r • x)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
⊢ sInf {r_1 | 0 < r_1 ∧ ‖r‖ • x ∈ r_1 • s} = sInf {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
tactic: unfold gauge
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
⊢ sInf {r_1 | 0 < r_1 ∧ ‖r‖ • x ∈ r_1 • s} = sInf {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
state_after: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
⊢ θ ∈ {r_1 | 0 < r_1 ∧ ‖r‖ • x ∈ r_1 • s} ↔ θ ∈ {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
tactic: congr with θ
state_before: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
⊢ θ ∈ {r_1 | 0 < r_1 ∧ ‖r‖ • x ∈ r_1 • s} ↔ θ ∈ {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
state_after: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
⊢ θ ∈ {r_1 | 0 < r_1 ∧ ↑‖r‖ • x ∈ r_1 • s} ↔ θ ∈ {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
tactic: rw [@RCLike.real_smul_eq_coe_smul 𝕜]
state_before: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
⊢ θ ∈ {r_1 | 0 < r_1 ∧ ↑‖r‖ • x ∈ r_1 • s} ↔ θ ∈ {r_1 | 0 < r_1 ∧ r • x ∈ r_1 • s}
state_after: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
hθ : 0 < θ
⊢ ‖↑‖r‖‖ = ‖r‖
tactic: refine and_congr_right fun hθ => (hs.smul _).smul_mem_iff ?_
state_before: case e_a.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
s t : Set E
x✝ : E
a : ℝ
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : IsScalarTower ℝ 𝕜 E
hs : Balanced 𝕜 s
r : 𝕜
x : E
θ : ℝ
hθ : 0 < θ
⊢ ‖↑‖r‖‖ = ‖r‖
state_after: no goals
tactic: rw [RCLike.norm_ofReal, abs_norm]
Theorem: EMetric.diam_iUnion_mem_option
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s✝ t : Set α
ι : Type u_2
o : Option ι
s : ι → Set α
⊢ diam (⋃ i ∈ o, s i) = ⨆ i ∈ o, diam (s i)
state_after: no goals
tactic: cases o <;> simp
Theorem: ENNReal.log_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean

Proof steps:
state_before: x y : ℝ≥0∞
h : x = y
⊢ x.log = y.log
state_after: no goals
tactic: rw [h]
Theorem: Polynomial.pow_sub_one_dvd_derivative_of_pow_dvd
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
p q : R[X]
n : ℕ
dvd : q ^ n ∣ p
⊢ q ^ (n - 1) ∣ derivative p
state_after: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
q : R[X]
n : ℕ
r : R[X]
⊢ q ^ (n - 1) ∣ derivative (q ^ n * r)
tactic: obtain ⟨r, rfl⟩ := dvd
state_before: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
q : R[X]
n : ℕ
r : R[X]
⊢ q ^ (n - 1) ∣ derivative (q ^ n * r)
state_after: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
q : R[X]
n : ℕ
r : R[X]
⊢ q ^ (n - 1) ∣ C ↑n * q ^ (n - 1) * derivative q * r + q ^ n * derivative r
tactic: rw [derivative_mul, derivative_pow]
state_before: case intro
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
q : R[X]
n : ℕ
r : R[X]
⊢ q ^ (n - 1) ∣ C ↑n * q ^ (n - 1) * derivative q * r + q ^ n * derivative r
state_after: no goals
tactic: exact (((dvd_mul_left _ _).mul_right _).mul_right _).add ((pow_dvd_pow q n.pred_le).mul_right _)
Theorem: List.infix_concat
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
a : α✝
x✝ : l₁ <:+: l₂
L₁ L₂ : List α✝
h : L₁ ++ l₁ ++ L₂ = l₂
⊢ L₁ ++ l₁ ++ L₂.concat a = l₂.concat a
state_after: no goals
tactic: simp [← h, concat_eq_append, append_assoc]