ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: measurable_uniqueElim
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝⁴ : MeasurableSpace α
inst✝³ : (a : δ) → MeasurableSpace (π a)
inst✝² : MeasurableSpace γ
inst✝¹ : Unique δ
inst✝ : (i : δ) → MeasurableSpace (π i)
⊢ Measurable uniqueElim
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝⁴ : MeasurableSpace α
inst✝³ : (a : δ) → MeasurableSpace (π a)
inst✝² : MeasurableSpace γ
inst✝¹ : Unique δ
inst✝ : (i : δ) → MeasurableSpace (π i)
⊢ Measurable fun x => x
tactic: simp_rw [measurable_pi_iff, Unique.forall_iff, uniqueElim_default]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
π : δ → Type u_6
inst✝⁴ : MeasurableSpace α
inst✝³ : (a : δ) → MeasurableSpace (π a)
inst✝² : MeasurableSpace γ
inst✝¹ : Unique δ
inst✝ : (i : δ) → MeasurableSpace (π i)
⊢ Measurable fun x => x
state_after: no goals
tactic: exact measurable_id
Theorem: Fin.sum_univ_six
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ ∏ i : Fin 6, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (last 5) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5
tactic: rw [prod_univ_castSucc, prod_univ_five]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (castSucc 4) * f (last 5) =
    f 0 * f 1 * f 2 * f 3 * f 4 * f 5
