ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isLindelof_singleton
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x : X
f : Filter X
hf : f.NeBot
x✝ : CountableInterFilter f
hfa : f ≤ 𝓟 {x}
⊢ 𝓟 {x} ≤ 𝓝 x
state_after: no goals
tactic: simpa only [principal_singleton] using pure_le_nhds x
Theorem: Relation.TransGen.trans_left
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
a b c d : α
hab : TransGen r a b
hbc : ReflTransGen r b c
⊢ TransGen r a c
state_after: no goals
tactic: induction hbc with
  | refl => assumption
  | tail _ hcd hac => exact hac.tail hcd
Theorem: Nat.size_zero
File: Mathlib/Data/Nat/Size.lean

Proof steps:
state_before: ⊢ size 0 = 0
state_after: no goals
tactic: simp [size]
Theorem: Polynomial.exists_root_of_splits'
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hs : Splits i f
hf0 : (map i f).degree ≠ 0
this : DecidableEq L := Classical.decEq L
hf0' : map i f = 0
⊢ ∃ x, eval₂ i x f = 0
state_after: no goals
tactic: simp [eval₂_eq_eval_map, hf0']
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i✝ : K →+* L
f : K[X]
hs : Splits i✝ f
hf0 : (map i✝ f).degree ≠ 0
this : DecidableEq L := Classical.decEq L
hf0' : ¬map i✝ f = 0
g : L[X]
hg : Irreducible g ∧ g ∣ map i✝ f
x : L
hx : g.IsRoot x
i : L[X]
hi : map i✝ f = g * i
⊢ eval₂ i✝ x f = 0
state_after: no goals
tactic: rw [← eval_map, hi, eval_mul, show _ = _ from hx, zero_mul]
Theorem: Algebra.Presentation.localizationAway_relation
File: Mathlib/RingTheory/Presentation.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span (Set.range fun x => C r * X () - 1) = (Generators.localizationAway r).ker
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span {C r * X () - 1} = (Generators.localizationAway r).ker
tactic: simp only [Generators.localizationAway_vars, Set.range_const]
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Presentation R S
r : R
inst✝ : IsLocalization.Away r S
⊢ Ideal.span {C r * X () - 1} = (Generators.localizationAway r).ker
state_after: no goals
tactic: apply span_range_relation_eq_ker_localizationAway r
Theorem: CategoryTheory.StructuredArrow.homMk'_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ f = mk (f.hom ≫ T.map (𝟙 f.right))
state_after: no goals
tactic: aesop_cat
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ f.homMk' (𝟙 f.right) = eqToHom ⋯
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (f.homMk' (𝟙 f.right)).right = (eqToHom ⋯).right
tactic: ext
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (f.homMk' (𝟙 f.right)).right = (eqToHom ⋯).right
state_after: no goals
tactic: simp [eqToHom_right]
Theorem: Ordnode.node4L_size
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
hm : m.Sized
⊢ (l.node4L x m y r).size = l.size + m.size + r.size + 2
state_after: no goals
tactic: cases m <;> simp [node4L, node3L, node'] <;> [abel; (simp [size, hm.1]; abel)]
Theorem: add_sub_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 : G
⊢ a * b / b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_inv_cancel_right a b]
Theorem: Applicative.pure_seq_eq_map'
File: Mathlib/Control/Applicative.lean

Proof steps:
state_before: F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
⊢ (fun x => Seq.seq (pure f) fun x_1 => x) = fun x => f <$> x
state_after: case h
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
x✝ : F α
⊢ (Seq.seq (pure f) fun x => x✝) = f <$> x✝
tactic: ext
state_before: case h
F : Type u → Type v
inst✝¹ : Applicative F
inst✝ : LawfulApplicative F
α β γ σ : Type u
f : α → β
x✝ : F α
⊢ (Seq.seq (pure f) fun x => x✝) = f <$> x✝
state_after: no goals
tactic: simp [functor_norm]
Theorem: Multiset.disjoint_ndinsert_right
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ s.Disjoint (ndinsert a t) ↔ a ∉ s ∧ s.Disjoint t
state_after: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ a ∉ s ∧ t.Disjoint s ↔ a ∉ s ∧ s.Disjoint t
tactic: rw [disjoint_comm, disjoint_ndinsert_left]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ a ∉ s ∧ t.Disjoint s ↔ a ∉ s ∧ s.Disjoint t
state_after: no goals
tactic: tauto
Theorem: List.cyclicPermutations_ne_nil
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l✝ l' : List α
a : α
l : List α
h : (a :: l).cyclicPermutations = []
⊢ False
state_after: no goals
tactic: simpa using congr_arg length h
Theorem: AntilipschitzWith.isBounded_of_image2_left
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : IsBounded (image2 f s t)
⊢ IsBounded s ∨ IsBounded t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬IsBounded s ∧ ¬IsBounded t
⊢ ¬IsBounded (image2 f s t)
tactic: contrapose! hst
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬IsBounded s ∧ ¬IsBounded t
⊢ ¬IsBounded (image2 f s t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬IsBounded s ∧ ¬IsBounded t
b : β
hb : b ∈ t
⊢ ¬IsBounded (image2 f s t)
tactic: obtain ⟨b, hb⟩ : t.Nonempty := nonempty_of_not_isBounded hst.2
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬IsBounded s ∧ ¬IsBounded t
b : β
hb : b ∈ t
⊢ ¬IsBounded (image2 f s t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
f✝ : α → β
f : α → β → γ
K₁ : ℝ≥0
hf : ∀ (b : β), AntilipschitzWith K₁ fun a => f a b
s : Set α
t : Set β
hst : ¬IsBounded s ∧ ¬IsBounded t
b : β
hb : b ∈ t
this : ¬IsBounded (image2 f s {b})
⊢ ¬IsBounded (image2 f s t)
tactic: have : ¬IsBounded (Set.image2 f s {b}) := by
    intro h
    apply hst.1
    rw [Set.image2_singleton_right] at h
    replace h := (hf b).isBounded_preimage h
    exact h.subset (subset_preimage_image _ _)
Theorem: Prop.isAtom_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
p : Prop
⊢ IsAtom p ↔ p
state_after: no goals
tactic: simp [IsAtom, show ⊥ = False from rfl, fun q r : Prop => show q < r ↔ _ ∧ _ from .rfl]
Theorem: CategoryTheory.MonoidalCategory.hom_inv_whiskerRight
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y : C
f : X ≅ Y
Z : C
⊢ f.hom ▷ Z ≫ f.inv ▷ Z = 𝟙 (X ⊗ Z)
state_after: no goals
tactic: rw [← comp_whiskerRight, hom_inv_id, id_whiskerRight]
Theorem: RingHom.RespectsIso.cancel_left_isIso
File: Mathlib/RingTheory/RingHomProperties.lean

Proof steps:
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
R S T : CommRingCat
f : R ⟶ S
g : S ⟶ T
inst✝ : IsIso f
H : P (f ≫ g)
⊢ P g
state_after: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
R S T : CommRingCat
f : R ⟶ S
g : S ⟶ T
inst✝ : IsIso f
H : P (f ≫ g)
⊢ g = comp (f ≫ g) (asIso f).symm.commRingCatIsoToRingEquiv.toRingHom
tactic: convert hP.2 (f ≫ g) (asIso f).symm.commRingCatIsoToRingEquiv H
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
R S T : CommRingCat
f : R ⟶ S
g : S ⟶ T
inst✝ : IsIso f
H : P (f ≫ g)
⊢ g = comp (f ≫ g) (asIso f).symm.commRingCatIsoToRingEquiv.toRingHom
state_after: no goals
tactic: exact (IsIso.inv_hom_id_assoc _ _).symm
Theorem: Ordinal.brange_bfamilyOfFamily'
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
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
⊢ (type r).brange (bfamilyOfFamily' r f) = range f
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
a : α
⊢ a ∈ (type r).brange (bfamilyOfFamily' r f) → a ∈ range f

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
r : ι → ι → Prop
inst✝ : IsWellOrder ι r
f : ι → α
a : α
⊢ a ∈ range f → a ∈ (type r).brange (bfamilyOfFamily' r f)
tactic: refine Set.ext fun a => ⟨?_, ?_⟩
Theorem: Asymptotics.isLittleO_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ f =o[map k l] g ↔ (f ∘ k) =o[l] (g ∘ k)
state_after: no goals
tactic: simp only [IsLittleO_def, isBigOWith_map]
Theorem: Real.cos_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ cos (π / 2 - x) = sin x
state_after: no goals
tactic: rw [← cos_neg, neg_sub, cos_sub_pi_div_two]
Theorem: HahnSeries.min_orderTop_le_orderTop_sub
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : AddGroup R
Γ : Type u_3
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
⊢ min x.orderTop y.orderTop ≤ (x - y).orderTop
state_after: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : AddGroup R
Γ : Type u_3
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
⊢ min x.orderTop (-y).orderTop ≤ (x + -y).orderTop
tactic: rw [sub_eq_add_neg, ← orderTop_neg (x := y)]
state_before: Γ✝ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ✝
inst✝¹ : AddGroup R
Γ : Type u_3
inst✝ : LinearOrder Γ
x y : HahnSeries Γ R
⊢ min x.orderTop (-y).orderTop ≤ (x + -y).orderTop
state_after: no goals
tactic: exact min_orderTop_le_orderTop_add
Theorem: Real.tan_two_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: x : ℝ
⊢ tan (2 * x) = 2 * tan x / (1 - tan x ^ 2)
state_after: x : ℝ
this : Complex.tan (2 * ↑x) = 2 * Complex.tan ↑x / (1 - Complex.tan ↑x ^ 2)
⊢ tan (2 * x) = 2 * tan x / (1 - tan x ^ 2)
tactic: have := @Complex.tan_two_mul x
state_before: x : ℝ
this : Complex.tan (2 * ↑x) = 2 * Complex.tan ↑x / (1 - Complex.tan ↑x ^ 2)
⊢ tan (2 * x) = 2 * tan x / (1 - tan x ^ 2)
state_after: no goals
tactic: norm_cast at *
Theorem: CochainComplex.HomComplex.Cochain.ofHom_sub
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
φ₁ φ₂ : F ⟶ G
⊢ ofHom (φ₁ - φ₂) = ofHom φ₁ - ofHom φ₂
state_after: no goals
tactic: aesop_cat
Theorem: Comon_.Comon_ToMon_OpOp_map
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op).unop =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one.unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op).unop =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one.unop
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op =
    (f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op).unop =
    ((f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul).unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op).unop =
    ((f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul).unop
state_after: no goals
tactic: simp [op_tensorHom]
Theorem: Computation.of_results_bind
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
f : α → Computation β
b : β
k : ℕ
⊢ (s.bind f).Results b k → ∃ a m n, s.Results a m ∧ (f a).Results b n ∧ k = n + m
state_after: α : Type u
β : Type v
γ : Type w
f : α → Computation β
b : β
s : Computation α
e : α
h : ((pure e).bind f).Results b 0
⊢ ∃ a m n, (pure e).Results a m ∧ (f a).Results b n ∧ 0 = n + m

α : Type u
β : Type v
γ : Type w
f : α → Computation β
b : β
s e : Computation α
h : (e.think.bind f).Results b 0
⊢ ∃ a m n, e.think.Results a m ∧ (f a).Results b n ∧ 0 = n + m

α : Type u
β : Type v
γ : Type w
f : α → Computation β
b : β
n : ℕ
IH : ∀ {s : Computation α}, (s.bind f).Results b n → ∃ a m n_1, s.Results a m ∧ (f a).Results b n_1 ∧ n = n_1 + m
s : Computation α
e : α
h : ((pure e).bind f).Results b (n + 1)
⊢ ∃ a m n_1, (pure e).Results a m ∧ (f a).Results b n_1 ∧ n + 1 = n_1 + m

α : Type u
β : Type v
γ : Type w
f : α → Computation β
b : β
n : ℕ
IH : ∀ {s : Computation α}, (s.bind f).Results b n → ∃ a m n_1, s.Results a m ∧ (f a).Results b n_1 ∧ n = n_1 + m
s e : Computation α
h : (e.think.bind f).Results b (n + 1)
⊢ ∃ a m n_1, e.think.Results a m ∧ (f a).Results b n_1 ∧ n + 1 = n_1 + m
tactic: induction' k with n IH generalizing s <;> apply recOn s (fun a => _) fun s' => _ <;> intro e h
Theorem: groupCohomology.toCocycles_comp_isoTwoCocycles_hom
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ toCocycles A 1 2 ≫ (isoTwoCocycles A).hom =
    (oneCochainsLequiv A).toModuleIso.hom ≫ ModuleCat.ofHom (shortComplexH2 A).moduleCatToCycles
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ↑(oneCochainsLequiv A) ≫ (shortComplexH2 A).moduleCatToCycles =
    ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (shortComplexH2 A).moduleCatToCycles
tactic: simp [isoTwoCocycles]
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
⊢ ↑(oneCochainsLequiv A) ≫ (shortComplexH2 A).moduleCatToCycles =
    ↑(oneCochainsLequiv A) ≫ ModuleCat.ofHom (shortComplexH2 A).moduleCatToCycles
state_after: no goals
tactic: rfl
Theorem: antitone_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ Antitone (⇑toDual ∘ f ∘ ⇑ofDual) ↔ Antitone f
state_after: no goals
tactic: rw [antitone_toDual_comp_iff, monotone_comp_ofDual_iff]
Theorem: min_def
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ min a b = if a ≤ b then a else b
state_after: no goals
tactic: rw [LinearOrder.min_def a]
Theorem: cfc_smul
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁴ : CommSemiring R
inst✝¹³ : StarRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : TopologicalSpace A
inst✝⁸ : Ring A
inst✝⁷ : StarRing A
inst✝⁶ : Algebra R A
inst✝⁵ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
S : Type u_3
inst✝⁴ : SMul S R
inst✝³ : ContinuousConstSMul S R
inst✝² : SMulZeroClass S A
inst✝¹ : IsScalarTower S R A
inst✝ : IsScalarTower S R (R → R)
s : S
f : R → R
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
⊢ cfc (fun x => s • f x) a = s • cfc f a
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁴ : CommSemiring R
inst✝¹³ : StarRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : TopologicalSpace A
inst✝⁸ : Ring A
inst✝⁷ : StarRing A
inst✝⁶ : Algebra R A
inst✝⁵ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
S : Type u_3
inst✝⁴ : SMul S R
inst✝³ : ContinuousConstSMul S R
inst✝² : SMulZeroClass S A
inst✝¹ : IsScalarTower S R A
inst✝ : IsScalarTower S R (R → R)
s : S
f : R → R
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : p a
⊢ cfc (fun x => s • f x) a = s • cfc f a

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁴ : CommSemiring R
inst✝¹³ : StarRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : TopologicalSpace A
inst✝⁸ : Ring A
inst✝⁷ : StarRing A
inst✝⁶ : Algebra R A
inst✝⁵ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
S : Type u_3
inst✝⁴ : SMul S R
inst✝³ : ContinuousConstSMul S R
inst✝² : SMulZeroClass S A
inst✝¹ : IsScalarTower S R A
inst✝ : IsScalarTower S R (R → R)
s : S
f : R → R
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : ¬p a
⊢ cfc (fun x => s • f x) a = s • cfc f a
tactic: by_cases ha : p a
Theorem: Filter.tendsto_const_mul_atBot_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => r * f x) l atBot ↔ Tendsto f l atTop
state_after: no goals
tactic: simpa only [neg_mul, tendsto_neg_atTop_iff] using tendsto_const_mul_atTop_of_pos (neg_pos.2 hr)
Theorem: Set.indicator_compl_add_self_apply
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✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : a ∈ s
⊢ sᶜ.mulIndicator f a * s.mulIndicator f a = f a
state_after: no goals
tactic: simp [ha]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g : α → M
a✝ : α
s : Set α
f : α → M
a : α
ha : a ∉ s
⊢ sᶜ.mulIndicator f a * s.mulIndicator f a = f a
state_after: no goals
tactic: simp [ha]
Theorem: geom_sum₂_with_one
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
inst✝ : Semiring α
x : α
n i : ℕ
x✝ : i ∈ range n
⊢ x ^ i * 1 ^ (n - 1 - i) = x ^ i
state_after: no goals
tactic: rw [one_pow, mul_one]
Theorem: Cardinal.add_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b : Cardinal.{u_1}
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑m + ↑n < ℵ₀
state_after: α β : Type u
a b : Cardinal.{u_1}
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑(m + n) < ℵ₀
tactic: rw [← Nat.cast_add]
state_before: α β : Type u
a b : Cardinal.{u_1}
m n : ℕ
ha : ↑m < ℵ₀
hb : ↑n < ℵ₀
⊢ ↑(m + n) < ℵ₀
state_after: no goals
tactic: apply nat_lt_aleph0
Theorem: AlgebraicGeometry.PresheafedSpace.restrictTopIso_hom
File: Mathlib/Geometry/RingedSpace/PresheafedSpace.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
⊢ X.ofRestrict ⋯ ≫ X.toRestrictTop = 𝟙 (X.restrict ⋯)
state_after: case w.w
C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
x✝ : (CategoryTheory.forget TopCat).obj ↑(X.restrict ⋯)
⊢ (X.ofRestrict ⋯ ≫ X.toRestrictTop).base x✝ = (𝟙 (X.restrict ⋯)).base x✝

case h.w
C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑(X.restrict ⋯)
⊢ ((X.ofRestrict ⋯ ≫ X.toRestrictTop).c ≫ whiskerRight (eqToHom ⋯) (X.restrict ⋯).presheaf).app (op U✝) =
    (𝟙 (X.restrict ⋯)).c.app (op U✝)
tactic: ext
state_before: C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
⊢ X.toRestrictTop ≫ X.ofRestrict ⋯ = 𝟙 X
state_after: case w.w
C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
x✝ : (CategoryTheory.forget TopCat).obj ↑X
⊢ (X.toRestrictTop ≫ X.ofRestrict ⋯).base x✝ = (𝟙 X).base x✝

case h.w
C : Type u_1
inst✝ : Category.{?u.84251, u_1} C
X : PresheafedSpace C
U✝ : Opens ↑↑X
⊢ ((X.toRestrictTop ≫ X.ofRestrict ⋯).c ≫ whiskerRight (eqToHom ⋯) X.presheaf).app (op U✝) = (𝟙 X).c.app (op U✝)
tactic: ext