ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCocone_pt
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ D.map f ≫ (fun j => { f := c.ι.app j, h := ⋯ }) Y =
    (fun j => { f := c.ι.app j, h := ⋯ }) X ≫ ((Functor.const J).obj (coconePoint D c t)).map f
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ (D.map f ≫ (fun j => { f := c.ι.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.ι.app j, h := ⋯ }) X ≫ ((Functor.const J).obj (coconePoint D c t)).map f).f
tactic: ext1
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ (D.map f ≫ (fun j => { f := c.ι.app j, h := ⋯ }) Y).f =
    ((fun j => { f := c.ι.app j, h := ⋯ }) X ≫ ((Functor.const J).obj (coconePoint D c t)).map f).f
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ (D.map f).f ≫ c.ι.app Y = c.ι.app X ≫ 𝟙 c.pt
tactic: dsimp
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ (D.map f).f ≫ c.ι.app Y = c.ι.app X ≫ 𝟙 c.pt
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ c.ι.app X = c.ι.app X ≫ 𝟙 c.pt
tactic: erw [c.w f]
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D✝ : Type u₂
inst✝¹ : Category.{v₂, u₂} D✝
J : Type u
inst✝ : Category.{v, u} J
T : Comonad C
D : J ⥤ T.Coalgebra
c : Cocone (D ⋙ T.forget)
t : IsColimit c
X Y : J
f : X ⟶ Y
⊢ c.ι.app X = c.ι.app X ≫ 𝟙 c.pt
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.Data.ZMod.Basic.0.ZMod.mul_inv_cancel_aux
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n a✝ p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ZMod p
h : a ≠ 0
⊢ a * a⁻¹ = 1
state_after: case intro
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ ↑k * (↑k)⁻¹ = 1
tactic: obtain ⟨k, rfl⟩ := natCast_zmod_surjective a
state_before: case intro
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ ↑k * (↑k)⁻¹ = 1
state_after: case intro.h
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ k.Coprime p
tactic: apply coe_mul_inv_eq_one
state_before: case intro.h
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ k.Coprime p
state_after: case intro.h.a
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ p.Coprime k
tactic: apply Nat.Coprime.symm
state_before: case intro.h.a
m n✝ n a p : ℕ
inst✝ : Fact (Nat.Prime p)
k : ℕ
h : ↑k ≠ 0
⊢ p.Coprime k
state_after: no goals
tactic: rwa [Nat.Prime.coprime_iff_not_dvd Fact.out, ← CharP.cast_eq_zero_iff (ZMod p)]
Theorem: SetTheory.PGame.inv_eq_of_equiv_zero
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x : PGame
h : x ≈ 0
⊢ x⁻¹ = 0
state_after: no goals
tactic: classical exact if_pos h
Theorem: HahnSeries.zero_le_orderTop_iff
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
⊢ 0 ≤ x.orderTop ↔ 0 ≤ x.order
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
h : x = 0
⊢ 0 ≤ x.orderTop ↔ 0 ≤ x.order

case neg
Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
h : ¬x = 0
⊢ 0 ≤ x.orderTop ↔ 0 ≤ x.order
tactic: by_cases h : x = 0
Theorem: CategoryTheory.ShortComplex.mono_homologyMap_of_mono_opcyclesMap'
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Mono (opcyclesMap φ)
⊢ Mono (homologyMap φ)
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Mono (opcyclesMap φ)
this : Mono (homologyMap φ ≫ S₂.homologyι)
⊢ Mono (homologyMap φ)
tactic: have : Mono (homologyMap φ ≫ S₂.homologyι) := by
    rw [homologyι_naturality φ]
    apply mono_comp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
h : Mono (opcyclesMap φ)
this : Mono (homologyMap φ ≫ S₂.homologyι)
⊢ Mono (homologyMap φ)
state_after: no goals
tactic: exact mono_of_mono (homologyMap φ) S₂.homologyι
Theorem: Function.Surjective.leftDistribClass
File: Mathlib/Algebra/Ring/InjSurj.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹³ : Zero β
inst✝¹² : One β
inst✝¹¹ : Add β
inst✝¹⁰ : Mul β
inst✝⁹ : Neg β
inst✝⁸ : Sub β
inst✝⁷ : SMul ℕ β
inst✝⁶ : SMul ℤ β
inst✝⁵ : Pow β ℕ
inst✝⁴ : NatCast β
inst✝³ : IntCast β
f : α → β
hf : Surjective f
inst✝² : Mul α
inst✝¹ : Add α
inst✝ : LeftDistribClass α
add : ∀ (x y : α), f (x + y) = f x + f y
mul : ∀ (x y : α), f (x * y) = f x * f y
x y z : α
⊢ f x * (f y + f z) = f x * f y + f x * f z
state_after: no goals
tactic: simp only [← add, ← mul, left_distrib]
Theorem: IsRelPrime.isCoprime
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
h : IsRelPrime x y
⊢ IsCoprime x y
state_after: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
h : IsRelPrime x y
⊢ IsUnit (gcd x y)
tactic: rw [← Ideal.isCoprime_span_singleton_iff, Ideal.isCoprime_iff_sup_eq, ← Ideal.span_union,
    Set.singleton_union, ← span_gcd, Ideal.span_singleton_eq_top]
