ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ENNReal.essSup_indicator_eq_essSup_restrict
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f✝ : α → ℝ≥0∞
s : Set α
f : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup (s.indicator f) μ = essSup f (μ.restrict s)
state_after: no goals
tactic: classical
  simp only [← piecewise_eq_indicator, essSup_piecewise hs, max_eq_left_iff]
  exact limsup_const_bot.trans_le (zero_le _)
Theorem: MeasurableSet.union
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
⊢ MeasurableSet (s₁ ∪ s₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
⊢ MeasurableSet (⋃ b, bif b then s₁ else s₂)
tactic: rw [union_eq_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
m : MeasurableSpace α
s₁ s₂ : Set α
h₁ : MeasurableSet s₁
h₂ : MeasurableSet s₂
⊢ MeasurableSet (⋃ b, bif b then s₁ else s₂)
state_after: no goals
tactic: exact .iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)
Theorem: Polynomial.coeff_reflect
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N : ℕ
f : R[X]
i : ℕ
⊢ (reflect N f).coeff i = f.coeff ((revAt N) i)
state_after: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ (reflect N { toFinsupp := f }).coeff i = { toFinsupp := f }.coeff ((revAt N) i)
tactic: rcases f with ⟨f⟩
state_before: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ (reflect N { toFinsupp := f }).coeff i = { toFinsupp := f }.coeff ((revAt N) i)
state_after: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ (embDomain (revAt N) f) i = f ((revAt N) i)
tactic: simp only [reflect, coeff]
state_before: case ofFinsupp
R : Type u_1
inst✝ : Semiring R
f✝ : R[X]
N i : ℕ
f : AddMonoidAlgebra R ℕ
⊢ (embDomain (revAt N) f) i = f ((revAt N) i)
state_after: no goals
tactic: calc
    Finsupp.embDomain (revAt N) f i = Finsupp.embDomain (revAt N) f (revAt N (revAt N i)) := by
      rw [revAt_invol]
    _ = f (revAt N i) := Finsupp.embDomain_apply _ _ _
Theorem: HahnSeries.orderTop_smul_not_lt
File: Mathlib/RingTheory/HahnSeries/Addition.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
V : Type u_3
inst✝¹ : Zero V
inst✝ : SMulZeroClass R V
r : R
x : HahnSeries Γ V
⊢ ¬(r • x).orderTop < x.orderTop
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
V : Type u_3
inst✝¹ : Zero V
inst✝ : SMulZeroClass R V
r : R
x : HahnSeries Γ V
hrx : r • x = 0
⊢ ¬(r • x).orderTop < x.orderTop

case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
V : Type u_3
inst✝¹ : Zero V
inst✝ : SMulZeroClass R V
r : R
x : HahnSeries Γ V
hrx : ¬r • x = 0
⊢ ¬(r • x).orderTop < x.orderTop
tactic: by_cases hrx : r • x = 0
Theorem: Sum.LiftRel.isRight_right
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
y : γ ⊕ δ
a : α
b : β
c : γ
d : δ
h : LiftRel r s (inr b) y
⊢ y.isRight = true
state_after: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d d✝ : δ
a✝ : s b d✝
⊢ (inr d✝).isRight = true
tactic: cases h
state_before: case inr
α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
r : α → γ → Prop
s : β → δ → Prop
x : α ⊕ β
a : α
b : β
c : γ
d d✝ : δ
a✝ : s b d✝
⊢ (inr d✝).isRight = true
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.pullback_inv_snd_fst_of_left_isIso
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : IsIso f
⊢ inv (pullback.snd f g) ≫ pullback.fst f g = g ≫ inv f
state_after: no goals
tactic: rw [IsIso.inv_comp_eq, ← pullback.condition_assoc, IsIso.hom_inv_id, Category.comp_id]
Theorem: List.nextOr_eq_nextOr_of_mem_of_ne
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
xs : List α
x d d' : α
x_mem : x ∈ xs
x_ne : x ≠ xs.getLast ⋯
⊢ xs.nextOr x d = xs.nextOr x d'
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
x d d' : α
x_mem : x ∈ []
x_ne : x ≠ [].getLast ⋯
⊢ [].nextOr x d = [].nextOr x d'

case cons
α : Type u_1
inst✝ : DecidableEq α
x d d' y : α
ys : List α
IH : ∀ (x_mem : x ∈ ys), x ≠ ys.getLast ⋯ → ys.nextOr x d = ys.nextOr x d'
x_mem : x ∈ y :: ys
x_ne : x ≠ (y :: ys).getLast ⋯
⊢ (y :: ys).nextOr x d = (y :: ys).nextOr x d'
tactic: induction' xs with y ys IH
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x d d' y : α
ys : List α
IH : ∀ (x_mem : x ∈ ys), x ≠ ys.getLast ⋯ → ys.nextOr x d = ys.nextOr x d'
x_mem : x ∈ y :: ys
x_ne : x ≠ (y :: ys).getLast ⋯
⊢ (y :: ys).nextOr x d = (y :: ys).nextOr x d'
state_after: case cons.nil
α : Type u_1
inst✝ : DecidableEq α
x d d' y : α
IH : ∀ (x_mem : x ∈ []), x ≠ [].getLast ⋯ → [].nextOr x d = [].nextOr x d'
x_mem : x ∈ [y]
x_ne : x ≠ [y].getLast ⋯
⊢ [y].nextOr x d = [y].nextOr x d'

case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x d d' y z : α
zs : List α
IH : ∀ (x_mem : x ∈ z :: zs), x ≠ (z :: zs).getLast ⋯ → (z :: zs).nextOr x d = (z :: zs).nextOr x d'
x_mem : x ∈ y :: z :: zs
x_ne : x ≠ (y :: z :: zs).getLast ⋯
⊢ (y :: z :: zs).nextOr x d = (y :: z :: zs).nextOr x d'
tactic: cases' ys with z zs
state_before: case cons.cons
α : Type u_1
inst✝ : DecidableEq α
x d d' y z : α
zs : List α
IH : ∀ (x_mem : x ∈ z :: zs), x ≠ (z :: zs).getLast ⋯ → (z :: zs).nextOr x d = (z :: zs).nextOr x d'
x_mem : x ∈ y :: z :: zs
x_ne : x ≠ (y :: z :: zs).getLast ⋯
⊢ (y :: z :: zs).nextOr x d = (y :: z :: zs).nextOr x d'
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
x d d' y z : α
zs : List α
IH : ∀ (x_mem : x ∈ z :: zs), x ≠ (z :: zs).getLast ⋯ → (z :: zs).nextOr x d = (z :: zs).nextOr x d'
x_mem : x ∈ y :: z :: zs
x_ne : x ≠ (y :: z :: zs).getLast ⋯
h : x = y
⊢ (y :: z :: zs).nextOr x d = (y :: z :: zs).nextOr x d'

case neg
α : Type u_1
inst✝ : DecidableEq α
x d d' y z : α
zs : List α
IH : ∀ (x_mem : x ∈ z :: zs), x ≠ (z :: zs).getLast ⋯ → (z :: zs).nextOr x d = (z :: zs).nextOr x d'
x_mem : x ∈ y :: z :: zs
x_ne : x ≠ (y :: z :: zs).getLast ⋯
h : ¬x = y
⊢ (y :: z :: zs).nextOr x d = (y :: z :: zs).nextOr x d'
tactic: by_cases h : x = y
Theorem: lt_iff_lt_of_cmp_eq_cmp
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
inst✝¹ : LinearOrder α
x y : α
β : Type u_3
inst✝ : LinearOrder β
x' y' : β
h : cmp x y = cmp x' y'
⊢ x < y ↔ x' < y'
state_after: no goals
tactic: rw [← cmp_eq_lt_iff, ← cmp_eq_lt_iff, h]
Theorem: Complex.isCauSeq_conj
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' ((fun n => (starRingEnd ℂ) (↑f n)) j - (fun n => (starRingEnd ℂ) (↑f n)) i) < ε
state_after: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' (↑f j - ↑f i) < ε
tactic: rw [← RingHom.map_sub, abs_conj]
state_before: f : CauSeq ℂ ⇑abs'
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ j ≥ i, abs' (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ abs' (↑f j - ↑f i) < ε
state_after: no goals
tactic: exact hi j hj
Theorem: Int.fract_neg
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ fract (-x) = 1 - fract x
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 0 ≤ 1 - fract x ∧ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z
tactic: rw [fract_eq_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 0 ≤ 1 - fract x ∧ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z
state_after: case left
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 0 ≤ 1 - fract x

case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z
tactic: constructor
state_before: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ 1 - fract x < 1 ∧ ∃ z, -x - (1 - fract x) = ↑z
state_after: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x - (1 - fract x) = ↑(-⌊x⌋ - 1)
tactic: refine ⟨sub_lt_self _ (lt_of_le_of_ne' (fract_nonneg x) hx), -⌊x⌋ - 1, ?_⟩
state_before: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x - (1 - fract x) = ↑(-⌊x⌋ - 1)
state_after: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x + fract x = -↑⌊x⌋
tactic: simp only [sub_sub_eq_add_sub, cast_sub, cast_neg, cast_one, sub_left_inj]
state_before: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -x + fract x = -↑⌊x⌋
state_after: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -(↑⌊x⌋ + fract x) + fract x = -↑⌊x⌋
tactic: conv in -x => rw [← floor_add_fract x]
state_before: case right
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a x : α
hx : fract x ≠ 0
⊢ -(↑⌊x⌋ + fract x) + fract x = -↑⌊x⌋
state_after: no goals
tactic: simp [-floor_add_fract]
Theorem: WeierstrassCurve.ofJ_c₄
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ (ofJ j).c₄ = j * (j - 1728) ^ 3
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ ((j - 1728) ^ 2 + 4 * 0) ^ 2 - 24 * (2 * (-36 * (j - 1728) ^ 3) + (j - 1728) * 0) = j * (j - 1728) ^ 3
tactic: simp only [ofJ, c₄, b₂, b₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
j : R
⊢ ((j - 1728) ^ 2 + 4 * 0) ^ 2 - 24 * (2 * (-36 * (j - 1728) ^ 3) + (j - 1728) * 0) = j * (j - 1728) ^ 3
state_after: no goals
tactic: ring1
Theorem: openSegment_eq_image₂
File: Mathlib/Analysis/Convex/Segment.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMul 𝕜 E
s : Set E
x✝ y✝ x y : E
⊢ openSegment 𝕜 x y = (fun p => p.1 • x + p.2 • y) '' {p | 0 < p.1 ∧ 0 < p.2 ∧ p.1 + p.2 = 1}
state_after: no goals
tactic: simp only [openSegment, image, Prod.exists, mem_setOf_eq, exists_prop, and_assoc]
Theorem: Comon_.Mon_OpOpToComon__obj
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit).op =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit.op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).counit).op =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).counit.op
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul =
    ((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul).op =
    (((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)).op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M : Comon_ C
X✝ Y✝ : (Mon_ Cᵒᵖ)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (f.unop.hom.unop ≫ ((fun A => Mon_OpOpToComon_obj' C (unop A)) Y✝).comul).op =
    (((fun A => Mon_OpOpToComon_obj' C (unop A)) X✝).comul ≫ (f.unop.hom.unop ⊗ f.unop.hom.unop)).op
state_after: no goals
tactic: simp [op_tensorHom]
Theorem: IsWellOrderLimitElement.bot_lt
File: Mathlib/Order/IsWellOrderLimitElement.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
⊢ ⊥ < a
state_after: case inl
α : Type u_1
inst✝¹ : LinearOrder α
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ = a
⊢ ⊥ < a

case inr
α : Type u_1
inst✝¹ : LinearOrder α
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
h : ⊥ < a
⊢ ⊥ < a
tactic: obtain h|h := eq_or_lt_of_le (@bot_le _ _ _ a)
Theorem: le_dimH_of_hausdorffMeasure_eq_top
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ dimH s
state_after: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d
tactic: rw [dimH_def]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝³ : EMetricSpace X
inst✝² : EMetricSpace Y
inst✝¹ : MeasurableSpace X
inst✝ : BorelSpace X
s : Set X
d : ℝ≥0
h : μH[↑d] s = ⊤
⊢ ↑d ≤ ⨆ d, ⨆ (_ : μH[↑d] s = ⊤), ↑d
state_after: no goals
tactic: exact le_iSup₂ (α := ℝ≥0∞) d h
Theorem: CategoryTheory.Limits.Cocone.toOver_ι_app
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j : J
⊢ c.ι.app j ≫ (((const J).obj (Over.mk (𝟙 c.pt))).obj j).hom =
    ((c.toCostructuredArrow ⋙ CostructuredArrow.toOver F c.pt).obj j).hom
state_after: no goals
tactic: simp
Theorem: PrimeMultiset.prod_dvd_iff'
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: u : PrimeMultiset
n : ℕ+
⊢ u.prod ∣ n ↔ u ≤ n.factorMultiset
state_after: u : PrimeMultiset
n : ℕ+
h : u.prod ∣ n.factorMultiset.prod ↔ u ≤ n.factorMultiset := prod_dvd_iff
⊢ u.prod ∣ n ↔ u ≤ n.factorMultiset
tactic: let h := @prod_dvd_iff u n.factorMultiset
state_before: u : PrimeMultiset
n : ℕ+
h : u.prod ∣ n.factorMultiset.prod ↔ u ≤ n.factorMultiset := prod_dvd_iff
⊢ u.prod ∣ n ↔ u ≤ n.factorMultiset
state_after: u : PrimeMultiset
n : ℕ+
h : u.prod ∣ n ↔ u ≤ n.factorMultiset
⊢ u.prod ∣ n ↔ u ≤ n.factorMultiset
tactic: rw [n.prod_factorMultiset] at h
state_before: u : PrimeMultiset
n : ℕ+
h : u.prod ∣ n ↔ u ≤ n.factorMultiset
⊢ u.prod ∣ n ↔ u ≤ n.factorMultiset
state_after: no goals
tactic: exact h
Theorem: Stream'.WSeq.map_ret
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
a : α
⊢ map f (ret a) = ret (f a)
state_after: no goals
tactic: simp [ret]
Theorem: Set.list_sum_mem_list_sum
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f : ι → Set α
g : ι → α
hg : ∀ i ∈ t, g i ∈ f i
⊢ (List.map g t).prod ∈ (List.map f t).prod
state_after: case nil
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
hg : ∀ i ∈ [], g i ∈ f i
⊢ (List.map g []).prod ∈ (List.map f []).prod

case cons
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
h : ι
tl : List ι
ih : (∀ i ∈ tl, g i ∈ f i) → (List.map g tl).prod ∈ (List.map f tl).prod
hg : ∀ i ∈ h :: tl, g i ∈ f i
⊢ (List.map g (h :: tl)).prod ∈ (List.map f (h :: tl)).prod
tactic: induction' t with h tl ih
Theorem: List.mem_of_formPerm_apply_mem
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : l.formPerm x ∈ l
⊢ x ∈ l
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : x ∉ l
⊢ l.formPerm x ∉ l
tactic: contrapose h
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x : α
h : x ∉ l
⊢ l.formPerm x ∉ l
state_after: no goals
tactic: rwa [formPerm_apply_of_not_mem h]
Theorem: div_one
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivInvOneMonoid G
a : G
⊢ a / 1 = a
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: CategoryTheory.PreGaloisCategory.evaluationEquivOfIsGalois_symm_fiber
File: Mathlib/CategoryTheory/Galois/GaloisObjects.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsGalois A
a b : ↑(F.obj A)
⊢ F.map ((evaluationEquivOfIsGalois F A a).symm b).hom a = b
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsGalois A
a b : ↑(F.obj A)
⊢ (evaluationEquivOfIsGalois F A a) ((evaluationEquivOfIsGalois F A a).symm b) = b
tactic: change (evaluationEquivOfIsGalois F A a) _ = _
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : GaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsGalois A
a b : ↑(F.obj A)
⊢ (evaluationEquivOfIsGalois F A a) ((evaluationEquivOfIsGalois F A a).symm b) = b
state_after: no goals
tactic: simp
Theorem: IsUpperSet.erase
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : LE α
inst✝ : LE β
s t : Set α
a : α
hs : IsUpperSet s
has : ∀ b ∈ s, b ≤ a → b = a
⊢ ∀ b ∈ s, ∀ c ∈ {a}, b ≤ c → b ∈ {a}
state_after: no goals
tactic: simpa using has
Theorem: MeasureTheory.IntegrableAtFilter.neg
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
f : α → E
hf : IntegrableAtFilter f l μ
⊢ IntegrableAtFilter (-f) l μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
f : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
⊢ IntegrableAtFilter (-f) l μ
tactic: rcases hf with ⟨s, sl, hs⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
f : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
⊢ IntegrableAtFilter (-f) l μ
state_after: no goals
tactic: exact ⟨s, sl, hs.neg⟩
Theorem: CategoryTheory.Limits.limit.pre_eq
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimit F
E : K ⥤ J
inst✝¹ : HasLimit (E ⋙ F)
L : Type u₃
inst✝ : Category.{v₃, u₃} L
D : L ⥤ K
s : LimitCone (E ⋙ F)
t : LimitCone F
⊢ pre F E = (isoLimitCone t).hom ≫ s.isLimit.lift (Cone.whisker E t.cone) ≫ (isoLimitCone s).inv
state_after: no goals
tactic: aesop_cat
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.ofIsColimitCokernelCofork_i
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.20185, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ 𝟙 S.X₂ ≫ S.g = 0
state_after: no goals
tactic: rw [id_comp, hg]
Theorem: uniformity_prod_eq_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
⊢ 𝓤 (α × β) = map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 β)
state_after: no goals
tactic: rw [map_swap4_eq_comap, uniformity_prod_eq_comap_prod]
Theorem: List.periodic_prod
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
l : List (α → β)
hl : ∀ f ∈ l, Periodic f c
⊢ Periodic l.prod c
state_after: case nil
α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
hl : ∀ f ∈ [], Periodic f c
⊢ Periodic [].prod c

case cons
α : Type u_1
β : Type u_2
γ : Type u_3
f g✝ : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Monoid β
g : α → β
l : List (α → β)
ih : (∀ f ∈ l, Periodic f c) → Periodic l.prod c
hl : ∀ f ∈ g :: l, Periodic f c
⊢ Periodic (g :: l).prod c
tactic: induction' l with g l ih hl
Theorem: eq_mul_of_inv_mul_eq
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : b⁻¹ * a = c
⊢ a = b * c
state_after: no goals
tactic: simp [h.symm, mul_inv_cancel_left]
Theorem: CategoryTheory.Limits.limit.map_post
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasLimitsOfShape J D
H : C ⥤ D
⊢ H.map (limMap α) ≫ post G H = post F H ≫ limMap (whiskerRight α H)
state_after: case w
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasLimitsOfShape J D
H : C ⥤ D
j✝ : J
⊢ (H.map (limMap α) ≫ post G H) ≫ π (G ⋙ H) j✝ = (post F H ≫ limMap (whiskerRight α H)) ≫ π (G ⋙ H) j✝
tactic: ext
state_before: case w
J : Type u₁
inst✝⁵ : Category.{v₁, u₁} J
K : Type u₂
inst✝⁴ : Category.{v₂, u₂} K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ C
inst✝² : HasLimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasLimitsOfShape J D
H : C ⥤ D
j✝ : J
⊢ (H.map (limMap α) ≫ post G H) ≫ π (G ⋙ H) j✝ = (post F H ≫ limMap (whiskerRight α H)) ≫ π (G ⋙ H) j✝
state_after: no goals
tactic: simp only [whiskerRight_app, limMap_π, assoc, limit.post_π_assoc, limit.post_π, ← H.map_comp]