ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rel.interedges_disjoint_right
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : Disjoint t t'
⊢ Disjoint (interedges r s t) (interedges r s t')
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s t'
tactic: rw [Finset.disjoint_left] at ht ⊢
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → a ∉ interedges r s t'
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s t'
⊢ False
tactic: intro _ hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s t'
⊢ False
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s ∧ a✝.2 ∈ t' ∧ r a✝.1 a✝.2
⊢ False
tactic: rw [mem_interedges_iff] at hx hy
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → a ∉ t'
a✝ : α × β
hx : a✝.1 ∈ s ∧ a✝.2 ∈ t ∧ r a✝.1 a✝.2
hy : a✝.1 ∈ s ∧ a✝.2 ∈ t' ∧ r a✝.1 a✝.2
⊢ False
state_after: no goals
tactic: exact ht hx.2.1 hy.2.1
Theorem: pos_nilpotencyClass_iff
File: Mathlib/RingTheory/Nilpotent/Defs.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
⊢ 0 < nilpotencyClass x ↔ IsNilpotent x
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx : IsNilpotent x
hx' : nilpotencyClass x = 0
⊢ False
tactic: refine ⟨isNilpotent_of_pos_nilpotencyClass, fun hx ↦ Nat.pos_of_ne_zero fun hx' ↦ ?_⟩
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx : IsNilpotent x
hx' : nilpotencyClass x = 0
⊢ False
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx' : nilpotencyClass x = 0
hx : x ^ nilpotencyClass x = 0
⊢ False
tactic: replace hx := pow_nilpotencyClass hx
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx' : nilpotencyClass x = 0
hx : x ^ nilpotencyClass x = 0
⊢ False
state_after: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx' : nilpotencyClass x = 0
hx : 1 = 0
⊢ False
tactic: rw [hx', pow_zero] at hx
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝¹ : MonoidWithZero R
inst✝ : Nontrivial R
hx' : nilpotencyClass x = 0
hx : 1 = 0
⊢ False
state_after: no goals
tactic: exact one_ne_zero hx
Theorem: isPreconnected_iff_preconnectedSpace
File: Mathlib/Topology/Connected/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
h : PreconnectedSpace ↑s
⊢ IsPreconnected s
state_after: no goals
tactic: simpa using isPreconnected_univ.image ((↑) : s → α) continuous_subtype_val.continuousOn
Theorem: AlgebraicGeometry.Polynomial.isOpen_imageOfDf
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (imageOfDf f)
state_after: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (⋃ i, {x | f.coeff i ∉ x.asIdeal})
tactic: rw [imageOfDf, setOf_exists fun i (x : PrimeSpectrum R) => coeff f i ∉ x.asIdeal]
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ IsOpen (⋃ i, {x | f.coeff i ∉ x.asIdeal})
state_after: no goals
tactic: exact isOpen_iUnion fun i => isOpen_basicOpen
Theorem: CategoryTheory.PreOneHypercover.map_f
File: Mathlib/CategoryTheory/Sites/Continuous.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E✝ : Type u₃
inst✝ : Category.{v₃, u₃} E✝
X : C
E : PreOneHypercover X
F : C ⥤ D
x✝¹ x✝ : E.I₀
j : E.I₁ x✝¹ x✝
⊢ (fun x x_1 j => F.map (E.p₁ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝¹ =
    (fun x x_1 j => F.map (E.p₂ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝
state_after: no goals
tactic: simpa using F.congr_map (E.w j)
Theorem: Filter.frequently_const
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f : Filter α
inst✝ : f.NeBot
p : Prop
⊢ (∃ᶠ (x : α) in f, p) ↔ p
state_after: no goals
tactic: by_cases p <;> simp [*]
Theorem: Rat.mk'_pow
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q : ℚ
num : ℤ
den : ℕ
hd : den ≠ 0
hdn : num.natAbs.Coprime den
n : ℕ
⊢ den ^ n ≠ 0
state_after: no goals
tactic: simp [Nat.pow_eq_zero, hd]
state_before: q : ℚ
num : ℤ
den : ℕ
hd : den ≠ 0
hdn : num.natAbs.Coprime den
n : ℕ
⊢ (num ^ n).natAbs.Coprime (den ^ n)
state_after: q : ℚ
num : ℤ
den : ℕ
hd : den ≠ 0
hdn : num.natAbs.Coprime den
n : ℕ
⊢ (num.natAbs ^ n).Coprime (den ^ n)
tactic: rw [Int.natAbs_pow]
state_before: q : ℚ
num : ℤ
den : ℕ
hd : den ≠ 0
hdn : num.natAbs.Coprime den
n : ℕ
⊢ (num.natAbs ^ n).Coprime (den ^ n)
state_after: no goals
tactic: exact hdn.pow _ _
Theorem: IsClosed.exists_minimal_nonempty_closed_subset
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
⊢ ∃ V ⊆ S, V.Nonempty ∧ IsClosed V ∧ ∀ V' ⊆ V, V'.Nonempty → IsClosed V' → V' = V
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
⊢ ∃ V ⊆ S, V.Nonempty ∧ IsClosed V ∧ ∀ V' ⊆ V, V'.Nonempty → IsClosed V' → V' = V
tactic: let opens := { U : Set X | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty }
state_before: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
U : Set X
h : ∀ a ∈ opens, U ⊆ a → a = U
Uc : Sᶜ ⊆ U
Uo : IsOpen U
Ucne : Uᶜ.Nonempty
⊢ ∃ V ⊆ S, V.Nonempty ∧ IsClosed V ∧ ∀ V' ⊆ V, V'.Nonempty → IsClosed V' → V' = V
state_after: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
U : Set X
h : ∀ a ∈ opens, U ⊆ a → a = U
Uc : Sᶜ ⊆ U
Uo : IsOpen U
Ucne : Uᶜ.Nonempty
⊢ ∀ V' ⊆ Uᶜ, V'.Nonempty → IsClosed V' → V' = Uᶜ
tactic: refine ⟨Uᶜ, Set.compl_subset_comm.mp Uc, Ucne, Uo.isClosed_compl, ?_⟩
state_before: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
U : Set X
h : ∀ a ∈ opens, U ⊆ a → a = U
Uc : Sᶜ ⊆ U
Uo : IsOpen U
Ucne : Uᶜ.Nonempty
⊢ ∀ V' ⊆ Uᶜ, V'.Nonempty → IsClosed V' → V' = Uᶜ
state_after: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
U : Set X
h : ∀ a ∈ opens, U ⊆ a → a = U
Uc : Sᶜ ⊆ U
Uo : IsOpen U
Ucne : Uᶜ.Nonempty
V' : Set X
V'sub : V' ⊆ Uᶜ
V'ne : V'.Nonempty
V'cls : IsClosed V'
⊢ V' = Uᶜ
tactic: intro V' V'sub V'ne V'cls
state_before: case intro.intro.intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : CompactSpace X
S : Set X
hS : IsClosed S
hne : S.Nonempty
opens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}
U : Set X
h : ∀ a ∈ opens, U ⊆ a → a = U
Uc : Sᶜ ⊆ U
Uo : IsOpen U
Ucne : Uᶜ.Nonempty
V' : Set X
V'sub : V' ⊆ Uᶜ
V'ne : V'.Nonempty
V'cls : IsClosed V'
this : V'ᶜ = U
⊢ V' = Uᶜ
state_after: no goals
tactic: rw [← this, compl_compl]
Theorem: List.rotate_eq_drop_append_take
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate n = drop n l ++ take n l
state_after: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate' n = drop n l ++ take n l
tactic: rw [rotate_eq_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ n ≤ l.length → l.rotate' n = drop n l ++ take n l
state_after: no goals
tactic: exact rotate'_eq_drop_append_take
Theorem: Ultrafilter.tendsto_pure_self
File: Mathlib/Topology/StoneCech.lean

Proof steps:
state_before: α : Type u
b : Ultrafilter α
⊢ Tendsto pure (↑b) (𝓝 b)
state_after: α : Type u
b : Ultrafilter α
⊢ b = joinM (map pure b)
tactic: rw [Tendsto, ← coe_map, ultrafilter_converges_iff]
state_before: α : Type u
b : Ultrafilter α
⊢ b = joinM (map pure b)
state_after: case h
α : Type u
b : Ultrafilter α
s : Set α
⊢ s ∈ b ↔ s ∈ joinM (map pure b)
tactic: ext s
state_before: case h
α : Type u
b : Ultrafilter α
s : Set α
⊢ s ∈ b ↔ s ∈ joinM (map pure b)
state_after: case h
α : Type u
b : Ultrafilter α
s : Set α
⊢ s ∈ b ↔ {t | s ∈ t} ∈ map pure b
tactic: change s ∈ b ↔ {t | s ∈ t} ∈ map pure b
state_before: case h
α : Type u
b : Ultrafilter α
s : Set α
⊢ s ∈ b ↔ {t | s ∈ t} ∈ map pure b
state_after: no goals
tactic: simp_rw [mem_map, preimage_setOf_eq, mem_pure, setOf_mem_eq]
Theorem: List.foldlIdx_eq_foldl_enum
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
f : ℕ → α → β → α
a : α
bs : List β
⊢ foldlIdx f a bs = foldl (fun a p => f p.1 a p.2) a bs.enum
state_after: no goals
tactic: simp only [foldlIdx, foldlIdxSpec, foldlIdx_eq_foldlIdxSpec, enum]
Theorem: AddCircle.liftIco_eq_lift_Icc
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝ : Archimedean 𝕜
f : 𝕜 → B
h : f a = f (a + p)
⊢ ∀ (a_1 b : ↑(Icc a (a + p))), EndpointIdent p a a_1 b → (Icc a (a + p)).restrict f a_1 = (Icc a (a + p)).restrict f b
state_after: case mk
𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝ : Archimedean 𝕜
f : 𝕜 → B
h : f a = f (a + p)
⊢ (Icc a (a + p)).restrict f ⟨a, ⋯⟩ = (Icc a (a + p)).restrict f ⟨a + p, ⋯⟩
tactic: rintro _ _ ⟨_⟩
state_before: case mk
𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p a : 𝕜
hp : Fact (0 < p)
inst✝ : Archimedean 𝕜
f : 𝕜 → B
h : f a = f (a + p)
⊢ (Icc a (a + p)).restrict f ⟨a, ⋯⟩ = (Icc a (a + p)).restrict f ⟨a + p, ⋯⟩
state_after: no goals
tactic: exact h
Theorem: Tree.coe_treesOfNumNodesEq
File: Mathlib/Combinatorics/Enumerative/Catalan.lean

Proof steps:
state_before: n : ℕ
⊢ ∀ (x : Tree Unit), x ∈ ↑(treesOfNumNodesEq n) ↔ x ∈ {x | x.numNodes = n}
state_after: no goals
tactic: simp
Theorem: GaussianFourier.tendsto_verticalIntegral
File: Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean

Proof steps:
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (verticalIntegral b c) atTop (𝓝 0)
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => ‖verticalIntegral b c x‖) atTop (𝓝 0)
tactic: rw [tendsto_zero_iff_norm_tendsto_zero]
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => ‖verticalIntegral b c x‖) atTop (𝓝 0)
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => 2 * |c| * rexp (-(b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2))) atTop (𝓝 0)
tactic: refine
    tendsto_of_tendsto_of_tendsto_of_le_of_le' tendsto_const_nhds ?_
      (eventually_of_forall fun _ => norm_nonneg _)
      ((eventually_ge_atTop (0 : ℝ)).mp
        (eventually_of_forall fun T hT => verticalIntegral_norm_le hb c hT))
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => 2 * |c| * rexp (-(b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2))) atTop (𝓝 0)
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => 2 * |c| * rexp (-(b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2))) atTop (𝓝 (2 * |c| * 0))
tactic: rw [(by ring : 0 = 2 * |c| * 0)]
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => 2 * |c| * rexp (-(b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2))) atTop (𝓝 (2 * |c| * 0))
state_after: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2) atTop atTop
tactic: refine (tendsto_exp_atBot.comp (tendsto_neg_atTop_atBot.comp ?_)).const_mul _
state_before: b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun T => b.re * T ^ 2 - 2 * |b.im| * |c| * T - b.re * c ^ 2) atTop atTop
state_after: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => b.re * x ^ 2 - 2 * |b.im| * |c| * x) atTop atTop
tactic: apply tendsto_atTop_add_const_right
state_before: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => b.re * x ^ 2 - 2 * |b.im| * |c| * x) atTop atTop
state_after: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => (b.re * x - 2 * |b.im| * |c|) * x) atTop atTop
tactic: simp_rw [sq, ← mul_assoc, ← sub_mul]
state_before: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (fun x => (b.re * x - 2 * |b.im| * |c|) * x) atTop atTop
state_after: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (HMul.hMul b.re) atTop atTop
tactic: refine Tendsto.atTop_mul_atTop (tendsto_atTop_add_const_right _ _ ?_) tendsto_id
state_before: case hf
b : ℂ
hb : 0 < b.re
c : ℝ
⊢ Tendsto (HMul.hMul b.re) atTop atTop
state_after: no goals
tactic: exact (tendsto_const_mul_atTop_of_pos hb).mpr tendsto_id
Theorem: AlgebraicGeometry.PresheafedSpace.restrictStalkIso_inv_eq_germ
File: Mathlib/Geometry/RingedSpace/Stalks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
U : TopCat
X : PresheafedSpace C
f : U ⟶ ↑X
h : OpenEmbedding ⇑f
V : Opens ↑U
x : ↑U
hx : x ∈ V
⊢ X.presheaf.germ ⟨f x, ⋯⟩ ≫ (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ ⟨x, hx⟩
state_after: no goals
tactic: rw [← restrictStalkIso_hom_eq_germ, Category.assoc, Iso.hom_inv_id, Category.comp_id]
Theorem: invOf_nonpos
File: Mathlib/Algebra/Order/Invertible.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedSemiring α
a : α
inst✝ : Invertible a
⊢ ⅟a ≤ 0 ↔ a ≤ 0
state_after: no goals
tactic: simp only [← not_lt, invOf_pos]
Theorem: BoundedContinuousFunction.integrable
File: Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean

Proof steps:
state_before: X : Type u_1
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : OpensMeasurableSpace X
μ : Measure X
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
inst✝ : IsFiniteMeasure μ
f : X →ᵇ E
⊢ Integrable (⇑f) μ
state_after: X : Type u_1
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : OpensMeasurableSpace X
μ : Measure X
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
inst✝ : IsFiniteMeasure μ
f : X →ᵇ E
⊢ HasFiniteIntegral (⇑f) μ
tactic: refine ⟨f.continuous.measurable.aestronglyMeasurable, (hasFiniteIntegral_def _ _).mp ?_⟩
state_before: X : Type u_1
inst✝⁷ : MeasurableSpace X
inst✝⁶ : TopologicalSpace X
inst✝⁵ : OpensMeasurableSpace X
μ : Measure X
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : SecondCountableTopology E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
inst✝ : IsFiniteMeasure μ
f : X →ᵇ E
⊢ HasFiniteIntegral (⇑f) μ
state_after: no goals
tactic: calc  ∫⁻ x, ‖f x‖₊ ∂μ
    _ ≤ ‖f‖₊ * (μ Set.univ)   := f.lintegral_nnnorm_le μ
    _ < ∞                     := ENNReal.mul_lt_top ENNReal.coe_ne_top (measure_ne_top μ Set.univ)
Theorem: CategoryTheory.Pretriangulated.binaryProductTriangleIsoBinaryBiproductTriangle_inv_hom₁
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₁ ≫ (biprod.isoProd X₁ X₂).symm.hom =
    (Iso.refl (binaryProductTriangle X₁ X₂).obj₁).hom ≫ (binaryBiproductTriangle X₁ X₂).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₂ ≫ (Iso.refl (binaryProductTriangle X₁ X₂).obj₃).hom =
    (biprod.isoProd X₁ X₂).symm.hom ≫ (binaryBiproductTriangle X₁ X₂).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₃ ≫ (shiftFunctor C 1).map (Iso.refl (binaryProductTriangle X₁ X₂).obj₁).hom =
    (Iso.refl (binaryProductTriangle X₁ X₂).obj₃).hom ≫ (binaryBiproductTriangle X₁ X₂).mor₃
state_after: no goals
tactic: aesop_cat
Theorem: Convex.mem_Ico
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ z ∈ Ico x y ↔ ∃ a b, 0 < a ∧ 0 ≤ b ∧ a + b = 1 ∧ a * x + b * y = z
state_after: case refine_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
hz : z ∈ Ico x y
⊢ ∃ a b, 0 < a ∧ 0 ≤ b ∧ a + b = 1 ∧ a * x + b * y = z

case refine_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝ : LinearOrderedField 𝕜
x y z : 𝕜
h : x < y
⊢ (∃ a b, 0 < a ∧ 0 ≤ b ∧ a + b = 1 ∧ a * x + b * y = z) → z ∈ Ico x y
tactic: refine ⟨fun hz => ?_, ?_⟩
Theorem: CategoryTheory.Bicategory.isRightAdjoint_TFAE
File: Mathlib/CategoryTheory/Bicategory/Kan/Adjunction.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
state_after: case tfae_1_to_2
B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
⊢ IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)

