ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: UniformConvexOn.add
File: Mathlib/Analysis/Convex/Strong.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConvexOn s φ f
hg : UniformConvexOn s ψ g
⊢ UniformConvexOn s (φ + ψ) (f + g)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConvexOn s φ f
hg : UniformConvexOn s ψ g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ (f + g) (a • x + b • y) ≤ a • (f + g) x + b • (f + g) y - a * b * (φ + ψ) ‖x - y‖
tactic: refine ⟨hf.1, fun x hx y hy a b ha hb hab ↦ ?_⟩
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a✝ b✝ m : ℝ
x✝ y✝ : E
f g : E → ℝ
hf : UniformConvexOn s φ f
hg : UniformConvexOn s ψ g
x : E
hx : x ∈ s
y : E
hy : y ∈ s
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ (f + g) (a • x + b • y) ≤ a • (f + g) x + b • (f + g) y - a * b * (φ + ψ) ‖x - y‖
state_after: no goals
tactic: simpa [mul_add, add_add_add_comm, sub_add_sub_comm]
    using add_le_add (hf.2 hx hy ha hb hab) (hg.2 hx hy ha hb hab)
Theorem: Polynomial.pow_sub_dvd_iterate_derivative_of_pow_dvd
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
p q : R[X]
n m : ℕ
dvd : q ^ n ∣ p
⊢ q ^ (n - m) ∣ (⇑derivative)^[m] p
state_after: no goals
tactic: induction m generalizing p with
  | zero => simpa
  | succ m ih =>
    rw [Nat.sub_succ, Function.iterate_succ']
    exact pow_sub_one_dvd_derivative_of_pow_dvd (ih dvd)
Theorem: Matrix.zpow_add_of_nonneg
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
m n : ℤ
hm : 0 ≤ m
hn : 0 ≤ n
⊢ A ^ (m + n) = A ^ m * A ^ n
state_after: case intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : 0 ≤ n
k : ℕ
hm : 0 ≤ ↑k
⊢ A ^ (↑k + n) = A ^ ↑k * A ^ n
tactic: obtain ⟨k, rfl⟩ := eq_ofNat_of_zero_le hm
state_before: case intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℤ
hn : 0 ≤ n
k : ℕ
hm : 0 ≤ ↑k
⊢ A ^ (↑k + n) = A ^ ↑k * A ^ n
state_after: case intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
k : ℕ
hm : 0 ≤ ↑k
l : ℕ
hn : 0 ≤ ↑l
⊢ A ^ (↑k + ↑l) = A ^ ↑k * A ^ ↑l
tactic: obtain ⟨l, rfl⟩ := eq_ofNat_of_zero_le hn
state_before: case intro.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
k : ℕ
hm : 0 ≤ ↑k
l : ℕ
hn : 0 ≤ ↑l
⊢ A ^ (↑k + ↑l) = A ^ ↑k * A ^ ↑l
state_after: no goals
tactic: rw [← Int.ofNat_add, zpow_natCast, zpow_natCast, zpow_natCast, pow_add]
Theorem: CategoryTheory.ShortComplex.SnakeInput.naturality_φ₁
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S S₁ S₂ S₃ : SnakeInput C
f : S₁ ⟶ S₂
⊢ S₁.φ₁ ≫ f.f₂.τ₁ = functorP.map f ≫ S₂.φ₁
state_after: no goals
tactic: simp only [← cancel_mono S₂.L₂.f, assoc, φ₁_L₂_f, ← naturality_φ₂, f.f₂.comm₁₂, φ₁_L₂_f_assoc]
Theorem: Basis.forall_coord_eq_zero_iff
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x✝ x : M
⊢ (∀ (i : ι), (b.coord i) x = 0) ↔ b.repr x = 0
state_after: no goals
tactic: simp only [b.coord_apply, DFunLike.ext_iff, Finsupp.zero_apply]
Theorem: TypeVec.prod_fst_mk
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α β : TypeVec.{u_1} n
i : Fin2 n
a : α i
b : β i
⊢ prod.fst i (prod.mk i a b) = a
state_after: case fz
n n✝ : ℕ
α β : TypeVec.{u_1} (n✝ + 1)
a : α Fin2.fz
b : β Fin2.fz
⊢ prod.fst Fin2.fz (prod.mk Fin2.fz a b) = a

case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.fst a✝.fs (prod.mk a✝.fs a b) = a
tactic: induction' i with _ _ _ i_ih
state_before: case fs
n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α β : TypeVec.{u_1} n✝} (a : α a✝) (b : β a✝), prod.fst a✝ (prod.mk a✝ a b) = a
α β : TypeVec.{u_1} (n✝ + 1)
a : α a✝.fs
b : β a✝.fs
⊢ prod.fst a✝.fs (prod.mk a✝.fs a b) = a
state_after: no goals
tactic: apply i_ih
Theorem: Polynomial.le_natTrailingDegree
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hn : ∀ m < n, p.coeff m = 0
⊢ n ≤ p.natTrailingDegree
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hn : ∀ m < n, p.coeff m = 0
⊢ n ≤ p.support.min' ⋯
tactic: rw [natTrailingDegree_eq_support_min' hp]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hn : ∀ m < n, p.coeff m = 0
⊢ n ≤ p.support.min' ⋯
state_after: no goals
tactic: exact Finset.le_min' _ _ _ fun m hm => not_lt.1 fun hmn => mem_support_iff.1 hm <| hn _ hmn
Theorem: SimpleGraph.le_minDegree_of_forall_le_degree
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ G.degree v
⊢ k ≤ G.minDegree
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ G.degree v
v : V
hv : G.minDegree = G.degree v
⊢ k ≤ G.minDegree
tactic: rcases G.exists_minimal_degree_vertex with ⟨v, hv⟩
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ G.degree v
v : V
hv : G.minDegree = G.degree v
⊢ k ≤ G.minDegree
state_after: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ G.degree v
v : V
hv : G.minDegree = G.degree v
⊢ k ≤ G.degree v
tactic: rw [hv]
state_before: case intro
V : Type u_1
G : SimpleGraph V
e : Sym2 V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : Nonempty V
k : ℕ
h : ∀ (v : V), k ≤ G.degree v
v : V
hv : G.minDegree = G.degree v
⊢ k ≤ G.degree v
state_after: no goals
tactic: apply h
Theorem: Matroid.closure_biUnion_closure_eq_closure_sUnion
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X Y : Set α
e : α
M : Matroid α
Xs : Set (Set α)
⊢ M.closure (⋃ X ∈ Xs, M.closure X) = M.closure (⋃₀ Xs)
state_after: no goals
tactic: rw [sUnion_eq_iUnion, biUnion_eq_iUnion, closure_iUnion_closure_eq_closure_iUnion]
Theorem: Fintype.finsetEquivSet_symm_apply
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s : Set α
inst✝ : Fintype ↑s
⊢ finsetEquivSet.symm s = s.toFinset
state_after: no goals
tactic: simp [finsetEquivSet]
Theorem: Filter.tendsto_atTop_finset_of_monotone
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
⊢ Tendsto f atTop atTop
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
⊢ ∀ (i : α), ∀ᶠ (a : β) in atTop, f a ∈ Ici {i}
tactic: simp only [atTop_finset_eq_iInf, tendsto_iInf, tendsto_principal]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
⊢ ∀ (i : α), ∀ᶠ (a : β) in atTop, f a ∈ Ici {i}
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}
tactic: intro a
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
b : β
hb : a ∈ f b
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}
tactic: rcases h' a with ⟨b, hb⟩
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
b : β
hb : a ∈ f b
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}
state_after: no goals
tactic: exact (eventually_ge_atTop b).mono fun b' hb' => (Finset.singleton_subset_iff.2 hb).trans (h hb')
Theorem: isEmpty_plift
File: Mathlib/Logic/IsEmpty.lean

Proof steps:
state_before: α✝ : Sort u_1
β : Sort u_2
γ : Sort u_3
α : Sort u_4
⊢ IsEmpty (PLift α) ↔ IsEmpty α
state_after: no goals
tactic: simp only [← not_nonempty_iff, nonempty_plift]
Theorem: Order.isIdeal_sUnion_of_directedOn
File: Mathlib/Order/Ideal.lean

Proof steps:
state_before: P : Type u_1
inst✝ : Preorder P
C : Set (Set P)
hidl : ∀ I ∈ C, IsIdeal I
hD : DirectedOn (fun x x_1 => x ⊆ x_1) C
hNe : C.Nonempty
⊢ IsIdeal (⋃₀ C)
state_after: P : Type u_1
inst✝ : Preorder P
C : Set (Set P)
hidl : ∀ I ∈ C, IsIdeal I
hD : DirectedOn (fun x x_1 => x ⊆ x_1) C
hNe : C.Nonempty
⊢ ∃ s ∈ C, s.Nonempty
tactic: refine ⟨isLowerSet_sUnion (fun I hI ↦ (hidl I hI).1), Set.nonempty_sUnion.2 ?_,
    directedOn_sUnion hD (fun J hJ => (hidl J hJ).3)⟩
state_before: P : Type u_1
inst✝ : Preorder P
C : Set (Set P)
hidl : ∀ I ∈ C, IsIdeal I
hD : DirectedOn (fun x x_1 => x ⊆ x_1) C
hNe : C.Nonempty
⊢ ∃ s ∈ C, s.Nonempty
state_after: P : Type u_1
inst✝ : Preorder P
C : Set (Set P)
hidl : ∀ I ∈ C, IsIdeal I
hD : DirectedOn (fun x x_1 => x ⊆ x_1) C
hNe : C.Nonempty
I : Set P
hI : I ∈ C
⊢ ∃ s ∈ C, s.Nonempty
tactic: let ⟨I, hI⟩ := hNe
state_before: P : Type u_1
inst✝ : Preorder P
C : Set (Set P)
hidl : ∀ I ∈ C, IsIdeal I
hD : DirectedOn (fun x x_1 => x ⊆ x_1) C
hNe : C.Nonempty
I : Set P
hI : I ∈ C
⊢ ∃ s ∈ C, s.Nonempty
state_after: no goals
tactic: exact ⟨I, ⟨hI, (hidl I hI).2⟩⟩
Theorem: Cardinal.sup_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
ι : Type (max u_2 u_3)
f : ι → Ordinal.{max u_2 u_3}
c : Cardinal.{max u_2 u_3}
hc : c.IsRegular
hι : #ι < c
⊢ #ι < c.ord.cof
state_after: no goals
tactic: rwa [hc.cof_eq]
Theorem: MeasureTheory.Measure.exists_isOpen_measure_lt_top
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
μ✝ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : IsLocallyFiniteMeasure μ
x : α
⊢ ∃ s, x ∈ s ∧ IsOpen s ∧ μ s < ⊤
state_after: no goals
tactic: simpa only [and_assoc] using (μ.finiteAt_nhds x).exists_mem_basis (nhds_basis_opens x)
Theorem: Condensed.epi_iff_locallySurjective_on_compHaus
File: Mathlib/Condensed/Epi.lean

Proof steps:
state_before: A : Type u'
inst✝⁸ : Category.{v', u'} A
inst✝⁷ : ConcreteCategory A
inst✝⁶ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝⁵ : (coherentTopology CompHaus).WEqualsLocallyBijective A
inst✝⁴ : HasSheafify (coherentTopology CompHaus) A
inst✝³ : (coherentTopology CompHaus).HasSheafCompose (CategoryTheory.forget A)
inst✝² : Balanced (Sheaf (coherentTopology CompHaus) A)
inst✝¹ : PreservesFiniteProducts (CategoryTheory.forget A)
inst✝ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A
X Y : Condensed A
f : X ⟶ Y
⊢ Epi f ↔
    ∀ (S : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (op S))),
      ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, (f.val.app (op S')) x = (Y.val.map (op φ)) y
state_after: A : Type u'
inst✝⁸ : Category.{v', u'} A
inst✝⁷ : ConcreteCategory A
inst✝⁶ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝⁵ : (coherentTopology CompHaus).WEqualsLocallyBijective A
inst✝⁴ : HasSheafify (coherentTopology CompHaus) A
inst✝³ : (coherentTopology CompHaus).HasSheafCompose (CategoryTheory.forget A)
inst✝² : Balanced (Sheaf (coherentTopology CompHaus) A)
inst✝¹ : PreservesFiniteProducts (CategoryTheory.forget A)
inst✝ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A
X Y : Condensed A
f : X ⟶ Y
⊢ (∀ (X_1 : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (op X_1))),
      ∃ X' φ, ∃ (_ : EffectiveEpi φ), ∃ x, (f.val.app (op X')) x = (Y.val.map (op φ)) y) ↔
    ∀ (S : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (op S))),
      ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, (f.val.app (op S')) x = (Y.val.map (op φ)) y
tactic: rw [← isLocallySurjective_iff_epi', coherentTopology.isLocallySurjective_iff,
    regularTopology.isLocallySurjective_iff]
state_before: A : Type u'
inst✝⁸ : Category.{v', u'} A
inst✝⁷ : ConcreteCategory A
inst✝⁶ : HasFunctorialSurjectiveInjectiveFactorization A
inst✝⁵ : (coherentTopology CompHaus).WEqualsLocallyBijective A
inst✝⁴ : HasSheafify (coherentTopology CompHaus) A
inst✝³ : (coherentTopology CompHaus).HasSheafCompose (CategoryTheory.forget A)
inst✝² : Balanced (Sheaf (coherentTopology CompHaus) A)
inst✝¹ : PreservesFiniteProducts (CategoryTheory.forget A)
inst✝ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A
X Y : Condensed A
f : X ⟶ Y
⊢ (∀ (X_1 : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (op X_1))),
      ∃ X' φ, ∃ (_ : EffectiveEpi φ), ∃ x, (f.val.app (op X')) x = (Y.val.map (op φ)) y) ↔
    ∀ (S : CompHaus) (y : (CategoryTheory.forget A).obj (Y.val.obj (op S))),
      ∃ S' φ, ∃ (_ : Function.Surjective ⇑φ), ∃ x, (f.val.app (op S')) x = (Y.val.map (op φ)) y
