ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Int.mem_box
File: Mathlib/Order/Interval/Finset/Box.lean

Proof steps:
state_before: n : ℕ
x : ℤ × ℤ
⊢ x ∈ box 0 ↔ max x.1.natAbs x.2.natAbs = 0
state_after: no goals
tactic: simp [Prod.ext_iff]
state_before: n✝ : ℕ
x : ℤ × ℤ
n : ℕ
⊢ x ∈ box (n + 1) ↔ max x.1.natAbs x.2.natAbs = n + 1
state_after: n✝ : ℕ
x : ℤ × ℤ
n : ℕ
⊢ ((-1 ≤ x.1 + ↑n ∧ -1 ≤ x.2 + ↑n) ∧ x.1 ≤ ↑n + 1 ∧ x.2 ≤ ↑n + 1) ∧ (-↑n ≤ x.1 → -↑n ≤ x.2 → x.1 ≤ ↑n → ↑n < x.2) ↔
    max x.1.natAbs x.2.natAbs = n + 1
tactic: simp [box_succ_eq_sdiff, Prod.le_def]
state_before: n✝ : ℕ
x : ℤ × ℤ
n : ℕ
⊢ ((-1 ≤ x.1 + ↑n ∧ -1 ≤ x.2 + ↑n) ∧ x.1 ≤ ↑n + 1 ∧ x.2 ≤ ↑n + 1) ∧ (-↑n ≤ x.1 → -↑n ≤ x.2 → x.1 ≤ ↑n → ↑n < x.2) ↔
    max x.1.natAbs x.2.natAbs = n + 1
state_after: n✝ : ℕ
x : ℤ × ℤ
n : ℕ
this : ↑n = ↑n
⊢ ((-1 ≤ x.1 + ↑n ∧ -1 ≤ x.2 + ↑n) ∧ x.1 ≤ ↑n + 1 ∧ x.2 ≤ ↑n + 1) ∧ (-↑n ≤ x.1 → -↑n ≤ x.2 → x.1 ≤ ↑n → ↑n < x.2) ↔
    max x.1.natAbs x.2.natAbs = n + 1
tactic: have : @Nat.cast ℤ instNatCastInt n = @Nat.cast ℤ AddMonoidWithOne.toNatCast n := rfl
state_before: n✝ : ℕ
x : ℤ × ℤ
n : ℕ
this : ↑n = ↑n
⊢ ((-1 ≤ x.1 + ↑n ∧ -1 ≤ x.2 + ↑n) ∧ x.1 ≤ ↑n + 1 ∧ x.2 ≤ ↑n + 1) ∧ (-↑n ≤ x.1 → -↑n ≤ x.2 → x.1 ≤ ↑n → ↑n < x.2) ↔
    max x.1.natAbs x.2.natAbs = n + 1
state_after: no goals
tactic: omega
Theorem: Filter.subsingleton_iff_exists_le_pure
File: Mathlib/Order/Filter/Subsingleton.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
inst✝ : Nonempty α
⊢ l.Subsingleton ↔ ∃ a, l ≤ pure a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : Nonempty α
⊢ ⊥.Subsingleton ↔ ∃ a, ⊥ ≤ pure a

case inr
α : Type u_1
β : Type u_2
l : Filter α
inst✝ : Nonempty α
hbot : l.NeBot
⊢ l.Subsingleton ↔ ∃ a, l ≤ pure a
tactic: rcases eq_or_neBot l with rfl | hbot
Theorem: MvPolynomial.rename_monomial
File: Mathlib/Algebra/MvPolynomial/Rename.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ (rename f) ((monomial d) r) = (monomial (Finsupp.mapDomain f d)) r
state_after: σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ((algebraMap R (MvPolynomial τ R)) r * d.prod fun i k => (X ∘ f) i ^ k) = C r * d.prod fun a m => X (f a) ^ m

case h_zero
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ), X b ^ 0 = 1

case h_add
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : σ → τ
d : σ →₀ ℕ
r : R
⊢ ∀ (b : τ) (m₁ m₂ : ℕ), X b ^ (m₁ + m₂) = X b ^ m₁ * X b ^ m₂
tactic: rw [rename, aeval_monomial, monomial_eq (s := Finsupp.mapDomain f d),
    Finsupp.prod_mapDomain_index]
