ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Asymptotics.SuperpolynomialDecay.polynomial_mul
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝³ : TopologicalSpace β
inst✝² : CommSemiring β
inst✝¹ : ContinuousAdd β
inst✝ : ContinuousMul β
hf : SuperpolynomialDecay l k f
p✝ p q : β[X]
hp : SuperpolynomialDecay l k fun x => eval (k x) p * f x
hq : SuperpolynomialDecay l k fun x => eval (k x) q * f x
⊢ SuperpolynomialDecay l k fun x => eval (k x) (p + q) * f x
state_after: no goals
tactic: simpa [add_mul] using hp.add hq
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝³ : TopologicalSpace β
inst✝² : CommSemiring β
inst✝¹ : ContinuousAdd β
inst✝ : ContinuousMul β
hf : SuperpolynomialDecay l k f
p : β[X]
n : ℕ
c : β
⊢ SuperpolynomialDecay l k fun x => eval (k x) ((monomial n) c) * f x
state_after: no goals
tactic: simpa [mul_assoc] using (hf.param_pow_mul n).const_mul c
Theorem: PowerSeries.coeff_mul_X_pow'
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
p : R⟦X⟧
n d : ℕ
⊢ (coeff R d) (p * X ^ n) = if n ≤ d then (coeff R (d - n)) p else 0
state_after: case pos
R : Type u_1
inst✝ : Semiring R
p : R⟦X⟧
n d : ℕ
h : n ≤ d
⊢ (coeff R d) (p * X ^ n) = (coeff R (d - n)) p

case neg
R : Type u_1
inst✝ : Semiring R
p : R⟦X⟧
n d : ℕ
h : ¬n ≤ d
⊢ (coeff R d) (p * X ^ n) = 0
tactic: split_ifs with h
Theorem: pow_eq_pow_iff_modEq
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m n : ℕ
⊢ x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x]
state_after: case inr
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m n : ℕ
this : ∀ {m n : ℕ}, m ≤ n → (x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x])
hmn : ¬m ≤ n
⊢ x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x]

G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ m n : ℕ
hmn : m ≤ n
⊢ x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x]
tactic: wlog hmn : m ≤ n generalizing m n
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ m n : ℕ
hmn : m ≤ n
⊢ x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x]
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n m k : ℕ
hmn : m ≤ m + k
⊢ x ^ (m + k) = x ^ m ↔ m + k ≡ m [MOD orderOf x]
tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n m k : ℕ
hmn : m ≤ m + k
⊢ x ^ (m + k) = x ^ m ↔ m + k ≡ m [MOD orderOf x]
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n m k : ℕ
hmn : m ≤ m + k
⊢ k ≡ 0 [MOD orderOf x] ↔ m + k ≡ m [MOD orderOf x]
tactic: rw [← mul_one (x ^ m), pow_add, mul_left_cancel_iff, pow_eq_one_iff_modEq]
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n m k : ℕ
hmn : m ≤ m + k
⊢ k ≡ 0 [MOD orderOf x] ↔ m + k ≡ m [MOD orderOf x]
state_after: no goals
tactic: exact ⟨fun h => Nat.ModEq.add_left _ h, fun h => Nat.ModEq.add_left_cancel' _ h⟩
Theorem: Polynomial.derivative_comp
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]
⊢ derivative (p.comp q) = derivative q * (derivative p).comp q
state_after: case h_add
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
q p✝ q✝ : R[X]
a✝¹ : derivative (p✝.comp q) = derivative q * (derivative p✝).comp q
a✝ : derivative (q✝.comp q) = derivative q * (derivative q✝).comp q
⊢ derivative ((p✝ + q✝).comp q) = derivative q * (derivative (p✝ + q✝)).comp q