state_after: no goals
tactic: simp_rw [((CompHaus.effectiveEpi_tfae _).out 0 2 :)]
Theorem: CategoryTheory.Limits.factorThruImageSubobject_comp_self_assoc
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h = k ≫ k' ≫ factorThruImageSubobject f
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ k' ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow
tactic: ext
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W W' : C
k : W ⟶ W'
k' : W' ⟶ X
h : (imageSubobject f).Factors (k ≫ k' ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ k' ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ k' ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MonoidalClosed.uncurry_pre
File: Mathlib/CategoryTheory/Closed/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : MonoidalCategory C
A B X✝ X' Y Y' Z : C
inst✝¹ : Closed A
inst✝ : Closed B
f : B ⟶ A
X : C
⊢ uncurry ((pre f).app X) = f ▷ (ihom A).obj X ≫ (ihom.ev A).app X
state_after: no goals
tactic: simp [uncurry_eq]
Theorem: CategoryTheory.GrothendieckTopology.imagePresheaf_id
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
⊢ imagePresheaf (𝟙 F) = ⊤
state_after: case obj.h.h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
x✝¹ : Cᵒᵖ
x✝ : F.obj x✝¹
⊢ x✝ ∈ (imagePresheaf (𝟙 F)).obj x✝¹ ↔ x✝ ∈ ⊤.obj x✝¹
tactic: ext
state_before: case obj.h.h
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
x✝¹ : Cᵒᵖ
x✝ : F.obj x✝¹
⊢ x✝ ∈ (imagePresheaf (𝟙 F)).obj x✝¹ ↔ x✝ ∈ ⊤.obj x✝¹
state_after: no goals
tactic: simp
Theorem: SetTheory.PGame.birthday_add_one
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: a b x : PGame
⊢ (a + 1).birthday = Order.succ a.birthday
state_after: no goals
tactic: simp
Theorem: ClosureOperator.eq_ofPred_closed
File: Mathlib/Order/Closure.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : PartialOrder α
c✝ : ClosureOperator α
x y : α
c : ClosureOperator α
⊢ c = ofPred (⇑c) c.IsClosed ⋯ ⋯ ⋯
state_after: case a
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : PartialOrder α
c✝ : ClosureOperator α
x y : α
c : ClosureOperator α
x✝ : α
⊢ c x✝ = (ofPred (⇑c) c.IsClosed ⋯ ⋯ ⋯) x✝
tactic: ext
state_before: case a
α : Type u_1
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : PartialOrder α
c✝ : ClosureOperator α
x y : α
c : ClosureOperator α
x✝ : α
⊢ c x✝ = (ofPred (⇑c) c.IsClosed ⋯ ⋯ ⋯) x✝
state_after: no goals
tactic: rfl
Theorem: Int.natCast_ne_zero_iff_pos
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑n ≠ 0 ↔ 0 < n
state_after: no goals
tactic: omega
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_hom_snd
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).hom ≫ snd (snd g g ≫ g) f = fst (fst f g) (fst f g) ≫ fst f g
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).hom ≫
      snd (snd g g ≫ g) f =
    fst (fst f g) (fst f g) ≫ fst f g
tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).hom ≫
      snd (snd g g ≫ g) f =
    fst (fst f g) (fst f g) ≫ fst f g
state_after: no goals
tactic: simp
Theorem: map_comp_add_neg
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 h : ι → G
⊢ ⇑f ∘ (g * h⁻¹) = ⇑f ∘ g * (⇑f ∘ h)⁻¹
state_after: no goals
tactic: simp
Theorem: lcm_eq_right_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
h : normalize b = b
⊢ lcm a b = b ↔ a ∣ b
state_after: no goals
tactic: simpa only [lcm_comm b a] using lcm_eq_left_iff b a h
Theorem: deriv_mem_iff
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x✝ : 𝕜
s✝ t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
s : Set F
x : 𝕜
⊢ deriv f x ∈ s ↔ DifferentiableAt 𝕜 f x ∧ deriv f x ∈ s ∨ ¬DifferentiableAt 𝕜 f x ∧ 0 ∈ s
state_after: no goals
tactic: by_cases hx : DifferentiableAt 𝕜 f x <;> simp [deriv_zero_of_not_differentiableAt, *]
Theorem: EReal.exp_neg
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

Proof steps:
state_before: x : EReal
⊢ (-x).exp = x.exp⁻¹
state_after: case h_bot

⊢ (-⊥).exp = ⊥.exp⁻¹