state_before: R : Type u
M : Type v
inst✝¹ : CommRing R
x y z : R
inst✝ : IsPrincipal (Ideal.span {x, y})
h : IsRelPrime x y
⊢ IsUnit (gcd x y)
state_after: no goals
tactic: exact h (gcd_dvd_left x y) (gcd_dvd_right x y)
Theorem: Complex.arg_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x z : ℂ
⊢ arg 0 = 0
state_after: no goals
tactic: simp [arg, le_refl]
Theorem: IsAddFreimanHom.comp
File: Mathlib/Combinatorics/Additive/FreimanHom.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ (map (g ∘ f) s).prod = (map (g ∘ f) t).prod
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ (map g (map f s)).prod = (map g (map f t)).prod
tactic: rw [← map_map, ← map_map]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ (map g (map f s)).prod = (map g (map f t)).prod
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ ∀ ⦃x : β⦄, x ∈ map f s → x ∈ B

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : CommMonoid γ
A A₁ A₂ : Set α
B B₁ B₂ : Set β
C : Set γ
f f₁ f₂ : α → β
g : β → γ
m n : ℕ
hg : IsMulFreimanHom n B C g
hf : IsMulFreimanHom n A B f
s t : Multiset α
hsA : ∀ ⦃x : α⦄, x ∈ s → x ∈ A
htA : ∀ ⦃x : α⦄, x ∈ t → x ∈ A
hs : card s = n
ht : card t = n
h : s.prod = t.prod
⊢ ∀ ⦃x : β⦄, x ∈ map f t → x ∈ B
tactic: refine hg.map_prod_eq_map_prod ?_ ?_ (by rwa [card_map]) (by rwa [card_map])
      (hf.map_prod_eq_map_prod hsA htA hs ht h)
Theorem: Zsqrtd.norm_eq_one_iff_mem_unitary
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ a ∈ unitary (ℤ√d)
state_after: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ ↑a.norm = 1
tactic: rw [unitary.mem_iff_self_mul_star, ← norm_eq_mul_conj]
state_before: R : Type
inst✝ : CommRing R
d : ℤ
a : ℤ√d
⊢ a.norm = 1 ↔ ↑a.norm = 1
state_after: no goals
tactic: norm_cast
Theorem: Matroid.restrict_idem
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
R✝ I J X Y : Set α
M : Matroid α
R : Set α
⊢ M ↾ R ↾ R = M ↾ R
state_after: no goals
tactic: rw [M.restrict_restrict_eq Subset.rfl]
Theorem: LinearMap.mul_toMatrix₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M₁
inst✝¹⁶ : Module R M₁
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R M₂
inst✝¹³ : AddCommMonoid N₂
inst✝¹² : Module R N₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁✝ : Basis n R M₁
b₂✝ : Basis m R M₂
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
B : M₁ →ₗ[R] M₂ →ₗ[R] R
M : Matrix n' n R
⊢ M * (toMatrix₂ b₁ b₂) B = (toMatrix₂ b₁' b₂) (B ∘ₗ (toLin b₁' b₁) Mᵀ)
state_after: no goals
tactic: rw [LinearMap.toMatrix₂_comp b₁, toMatrix_toLin, transpose_transpose]
Theorem: Polynomial.splits_of_exists_multiset
File: Mathlib/Algebra/Polynomial/Splits.lean

Proof steps:
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Irreducible p
hdp : p ∣ map i f
⊢ p.degree = 1
state_after: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ map i f
⊢ p.degree = 1
tactic: rw [irreducible_iff_prime] at hp
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ map i f
⊢ p.degree = 1
state_after: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).toList.prod
⊢ p.degree = 1
tactic: rw [hs, ← Multiset.prod_toList] at hdp
state_before: R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).toList.prod
⊢ p.degree = 1
state_after: case inl
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).toList.prod
hd : p ∣ C (i f.leadingCoeff)
⊢ p.degree = 1

case inr
R : Type u_1
F : Type u
K : Type v
L : Type w
inst✝³ : CommRing R
inst✝² : Field K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
s : Multiset L
hs : map i f = C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).prod
this : DecidableEq K := Classical.decEq K
hf0 : ¬f = 0
p : L[X]
hp : Prime p
hdp : p ∣ C (i f.leadingCoeff) * (Multiset.map (fun a => X - C a) s).toList.prod
hd : p ∣ (Multiset.map (fun a => X - C a) s).toList.prod
⊢ p.degree = 1
tactic: obtain hd | hd := hp.2.2 _ _ hdp
Theorem: CategoryTheory.Functor.HasRightDerivedFunctor.mk'
File: Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean

