ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.lookupAll_eq_dlookup
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (dlookup a l).toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (lookupAll a l).head?.toList
tactic: rw [← head?_lookupAll]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ lookupAll a l = (lookupAll a l).head?.toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
h1 : (lookupAll a l).length ≤ 1
⊢ lookupAll a l = (lookupAll a l).head?.toList
tactic: have h1 := lookupAll_length_le_one a h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
h1 : (lookupAll a l).length ≤ 1
⊢ lookupAll a l = (lookupAll a l).head?.toList
state_after: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).length ≤ 1 → lookupAll a l = (lookupAll a l).head?.toList
tactic: revert h1
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l : List (Sigma β)
h : l.NodupKeys
⊢ (lookupAll a l).length ≤ 1 → lookupAll a l = (lookupAll a l).head?.toList
state_after: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : l✝.NodupKeys
b c : β a
l : List (β a)
h1 : (b :: c :: l).length ≤ 1
⊢ b :: c :: l = (b :: c :: l).head?.toList
tactic: rcases lookupAll a l with (_ | ⟨b, _ | ⟨c, l⟩⟩) <;> intro h1 <;> try rfl
state_before: case cons.cons
α : Type u
β : α → Type v
l✝¹ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l✝ : List (Sigma β)
h : l✝.NodupKeys
b c : β a
l : List (β a)
h1 : (b :: c :: l).length ≤ 1
⊢ b :: c :: l = (b :: c :: l).head?.toList
state_after: no goals
tactic: exact absurd h1 (by simp)
Theorem: Finset.piecewise_mem_set_pi
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π✝ : ι → Sort u_2
s : Finset ι
f✝ g✝ : (i : ι) → π✝ i
inst✝ : (j : ι) → Decidable (j ∈ s)
π : ι → Type u_3
t : Set ι
t' : (i : ι) → Set (π i)
f g f' g' h : (i : ι) → π i
hf : f ∈ t.pi t'
hg : g ∈ t.pi t'
⊢ s.piecewise f g ∈ t.pi t'
state_after: no goals
tactic: classical rw [← piecewise_coe]; exact Set.piecewise_mem_pi (↑s) hf hg
Theorem: Associates.map_subtype_coe_factors'
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
⊢ Multiset.map Subtype.val (factors' a) = Multiset.map Associates.mk (factors a)
state_after: no goals
tactic: simp [factors', Multiset.map_pmap, Multiset.pmap_eq_map]
Theorem: Set.exists_isOpen_le_add
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
ε : ℝ≥0∞
hε : ε ≠ 0
⊢ ∃ U ⊇ A, IsOpen U ∧ μ U ≤ μ A + ε
state_after: case inl
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
ε : ℝ≥0∞
hε : ε ≠ 0
H : μ A = ⊤
⊢ ∃ U ⊇ A, IsOpen U ∧ μ U ≤ μ A + ε

case inr
α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ✝ : Measure α
A : Set α
μ : Measure α
inst✝ : μ.OuterRegular
ε : ℝ≥0∞
hε : ε ≠ 0
H : μ A ≠ ⊤
⊢ ∃ U ⊇ A, IsOpen U ∧ μ U ≤ μ A + ε
tactic: rcases eq_or_ne (μ A) ∞ with (H | H)
Theorem: CategoryTheory.PreGaloisCategory.lt_card_fiber_of_mono_of_notIso
File: Mathlib/CategoryTheory/Galois/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
⊢ Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ False
tactic: by_contra hlt
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ False
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ IsIso f
tactic: apply h
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ IsIso f
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
tactic: apply isIso_of_mono_of_eq_card_fiber F f
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : ¬Nat.card ↑(F.obj X) < Nat.card ↑(F.obj Y)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : Nat.card ↑(F.obj Y) ≤ Nat.card ↑(F.obj X)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
tactic: simp only [gt_iff_lt, not_lt] at hlt
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : ¬IsIso f
hlt : Nat.card ↑(F.obj Y) ≤ Nat.card ↑(F.obj X)
⊢ Nat.card ↑(F.obj X) = Nat.card ↑(F.obj Y)
state_after: no goals
tactic: exact Nat.le_antisymm
    (Finite.card_le_of_injective (F.map f) (injective_of_mono_of_preservesPullback (F.map f))) hlt
Theorem: CategoryTheory.IsCofiltered.small_fullSubcategory_cofilteredClosure
File: Mathlib/CategoryTheory/Filtered/Small.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
α : Type w
f : α → C
⊢ Small.{max v w, u} (FullSubcategory (CofilteredClosure f))
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
α : Type w
f : α → C
⊢ ∀ (b : FullSubcategory (CofilteredClosure f)),
    ∃ a, CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a = b.obj
tactic: refine small_of_injective_of_exists
    (CofilteredClosureSmall.abstractCofilteredClosureRealization f) FullSubcategory.ext ?_
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
α : Type w
f : α → C
⊢ ∀ (b : FullSubcategory (CofilteredClosure f)),
    ∃ a, CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a = b.obj
state_after: case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
α : Type w
f : α → C
j : C
h : CofilteredClosure f j
⊢ ∃ a,
    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =
      { obj := j, property := h }.obj
tactic: rintro ⟨j, h⟩
state_before: case mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : IsCofilteredOrEmpty C
α : Type w
f : α → C
j : C
h : CofilteredClosure f j
⊢ ∃ a,
    CategoryTheory.IsCofiltered.CofilteredClosureSmall.abstractCofilteredClosureRealization f a =
      { obj := j, property := h }.obj
state_after: no goals
tactic: induction h with
  | base x => exact ⟨⟨0, ⟨x⟩⟩, rfl⟩
  | min hj₁ hj₂ ih ih' =>
    rcases ih with ⟨⟨n, x⟩, rfl⟩
    rcases ih' with ⟨⟨m, y⟩, rfl⟩
    refine ⟨⟨(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.min ?_ ?_ x y⟩, rfl⟩
    all_goals apply Nat.lt_succ_of_le
    exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]
  | eq hj₁ hj₂ g g' ih ih' =>
    rcases ih with ⟨⟨n, x⟩, rfl⟩
    rcases ih' with ⟨⟨m, y⟩, rfl⟩
    refine ⟨⟨(Max.max n m).succ, CofilteredClosureSmall.InductiveStep.eq ?_ ?_ x y g g'⟩, rfl⟩
    all_goals apply Nat.lt_succ_of_le
    exacts [Nat.le_max_left _ _, Nat.le_max_right _ _]
Theorem: Set.Icc_bot
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : OrderBot α
a : α
⊢ Icc ⊥ a = Iic a
state_after: no goals
tactic: simp [← Ici_inter_Iic]
Theorem: Matroid.Dep.nonempty
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hD : M.Dep D
⊢ D.Nonempty
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hD : M.Dep D
⊢ D ≠ ∅
tactic: rw [nonempty_iff_ne_empty]
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hD : M.Dep D
⊢ D ≠ ∅
state_after: α : Type u_1
M : Matroid α
B B' I J X : Set α
e f : α
hD : M.Dep ∅
⊢ False
tactic: rintro rfl
state_before: α : Type u_1
M : Matroid α
B B' I J X : Set α
e f : α
hD : M.Dep ∅
⊢ False
state_after: no goals
tactic: exact hD.not_indep M.empty_indep
Theorem: List.sum_eq_nsmul_single
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
a : M
h : ∀ (a' : M), a' ≠ a → a' ∈ l → a' = 1
⊢ l.prod = (map id l).prod
state_after: no goals
tactic: rw [map_id]
Theorem: CategoryTheory.Limits.Multicofork.ofπ_ι_app
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I✝ : MultispanIndex C
K : Multicofork I✝
I : MultispanIndex C
P : C
π : (b : I.R) → I.right b ⟶ P
w : ∀ (a : I.L), I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)
⊢ ∀ ⦃X Y : WalkingMultispan I.fstFrom I.sndFrom⦄ (f : X ⟶ Y),
    I.multispan.map f ≫
        (fun x =>
            match x with
            | WalkingMultispan.left a => I.fst a ≫ π (I.fstFrom a)
            | WalkingMultispan.right b => π b)
          Y =
      (fun x =>
            match x with
            | WalkingMultispan.left a => I.fst a ≫ π (I.fstFrom a)
            | WalkingMultispan.right b => π b)
          X ≫
        ((Functor.const (WalkingMultispan I.fstFrom I.sndFrom)).obj P).map f
state_after: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MultispanIndex C
K : Multicofork I✝
I : MultispanIndex C
P : C
π : (b : I.R) → I.right b ⟶ P
w : ∀ (a : I.L), I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)
a✝ : I.L
⊢ I.snd a✝ ≫ π (I.sndFrom a✝) = I.fst a✝ ≫ π (I.fstFrom a✝)
tactic: rintro (_ | _) (_ | _) (_ | _ | _) <;> dsimp <;>
          simp only [Functor.map_id, MultispanIndex.multispan_obj_left,
            Category.id_comp, Category.comp_id, MultispanIndex.multispan_obj_right]
state_before: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MultispanIndex C
K : Multicofork I✝
I : MultispanIndex C
P : C
π : (b : I.R) → I.right b ⟶ P
w : ∀ (a : I.L), I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)
a✝ : I.L
⊢ I.snd a✝ ≫ π (I.sndFrom a✝) = I.fst a✝ ≫ π (I.fstFrom a✝)
state_after: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MultispanIndex C
K : Multicofork I✝
I : MultispanIndex C
P : C
π : (b : I.R) → I.right b ⟶ P
w : ∀ (a : I.L), I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)
a✝ : I.L
⊢ I.fst a✝ ≫ π (I.fstFrom a✝) = I.snd a✝ ≫ π (I.sndFrom a✝)
tactic: symm
state_before: case left.right.snd
C : Type u
inst✝ : Category.{v, u} C
I✝ : MultispanIndex C
K : Multicofork I✝
I : MultispanIndex C
P : C
π : (b : I.R) → I.right b ⟶ P
w : ∀ (a : I.L), I.fst a ≫ π (I.fstFrom a) = I.snd a ≫ π (I.sndFrom a)
a✝ : I.L
⊢ I.fst a✝ ≫ π (I.fstFrom a✝) = I.snd a✝ ≫ π (I.sndFrom a✝)
state_after: no goals
tactic: apply w
Theorem: tendsto_list_prod
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
x✝ : ∀ i ∈ [], Tendsto (f i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f c b) []).prod) x (𝓝 (List.map a []).prod)
state_after: no goals
tactic: simp [tendsto_const_nhds]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f✝ c b) (f :: l)).prod) x (𝓝 (List.map a (f :: l)).prod)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))
tactic: simp only [List.map_cons, List.prod_cons]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))
state_after: no goals
tactic: exact
      (h f (List.mem_cons_self _ _)).mul
        (tendsto_list_prod l fun c hc => h c (List.mem_cons_of_mem _ hc))
