ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ENNReal.ofReal_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x p : ℝ
hx_pos : 0 < x
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)
state_after: x p : ℝ
hx_pos : 0 < x
⊢ ↑x.toNNReal ^ p = ↑(x ^ p).toNNReal
tactic: simp_rw [ENNReal.ofReal]
state_before: x p : ℝ
hx_pos : 0 < x
⊢ ↑x.toNNReal ^ p = ↑(x ^ p).toNNReal
state_after: case h
x p : ℝ
hx_pos : 0 < x
⊢ x.toNNReal ≠ 0
tactic: rw [coe_rpow_of_ne_zero, coe_inj, Real.toNNReal_rpow_of_nonneg hx_pos.le]
state_before: case h
x p : ℝ
hx_pos : 0 < x
⊢ x.toNNReal ≠ 0
state_after: no goals
tactic: simp [hx_pos]
Theorem: EMetric.diam_pos_iff'
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
⊢ 0 < diam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y
state_after: no goals
tactic: simp only [diam_pos_iff, Set.Nontrivial, exists_prop]
Theorem: Summable.mul_of_nonneg
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝ : NormedRing R
f : ι → ℝ
g : ι' → ℝ
hf : Summable f
hg : Summable g
hf' : 0 ≤ f
hg' : 0 ≤ g
⊢ Summable fun x => ∑' (y : ι'), f (x, y).1 * g (x, y).2
state_after: no goals
tactic: simpa only [hg.tsum_mul_left _] using hf.mul_right (∑' x, g x)
Theorem: Quandle.dihedralAct.inv
File: Mathlib/Algebra/Quandle.lean

Proof steps:
state_before: Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a : ZMod n
⊢ Function.Involutive (dihedralAct n a)
state_after: Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ dihedralAct n a (dihedralAct n a b) = b
tactic: intro b
state_before: Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ dihedralAct n a (dihedralAct n a b) = b
state_after: Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ 2 * a - (2 * a - b) = b
tactic: dsimp only [dihedralAct]
state_before: Q : Type u_1
inst✝ : Quandle Q
n : ℕ
a b : ZMod n
⊢ 2 * a - (2 * a - b) = b
state_after: no goals
tactic: simp
Theorem: Subgroup.smul_inf
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S✝ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Group α
inst✝ : MulDistribMulAction α G
a : α
S T : Subgroup G
⊢ a • (S ⊓ T) = a • S ⊓ a • T
state_after: no goals
tactic: simp [SetLike.ext_iff, mem_pointwise_smul_iff_inv_smul_mem]
Theorem: IsUnit.mem_submonoid_iff
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

Proof steps:
state_before: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ submonoid M ↔ IsUnit a
state_after: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ setOf IsUnit ↔ IsUnit a
tactic: change a ∈ setOf IsUnit ↔ IsUnit a
state_before: M✝ : Type u_1
N : Type u_2
A : Type u_3
inst✝² : Monoid M✝
inst✝¹ : Monoid N
s : Set M✝
M : Type u_4
inst✝ : Monoid M
a : M
⊢ a ∈ setOf IsUnit ↔ IsUnit a
state_after: no goals
tactic: rw [Set.mem_setOf_eq]
Theorem: Multiset.le_iff_count
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
al : ∀ (a : α), count a s ≤ count a t
⊢ s ≤ t
state_after: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
al : ∀ (a : α), count a s ≤ count a t
⊢ s ≤ s ∪ t
tactic: rw [← (ext.2 fun a => by simp [max_eq_right (al a)] : s ∪ t = t)]
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ s t : Multiset α
al : ∀ (a : α), count a s ≤ count a t
⊢ s ≤ s ∪ t
state_after: no goals
tactic: apply le_union_left
Theorem: CategoryTheory.IsPullback.isoIsPullback_inv_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
P' : C
fst' : P' ⟶ X
snd' : P' ⟶ Y
h : IsPullback fst snd f g
h' : IsPullback fst' snd' f g
⊢ (isoIsPullback X Y h h').inv ≫ fst = fst'
state_after: no goals
tactic: simp only [Iso.inv_comp_eq, isoIsPullback_hom_fst]
Theorem: PartialHomeomorph.trans_ofSet
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
e' : PartialHomeomorph Y Z
s : Set Y
hs : IsOpen s
⊢ (e.trans (ofSet s hs)).source = (e.restr (↑e ⁻¹' s)).source
state_after: no goals
tactic: rw [trans_source, restr_source, ofSet_source, ← preimage_interior, hs.interior_eq]
Theorem: DihedralGroup.nat_card
File: Mathlib/GroupTheory/SpecificGroups/Dihedral.lean

Proof steps:
state_before: n : ℕ
⊢ Nat.card (DihedralGroup n) = 2 * n
state_after: case zero

⊢ Nat.card (DihedralGroup 0) = 2 * 0

case succ
n✝ : ℕ
⊢ Nat.card (DihedralGroup (n✝ + 1)) = 2 * (n✝ + 1)
tactic: cases n
Theorem: SeminormFamily.basisSets_iff
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕝 : Type u_3
𝕝₂ : Type u_4
E : Type u_5
F : Type u_6
G : Type u_7
ι : Type u_8
ι' : Type u_9
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U : Set E
⊢ U ∈ p.basisSets ↔ ∃ i r, 0 < r ∧ U = (i.sup p).ball 0 r
state_after: no goals
tactic: simp only [basisSets, mem_iUnion, exists_prop, mem_singleton_iff]
Theorem: Grp.hasLimit_iff_small_sections
File: Mathlib/Algebra/Category/Grp/Limits.lean

Proof steps:
state_before: J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ forget Grp).sections
state_after: case mp
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ HasLimit F → Small.{u, max u v} ↑(F ⋙ forget Grp).sections

case mpr
J : Type v
inst✝ : Category.{w, v} J
F : J ⥤ Grp
⊢ Small.{u, max u v} ↑(F ⋙ forget Grp).sections → HasLimit F
tactic: constructor
Theorem: Urysohns.CU.approx_of_nmem_U
File: Mathlib/Topology/UrysohnsLemma.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
n : ℕ
x : X
hx : x ∉ c.U
⊢ approx n c x = 1
state_after: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
hx : x ∉ c.U
⊢ approx 0 c x = 1

case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), x ∉ c.U → approx n c x = 1
c : CU P
hx : x ∉ c.U
⊢ approx (n + 1) c x = 1
tactic: induction' n with n ihn generalizing c
Theorem: Ideal.IsPrime.mem_of_pow_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : I.IsPrime
r : α
n : ℕ
H : r ^ n ∈ I
⊢ r ∈ I
state_after: case zero
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : I.IsPrime
r : α
H : r ^ 0 ∈ I
⊢ r ∈ I

case succ
α : Type u
β : Type v
inst✝ : Semiring α
I✝ : Ideal α
a b : α
I : Ideal α
hI : I.IsPrime
r : α
n : ℕ
ih : r ^ n ∈ I → r ∈ I
H : r ^ (n + 1) ∈ I
⊢ r ∈ I
tactic: induction' n with n ih
Theorem: Set.card_div_le
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
⊢ Nat.card ↑(s / t) ≤ Nat.card ↑s * Nat.card ↑t
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
⊢ Nat.card ↑(s * t⁻¹) ≤ Nat.card ↑s * Nat.card ↑t⁻¹
tactic: rw [div_eq_mul_inv, ← card_inv t]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : Group α
s t : Set α
⊢ Nat.card ↑(s * t⁻¹) ≤ Nat.card ↑s * Nat.card ↑t⁻¹
state_after: no goals
tactic: exact card_mul_le
Theorem: ENNReal.toNNReal_sSup
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
state_after: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
hf : ∀ (i : { x // x ∈ s }), ↑i ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
tactic: have hf : ∀ i, ((↑) : s → ℝ≥0∞) i ≠ ∞ := fun ⟨r, rs⟩ => hs r rs
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
s : Set ℝ≥0∞
hs : ∀ r ∈ s, r ≠ ⊤
hf : ∀ (i : { x // x ∈ s }), ↑i ≠ ⊤
⊢ (sSup s).toNNReal = sSup (ENNReal.toNNReal '' s)
state_after: no goals
tactic: simpa only [← sSup_range, ← image_eq_range, Subtype.range_coe_subtype] using (toNNReal_iSup hf)
Theorem: CategoryTheory.ComposableArrows.mk₄_surjective
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 4
⊢ X.map' 0 1 ⋯ ⋯ =
    eqToHom ⋯ ≫ (mk₄ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯)).map' 0 1 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 4
⊢ X.map' 1 2 ⋯ ⋯ =
    eqToHom ⋯ ≫ (mk₄ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯)).map' 1 2 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 4
⊢ X.map' 2 3 ⋯ ⋯ =
    eqToHom ⋯ ≫ (mk₄ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯)).map' 2 3 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F G : ComposableArrows C n
X : ComposableArrows C 4
⊢ X.map' 3 4 ⋯ ⋯ =
    eqToHom ⋯ ≫ (mk₄ (X.map' 0 1 ⋯ ⋯) (X.map' 1 2 ⋯ ⋯) (X.map' 2 3 ⋯ ⋯) (X.map' 3 4 ⋯ ⋯)).map' 3 4 ⋯ ⋯ ≫ eqToHom ⋯
state_after: no goals
tactic: simp
Theorem: PiNat.firstDiff_le_longestPrefix
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ firstDiff x y ≤ longestPrefix x s
state_after: E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ firstDiff x y + 1 ≤ shortestPrefixDiff x s

E : ℕ → Type u_1
inst✝¹ : (n : ℕ) → TopologicalSpace (E n)
inst✝ : ∀ (n : ℕ), DiscreteTopology (E n)
s : Set ((n : ℕ) → E n)
hs : IsClosed s
x y : (n : ℕ) → E n
hx : x ∉ s
hy : y ∈ s
⊢ 1 ≤ shortestPrefixDiff x s
tactic: rw [longestPrefix, le_tsub_iff_right]
Theorem: LieSubalgebra.lieSpan_mono
File: Mathlib/Algebra/Lie/Subalgebra.lean

Proof steps:
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ lieSpan R L s ≤ lieSpan R L t
state_after: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)
tactic: rw [lieSpan_le]
state_before: R : Type u
L : Type v
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
L₂ : Type w
inst✝¹ : LieRing L₂
inst✝ : LieAlgebra R L₂
f : L →ₗ⁅R⁆ L₂
K K' : LieSubalgebra R L
K₂ : LieSubalgebra R L₂
s t : Set L
h : s ⊆ t
⊢ s ⊆ ↑(lieSpan R L t)
state_after: no goals
tactic: exact Set.Subset.trans h subset_lieSpan
Theorem: Polynomial.degree_div_le
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
⊢ (p / q).degree ≤ p.degree
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : q = 0
⊢ (p / q).degree ≤ p.degree

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
hq : ¬q = 0
⊢ (p / q).degree ≤ p.degree
tactic: by_cases hq : q = 0
Theorem: Finset.insert_erase
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
x : α
⊢ x ∈ insert a (s.erase a) ↔ x ∈ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
x : α
⊢ x = a ∨ x ∈ s ↔ x ∈ s
tactic: simp only [mem_insert, mem_erase, or_and_left, dec_em, true_and_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
x : α
⊢ x = a ∨ x ∈ s ↔ x ∈ s
state_after: case ha
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
x : α
⊢ x = a → x ∈ s
tactic: apply or_iff_right_of_imp
state_before: case ha
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
x : α
⊢ x = a → x ∈ s
state_after: case ha
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
b x : α
h : x ∈ s
⊢ x ∈ s
tactic: rintro rfl
state_before: case ha
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
b x : α
h : x ∈ s
⊢ x ∈ s
state_after: no goals
tactic: exact h
Theorem: MeasureTheory.Integrable.re_im_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
⊢ Integrable (fun x => RCLike.re (f x)) μ ∧ Integrable (fun x => RCLike.im (f x)) μ ↔ Integrable f μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
⊢ Memℒp (fun x => RCLike.re (f x)) 1 μ ∧ Memℒp (fun x => RCLike.im (f x)) 1 μ ↔ Memℒp f 1 μ
tactic: simp_rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_5
inst✝ : RCLike 𝕜
f : α → 𝕜
⊢ Memℒp (fun x => RCLike.re (f x)) 1 μ ∧ Memℒp (fun x => RCLike.im (f x)) 1 μ ↔ Memℒp f 1 μ
state_after: no goals
tactic: exact memℒp_re_im_iff
Theorem: List.countP_eq_zero
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
⊢ countP p l = 0 ↔ ∀ (a : α), a ∈ l → ¬p a = true
state_after: no goals
tactic: simp only [countP_eq_length_filter, length_eq_zero, filter_eq_nil]
Theorem: LipschitzWith.mk_one
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
h : ∀ (x y : α), dist (f x) (f y) ≤ dist x y
⊢ ∀ (x y : α), dist (f x) (f y) ≤ ↑1 * dist x y
state_after: no goals
tactic: simpa only [NNReal.coe_one, one_mul] using h
Theorem: MulEquiv.toSingleObjEquiv_unitIso_hom
File: Mathlib/CategoryTheory/SingleObj.lean

Proof steps:
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ 𝟭 (SingleObj M) = e.toMonoidHom.toFunctor ⋙ e.symm.toMonoidHom.toFunctor
state_after: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (MonoidHom.id M).toFunctor = (e.symm.toMonoidHom.comp e.toMonoidHom).toFunctor
tactic: rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (MonoidHom.id M).toFunctor = (e.symm.toMonoidHom.comp e.toMonoidHom).toFunctor
state_after: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ MonoidHom.id M = e.symm.toMonoidHom.comp e.toMonoidHom
tactic: congr 1
state_before: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ MonoidHom.id M = e.symm.toMonoidHom.comp e.toMonoidHom
state_after: no goals
tactic: aesop_cat
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.symm.toMonoidHom.toFunctor ⋙ e.toMonoidHom.toFunctor = 𝟭 (SingleObj N)
state_after: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (e.toMonoidHom.comp e.symm.toMonoidHom).toFunctor = (MonoidHom.id N).toFunctor
tactic: rw [← MonoidHom.comp_toFunctor, ← MonoidHom.id_toFunctor]
state_before: M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ (e.toMonoidHom.comp e.symm.toMonoidHom).toFunctor = (MonoidHom.id N).toFunctor
state_after: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.toMonoidHom.comp e.symm.toMonoidHom = MonoidHom.id N
tactic: congr 1
state_before: case e_f
M : Type u
N : Type v
inst✝¹ : Monoid M
inst✝ : Monoid N
e : M ≃* N
⊢ e.toMonoidHom.comp e.symm.toMonoidHom = MonoidHom.id N
state_after: no goals
tactic: aesop_cat
Theorem: mem_closure_iff_nhds_basis'
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p✝ p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
p : ι → Prop
s : ι → Set X
h : (𝓝 x).HasBasis p s
⊢ (∀ ⦃i : ι⦄, p i → ∀ ⦃j : Unit⦄, True → (s i ∩ t).Nonempty) ↔ ∀ (i : ι), p i → (s i ∩ t).Nonempty
state_after: no goals
tactic: simp only [exists_prop, forall_const]
Theorem: FirstOrder.Language.LHom.id_onBoundedFormula
File: Mathlib/ModelTheory/Syntax.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
⊢ (LHom.id L).onBoundedFormula = id
state_after: case h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
f : L.BoundedFormula α n
⊢ (LHom.id L).onBoundedFormula f = id f
tactic: ext f
state_before: case h
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
f : L.BoundedFormula α n
⊢ (LHom.id L).onBoundedFormula f = id f
state_after: case h.falsum
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n n✝ : ℕ
⊢ (LHom.id L).onBoundedFormula falsum = id falsum

case h.equal
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n n✝ : ℕ
t₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)
⊢ (LHom.id L).onBoundedFormula (equal t₁✝ t₂✝) = id (equal t₁✝ t₂✝)

case h.rel
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n n✝ l✝ : ℕ
R✝ : L.Relations l✝
ts✝ : Fin l✝ → L.Term (α ⊕ Fin n✝)
⊢ (LHom.id L).onBoundedFormula (rel R✝ ts✝) = id (rel R✝ ts✝)

case h.imp
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n n✝ : ℕ
f₁✝ f₂✝ : L.BoundedFormula α n✝
ih1 : (LHom.id L).onBoundedFormula f₁✝ = id f₁✝
ih2 : (LHom.id L).onBoundedFormula f₂✝ = id f₂✝
⊢ (LHom.id L).onBoundedFormula (f₁✝.imp f₂✝) = id (f₁✝.imp f₂✝)

case h.all
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n n✝ : ℕ
f✝ : L.BoundedFormula α (n✝ + 1)
ih3 : (LHom.id L).onBoundedFormula f✝ = id f✝
⊢ (LHom.id L).onBoundedFormula f✝.all = id f✝.all
tactic: induction' f with _ _ _ _ _ _ _ _ _ _ _ ih1 ih2 _ _ ih3
Theorem: ContinuousMultilinearMap.nnnorm_smulRight
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 E 𝕜
z : G
⊢ ‖f.smulRight z‖₊ = ‖f‖₊ * ‖z‖₊
state_after: case refine_1
𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 E 𝕜
z : G
⊢ ‖f.smulRight z‖₊ ≤ ‖f‖₊ * ‖z‖₊

case refine_2
𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : ContinuousMultilinearMap 𝕜 E 𝕜
z : G
⊢ ‖f‖₊ * ‖z‖₊ ≤ ‖f.smulRight z‖₊
tactic: refine le_antisymm ?_ ?_
Theorem: isBigO_deriv_rpow_const_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

Proof steps:
state_before: f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)
state_after: case inl
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
⊢ (deriv fun x => x ^ 0) =O[atTop] fun x => x ^ (0 - 1)

case inr
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)
tactic: rcases eq_or_ne p 0 with rfl | hp
state_before: case inl
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
⊢ (deriv fun x => x ^ 0) =O[atTop] fun x => x ^ (0 - 1)

case inr
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)
state_after: case inr
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)
tactic: case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
state_before: case inr
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)
state_after: no goals
tactic: case inr =>
    exact (isTheta_deriv_rpow_const_atTop hp).1