ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: RingHom.map_geom_sum₂
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝¹ : Semiring α
inst✝ : Semiring β
x y : α
n : ℕ
f : α →+* β
⊢ f (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) = ∑ i ∈ range n, f x ^ i * f y ^ (n - 1 - i)
state_after: no goals
tactic: simp [map_sum f]
Theorem: Cardinal.nfpFamily_lt_ord_lift_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
ha : a < c.ord
⊢ nfpFamily f a < c.ord
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
ha : a < c.ord
⊢ ℵ₀ < c

α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
ha : a < c.ord
⊢ lift.{v, u} #ι < c
tactic: apply nfpFamily_lt_ord_lift.{u, v} _ _ hf ha <;> rw [hc.cof_eq]
Theorem: Polynomial.taylor_zero
File: Mathlib/Algebra/Polynomial/Taylor.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f✝ f : R[X]
⊢ (taylor 0) f = f
state_after: no goals
tactic: rw [taylor_zero', LinearMap.id_apply]
Theorem: AddMonoidHom.completion_zero
File: Mathlib/Topology/Algebra/GroupCompletion.lean

Proof steps:
state_before: M : Type u_1
R : Type u_2
α : Type u_3
β : Type u_4
inst✝⁵ : UniformSpace α
inst✝⁴ : AddGroup α
inst✝³ : UniformAddGroup α
inst✝² : UniformSpace β
inst✝¹ : AddGroup β
inst✝ : UniformAddGroup β
⊢ completion 0 ⋯ = 0
state_after: case h
M : Type u_1
R : Type u_2
α : Type u_3
β : Type u_4
inst✝⁵ : UniformSpace α
inst✝⁴ : AddGroup α
inst✝³ : UniformAddGroup α
inst✝² : UniformSpace β
inst✝¹ : AddGroup β
inst✝ : UniformAddGroup β
x : Completion α
⊢ (completion 0 ⋯) x = 0 x
tactic: ext x
state_before: case h
M : Type u_1
R : Type u_2
α : Type u_3
β : Type u_4
inst✝⁵ : UniformSpace α
inst✝⁴ : AddGroup α
inst✝³ : UniformAddGroup α
inst✝² : UniformSpace β
inst✝¹ : AddGroup β
inst✝ : UniformAddGroup β
x : Completion α
⊢ (completion 0 ⋯) x = 0 x
state_after: case h.refine_1
M : Type u_1
R : Type u_2
α : Type u_3
β : Type u_4
inst✝⁵ : UniformSpace α
inst✝⁴ : AddGroup α
inst✝³ : UniformAddGroup α
inst✝² : UniformSpace β
inst✝¹ : AddGroup β
inst✝ : UniformAddGroup β
x : Completion α
⊢ IsClosed {a | (completion 0 ⋯) a = 0 a}

case h.refine_2
M : Type u_1
R : Type u_2
α : Type u_3
β : Type u_4
inst✝⁵ : UniformSpace α
inst✝⁴ : AddGroup α
inst✝³ : UniformAddGroup α
inst✝² : UniformSpace β
inst✝¹ : AddGroup β
inst✝ : UniformAddGroup β
x : Completion α
⊢ ∀ (a : α), (completion 0 ⋯) (↑α a) = 0 (↑α a)
tactic: refine Completion.induction_on x ?_ ?_
Theorem: List.dropSlice_eq
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ xs : List α
n m : ℕ
⊢ dropSlice n m xs = take n xs ++ drop (n + m) xs
state_after: case zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
m : ℕ
xs : List α
⊢ dropSlice 0 m xs = take 0 xs ++ drop (0 + m) xs

case succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
m n✝ : ℕ
a✝ : ∀ (xs : List α), dropSlice n✝ m xs = take n✝ xs ++ drop (n✝ + m) xs
xs : List α
⊢ dropSlice (n✝ + 1) m xs = take (n✝ + 1) xs ++ drop (n✝ + 1 + m) xs
tactic: induction n generalizing xs
Theorem: Finsupp.single_add_single_eq_single_add_single
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✝ : AddCommMonoid M
k l m n : α
u v : M
hu : u ≠ 0
hv : v ≠ 0
⊢ single k u + single l v = single m u + single n v ↔ k = m ∧ l = n ∨ u = v ∧ k = n ∧ l = m ∨ u + v = 0 ∧ k = l ∧ m = n
state_after: no goals
tactic: classical
    simp_rw [DFunLike.ext_iff, coe_add, single_eq_pi_single, ← funext_iff]
    exact Pi.single_add_single_eq_single_add_single hu hv
Theorem: star_div'
File: Mathlib/Algebra/Star/Basic.lean

Proof steps:
state_before: R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ star (x / y) = star x / star y
state_after: case a
R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ op (star (x / y)) = op (star x / star y)
tactic: apply op_injective
state_before: case a
R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ op (star (x / y)) = op (star x / star y)
state_after: no goals
tactic: rw [division_def, op_div, mul_comm, star_mul, star_inv', op_mul, op_inv]
Theorem: ContractingWith.edist_le_of_fixedPoint
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
hy : IsFixedPt f y
⊢ edist x y ≤ edist x (f x) / (1 - ↑K)
state_after: no goals
tactic: simpa only [hy.eq, edist_self, add_zero] using hf.edist_inequality h
Theorem: Nat.factorizationLCMLeft_mul_factorizationLCMRight
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a.factorizationLCMLeft b * a.factorizationLCMRight b = a.lcm b
state_after: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ ((a.lcm b).factorization.prod fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    (a.lcm b).factorization.prod fun x x_1 => x ^ x_1
tactic: rw [← factorization_prod_pow_eq_self (lcm_ne_zero ha hb), factorizationLCMLeft,
    factorizationLCMRight, ← prod_mul]
state_before: a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ ((a.lcm b).factorization.prod fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    (a.lcm b).factorization.prod fun x x_1 => x ^ x_1
state_after: case e_g
a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    fun x x_1 => x ^ x_1
tactic: congr
state_before: case e_g
a b m n p : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (fun a_1 b_1 =>
      (if b.factorization a_1 ≤ a.factorization a_1 then a_1 ^ b_1 else 1) *
        if b.factorization a_1 ≤ a.factorization a_1 then 1 else a_1 ^ b_1) =
    fun x x_1 => x ^ x_1
state_after: case e_g.h.h
a b m n✝ p✝ : ℕ
ha : a ≠ 0
hb : b ≠ 0
p n : ℕ
⊢ ((if b.factorization p ≤ a.factorization p then p ^ n else 1) *
      if b.factorization p ≤ a.factorization p then 1 else p ^ n) =
    p ^ n
tactic: ext p n
state_before: case e_g.h.h
a b m n✝ p✝ : ℕ
ha : a ≠ 0
hb : b ≠ 0
p n : ℕ
⊢ ((if b.factorization p ≤ a.factorization p then p ^ n else 1) *
      if b.factorization p ≤ a.factorization p then 1 else p ^ n) =
    p ^ n
state_after: no goals
tactic: split_ifs <;> simp
Theorem: RCLike.conj_eq_re_sub_im
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ (starRingEnd K) (↑(re z) + ↑(im z) * I) = ↑(re z) - ↑(im z) * I
state_after: no goals
tactic: rw [map_add, map_mul, conj_I, conj_ofReal, conj_ofReal, mul_neg, sub_eq_add_neg]
Theorem: Ideal.IsPrime.mem_pow_mul
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I.IsPrime
a b : R
n : ℕ
h : a * b ∈ I ^ n
⊢ a ∈ I ^ n ∨ b ∈ I
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I.IsPrime
a b : R
n : ℕ
h : b * a ∈ I ^ n
⊢ a ∈ I ^ n ∨ b ∈ I
tactic: rw [mul_comm] at h
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I.IsPrime
a b : R
n : ℕ
h : b * a ∈ I ^ n
⊢ a ∈ I ^ n ∨ b ∈ I
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I.IsPrime
a b : R
n : ℕ
h : b * a ∈ I ^ n
⊢ b ∈ I ∨ a ∈ I ^ n
tactic: rw [or_comm]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Field K
inst✝ : IsDedekindDomain R
I : Ideal R
hI : I.IsPrime
a b : R
n : ℕ
h : b * a ∈ I ^ n
⊢ b ∈ I ∨ a ∈ I ^ n
state_after: no goals
tactic: exact Ideal.IsPrime.mul_mem_pow _ h
Theorem: Associates.one_or_eq_of_le_of_prime
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p m : Associates α
hp : Prime p
hle : m ≤ p
⊢ m = 1 ∨ m = p
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
m : Associates α
p : α
hp : Prime (Associates.mk p)
hle : m ≤ Associates.mk p
⊢ m = 1 ∨ m = Associates.mk p
tactic: rcases mk_surjective p with ⟨p, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
m : Associates α
p : α
hp : Prime (Associates.mk p)
hle : m ≤ Associates.mk p
⊢ m = 1 ∨ m = Associates.mk p
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime (Associates.mk p)
m : α
hle : Associates.mk m ≤ Associates.mk p
⊢ Associates.mk m = 1 ∨ Associates.mk m = Associates.mk p
tactic: rcases mk_surjective m with ⟨m, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime (Associates.mk p)
m : α
hle : Associates.mk m ≤ Associates.mk p
⊢ Associates.mk m = 1 ∨ Associates.mk m = Associates.mk p
state_after: no goals
tactic: simpa [mk_eq_mk_iff_associated, Associated.comm, -Quotient.eq]
    using (prime_mk.1 hp).irreducible.dvd_iff.mp (mk_le_mk_iff_dvd.1 hle)
Theorem: LipschitzWith.coordinate
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
inst✝ : PseudoMetricSpace α
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
⊢ LipschitzWith K f ↔ ∀ (i : ι), LipschitzWith K fun a => ↑(f a) i
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
inst✝ : PseudoMetricSpace α
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
⊢ LipschitzOnWith K f Set.univ ↔ ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) Set.univ
tactic: simp_rw [← lipschitzOnWith_univ]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
ι : Type u_3
inst✝ : PseudoMetricSpace α
f : α → ↥(lp (fun i => ℝ) ⊤)
K : ℝ≥0
⊢ LipschitzOnWith K f Set.univ ↔ ∀ (i : ι), LipschitzOnWith K (fun a => ↑(f a) i) Set.univ
state_after: no goals
tactic: apply LipschitzOnWith.coordinate
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_neg_add_self_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n : A
X : C
⊢ (shiftFunctor C (-n)).map ((shiftFunctorCompIsoId C (-n) n ⋯).inv.app X) =
    (shiftFunctorCompIsoId C n (-n) ⋯).inv.app ((shiftFunctor C (-n)).obj X)
state_after: no goals
tactic: apply shift_shiftFunctorCompIsoId_inv_app
Theorem: QuotientAddGroup.rangeKerLift_surjective
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
⊢ Surjective ⇑(rangeKerLift φ)
state_after: case mk.intro
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
g : G
⊢ ∃ a, (rangeKerLift φ) a = ⟨φ g, ⋯⟩
tactic: rintro ⟨_, g, rfl⟩
state_before: case mk.intro
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
g : G
⊢ ∃ a, (rangeKerLift φ) a = ⟨φ g, ⋯⟩
state_after: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
g : G
⊢ (rangeKerLift φ) ↑g = ⟨φ g, ⋯⟩
tactic: use mk g
state_before: case h
G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
φ : G →* H
g : G
⊢ (rangeKerLift φ) ↑g = ⟨φ g, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: TendstoLocallyUniformlyOn.mono
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
⊢ TendstoLocallyUniformlyOn F f p s'
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
⊢ ∃ t ∈ 𝓝[s'] x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
tactic: intro u hu x hx
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
⊢ ∃ t ∈ 𝓝[s'] x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
state_after: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
t : Set α
ht : t ∈ 𝓝[s] x
H : ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
⊢ ∃ t ∈ 𝓝[s'] x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
tactic: rcases h u hu x (h' hx) with ⟨t, ht, H⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
h : TendstoLocallyUniformlyOn F f p s
h' : s' ⊆ s
u : Set (β × β)
hu : u ∈ 𝓤 β
x : α
hx : x ∈ s'
t : Set α
ht : t ∈ 𝓝[s] x
H : ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
⊢ ∃ t ∈ 𝓝[s'] x, ∀ᶠ (n : ι) in p, ∀ y ∈ t, (f y, F n y) ∈ u
state_after: no goals
tactic: exact ⟨t, nhdsWithin_mono x h' ht, H.mono fun n => id⟩
Theorem: Nat.multiplicity_eq_card_pow_dvd
File: Mathlib/Data/Nat/Multiplicity.lean

Proof steps:
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
⊢ multiplicity m n = ↑(Ico 1 ((multiplicity m n).get ⋯ + 1)).card
state_after: no goals
tactic: simp
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
⊢ i ∈ Ico 1 ((multiplicity m n).get ⋯ + 1) ↔ i ∈ filter (fun i => m ^ i ∣ n) (Ico 1 b)
state_after: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
⊢ 1 ≤ i ∧ m ^ i ∣ n ↔ (1 ≤ i ∧ m ^ i ∣ n) ∧ i < b
tactic: rw [mem_filter, mem_Ico, mem_Ico, Nat.lt_succ_iff, ← @PartENat.coe_le_coe i,
              PartENat.natCast_get, ← pow_dvd_iff_le_multiplicity, and_right_comm]
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
⊢ 1 ≤ i ∧ m ^ i ∣ n ↔ (1 ≤ i ∧ m ^ i ∣ n) ∧ i < b
state_after: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
h : 1 ≤ i ∧ m ^ i ∣ n
⊢ i ≤ log m n
tactic: refine (and_iff_left_of_imp fun h => lt_of_le_of_lt ?_ hb).symm
state_before: m n b : ℕ
hm : m ≠ 1
hn : 0 < n
hb : log m n < b
i : ℕ
h : 1 ≤ i ∧ m ^ i ∣ n
⊢ i ≤ log m n
state_after: case zero
n b : ℕ
hn : 0 < n
i : ℕ
hm : 0 ≠ 1
hb : log 0 n < b
h : 1 ≤ i ∧ 0 ^ i ∣ n
⊢ i ≤ log 0 n

case succ
n b : ℕ
hn : 0 < n
i m : ℕ
hm : m + 1 ≠ 1
hb : log (m + 1) n < b
h : 1 ≤ i ∧ (m + 1) ^ i ∣ n
⊢ i ≤ log (m + 1) n
tactic: cases' m with m
state_before: case succ
n b : ℕ
hn : 0 < n
i m : ℕ
hm : m + 1 ≠ 1
hb : log (m + 1) n < b
h : 1 ≤ i ∧ (m + 1) ^ i ∣ n
⊢ i ≤ log (m + 1) n
state_after: no goals
tactic: exact le_log_of_pow_le (one_lt_iff_ne_zero_and_ne_one.2 ⟨m.succ_ne_zero, hm⟩)
                (le_of_dvd hn h.2)
Theorem: Set.nonempty_compl_of_nontrivial
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Nontrivial α
x : α
⊢ {x}ᶜ.Nonempty
state_after: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Nontrivial α
x y : α
hy : y ≠ x
⊢ {x}ᶜ.Nonempty
tactic: obtain ⟨y, hy⟩ := exists_ne x
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝ : Nontrivial α
x y : α
hy : y ≠ x
⊢ {x}ᶜ.Nonempty
state_after: no goals
tactic: exact ⟨y, by simp [hy]⟩
Theorem: Cardinal.continuum_lt_lift
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: c : Cardinal.{u}
⊢ 𝔠 < lift.{v, u} c ↔ 𝔠 < c
state_after: no goals
tactic: rw [← lift_continuum.{v, u}, lift_lt]
Theorem: CategoryTheory.Discrete.functor_map
File: Mathlib/CategoryTheory/DiscreteCategory.lean

Proof steps:
state_before: α : Type u₁
C : Type u₂
inst✝ : Category.{v₂, u₂} C
I : Type u₁
F : I → C
i : Discrete I
f : i ⟶ i
⊢ (functor F).map f = 𝟙 (F i.as)
state_after: no goals
tactic: aesop_cat
Theorem: ite_add
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : Mul α
P : Prop
inst✝ : Decidable P
a b c : α
⊢ (if P then a else b) * c = if P then a * c else b * c
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: MulAction.set_mem_fixedBy_of_movedBy_subset
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
⊢ s ∈ fixedBy (Set α) g
state_after: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
⊢ s ∈ fixedBy (Set α) g⁻¹
tactic: rw [← fixedBy_inv]
state_before: α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
⊢ s ∈ fixedBy (Set α) g⁻¹
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
⊢ a ∈ g⁻¹ • s ↔ a ∈ s
tactic: ext a
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
⊢ a ∈ g⁻¹ • s ↔ a ∈ s
state_after: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
⊢ g • a ∈ s ↔ a ∈ s
tactic: rw [Set.mem_inv_smul_set_iff]
state_before: case h
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
⊢ g • a ∈ s ↔ a ∈ s
state_after: case pos
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
h✝ : a ∈ fixedBy α g
⊢ g • a ∈ s ↔ a ∈ s

case neg
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
h✝ : a ∉ fixedBy α g
⊢ g • a ∈ s ↔ a ∈ s
tactic: by_cases a ∈ fixedBy α g
state_before: case pos
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
h✝ : a ∈ fixedBy α g
⊢ g • a ∈ s ↔ a ∈ s

case neg
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
h✝ : a ∉ fixedBy α g
⊢ g • a ∈ s ↔ a ∈ s
state_after: case neg
α : Type u_1
G : Type u_2
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u_3
inst✝¹ : Monoid M
inst✝ : MulAction M α
s : Set α
g : G
s_subset : (fixedBy α g)ᶜ ⊆ s
a : α
h✝ : a ∉ fixedBy α g
⊢ g • a ∈ s ↔ a ∈ s
tactic: case pos a_fixed =>
    rw [a_fixed]
Theorem: Finset.uIcc_injective_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : (fun b => [[b, a]]) b = (fun b => [[b, a]]) c
⊢ b = c
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : ∀ (a_1 : α), a_1 ∈ (fun b => [[b, a]]) b ↔ a_1 ∈ (fun b => [[b, a]]) c
⊢ b = c
tactic: rw [ext_iff] at h
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b✝ b₁ b₂ c✝ x a b c : α
h : ∀ (a_1 : α), a_1 ∈ (fun b => [[b, a]]) b ↔ a_1 ∈ (fun b => [[b, a]]) c
⊢ b = c
state_after: no goals
tactic: exact eq_of_mem_uIcc_of_mem_uIcc ((h _).1 left_mem_uIcc) ((h _).2 left_mem_uIcc)
Theorem: Fintype.card_of_subtype
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset α
H : ∀ (x : α), x ∈ s ↔ p x
inst✝ : Fintype { x // p x }
⊢ card { x // p x } = s.card
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset α
H : ∀ (x : α), x ∈ s ↔ p x
inst✝ : Fintype { x // p x }
⊢ card { x // p x } = card { x // p x }
tactic: rw [← subtype_card s H]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
s : Finset α
H : ∀ (x : α), x ∈ s ↔ p x
inst✝ : Fintype { x // p x }
⊢ card { x // p x } = card { x // p x }
state_after: no goals
tactic: congr!
Theorem: IsUltrametricDist.mem_ball_iff
File: Mathlib/Topology/MetricSpace/Ultra/Basic.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : PseudoMetricSpace X
inst✝ : IsUltrametricDist X
x✝ y✝ z : X
r✝ s : ℝ
x y : X
r : ℝ
⊢ y ∈ ball x r ↔ x ∈ ball y r
state_after: no goals
tactic: cases lt_or_le 0 r with
  | inl hr =>
    constructor <;> intro h <;>
    rw [← ball_eq_of_mem h] <;>
    simp [hr]
  | inr hr => simp [ball_eq_empty.mpr hr]