ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HomologicalComplex.natIsoSc'_hom_app_τ₁
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
K : HomologicalComplex C c
⊢ (K.XIsoOfEq hi).hom ≫ ((shortComplexFunctor' C c i j k).obj K).f =
    ((shortComplexFunctor C c j).obj K).f ≫ (Iso.refl ((shortComplexFunctor C c j).obj K).X₂).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
K : HomologicalComplex C c
⊢ (Iso.refl ((shortComplexFunctor C c j).obj K).X₂).hom ≫ ((shortComplexFunctor' C c i j k).obj K).g =
    ((shortComplexFunctor C c j).obj K).g ≫ (K.XIsoOfEq hk).hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.3350, u_1} C
inst✝ : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
i j k : ι
hi : c.prev j = i
hk : c.next j = k
⊢ ∀ {X Y : HomologicalComplex C c} (f : X ⟶ Y),
    (shortComplexFunctor C c j).map f ≫
        ((fun K =>
              ShortComplex.isoMk (K.XIsoOfEq hi) (Iso.refl ((shortComplexFunctor C c j).obj K).X₂) (K.XIsoOfEq hk) ⋯ ⋯)
            Y).hom =
      ((fun K =>
              ShortComplex.isoMk (K.XIsoOfEq hi) (Iso.refl ((shortComplexFunctor C c j).obj K).X₂) (K.XIsoOfEq hk) ⋯ ⋯)
            X).hom ≫
        (shortComplexFunctor' C c i j k).map f
state_after: no goals
tactic: aesop_cat
Theorem: RingHom.ker_isPrime
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
⊢ ker f ≠ ⊤
state_after: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
⊢ 1 ∉ ker f
tactic: rw [Ne, Ideal.eq_top_iff_one]
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
⊢ 1 ∉ ker f
state_after: no goals
tactic: exact not_one_mem_ker f
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain S
inst✝¹ : FunLike F R S
inst✝ : RingHomClass F R S
f : F
x y : R
⊢ x * y ∈ ker f → x ∈ ker f ∨ y ∈ ker f
state_after: no goals
tactic: simpa only [mem_ker, map_mul] using @eq_zero_or_eq_zero_of_mul_eq_zero S _ _ _ _ _
Theorem: IsSeqCompact.range
File: Mathlib/Topology/Sequences.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
f : X → Y
inst✝ : SeqCompactSpace X
f_cont : SeqContinuous f
⊢ IsSeqCompact (Set.range f)
state_after: no goals
tactic: simpa using isSeqCompact_univ.image f_cont
Theorem: Sum.forall_sum
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
⊢ (∀ (fab : (ab : α ⊕ β) → γ ab), p fab) ↔
    ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
state_after: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
⊢ p fab
tactic: refine ⟨fun h fa fb => h _, fun h fab => ?_⟩
state_before: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
⊢ p fab
state_after: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
⊢ p fab
tactic: have h1 : fab = Sum.rec (fun a => fab (Sum.inl a)) (fun b => fab (Sum.inr b)) := by
    ext ab; cases ab <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
⊢ p fab
state_after: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
⊢ p fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
tactic: rw [h1]
state_before: α : Type u_1
β : Type u_2
γ : α ⊕ β → Sort u_3
p : ((ab : α ⊕ β) → γ ab) → Prop
h : ∀ (fa : (val : α) → γ (inl val)) (fb : (val : β) → γ (inr val)), p fun t => rec fa fb t
fab : (ab : α ⊕ β) → γ ab
h1 : fab = fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
⊢ p fun t => rec (fun a => fab (inl a)) (fun b => fab (inr b)) t
state_after: no goals
tactic: exact h _ _
Theorem: MeasureTheory.integral_finset
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
hE : CompleteSpace E
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedSpace 𝕜 E
inst✝⁸ : SMulCommClass ℝ 𝕜 E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : CompleteSpace F
G : Type u_5
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
X : Type u_6
inst✝² : TopologicalSpace X
inst✝¹ : FirstCountableTopology X
ν : Measure α
inst✝ : MeasurableSingletonClass α
s : Finset α
f : α → E
hf : Integrable f (μ.restrict ↑s)
⊢ ∫ (x : α) in ↑s, f x ∂μ = ∑ x ∈ s, (μ {x}).toReal • f x
state_after: no goals
tactic: rw [integral_countable _ s.countable_toSet hf, ← Finset.tsum_subtype']
Theorem: MeasureTheory.quasiMeasurePreserving_sub_of_right_invariant
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
⊢ QuasiMeasurePreserving (fun p => p.1 / p.2) (μ.prod ν) μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
y : G
⊢ QuasiMeasurePreserving (fun x => (x, y).1 / (x, y).2) μ μ
tactic: refine QuasiMeasurePreserving.prod_of_left measurable_div (eventually_of_forall fun y => ?_)
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulRightInvariant
y : G
⊢ QuasiMeasurePreserving (fun x => (x, y).1 / (x, y).2) μ μ
state_after: no goals
tactic: exact (measurePreserving_div_right μ y).quasiMeasurePreserving
Theorem: OrderedCommGroup.to_contravariantClass_right_le
File: Mathlib/Algebra/Order/Group/Defs.lean

Proof steps:
state_before: α✝ α : Type u
inst✝ : OrderedCommGroup α
a b c : α
bc : swap (fun x x_1 => x * x_1) a b ≤ swap (fun x x_1 => x * x_1) a c
⊢ b ≤ c
state_after: no goals
tactic: simpa using mul_le_mul_right' bc a⁻¹
Theorem: Directed.sequence_mono_nat
File: Mathlib/Logic/Encodable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
⊢ r (f (Directed.sequence f hf n)) (f (Directed.sequence f hf (n + 1)))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
⊢ r (f (Directed.sequence f hf n))
    (f
      (match decode n with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))
tactic: dsimp [Directed.sequence]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
⊢ r (f (Directed.sequence f hf n))
    (f
      (match decode n with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
⊢ r (f p)
    (f
      (match decode n with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))
tactic: generalize hf.sequence f n = p
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
⊢ r (f p)
    (f
      (match decode n with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))
state_after: case none
α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
⊢ r (f p)
    (f
      (match none with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))

case some
α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p a : α
⊢ r (f p)
    (f
      (match some a with
      | none => Classical.choose ⋯
      | some a => Classical.choose ⋯))
tactic: cases' (decode n : Option α) with a
Theorem: QuotientGroup.isClosedMap_coe
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
H : Subgroup G
hH : IsCompact ↑H
⊢ IsClosedMap mk
state_after: G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ IsClosed (mk '' t)
tactic: intro t ht
state_before: G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ IsClosed (mk '' t)
state_after: G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ IsClosed (Quotient.mk' ⁻¹' (mk '' t))
tactic: rw [← quotientMap_quotient_mk'.isClosed_preimage]
state_before: G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ IsClosed (Quotient.mk' ⁻¹' (mk '' t))
state_after: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ Quotient.mk' ⁻¹' (mk '' t) = t * ↑H
tactic: convert ht.mul_right_of_isCompact hH
state_before: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ Quotient.mk' ⁻¹' (mk '' t) = t * ↑H
state_after: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ ⋃ x, (fun x_1 => x_1 * ↑x) '' t = t * ↑H
tactic: refine (QuotientGroup.preimage_image_mk_eq_iUnion_image _ _).trans ?_
state_before: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ ⋃ x, (fun x_1 => x_1 * ↑x) '' t = t * ↑H
state_after: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ ⋃ x, ⋃ (hx : x ∈ H), (fun x_1 => x_1 * ↑⟨x, hx⟩) '' t = ⋃ a ∈ ↑H, (fun x => x * a) '' t
tactic: rw [iUnion_subtype, ← iUnion_mul_right_image]
state_before: case h.e'_3
G : Type w
H✝ : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t✝ : Set G
H : Subgroup G
hH : IsCompact ↑H
t : Set G
ht : IsClosed t
⊢ ⋃ x, ⋃ (hx : x ∈ H), (fun x_1 => x_1 * ↑⟨x, hx⟩) '' t = ⋃ a ∈ ↑H, (fun x => x * a) '' t
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.Kernel.iIndepSet.indep_generateFrom_le
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝¹ : LinearOrder ι
inst✝ : IsMarkovKernel κ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s κ μ
i k : ι
hk : i < k
⊢ Indep (generateFrom {s k}) (generateFrom {t | ∃ j ≤ i, s j = t}) κ μ
state_after: case h.e'_4.h.e'_2
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝¹ : LinearOrder ι
inst✝ : IsMarkovKernel κ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s κ μ
i k : ι
hk : i < k
⊢ {s k} = {t | ∃ n ∈ {k}, s n = t}
tactic: convert iIndepSet.indep_generateFrom_of_disjoint hsm hs {k} { j | j ≤ i }
      (Set.disjoint_singleton_left.mpr hk.not_le)
state_before: case h.e'_4.h.e'_2
α : Type u_1
Ω : Type u_2
ι : Type u_3
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
inst✝¹ : LinearOrder ι
inst✝ : IsMarkovKernel κ
s : ι → Set Ω
hsm : ∀ (n : ι), MeasurableSet (s n)
hs : iIndepSet s κ μ
i k : ι
hk : i < k
⊢ {s k} = {t | ∃ n ∈ {k}, s n = t}
state_after: no goals
tactic: simp only [Set.mem_singleton_iff, exists_prop, exists_eq_left, Set.setOf_eq_eq_singleton']
Theorem: DFinsupp.comp_liftAddHom
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
δ : Type u_1
inst✝² : (i : ι) → AddZeroClass (β i)
inst✝¹ : AddCommMonoid γ
inst✝ : AddCommMonoid δ
g : γ →+ δ
f : (i : ι) → β i →+ γ
a : ι
⊢ liftAddHom.symm (g.comp (liftAddHom f)) a = g.comp (f a)
state_after: no goals
tactic: rw [liftAddHom_symm_apply, AddMonoidHom.comp_assoc, liftAddHom_comp_single]
Theorem: ENNReal.tendsto_toReal_iff
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∞
ι : Type u_4
fi : Filter ι
f : ι → ℝ≥0∞
hf : ∀ (i : ι), f i ≠ ⊤
x : ℝ≥0∞
hx : x ≠ ⊤
⊢ Tendsto (fun n => (f n).toReal) fi (𝓝 x.toReal) ↔ Tendsto f fi (𝓝 x)
state_after: case intro
α : 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∞
ι : Type u_4
fi : Filter ι
x : ℝ≥0∞
hx : x ≠ ⊤
f : ι → ℝ≥0
⊢ Tendsto (fun n => ((fun i => ↑(f i)) n).toReal) fi (𝓝 x.toReal) ↔ Tendsto (fun i => ↑(f i)) fi (𝓝 x)
tactic: lift f to ι → ℝ≥0 using hf
state_before: case intro
α : 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∞
ι : Type u_4
fi : Filter ι
x : ℝ≥0∞
hx : x ≠ ⊤
f : ι → ℝ≥0
⊢ Tendsto (fun n => ((fun i => ↑(f i)) n).toReal) fi (𝓝 x.toReal) ↔ Tendsto (fun i => ↑(f i)) fi (𝓝 x)
state_after: case intro.intro
α : 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∞
ι : Type u_4
fi : Filter ι
f : ι → ℝ≥0
x : ℝ≥0
⊢ Tendsto (fun n => ((fun i => ↑(f i)) n).toReal) fi (𝓝 (↑x).toReal) ↔ Tendsto (fun i => ↑(f i)) fi (𝓝 ↑x)
tactic: lift x to ℝ≥0 using hx
state_before: case intro.intro
α : 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∞
ι : Type u_4
fi : Filter ι
f : ι → ℝ≥0
x : ℝ≥0
⊢ Tendsto (fun n => ((fun i => ↑(f i)) n).toReal) fi (𝓝 (↑x).toReal) ↔ Tendsto (fun i => ↑(f i)) fi (𝓝 ↑x)
state_after: no goals
tactic: simp [tendsto_coe]
Theorem: Traversable.map_traverse
File: Mathlib/Control/Traversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ map f <$> traverse g x = traverse (map f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (pure ∘ f) <$> traverse g x = traverse (map f ∘ g) x
tactic: rw [map_eq_traverse_id f]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (pure ∘ f) <$> traverse g x = traverse (map f ∘ g) x
state_after: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (Comp.mk ∘ map (pure ∘ f) ∘ g) x = traverse (map f ∘ g) x
tactic: refine (comp_traverse (pure ∘ f) g x).symm.trans ?_
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ traverse (Comp.mk ∘ map (pure ∘ f) ∘ g) x = traverse (map f ∘ g) x
state_after: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
tactic: congr
state_before: case h.e_4.h
t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
x : t α
⊢ Comp.instApplicativeComp = inst✝³
state_after: no goals
tactic: apply Comp.applicative_comp_id
Theorem: TopCat.pullback_fst_range
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
⊢ Set.range ⇑(pullback.fst f g) = {x | ∃ y, f x = g y}
state_after: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑(pullback.fst f g) ↔ x ∈ {x | ∃ y, f x = g y}
tactic: ext x
state_before: case h
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑(pullback.fst f g) ↔ x ∈ {x | ∃ y, f x = g y}
state_after: case h.mp
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ Set.range ⇑(pullback.fst f g) → x ∈ {x | ∃ y, f x = g y}

case h.mpr
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
x : ↑X
⊢ x ∈ {x | ∃ y, f x = g y} → x ∈ Set.range ⇑(pullback.fst f g)
tactic: constructor
Theorem: multiplicity.finite_int_iff_natAbs_finite
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a b : ℤ
⊢ Finite a b ↔ Finite a.natAbs b.natAbs
state_after: no goals
tactic: simp only [finite_def, ← Int.natAbs_dvd_natAbs, Int.natAbs_pow]
Theorem: Nat.floor_eq_iff'
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
hn : n ≠ 0
⊢ ⌊a⌋₊ = n ↔ ↑n ≤ a ∧ a < ↑n + 1
state_after: no goals
tactic: rw [← le_floor_iff' hn, ← Nat.cast_one, ← Nat.cast_add, ← floor_lt' (Nat.add_one_ne_zero n),
    Nat.lt_add_one_iff, le_antisymm_iff, and_comm]
Theorem: disjoint_sup_right
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderBot α
a b c : α
⊢ Disjoint a (b ⊔ c) ↔ Disjoint a b ∧ Disjoint a c
state_after: no goals
tactic: simp only [disjoint_iff, inf_sup_left, sup_eq_bot_iff]
Theorem: AlgebraicTopology.DoldKan.homotopyPInftyToId_hom
File: Mathlib/AlgebraicTopology/DoldKan/HomotopyEquivalence.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.13714, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ PInfty.f n =
    (((dNext n) fun i j => (homotopyPToId X (j + 1)).hom i j) +
        (prevD n) fun i j => (homotopyPToId X (j + 1)).hom i j) +
      (𝟙 K[X]).f n
state_after: case zero
C : Type u_1
inst✝¹ : Category.{?u.13714, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ PInfty.f 0 =
    (((dNext 0) fun i j => (homotopyPToId X (j + 1)).hom i j) +
        (prevD 0) fun i j => (homotopyPToId X (j + 1)).hom i j) +
      (𝟙 K[X]).f 0

case succ
C : Type u_1
inst✝¹ : Category.{?u.13714, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ PInfty.f (n + 1) =
    (((dNext (n + 1)) fun i j => (homotopyPToId X (j + 1)).hom i j) +
        (prevD (n + 1)) fun i j => (homotopyPToId X (j + 1)).hom i j) +
      (𝟙 K[X]).f (n + 1)
tactic: rcases n with _|n
Theorem: Polynomial.irreducible_mul_leadingCoeff_inv
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
⊢ Irreducible (p * C p.leadingCoeff⁻¹) ↔ Irreducible p
state_after: case pos
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp0 : p = 0
⊢ Irreducible (p * C p.leadingCoeff⁻¹) ↔ Irreducible p

case neg
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp0 : ¬p = 0
⊢ Irreducible (p * C p.leadingCoeff⁻¹) ↔ Irreducible p
tactic: by_cases hp0 : p = 0
state_before: case neg
R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
K : Type u_1
inst✝ : DivisionRing K
p : K[X]
hp0 : ¬p = 0
⊢ Irreducible (p * C p.leadingCoeff⁻¹) ↔ Irreducible p
state_after: no goals
tactic: exact irreducible_mul_isUnit
    (isUnit_C.mpr (IsUnit.mk0 _ (inv_ne_zero (leadingCoeff_ne_zero.mpr hp0))))
Theorem: Fin.coe_cycleRange_of_lt
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
i j : Fin n.succ
h : j < i
⊢ ↑(i.cycleRange j) = ↑j + 1
state_after: no goals
tactic: rw [coe_cycleRange_of_le h.le, if_neg h.ne]