ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Complex.volume_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/VolumeOfBalls.lean

Proof steps:
state_before: a : ℂ
r : ℝ
⊢ volume (Metric.ball a r) = ENNReal.ofReal r ^ 2 * ↑NNReal.pi
state_after: no goals
tactic: rw [InnerProductSpace.volume_ball a r, finrank_real_complex, Nat.cast_ofNat, div_self two_ne_zero,
    one_add_one_eq_two, Real.Gamma_two, div_one, Real.sq_sqrt (by positivity),
    ← NNReal.coe_real_pi, ofReal_coe_nnreal]
Theorem: Finset.fold_map
File: Mathlib/Data/Finset/Fold.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s✝ : Finset α
a : α
g : γ ↪ α
s : Finset γ
⊢ fold op b f (map g s) = fold op b (f ∘ ⇑g) s
state_after: no goals
tactic: simp only [fold, map, Multiset.map_map]
Theorem: trop_iInf
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : ConditionallyCompleteLinearOrder R
inst✝ : Fintype S
f : S → WithTop R
⊢ trop (⨅ i, f i) = ∑ i : S, trop (f i)
state_after: no goals
tactic: rw [iInf, ← Set.image_univ, ← coe_univ, trop_sInf_image]
Theorem: Locale.openOfElementHom_toFun
File: Mathlib/Topology/Order/Category/FrameAdjunction.lean

