ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: StieltjesFunction.measure_smul
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
⊢ (c • f).measure = c • f.measure
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ (c • f).measure (Ioc a b) = (c • f.measure) (Ioc a b)
tactic: refine Measure.ext_of_Ioc _ _ (fun a b _ ↦ ?_)
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ (c • f).measure (Ioc a b) = (c • f.measure) (Ioc a b)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑(c • f) b - ↑(c • f) a) = c • ofReal (↑f b - ↑f a)
tactic: simp only [measure_Ioc, Measure.smul_apply]
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑(c • f) b - ↑(c • f) a) = c • ofReal (↑f b - ↑f a)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑c * ↑f b - ↑c * ↑f a) = c • ofReal (↑f b - ↑f a)
tactic: change ofReal (c * f b - c * f a) = c • ofReal (f b - f a)
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ofReal (↑c * ↑f b - ↑c * ↑f a) = c • ofReal (↑f b - ↑f a)
state_after: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ↑c • ofReal (↑f b - ↑f a) = c • ofReal (↑f b - ↑f a)
tactic: rw [← _root_.mul_sub, ENNReal.ofReal_mul zero_le_coe, ofReal_coe_nnreal, ← smul_eq_mul]
state_before: f✝ : StieltjesFunction
c : ℝ≥0
f : StieltjesFunction
a b : ℝ
x✝ : a < b
⊢ ↑c • ofReal (↑f b - ↑f a) = c • ofReal (↑f b - ↑f a)
state_after: no goals
tactic: rfl
Theorem: Finset.all_card_le_biUnion_card_iff_existsInjective'
File: Mathlib/Combinatorics/Hall/Finite.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Finite ι
inst✝ : DecidableEq α
t : ι → Finset α
⊢ (∀ (s : Finset ι), s.card ≤ (s.biUnion t).card) ↔ ∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x
state_after: case mp
ι : Type u_1
α : Type u_2
inst✝¹ : Finite ι
inst✝ : DecidableEq α
t : ι → Finset α
⊢ (∀ (s : Finset ι), s.card ≤ (s.biUnion t).card) → ∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x

case mpr
ι : Type u_1
α : Type u_2
inst✝¹ : Finite ι
inst✝ : DecidableEq α
t : ι → Finset α
⊢ (∃ f, Function.Injective f ∧ ∀ (x : ι), f x ∈ t x) → ∀ (s : Finset ι), s.card ≤ (s.biUnion t).card
tactic: constructor
Theorem: HasProd.update
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
⊢ HasProd (Function.update f b a) (a / f b * a₁)
state_after: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
tactic: convert (hasProd_ite_eq b (a / f b)).mul hf with b'
state_before: case h.e'_5.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
f g : β → α
a✝ a₁ a₂ : α
hf : HasProd f a₁
b : β
inst✝ : DecidableEq β
a : α
b' : β
h : ¬b' = b
⊢ Function.update f b a b' = (if b' = b then a / f b else 1) * f b'
tactic: by_cases h : b' = b
Theorem: Nat.div_le_iff_le_mul_add_pred
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a / b ≤ c ↔ a ≤ b * c + (b - 1)
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a < b * c + b ↔ a ≤ b * c + (b - 1)
tactic: rw [← Nat.lt_succ_iff, div_lt_iff_lt_mul hb, succ_mul, Nat.mul_comm]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ a < b * c + b ↔ a ≤ b * c + (b - 1)
state_after: no goals
tactic: cases hb <;> exact Nat.lt_succ_iff
Theorem: WittVector.frobeniusEquiv_symm_apply
File: Mathlib/RingTheory/WittVector/Frobenius.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ ((map ↑(_root_.frobeniusEquiv R p).symm) (frobenius f)).coeff n = f.coeff n
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ ((map ↑(_root_.frobeniusEquiv R p).symm) ((map (_root_.frobenius R p)) f)).coeff n = f.coeff n
tactic: rw [frobenius_eq_map_frobenius]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ ((map ↑(_root_.frobeniusEquiv R p).symm) ((map (_root_.frobenius R p)) f)).coeff n = f.coeff n
state_after: no goals
tactic: exact frobeniusEquiv_symm_apply_frobenius R p _
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ (frobenius ((map ↑(_root_.frobeniusEquiv R p).symm) f)).coeff n = f.coeff n
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ ((map (_root_.frobenius R p)) ((map ↑(_root_.frobeniusEquiv R p).symm) f)).coeff n = f.coeff n
tactic: rw [frobenius_eq_map_frobenius]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : CharP R p
inst✝ : PerfectRing R p
f : 𝕎 R
n : ℕ
⊢ ((map (_root_.frobenius R p)) ((map ↑(_root_.frobeniusEquiv R p).symm) f)).coeff n = f.coeff n
state_after: no goals
tactic: exact frobenius_apply_frobeniusEquiv_symm R p _
Theorem: AlgebraicGeometry.isBasis_basicOpen
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X : Scheme
inst✝ : IsAffine X
⊢ Opens.IsBasis (Set.range X.basicOpen)
state_after: X : Scheme
inst✝ : IsAffine X
⊢ IsTopologicalBasis (SetLike.coe '' Set.range X.basicOpen)
tactic: delta Opens.IsBasis
state_before: X : Scheme
inst✝ : IsAffine X
⊢ IsTopologicalBasis (SetLike.coe '' Set.range X.basicOpen)
state_after: case h.e'_3
X : Scheme
inst✝ : IsAffine X
⊢ SetLike.coe '' Set.range X.basicOpen =
    Set.preimage ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ''
      (SetLike.coe '' Set.range PrimeSpectrum.basicOpen)
