ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.skeleton_skeletal
File: Mathlib/CategoryTheory/Skeletal.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
⊢ Skeletal (Skeleton C)
state_after: case intro
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 Y : Skeleton C
h : X ≅ Y
⊢ X = Y
tactic: rintro X Y ⟨h⟩
state_before: case intro
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 Y : Skeleton C
h : X ≅ Y
⊢ X = Y
state_after: case intro
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 Y : Skeleton C
h : X ≅ Y
this : Quotient.out X ≈ Quotient.out Y
⊢ X = Y
tactic: have : X.out ≈ Y.out := ⟨(fromSkeleton C).mapIso h⟩
state_before: case intro
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 Y : Skeleton C
h : X ≅ Y
this : Quotient.out X ≈ Quotient.out Y
⊢ X = Y
state_after: no goals
tactic: simpa using Quotient.sound this
Theorem: mul_inv_cancel_left₀
File: Mathlib/Algebra/GroupWithZero/Defs.lean

Proof steps:
state_before: G₀ : Type u
M₀ : Type u_1
M₀' : Type u_2
G₀' : Type u_3
inst✝ : GroupWithZero G₀
a b✝ c g h✝ x : G₀
h : a ≠ 0
b : G₀
⊢ a * a⁻¹ * b = b
state_after: no goals
tactic: simp [h]
Theorem: Finset.disjSups_union_right
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ s ○ (t₁ ∪ t₂) = s ○ t₁ ∪ s ○ t₂
state_after: no goals
tactic: simp [disjSups, filter_union, image_union]
Theorem: Nat.totient_lt
File: Mathlib/Data/Nat/Totient.lean

Proof steps:
state_before: n : ℕ
hn : 1 < n
⊢ 0 ∈ range n ∧ ¬n.Coprime 0
state_after: no goals
tactic: simp [hn.ne', pos_of_gt hn]
Theorem: Zsqrtd.isUnit_iff_norm_isUnit
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d✝ d : ℤ
z : ℤ√d
⊢ IsUnit z ↔ IsUnit z.norm
state_after: no goals
tactic: rw [Int.isUnit_iff_natAbs_eq, norm_eq_one_iff]
Theorem: StieltjesFunction.measure_Ioc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
a b : ℝ
⊢ f.measure (Ioc a b) = ofReal (↑f b - ↑f a)
state_after: f : StieltjesFunction
a b : ℝ
⊢ { toOuterMeasure := f.outer, m_iUnion := ⋯, trim_le := ⋯ } (Ioc a b) = ofReal (↑f b - ↑f a)
tactic: rw [StieltjesFunction.measure]
state_before: f : StieltjesFunction
a b : ℝ
⊢ { toOuterMeasure := f.outer, m_iUnion := ⋯, trim_le := ⋯ } (Ioc a b) = ofReal (↑f b - ↑f a)
state_after: no goals
tactic: exact f.outer_Ioc a b
Theorem: List.countP_cons_of_pos
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : p a = true
⊢ countP p (a :: l) = countP p l + 1
state_after: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countP.go p (a :: l) 0 = countP.go p l 1
⊢ countP p (a :: l) = countP p l + 1
tactic: have : countP.go p (a :: l) 0 = countP.go p l 1 := show cond .. = _ by rw [pa]; rfl
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countP.go p (a :: l) 0 = countP.go p l 1
⊢ countP p (a :: l) = countP p l + 1
state_after: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countP.go p (a :: l) 0 = countP.go p l 1
⊢ countP.go p (a :: l) 0 = countP.go p l 0 + 1
tactic: unfold countP
state_before: α : Type u_1
p q : α → Bool
a : α
l : List α
pa : p a = true
this : countP.go p (a :: l) 0 = countP.go p l 1
⊢ countP.go p (a :: l) 0 = countP.go p l 0 + 1
state_after: no goals
tactic: rw [this, Nat.add_comm, List.countP_go_eq_add]
Theorem: Filter.pi_inf_principal_univ_pi_neBot
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
⊢ (pi f ⊓ 𝓟 (univ.pi s)).NeBot ↔ ∀ (i : ι), (f i ⊓ 𝓟 (s i)).NeBot
state_after: no goals
tactic: simp [neBot_iff]
Theorem: Estimator.improveUntilAux_spec
File: Mathlib/Order/Estimator.lean

Proof steps:
state_before: α : Type u_1
ε : Type u_2
inst✝² : Preorder α
a : Thunk α
p : α → Bool
inst✝¹ : Estimator a ε
inst✝ : WellFoundedGT ↑(range (bound a))
e : ε
r : Bool
⊢ match improveUntilAux a p e r with
  | Except.error a_1 => ¬p a.get = true
  | Except.ok e' => p (bound a e') = true
