ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicTopology.DoldKan.Γ₀'_map_f
File: Mathlib/AlgebraicTopology/DoldKan/FunctorGamma.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{?u.75509, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ ((fun K => Split.mk' (Γ₀.splitting K)) K).s.ι n ≫ (Γ₀.map f).app (op [n]) =
    f.f n ≫ ((fun K => Split.mk' (Γ₀.splitting K)) K').s.ι n
state_after: C : Type u_1
inst✝² : Category.{?u.75509, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ ((Γ₀.splitting K).ι n ≫
      (Γ₀.splitting K).desc (op [n]) fun A => f.f (unop A.fst).len ≫ ((Γ₀.splitting K').cofan (op [n])).inj A) =
    f.f n ≫ (Γ₀.splitting K').ι n
tactic: dsimp
state_before: C : Type u_1
inst✝² : Category.{?u.75509, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ ((Γ₀.splitting K).ι n ≫
      (Γ₀.splitting K).desc (op [n]) fun A => f.f (unop A.fst).len ≫ ((Γ₀.splitting K').cofan (op [n])).inj A) =
    f.f n ≫ (Γ₀.splitting K').ι n
state_after: C : Type u_1
inst✝² : Category.{?u.75509, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ f.f (unop (Splitting.IndexSet.id (op [n])).fst).len ≫
      ((Γ₀.splitting K').cofan (op [n])).inj (Splitting.IndexSet.id (op [n])) =
    f.f n ≫ ((Γ₀.splitting K').cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
tactic: simp only [← Splitting.cofan_inj_id, (Γ₀.splitting K).ι_desc]
state_before: C : Type u_1
inst✝² : Category.{?u.75509, u_1} C
inst✝¹ : Preadditive C
K✝ K'✝ : ChainComplex C ℕ
f✝ : K✝ ⟶ K'✝
Δ Δ' Δ'' : SimplexCategory
inst✝ : HasFiniteCoproducts C
K K' : ChainComplex C ℕ
f : K ⟶ K'
n : ℕ
⊢ f.f (unop (Splitting.IndexSet.id (op [n])).fst).len ≫
      ((Γ₀.splitting K').cofan (op [n])).inj (Splitting.IndexSet.id (op [n])) =
    f.f n ≫ ((Γ₀.splitting K').cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
state_after: no goals
tactic: rfl
Theorem: Real.dimH_univ_pi_fin
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
C K r : ℝ≥0
f : X → Y
s t : Set X
E : Type u_4
inst✝³ : Fintype ι
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
n : ℕ
⊢ dimH univ = ↑n
state_after: no goals
tactic: rw [dimH_univ_pi, Fintype.card_fin]
Theorem: seminormFromBounded_ker
File: Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
⊢ seminormFromBounded' f ⁻¹' {0} = f ⁻¹' {0}
state_after: case h
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
⊢ x ∈ seminormFromBounded' f ⁻¹' {0} ↔ x ∈ f ⁻¹' {0}
tactic: ext x
state_before: case h
R : Type u_1
inst✝ : CommRing R
f : R → ℝ
c : ℝ
f_nonneg : 0 ≤ f
f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y
x : R
⊢ x ∈ seminormFromBounded' f ⁻¹' {0} ↔ x ∈ f ⁻¹' {0}
state_after: no goals
tactic: exact seminormFromBounded_eq_zero_iff f_nonneg f_mul x
Theorem: IsLocalizedModule.iso_symm_apply'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommSemiring R
S : Submonoid R
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid M''
A : Type u_5
inst✝⁸ : CommSemiring A
inst✝⁷ : Algebra R A
inst✝⁶ : Module A M'
inst✝⁵ : IsLocalization S A
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M''
inst✝¹ : IsScalarTower R A M'
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M'
a : M
b : ↥S
eq1 : b • m = f a
⊢ ∃ u, u • b • ⋯.choose.1 = u • ⋯.choose.2 • a
state_after: no goals
tactic: rw [← IsLocalizedModule.eq_iff_exists S f, Submonoid.smul_def, Submonoid.smul_def, f.map_smul,
        f.map_smul, ← (surj' _).choose_spec, ← Submonoid.smul_def, ← Submonoid.smul_def, ← mul_smul,
        mul_comm, mul_smul, eq1]
Theorem: div_div_div_cancel_right'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a✝ b✝ c✝ d : G
n : ℤ
a b c : G
⊢ a / c / (b / c) = a / b
state_after: no goals
tactic: rw [← inv_div c b, div_inv_eq_mul, div_mul_div_cancel']
Theorem: Complex.range_exp_mul_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
⊢ (range fun x => cexp (↑x * I)) = sphere 0 1
state_after: case h
a x✝ z x : ℂ
⊢ (x ∈ range fun x => cexp (↑x * I)) ↔ x ∈ sphere 0 1
tactic: ext x
state_before: case h
a x✝ z x : ℂ
⊢ (x ∈ range fun x => cexp (↑x * I)) ↔ x ∈ sphere 0 1
state_after: no goals
tactic: simp only [mem_sphere_zero_iff_norm, norm_eq_abs, abs_eq_one_iff, Set.mem_range]
Theorem: CategoryTheory.CategoryOfElements.structuredArrowEquivalence_counitIso_hom
File: Mathlib/CategoryTheory/Elements.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
X : F.Elements
⊢ (𝟭 F.Elements).obj X = (toStructuredArrow F ⋙ fromStructuredArrow F).obj X
state_after: no goals
tactic: aesop_cat
Theorem: Polynomial.valuation_X_eq_neg_one
File: Mathlib/FieldTheory/RatFunc/AsPolynomial.lean

Proof steps:
state_before: K✝ : Type u
K : Type u_1
inst✝ : Field K
⊢ (idealX K).valuation RatFunc.X = ↑(Multiplicative.ofAdd (-1))
state_after: case hr
K✝ : Type u
K : Type u_1
inst✝ : Field K
⊢ X ≠ 0

case hv
K✝ : Type u
K : Type u_1
inst✝ : Field K
⊢ (idealX K).asIdeal = Ideal.span {X}
tactic: rw [← RatFunc.algebraMap_X, valuation_of_algebraMap, intValuation_singleton]
Theorem: Set.mulIndicator_const_preimage_eq_union
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ (U.mulIndicator fun x => a) ⁻¹' s = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ U.ite (if a ∈ s then univ else ∅) (if 1 ∈ s then univ else ∅) = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅
tactic: rw [mulIndicator_preimage, preimage_one, preimage_const]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝³ : One M
inst✝² : One N
s✝ t : Set α
f g : α → M
a✝ : α
U : Set α
s : Set M
a : M
inst✝¹ : Decidable (a ∈ s)
inst✝ : Decidable (1 ∈ s)
⊢ U.ite (if a ∈ s then univ else ∅) (if 1 ∈ s then univ else ∅) = (if a ∈ s then U else ∅) ∪ if 1 ∈ s then Uᶜ else ∅
state_after: no goals
tactic: split_ifs <;> simp [← compl_eq_univ_diff]
Theorem: Finset.sup'_le_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ s.sup' H f ≤ a ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b ≤ ↑a) ↔ ∀ b ∈ s, ↑(f b) ≤ ↑a
tactic: simp_rw [← @WithBot.coe_le_coe α, coe_sup', Finset.sup_le_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f : β → α
a : α
⊢ (∀ b ∈ s, (WithBot.some ∘ f) b ≤ ↑a) ↔ ∀ b ∈ s, ↑(f b) ≤ ↑a
state_after: no goals
tactic: rfl
Theorem: Surreal.Multiplication.P3.trans
File: Mathlib/SetTheory/Surreal/Multiplication.lean

Proof steps:
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : P3 x₁ x₂ y₁ y₂
h₂ : P3 x₂ x₃ y₁ y₂
⊢ P3 x₁ x₃ y₁ y₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ P3 x₁ x₃ y₁ y₂
tactic: rw [P3] at h₁ h₂
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ P3 x₁ x₃ y₁ y₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₂⟧ + ⟦x₃ * y₁⟧) < ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₁⟧ + ⟦x₃ * y₂⟧)
tactic: rw [P3, ← add_lt_add_iff_left (⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧)]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₂⟧ + ⟦x₃ * y₁⟧) < ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₁⟧ + ⟦x₃ * y₂⟧)
state_after: no goals
tactic: convert add_lt_add h₁ h₂ using 1 <;> abel
Theorem: Finset.forall_mem_cons
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Finset α
a b : α
h : a ∉ s
p : α → Prop
⊢ (∀ x ∈ cons a s h, p x) ↔ p a ∧ ∀ x ∈ s, p x
state_after: no goals
tactic: simp only [mem_cons, or_imp, forall_and, forall_eq]
Theorem: Finset.sum_sdiff_lt_sum_sdiff
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ ∏ i ∈ s \ t, f i < ∏ i ∈ t \ s, f i ↔ ∏ i ∈ s, f i < ∏ i ∈ t, f i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ Disjoint (t \ s) (s ∩ t)
tactic: rw [← mul_lt_mul_iff_right, ← prod_union (disjoint_sdiff_inter _ _), sdiff_union_inter,
    ← prod_union, inter_comm, sdiff_union_inter]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ Disjoint (t \ s) (s ∩ t)
state_after: no goals
tactic: simpa only [inter_comm] using disjoint_sdiff_inter t s
Theorem: CategoryTheory.MonoidalCategory.tensorHom_id
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
Y : C
⊢ f ⊗ 𝟙 Y = f ▷ Y
state_after: no goals
tactic: simp [tensorHom_def]
Theorem: Nat.bitCasesOn_bit
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ : ℕ
C : ℕ → Sort u
H : (b : Bool) → (n : ℕ) → C (bit b n)
b : Bool
n : ℕ
⊢ HEq (H (bit b n).bodd (bit b n).div2) (H b n)
state_after: no goals
tactic: rw [bodd_bit, div2_bit]
Theorem: Cardinal.mk_subset_ge_of_subset_image
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ f '' s
⊢ #↑t ≤ #↑{x | x ∈ s ∧ f x ∈ t}
state_after: α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑t ≤ #↑{x | x ∈ s ∧ f x ∈ t}
tactic: rw [image_eq_range] at h
state_before: α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑t ≤ #↑{x | x ∈ s ∧ f x ∈ t}
state_after: case h.e'_4
α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑{x | x ∈ s ∧ f x ∈ t} = #↑((fun x => f ↑x) ⁻¹' t)
tactic: convert mk_preimage_of_subset_range _ _ h using 1
state_before: case h.e'_4
α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑{x | x ∈ s ∧ f x ∈ t} = #↑((fun x => f ↑x) ⁻¹' t)
state_after: case h.e'_4
α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑{x | f ↑x ∈ t} = #↑((fun x => f ↑x) ⁻¹' t)
tactic: rw [mk_sep]
state_before: case h.e'_4
α β : Type u
c : Cardinal.{?u.231592}
f : α → β
s : Set α
t : Set β
h : t ⊆ range fun x => f ↑x
⊢ #↑{x | f ↑x ∈ t} = #↑((fun x => f ↑x) ⁻¹' t)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.SimplicialObject.instCategoryAugmented_id_left_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
⊢ Category.{?u.48352, max u v} (Augmented C)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
⊢ Category.{?u.48352, max u v} (Comma (𝟭 (SimplicialObject C)) (const C))
tactic: dsimp only [Augmented]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
⊢ Category.{?u.48352, max u v} (Comma (𝟭 (SimplicialObject C)) (const C))
state_after: no goals
tactic: infer_instance
Theorem: AlgebraicTopology.DoldKan.map_PInfty_f
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
X✝ : SimplicialObject C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
G : C ⥤ D
inst✝ : G.Additive
X : SimplicialObject C
n : ℕ
⊢ PInfty.f n = G.map (PInfty.f n)
state_after: no goals
tactic: simp only [PInfty_f, map_P]
Theorem: Submodule.fg_biSup
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
ι : Type u_3
s : Finset ι
N : ι → Submodule R M
h : ∀ i ∈ s, (N i).FG
⊢ (⨆ i ∈ s, N i).FG
state_after: no goals
tactic: simpa only [Finset.sup_eq_iSup] using fg_finset_sup s N h
Theorem: Order.Ideal.PrimePair.I_isPrime
File: Mathlib/Order/PrimeIdeal.lean

Proof steps:
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
⊢ IsPFilter (↑IF.I)ᶜ
state_after: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
⊢ IsPFilter ↑IF.F
tactic: rw [IF.compl_I_eq_F]
state_before: P : Type u_1
inst✝ : Preorder P
IF : PrimePair P
⊢ IsPFilter ↑IF.F
state_after: no goals
tactic: exact IF.F.isPFilter
Theorem: MeasureTheory.toFiniteAux_univ_le_one
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
⊢ μ.toFiniteAux Set.univ ≤ 1
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
⊢ ∑' (n : ℕ), (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ * (sFiniteSeq μ n) Set.univ ≤ 1
tactic: rw [toFiniteAux_apply]
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
h_le_pow : ∀ (n : ℕ), (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ * (sFiniteSeq μ n) Set.univ ≤ (2 ^ (n + 1))⁻¹
⊢ ∑' (n : ℕ), (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ * (sFiniteSeq μ n) Set.univ ≤ 1
state_after: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
h_le_pow : ∀ (n : ℕ), (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ * (sFiniteSeq μ n) Set.univ ≤ (2 ^ (n + 1))⁻¹
⊢ ∑' (i : ℕ), (2 ^ (i + 1))⁻¹ ≤ 1
tactic: refine (tsum_le_tsum h_le_pow ENNReal.summable ENNReal.summable).trans ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ μ : Measure α
inst✝ : SFinite μ
h_le_pow : ∀ (n : ℕ), (2 ^ (n + 1) * (sFiniteSeq μ n) Set.univ)⁻¹ * (sFiniteSeq μ n) Set.univ ≤ (2 ^ (n + 1))⁻¹
⊢ ∑' (i : ℕ), (2 ^ (i + 1))⁻¹ ≤ 1
state_after: no goals
tactic: simp [ENNReal.inv_pow, ENNReal.tsum_geometric_add_one, ENNReal.inv_mul_cancel]
Theorem: CochainComplex.fromSingle₀Equiv_symm_apply_f_zero
File: Mathlib/Algebra/Homology/Single.lean

Proof steps:
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : CochainComplex V ℕ
X : V
f : X ⟶ C.X 0
hf : f ≫ C.d 0 1 = 0
⊢ ((C.fromSingle₀Equiv X).symm ⟨f, hf⟩).f 0 = f
state_after: no goals
tactic: simp [fromSingle₀Equiv]
Theorem: PseudoMetricSpace.replaceBornology_eq
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
⊢ m.replaceBornology H = m
state_after: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
tactic: ext
state_before: case h.dist.h.h
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
m : PseudoMetricSpace α
B : Bornology α
H : ∀ (s : Set α), IsBounded s ↔ IsBounded s
x✝¹ x✝ : α
⊢ dist x✝¹ x✝ = dist x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: NormedRing.algEquivComplexOfComplete_symm_apply
File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝² : NormedRing A
inst✝¹ : NormedAlgebra ℂ A
hA : ∀ {a : A}, IsUnit a ↔ a ≠ 0
inst✝ : CompleteSpace A
nt : Nontrivial A :=
  {
    exists_pair_ne :=
      Exists.intro 1
        (Exists.intro 0 (hA.mp (Exists.intro { val := 1, inv := 1, val_inv := mul_one 1, inv_val := mul_one 1 } rfl))) }
z : ℂ
⊢ (fun a => ⋯.some) ((algebraMap ℂ A) z) = z
state_after: no goals
tactic: simpa only [@scalar_eq _ _ _ _ _ nt _] using
        (@spectrum.nonempty _ _ _ _ nt <| algebraMap ℂ A z).some_mem
Theorem: Fin.add_one_le_of_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
a b : Fin (n + 1)
h : a < b
⊢ a + 1 ≤ b
state_after: case mk
n✝ m n : ℕ
b : Fin (n + 1)
a : ℕ
ha : a < n + 1
h : ⟨a, ha⟩ < b
⊢ ⟨a, ha⟩ + 1 ≤ b
tactic: cases' a with a ha
state_before: case mk
n✝ m n : ℕ
b : Fin (n + 1)
a : ℕ
ha : a < n + 1
h : ⟨a, ha⟩ < b
⊢ ⟨a, ha⟩ + 1 ≤ b
state_after: case mk.mk
n✝ m n a : ℕ
ha : a < n + 1
b : ℕ
hb : b < n + 1
h : ⟨a, ha⟩ < ⟨b, hb⟩
⊢ ⟨a, ha⟩ + 1 ≤ ⟨b, hb⟩
tactic: cases' b with b hb
state_before: case mk.mk
n✝ m n a : ℕ
ha : a < n + 1
b : ℕ
hb : b < n + 1
h : ⟨a, ha⟩ < ⟨b, hb⟩
⊢ ⟨a, ha⟩ + 1 ≤ ⟨b, hb⟩
state_after: case mk.mk.zero
n m a b : ℕ
ha : a < 0 + 1
hb : b < 0 + 1
h : ⟨a, ha⟩ < ⟨b, hb⟩
⊢ ⟨a, ha⟩ + 1 ≤ ⟨b, hb⟩

case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : ⟨a, ha⟩ < ⟨b, hb⟩
⊢ ⟨a, ha⟩ + 1 ≤ ⟨b, hb⟩
tactic: cases n
state_before: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : ⟨a, ha⟩ < ⟨b, hb⟩
⊢ ⟨a, ha⟩ + 1 ≤ ⟨b, hb⟩
state_after: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ (a + 1) % (n✝ + 1 + 1) ≤ b
tactic: simp only [le_iff_val_le_val, val_add, lt_iff_val_lt_val, val_mk, val_one] at h ⊢
state_before: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ (a + 1) % (n✝ + 1 + 1) ≤ b
state_after: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ a + 1 < n✝ + 1 + 1
tactic: rwa [Nat.mod_eq_of_lt, Nat.succ_le_iff]
state_before: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ a + 1 < n✝ + 1 + 1
state_after: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ a < n✝ + 1
tactic: rw [Nat.succ_lt_succ_iff]
state_before: case mk.mk.succ
n m a b n✝ : ℕ
ha : a < n✝ + 1 + 1
hb : b < n✝ + 1 + 1
h : a < b
⊢ a < n✝ + 1
state_after: no goals
tactic: exact h.trans_le (Nat.le_of_lt_succ hb)
Theorem: MeasurableSpace.cardinal_generateMeasurable_le
File: Mathlib/MeasureTheory/MeasurableSpace/Card.lean

Proof steps:
state_before: α : Type u
s : Set (Set α)
⊢ #↑{t | GenerateMeasurable s t} ≤ max (#↑s) 2 ^ ℵ₀
state_after: α : Type u
s : Set (Set α)
⊢ #↑(⋃ i, generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
tactic: rw [generateMeasurable_eq_rec]
state_before: α : Type u
s : Set (Set α)
⊢ #↑(⋃ i, generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
state_after: α : Type u
s : Set (Set α)
⊢ #(Quotient.out (aleph 1).ord).α * ⨆ i, #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
tactic: apply (mk_iUnion_le _).trans
state_before: α : Type u
s : Set (Set α)
⊢ #(Quotient.out (aleph 1).ord).α * ⨆ i, #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
state_after: α : Type u
s : Set (Set α)
⊢ aleph 1 * ⨆ i, #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
tactic: rw [(aleph 1).mk_ord_out]
state_before: α : Type u
s : Set (Set α)
⊢ aleph 1 * ⨆ i, #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
state_after: α : Type u
s : Set (Set α)
⊢ 𝔠 * max (#↑s) 2 ^ ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
tactic: refine le_trans (mul_le_mul' aleph_one_le_continuum
      (ciSup_le' fun i => cardinal_generateMeasurableRec_le s i)) ?_
state_before: α : Type u
s : Set (Set α)
⊢ 𝔠 * max (#↑s) 2 ^ ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
state_after: α : Type u
s : Set (Set α)
⊢ 𝔠 ≤ max (#↑s) 2 ^ ℵ₀
tactic: refine (mul_le_max_of_aleph0_le_left aleph0_le_continuum).trans (max_le ?_ le_rfl)
state_before: α : Type u
s : Set (Set α)
⊢ 𝔠 ≤ max (#↑s) 2 ^ ℵ₀
state_after: no goals
tactic: exact power_le_power_right (le_max_right _ _)
Theorem: nonZeroDivisors.associated_coe
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

Proof steps:
state_before: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑(unitsNonZeroDivisorsEquiv.symm.symm b_1) = ↑b) ↔ Associated a b
state_after: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑↑b_1 = ↑b) ↔ ∃ u, a * ↑u = b
tactic: simp [Associated]
state_before: M₀ : Type u_1
inst✝¹ inst✝ : MonoidWithZero M₀
a b : ↥M₀⁰
⊢ (∃ b_1, ↑a * ↑↑b_1 = ↑b) ↔ ∃ u, a * ↑u = b
state_after: no goals
tactic: norm_cast
Theorem: Nat.digits_of_lt
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b x : ℕ
hx : x ≠ 0
hxb : x < b
⊢ b.digits x = [x]
state_after: case intro
n b x : ℕ
hx : x.succ ≠ 0
hxb : x.succ < b
⊢ b.digits x.succ = [x.succ]
tactic: rcases exists_eq_succ_of_ne_zero hx with ⟨x, rfl⟩
state_before: case intro
n b x : ℕ
hx : x.succ ≠ 0
hxb : x.succ < b
⊢ b.digits x.succ = [x.succ]
state_after: case intro.intro
n x : ℕ
hx : x.succ ≠ 0
b : ℕ
hxb : x.succ < b + succ 1
⊢ (b + succ 1).digits x.succ = [x.succ]
tactic: rcases Nat.exists_eq_add_of_le' ((Nat.le_add_left 1 x).trans_lt hxb) with ⟨b, rfl⟩
state_before: case intro.intro
n x : ℕ
hx : x.succ ≠ 0
b : ℕ
hxb : x.succ < b + succ 1
⊢ (b + succ 1).digits x.succ = [x.succ]
state_after: no goals
tactic: rw [digits_add_two_add_one, div_eq_of_lt hxb, digits_zero, mod_eq_of_lt hxb]
Theorem: WittVector.constantCoeff_wittAdd
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (wittAdd p n) = 0
state_after: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (X 0 + X 1) = 0
tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (X 0 + X 1) = 0
state_after: no goals
tactic: simp only [add_zero, RingHom.map_add, constantCoeff_X]