Proof steps:
state_before: L : Type u_1
inst✝ : CompleteLattice L
a b : L
⊢ (fun u => {x | x u}) (a ⊓ b) = (fun u => {x | x u}) a ⊓ (fun u => {x | x u}) b
state_after: no goals
tactic: simp [Set.setOf_and]
state_before: L : Type u_1
inst✝ : CompleteLattice L
⊢ { toFun := fun u => {x | x u}, map_inf' := ⋯ }.toFun ⊤ = ⊤
state_after: no goals
tactic: simp
state_before: L : Type u_1
inst✝ : CompleteLattice L
S : Set L
⊢ { toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun (sSup S) =
    sSup ({ toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun '' S)
state_after: case h
L : Type u_1
inst✝ : CompleteLattice L
S : Set L
x✝ : PT L
⊢ x✝ ∈ { toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun (sSup S) ↔
    x✝ ∈ sSup ({ toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun '' S)
tactic: ext
state_before: case h
L : Type u_1
inst✝ : CompleteLattice L
S : Set L
x✝ : PT L
⊢ x✝ ∈ { toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun (sSup S) ↔
    x✝ ∈ sSup ({ toFun := fun u => {x | x u}, map_inf' := ⋯, map_top' := ⋯ }.toFun '' S)
state_after: no goals
tactic: simp [Prop.exists_iff]
Theorem: NNReal.isConjExponent_iff_eq_conjExponent
File: Mathlib/Data/Real/ConjExponents.lean

Proof steps:
state_before: a b p q : ℝ≥0
h✝ : p.IsConjExponent q
h : 1 < p
⊢ p.IsConjExponent q ↔ q = p / (p - 1)
state_after: no goals
tactic: rw [← isConjExponent_coe, Real.isConjExponent_iff_eq_conjExponent (mod_cast h), ← coe_inj,
    NNReal.coe_div, NNReal.coe_sub h.le, coe_one]
Theorem: List.takeD_left'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD n (l₁ ++ l₂) a = l₁
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD l₁.length (l₁ ++ l₂) a = l₁
tactic: rw [← h]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
a : α
h : l₁.length = n
⊢ takeD l₁.length (l₁ ++ l₂) a = l₁
state_after: no goals
tactic: apply takeD_left
Theorem: CategoryTheory.Functor.map_commSq
File: Mathlib/CategoryTheory/CommSq.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_3, u_1} C
D : Type u_2
inst✝ : Category.{u_4, u_2} D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
s : CommSq f g h i
⊢ F.map f ≫ F.map h = F.map g ≫ F.map i
state_after: no goals
tactic: simpa using congr_arg (fun k : W ⟶ Z => F.map k) s.w
Theorem: Matrix.dotProduct_diagonal'
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
⊢ (v ⬝ᵥ fun j => diagonal w j i) = v i * w i
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → v j * diagonal w j i = 0
⊢ (v ⬝ᵥ fun j => diagonal w j i) = v i * w i
tactic: have : ∀ j ≠ i, v j * diagonal w j i = 0 := fun j hij => by
    simp [diagonal_apply_ne _ hij]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Fintype m
inst✝² : Fintype n
inst✝¹ : DecidableEq m
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
i : m
this : ∀ (j : m), j ≠ i → v j * diagonal w j i = 0
⊢ (v ⬝ᵥ fun j => diagonal w j i) = v i * w i
state_after: no goals
tactic: convert Finset.sum_eq_single i (fun j _ => this j) _ using 1 <;> simp
Theorem: IsAddCyclic.exists_addMonoid_generator
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : Finite α
inst✝ : IsCyclic α
⊢ ∃ x, ∀ (y : α), y ∈ Submonoid.powers x
state_after: α : Type u
a : α
inst✝² : Group α
inst✝¹ : Finite α
inst✝ : IsCyclic α
⊢ ∃ x, ∀ (y : α), y ∈ zpowers x
tactic: simp_rw [mem_powers_iff_mem_zpowers]
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : Finite α
inst✝ : IsCyclic α
⊢ ∃ x, ∀ (y : α), y ∈ zpowers x
state_after: no goals
tactic: exact IsCyclic.exists_generator
Theorem: Num.cast_to_int
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : Num
⊢ ↑↑n = ↑n
state_after: no goals
tactic: rw [← to_nat_to_int, Int.cast_natCast, cast_to_nat]
Theorem: Finset.sum_finset_product
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 β
r : Finset (γ × α)
s : Finset γ
t : γ → Finset α
h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1
f : γ × α → β
⊢ ∏ p ∈ r, f p = ∏ c ∈ s, ∏ a ∈ t c, f (c, a)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
r : Finset (γ × α)
s : Finset γ
t : γ → Finset α
h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1
f : γ × α → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.fst, x.snd)
tactic: refine Eq.trans ?_ (prod_sigma s t fun p => f (p.1, p.2))
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 β
r : Finset (γ × α)
s : Finset γ
t : γ → Finset α
h : ∀ (p : γ × α), p ∈ r ↔ p.1 ∈ s ∧ p.2 ∈ t p.1
f : γ × α → β
⊢ ∏ p ∈ r, f p = ∏ x ∈ s.sigma t, f (x.fst, x.snd)
state_after: no goals
tactic: apply prod_equiv (Equiv.sigmaEquivProd _ _).symm <;> simp [h]
Theorem: Matrix.range_cons_empty
File: Mathlib/Data/Fin/VecNotation.lean

Proof steps:
state_before: α : Type u
m n o : ℕ
m' : Type u_1
n' : Type u_2
o' : Type u_3
x : α
u : Fin 0 → α
⊢ Set.range (vecCons x u) = {x}
state_after: no goals
tactic: rw [range_cons, range_empty, Set.union_empty]
Theorem: CategoryTheory.Sieve.functor_galoisConnection
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S R : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
X : C
⊢ GaloisConnection (functorPushforward F) (functorPullback F)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S✝ R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
X : C
R : Sieve X
S : Sieve (F.obj X)
⊢ functorPushforward F R ≤ S ↔ R ≤ functorPullback F S
tactic: intro R S
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S✝ R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
X : C
R : Sieve X
S : Sieve (F.obj X)
⊢ functorPushforward F R ≤ S ↔ R ≤ functorPullback F S
state_after: case mp
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S✝ R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
X : C
R : Sieve X
S : Sieve (F.obj X)
⊢ functorPushforward F R ≤ S → R ≤ functorPullback F S

case mpr
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
S✝ R✝ : Sieve X✝
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
X : C
R : Sieve X
S : Sieve (F.obj X)
⊢ R ≤ functorPullback F S → functorPushforward F R ≤ S
tactic: constructor
Theorem: Finset.antidiagonal_congr'
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : AddCancelCommMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
⊢ p = q ↔ p.2 = q.2
state_after: A : Type u_1
inst✝¹ : AddCancelCommMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
⊢ p.swap = q.swap ↔ p.2 = q.2
tactic: rw [← Prod.swap_inj]
state_before: A : Type u_1
inst✝¹ : AddCancelCommMonoid A
inst✝ : HasAntidiagonal A
p q : A × A
n : A
hp : p ∈ antidiagonal n
hq : q ∈ antidiagonal n
⊢ p.swap = q.swap ↔ p.2 = q.2
state_after: no goals
tactic: exact antidiagonal_congr (swap_mem_antidiagonal.2 hp) (swap_mem_antidiagonal.2 hq)
Theorem: SimpleGraph.is3Clique_triple_iff
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ G.IsNClique 3 {a, b, c} ↔ G.Adj a b ∧ G.Adj a c ∧ G.Adj b c
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ (((↑{c}).Pairwise G.Adj ∧ ∀ b_1 ∈ ↑{c}, b ≠ b_1 → G.Adj b b_1) ∧ ∀ b_1 ∈ insert b ↑{c}, a ≠ b_1 → G.Adj a b_1) ∧
      {a, b, c}.card = 3 ↔
    G.Adj a b ∧ G.Adj a c ∧ G.Adj b c
tactic: simp only [isNClique_iff, isClique_iff, Set.pairwise_insert_of_symmetric G.symm, coe_insert]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
inst✝ : DecidableEq α
⊢ (((↑{c}).Pairwise G.Adj ∧ ∀ b_1 ∈ ↑{c}, b ≠ b_1 → G.Adj b b_1) ∧ ∀ b_1 ∈ insert b ↑{c}, a ≠ b_1 → G.Adj a b_1) ∧
      {a, b, c}.card = 3 ↔
    G.Adj a b ∧ G.Adj a c ∧ G.Adj b c
state_after: no goals
tactic: by_cases hab : a = b <;> by_cases hbc : b = c <;> by_cases hac : a = c <;> subst_vars <;>
    simp [G.ne_of_adj, and_rotate, *]
Theorem: map_comp_inv
File: Mathlib/Algebra/Group/Hom/Defs.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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
g : ι → G
⊢ ⇑f ∘ g⁻¹ = (⇑f ∘ g)⁻¹
state_after: case h
ι : 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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
g : ι → G
x✝ : ι
⊢ (⇑f ∘ g⁻¹) x✝ = (⇑f ∘ g)⁻¹ x✝
tactic: ext
state_before: case h
ι : 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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : Group G
inst✝¹ : DivisionMonoid H
inst✝ : MonoidHomClass F G H
f : F
g : ι → G
x✝ : ι
⊢ (⇑f ∘ g⁻¹) x✝ = (⇑f ∘ g)⁻¹ x✝
state_after: no goals
tactic: simp
Theorem: Path.Homotopic.prod_projLeft_projRight
File: Mathlib/Topology/Homotopy/Product.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
p : Homotopic.Quotient (a₁, b₁) (a₂, b₂)
⊢ prod (projLeft p) (projRight p) = p
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
a✝ : Path (a₁, b₁) (a₂, b₂)
⊢ prod (projLeft ⟦a✝⟧) (projRight ⟦a✝⟧) = ⟦a✝⟧
tactic: induction p using Quotient.inductionOn
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
a✝ : Path (a₁, b₁) (a₂, b₂)
⊢ prod (projLeft ⟦a✝⟧) (projRight ⟦a✝⟧) = ⟦a✝⟧
state_after: case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
a✝ : Path (a₁, b₁) (a₂, b₂)
⊢ prod ⟦a✝.map ⋯⟧ ⟦a✝.map ⋯⟧ = ⟦a✝⟧
tactic: simp only [projLeft, projRight, ← Path.Homotopic.map_lift, prod_lift]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
a₁ a₂ a₃ : α
b₁ b₂ b₃ : β
p₁ p₁' : Path a₁ a₂
p₂ p₂' : Path b₁ b₂
q₁ : Homotopic.Quotient a₁ a₂
q₂ : Homotopic.Quotient b₁ b₂
r₁ : Homotopic.Quotient a₂ a₃
r₂ : Homotopic.Quotient b₂ b₃
c₁ c₂ : α × β
a✝ : Path (a₁, b₁) (a₂, b₂)
⊢ prod ⟦a✝.map ⋯⟧ ⟦a✝.map ⋯⟧ = ⟦a✝⟧
state_after: no goals
tactic: congr
Theorem: Module.toAddMonoidEnd_apply_apply
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r✝ s : R
x y r : M
⊢ 0 • r = 0
state_after: no goals
tactic: simp
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
r✝ s : R
x✝ y✝ : M
x y : R
r : M
⊢ (x + y) • r = x • r + y • r
state_after: no goals
tactic: simp [add_smul]
Theorem: CategoryTheory.Sieve.functorPullback_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve ((F ⋙ G).obj X)
⊢ functorPullback (F ⋙ G) R = functorPullback F (functorPullback G R)
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve ((F ⋙ G).obj X)
Y✝ : C
f✝ : Y✝ ⟶ X
⊢ (functorPullback (F ⋙ G) R).arrows f✝ ↔ (functorPullback F (functorPullback G R)).arrows f✝
tactic: ext
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category.{v₃, u₃} E
G : D ⥤ E
R : Sieve ((F ⋙ G).obj X)
Y✝ : C
f✝ : Y✝ ⟶ X
⊢ (functorPullback (F ⋙ G) R).arrows f✝ ↔ (functorPullback F (functorPullback G R)).arrows f✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Idempotents.idem_of_id_sub_idem
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ (𝟙 X - p) ≫ (𝟙 X - p) = 𝟙 X - p
state_after: no goals
tactic: simp only [comp_sub, sub_comp, id_comp, comp_id, hp, sub_self, sub_zero]
Theorem: List.rotate_length
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l : List α
⊢ l.rotate l.length = l
state_after: no goals
tactic: rw [rotate_eq_rotate', rotate'_length]
Theorem: Set.preimage_swap_prod
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
⊢ Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s
state_after: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
x : β
y : α
⊢ (x, y) ∈ Prod.swap ⁻¹' s ×ˢ t ↔ (x, y) ∈ t ×ˢ s
tactic: ext ⟨x, y⟩
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s✝ s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
a : α
b : β
s : Set α
t : Set β
x : β
y : α
⊢ (x, y) ∈ Prod.swap ⁻¹' s ×ˢ t ↔ (x, y) ∈ t ×ˢ s
state_after: no goals
tactic: simp [and_comm]
Theorem: concaveOn_of_slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ ConcaveOn 𝕜 s f
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ ConvexOn 𝕜 s (-f)
tactic: rw [← neg_convexOn_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
⊢ ConvexOn 𝕜 s (-f)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) ≤ ((-f) z✝ - (-f) y✝) / (z✝ - y✝)
tactic: refine convexOn_of_slope_mono_adjacent hs fun hx hz hxy hyz => ?_
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ ((-f) y✝ - (-f) x✝) / (y✝ - x✝) ≤ ((-f) z✝ - (-f) y✝) / (z✝ - y✝)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) ≤ -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))
tactic: rw [← neg_le_neg_iff]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ -(((-f) z✝ - (-f) y✝) / (z✝ - y✝)) ≤ -(((-f) y✝ - (-f) x✝) / (y✝ - x✝))
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) ≤ (f y✝ - f x✝) / (y✝ - x✝)
tactic: simp_rw [← neg_div, neg_sub, Pi.neg_apply, neg_sub_neg]
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hs : Convex 𝕜 s
hf : ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) ≤ (f y - f x) / (y - x)
x✝ y✝ z✝ : 𝕜
hx : x✝ ∈ s
hz : z✝ ∈ s
hxy : x✝ < y✝
hyz : y✝ < z✝
⊢ (f z✝ - f y✝) / (z✝ - y✝) ≤ (f y✝ - f x✝) / (y✝ - x✝)
state_after: no goals
tactic: exact hf hx hz hxy hyz
Theorem: CategoryTheory.Idempotents.functorExtension₁CompWhiskeringLeftToKaroubiIso_hom_app_app_f
File: Mathlib/CategoryTheory/Idempotents/FunctorExtension.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.29860, u_1} C
inst✝¹ : Category.{?u.29864, u_2} D
inst✝ : Category.{?u.29868, u_3} E
F : C ⥤ Karoubi D
X Y : C
f : X ⟶ Y
⊢ ((functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C)).obj F).map f ≫
      ((fun X =>
            { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
              inv_hom_id := ⋯ })
          Y).hom =
    ((fun X =>
            { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
              inv_hom_id := ⋯ })
          X).hom ≫
      ((𝟭 (C ⥤ Karoubi D)).obj F).map f
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.29860, u_1} C
inst✝¹ : Category.{?u.29864, u_2} D
inst✝ : Category.{?u.29868, u_3} E
⊢ ∀ {X Y : C ⥤ Karoubi D} (f : X ⟶ Y),
    (functorExtension₁ C D ⋙ (whiskeringLeft C (Karoubi C) (Karoubi D)).obj (toKaroubi C)).map f ≫
        ((fun F =>
              NatIso.ofComponents
                (fun X =>
                  { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
                    inv_hom_id := ⋯ })
                ⋯)
            Y).hom =
      ((fun F =>
              NatIso.ofComponents
                (fun X =>
                  { hom := { f := (F.obj X).p, comm := ⋯ }, inv := { f := (F.obj X).p, comm := ⋯ }, hom_inv_id := ⋯,
                    inv_hom_id := ⋯ })
                ⋯)
            X).hom ≫
        (𝟭 (C ⥤ Karoubi D)).map f