Theorem: Complex.im_eq_sub_conj
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ ↑z.im = (z - (starRingEnd ℂ) z) / (2 * I)
state_after: no goals
tactic: simp only [sub_conj, ofReal_mul, ofReal_ofNat, mul_right_comm,
    mul_div_cancel_left₀ _ (mul_ne_zero two_ne_zero I_ne_zero : 2 * I ≠ 0)]
Theorem: Polynomial.smeval_assoc_X_pow
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Semiring R
p✝ : R[X]
r : R
p q : R[X]
S : Type u_2
inst✝⁵ : NonAssocSemiring S
inst✝⁴ : Module R S
inst✝³ : IsScalarTower R S S
inst✝² : SMulCommClass R S S
inst✝¹ : Pow S ℕ
inst✝ : NatPowAssoc S
x : S
m n : ℕ
⊢ p.smeval x * x ^ m * x ^ n = p.smeval x * (x ^ m * x ^ n)
state_after: no goals
tactic: induction p using Polynomial.induction_on' with
  | h_add p q ph qh =>
    simp only [smeval_add, ph, qh, add_mul]
  | h_monomial n a =>
    rw [smeval_monomial, smul_mul_assoc, smul_mul_assoc, npow_mul_assoc, ← smul_mul_assoc]
Theorem: List.map_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
β : Type u_1
n : ℕ
f : Fin n → α
g : α → β
⊢ (map g (ofFn f)).length = (ofFn (g ∘ f)).length
state_after: no goals
tactic: simp
state_before: α : Type u
β : Type u_1
n : ℕ
f : Fin n → α
g : α → β
i : ℕ
h : i < (map g (ofFn f)).length
h' : i < (ofFn (g ∘ f)).length
⊢ (map g (ofFn f)).get ⟨i, h⟩ = (ofFn (g ∘ f)).get ⟨i, h'⟩
state_after: no goals
tactic: simp
Theorem: ContinuousMap.Homotopic.equivalence
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'
⊢ ∀ {x y : C(X, Y)}, x.Homotopic y → y.Homotopic x
state_after: no goals
tactic: apply symm
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'
⊢ ∀ {x y z : C(X, Y)}, x.Homotopic y → y.Homotopic z → x.Homotopic z
state_after: no goals
tactic: apply trans
Theorem: Complex.GammaAux_recurrence1
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℂ
n : ℕ
h1 : -s.re < ↑n
⊢ GammaAux n s = GammaAux n (s + 1) / s
state_after: case zero
s : ℂ
h1 : -s.re < ↑0
⊢ GammaAux 0 s = GammaAux 0 (s + 1) / s

case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ GammaAux (n + 1) s = GammaAux (n + 1) (s + 1) / s
tactic: induction' n with n hn generalizing s
Theorem: MeasureTheory.SimpleFunc.range_const
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : MeasurableSpace α✝
α : Type u_5
inst✝¹ : MeasurableSpace α
inst✝ : Nonempty α
b : β
⊢ ↑(const α b).range = ↑{b}
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) [Function.const]
Theorem: Finite.exists_ne_map_eq_of_infinite
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝¹ : Infinite α
inst✝ : Finite β
f : α → β
⊢ ∃ x y, x ≠ y ∧ f x = f y
state_after: no goals
tactic: simpa [Injective, and_comm] using not_injective_infinite_finite f
Theorem: Filter.eventuallyConst_atTop
File: Mathlib/Order/Filter/EventuallyConst.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
l : Filter α
f : α → β
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
⊢ (∃ i, True ∧ ∀ y ∈ Ici i, f y = f i) ↔ ∃ i, ∀ (j : α), i ≤ j → f j = f i
state_after: no goals
tactic: simp only [true_and, mem_Ici]
Theorem: ZMod.eisenstein_lemma
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
a : ℕ
ha1 : a % 2 = 1
ha0 : ↑a ≠ 0
⊢ legendreSym p ↑a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
a : ℕ
ha1 : a % 2 = 1
ha0 : ↑a ≠ 0
hp' : Fact (p % 2 = 1)
⊢ legendreSym p ↑a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p
tactic: haveI hp' : Fact (p % 2 = 1) := ⟨Nat.Prime.mod_two_eq_one_iff_ne_two.mpr hp⟩
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
a : ℕ
ha1 : a % 2 = 1
ha0 : ↑a ≠ 0
hp' : Fact (p % 2 = 1)
⊢ legendreSym p ↑a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
a : ℕ
ha1 : a % 2 = 1
ha0 : ↑a ≠ 0
hp' : Fact (p % 2 = 1)
ha0' : ↑↑a ≠ 0
⊢ legendreSym p ↑a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p
tactic: have ha0' : ((a : ℤ) : ZMod p) ≠ 0 := by norm_cast
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp : p ≠ 2
a : ℕ
ha1 : a % 2 = 1
ha0 : ↑a ≠ 0
hp' : Fact (p % 2 = 1)
ha0' : ↑↑a ≠ 0
⊢ legendreSym p ↑a = (-1) ^ ∑ x ∈ Ico 1 (p / 2).succ, x * a / p
state_after: no goals
tactic: rw [neg_one_pow_eq_pow_mod_two, gauss_lemma hp ha0', neg_one_pow_eq_pow_mod_two,
    (by norm_cast : ((a : ℤ) : ZMod p) = (a : ZMod p)),
    show _ = _ from eisenstein_lemma_aux p ha1 ha0]