B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
tactic: tfae_have 1 → 2
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
state_after: case tfae_2_to_3
B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
⊢ HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u

B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
tfae_2_to_3 : HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
tactic: tfae_have 2 → 3
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
tfae_2_to_3 : HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
state_after: case tfae_3_to_1
B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
tfae_2_to_3 : HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u
⊢ (∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u) → IsRightAdjoint u

B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
tfae_2_to_3 : HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u
tfae_3_to_1 : (∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u) → IsRightAdjoint u
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
tactic: tfae_have 3 → 1
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
u : b ⟶ a
tfae_1_to_2 : IsRightAdjoint u → HasAbsLeftKanLift u (𝟙 a)
tfae_2_to_3 : HasAbsLeftKanLift u (𝟙 a) → ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u
tfae_3_to_1 : (∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u) → IsRightAdjoint u
⊢ [IsRightAdjoint u, HasAbsLeftKanLift u (𝟙 a), ∃ (x : HasLeftKanLift u (𝟙 a)), LanLift.CommuteWith u (𝟙 a) u].TFAE
state_after: no goals
tactic: tfae_finish
Theorem: Cardinal.toNat_congr
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c d : Cardinal.{u}
β : Type v
e : α ≃ β
⊢ toNat #α = toNat #β
state_after: no goals
tactic: rw [← toNat_lift, (lift_mk_eq.{_,_,v}).mpr ⟨e⟩, toNat_lift]
Theorem: SimpleGraph.Subgraph.induce_self_verts
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
⊢ G'.induce G'.verts = G'
state_after: case verts.h
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
x✝ : V
⊢ x✝ ∈ (G'.induce G'.verts).verts ↔ x✝ ∈ G'.verts

case Adj.h.h.a
ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G' G'' : G.Subgraph
s s' : Set V
x✝¹ x✝ : V
⊢ (G'.induce G'.verts).Adj x✝¹ x✝ ↔ G'.Adj x✝¹ x✝
tactic: ext
Theorem: Option.pbind_eq_none
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
x : Option α
f : (a : α) → a ∈ x → Option β
h' : ∀ (a : α) (H : a ∈ x), f a H = none → x = none
⊢ x.pbind f = none ↔ x = none
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
f : (a : α) → a ∈ none → Option β
h' : ∀ (a : α) (H : a ∈ none), f a H = none → none = none
⊢ none.pbind f = none ↔ none = none

case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
p : α → Prop
f✝ : (a : α) → p a → β
val✝ : α
f : (a : α) → a ∈ some val✝ → Option β
h' : ∀ (a : α) (H : a ∈ some val✝), f a H = none → some val✝ = none
⊢ (some val✝).pbind f = none ↔ some val✝ = none
tactic: cases x
Theorem: Nat.nine_dvd_iff
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ 10 % 9 = 1
state_after: no goals
tactic: norm_num