case h_monomial
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✝ : ℕ
a✝ : R
⊢ derivative (((monomial n✝) a✝).comp q) = derivative q * (derivative ((monomial n✝) a✝)).comp q
tactic: induction p using Polynomial.induction_on'
Theorem: Matrix.cons_val_succ
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin m → α
i : Fin m
⊢ vecCons x u i.succ = u i
state_after: no goals
tactic: simp [vecCons]
Theorem: AlgebraicGeometry.StructureSheaf.const_mul_cancel
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ const R f g₁ U hu₁ * const R g₁ g₂ U hu₂ = const R f g₂ U hu₂
state_after: case h
R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ f * g₁ * g₂ = f * (g₁ * g₂)
tactic: rw [const_mul, const_ext]
state_before: case h
R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ f * g₁ * g₂ = f * (g₁ * g₂)
state_after: no goals
tactic: rw [mul_assoc]
Theorem: Polynomial.toFinsupp_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q a : R[X]
n : ℕ
⊢ (a ^ n).toFinsupp = a.toFinsupp ^ n
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } ^ n).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp ^ n
tactic: cases a
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } ^ n).toFinsupp = { toFinsupp := toFinsupp✝ }.toFinsupp ^ n
state_after: no goals
tactic: rw [← ofFinsupp_pow]
Theorem: SemiconjBy.mul_left
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ SemiconjBy (a * b) x z
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Semigroup S
a b x y z x' y' : S
ha : SemiconjBy a y z
hb : SemiconjBy b x y
⊢ a * b * x = z * (a * b)
state_after: no goals
tactic: rw [mul_assoc, hb.eq, ← mul_assoc, ha.eq, mul_assoc]
Theorem: IsCoprime.add_mul_left_left
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
x y : R
h : IsCoprime x y
z : R
⊢ IsCoprime (x + y * z + y * -z) y
state_after: no goals
tactic: simpa only [mul_neg, add_neg_cancel_right] using h
Theorem: TensorProduct.piScalarRightHom_tmul
File: Mathlib/LinearAlgebra/TensorProduct/Pi.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommSemiring R
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : Module S N
inst✝ : IsScalarTower R S N
ι : Type u_4
x : N
f : ι → R
⊢ (piScalarRightHom R S N ι) (x ⊗ₜ[R] f) = fun j => f j • x
state_after: case h
R : Type u_1
inst✝⁶ : CommSemiring R
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : Module S N
inst✝ : IsScalarTower R S N
ι : Type u_4
x : N
f : ι → R
j : ι
⊢ (piScalarRightHom R S N ι) (x ⊗ₜ[R] f) j = f j • x
tactic: ext j
state_before: case h
R : Type u_1
inst✝⁶ : CommSemiring R
S : Type u_2
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra R S
N : Type u_3
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : Module S N
inst✝ : IsScalarTower R S N
ι : Type u_4
x : N
f : ι → R
j : ι
⊢ (piScalarRightHom R S N ι) (x ⊗ₜ[R] f) j = f j • x
state_after: no goals
tactic: simp [piScalarRightHom, piScalarRightHomBil]
Theorem: Finset.piFinset_filter_const
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝² : DecidableEq (ι → α)
s : Finset α
f : ι → α
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
⊢ filter (fun x => ∃ a ∈ s, const ι a = x) (Fintype.piFinset fun x => s) = s.piDiag ι
state_after: no goals
tactic: aesop
Theorem: Multiset.map_noncommSum
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 β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
f : F
⊢ f (s.noncommProd comm) = (map (⇑f) s).noncommProd ⋯
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
⊢ f (noncommProd ⟦a✝⟧ comm) = (map ⇑f ⟦a✝⟧).noncommProd ⋯
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : FunLike F α β
inst✝ : MonoidHomClass F α β
f : F
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
⊢ f (noncommProd ⟦a✝⟧ comm) = (map ⇑f ⟦a✝⟧).noncommProd ⋯
state_after: no goals
tactic: simpa using map_list_prod f _
Theorem: alexDiscEquivPreord_unitIso
File: Mathlib/Topology/Order/Category/AlexDisc.lean

Proof steps:
state_before: X : AlexDisc
⊢ ↑((𝟭 AlexDisc).obj X) ≃ₜ
    ↑(((forget₂ AlexDisc TopCat ⋙ topToPreord) ⋙
            { obj := fun X => AlexDisc.of (WithUpperSet ↑X), map := fun {X Y} => WithUpperSet.map, map_id := ⋯,
              map_comp := ⋯ }).obj
        X)
state_after: X : AlexDisc
⊢ ↑X ≃ₜ WithUpperSet (Specialization ↑X)
tactic: dsimp
state_before: X : AlexDisc
⊢ ↑X ≃ₜ WithUpperSet (Specialization ↑X)
state_after: no goals
tactic: exact homeoWithUpperSetTopologyorderIso X
state_before: X : Preord
⊢ ↑(({ obj := fun X => AlexDisc.of (WithUpperSet ↑X), map := fun {X Y} => WithUpperSet.map, map_id := ⋯,
              map_comp := ⋯ } ⋙
            forget₂ AlexDisc TopCat ⋙ topToPreord).obj
        X) ≃o
    ↑((𝟭 Preord).obj X)
