ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsIdempotentElem.iff_eq_zero_or_one
File: Mathlib/Algebra/Ring/Idempotents.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
⊢ IsIdempotentElem p ↔ p = 0 ∨ p = 1
state_after: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
h : IsIdempotentElem p
hp : ¬p = 0
⊢ p = 1
tactic: refine
    Iff.intro (fun h => or_iff_not_imp_left.mpr fun hp => ?_) fun h =>
      h.elim (fun hp => hp.symm ▸ zero) fun hp => hp.symm ▸ one
state_before: M : Type u_1
N : Type u_2
S : Type u_3
M₀ : Type u_4
M₁ : Type u_5
R : Type u_6
G : Type u_7
G₀ : Type u_8
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : G₀
h : IsIdempotentElem p
hp : ¬p = 0
⊢ p = 1
state_after: no goals
tactic: exact mul_left_cancel₀ hp (h.trans (mul_one p).symm)
Theorem: SimplexCategory.factor_δ_spec
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
⊢ factor_δ f j ≫ δ j = f
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
k : Fin ([m].len + 1)
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
tactic: ext k : 3
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
hj : ∀ (k : Fin (m + 1)), (Hom.toOrderHom f) k ≠ j
k : Fin ([m].len + 1)
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
tactic: specialize hj k
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ (Hom.toOrderHom (factor_δ f j ≫ δ j)) k = (Hom.toOrderHom f) k
state_after: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ j.succAbove ((predAbove 0 j).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
tactic: dsimp [factor_δ, δ, σ]
state_before: case a.h.h
m n : ℕ
f : [m] ⟶ [n + 1]
j : Fin (n + 2)
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ j
⊢ j.succAbove ((predAbove 0 j).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
state_after: case a.h.h.zero
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
hj : (Hom.toOrderHom f) k ≠ 0
⊢ succAbove 0 ((predAbove 0 0).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k

case a.h.h.succ
m n : ℕ
f : [m] ⟶ [n + 1]
k : Fin ([m].len + 1)
j : Fin (n + 1)
hj : (Hom.toOrderHom f) k ≠ j.succ
⊢ j.succ.succAbove ((predAbove 0 j.succ).predAbove ((Hom.toOrderHom f) k)) = (Hom.toOrderHom f) k
tactic: cases' j using cases with j
Theorem: List.prod_erase_of_comm
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
ha : a ∈ l
comm : ∀ x ∈ l, ∀ y ∈ l, x * y = y * x
⊢ a * (l.erase a).prod = l.prod
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
ha : a ∈ []
comm : ∀ x ∈ [], ∀ y ∈ [], x * y = y * x
⊢ a * ([].erase a).prod = [].prod

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
tactic: induction' l with b l ih
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
state_after: case cons.inl
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ a :: l
comm : ∀ x ∈ a :: l, ∀ y ∈ a :: l, x * y = y * x
⊢ a * ((a :: l).erase a).prod = (a :: l).prod

case cons.inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
ne : a ≠ b
h : a ∈ l
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
tactic: obtain rfl | ⟨ne, h⟩ := List.eq_or_ne_mem_of_mem ha
state_before: case cons.inr.intro
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : DecidableEq M
b : M
l : List M
ih : a ∈ l → (∀ x ∈ l, ∀ y ∈ l, x * y = y * x) → a * (l.erase a).prod = l.prod
ha : a ∈ b :: l
comm : ∀ x ∈ b :: l, ∀ y ∈ b :: l, x * y = y * x
ne : a ≠ b
h : a ∈ l
⊢ a * ((b :: l).erase a).prod = (b :: l).prod
state_after: no goals
tactic: rw [List.erase, beq_false_of_ne ne.symm, List.prod_cons, List.prod_cons, ← mul_assoc,
    comm a ha b (l.mem_cons_self b), mul_assoc,
    ih h fun x hx y hy ↦ comm _ (List.mem_cons_of_mem b hx) _ (List.mem_cons_of_mem b hy)]
Theorem: MeasureTheory.tilted_const
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ : Measure α
f : α → ℝ
μ : Measure α
inst✝ : IsProbabilityMeasure μ
c : ℝ
⊢ (μ.tilted fun x => c) = μ
state_after: no goals
tactic: simp
Theorem: Finsupp.sum_of_support_subset
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : α →₀ M
s : Finset α
hs : f.support ⊆ s
g : α → M → N
h : ∀ i ∈ s, g i 0 = 1
⊢ f.prod g = ∏ x ∈ s, g x (f x)
state_after: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x✝ : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : α →₀ M
s : Finset α
hs : f.support ⊆ s
g : α → M → N
h : ∀ i ∈ s, g i 0 = 1
x : α
hxs : x ∈ s
hx : x ∉ f.support
⊢ f x = 0
tactic: refine Finset.prod_subset hs fun x hxs hx => h x hxs ▸ (congr_arg (g x) ?_)
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x✝ : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : α →₀ M
s : Finset α
hs : f.support ⊆ s
g : α → M → N
h : ∀ i ∈ s, g i 0 = 1
x : α
hxs : x ∈ s
hx : x ∉ f.support
⊢ f x = 0
state_after: no goals
tactic: exact not_mem_support_iff.1 hx
Theorem: TopCat.Presheaf.isSheaf_iff_isSheafUniqueGluing_types
File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
⊢ F.IsSheaf ↔ F.IsSheafUniqueGluing
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
⊢ (∀ ⦃ι : Type x⦄ (U : ι → Opens ↑X),
      ∀ s ∈ ((Pairwise.diagram U).op ⋙ F).sections,
        ∃! x, ∀ (j : (CategoryTheory.Pairwise ι)ᵒᵖ), (Functor.mapCone F (Pairwise.cocone U).op).π.app j x = s j) ↔
    ∀ ⦃ι : Type x⦄ (U : ι → Opens ↑X) (sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))),
      F.IsCompatible U sf →
        ∃! s,
          ∀ (i : (CategoryTheory.Pairwise ι)ᵒᵖ),
            (Functor.mapCone F (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i
tactic: simp_rw [isSheaf_iff_isSheafPairwiseIntersections, IsSheafPairwiseIntersections,
    Types.isLimit_iff, IsSheafUniqueGluing, isGluing_iff_pairwise]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι : Type x
U : ι → Opens ↑X
⊢ (∀ ⦃ι : Type x⦄ (U : ι → Opens ↑X),
      ∀ s ∈ ((Pairwise.diagram U).op ⋙ F).sections,
        ∃! x, ∀ (j : (CategoryTheory.Pairwise ι)ᵒᵖ), (Functor.mapCone F (Pairwise.cocone U).op).π.app j x = s j) ↔
    ∀ ⦃ι : Type x⦄ (U : ι → Opens ↑X) (sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))),
      F.IsCompatible U sf →
        ∃! s,
          ∀ (i : (CategoryTheory.Pairwise ι)ᵒᵖ),
            (Functor.mapCone F (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i
state_after: case refine_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
ι : Type x
U : ι → Opens ↑X
h :
  ∀ s ∈ ((Pairwise.diagram U).op ⋙ F).sections,
    ∃! x, ∀ (j : (CategoryTheory.Pairwise ι)ᵒᵖ), (Functor.mapCone F (Pairwise.cocone U).op).π.app j x = s j
sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))
cpt : F.IsCompatible U sf
⊢ ∃! s,
    ∀ (i : (CategoryTheory.Pairwise ι)ᵒᵖ),
      (Functor.mapCone F (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i

case refine_2
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ConcreteCategory C
X : TopCat
F : Presheaf (Type u) X
ι✝ : Type x
U✝ : ι✝ → Opens ↑X
ι : Type x
U : ι → Opens ↑X
h :
  ∀ (sf : (i : ι) → (forget (Type u)).obj (F.obj (op (U i)))),
    F.IsCompatible U sf →
      ∃! s,
        ∀ (i : (CategoryTheory.Pairwise ι)ᵒᵖ),
          (Functor.mapCone F (Pairwise.cocone U).op).π.app i s = objPairwiseOfFamily sf i
s : (j : (CategoryTheory.Pairwise ι)ᵒᵖ) → ((Pairwise.diagram U).op ⋙ F).obj j
hs : s ∈ ((Pairwise.diagram U).op ⋙ F).sections
⊢ ∃! x, ∀ (j : (CategoryTheory.Pairwise ι)ᵒᵖ), (Functor.mapCone F (Pairwise.cocone U).op).π.app j x = s j
tactic: refine forall₂_congr fun ι U ↦ ⟨fun h sf cpt ↦ ?_, fun h s hs ↦ ?_⟩
Theorem: Computation.of_results_think
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this : s.Terminates
⊢ ∃ m, s.Results a m ∧ n = m + 1
tactic: haveI := of_think_terminates h.terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this : s.Terminates
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this✝ : s.Terminates
this : s.Results a s.length
⊢ ∃ m, s.Results a m ∧ n = m + 1
tactic: have := results_of_terminates' _ (of_think_mem h.mem)
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this✝ : s.Terminates
this : s.Results a s.length
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: no goals
tactic: exact ⟨_, this, Results.len_unique h (results_think this)⟩
Theorem: Nat.Prime.dvd_iff_one_le_factorization
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ p n : ℕ
pp : Prime p
hn : n ≠ 0
⊢ p ∣ n ↔ p ^ 1 ∣ n
state_after: no goals
tactic: simp
Theorem: MeasureTheory.measureUnivNNReal_eq_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
⊢ measureUnivNNReal μ = 0 ↔ μ = 0
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
⊢ measureUnivNNReal μ = 0 ↔ ↑(measureUnivNNReal μ) = 0
tactic: rw [← MeasureTheory.Measure.measure_univ_eq_zero, ← coe_measureUnivNNReal]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
⊢ measureUnivNNReal μ = 0 ↔ ↑(measureUnivNNReal μ) = 0
state_after: no goals
tactic: norm_cast
Theorem: MeasureTheory.Measure.InnerRegularWRT.trans
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
⊢ μ.InnerRegularWRT p q'
state_after: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
⊢ ∃ K ⊆ U, p K ∧ r < μ K
tactic: intro U hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
⊢ ∃ K ⊆ U, p K ∧ r < μ K
state_after: case intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < μ F
⊢ ∃ K ⊆ U, p K ∧ r < μ K
tactic: rcases H' hU r hr with ⟨F, hFU, hqF, hF⟩
state_before: case intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < μ F
⊢ ∃ K ⊆ U, p K ∧ r < μ K
state_after: case intro.intro.intro.intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < μ F
K : Set α
hKF : K ⊆ F
hpK : p K
hrK : r < μ K
⊢ ∃ K ⊆ U, p K ∧ r < μ K
tactic: rcases H hqF _ hF with ⟨K, hKF, hpK, hrK⟩
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
q' : Set α → Prop
H : μ.InnerRegularWRT p q
H' : μ.InnerRegularWRT q q'
U : Set α
hU : q' U
r : ℝ≥0∞
hr : r < μ U
F : Set α
hFU : F ⊆ U
hqF : q F
hF : r < μ F
K : Set α
hKF : K ⊆ F
hpK : p K
hrK : r < μ K
⊢ ∃ K ⊆ U, p K ∧ r < μ K
state_after: no goals
tactic: exact ⟨K, hKF.trans hFU, hpK, hrK⟩
Theorem: Submonoid.map_powers
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝³ : Monoid M
a : M
N : Type u_4
F : Type u_5
inst✝² : Monoid N
inst✝¹ : FunLike F M N
inst✝ : MonoidHomClass F M N
f : F
m : M
⊢ map f (powers m) = powers (f m)
state_after: no goals
tactic: simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
Theorem: Nat.floorRoot_ne_zero
File: Mathlib/Data/Nat/Factorization/Root.lean

Proof steps:
state_before: a b n : ℕ
⊢ n.floorRoot a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0
state_after: no goals
tactic: simp (config := { contextual := true }) [floorRoot, not_imp_not, not_or]
Theorem: CategoryTheory.obj_zero_map_μ_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y = F.εIso.inv.app X ≫ f ≫ (F.map (ρ_ m).inv).app Y
state_after: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (inv (F.εIso.inv.app X) ≫ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y) ≫ inv ((F.map (ρ_ m).inv).app Y) = f
tactic: rw [← IsIso.inv_comp_eq, ← IsIso.comp_inv_eq]
state_before: C : Type u
inst✝² : Category.{v, u} C
M : Type u_1
inst✝¹ : Category.{u_2, u_1} M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
m : M
X Y : C
f : X ⟶ (F.obj m).obj Y
⊢ (inv (F.εIso.inv.app X) ≫ (F.obj (𝟙_ M)).map f ≫ (F.μ m (𝟙_ M)).app Y) ≫ inv ((F.map (ρ_ m).inv).app Y) = f
state_after: no goals
tactic: simp
Theorem: Real.inv_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y✝ z : ℝ
n : ℕ
hx : 0 ≤ x
y : ℝ
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
state_after: no goals
tactic: simp only [← rpow_neg_one, ← rpow_mul hx, mul_comm]
Theorem: Mathlib.Vector.ne_cons_iff
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
a : α
v : Vector α n.succ
v' : Vector α n
⊢ v ≠ a ::ᵥ v' ↔ v.head ≠ a ∨ v.tail ≠ v'
state_after: no goals
tactic: rw [Ne, eq_cons_iff a v v', not_and_or]
Theorem: div_lt_div_iff_right
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c✝ d c : α
⊢ a / c < b / c ↔ a < b
state_after: no goals
tactic: simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
Theorem: Real.deriv_sqrt_aux
File: Mathlib/Analysis/SpecialFunctions/Sqrt.lean

Proof steps:
state_before: x : ℝ
hx : x ≠ 0
⊢ HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x ∧ ∀ (n : ℕ∞), ContDiffAt ℝ n (fun x => √x) x
state_after: case inl
x : ℝ
hx✝ : x ≠ 0
hx : x < 0
⊢ HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x ∧ ∀ (n : ℕ∞), ContDiffAt ℝ n (fun x => √x) x

case inr
x : ℝ
hx✝ : x ≠ 0
hx : 0 < x
⊢ HasStrictDerivAt (fun x => √x) (1 / (2 * √x)) x ∧ ∀ (n : ℕ∞), ContDiffAt ℝ n (fun x => √x) x
tactic: cases' hx.lt_or_lt with hx hx
Theorem: Sum.Ioo_inl_inr
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a₁ a₂ : α
b₁ b₂ : β
a b : α ⊕ β
⊢ Ioo (inl a₁) (inr b₂) = ∅
state_after: no goals
tactic: rfl
Theorem: List.ofFn_getElem_eq_map
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
β : Type u_1
l : List α
f : α → β
⊢ (ofFn fun i => f l[↑i]) = map f l
state_after: no goals
tactic: rw [← Function.comp_def, ← map_ofFn, ofFn_getElem]
Theorem: Filter.coprodᵢ_neBot_iff
File: Mathlib/Order/Filter/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
p : (i : ι) → α i → Prop
inst✝ : ∀ (i : ι), Nonempty (α i)
⊢ (Filter.coprodᵢ f).NeBot ↔ ∃ d, (f d).NeBot
state_after: no goals
tactic: simp [coprodᵢ_neBot_iff', *]
Theorem: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable_range'
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω}
⊢ MeasurableSet {ω | i ≤ τ ω}
tactic: have : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω} := by
    ext1 ω
    simp only [le_iff_lt_or_eq, Set.mem_setOf_eq, Set.mem_union]
    rw [@eq_comm _ i, or_comm]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω}
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω}
⊢ MeasurableSet ({ω | τ ω = i} ∪ {ω | i < τ ω})
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω = i} ∪ {ω | i < τ ω}
⊢ MeasurableSet ({ω | τ ω = i} ∪ {ω | i < τ ω})
state_after: no goals
tactic: exact (hτ.measurableSet_eq_of_countable_range' h_countable i).union (hτ.measurableSet_gt' i)