Theorem: CategoryTheory.Limits.fst_of_isColimit
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsColimit t.toCocone
⊢ t.fst = ht.desc (BinaryCofan.mk (𝟙 X) 0)
state_after: case x
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsColimit t.toCocone
⊢ ∀ (j : Discrete WalkingPair), t.toCocone.ι.app j ≫ t.fst = (BinaryCofan.mk (𝟙 X) 0).ι.app j
tactic: apply ht.uniq (BinaryCofan.mk (𝟙 X) 0)
state_before: case x
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
X Y : C
t : BinaryBicone X Y
ht : IsColimit t.toCocone
⊢ ∀ (j : Discrete WalkingPair), t.toCocone.ι.app j ≫ t.fst = (BinaryCofan.mk (𝟙 X) 0).ι.app j
state_after: no goals
tactic: rintro ⟨⟨⟩⟩ <;> dsimp <;> simp
Theorem: Filter.blimsup_false
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ (blimsup u f fun x => False) = ⊥
state_after: no goals
tactic: simp [blimsup_eq]
Theorem: Finset.inl_mem_sumLexLift
File: Mathlib/Data/Sum/Interval.lean

Proof steps:
state_before: α₁ : Type u_1
α₂ : Type u_2
β₁ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
f₁ f₁' : α₁ → β₁ → Finset γ₁
f₂ f₂' : α₂ → β₂ → Finset γ₂
g₁ g₁' : α₁ → β₂ → Finset γ₁
g₂ g₂' : α₁ → β₂ → Finset γ₂
a : α₁ ⊕ α₂
b : β₁ ⊕ β₂
c : γ₁ ⊕ γ₂
c₁ : γ₁
⊢ inl c₁ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
    (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨ ∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₁ ∈ g₁ a₁ b₂
state_after: no goals
tactic: simp [mem_sumLexLift]
Theorem: iteratedFDeriv_const_of_ne
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x✝ x₀ : E
c✝ : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hn : n ≠ 0
c : F
x : E
⊢ iteratedFDeriv 𝕜 n (fun x => c) x = 0 x
state_after: no goals
tactic: simpa [← iteratedFDerivWithin_univ] using
    iteratedFDerivWithin_const_of_ne hn c uniqueDiffOn_univ (mem_univ x)
Theorem: Profinite.NobelingProof.GoodProducts.union
File: Mathlib/Topology/Category/Profinite/Nobeling.lean

Proof steps:
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
⊢ range C = ⋃ e, smaller C ↑e
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
⊢ p ∈ range C ↔ p ∈ ⋃ e, smaller C ↑e
tactic: ext p
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
⊢ p ∈ range C ↔ p ∈ ⋃ e, smaller C ↑e
state_after: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
⊢ (∃ a, ∃ (b : Products.isGood C a), eval C ⟨a, b⟩ = p) ↔
    ∃ a,
      ∃ (h : a < o),
        ∃ x,
          (∃ a_1,
              ∃ (h_1 : Products.isGood (π C fun x => ord I x < a) a_1), eval (π C fun x => ord I x < a) ⟨a_1, ⋯⟩ = x) ∧
            (πs C a) x = p
tactic: simp only [smaller, range, Set.mem_iUnion, Set.mem_image, Set.mem_range, Subtype.exists]
state_before: case h
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
⊢ (∃ a, ∃ (b : Products.isGood C a), eval C ⟨a, b⟩ = p) ↔
    ∃ a,
      ∃ (h : a < o),
        ∃ x,
          (∃ a_1,
              ∃ (h_1 : Products.isGood (π C fun x => ord I x < a) a_1), eval (π C fun x => ord I x < a) ⟨a_1, ⋯⟩ = x) ∧
            (πs C a) x = p
state_after: case h.refine_1
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
hp : ∃ a, ∃ (b : Products.isGood C a), eval C ⟨a, b⟩ = p
⊢ ∃ a,
    ∃ (h : a < o),
      ∃ x,
        (∃ a_1,
            ∃ (h_1 : Products.isGood (π C fun x => ord I x < a) a_1), eval (π C fun x => ord I x < a) ⟨a_1, ⋯⟩ = x) ∧
          (πs C a) x = p

case h.refine_2
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
o : Ordinal.{u}
ho : o.IsLimit
hsC : contained C o
p : LocallyConstant ↑C ℤ
hp :
  ∃ a,
    ∃ (h : a < o),
      ∃ x,
        (∃ a_1,
            ∃ (h_1 : Products.isGood (π C fun x => ord I x < a) a_1), eval (π C fun x => ord I x < a) ⟨a_1, ⋯⟩ = x) ∧
          (πs C a) x = p
⊢ ∃ a, ∃ (b : Products.isGood C a), eval C ⟨a, b⟩ = p
tactic: refine ⟨fun hp ↦ ?_, fun hp ↦ ?_⟩
Theorem: Filter.blimsup_eq_iInf_biSup_of_nat
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
p : ℕ → Prop
u : ℕ → α
⊢ blimsup u atTop p = ⨅ i, ⨆ j, ⨆ (_ : p j ∧ i ≤ j), u j
state_after: no goals
tactic: simp only [atTop_basis.blimsup_eq_iInf_iSup, @and_comm (p _), iSup_and, mem_Ici, iInf_true]
Theorem: isOpen_prod_iff'
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
⊢ IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅
state_after: case inl
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
h : s ×ˢ t = ∅
⊢ IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅

case inr
X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
h : (s ×ˢ t).Nonempty
⊢ IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅
tactic: rcases (s ×ˢ t).eq_empty_or_nonempty with h | h
Theorem: Asymptotics.IsLittleO.sqrt
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
r c : ℝ
l : Filter α
f g : α → ℝ
hfg : f =o[l] g
hg : 0 ≤ᶠ[l] g
⊢ (fun x => √(f x)) =o[l] fun x => √(g x)
state_after: no goals
tactic: simpa [Real.sqrt_eq_rpow] using hfg.rpow one_half_pos hg
Theorem: BoundedContinuousFunction.norm_sub_nonneg
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
⊢ 0 ≤ const α ‖f‖ - f
state_after: F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ (fun f => f.toFun) 0 x ≤ (fun f => f.toFun) (const α ‖f‖ - f) x
tactic: intro x
state_before: F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ (fun f => f.toFun) 0 x ≤ (fun f => f.toFun) (const α ‖f‖ - f) x
state_after: F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ f x ≤ ‖f‖
tactic: simp only [ContinuousMap.toFun_eq_coe, coe_to_continuous_fun, coe_zero, Pi.zero_apply, coe_sub,
    const_toFun, Pi.sub_apply, sub_nonneg]
state_before: F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ
x : α
⊢ f x ≤ ‖f‖
state_after: no goals
tactic: linarith [(abs_le.mp (norm_coe_le_norm f x)).2]
Theorem: MeasureTheory.L1.continuous_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integral f
state_after: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integralCLM f
tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
𝕜 : Type u_4
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
⊢ Continuous fun f => integralCLM f
state_after: no goals
tactic: exact L1.integralCLM.continuous