state_after: no goals
tactic: rfl
Theorem: List.nodup_iff_get?_ne_get?
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
⊢ l.Nodup ↔ ∀ (i j : ℕ), i < j → j < l.length → l.get? i ≠ l.get? j
state_after: no goals
tactic: simp [nodup_iff_getElem?_ne_getElem?]
Theorem: Sym2.mem_iff'
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ Sym2.Mem a s(b, c) → a = b ∨ a = c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : s(b, c) = s(a, w✝)
⊢ a = b ∨ a = c
tactic: rintro ⟨_, h⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : s(b, c) = s(a, w✝)
⊢ a = b ∨ a = c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : b = a ∧ c = w✝ ∨ b = w✝ ∧ c = a
⊢ a = b ∨ a = c
tactic: rw [eq_iff] at h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c w✝ : α
h : b = a ∧ c = w✝ ∨ b = w✝ ∧ c = a
⊢ a = b ∨ a = c
state_after: no goals
tactic: aesop
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c : α
⊢ a = b ∨ a = c → Sym2.Mem a s(b, c)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
a c : α
⊢ Sym2.Mem a s(a, c)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(b, a)
tactic: rintro (rfl | rfl)
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(b, a)
state_after: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(a, b)
tactic: rw [eq_swap]
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
a b : α
⊢ Sym2.Mem a s(a, b)
state_after: no goals
tactic: exact ⟨_, rfl⟩
Theorem: CategoryTheory.ShortComplex.RightHomologyMapData.opcyclesMap_comm
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
γ : RightHomologyMapData φ h₁ h₂
inst✝¹ : S₁.HasRightHomology
inst✝ : S₂.HasRightHomology
⊢ opcyclesMap φ ≫ h₂.opcyclesIso.hom = h₁.opcyclesIso.hom ≫ γ.φQ
state_after: no goals
tactic: simp only [γ.opcyclesMap_eq, assoc, Iso.inv_hom_id, comp_id]
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.braiding_naturality
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Symmetric.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ tensorHom ℬ f g ≫ (BinaryFan.braiding (ℬ Y Y').isLimit (ℬ Y' Y).isLimit).hom =
    (BinaryFan.braiding (ℬ X X').isLimit (ℬ X' X).isLimit).hom ≫ tensorHom ℬ g f
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (ℬ Y Y').isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
      ((ℬ Y Y').isLimit.conePointUniqueUpToIso (ℬ Y' Y).isLimit.swapBinaryFan).hom =
    ((ℬ X X').isLimit.conePointUniqueUpToIso (ℬ X' X).isLimit.swapBinaryFan).hom ≫
      (ℬ Y' Y).isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))
tactic: dsimp [tensorHom, Limits.BinaryFan.braiding]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ (ℬ Y Y').isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
      ((ℬ Y Y').isLimit.conePointUniqueUpToIso (ℬ Y' Y).isLimit.swapBinaryFan).hom =
    ((ℬ X X').isLimit.conePointUniqueUpToIso (ℬ X' X).isLimit.swapBinaryFan).hom ≫
      (ℬ Y' Y).isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X X' Y Y' : C
f : X ⟶ Y
g : X' ⟶ Y'
⊢ ∀ (j : Discrete WalkingPair),
    ((ℬ Y Y').isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X X').cone ≫ f) (BinaryFan.snd (ℬ X X').cone ≫ g)) ≫
          ((ℬ Y Y').isLimit.conePointUniqueUpToIso (ℬ Y' Y).isLimit.swapBinaryFan).hom) ≫
        (ℬ Y' Y).cone.π.app j =
      (((ℬ X X').isLimit.conePointUniqueUpToIso (ℬ X' X).isLimit.swapBinaryFan).hom ≫
          (ℬ Y' Y).isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X' X).cone ≫ g) (BinaryFan.snd (ℬ X' X).cone ≫ f))) ≫
        (ℬ Y' Y).cone.π.app j
tactic: apply (ℬ _ _).isLimit.hom_ext
Theorem: CategoryTheory.regularTopology.parallelPair_pullback_initial
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.61160, u_2} D
inst✝ : Category.{?u.61164, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ (parallelPair (Over.homMk c.fst ⋯).op (Over.homMk c.snd ⋯).op).Initial
state_after: case h₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.61160, u_2} D
inst✝ : Category.{?u.61164, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ (Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ),
    Nonempty (op ((Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯) ⟶ Z)

case h₂
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_4, u_1} C
inst✝¹ : Category.{?u.61160, u_2} D
inst✝ : Category.{?u.61164, u_3} E
X B : C
π : X ⟶ B
c : PullbackCone π π
hc : IsLimit c
⊢ ∀ ⦃Z : (Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryᵒᵖ⦄
    (i j : op ((Sieve.ofArrows (fun x => X) fun x => π).arrows.categoryMk π ⋯) ⟶ Z),
    ∃ a, i = (Over.homMk c.fst ⋯).op ≫ a ∧ j = (Over.homMk c.snd ⋯).op ≫ a
tactic: apply Limits.parallelPair_initial_mk
Theorem: max_def_lt
File: Mathlib/Order/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ max x y = if x < y then y else x
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ (if ¬y ≤ x then y else x) = if x < y then y else x
tactic: rw [max_comm, max_def, ← ite_not]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : LinearOrder α
p : α → Prop
x✝ y✝ x y : α
⊢ (if ¬y ≤ x then y else x) = if x < y then y else x
state_after: no goals
tactic: simp only [not_le]
Theorem: Set.strictMonoOn_projIic
File: Mathlib/Order/Interval/Set/ProjIcc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ x : α
hx : x ∈ Iic b
y : α
hy : y ∈ Iic b
hxy : x < y
⊢ projIic b x < projIic b y
state_after: no goals
tactic: simpa only [projIic_of_mem, hx, hy]
Theorem: Fin.le_pred_castSucc_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a b : Fin (n + 1)
ha : a.castSucc ≠ 0
⊢ b ≤ a.castSucc.pred ha ↔ b < a
state_after: no goals
tactic: rw [le_pred_iff, succ_le_castSucc_iff]
Theorem: MeasureTheory.integrable_condexpL2_indicator
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹⁹ : RCLike 𝕜
inst✝¹⁸ : NormedAddCommGroup E
inst✝¹⁷ : InnerProductSpace 𝕜 E
inst✝¹⁶ : CompleteSpace E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : InnerProductSpace 𝕜 E'
inst✝¹³ : CompleteSpace E'
inst✝¹² : NormedSpace ℝ E'
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup G'
inst✝⁷ : NormedSpace ℝ G'
inst✝⁶ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
E'' : Type u_8
𝕜' : Type u_9
inst✝⁵ : RCLike 𝕜'
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : InnerProductSpace 𝕜' E''
inst✝² : CompleteSpace E''
inst✝¹ : NormedSpace ℝ E''
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : E'
⊢ Integrable (↑↑↑((condexpL2 E' 𝕜 hm) (indicatorConstLp 2 hs hμs x))) μ
state_after: case refine_1
α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹⁹ : RCLike 𝕜
inst✝¹⁸ : NormedAddCommGroup E
inst✝¹⁷ : InnerProductSpace 𝕜 E
inst✝¹⁶ : CompleteSpace E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : InnerProductSpace 𝕜 E'
inst✝¹³ : CompleteSpace E'
inst✝¹² : NormedSpace ℝ E'
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup G'
inst✝⁷ : NormedSpace ℝ G'
inst✝⁶ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
E'' : Type u_8
𝕜' : Type u_9
inst✝⁵ : RCLike 𝕜'
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : InnerProductSpace 𝕜' E''
inst✝² : CompleteSpace E''
inst✝¹ : NormedSpace ℝ E''
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : E'
⊢ AEStronglyMeasurable (↑↑↑((condexpL2 E' 𝕜 hm) (indicatorConstLp 2 hs hμs x))) μ

case refine_2
α : Type u_1
E : Type u_2
E' : Type u_3
F : Type u_4
G : Type u_5
G' : Type u_6
𝕜 : Type u_7
p : ℝ≥0∞
inst✝¹⁹ : RCLike 𝕜
inst✝¹⁸ : NormedAddCommGroup E
inst✝¹⁷ : InnerProductSpace 𝕜 E
inst✝¹⁶ : CompleteSpace E
inst✝¹⁵ : NormedAddCommGroup E'
inst✝¹⁴ : InnerProductSpace 𝕜 E'
inst✝¹³ : CompleteSpace E'
inst✝¹² : NormedSpace ℝ E'
inst✝¹¹ : NormedAddCommGroup F
inst✝¹⁰ : NormedSpace 𝕜 F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup G'
inst✝⁷ : NormedSpace ℝ G'
inst✝⁶ : CompleteSpace G'
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
E'' : Type u_8
𝕜' : Type u_9
inst✝⁵ : RCLike 𝕜'
inst✝⁴ : NormedAddCommGroup E''
inst✝³ : InnerProductSpace 𝕜' E''
inst✝² : CompleteSpace E''
inst✝¹ : NormedSpace ℝ E''
hm : m ≤ m0
inst✝ : SigmaFinite (μ.trim hm)
hs : MeasurableSet s
hμs : μ s ≠ ⊤
x : E'
⊢ ∀ (s_1 : Set α),
    MeasurableSet s_1 →
      μ s_1 ≠ ⊤ → ∫⁻ (x_1 : α) in s_1, ↑‖↑↑↑((condexpL2 E' 𝕜 hm) (indicatorConstLp 2 hs hμs x)) x_1‖₊ ∂μ ≤ μ s * ↑‖x‖₊
tactic: refine integrable_of_forall_fin_meas_le' hm (μ s * ‖x‖₊)
    (ENNReal.mul_lt_top hμs ENNReal.coe_ne_top) ?_ ?_
Theorem: StalkSkyscraperPresheafAdjunctionAuxs.to_skyscraper_fromStalk
File: Mathlib/Topology/Sheaves/Skyscraper.lean

Proof steps:
state_before: X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
⊢ toSkyscraperPresheaf p₀ (fromStalk p₀ f) = f
state_after: case app
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app = f.app
tactic: apply NatTrans.ext
state_before: case app
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app = f.app
state_after: case app.h
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app U = f.app U
tactic: ext U
state_before: case app.h
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
⊢ (toSkyscraperPresheaf p₀ (fromStalk p₀ f)).app U = f.app U
state_after: case app.h
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
⊢ (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ fromStalk p₀ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) =
    f.app U
tactic: dsimp
state_before: case app.h
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
⊢ (if h : p₀ ∈ unop U then 𝓕.germ ⟨p₀, h⟩ ≫ fromStalk p₀ f ≫ eqToHom ⋯ else (⋯ ▸ terminalIsTerminal).from (𝓕.obj U)) =
    f.app U
state_after: case pos
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
h : p₀ ∈ unop U
⊢ 𝓕.germ ⟨p₀, h⟩ ≫ fromStalk p₀ f ≫ eqToHom ⋯ = f.app U

case neg
X : TopCat
p₀ : ↑X
inst✝³ : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝² : Category.{u, v} C
A : C
inst✝¹ : HasTerminal C
inst✝ : HasColimits C
𝓕 : Presheaf C X
c : C
f : 𝓕 ⟶ skyscraperPresheaf p₀ c
U : (Opens ↑X)ᵒᵖ
h : p₀ ∉ unop U
⊢ (⋯ ▸ terminalIsTerminal).from (𝓕.obj U) = f.app U
tactic: split_ifs with h
Theorem: lt_inv_mul_iff_lt
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ 1 < b⁻¹ * a ↔ b < a
state_after: no goals
tactic: rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
Theorem: Matrix.det_one
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ det 1 = 1
state_after: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ (diagonal fun x => 1).det = 1
tactic: rw [← diagonal_one]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
⊢ (diagonal fun x => 1).det = 1
state_after: no goals
tactic: simp [-diagonal_one]
Theorem: CoxeterSystem.exists_reduced_word
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
this : ∃ ω, ω.length = Nat.find ⋯ ∧ cs.wordProd ω = w
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω
tactic: have := Nat.find_spec (cs.exists_word_with_prod w)
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
this : ∃ ω, ω.length = Nat.find ⋯ ∧ cs.wordProd ω = w
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω
state_after: no goals
tactic: tauto
Theorem: SlashAction.neg_slash
File: Mathlib/NumberTheory/ModularForms/SlashActions.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
α : Type u_3
γ : Type u_4
inst✝³ : Group G
inst✝² : AddGroup α
inst✝¹ : SMul γ α
inst✝ : SlashAction β G α γ
k : β
g : G
a : α
⊢ (-a) ∣[k;γ] g + a ∣[k;γ] g = 0
state_after: no goals
tactic: rw [← SlashAction.add_slash, add_left_neg, SlashAction.zero_slash]
Theorem: MeasureTheory.locallyIntegrable_finset_sum
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f✝ g : X → E
μ : Measure X
s✝ : Set X
ι : Type u_6
s : Finset ι
f : ι → X → E
hf : ∀ i ∈ s, LocallyIntegrable (f i) μ
⊢ LocallyIntegrable (fun a => ∑ i ∈ s, f i a) μ
state_after: no goals
tactic: simpa only [← Finset.sum_apply] using locallyIntegrable_finset_sum' s hf
Theorem: Finset.nonempty_Ico
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ (Ico a b).Nonempty ↔ a < b
state_after: no goals
tactic: rw [← coe_nonempty, coe_Ico, Set.nonempty_Ico]
Theorem: List.foldr_hom
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: β₁ : Type u_1
β₂ : Type u_2
α : Type u_3
f : β₁ → β₂
g₁ : α → β₁ → β₁
g₂ : α → β₂ → β₂
l : List α
init : β₁
H : ∀ (x : α) (y : β₁), g₂ x (f y) = f (g₁ x y)
⊢ foldr g₂ (f init) l = f (foldr g₁ init l)
state_after: no goals
tactic: induction l <;> simp [*, H]
Theorem: MeasureTheory.VectorMeasure.exists_pos_measure_of_not_restrict_le_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬v.restrict i ≤ restrict 0 i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬v.restrict i ≤ restrict 0 i
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
tactic: have hi₁ : MeasurableSet i := measurable_of_not_restrict_le_zero _ hi
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬v.restrict i ≤ restrict 0 i
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑0 j
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
tactic: rw [restrict_le_restrict_iff _ _ hi₁] at hi
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi : ¬∀ ⦃j : Set α⦄, MeasurableSet j → j ⊆ i → ↑v j ≤ ↑0 j
hi₁ : MeasurableSet i
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi : ∃ j, MeasurableSet j ∧ j ⊆ i ∧ ↑0 j < ↑v j
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
tactic: push_neg at hi
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
M : Type u_3
inst✝¹ : TopologicalSpace M
inst✝ : LinearOrderedAddCommMonoid M
v w : VectorMeasure α M
i j : Set α
hi₁ : MeasurableSet i
hi : ∃ j, MeasurableSet j ∧ j ⊆ i ∧ ↑0 j < ↑v j
⊢ ∃ j, MeasurableSet j ∧ j ⊆ i ∧ 0 < ↑v j
state_after: no goals
tactic: exact hi
Theorem: interior_sphere
File: Mathlib/Analysis/NormedSpace/Real.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
x : E
r : ℝ
hr : r ≠ 0
⊢ interior (sphere x r) = ∅
state_after: no goals
tactic: rw [← frontier_closedBall x hr, interior_frontier isClosed_ball]
Theorem: CategoryTheory.WithInitial.mapId_hom_app
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
C : Type u_1
inst✝ : Category.{?u.248293, u_1} C
⊢ ∀ {X Y : WithInitial C} (f : X ⟶ Y),
    (map (𝟭 C)).map f ≫
        ((fun X =>
              match X with
              | of x => Iso.refl ((map (𝟭 C)).obj (of x))
              | star => Iso.refl ((map (𝟭 C)).obj star))
            Y).hom =
      ((fun X =>
              match X with
              | of x => Iso.refl ((map (𝟭 C)).obj (of x))
              | star => Iso.refl ((map (𝟭 C)).obj star))
            X).hom ≫
        (𝟭 (WithInitial C)).map f
state_after: no goals
tactic: aesop_cat
Theorem: distrib_three_right
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Mul R
inst✝¹ : Add R
inst✝ : RightDistribClass R
a b c d : R
⊢ (a + b + c) * d = a * d + b * d + c * d
state_after: no goals
tactic: simp [right_distrib]
Theorem: BoxIntegral.Prepartition.isPartition_splitCenter
File: Mathlib/Analysis/BoxIntegral/Partition/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J I : Box ι
x : ι → ℝ
hx : x ∈ I
⊢ ∃ J ∈ splitCenter I, x ∈ J
state_after: no goals
tactic: simp [hx]