state_after: α : Type u_1
ε : Type u_2
inst✝² : Preorder α
a : Thunk α
p : α → Bool
inst✝¹ : Estimator a ε
inst✝ : WellFoundedGT ↑(range (bound a))
e : ε
r : Bool
⊢ match
    if p (bound a e) = true then pure e
    else
      match improve a e, ⋯ with
      | none, x => Except.error (if r = true then none else some e)
      | some e', x => improveUntilAux a p e' true with
  | Except.error a_1 => ¬p a.get = true
  | Except.ok e' => p (bound a e') = true
tactic: rw [Estimator.improveUntilAux]
state_before: α : Type u_1
ε : Type u_2
inst✝² : Preorder α
a : Thunk α
p : α → Bool
inst✝¹ : Estimator a ε
inst✝ : WellFoundedGT ↑(range (bound a))
e : ε
r : Bool
⊢ match
    if p (bound a e) = true then pure e
    else
      match improve a e, ⋯ with
      | none, x => Except.error (if r = true then none else some e)
      | some e', x => improveUntilAux a p e' true with
  | Except.error a_1 => ¬p a.get = true
  | Except.ok e' => p (bound a e') = true
state_after: case pos
α : Type u_1
ε : Type u_2
inst✝² : Preorder α
a : Thunk α
p : α → Bool
inst✝¹ : Estimator a ε
inst✝ : WellFoundedGT ↑(range (bound a))
e : ε
r : Bool
h : p (bound a e) = true
⊢ match
    if p (bound a e) = true then pure e
    else
      match improve a e, ⋯ with
      | none, x => Except.error (if r = true then none else some e)
      | some e', x => improveUntilAux a p e' true with
  | Except.error a_1 => ¬p a.get = true
  | Except.ok e' => p (bound a e') = true

case neg
α : Type u_1
ε : Type u_2
inst✝² : Preorder α
a : Thunk α
p : α → Bool
inst✝¹ : Estimator a ε
inst✝ : WellFoundedGT ↑(range (bound a))
e : ε
r : Bool
h : ¬p (bound a e) = true
⊢ match
    if p (bound a e) = true then pure e
    else
      match improve a e, ⋯ with
      | none, x => Except.error (if r = true then none else some e)
      | some e', x => improveUntilAux a p e' true with
  | Except.error a_1 => ¬p a.get = true
  | Except.ok e' => p (bound a e') = true
tactic: by_cases h : p (bound a e)
Theorem: Finset.prod_univ_pi
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ✝ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝² : CommMonoid β
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
κ : ι → Type u_6
t : (i : ι) → Finset (κ i)
f : ((i : ι) → i ∈ univ → κ i) → β
⊢ ∏ x ∈ univ.pi t, f x = ∏ x ∈ Fintype.piFinset t, f fun a x_1 => x a
state_after: no goals
tactic: apply prod_nbij' (fun x i ↦ x i $ mem_univ _) (fun x i _ ↦ x i) <;> simp
Theorem: Metric.Sigma.isOpen_iff
File: Mathlib/Topology/MetricSpace/Gluing.lean