Proof steps:
state_before: C : Type u_1
C' : Type ?u.94612
D : Type u_2
D' : Type ?u.94618
H : Type u_3
H' : Type ?u.94624
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{?u.94632, ?u.94612} C'
inst✝⁵ : Category.{u_5, u_2} D
inst✝⁴ : Category.{?u.94640, ?u.94618} D'
inst✝³ : Category.{u_6, u_3} H
inst✝² : Category.{?u.94648, ?u.94624} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α' : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : RF.IsRightDerivedFunctor α W
⊢ F.HasRightDerivedFunctor W
state_after: C : Type u_1
C' : Type ?u.94612
D : Type u_2
D' : Type ?u.94618
H : Type u_3
H' : Type ?u.94624
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{?u.94632, ?u.94612} C'
inst✝⁵ : Category.{u_5, u_2} D
inst✝⁴ : Category.{?u.94640, ?u.94618} D'
inst✝³ : Category.{u_6, u_3} H
inst✝² : Category.{?u.94648, ?u.94624} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α' : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : RF.IsRightDerivedFunctor α W
this : RF.IsLeftKanExtension α
⊢ F.HasRightDerivedFunctor W
tactic: have := IsRightDerivedFunctor.isLeftKanExtension RF α W
state_before: C : Type u_1
C' : Type ?u.94612
D : Type u_2
D' : Type ?u.94618
H : Type u_3
H' : Type ?u.94624
inst✝⁷ : Category.{u_4, u_1} C
inst✝⁶ : Category.{?u.94632, ?u.94612} C'
inst✝⁵ : Category.{u_5, u_2} D
inst✝⁴ : Category.{?u.94640, ?u.94618} D'
inst✝³ : Category.{u_6, u_3} H
inst✝² : Category.{?u.94648, ?u.94624} H'
RF RF' RF'' : D ⥤ H
F F' F'' : C ⥤ H
e : F ≅ F'
L : C ⥤ D
α : F ⟶ L ⋙ RF
α' : F' ⟶ L ⋙ RF'
α'' : F'' ⟶ L ⋙ RF''
α'₂ : F ⟶ L ⋙ RF'
W : MorphismProperty C
inst✝¹ : L.IsLocalization W
inst✝ : RF.IsRightDerivedFunctor α W
this : RF.IsLeftKanExtension α
⊢ F.HasRightDerivedFunctor W
state_after: no goals
tactic: simpa only [hasRightDerivedFunctor_iff F L W] using HasLeftKanExtension.mk RF α
Theorem: AlgebraicGeometry.LocallyRingedSpace.residue_comp_residueFieldMap_eq_stalkMap_comp_residue
File: Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean

Proof steps:
state_before: X✝ : LocallyRingedSpace
U : Opens ↑X✝.toTopCat
X Y : LocallyRingedSpace
f : X ⟶ Y
x : ↑X.toTopCat
⊢ LocalRing.residue ↑(Y.presheaf.stalk (f.val.base x)) ≫ residueFieldMap f x =
    Hom.stalkMap f x ≫ LocalRing.residue ↑(X.presheaf.stalk x)
state_after: X✝ : LocallyRingedSpace
U : Opens ↑X✝.toTopCat
X Y : LocallyRingedSpace
f : X ⟶ Y
x : ↑X.toTopCat
⊢ LocalRing.residue ↑(Y.presheaf.stalk (f.val.base x)) ≫ LocalRing.ResidueField.map (Hom.stalkMap f x) =
    Hom.stalkMap f x ≫ LocalRing.residue ↑(X.presheaf.stalk x)
tactic: simp [residueFieldMap]
state_before: X✝ : LocallyRingedSpace
U : Opens ↑X✝.toTopCat
X Y : LocallyRingedSpace
f : X ⟶ Y
x : ↑X.toTopCat
⊢ LocalRing.residue ↑(Y.presheaf.stalk (f.val.base x)) ≫ LocalRing.ResidueField.map (Hom.stalkMap f x) =
    Hom.stalkMap f x ≫ LocalRing.residue ↑(X.presheaf.stalk x)