state_after: no goals
tactic: aesop_cat
Theorem: DirectSum.coeAlgHom_of
File: Mathlib/Algebra/DirectSum/Internal.lean

Proof steps:
state_before: ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : ↥(A i)
⊢ ((fun i => (A i).subtype) 0).toAddMonoidHom GradedMonoid.GOne.one = 1
state_after: no goals
tactic: rfl
state_before: ι : Type u_1
σ : Type u_2
S : Type u_3
R : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddMonoid ι
inst✝³ : CommSemiring S
inst✝² : Semiring R
inst✝¹ : Algebra S R
A : ι → Submodule S R
inst✝ : SetLike.GradedMonoid A
i : ι
x : ↥(A i)
i✝ j✝ : ι
x✝¹ : (fun i => ↥(A i)) i✝
x✝ : (fun i => ↥(A i)) j✝
⊢ ((fun i => (A i).subtype) (i✝ + j✝)).toAddMonoidHom (GradedMonoid.GMul.mul x✝¹ x✝) =
    ((fun i => (A i).subtype) i✝).toAddMonoidHom x✝¹ * ((fun i => (A i).subtype) j✝).toAddMonoidHom x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.instCategoryCosimplicialObject_id_app
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.127550, max u v} (CosimplicialObject C)
state_after: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.127550, max u v} (SimplexCategory ⥤ C)
tactic: dsimp only [CosimplicialObject]
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.127550, max u v} (SimplexCategory ⥤ C)
state_after: no goals
tactic: infer_instance
Theorem: dist_partial_sum
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : SeminormedAddCommGroup α
r C : ℝ
f u : ℕ → α
n : ℕ
⊢ dist (∑ k ∈ Finset.range (n + 1), u k) (∑ k ∈ Finset.range n, u k) = ‖u n‖
state_after: no goals
tactic: simp [dist_eq_norm, sum_range_succ]
Theorem: not_subsingleton_iff_nontrivial
File: Mathlib/Logic/Nontrivial/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
⊢ ¬Subsingleton α ↔ Nontrivial α
state_after: no goals
tactic: rw [← not_nontrivial_iff_subsingleton, Classical.not_not]