Proof steps:
state_before: ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
s : Set ((i : ι) × E i)
⊢ IsOpen s ↔ ∀ x ∈ s, ∃ ε > 0, ∀ (y : (i : ι) × E i), dist x y < ε → y ∈ s
state_after: case mp
ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
s : Set ((i : ι) × E i)
⊢ IsOpen s → ∀ x ∈ s, ∃ ε > 0, ∀ (y : (i : ι) × E i), dist x y < ε → y ∈ s

case mpr
ι : Type u_1
E : ι → Type u_2
inst✝ : (i : ι) → MetricSpace (E i)
s : Set ((i : ι) × E i)
⊢ (∀ x ∈ s, ∃ ε > 0, ∀ (y : (i : ι) × E i), dist x y < ε → y ∈ s) → IsOpen s
tactic: constructor
Theorem: Mathlib.Vector.mem_iff_get
File: Mathlib/Data/Vector/Mem.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α n
⊢ a ∈ v.toList ↔ ∃ i, v.get i = a
state_after: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α n
⊢ (∃ i, ∃ (h : i < v.toList.length), v.toList.get ⟨i, h⟩ = a) ↔ ∃ i, ∃ (h : i < n), v.toList.get (Fin.cast ⋯ ⟨i, h⟩) = a
tactic: simp only [List.mem_iff_get, Fin.exists_iff, Vector.get_eq_get]
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
v : Vector α n
⊢ (∃ i, ∃ (h : i < v.toList.length), v.toList.get ⟨i, h⟩ = a) ↔ ∃ i, ∃ (h : i < n), v.toList.get (Fin.cast ⋯ ⟨i, h⟩) = a
state_after: no goals
tactic: exact
    ⟨fun ⟨i, hi, h⟩ => ⟨i, by rwa [toList_length] at hi, h⟩, fun ⟨i, hi, h⟩ =>
      ⟨i, by rwa [toList_length], h⟩⟩
Theorem: Cardinal.ofENat_eq_zero
File: Mathlib/SetTheory/Cardinal/ENat.lean

Proof steps:
state_before: m : ℕ∞
⊢ ↑m = 0 ↔ m = 0
state_after: no goals
tactic: norm_cast
Theorem: List.nnnorm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝ : SeminormedRing α
l : List α
hl : l ≠ []
⊢ (map norm l).prod = (fun a => ↑a) (map nnnorm l).prod
state_after: no goals
tactic: simp [NNReal.coe_list_prod, List.map_map]
Theorem: List.mapIdxM_eq_mmap_enum
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β✝ : Type v
m : Type u → Type v
inst✝¹ : Monad m
inst✝ : LawfulMonad m
β : Type u
f : ℕ → α → m β
as : List α
⊢ as.mapIdxM f = List.traverse (uncurry f) as.enum
state_after: no goals
tactic: simp only [mapIdxM, mapIdxMGo_eq_mapIdxMAuxSpec, Array.toList_eq, Array.data_toArray,
    nil_append, mapIdxMAuxSpec, Array.size_toArray, length_nil, id_map', enum]
Theorem: PartialEquiv.image_source_inter_eq
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
s : Set α
⊢ ↑e '' (e.source ∩ s) = e.target ∩ ↑e.symm ⁻¹' (e.source ∩ s)
state_after: no goals
tactic: rw [inter_comm, e.leftInvOn.image_inter, image_source_eq_target, inter_comm]
Theorem: Dilation.diam_image
File: Mathlib/Topology/MetricSpace/Dilation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
F : Type u_4
G : Type u_5
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : FunLike F α β
inst✝ : DilationClass F α β
f : F
s : Set α
⊢ Metric.diam (⇑f '' s) = ↑(ratio f) * Metric.diam s
state_after: no goals
tactic: simp [Metric.diam, ediam_image, ENNReal.toReal_mul]
Theorem: Batteries.HashMap.Imp.Buckets.WF.update
File: .lake/packages/batteries/Batteries/Data/HashMap/WF.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
buckets : Buckets α β
i : USize
d : AssocList α β
h : i.toNat < buckets.val.size
H : buckets.WF
h₁ :
  ∀ [inst : PartialEquivBEq α] [inst : LawfulHashable α],
    List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) buckets.val[i].toList →
      List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) d.toList