state_after: no goals
tactic: rfl
Theorem: AddSubgroup.characteristic_iff_map_le
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), map ϕ.toMonoidHom H ≤ H
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H ≤ H
tactic: simp_rw [map_equiv_eq_comap_symm']
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
⊢ H.Characteristic ↔ ∀ (ϕ : G ≃* G), comap ϕ.symm.toMonoidHom H ≤ H
state_after: no goals
tactic: exact characteristic_iff_comap_le.trans ⟨fun h ϕ => h ϕ.symm, fun h ϕ => h ϕ.symm⟩
Theorem: BoxIntegral.Prepartition.biUnion_top
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
⊢ (π.biUnion fun x => ⊤) = π
state_after: case h
ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
J✝ : Box ι
⊢ (J✝ ∈ π.biUnion fun x => ⊤) ↔ J✝ ∈ π
tactic: ext
state_before: case h
ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
J✝ : Box ι
⊢ (J✝ ∈ π.biUnion fun x => ⊤) ↔ J✝ ∈ π
state_after: no goals
tactic: simp
Theorem: le_add_neg_iff_add_le
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * b ≤ a * b⁻¹ * b ↔ c * b ≤ a
state_after: no goals
tactic: rw [inv_mul_cancel_right]
Theorem: PartENat.le_of_lt_add_one
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : PartENat
h : x < y + 1
⊢ x ≤ y
state_after: case a
x : PartENat
h : x < ⊤ + 1
⊢ x ≤ ⊤

case a
x : PartENat
n : ℕ
h : x < ↑n + 1
⊢ x ≤ ↑n
tactic: induction' y using PartENat.casesOn with n
state_before: case a
x : PartENat
n : ℕ
h : x < ↑n + 1
⊢ x ≤ ↑n
state_after: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ ↑m ≤ ↑n
tactic: rcases ne_top_iff.mp (ne_top_of_lt h) with ⟨m, rfl⟩
state_before: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ ↑m ≤ ↑n
state_after: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ m ≤ n
tactic: norm_cast
state_before: case a.intro
n m : ℕ
h : ↑m < ↑n + 1
⊢ m ≤ n
state_after: case a.intro.a
n m : ℕ
h : ↑m < ↑n + 1
⊢ m < n.succ
tactic: apply Nat.le_of_lt_succ
state_before: case a.intro.a
n m : ℕ
h : ↑m < ↑n + 1
⊢ m < n.succ
state_after: no goals
tactic: norm_cast at h
Theorem: List.length_eraseP_add_one
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
⊢ (eraseP p l).length + 1 = l.length
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length + 1 = l.length
tactic: let ⟨_, l₁, l₂, _, _, h₁, h₂⟩ := exists_of_eraseP al pa
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length + 1 = l.length
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length + 1 = l₁.length + (w✝ :: l₂).length
tactic: rw [h₂, h₁, length_append, length_append]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : α → Bool
l : List α
a : α
al : a ∈ l
pa : p a = true
w✝ : α
l₁ l₂ : List α
left✝¹ : ∀ (b : α), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
h₁ : l = l₁ ++ w✝ :: l₂
h₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length + 1 = l₁.length + (w✝ :: l₂).length
state_after: no goals
tactic: rfl
Theorem: Real.exp_sub
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ rexp (x - y) = rexp x / rexp y
state_after: no goals
tactic: simp [sub_eq_add_neg, exp_add, exp_neg, div_eq_mul_inv]
Theorem: PowerSeries.order_one
File: Mathlib/RingTheory/PowerSeries/Order.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
inst✝ : Nontrivial R
⊢ order 1 = 0
state_after: no goals
tactic: simpa using order_monomial_of_ne_zero 0 (1 : R) one_ne_zero
Theorem: List.Chain'.length_sub_one_le_two_mul_count_bool
File: Mathlib/Data/Bool/Count.lean

Proof steps:
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ l.length - 1 ≤ 2 * count b l
state_after: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ l.length - 1 ≤ if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1
tactic: rw [hl.two_mul_count_bool_eq_ite]
state_before: l : List Bool
hl : Chain' (fun x x_1 => x ≠ x_1) l
b : Bool
⊢ l.length - 1 ≤ if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1
state_after: no goals
tactic: split_ifs <;> simp [le_tsub_add, Nat.le_succ_of_le]
Theorem: jacobiSym.prime_dvd_of_eq_neg_one
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : J(a | p) = -1
x y : ℤ
hxy : ↑p ∣ x ^ 2 - a * y ^ 2
⊢ ↑p ∣ x ∧ ↑p ∣ y
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑p ∣ x ^ 2 - a * y ^ 2
⊢ ↑p ∣ x ∧ ↑p ∣ y
tactic: rw [← legendreSym.to_jacobiSym] at h
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑p ∣ x ^ 2 - a * y ^ 2
⊢ ↑p ∣ x ∧ ↑p ∣ y
state_after: no goals
tactic: exact legendreSym.prime_dvd_of_eq_neg_one h hxy
Theorem: Set.ite_left
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s.ite s t = s ∪ t
state_after: no goals
tactic: simp [Set.ite]