ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CompHausLike.hasPullbacksOfInclusions
File: Mathlib/Topology/Category/CompHausLike/Limits.lean

Proof steps:
state_before: P : TopCat → Prop
inst✝ : HasExplicitFiniteCoproducts P
hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → HasExplicitPullback f g
⊢ ∀ {X Y Z : CompHausLike P} (f : Z ⟶ X ⨿ Y), HasExplicitPullback coprod.inl f
state_after: P : TopCat → Prop
inst✝ : HasExplicitFiniteCoproducts P
hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → HasExplicitPullback f g
X✝ Y✝ Z✝ : CompHausLike P
f : Z✝ ⟶ X✝ ⨿ Y✝
⊢ HasExplicitPullback coprod.inl f
tactic: intro _ _ _ f
state_before: P : TopCat → Prop
inst✝ : HasExplicitFiniteCoproducts P
hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → HasExplicitPullback f g
X✝ Y✝ Z✝ : CompHausLike P
f : Z✝ ⟶ X✝ ⨿ Y✝
⊢ HasExplicitPullback coprod.inl f
state_after: case x
P : TopCat → Prop
inst✝ : HasExplicitFiniteCoproducts P
hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → HasExplicitPullback f g
X✝ Y✝ Z✝ : CompHausLike P
f : Z✝ ⟶ X✝ ⨿ Y✝
⊢ OpenEmbedding ⇑coprod.inl
tactic: apply hP'
state_before: case x
P : TopCat → Prop
inst✝ : HasExplicitFiniteCoproducts P
hP' : ∀ ⦃X Y B : CompHausLike P⦄ (f : X ⟶ B) (g : Y ⟶ B), OpenEmbedding ⇑f → HasExplicitPullback f g
X✝ Y✝ Z✝ : CompHausLike P
f : Z✝ ⟶ X✝ ⨿ Y✝
⊢ OpenEmbedding ⇑coprod.inl
state_after: no goals
tactic: exact Sigma.openEmbedding_ι _ _
Theorem: Set.preimage_eq
File: Mathlib/Data/Rel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → β
s : Set β
⊢ f ⁻¹' s = (Function.graph f).preimage s
state_after: no goals
tactic: simp [Set.preimage, Rel.preimage, Rel.inv, flip, Rel.image]
Theorem: mabs_mul_le
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ mabs (a * b) ≤ mabs a * mabs b
state_after: case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ a * b ≤ mabs a * mabs b