state_after: X : Preord
⊢ Specialization (WithUpperSet ↑X) ≃o ↑X
tactic: dsimp
state_before: X : Preord
⊢ Specialization (WithUpperSet ↑X) ≃o ↑X
state_after: no goals
tactic: exact (orderIsoSpecializationWithUpperSetTopology X).symm
Theorem: Set.iInter₂_union
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋂ i, ⋂ j, s i j) ∪ t = ⋂ i, ⋂ j, s i j ∪ t
state_after: no goals
tactic: simp_rw [iInter_union]
Theorem: _private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.sups_aux
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : DistribLattice α
inst✝² : BoundedOrder α
inst✝¹ : DecidableEq α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a : α
⊢ a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure ↑s ∧ a ∈ upperClosure ↑t
state_after: no goals
tactic: rw [coe_sups, upperClosure_sups, UpperSet.mem_sup_iff]
Theorem: inv_pos_le_iff_one_le_mul
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ a⁻¹ ≤ b ↔ 1 ≤ b * a
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ b * a
tactic: rw [inv_eq_one_div]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
⊢ 1 / a ≤ b ↔ 1 ≤ b * a
state_after: no goals
tactic: exact div_le_iff ha
Theorem: Function.Surjective.wellFounded_iff
File: Mathlib/Order/RelIso/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a✝ b✝ : β
h : s a✝ b✝
⊢ r (surjInv hf a✝) (surjInv hf b✝)
state_after: no goals
tactic: simpa only [o, surjInv_eq hf] using h
Theorem: CategoryTheory.ShortComplex.FunctorEquivalence.counitIso_inv_app_app_τ₁
File: Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₁).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).f =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).f ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝¹ : J ⥤ ShortComplex C
x✝ : J
⊢ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₂).hom ≫ (((𝟭 (J ⥤ ShortComplex C)).obj x✝¹).obj x✝).g =
    (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).g ≫ (Iso.refl (((inverse J C ⋙ functor J C).obj x✝¹).obj x✝).X₃).hom
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
x✝ : J ⥤ ShortComplex C
⊢ ∀ {X Y : J} (f : X ⟶ Y),
    ((inverse J C ⋙ functor J C).obj x✝).map f ≫
        ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            Y).hom =
      ((fun x =>
              isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₁)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₂)
                (Iso.refl (((inverse J C ⋙ functor J C).obj x✝).obj x).X₃) ⋯ ⋯)
            X).hom ≫
        ((𝟭 (J ⥤ ShortComplex C)).obj x✝).map f
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.66473, u_1} J
inst✝¹ : Category.{?u.66477, u_2} C
inst✝ : HasZeroMorphisms C
⊢ ∀ {X Y : J ⥤ ShortComplex C} (f : X ⟶ Y),
    (inverse J C ⋙ functor J C).map f ≫
        ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            Y).hom =
      ((fun x =>
              NatIso.ofComponents
                (fun x_1 =>
                  isoMk (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₁)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₂)
                    (Iso.refl (((inverse J C ⋙ functor J C).obj x).obj x_1).X₃) ⋯ ⋯)
                ⋯)
            X).hom ≫
        (𝟭 (J ⥤ ShortComplex C)).map f
state_after: no goals
tactic: aesop_cat
Theorem: LipschitzWith.cauchySeq_comp
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 : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
⊢ CauchySeq (f ∘ u)
state_after: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
b : ℕ → ℝ
b_nonneg : ∀ (n : ℕ), 0 ≤ b n
hb : ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist (u n) (u m) ≤ b N
blim : Tendsto b atTop (𝓝 0)
⊢ CauchySeq (f ∘ u)
tactic: rcases cauchySeq_iff_le_tendsto_0.1 hu with ⟨b, b_nonneg, hb, blim⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
b : ℕ → ℝ
b_nonneg : ∀ (n : ℕ), 0 ≤ b n
hb : ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist (u n) (u m) ≤ b N
blim : Tendsto b atTop (𝓝 0)
⊢ CauchySeq (f ∘ u)
state_after: case intro.intro.intro.refine_1
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
b : ℕ → ℝ
b_nonneg : ∀ (n : ℕ), 0 ≤ b n
hb : ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist (u n) (u m) ≤ b N
blim : Tendsto b atTop (𝓝 0)
⊢ ∀ (n : ℕ), 0 ≤ (fun n => ↑K * b n) n