case h_real
a✝ : ℝ
⊢ (-↑a✝).exp = (↑a✝).exp⁻¹

case h_top

⊢ (-⊤).exp = ⊤.exp⁻¹
tactic: induction x
Theorem: AddUnits.isAddUnit_addUnits_add
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ IsUnit a
state_after: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
this : IsUnit (↑u⁻¹ * (↑u * a))
⊢ IsUnit a
tactic: have : IsUnit (↑u⁻¹ * (↑u * a)) := by exists u⁻¹ * v; rw [← hv, Units.val_mul]
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
this : IsUnit (↑u⁻¹ * (↑u * a))
⊢ IsUnit a
state_after: no goals
tactic: rwa [← mul_assoc, Units.inv_mul, one_mul] at this
Theorem: ContextFreeRule.reverse_involutive
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
N : Type uN
⊢ Function.Involutive reverse
state_after: T : Type uT
N : Type uN
x : ContextFreeRule T N
⊢ x.reverse.reverse = x
tactic: intro x
state_before: T : Type uT
N : Type uN
x : ContextFreeRule T N
⊢ x.reverse.reverse = x
state_after: no goals
tactic: simp [ContextFreeRule.reverse]
Theorem: Complex.sinh_ofReal_im
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (sinh ↑x).im = 0
state_after: no goals
tactic: rw [← ofReal_sinh_ofReal_re, ofReal_im]
Theorem: WeierstrassCurve.Jacobian.map_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
u : R
⊢ ⇑f ∘ (u • P) = f u • ⇑f ∘ P
state_after: case h
R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
u : R
i : Fin 3
⊢ (⇑f ∘ (u • P)) i = (f u • ⇑f ∘ P) i
tactic: ext i
state_before: case h
R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
u : R
i : Fin 3
⊢ (⇑f ∘ (u • P)) i = (f u • ⇑f ∘ P) i
state_after: no goals
tactic: fin_cases i <;> simp [smul_fin3]
Theorem: Equiv.swap_smul_self_smul
File: Mathlib/GroupTheory/Perm/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : DecidableEq α
inst✝ : MulAction (Perm α) β
i j : α
x : β
⊢ swap i j • swap i j • x = x
state_after: no goals
tactic: simp [smul_smul]