case a
α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a * b)⁻¹ ≤ mabs a * mabs b
tactic: apply sup_le
Theorem: Polynomial.coeff_erase
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n i : ℕ
⊢ (erase n p).coeff i = if i = n then 0 else p.coeff i
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n i : ℕ
toFinsupp✝ : R[ℕ]
⊢ (erase n { toFinsupp := toFinsupp✝ }).coeff i = if i = n then 0 else { toFinsupp := toFinsupp✝ }.coeff i
tactic: rcases p with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n i : ℕ
toFinsupp✝ : R[ℕ]
⊢ (erase n { toFinsupp := toFinsupp✝ }).coeff i = if i = n then 0 else { toFinsupp := toFinsupp✝ }.coeff i
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n i : ℕ
toFinsupp✝ : R[ℕ]
⊢ (Finsupp.erase n toFinsupp✝) i = if i = n then 0 else toFinsupp✝ i
tactic: simp only [erase_def, coeff]
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n i : ℕ
toFinsupp✝ : R[ℕ]
⊢ (Finsupp.erase n toFinsupp✝) i = if i = n then 0 else toFinsupp✝ i
state_after: no goals
tactic: exact ite_congr rfl (fun _ => rfl) (fun _ => rfl)
Theorem: finsuppTensorFinsupp_single
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Semiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
i : ι
m : M
k : κ
n : N
⊢ (finsuppTensorFinsupp R S M N ι κ) (Finsupp.single i m ⊗ₜ[R] Finsupp.single k n) = Finsupp.single (i, k) (m ⊗ₜ[R] n)
state_after: no goals
tactic: simp [finsuppTensorFinsupp]
Theorem: tsub_tsub_tsub_le_tsub
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c - a - (c - b) ≤ b - a
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c ≤ c - b + (a + (b - a))
tactic: rw [tsub_le_iff_left, tsub_le_iff_left, add_left_comm]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Preorder α
inst✝³ : AddCommSemigroup α
inst✝² : Sub α
inst✝¹ : OrderedSub α
a b c d : α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
⊢ c ≤ c - b + (a + (b - a))
state_after: no goals
tactic: exact le_tsub_add.trans (add_le_add_left le_add_tsub _)
Theorem: Finset.uIcc_injective_left
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : DistribLattice α
inst✝ : LocallyFiniteOrder α
a✝ a₁ a₂ b b₁ b₂ c x a : α
⊢ Injective (uIcc a)
state_after: no goals
tactic: simpa only [uIcc_comm] using uIcc_injective_right a
Theorem: Caratheodory.minCardFinsetOfMemConvexHull_nonempty
File: Mathlib/Analysis/Convex/Caratheodory.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ (minCardFinsetOfMemConvexHull hx).Nonempty
state_after: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ ((convexHull 𝕜) ↑(minCardFinsetOfMemConvexHull hx)).Nonempty
tactic: rw [← Finset.coe_nonempty, ← @convexHull_nonempty_iff 𝕜]
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ (convexHull 𝕜) s
⊢ ((convexHull 𝕜) ↑(minCardFinsetOfMemConvexHull hx)).Nonempty
state_after: no goals
tactic: exact ⟨x, mem_minCardFinsetOfMemConvexHull hx⟩
Theorem: CommMon_.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided_obj_obj
File: Mathlib/CategoryTheory/Monoidal/CommMon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : CommMon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ ((fun A =>
              { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X), map_id := ⋯, map_comp := ⋯, ε := A.one,
                μ := fun x x => A.mul, μ_natural_left := ⋯, μ_natural_right := ⋯, associativity := ⋯,
                left_unitality := ⋯, right_unitality := ⋯, braided := ⋯ })
            X✝).map
        x✝ ≫
      (fun x => f.hom) x✝¹ =
    (fun x => f.hom) x✝² ≫
      ((fun A =>
              { obj := fun x => A.X, map := fun {X Y} x => 𝟙 ((fun x => A.X) X), map_id := ⋯, map_comp := ⋯, ε := A.one,
                μ := fun x x => A.mul, μ_natural_left := ⋯, μ_natural_right := ⋯, associativity := ⋯,
                left_unitality := ⋯, right_unitality := ⋯, braided := ⋯ })
            Y✝).map
        x✝
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : CommMon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ 𝟙 X✝.X ≫ f.hom = f.hom ≫ 𝟙 Y✝.X
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X✝ Y✝ : CommMon_ C
f : X✝ ⟶ Y✝
x✝² x✝¹ : Discrete PUnit.{u + 1}
x✝ : x✝² ⟶ x✝¹
⊢ 𝟙 X✝.X ≫ f.hom = f.hom ≫ 𝟙 Y✝.X
state_after: no goals
tactic: rw [Category.id_comp, Category.comp_id]
Theorem: FirstOrder.Language.Equiv.refl_apply
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
x : M
⊢ (refl L M) x = x
state_after: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
x : M
⊢ { toEquiv := _root_.Equiv.refl M, map_fun' := ⋯, map_rel' := ⋯ } x = x
tactic: simp [refl]
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
x : M
⊢ { toEquiv := _root_.Equiv.refl M, map_fun' := ⋯, map_rel' := ⋯ } x = x
state_after: no goals
tactic: rfl
Theorem: RatFunc.ofFractionRing_smul
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝¹ : CommRing K
R : Type u_1
inst✝ : SMul R (FractionRing K[X])
c : R
p : FractionRing K[X]
⊢ { toFractionRing := c • p } = c • { toFractionRing := p }
state_after: no goals
tactic: simp only [SMul.smul, HSMul.hSMul, RatFunc.smul]
Theorem: Nat.cast_div_le
File: Mathlib/Data/Nat/Cast/Order/Field.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
m n : ℕ
⊢ ↑(m / n) ≤ ↑m / ↑n
state_after: case zero
α : Type u_1
inst✝ : LinearOrderedSemifield α
m : ℕ
⊢ ↑(m / 0) ≤ ↑m / ↑0