h₂ :
  AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) buckets.val[i] →
    AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) d
⊢ (buckets.update i d h).WF
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝³ : BEq α
inst✝² : Hashable α
buckets : Buckets α β
i : USize
d : AssocList α β
h : i.toNat < buckets.val.size
H : buckets.WF
h₁ :
  ∀ [inst : PartialEquivBEq α] [inst : LawfulHashable α],
    List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) buckets.val[i].toList →
      List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) d.toList
h₂ :
  AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) buckets.val[i] →
    AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i.toNat) d
inst✝¹ : LawfulHashable α
inst✝ : PartialEquivBEq α
l : AssocList α β
hl : l ∈ (buckets.update i d h).val.data
⊢ List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) l.toList

case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : BEq α
inst✝ : Hashable α
buckets : Buckets α β
i✝ : USize
d : AssocList α β
h : i✝.toNat < buckets.val.size
H : buckets.WF
h₁ :
  ∀ [inst : PartialEquivBEq α] [inst : LawfulHashable α],
    List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) buckets.val[i✝].toList →
      List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) d.toList
h₂ :
  AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i✝.toNat) buckets.val[i✝] →
    AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i✝.toNat) d
i : Nat
hi : i < (buckets.update i✝ d h).val.size
p : α × β
hp : p ∈ (buckets.update i✝ d h).val[i].toList
⊢ (fun k x => ((hash k).toUSize % (buckets.update i✝ d h).val.size).toNat = i) p.fst p.snd
tactic: refine ⟨fun l hl => ?_, fun i hi p hp => ?_⟩
Theorem: Orientation.oangle_sub_left
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y z : V
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ o.oangle x z - o.oangle x y = o.oangle y z
state_after: no goals
tactic: rw [sub_eq_iff_eq_add, o.oangle_add_swap hx hy hz]
Theorem: Submonoid.multiset_noncommProd_mem
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
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
m : Multiset M
comm : {x | x ∈ m}.Pairwise Commute
h : ∀ x ∈ m, x ∈ S
⊢ m.noncommProd comm ∈ S
state_after: case h
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
l : List M
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
h : ∀ x ∈ ⟦l⟧, x ∈ S
⊢ Multiset.noncommProd ⟦l⟧ comm ∈ S
tactic: induction' m using Quotient.inductionOn with l
state_before: case h
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
l : List M
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
h : ∀ x ∈ ⟦l⟧, x ∈ S
⊢ Multiset.noncommProd ⟦l⟧ comm ∈ S
state_after: case h
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
l : List M
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
h : ∀ x ∈ ⟦l⟧, x ∈ S
⊢ l.prod ∈ S
tactic: simp only [Multiset.quot_mk_to_coe, Multiset.noncommProd_coe]
state_before: case h
M : Type u_1
A : Type u_2
B : Type u_3
inst✝² : Monoid M
inst✝¹ : SetLike B M
inst✝ : SubmonoidClass B M
S✝ : B
s S : Submonoid M
l : List M
comm : {x | x ∈ ⟦l⟧}.Pairwise Commute
h : ∀ x ∈ ⟦l⟧, x ∈ S
⊢ l.prod ∈ S
state_after: no goals
tactic: exact Submonoid.list_prod_mem _ h
Theorem: Set.countable_pi
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : Finite α
s : (a : α) → Set (π a)
hs : ∀ (a : α), (s a).Countable
⊢ {f | ∀ (a : α), f a ∈ s a}.Countable
state_after: no goals
tactic: simpa only [← mem_univ_pi] using countable_univ_pi hs
Theorem: lipschitzOnWith_iff_dist_le_mul
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ ↑K * dist x y
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ (∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)) ↔
    ∀ x ∈ s, ∀ y ∈ s, ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)