case intro.intro.intro.refine_2
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
b : ℕ → ℝ
b_nonneg : ∀ (n : ℕ), 0 ≤ b n
hb : ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist (u n) (u m) ≤ b N
blim : Tendsto b atTop (𝓝 0)
⊢ ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist ((f ∘ u) n) ((f ∘ u) m) ≤ (fun n => ↑K * b n) N

case intro.intro.intro.refine_3
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f : α → β
x y : α
r : ℝ
hf : LipschitzWith K f
u : ℕ → α
hu : CauchySeq u
b : ℕ → ℝ
b_nonneg : ∀ (n : ℕ), 0 ≤ b n
hb : ∀ (n m N : ℕ), N ≤ n → N ≤ m → dist (u n) (u m) ≤ b N
blim : Tendsto b atTop (𝓝 0)
⊢ Tendsto (fun n => ↑K * b n) atTop (𝓝 0)
tactic: refine cauchySeq_iff_le_tendsto_0.2 ⟨fun n ↦ K * b n, ?_, ?_, ?_⟩
Theorem: Finset.sigmaLift_eq_empty
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ sigmaLift f a b = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
state_after: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅) = ∅ ↔
    ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
tactic: simp_rw [sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅) = ∅ ↔
    ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
state_after: case pos
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : a.fst = b.fst
⊢ map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅

case neg
ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
h : ¬a.fst = b.fst
⊢ ∅ = ∅ ↔ ∀ (h : a.fst = b.fst), f (h ▸ a.snd) b.snd = ∅
tactic: split_ifs with h
Theorem: Pell.xn_one
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
⊢ xn a1 1 = a
state_after: no goals
tactic: simp
Theorem: csSup_Iio
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝² : ConditionallyCompleteLattice α
s t : Set α
a b : α
inst✝¹ : NoMinOrder α
inst✝ : DenselyOrdered α
w : α
hw : w < a
⊢ ∃ a_1 ∈ Iio a, w < a_1
state_after: no goals
tactic: simpa [and_comm] using exists_between hw
Theorem: EReal.addLECancellable_coe
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x z : ℝ
h : ↑x + ⊤ ≤ ↑x + ↑z
⊢ ⊤ ≤ ↑z
state_after: no goals
tactic: simp only [coe_add_top, ← coe_add, top_le_iff, coe_ne_top] at h
state_before: x : ℝ
x✝ : EReal
h : ↑x + x✝ ≤ ↑x + ⊥
⊢ x✝ ≤ ⊥
state_after: no goals
tactic: simpa using h
state_before: x y z : ℝ
h : ↑x + ↑y ≤ ↑x + ↑z
⊢ ↑y ≤ ↑z
state_after: no goals
tactic: simpa only [← coe_add, EReal.coe_le_coe_iff, add_le_add_iff_left] using h
Theorem: Int.testBit_ldiff
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: m n : ℤ
k : ℕ
⊢ (m.ldiff n).testBit k = (m.testBit k && !n.testBit k)
state_after: no goals
tactic: rw [← bitwise_diff, testBit_bitwise]
Theorem: CliffordAlgebra.even.lift.aux_apply
File: Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean

Proof steps:
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : EvenHom Q A
⊢ ↥(even Q) →ₗ[R] A
state_after: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : EvenHom Q A
⊢ CliffordAlgebra Q →ₗ[R] A
tactic: refine ?_ ∘ₗ (even Q).val.toLinearMap
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : EvenHom Q A
⊢ CliffordAlgebra Q →ₗ[R] A
state_after: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : EvenHom Q A
this : AddCommGroup ↥(CliffordAlgebra.even.lift.S f) := AddSubgroupClass.toAddCommGroup (CliffordAlgebra.even.lift.S f)
⊢ CliffordAlgebra Q →ₗ[R] A
tactic: letI : AddCommGroup (S f) := AddSubgroupClass.toAddCommGroup _
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝ f : EvenHom Q A
this : AddCommGroup ↥(CliffordAlgebra.even.lift.S f) := AddSubgroupClass.toAddCommGroup (CliffordAlgebra.even.lift.S f)
⊢ CliffordAlgebra Q →ₗ[R] A
state_after: no goals
tactic: exact LinearMap.fst R _ _ ∘ₗ foldr Q (fFold f) (fFold_fFold f) (1, 0)