case succ
α : Type u_1
inst✝ : LinearOrderedSemifield α
m n✝ : ℕ
⊢ ↑(m / (n✝ + 1)) ≤ ↑m / ↑(n✝ + 1)
tactic: cases n
state_before: case succ
α : Type u_1
inst✝ : LinearOrderedSemifield α
m n✝ : ℕ
⊢ ↑(m / (n✝ + 1)) ≤ ↑m / ↑(n✝ + 1)
state_after: case succ
α : Type u_1
inst✝ : LinearOrderedSemifield α
m n✝ : ℕ
⊢ m / (n✝ + 1) * (n✝ + 1) ≤ m

case succ
α : Type u_1
inst✝ : LinearOrderedSemifield α
m n✝ : ℕ
⊢ 0 < ↑(n✝ + 1)
tactic: rw [le_div_iff, ← Nat.cast_mul, @Nat.cast_le]
Theorem: SimpleGraph.Walk.support_takeUntil_subset
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ p.support
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ (p.takeUntil u h).support ∨ x ∈ (p.dropUntil u h).support
tactic: rw [← take_spec p h, mem_support_append_iff]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : V
hx : x ∈ (p.takeUntil u h).support
⊢ x ∈ (p.takeUntil u h).support ∨ x ∈ (p.dropUntil u h).support
state_after: no goals
tactic: exact Or.inl hx
Theorem: Equiv.Perm.sum_cycleType
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
⊢ σ.cycleType.sum = σ.support.card
state_after: no goals
tactic: induction σ using cycle_induction_on with
  | base_one => simp
  | base_cycles σ hσ => rw [hσ.cycleType, sum_coe, List.sum_singleton]
  | induction_disjoint σ τ hd _ hσ hτ => rw [hd.cycleType, sum_add, hσ, hτ, hd.card_support_mul]
Theorem: HasCompactSupport.memℒp_of_bound
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ✝ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
X : Type u_5
inst✝² : TopologicalSpace X
inst✝¹ : MeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasureOnCompacts μ
f : X → E
hf : HasCompactSupport f
h2f : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : X) ∂μ, ‖f x‖ ≤ C
⊢ Memℒp f p μ
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ✝ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
X : Type u_5
inst✝² : TopologicalSpace X
inst✝¹ : MeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasureOnCompacts μ
f : X → E
hf : HasCompactSupport f
h2f : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : X) ∂μ, ‖f x‖ ≤ C
this : Memℒp f ⊤ μ
⊢ Memℒp f p μ
tactic: have := memℒp_top_of_bound h2f C hfC
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ✝ ν : Measure α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedAddCommGroup G
X : Type u_5
inst✝² : TopologicalSpace X
inst✝¹ : MeasurableSpace X
μ : Measure X
inst✝ : IsFiniteMeasureOnCompacts μ
f : X → E
hf : HasCompactSupport f
h2f : AEStronglyMeasurable f μ
C : ℝ
hfC : ∀ᵐ (x : X) ∂μ, ‖f x‖ ≤ C
this : Memℒp f ⊤ μ
⊢ Memℒp f p μ
state_after: no goals
tactic: exact this.memℒp_of_exponent_le_of_measure_support_ne_top
    (fun x ↦ image_eq_zero_of_nmem_tsupport) (hf.measure_lt_top.ne) le_top