Theorem: CategoryTheory.CostructuredArrow.unop_left_comp_ofMkLEMk_unop
File: Mathlib/CategoryTheory/Subobject/Comma.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
g : Q ⟶ op A
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
g : Q ⟶ op A
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left.op.unop ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left
tactic: conv_lhs =>
    congr
    rw [← Quiver.Hom.unop_op g.unop.left]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
g : Q ⟶ op A
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ g.unop.left.op.unop ≫ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h).unop = f.unop.left
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
g : Q ⟶ op A
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h ≫ g.unop.left.op).unop = f.unop.left
tactic: rw [← unop_comp]
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
A : CostructuredArrow S T
P Q : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
g : Q ⟶ op A
inst✝¹ : Mono f.unop.left.op
inst✝ : Mono g.unop.left.op
h : Subobject.mk f.unop.left.op ≤ Subobject.mk g.unop.left.op
⊢ (Subobject.ofMkLEMk f.unop.left.op g.unop.left.op h ≫ g.unop.left.op).unop = f.unop.left
state_after: no goals
tactic: simp only [Subobject.ofMkLEMk_comp, Quiver.Hom.unop_op]
Theorem: CategoryTheory.OplaxFunctor.mapComp_assoc_left
File: Mathlib/CategoryTheory/Bicategory/Functor/Oplax.lean