tactic: simp only [LipschitzOnWith, edist_nndist, dist_nndist]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
s : Set α
f : α → β
⊢ (∀ ⦃x : α⦄, x ∈ s → ∀ ⦃y : α⦄, y ∈ s → ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)) ↔
    ∀ x ∈ s, ∀ y ∈ s, ↑(nndist (f x) (f y)) ≤ ↑K * ↑(nndist x y)
state_after: no goals
tactic: norm_cast
Theorem: Profinite.NobelingProof.GoodProducts.injective
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)
⊢ Function.Injective (eval C)
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : eval C ⟨a, ha⟩ = eval C ⟨b, hb⟩
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
tactic: intro ⟨a, ha⟩ ⟨b, hb⟩ h
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : eval C ⟨a, ha⟩ = eval C ⟨b, hb⟩
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
tactic: dsimp [eval] at h
state_before: I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
state_after: case inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : a < b
⊢ ⟨a, ha⟩ = ⟨b, hb⟩

case inr.inl
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha hb : Products.isGood C a
h : Products.eval C a = Products.eval C a
⊢ ⟨a, ha⟩ = ⟨a, hb⟩

case inr.inr
I : Type u
inst✝¹ : LinearOrder I
inst✝ : IsWellOrder I fun x x_1 => x < x_1
C : Set (I → Bool)
a : Products I
ha : Products.isGood C a
b : Products I
hb : Products.isGood C b
h : Products.eval C a = Products.eval C b
h' : b < a
⊢ ⟨a, ha⟩ = ⟨b, hb⟩
tactic: rcases lt_trichotomy a b with (h'|rfl|h')
Theorem: Matrix.zpow_mul'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
h : IsUnit A.det
m n : ℤ
⊢ A ^ (m * n) = (A ^ n) ^ m
state_after: no goals
tactic: rw [mul_comm, zpow_mul _ h]
Theorem: CategoryTheory.tensorRightHomEquiv_symm_coevaluation_comp_whiskerLeft
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (tensorRightHomEquiv (𝟙_ C) (ᘁY) Y ᘁX).symm (η_ (ᘁX) X ≫ ᘁX ◁ f) = (λ_ ᘁY).hom ≫ ᘁf
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (η_ (ᘁX) X ≫ ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom =
    (λ_ ᘁY).hom ≫ (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom
tactic: dsimp [tensorRightHomEquiv, leftAdjointMate]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
⊢ (η_ (ᘁX) X ≫ ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom =
    (λ_ ᘁY).hom ≫ (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f) ▷ ᘁY ≫ (α_ (ᘁX) Y ᘁY).hom ≫ ᘁX ◁ ε_ (ᘁY) Y ≫ (ρ_ ᘁX).hom
state_after: no goals
tactic: simp
Theorem: t2Space_iff_nhds
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ T2Space X ↔ Pairwise fun x y => ∃ U ∈ 𝓝 x, ∃ V ∈ 𝓝 y, Disjoint U V
state_after: no goals
tactic: simp only [t2Space_iff_disjoint_nhds, Filter.disjoint_iff, Pairwise]
Theorem: integral_one_div_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, 1 / (1 + x ^ 2) = arctan b - arctan a
state_after: case refine_1
a b : ℝ
n : ℕ
⊢ Continuous fun x => 1 + x ^ 2

case refine_2
a b : ℝ
n : ℕ
x : ℝ
⊢ 1 + x ^ 2 ≠ 0
tactic: refine integral_deriv_eq_sub' _ Real.deriv_arctan (fun _ _ => differentiableAt_arctan _)
    (continuous_const.div ?_ fun x => ?_).continuousOn
Theorem: CategoryTheory.Limits.coprod.map_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryCoproduct A₁ B₁
inst✝¹ : HasBinaryCoproduct A₂ B₂
inst✝ : HasBinaryCoproduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ map f g ≫ map h k = map (f ≫ h) (g ≫ k)
state_after: no goals
tactic: ext <;> simp
Theorem: bddAbove_empty
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : Nonempty α
⊢ BddAbove ∅
state_after: no goals
tactic: simp only [BddAbove, upperBounds_empty, univ_nonempty]
Theorem: continuousOn_prod_of_discrete_left
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
s : Set (α × β)
⊢ ContinuousOn f s ↔ ∀ (a : α), ContinuousOn (fun x => f (a, x)) {b | (a, b) ∈ s}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
s : Set (α × β)
⊢ (∀ (a : α) (b : β), (a, b) ∈ s → ContinuousWithinAt (fun x => f (a, x)) {b | (a, b) ∈ s} b) ↔
    ∀ (a : α), ∀ x ∈ {b | (a, b) ∈ s}, ContinuousWithinAt (fun x => f (a, x)) {b | (a, b) ∈ s} x
tactic: simp_rw [ContinuousOn, Prod.forall, continuousWithinAt_prod_of_discrete_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝⁴ : (i : ι) → TopologicalSpace (π i)
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : DiscreteTopology α
f : α × β → γ
s : Set (α × β)
⊢ (∀ (a : α) (b : β), (a, b) ∈ s → ContinuousWithinAt (fun x => f (a, x)) {b | (a, b) ∈ s} b) ↔
    ∀ (a : α), ∀ x ∈ {b | (a, b) ∈ s}, ContinuousWithinAt (fun x => f (a, x)) {b | (a, b) ∈ s} x
state_after: no goals
tactic: rfl
Theorem: Real.one_sub_sq_div_two_le_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

Proof steps:
state_before: x : ℝ
⊢ 1 - x ^ 2 / 2 ≤ cos x
state_after: case inr
x : ℝ
this : ∀ {x : ℝ}, 0 ≤ x → 1 - x ^ 2 / 2 ≤ cos x
hx₀ : ¬0 ≤ x
⊢ 1 - x ^ 2 / 2 ≤ cos x

x✝ x : ℝ
hx₀ : 0 ≤ x
⊢ 1 - x ^ 2 / 2 ≤ cos x
tactic: wlog hx₀ : 0 ≤ x
state_before: x✝ x : ℝ
hx₀ : 0 ≤ x
⊢ 1 - x ^ 2 / 2 ≤ cos x
state_after: x✝ x : ℝ
hx₀ : 0 ≤ x
⊢ MonotoneOn (fun x => cos x + x ^ 2 / 2) (Ici 0)
tactic: suffices MonotoneOn (fun x ↦ cos x + x ^ 2 / 2) (Ici 0) by
    simpa using this left_mem_Ici hx₀ hx₀
state_before: x✝ x : ℝ
hx₀ : 0 ≤ x
⊢ MonotoneOn (fun x => cos x + x ^ 2 / 2) (Ici 0)
state_after: x✝¹ x✝ : ℝ
hx₀ : 0 ≤ x✝
x : ℝ
hx : x ∈ interior (Ici 0)
⊢ 0 ≤ -sin x + ↑2 * x ^ (2 - 1) / 2
tactic: refine monotoneOn_of_hasDerivWithinAt_nonneg
    (convex_Ici _) (by fun_prop)
    (fun x _ ↦ ((hasDerivAt_cos ..).add <| (hasDerivAt_pow ..).div_const _).hasDerivWithinAt)
    fun x hx ↦ ?_
state_before: x✝¹ x✝ : ℝ
hx₀ : 0 ≤ x✝
x : ℝ
hx : x ∈ interior (Ici 0)
⊢ 0 ≤ -sin x + ↑2 * x ^ (2 - 1) / 2
state_after: no goals
tactic: simpa [mul_div_cancel_left₀] using sin_le <| interior_subset hx