Theorem: CategoryTheory.IsCofilteredOrEmpty.of_exists_of_isCofiltered_of_fullyFaithful
File: Mathlib/CategoryTheory/Filtered/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsCofilteredOrEmpty C
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsFilteredOrEmpty Cᵒᵖ
tactic: suffices IsFilteredOrEmpty Cᵒᵖ from isCofilteredOrEmpty_of_isFilteredOrEmpty_op _
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
⊢ IsFilteredOrEmpty Cᵒᵖ
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
tactic: refine IsFilteredOrEmpty.of_exists_of_isFiltered_of_fullyFaithful F.op (fun d => ?_)
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ unop d
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
tactic: obtain ⟨c, ⟨f⟩⟩ := h d.unop
state_before: case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝² : IsCofilteredOrEmpty D
inst✝¹ : F.Full
inst✝ : F.Faithful
h : ∀ (d : D), ∃ c, Nonempty (F.obj c ⟶ d)
d : Dᵒᵖ
c : C
f : F.obj c ⟶ unop d
⊢ ∃ c, Nonempty (d ⟶ F.op.obj c)
state_after: no goals
tactic: exact ⟨op c, ⟨f.op⟩⟩
Theorem: tsum_pos
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ 1 < ∏' (i : ι), g i
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ ∏' (x : ?m.49247), 1 < ∏' (i : ι), g i

ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ Type ?u.49244
tactic: rw [← tprod_one]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ ∏' (x : ?m.49247), 1 < ∏' (i : ι), g i

ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ Type ?u.49244
state_after: no goals
tactic: exact tprod_lt_tprod hg hi multipliable_one hsum
Theorem: NNReal.summable_condensed_iff
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
⊢ (Summable fun k => 2 ^ k * f (2 ^ k)) ↔ Summable f
state_after: case h.e'_1.h.e'_5.h.h.e'_5
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
x✝ : ℕ
⊢ 2 ^ x✝ = ↑(2 ^ (x✝ + 1)) - ↑(2 ^ x✝)
tactic: convert summable_schlomilch_iff hf (pow_pos zero_lt_two) (pow_right_strictMono _root_.one_lt_two)
    two_ne_zero h_succ_diff
state_before: case h.e'_1.h.e'_5.h.h.e'_5
f : ℕ → ℝ≥0
hf : ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → f n ≤ f m
h_succ_diff : SuccDiffBounded 2 fun x => 2 ^ x
x✝ : ℕ
⊢ 2 ^ x✝ = ↑(2 ^ (x✝ + 1)) - ↑(2 ^ x✝)
state_after: no goals
tactic: simp [pow_succ, mul_two, two_mul]
Theorem: Cardinal.mk_lt_aleph0_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
⊢ #α < ℵ₀ ↔ Finite α
state_after: no goals
tactic: simp [← not_le, aleph0_le_mk_iff]
Theorem: MvPolynomial.isEmptyAlgEquiv_apply
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
he : IsEmpty σ
⊢ (aeval fun a => he.elim a).comp (Algebra.ofId R (MvPolynomial σ R)) = AlgHom.id R R
state_after: no goals
tactic: ext
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
he : IsEmpty σ
⊢ (Algebra.ofId R (MvPolynomial σ R)).comp (aeval fun a => he.elim a) = AlgHom.id R (MvPolynomial σ R)
state_after: case hf.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
he : IsEmpty σ
i : σ
m : σ →₀ ℕ
⊢ coeff m (((Algebra.ofId R (MvPolynomial σ R)).comp (aeval fun a => he.elim a)) (X i)) =
    coeff m ((AlgHom.id R (MvPolynomial σ R)) (X i))
tactic: ext i m
state_before: case hf.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
he : IsEmpty σ
i : σ
m : σ →₀ ℕ
⊢ coeff m (((Algebra.ofId R (MvPolynomial σ R)).comp (aeval fun a => he.elim a)) (X i)) =
    coeff m ((AlgHom.id R (MvPolynomial σ R)) (X i))
state_after: no goals
tactic: exact IsEmpty.elim' he i
Theorem: Tree.mem_treesOfNumNodesEq
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

Proof steps:
state_before: x : Tree Unit
n : ℕ
⊢ x ∈ treesOfNumNodesEq n ↔ x.numNodes = n
state_after: no goals
tactic: induction x using Tree.unitRecOn generalizing n <;> cases n <;>
    simp [treesOfNumNodesEq_succ, *]
