ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Filter.frequently_lt_of_lt_limsSup
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : a < f.limsSup
⊢ ∃ᶠ (n : α) in f, a < n
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ¬∃ᶠ (n : α) in f, a < n
⊢ f.limsSup ≤ a
tactic: contrapose! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ¬∃ᶠ (n : α) in f, a < n
⊢ f.limsSup ≤ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ∀ᶠ (x : α) in f, x ≤ a
⊢ f.limsSup ≤ a
tactic: simp only [not_frequently, not_lt] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
f : Filter α
inst✝ : ConditionallyCompleteLinearOrder α
a : α
hf : autoParam (IsCobounded (fun x x_1 => x ≤ x_1) f) _auto✝
h : ∀ᶠ (x : α) in f, x ≤ a
⊢ f.limsSup ≤ a
state_after: no goals
tactic: exact limsSup_le_of_le hf h
Theorem: Hyperreal.IsSt.isSt_st
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x : ℝ*
r : ℝ
hxr : x.IsSt r
⊢ x.IsSt x.st
state_after: no goals
tactic: rwa [hxr.st_eq]
Theorem: Cardinal.derivFamily_lt_ord_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
⊢ a < c.ord → derivFamily f a < c.ord
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
hω : ℵ₀ < c.ord.cof
⊢ a < c.ord → derivFamily f a < c.ord
tactic: have hω : ℵ₀ < c.ord.cof := by
    rw [hc.cof_eq]
    exact lt_of_le_of_ne hc.1 hc'.symm
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
c : Cardinal.{max u v}
hc : c.IsRegular
hι : lift.{v, u} #ι < c
hc' : c ≠ ℵ₀
hf : ∀ (i : ι), ∀ b < c.ord, f i b < c.ord
a : Ordinal.{max u v}
hω : ℵ₀ < c.ord.cof
⊢ a < c.ord → derivFamily f a < c.ord
state_after: no goals
tactic: induction a using limitRecOn with
  | H₁ =>
    rw [derivFamily_zero]
    exact nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
  | H₂ b hb =>
    intro hb'
    rw [derivFamily_succ]
    exact
      nfpFamily_lt_ord_lift hω (by rwa [hc.cof_eq]) hf
        ((ord_isLimit hc.1).2 _ (hb ((lt_succ b).trans hb')))
  | H₃ b hb H =>
    intro hb'
    rw [derivFamily_limit f hb]
    exact
      bsup_lt_ord_of_isRegular.{u, v} hc (ord_lt_ord.1 ((ord_card_le b).trans_lt hb')) fun o' ho' =>
        H o' ho' (ho'.trans hb')
Theorem: Complex.normSq_conj
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
⊢ normSq ((starRingEnd ℂ) z) = normSq z
state_after: no goals
tactic: simp [normSq]
Theorem: Equiv.Perm.cycleType_eq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
⊢ σ.cycleType = ↑(List.map (Finset.card ∘ support) l)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ σ.cycleType = ↑(List.map (Finset.card ∘ support) l)
tactic: have hl : l.Nodup := nodup_of_pairwise_disjoint_cycles h1 h2
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ σ.cycleType = ↑(List.map (Finset.card ∘ support) l)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ Multiset.map (Finset.card ∘ support) l.toFinset.val = ↑(List.map (Finset.card ∘ support) l)

case h1
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ ∀ f ∈ l.toFinset, f.IsCycle

case h2
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ (↑l.toFinset).Pairwise Disjoint

case h0
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
l : List (Perm α)
h0 : l.prod = σ
h1 : ∀ σ ∈ l, σ.IsCycle
h2 : List.Pairwise Disjoint l
hl : l.Nodup
⊢ l.toFinset.noncommProd id ⋯ = σ
tactic: rw [cycleType_eq' l.toFinset]
Theorem: StrictConvexOn.add
File: Mathlib/Analysis/Convex/Function.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁵ : OrderedSemiring 𝕜
inst✝⁴ : AddCommMonoid E
inst✝³ : AddCommMonoid F
inst✝² : OrderedCancelAddCommMonoid β
inst✝¹ : SMul 𝕜 E
inst✝ : DistribMulAction 𝕜 β
s : Set E
f g : E → β
hf : StrictConvexOn 𝕜 s f
hg : StrictConvexOn 𝕜 s g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • f x + b • f y + (a • g x + b • g y) = a • (f x + g x) + b • (f y + g y)
state_after: no goals
tactic: rw [smul_add, smul_add, add_add_add_comm]
Theorem: Ideal.to_quotient_square_range
File: Mathlib/RingTheory/Ideal/Cotangent.lean

Proof steps:
state_before: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ LinearMap.range I.cotangentToQuotientSquare = Submodule.restrictScalars R I.cotangentIdeal
state_after: R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ LinearMap.range I.cotangentToQuotientSquare = LinearMap.range (I.cotangentToQuotientSquare ∘ₗ I.toCotangent)

R : Type u
S : Type v
S' : Type w
inst✝⁶ : CommRing R
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : CommSemiring S'
inst✝² : Algebra S' R
inst✝¹ : Algebra S S'
inst✝ : IsScalarTower S S' R
I : Ideal R
⊢ LinearMap.range (I.cotangentToQuotientSquare ∘ₗ I.toCotangent) = Submodule.restrictScalars R I.cotangentIdeal
tactic: trans LinearMap.range (I.cotangentToQuotientSquare.comp I.toCotangent)
Theorem: List.forall₂_iff_zip
File: Mathlib/Data/List/Forall2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l₁ : List α
l₂ : List β
h : l₁.length = l₂.length ∧ ∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b
⊢ Forall₂ R l₁ l₂
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l₁ : List α
l₂ : List β
h₁ : l₁.length = l₂.length
h₂ : ∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b
⊢ Forall₂ R l₁ l₂
tactic: cases' h with h₁ h₂
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l₁ : List α
l₂ : List β
h₁ : l₁.length = l₂.length
h₂ : ∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b
⊢ Forall₂ R l₁ l₂
state_after: case intro.nil
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
l₂ : List β
h₁ : [].length = l₂.length
h₂ : ∀ {a : α} {b : β}, (a, b) ∈ [].zip l₂ → R a b
⊢ Forall₂ R [] l₂

case intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a : α
l₁ : List α
IH : ∀ {l₂ : List β}, l₁.length = l₂.length → (∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b) → Forall₂ R l₁ l₂
l₂ : List β
h₁ : (a :: l₁).length = l₂.length
h₂ : ∀ {a_1 : α} {b : β}, (a_1, b) ∈ (a :: l₁).zip l₂ → R a_1 b
⊢ Forall₂ R (a :: l₁) l₂
tactic: induction' l₁ with a l₁ IH generalizing l₂
Theorem: krullDim_eq_top_of_infiniteDimensionalOrder
File: Mathlib/Order/KrullDimension.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
this : Inhabited α
⊢ False
tactic: haveI : Inhabited α := ⟨LTSeries.withLength _ 0 0⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m
hm : ∀ (i : LTSeries α), ↑i.length ≤ ⊥
this : Inhabited α
⊢ False
state_after: no goals
tactic: exact not_le_of_lt (WithBot.bot_lt_coe _ : ⊥ < (0 : WithBot (WithTop ℕ))) <| hm default
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ ⊤ ≤ some (some m)
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ some (some m) < ↑(LTSeries.withLength α (m + 1)).length
tactic: refine (not_lt_of_le (hm (LTSeries.withLength _ (m + 1))) ?_).elim
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ some (some m) < ↑(LTSeries.withLength α (m + 1)).length
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ m < ↑(LTSeries.withLength α (m + 1)).length
tactic: erw [WithBot.coe_lt_coe, WithTop.coe_lt_coe]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : InfiniteDimensionalOrder α
m✝ : WithBot (WithTop ℕ)
hm✝ : ∀ (i : LTSeries α), ↑i.length ≤ m✝
m : ℕ
hm : ∀ (i : LTSeries α), ↑i.length ≤ some (some m)
⊢ m < ↑(LTSeries.withLength α (m + 1)).length
state_after: no goals
tactic: simp
Theorem: vectorSpan_range_eq_span_range_vsub_left
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ vectorSpan k (range p) = Submodule.span k (range fun i => p i0 -ᵥ p i)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => p i0 -ᵥ x) ∘ p)) = Submodule.span k (range fun i => p i0 -ᵥ p i)
tactic: rw [vectorSpan_eq_span_vsub_set_left k (Set.mem_range_self i0), ← Set.range_comp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x => p i0 -ᵥ x) ∘ p)) = Submodule.span k (range fun i => p i0 -ᵥ p i)
state_after: no goals
tactic: congr
Theorem: IsEllSequence.smul
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
h : IsEllSequence W
x : R
m n r : ℤ
⊢ (x • W) (m + n) * (x • W) (m - n) * (x • W) r ^ 2 =
    (x • W) (m + r) * (x • W) (m - r) * (x • W) n ^ 2 - (x • W) (n + r) * (x • W) (n - r) * (x • W) m ^ 2
state_after: no goals
tactic: linear_combination (norm := (simp only [Pi.smul_apply, smul_eq_mul]; ring1)) x ^ 4 * h m n r
Theorem: Ring.inverse_add_inverse
File: Mathlib/Algebra/Ring/Invertible.lean

Proof steps:
state_before: α : Type u
inst✝ : Semiring α
a b : α
h : IsUnit a ↔ IsUnit b
⊢ inverse a + inverse b = inverse a * (a + b) * inverse b
state_after: case pos
α : Type u
inst✝ : Semiring α
a b : α
h : IsUnit a ↔ IsUnit b
ha : IsUnit a
⊢ inverse a + inverse b = inverse a * (a + b) * inverse b

case neg
α : Type u
inst✝ : Semiring α
a b : α
h : IsUnit a ↔ IsUnit b
ha : ¬IsUnit a
⊢ inverse a + inverse b = inverse a * (a + b) * inverse b
tactic: by_cases ha : IsUnit a
Theorem: SemiNormedGrp.explicitCokernelIso_hom_desc
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

Proof steps:
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (explicitCokernelIso f).hom ≫ cokernel.desc f g w = explicitCokernelDesc w
state_after: case h
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ explicitCokernelπ f ≫ (explicitCokernelIso f).hom ≫ cokernel.desc f g w = explicitCokernelπ f ≫ explicitCokernelDesc w
tactic: ext1
state_before: case h
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ explicitCokernelπ f ≫ (explicitCokernelIso f).hom ≫ cokernel.desc f g w = explicitCokernelπ f ≫ explicitCokernelDesc w
state_after: no goals
tactic: simp [explicitCokernelDesc, explicitCokernelπ, explicitCokernelIso,
    IsColimit.coconePointUniqueUpToIso]
Theorem: MeasureTheory.measure_biUnion_le
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ✝ : F
s✝ t : Set α
I : Set ι
μ : F
hI : I.Countable
s : ι → Set α
⊢ μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)
state_after: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ✝ : F
s✝ t : Set α
I : Set ι
μ : F
hI : I.Countable
s : ι → Set α
this : Countable ↑I
⊢ μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)
tactic: have := hI.to_subtype
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ✝ : F
s✝ t : Set α
I : Set ι
μ : F
hI : I.Countable
s : ι → Set α
this : Countable ↑I
⊢ μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)
state_after: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ✝ : F
s✝ t : Set α
I : Set ι
μ : F
hI : I.Countable
s : ι → Set α
this : Countable ↑I
⊢ μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I), μ (s ↑i)
tactic: rw [biUnion_eq_iUnion]
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ✝ : F
s✝ t : Set α
I : Set ι
μ : F
hI : I.Countable
s : ι → Set α
this : Countable ↑I
⊢ μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I), μ (s ↑i)
state_after: no goals
tactic: apply measure_iUnion_le
Theorem: iUnion_Ico_add_intCast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ ⋃ n, Ico (a + ↑n) (a + ↑n + 1) = univ
state_after: no goals
tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
    iUnion_Ico_add_zsmul zero_lt_one a