Proof steps:
state_before: B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F : OplaxFunctor B C
a b c d : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
⊢ F.mapComp (f ≫ g) h ≫ F.mapComp f g ▷ F.map h =
    F.map₂ (α_ f g h).hom ≫ F.mapComp f (g ≫ h) ≫ F.map f ◁ F.mapComp g h ≫ (α_ (F.map f) (F.map g) (F.map h)).inv
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofZeros_H
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ S.f ≫ 𝟙 S.X₂ = 0
state_after: no goals
tactic: rw [comp_id, hf]
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ (CokernelCofork.IsColimit.ofId S.f hf).desc (CokernelCofork.ofπ S.g ⋯) = 0
state_after: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ S.g = 0
tactic: change 𝟙 _ ≫ S.g = 0
state_before: C : Type u_1
inst✝¹ : Category.{?u.30360, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hf : S.f = 0
hg : S.g = 0
⊢ 𝟙 S.X₂ ≫ S.g = 0
state_after: no goals
tactic: simp only [hg, comp_zero]
Theorem: Submodule.mulLeftMap_apply_single
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: R : Type u_1
M✝ : Type u_2
N✝ : Type u_3
inst✝⁹ : Semiring R
inst✝⁸ : AddCommMonoid M✝
inst✝⁷ : Module R M✝
inst✝⁶ : AddCommMonoid N✝
inst✝⁵ : Module R N✝
S : Type u_4
inst✝⁴ : Semiring S
inst✝³ : Module R S
inst✝² : SMulCommClass R R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
M N : Submodule R S
ι : Type u_5
m : ι → ↥M
i : ι
n : ↥N
⊢ (mulLeftMap N m) (Finsupp.single i n) = ↑(m i) * ↑n
state_after: no goals
tactic: simp [mulLeftMap]
Theorem: ENNReal.log_mul_add
File: Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean

Proof steps:
state_before: x y : ℝ≥0∞
⊢ (x * y).log = x.log + y.log
state_after: case inl
y : ℝ≥0∞
⊢ (0 * y).log = log 0 + y.log

case inr.inl
y : ℝ≥0∞
⊢ (⊤ * y).log = ⊤.log + y.log

case inr.inr
x y : ℝ≥0∞
x_real : 0 < x.toReal
⊢ (x * y).log = x.log + y.log
tactic: rcases ENNReal.trichotomy x with (rfl | rfl | x_real)
Theorem: Finset.noncommSum_induction
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
⊢ p (s.noncommProd f comm)
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ p b
tactic: refine Multiset.noncommProd_induction _ _ _ hom unit fun b hb ↦ ?_
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
b : β
hb : b ∈ Multiset.map f s.val
⊢ p b
state_after: case intro.intro
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
a : α
ha : a ∈ s
hb : f a ∈ Multiset.map f s.val
⊢ p (f a)
tactic: obtain (⟨a, ha : a ∈ s, rfl : f a = b⟩) := by simpa using hb
state_before: case intro.intro
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : (↑s).Pairwise fun a b => Commute (f a) (f b)
p : β → Prop
hom : ∀ (a b : β), p a → p b → p (a * b)
unit : p 1
base : ∀ x ∈ s, p (f x)
a : α
ha : a ∈ s
hb : f a ∈ Multiset.map f s.val
⊢ p (f a)
state_after: no goals
tactic: exact base a ha
Theorem: dimH_subsingleton
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
⊢ dimH s = 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s = 0
tactic: borelize X
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s = 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s ≤ 0
tactic: apply le_antisymm _ (zero_le _)
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ dimH s ≤ 0
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ μH[↑0] s ≠ ⊤
tactic: refine dimH_le_of_hausdorffMeasure_ne_top ?_
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
s : Set X
h : s.Subsingleton
this✝¹ : MeasurableSpace X := borel X
this✝ : BorelSpace X
⊢ μH[↑0] s ≠ ⊤
state_after: no goals
tactic: exact ((hausdorffMeasure_le_one_of_subsingleton h le_rfl).trans_lt ENNReal.one_lt_top).ne
Theorem: Complex.IsExpCmpFilter.isLittleO_cpow_exp
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

Proof steps:
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ (fun z => Real.exp (a.re * Real.log (abs z))) =o[l] fun x => ‖cexp (↑b * x)‖
state_after: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => b * x.re - a.re * Real.log (abs x)) l atTop
tactic: simp only [norm_eq_abs, abs_exp, re_ofReal_mul, Real.isLittleO_exp_comp_exp_comp]
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ Tendsto (fun x => b * x.re - a.re * Real.log (abs x)) l atTop
state_after: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ (fun x => a.re * Real.log (abs x)) =o[l] fun x => b * x.re
tactic: refine (IsEquivalent.refl.sub_isLittleO ?_).symm.tendsto_atTop
          (hl.tendsto_re.const_mul_atTop hb)
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
a : ℂ
b : ℝ
hb : 0 < b
⊢ (fun x => a.re * Real.log (abs x)) =o[l] fun x => b * x.re
state_after: no goals
tactic: exact (hl.isLittleO_log_abs_re.const_mul_left _).const_mul_right hb.ne'
Theorem: CategoryTheory.BraidedFunctor.toLaxBraidedFunctor_toLaxMonoidalFunctor
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
F : BraidedFunctor C D
X Y : C
⊢ F.μ X Y ≫ F.map (β_ X Y).hom = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
state_after: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
F : BraidedFunctor C D
X Y : C
⊢ F.μ X Y ≫ inv (F.μ X Y) ≫ (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
tactic: rw [F.braided]
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
F : BraidedFunctor C D
X Y : C
⊢ F.μ X Y ≫ inv (F.μ X Y) ≫ (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X = (β_ (F.obj X) (F.obj Y)).hom ≫ F.μ Y X
state_after: no goals
tactic: simp
Theorem: Submodule.restrictScalars_span
File: Mathlib/Algebra/Algebra/Tower.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
⊢ restrictScalars R (span A X) = span R X
state_after: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m : M
hm : m ∈ restrictScalars R (span A X)
⊢ m ∈ span R X
tactic: refine ((span_le_restrictScalars R A X).antisymm fun m hm => ?_).symm
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m : M
hm : m ∈ restrictScalars R (span A X)
⊢ m ∈ span R X
state_after: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
a : A
m : M
hm : m ∈ span R X
⊢ a • m ∈ span R X
tactic: refine span_induction hm subset_span (zero_mem _) (fun _ _ => add_mem) fun a m hm => ?_
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
a : A
m : M
hm : m ∈ span R X
⊢ a • m ∈ span R X
state_after: case intro
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
m : M
hm : m ∈ span R X
r : R
⊢ (algebraMap R A) r • m ∈ span R X
tactic: obtain ⟨r, rfl⟩ := hsur a
state_before: case intro
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : Module A M
inst✝ : IsScalarTower R A M
hsur : Function.Surjective ⇑(algebraMap R A)
X : Set M
m✝ : M
hm✝ : m✝ ∈ restrictScalars R (span A X)
m : M
hm : m ∈ span R X
r : R
⊢ (algebraMap R A) r • m ∈ span R X
state_after: no goals
tactic: simpa [algebraMap_smul] using smul_mem _ r hm
Theorem: Asymptotics.isLittleO_pow_pow_atTop_of_lt
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ (fun x => x ^ p) =o[atTop] fun x => x ^ q
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ ∀ᶠ (x : 𝕜) in atTop, x ^ q = 0 → x ^ p = 0
tactic: refine (isLittleO_iff_tendsto' ?_).mpr (tendsto_pow_div_pow_atTop_zero hpq)
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
inst✝ : OrderTopology 𝕜
p q : ℕ
hpq : p < q
⊢ ∀ᶠ (x : 𝕜) in atTop, x ^ q = 0 → x ^ p = 0
state_after: no goals
tactic: exact (eventually_gt_atTop 0).mono fun x hx hxq => (pow_ne_zero q hx.ne' hxq).elim
Theorem: Nat.cast_tsub
File: Mathlib/Data/Nat/Cast/Order/Ring.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : CanonicallyOrderedCommSemiring α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
m n : ℕ
⊢ ↑(m - n) = ↑m - ↑n
state_after: case inl
α : Type u_1
β : Type u_2
inst✝³ : CanonicallyOrderedCommSemiring α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
m n : ℕ
h : m ≤ n
⊢ ↑(m - n) = ↑m - ↑n

case inr
α : Type u_1
β : Type u_2
inst✝³ : CanonicallyOrderedCommSemiring α
inst✝² : Sub α
inst✝¹ : OrderedSub α
inst✝ : ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
m n : ℕ
h : n ≤ m
⊢ ↑(m - n) = ↑m - ↑n
tactic: rcases le_total m n with h | h
Theorem: CategoryTheory.Idempotents.KaroubiKaroubi.inverse_obj_p
File: Mathlib/CategoryTheory/Idempotents/KaroubiKaroubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.1672, u_1} C
P : Karoubi (Karoubi C)
⊢ P.p.f ≫ P.p.f = P.p.f
state_after: no goals
tactic: simpa only [hom_ext_iff] using P.idem
state_before: C : Type u_1
inst✝ : Category.{?u.1672, u_1} C
X✝ Y✝ : Karoubi (Karoubi C)
f : X✝ ⟶ Y✝
⊢ f.f.f =
    ((fun P => { X := P.X.X, p := P.p.f, idem := ⋯ }) X✝).p ≫
      f.f.f ≫ ((fun P => { X := P.X.X, p := P.p.f, idem := ⋯ }) Y✝).p
state_after: no goals
tactic: simpa only [hom_ext_iff] using f.comm