Theorem: Finset.smul_finset_neg
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : Monoid α
inst✝² : AddGroup β
inst✝¹ : DistribMulAction α β
inst✝ : DecidableEq β
a : α
s : Finset α
t : Finset β
⊢ a • -t = -(a • t)
state_after: no goals
tactic: simp only [← image_smul, ← image_neg, Function.comp, image_image, smul_neg]
Theorem: CategoryTheory.Limits.HasCoequalizersOfHasPushoutsAndBinaryCoproducts.pushoutInl_eq_pushout_inr
File: Mathlib/CategoryTheory/Limits/Constructions/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
G : C ⥤ D
inst✝¹ : HasBinaryCoproducts C
inst✝ : HasPushouts C
F : WalkingParallelPair ⥤ C
⊢ pushoutInl F =
    pushout.inr (coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.left))
      (coprod.desc (𝟙 (F.obj WalkingParallelPair.one)) (F.map WalkingParallelPairHom.right))
state_after: no goals
tactic: convert (whisker_eq Limits.coprod.inl pushout.condition :
    (_ : F.obj _ ⟶ constructCoequalizer _) = _) <;> simp
Theorem: Set.diag_image
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
s✝ t s : Set α
⊢ (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s
state_after: no goals
tactic: rw [← range_diag, ← image_preimage_eq_range_inter, diag_preimage_prod_self]
Theorem: Set.encard_eq_add_one_iff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b : α
k : ℕ∞
⊢ s.encard = k + 1 ↔ ∃ a t, a ∉ t ∧ insert a t = s ∧ t.encard = k
state_after: case refine_1
α : Type u_1
β : Type u_2
s t : Set α
a b : α
k : ℕ∞
h : s.encard = k + 1
⊢ ∃ a t, a ∉ t ∧ insert a t = s ∧ t.encard = k

case refine_2
α : Type u_1
β : Type u_2
s t : Set α
a b : α
k : ℕ∞
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.encard = k) → s.encard = k + 1
tactic: refine ⟨fun h ↦ ?_, ?_⟩
state_before: case refine_2
α : Type u_1
β : Type u_2
s t : Set α
a b : α
k : ℕ∞
⊢ (∃ a t, a ∉ t ∧ insert a t = s ∧ t.encard = k) → s.encard = k + 1
state_after: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
t✝ : Set α
a✝ b a : α
t : Set α
h : a ∉ t
⊢ (insert a t).encard = t.encard + 1
tactic: rintro ⟨a, t, h, rfl, rfl⟩
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
t✝ : Set α
a✝ b a : α
t : Set α
h : a ∉ t
⊢ (insert a t).encard = t.encard + 1
state_after: no goals
tactic: rw [encard_insert_of_not_mem h]
Theorem: Set.inter_prod
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ (s₁ ∩ s₂) ×ˢ t ↔ (x, y) ∈ s₁ ×ˢ t ∩ s₂ ×ˢ t
tactic: ext ⟨x, y⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ (s₁ ∩ s₂) ×ˢ t ↔ (x, y) ∈ s₁ ×ˢ t ∩ s₂ ×ˢ t
state_after: no goals
tactic: simp only [← and_and_right, mem_inter_iff, mem_prod]
Theorem: Comon_.tensorObj_comul'
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
M : Comon_ C
inst✝ : BraidedCategory C
A B : Comon_ C
⊢ (A ⊗ B).comul = (A.comul ⊗ B.comul) ≫ (tensor_μ Cᵒᵖ (op A.X, op B.X) (op A.X, op B.X)).unop
state_after: no goals
tactic: rfl
Theorem: LeftOrdContinuous.le_iff
File: Mathlib/Order/OrdContinuous.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
hf : LeftOrdContinuous f
h : Injective f
x y : α
⊢ f x ≤ f y ↔ x ≤ y
state_after: no goals
tactic: simp only [← sup_eq_right, ← hf.map_sup, h.eq_iff]
Theorem: Bool.not_eq_iff
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ {a b : Bool}, (!decide (a = b)) = true ↔ a ≠ b
state_after: no goals
tactic: decide
Theorem: WithBot.monotone_map_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((Monotone fun a => map f ↑a) ∧ ∀ (x : α), map f ⊥ ≤ map f ↑x) ↔ Monotone f
state_after: no goals
tactic: simp [Monotone]