tactic: convert PrimeSpectrum.isBasis_basic_opens.inducing
    (TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)).inducing using 1
state_before: case h.e'_3
X : Scheme
inst✝ : IsAffine X
⊢ SetLike.coe '' Set.range X.basicOpen =
    Set.preimage ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ''
      (SetLike.coe '' Set.range PrimeSpectrum.basicOpen)
state_after: case h.e'_3.h
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ x✝ ∈ SetLike.coe '' Set.range X.basicOpen ↔
    x✝ ∈
      Set.preimage ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ''
        (SetLike.coe '' Set.range PrimeSpectrum.basicOpen)
tactic: ext
state_before: case h.e'_3.h
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ x✝ ∈ SetLike.coe '' Set.range X.basicOpen ↔
    x✝ ∈
      Set.preimage ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ''
        (SetLike.coe '' Set.range PrimeSpectrum.basicOpen)
state_after: case h.e'_3.h
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ (∃ x ∈ Set.range X.basicOpen, ↑x = x✝) ↔
    ∃ x,
      (∃ x_1 ∈ Set.range PrimeSpectrum.basicOpen, ↑x_1 = x) ∧
        ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ⁻¹' x = x✝
tactic: simp only [Set.mem_image, exists_exists_eq_and]
state_before: case h.e'_3.h
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ (∃ x ∈ Set.range X.basicOpen, ↑x = x✝) ↔
    ∃ x,
      (∃ x_1 ∈ Set.range PrimeSpectrum.basicOpen, ↑x_1 = x) ∧
        ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ⁻¹' x = x✝
state_after: case h.e'_3.h.mp
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ (∃ x ∈ Set.range X.basicOpen, ↑x = x✝) →
    ∃ x,
      (∃ x_1 ∈ Set.range PrimeSpectrum.basicOpen, ↑x_1 = x) ∧
        ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ⁻¹' x = x✝