Theorem: ComplexShape.Embedding.next_f_of_not_boundaryLE
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hjk : c.next j = k
hj : ¬e.BoundaryLE j
⊢ c'.next (e.f j) = e.f k
state_after: case pos
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hjk : c.next j = k
hj : ¬e.BoundaryLE j
hjk' : c.Rel j k
⊢ c'.next (e.f j) = e.f k

case neg
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hjk : c.next j = k
hj : ¬e.BoundaryLE j
hjk' : ¬c.Rel j k
⊢ c'.next (e.f j) = e.f k
tactic: by_cases hjk' : c.Rel j k
Theorem: LieSubmodule.subset_lieSpan
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
⊢ s ⊆ ↑(lieSpan R L s)
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ m ∈ ↑(lieSpan R L s)
tactic: intro m hm
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ m ∈ ↑(lieSpan R L s)
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → m ∈ N
tactic: erw [mem_lieSpan]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
⊢ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → m ∈ N
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
N : LieSubmodule R L M
hN : s ⊆ ↑N
⊢ m ∈ N
tactic: intro N hN
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N✝ N' : LieSubmodule R L M
I J : LieIdeal R L
s : Set M
m : M
hm : m ∈ s
N : LieSubmodule R L M
hN : s ⊆ ↑N
⊢ m ∈ N
state_after: no goals
tactic: exact hN hm
Theorem: EReal.mem_nhds_bot_iff
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
s : Set EReal
⊢ (∃ i, True ∧ Iio ↑i ⊆ s) ↔ ∃ y, Iio ↑y ⊆ s
state_after: no goals
tactic: simp only [true_and]
Theorem: UniformSpace.Core.nhds_toTopologicalSpace
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u
u : Core α
x : α
⊢ 𝓝 x = comap (Prod.mk x) u.uniformity
state_after: case hpure
α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u
u : Core α
x : α
⊢ ∀ (a : α), ∀ i ∈ u.uniformity, a ∈ Prod.mk a ⁻¹' id i

