ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsUpperSet.thickening
File: Mathlib/Analysis/Normed/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (thickening ε s)
state_after: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (ball 1 ε * s)
tactic: rw [← ball_mul_one]
state_before: α : Type u_1
ι : Type u_2
inst✝ : NormedOrderedGroup α
s : Set α
hs : IsUpperSet s
ε : ℝ
⊢ IsUpperSet (ball 1 ε * s)
state_after: no goals
tactic: exact hs.mul_left
Theorem: Complex.continuousOn_abs_circleTransformBoundingFunction
File: Mathlib/MeasureTheory/Integral/CircleTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
R✝ : ℝ
z✝ w : ℂ
R r : ℝ
hr : r < R
z : ℂ
this : ContinuousOn (circleTransformBoundingFunction R z) (closedBall z r ×ˢ univ)
⊢ ContinuousOn (⇑abs ∘ circleTransformBoundingFunction R z) (closedBall z r ×ˢ univ)
state_after: no goals
tactic: exact this.norm
Theorem: CategoryTheory.ShortComplex.HomotopyEquiv.trans_homotopyHomInvId
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ (e.hom ≫ e'.hom) ≫ e'.inv ≫ e.inv = e.hom ≫ (e'.hom ≫ e'.inv) ≫ e.inv
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ e.hom ≫ 𝟙 S₂ ≫ e.inv = e.hom ≫ e.inv
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ (e'.inv ≫ e.inv) ≫ e.hom ≫ e'.hom = e'.inv ≫ (e.inv ≫ e.hom) ≫ e'.hom
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.239909, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
e : S₁.HomotopyEquiv S₂
e' : S₂.HomotopyEquiv S₃
⊢ e'.inv ≫ 𝟙 S₂ ≫ e'.hom = e'.inv ≫ e'.hom
state_after: no goals
tactic: simp
Theorem: Submonoid.unitsTypeEquivIsUnitSubmonoid_apply_coe
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: Relation.iff_comp
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : Prop → α → Prop
this : (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
⊢ (fun x x_1 => x ↔ x_1) ∘r r = r
state_after: no goals
tactic: rw [this, eq_comp]
Theorem: LucasLehmer.sMod_mod
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: p i : ℕ
⊢ sMod p i % (2 ^ p - 1) = sMod p i
state_after: no goals
tactic: cases i <;> simp [sMod]
Theorem: Ordering.swap_eq_iff_eq_swap
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
o o' : Ordering
⊢ o.swap = o' ↔ o = o'.swap
state_after: no goals
tactic: rw [← swap_inj, swap_swap]
Theorem: CompleteLattice.sup_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (f ⊔ g)
state_after: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (sSup {f, g})
tactic: rw [← sSup_pair]
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (sSup {f, g})
state_after: case hs
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ ∀ f_1 ∈ {f, g}, Continuous f_1
tactic: apply sSup_continuous
state_before: case hs
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ ∀ f_1 ∈ {f, g}, Continuous f_1
state_after: no goals
tactic: rintro f (rfl | rfl | _) <;> assumption
Theorem: Finset.addETransformLeft_neg
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ mulETransformLeft e⁻¹ x = (mulETransformRight e x.swap).swap
state_after: no goals
tactic: simp [-op_inv, op_smul_eq_smul, mulETransformLeft, mulETransformRight]
Theorem: exists_rat_gt
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x✝ y ε x : α
n : ℕ
h : x < ↑n
⊢ x < ↑↑n
state_after: no goals
tactic: rwa [Rat.cast_natCast]
Theorem: Nat.mem_smoothNumbers'
File: Mathlib/NumberTheory/SmoothNumbers.lean

Proof steps:
state_before: n m : ℕ
⊢ m ∈ n.smoothNumbers ↔ ∀ (p : ℕ), Prime p → p ∣ m → p < n
state_after: no goals
tactic: simp only [smoothNumbers_eq_factoredNumbers, mem_factoredNumbers', Finset.mem_range]
Theorem: Units.divp_sub
File: Mathlib/Algebra/Ring/Units.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a /ₚ u - b = (a - b * ↑u) /ₚ u
state_after: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ b = b * ↑u * ↑u⁻¹
tactic: simp only [divp, sub_mul, sub_right_inj]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ b = b * ↑u * ↑u⁻¹
state_after: no goals
tactic: rw [mul_assoc, Units.mul_inv, mul_one]
Theorem: sign_nonneg_iff
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
⊢ 0 ≤ sign a ↔ 0 ≤ a
state_after: case inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 < a
⊢ 0 ≤ sign a ↔ 0 ≤ a

case inr.inl
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 = a
⊢ 0 ≤ sign a ↔ 0 ≤ a

case inr.inr
α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : a < 0
⊢ 0 ≤ sign a ↔ 0 ≤ a
tactic: rcases lt_trichotomy 0 a with (h | h | h)
Theorem: Real.isLittleO_exp_comp_exp_comp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f g : α → ℝ
⊢ ((fun x => rexp (f x)) =o[l] fun x => rexp (g x)) ↔ Tendsto (fun x => g x - f x) l atTop
state_after: no goals
tactic: simp only [isLittleO_iff_tendsto, exp_ne_zero, ← exp_sub, ← tendsto_neg_atTop_iff, false_imp_iff,
    imp_true_iff, tendsto_exp_comp_nhds_zero, neg_sub]
Theorem: PNat.eq_one_of_lt_two
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: n : ℕ+
⊢ n < 2 → n = 1
state_after: n : ℕ+
h : n < 2
⊢ n = 1
tactic: intro h
state_before: n : ℕ+
h : n < 2
⊢ n = 1
state_after: case a
n : ℕ+
h : n < 2
⊢ n ≤ 1

case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n
tactic: apply le_antisymm
state_before: case a
n : ℕ+
h : n < 2
⊢ n ≤ 1

case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n
state_after: case a
n : ℕ+
h : n < 2
⊢ 1 ≤ n

case a
n : ℕ+
h : n < 2
⊢ n ≤ 1
tactic: swap
Theorem: MeasureTheory.FiniteMeasure.smul_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁵ : MeasurableSpace Ω
R : Type u_2
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
s : Set Ω
⊢ (c • μ) s = c • μ s
state_after: no goals
tactic: rw [coeFn_smul, Pi.smul_apply]
Theorem: Ordinal.mul_isLimit_left
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
l : a.IsLimit
b0 : 0 < b
⊢ (a * b).IsLimit
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
l : a.IsLimit
b0 : 0 < 0
⊢ (a * 0).IsLimit

case inr.inl.intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_4}
l : a.IsLimit
b : Ordinal.{u_4}
b0 : 0 < succ b
⊢ (a * succ b).IsLimit

case inr.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
l : a.IsLimit
b0 : 0 < b
lb : b.IsLimit
⊢ (a * b).IsLimit
tactic: rcases zero_or_succ_or_limit b with (rfl | ⟨b, rfl⟩ | lb)
Theorem: Polynomial.degree_cyclotomic'
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ (cyclotomic' n R).degree = ↑n.totient
state_after: no goals
tactic: simp only [degree_eq_natDegree (cyclotomic'_ne_zero n R), natDegree_cyclotomic' h]
Theorem: CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp
File: Mathlib/CategoryTheory/CofilteredSystem.lean

Proof steps:
state_before: J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i j k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
⊢ F.IsMittagLeffler ↔ ∀ (j : J), ∃ i f, ∀ ⦃k : J⦄ (g : k ⟶ i), range (F.map f) ⊆ range (F.map (g ≫ f))
state_after: no goals
tactic: simp_rw [isMittagLeffler_iff_eventualRange, eventualRange_eq_iff]
Theorem: Convex.combo_affine_apply
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (a • x + b • y) = a • f x + b • f y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (b • (y -ᵥ x) + x) = b • (f y -ᵥ f x) + f x
tactic: simp only [Convex.combo_eq_smul_sub_add h, ← vsub_eq_sub]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (b • (y -ᵥ x) + x) = b • (f y -ᵥ f x) + f x
state_after: no goals
tactic: exact f.apply_lineMap _ _ _
Theorem: AddMonoidAlgebra.singleZeroAlgHom_apply
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : Semiring k
inst✝¹ : Algebra R k
inst✝ : AddMonoid G
r : R
⊢ (↑↑__src✝).toFun ((algebraMap R k) r) = (algebraMap R k[G]) r
state_after: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : Semiring k
inst✝¹ : Algebra R k
inst✝ : AddMonoid G
r : R
x✝ : G
⊢ ((↑↑__src✝).toFun ((algebraMap R k) r)) x✝ = ((algebraMap R k[G]) r) x✝
tactic: refine Finsupp.ext fun _ => ?_
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : Semiring k
inst✝¹ : Algebra R k
inst✝ : AddMonoid G
r : R
x✝ : G
⊢ ((↑↑__src✝).toFun ((algebraMap R k) r)) x✝ = ((algebraMap R k[G]) r) x✝
state_after: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : Semiring k
inst✝¹ : Algebra R k
inst✝ : AddMonoid G
r : R
x✝ : G
⊢ (Finsupp.single 0 ((algebraMap R k) r)) x✝ = ((algebraMap R k[G]) r) x✝
tactic: simp
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝³ : CommSemiring R
inst✝² : Semiring k
inst✝¹ : Algebra R k
inst✝ : AddMonoid G
r : R
x✝ : G
⊢ (Finsupp.single 0 ((algebraMap R k) r)) x✝ = ((algebraMap R k[G]) r) x✝
state_after: no goals
tactic: rfl
Theorem: PMF.support_ofMultiset
File: Mathlib/Probability/Distributions/Uniform.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
⊢ ∀ (x : α), x ∈ (ofMultiset s hs).support ↔ x ∈ ↑s.toFinset
state_after: no goals
tactic: simp [mem_support_iff, hs]
Theorem: CategoryTheory.LaxFunctor.mapComp_assoc_right
File: Mathlib/CategoryTheory/Bicategory/Functor/Lax.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F : LaxFunctor B C
a b c d : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
⊢ F.map f ◁ F.mapComp g h ≫ F.mapComp f (g ≫ h) =
    (α_ (F.map f) (F.map g) (F.map h)).inv ≫ F.mapComp f g ▷ F.map h ≫ F.mapComp (f ≫ g) h ≫ F.map₂ (α_ f g h).hom
state_after: no goals
tactic: simp only [map₂_associator, Iso.inv_hom_id_assoc]
Theorem: LieAlgebra.is_cartan_of_zeroRootSubalgebra_eq
File: Mathlib/Algebra/Lie/Weights/Cartan.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h : zeroRootSubalgebra R L H = H
⊢ H.normalizer = H
state_after: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h : zeroRootSubalgebra R L H = H
⊢ (zeroRootSubalgebra R L H).normalizer = zeroRootSubalgebra R L H
tactic: rw [← h]
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h : zeroRootSubalgebra R L H = H
⊢ (zeroRootSubalgebra R L H).normalizer = zeroRootSubalgebra R L H
state_after: no goals
tactic: exact zeroRootSubalgebra_normalizer_eq_self R L H
Theorem: CategoryTheory.Equivalence.op_unitIso
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫ (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X) =
    𝟙 (e.functor.op.obj X)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ (e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫
        (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X)).unop =
    (𝟙 (e.functor.op.obj X)).unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ (e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫
        (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X)).unop =
    (𝟙 (e.functor.op.obj X)).unop
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ e.counitIso.inv.app (e.functor.obj (unop X)) ≫ e.functor.map (e.unitIso.inv.app (unop X)) = 𝟙 (e.functor.obj (unop X))
tactic: dsimp
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ e.counitIso.inv.app (e.functor.obj (unop X)) ≫ e.functor.map (e.unitIso.inv.app (unop X)) = 𝟙 (e.functor.obj (unop X))
state_after: no goals
tactic: simp
Theorem: MeasureTheory.SignedMeasure.eq_singularPart
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
htμ : t ⟂ᵥ μ.toENNRealVectorMeasure
hadd : s = t + μ.withDensityᵥ f
⊢ t = s.singularPart μ
state_after: case pos
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
htμ : t ⟂ᵥ μ.toENNRealVectorMeasure
hadd : s = t + μ.withDensityᵥ f
hfi : Integrable f μ
⊢ t = s.singularPart μ

case neg
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
s t✝ t : SignedMeasure α
f : α → ℝ
htμ : t ⟂ᵥ μ.toENNRealVectorMeasure
hadd : s = t + μ.withDensityᵥ f
hfi : ¬Integrable f μ
⊢ t = s.singularPart μ
tactic: by_cases hfi : Integrable f μ
Theorem: LinearMap.linearIndependent_iff
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
f : M →ₗ[R] M'
hf_inj : ker f = ⊥
h : LinearIndependent R v
⊢ Disjoint (span R (Set.range v)) (ker f)
state_after: no goals
tactic: simp only [hf_inj, disjoint_bot_right]
Theorem: Nat.factorization_le_of_le_pow
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b✝ m n✝ p✝ n p b : ℕ
hb : n ≤ p ^ b
⊢ n.factorization p ≤ b
state_after: no goals
tactic: if hn : n = 0 then simp [hn] else
  if pp : p.Prime then
    exact (pow_le_pow_iff_right pp.one_lt).1 ((ord_proj_le p hn).trans hb)
  else
    simp [factorization_eq_zero_of_non_prime n pp]
Theorem: Finpartition.IsEquipartition.card_large_parts_eq_mod
File: Mathlib/Order/Partition/Equipartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z : ∑ i ∈ P.parts, i.card = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
tactic: have z := P.sum_card_parts
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z : ∑ i ∈ P.parts, i.card = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  (filter (fun x => x.card = s.card / P.parts.card + 1) P.parts).card + P.parts.card * (s.card / P.parts.card) = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
tactic: rw [← sum_filter_add_sum_filter_not (s := P.parts)
      (p := fun x ↦ x.card = s.card / P.parts.card + 1),
    hP.filter_ne_average_add_one_eq_average,
    sum_const_nat (m := s.card / P.parts.card + 1) (by simp),
    sum_const_nat (m := s.card / P.parts.card) (by simp),
    ← hP.filter_ne_average_add_one_eq_average,
    mul_add, add_comm, ← add_assoc, ← add_mul, mul_one, add_comm (Finset.card _),
    filter_card_add_filter_neg_card_eq_card, add_comm] at z
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
z :
  (filter (fun x => x.card = s.card / P.parts.card + 1) P.parts).card + P.parts.card * (s.card / P.parts.card) = s.card
⊢ (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card = s.card % P.parts.card
state_after: no goals
tactic: rw [← add_left_inj, Nat.mod_add_div, z]
Theorem: PNat.factorMultiset_gcd
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: m n : ℕ+
⊢ (m.gcd n).factorMultiset = m.factorMultiset ⊓ n.factorMultiset
state_after: case a
m n : ℕ+
⊢ (m.gcd n).factorMultiset ≤ m.factorMultiset ⊓ n.factorMultiset

case a
m n : ℕ+
⊢ m.factorMultiset ⊓ n.factorMultiset ≤ (m.gcd n).factorMultiset
tactic: apply le_antisymm
Theorem: Nat.exists_mul_pow_lt_factorial
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n a c : ℕ
⊢ ∃ n0, ∀ n ≥ n0, a * c ^ n < (n - 1)!
state_after: case intro.intro
n a c n0 : ℕ
hn : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
⊢ ∃ n0, ∀ n ≥ n0, a * c ^ n < (n - 1)!
tactic: obtain ⟨n0, hn, h⟩ := Nat.exists_pow_lt_factorial (a * c)
state_before: case intro.intro
n a c n0 : ℕ
hn : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
⊢ ∃ n0, ∀ n ≥ n0, a * c ^ n < (n - 1)!
state_after: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ a * c ^ n ≤ (a * c) ^ n
tactic: refine ⟨n0, fun n hn => lt_of_le_of_lt ?_ (h n hn)⟩
state_before: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ a * c ^ n ≤ (a * c) ^ n
state_after: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ a * c ^ n ≤ a ^ n * c ^ n
tactic: rw [mul_pow]
state_before: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ a * c ^ n ≤ a ^ n * c ^ n
state_after: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ n ≠ 0
tactic: refine Nat.mul_le_mul_right _ (Nat.le_self_pow ?_ _)
state_before: case intro.intro
n✝ a c n0 : ℕ
hn✝ : n0 > 1
h : ∀ n ≥ n0, (a * c) ^ n < (n - 1)!
n : ℕ
hn : n ≥ n0
⊢ n ≠ 0
state_after: no goals
tactic: omega
Theorem: Subtype.range_coe
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
s : Set α
⊢ range val = s
state_after: α : Type u_1
s : Set α
⊢ val '' univ = s
tactic: rw [← image_univ]
state_before: α : Type u_1
s : Set α
⊢ val '' univ = s
state_after: no goals
tactic: simp [-image_univ, coe_image]
Theorem: MeasureTheory.measure_smul_setAverage
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g f : α → E
s : Set α
h : μ s ≠ ⊤
⊢ (μ s).toReal • ⨍ (x : α) in s, f x ∂μ = ∫ (x : α) in s, f x ∂μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g f : α → E
s : Set α
h : μ s ≠ ⊤
this : Fact (μ s < ⊤)
⊢ (μ s).toReal • ⨍ (x : α) in s, f x ∂μ = ∫ (x : α) in s, f x ∂μ
tactic: haveI := Fact.mk h.lt_top
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s✝ t : Set α
f✝ g f : α → E
s : Set α
h : μ s ≠ ⊤
this : Fact (μ s < ⊤)
⊢ (μ s).toReal • ⨍ (x : α) in s, f x ∂μ = ∫ (x : α) in s, f x ∂μ
state_after: no goals
tactic: rw [← measure_smul_average, restrict_apply_univ]