case h.e'_3.h.mpr
X : Scheme
inst✝ : IsAffine X
x✝ : Set ↑↑X.toPresheafedSpace
⊢ (∃ x,
      (∃ x_1 ∈ Set.range PrimeSpectrum.basicOpen, ↑x_1 = x) ∧
        ⇑(TopCat.homeoOfIso (Scheme.forgetToTop.mapIso X.isoSpec)) ⁻¹' x = x✝) →
    ∃ x ∈ Set.range X.basicOpen, ↑x = x✝
tactic: constructor
Theorem: Matrix.toLinAlgEquiv_toMatrixAlgEquiv
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
f : M₁ →ₗ[R] M₁
⊢ (toLinAlgEquiv v₁) ((toMatrixAlgEquiv v₁) f) = f
state_after: no goals
tactic: rw [← Matrix.toLinAlgEquiv_symm, AlgEquiv.apply_symm_apply]
Theorem: MeasureTheory.SimpleFunc.restrict_lintegral_eq_lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α →ₛ ℝ≥0∞
s : Set α
hs : MeasurableSet s
⊢ (f.restrict s).lintegral μ = f.lintegral (μ.restrict s)
state_after: no goals
tactic: rw [f.restrict_lintegral hs, lintegral_restrict]
Theorem: NNReal.isConjExponent_coe
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ (↑p).IsConjExponent ↑q ↔ p.IsConjExponent q
state_after: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → ((↑p)⁻¹ + (↑q)⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
tactic: simp [Real.isConjExponent_iff, isConjExponent_iff]
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → ((↑p)⁻¹ + (↑q)⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
state_after: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → (p⁻¹ + q⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
tactic: norm_cast
state_before: a b p q : ℝ≥0
h : p.IsConjExponent q
⊢ 1 < p → (p⁻¹ + q⁻¹ = 1 ↔ p⁻¹ + q⁻¹ = 1)
state_after: no goals
tactic: simp
Theorem: HomologicalComplex₂.flipEquivalenceUnitIso_inv_app_f_f
File: Mathlib/Algebra/Homology/HomologicalBicomplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
i₁ : I₁
⊢ ∀ (i j : I₂),
    c₂.Rel i j →
      ((fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) i).hom ≫
          (((flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).obj K).X i₁).d i j =
        (((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).d i j ≫
          ((fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K : HomologicalComplex₂ C c₁ c₂
⊢ ∀ (i j : I₁),
    c₁.Rel i j →
      ((fun i₁ => Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
              i).hom ≫
          ((flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).obj K).d i j =
        ((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).d i j ≫
          ((fun i₁ =>
                Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
              j).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.21503, u_1} C
inst✝ : HasZeroMorphisms C
I₁ : Type u_2
I₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
⊢ ∀ {X Y : HomologicalComplex₂ C c₁ c₂} (f : X ⟶ Y),
    (𝟭 (HomologicalComplex₂ C c₁ c₂)).map f ≫
        ((fun K =>
              Hom.isoOfComponents
                (fun i₁ =>
                  Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
                ⋯)
            Y).hom =
      ((fun K =>
              Hom.isoOfComponents
                (fun i₁ =>
                  Hom.isoOfComponents (fun i₂ => Iso.refl ((((𝟭 (HomologicalComplex₂ C c₁ c₂)).obj K).X i₁).X i₂)) ⋯)
                ⋯)
            X).hom ≫
        (flipFunctor C c₁ c₂ ⋙ flipFunctor C c₂ c₁).map f
state_after: no goals
tactic: aesop_cat
Theorem: AlgebraicGeometry.PresheafedSpace.GlueData.π_ιInvApp_eq_id
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U = 𝟙 (limit (D.diagramOverOpen U))
state_after: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j : (WalkingMultispan D.diagram.fstFrom D.diagram.sndFrom)ᵒᵖ
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫ limit.π (D.diagramOverOpen U) j =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) j
tactic: ext j
state_before: case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j : (WalkingMultispan D.diagram.fstFrom D.diagram.sndFrom)ᵒᵖ
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫ limit.π (D.diagramOverOpen U) j =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) j
state_after: case w.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j : WalkingMultispan D.diagram.fstFrom D.diagram.sndFrom
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫ limit.π (D.diagramOverOpen U) (op j) =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) (op j)
tactic: induction j using Opposite.rec' with | h j => ?_
state_before: case w.h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j : WalkingMultispan D.diagram.fstFrom D.diagram.sndFrom
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫ limit.π (D.diagramOverOpen U) (op j) =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) (op j)
state_after: case w.h.left.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j k : D.J
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫
      limit.π (D.diagramOverOpen U) (op (WalkingMultispan.left (j, k))) =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) (op (WalkingMultispan.left (j, k)))

case w.h.right
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i : D.J
U : Opens ↑↑(D.U i)
j : D.diagram.R
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U) ≫
      limit.π (D.diagramOverOpen U) (op (WalkingMultispan.right j)) =
    𝟙 (limit (D.diagramOverOpen U)) ≫ limit.π (D.diagramOverOpen U) (op (WalkingMultispan.right j))
tactic: rcases j with (⟨j, k⟩ | ⟨j⟩)
Theorem: CategoryTheory.eqToHom_unop
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X Y : Cᵒᵖ
h : X = Y
⊢ (eqToHom h).unop = eqToHom ⋯
state_after: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X : Cᵒᵖ
⊢ (eqToHom ⋯).unop = eqToHom ⋯
tactic: cases h
state_before: case refl
C : Type u₁
inst✝ : Category.{v₁, u₁} C
β : Sort u_1
X : Cᵒᵖ
⊢ (eqToHom ⋯).unop = eqToHom ⋯
state_after: no goals
tactic: rfl
Theorem: Subalgebra.iSupLift_inclusion
File: Mathlib/Algebra/Algebra/Subalgebra/Directed.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_4
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → ↥(K i) →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : ↥(K i)
h : K i ≤ T
⊢ (iSupLift K dir f hf T hT) ((inclusion h) x) = (f i) x
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_4
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → ↥(K i) →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : ↥(K i)
h : K i ≤ T
⊢ Set.iUnionLift (fun i => ↑(K i)) (fun i x => (f i) x) ⋯ ↑T ⋯ (Set.inclusion h x) = (f i) x
tactic: dsimp [iSupLift, inclusion]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁵ : CommSemiring R
inst✝⁴ : Semiring A
inst✝³ : Algebra R A
inst✝² : Semiring B
inst✝¹ : Algebra R B
S : Subalgebra R A
ι : Type u_4
inst✝ : Nonempty ι
K : ι → Subalgebra R A
dir : Directed (fun x x_1 => x ≤ x_1) K
f : (i : ι) → ↥(K i) →ₐ[R] B
hf : ∀ (i j : ι) (h : K i ≤ K j), f i = (f j).comp (inclusion h)
T : Subalgebra R A
hT : T = iSup K
i : ι
x : ↥(K i)
h : K i ≤ T
⊢ Set.iUnionLift (fun i => ↑(K i)) (fun i x => (f i) x) ⋯ ↑T ⋯ (Set.inclusion h x) = (f i) x
state_after: no goals
tactic: rw [Set.iUnionLift_inclusion]
Theorem: QuotientGroup.eq_iff_div_mem
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
N : Subgroup G
nN : N.Normal
x y : G
⊢ ↑x = ↑y ↔ x / y ∈ N
state_after: G : Type u
inst✝² : Group G
N✝ : Subgroup G
nN✝ : N✝.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
N : Subgroup G
nN : N.Normal
x y : G
⊢ y⁻¹ * x ∈ N ↔ x / y ∈ N
tactic: refine eq_comm.trans (QuotientGroup.eq.trans ?_)
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
N : Subgroup G
nN : N.Normal
x y : G
⊢ y⁻¹ * x ∈ N ↔ x / y ∈ N
state_after: no goals
tactic: rw [nN.mem_comm_iff, div_eq_mul_inv]
Theorem: gold_sq
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ φ ^ 2 = φ + 1
state_after: ⊢ ((1 + √5) / 2) ^ 2 - ((1 + √5) / 2 + 1) = 0
tactic: rw [goldenRatio, ← sub_eq_zero]
state_before: ⊢ ((1 + √5) / 2) ^ 2 - ((1 + √5) / 2 + 1) = 0
state_after: ⊢ -5 / 4 + √5 ^ 2 * (1 / 4) = 0
tactic: ring_nf
state_before: ⊢ -5 / 4 + √5 ^ 2 * (1 / 4) = 0
state_after: no goals
tactic: rw [Real.sq_sqrt] <;> norm_num
Theorem: CauSeq.lim_mul
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f : CauSeq β abv
x : β
⊢ f.lim * x = (f * const abv x).lim
state_after: no goals
tactic: rw [← lim_mul_lim, lim_const]
Theorem: Finsupp.sum_equivMapDomain
File: Mathlib/Data/Finsupp/Basic.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✝¹ : Zero M
inst✝ : CommMonoid N
f : α ≃ β
l : α →₀ M
g : β → M → N
⊢ (equivMapDomain f l).prod g = l.prod fun a m => g (f a) m
state_after: no goals
tactic: simp [prod, equivMapDomain]
Theorem: HasFPowerSeriesOnBall.eventually_eq_zero
File: Mathlib/Analysis/Analytic/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f 0 x r
⊢ ∀ᶠ (z : E) in 𝓝 x, f z = 0
state_after: no goals
tactic: filter_upwards [hf.eventually_hasSum_sub] with z hz using hz.unique hasSum_zero
Theorem: CategoryTheory.Limits.coyonedaOpColimitIsoLimitCoyoneda'_hom_comp_π
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
I : Type v₁
inst✝¹ : Category.{v₂, v₁} I
F : Iᵒᵖ ⥤ C
inst✝ : HasColimit F
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda' F).hom ≫ limit.π (F.rightOp ⋙ coyoneda) i = coyoneda.map (colimit.ι F (op i)).op
state_after: no goals
tactic: simp only [coyonedaOpColimitIsoLimitCoyoneda', Functor.mapIso_symm, Iso.trans_hom, Iso.symm_hom,
    Functor.mapIso_inv, Category.assoc, preservesLimitsIso_hom_π, ← Functor.map_comp,
    limitRightOpIsoOpColimit_inv_comp_π]
Theorem: Num.add_toZNum
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : Num
⊢ (m + n).toZNum = m.toZNum + n.toZNum
state_after: no goals
tactic: cases m <;> cases n <;> rfl
Theorem: Finset.sum_range_succ_comm
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x ∈ range (n + 1), f x = f n * ∏ x ∈ range n, f x
state_after: no goals
tactic: rw [range_succ, prod_insert not_mem_range_self]
Theorem: AkraBazziRecurrence.isLittleO_deriv_one_sub_smoothingFn
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (deriv fun x => 1 - ε x) =ᶠ[atTop] fun z => -deriv ε z
state_after: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 - ε x) x = -deriv ε x
tactic: filter_upwards [eventually_gt_atTop 1] with x hx
state_before: case h
α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
⊢ deriv (fun x => 1 - ε x) x = -deriv ε x
state_after: no goals
tactic: rw [deriv_sub] <;> aesop
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ (fun z => -deriv ε z) =o[atTop] fun x => x⁻¹
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ deriv ε =o[atTop] fun x => x⁻¹
tactic: rw [isLittleO_neg_left]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ deriv ε =o[atTop] fun x => x⁻¹
state_after: no goals
tactic: exact isLittleO_deriv_smoothingFn
Theorem: ENNReal.smul_sSup
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
R : Type u_4
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
s : Set ℝ≥0∞
c : R
⊢ c • sSup s = ⨆ i ∈ s, c • i
state_after: no goals
tactic: simp_rw [← smul_one_mul c (sSup s), ENNReal.mul_sSup, smul_one_mul]