case hopen
α✝ : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
α : Type u
u : Core α
x : α
⊢ ∀ (a : α),
    ∀ i ∈ u.uniformity,
      ∀ᶠ (x : α) in comap (Prod.mk a) u.uniformity, Prod.mk a ⁻¹' id i ∈ comap (Prod.mk x) u.uniformity
tactic: apply TopologicalSpace.nhds_mkOfNhds_of_hasBasis (fun _ ↦ (basis_sets _).comap _)
Theorem: IsAntichain.max_maximals
File: Mathlib/Order/Minimal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a b x : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
⊢ maximals r s = t
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b x : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
⊢ a ∈ maximals r s
tactic: refine h.antisymm fun a ha => ?_
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b x : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
⊢ a ∈ maximals r s
state_after: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
b : α
hb : b ∈ maximals r s
hr : r b a
⊢ a ∈ maximals r s
tactic: obtain ⟨b, hb, hr⟩ := hs ha
state_before: case intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ x : α
ht : IsAntichain r t
h : maximals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b ∈ maximals r s, r b a
a : α
ha : a ∈ t
b : α
hb : b ∈ maximals r s
hr : r b a
⊢ a ∈ maximals r s
state_after: no goals
tactic: rwa [of_not_not fun hab => ht (h hb) ha (Ne.symm hab) hr]
Theorem: Multiset.inter_le_right
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝¹ t✝ u : Multiset α
a✝ b : α
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t : Multiset α), s ∩ t ≤ t
t : Multiset α
h : a ∈ t
⊢ (a ::ₘ s) ∩ t ≤ t
state_after: no goals
tactic: simpa [h] using cons_le_cons a (IH (t.erase a))
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝¹ t✝ u : Multiset α
a✝ b : α
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t : Multiset α), s ∩ t ≤ t
t : Multiset α
h : a ∉ t
⊢ (a ::ₘ s) ∩ t ≤ t
state_after: no goals
tactic: simp [h, IH]
Theorem: MeasureTheory.measure_iUnion_null_iff
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

Proof steps:
state_before: α : Type u_1
ι✝ : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
ι : Sort u_4
inst✝ : Countable ι
s : ι → Set α
⊢ μ (⋃ i, s i) = 0 ↔ ∀ (i : ι), μ (s i) = 0
state_after: no goals
tactic: rw [← sUnion_range, measure_sUnion_null_iff (countable_range s), forall_mem_range]
Theorem: SignType.self_eq_neg_iff
File: Mathlib/Data/Sign.lean

Proof steps:
state_before: a : SignType
⊢ a = -a ↔ a = 0
state_after: no goals
tactic: cases a <;> decide