ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.RightExtension.coneAt_π_app
File: Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ ((const (StructuredArrow Y L)).obj (E.left.obj Y)).map φ ≫ (fun g => E.left.map g.hom ≫ E.hom.app g.right) g₂ =
    (fun g => E.left.map g.hom ≫ E.hom.app g.right) g₁ ≫ (StructuredArrow.proj Y L ⋙ F).map φ
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ 𝟙 (E.left.obj Y) ≫ E.left.map g₂.hom ≫ E.hom.app g₂.right = (E.left.map g₁.hom ≫ E.hom.app g₁.right) ≫ F.map φ.right
tactic: dsimp
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ 𝟙 (E.left.obj Y) ≫ E.left.map g₂.hom ≫ E.hom.app g₂.right = (E.left.map g₁.hom ≫ E.hom.app g₁.right) ≫ F.map φ.right
state_after: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ E.left.map g₁.hom ≫ E.left.map (L.map φ.right) ≫ E.hom.app g₂.right =
    E.left.map g₁.hom ≫ E.hom.app g₁.right ≫ F.map φ.right
tactic: rw [assoc, id_comp, ← StructuredArrow.w φ, Functor.map_comp, assoc]
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ E.left.map g₁.hom ≫ E.left.map (L.map φ.right) ≫ E.hom.app g₂.right =
    E.left.map g₁.hom ≫ E.hom.app g₁.right ≫ F.map φ.right
state_after: case e_a
C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ E.left.map (L.map φ.right) ≫ E.hom.app g₂.right = E.hom.app g₁.right ≫ F.map φ.right
tactic: congr 1
state_before: case e_a
C : Type u_1
D : Type u_2
H : Type u_3
inst✝² : Category.{?u.46478, u_1} C
inst✝¹ : Category.{?u.46482, u_2} D
inst✝ : Category.{?u.46486, u_3} H
L : C ⥤ D
F : C ⥤ H
E E' : L.RightExtension F
Y : D
g₁ g₂ : StructuredArrow Y L
φ : g₁ ⟶ g₂
⊢ E.left.map (L.map φ.right) ≫ E.hom.app g₂.right = E.hom.app g₁.right ≫ F.map φ.right
state_after: no goals
tactic: apply E.hom.naturality
Theorem: CategoryTheory.CostructuredArrow.lift_projectQuotient
File: Mathlib/CategoryTheory/Subobject/Comma.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
⊢ ∀ ⦃A_1 : (CostructuredArrow S T)ᵒᵖ⦄ (f : A_1 ⟶ op A) [inst : Mono f]
    {q : S.obj (unop (Subobject.underlying.obj (projectQuotient (Subobject.mk f)))) ⟶ (Functor.fromPUnit T).obj A.right}
    (hq : S.map (projectQuotient (Subobject.mk f)).arrow.unop ≫ q = A.hom),
    liftQuotient (projectQuotient (Subobject.mk f)) hq = Subobject.mk f
state_after: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
hf : Mono f
q : S.obj (unop (Subobject.underlying.obj (projectQuotient (Subobject.mk f)))) ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (projectQuotient (Subobject.mk f)).arrow.unop ≫ q = A.hom
⊢ liftQuotient (projectQuotient (Subobject.mk f)) hq = Subobject.mk f
tactic: intro P f hf q hq
state_before: C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
hf : Mono f
q : S.obj (unop (Subobject.underlying.obj (projectQuotient (Subobject.mk f)))) ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (projectQuotient (Subobject.mk f)).arrow.unop ≫ q = A.hom
⊢ liftQuotient (projectQuotient (Subobject.mk f)) hq = Subobject.mk f
state_after: case i
C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
hf : Mono f
q : S.obj (unop (Subobject.underlying.obj (projectQuotient (Subobject.mk f)))) ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (projectQuotient (Subobject.mk f)).arrow.unop ≫ q = A.hom
⊢ op (mk q) ≅ P

case w
C : Type u₁
inst✝³ : Category.{v, u₁} C
D : Type u₂
inst✝² : Category.{v, u₂} D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ op A
hf : Mono f
q : S.obj (unop (Subobject.underlying.obj (projectQuotient (Subobject.mk f)))) ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (projectQuotient (Subobject.mk f)).arrow.unop ≫ q = A.hom
⊢ ?i.hom ≫ f = (homMk (projectQuotient (Subobject.mk f)).arrow.unop hq).op
tactic: fapply Subobject.mk_eq_mk_of_comm
Theorem: SimpleGraph.edgeSet_sdiff_sdiff_isDiag
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
⊢ G.edgeSet \ (s \ {e | e.IsDiag}) = G.edgeSet \ s
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ G.edgeSet \ (s \ {e | e.IsDiag}) ↔ e ∈ G.edgeSet \ s
tactic: ext e
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ G.edgeSet \ (s \ {e | e.IsDiag}) ↔ e ∈ G.edgeSet \ s
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ G.edgeSet → (e ∈ s → e.IsDiag ↔ e ∉ s)
tactic: simp only [Set.mem_diff, Set.mem_setOf_eq, not_and, not_not, and_congr_right_iff]
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
⊢ e ∈ G.edgeSet → (e ∈ s → e.IsDiag ↔ e ∉ s)
state_after: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
h : e ∈ G.edgeSet
⊢ e ∈ s → e.IsDiag ↔ e ∉ s
tactic: intro h
state_before: case h
ι : Sort u_1
V : Type u
G✝ : SimpleGraph V
a b c u v w : V
e✝ : Sym2 V
G₁ G₂ G : SimpleGraph V
s : Set (Sym2 V)
e : Sym2 V
h : e ∈ G.edgeSet
⊢ e ∈ s → e.IsDiag ↔ e ∉ s
state_after: no goals
tactic: simp only [G.not_isDiag_of_mem_edgeSet h, imp_false]
Theorem: Complex.hasSum_taylorSeries_log
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ HasSum (fun n => (-1) ^ (n + 1) * z ^ n / ↑n) (log (1 + z))
state_after: case refine_1
z : ℂ
hz : ‖z‖ < 1
⊢ Summable fun i => ‖(-1) ^ (i + 1) * z ^ i / ↑i‖

case refine_2
z : ℂ
hz : ‖z‖ < 1
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, (-1) ^ (i + 1) * z ^ i / ↑i) atTop (nhds (log (1 + z)))
tactic: refine (hasSum_iff_tendsto_nat_of_summable_norm ?_).mpr ?_
Theorem: List.toFinset.ext_iff
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a✝ : α
a b : List α
⊢ a.toFinset = b.toFinset ↔ ∀ (x : α), x ∈ a ↔ x ∈ b
state_after: no goals
tactic: simp only [Finset.ext_iff, mem_toFinset]
Theorem: PerfectClosure.eq_iff
File: Mathlib/FieldTheory/PerfectClosure.lean

Proof steps:
state_before: K : Type u
inst✝³ : CommRing K
inst✝² : IsReduced K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y : ℕ × K
x✝ : ∃ z, (⇑(frobenius K p))^[y.1 + z] x.2 = (⇑(frobenius K p))^[x.1 + z] y.2
z : ℕ
H : (⇑(frobenius K p))^[y.1 + z] x.2 = (⇑(frobenius K p))^[x.1 + z] y.2
⊢ (⇑(frobenius K p))^[z] ((⇑(frobenius K p))^[y.1] x.2) = (⇑(frobenius K p))^[z] ((⇑(frobenius K p))^[x.1] y.2)
state_after: no goals
tactic: simpa only [add_comm, iterate_add] using H
Theorem: Real.log_nat_eq_sum_factorization
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
n : ℕ
⊢ log ↑n = n.factorization.sum fun p t => ↑t * log ↑p
state_after: case inl
x y : ℝ
⊢ log ↑0 = (Nat.factorization 0).sum fun p t => ↑t * log ↑p

case inr
x y : ℝ
n : ℕ
hn : n ≠ 0
⊢ log ↑n = n.factorization.sum fun p t => ↑t * log ↑p
tactic: rcases eq_or_ne n 0 with (rfl | hn)
Theorem: VectorFourier.norm_fourierSMulRight_le
File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

Proof steps:
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L✝ : V →L[ℝ] W →L[ℝ] ℝ
f✝ : V → E
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
v : V
⊢ 2 * π * ‖L v‖ * ‖f v‖ ≤ 2 * π * (‖L‖ * ‖v‖) * ‖f v‖
state_after: case h.h
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L✝ : V →L[ℝ] W →L[ℝ] ℝ
f✝ : V → E
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
v : V
⊢ ‖L v‖ ≤ ‖L‖ * ‖v‖
tactic: gcongr
state_before: case h.h
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L✝ : V →L[ℝ] W →L[ℝ] ℝ
f✝ : V → E
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
v : V
⊢ ‖L v‖ ≤ ‖L‖ * ‖v‖
state_after: no goals
tactic: exact L.le_opNorm _
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L✝ : V →L[ℝ] W →L[ℝ] ℝ
f✝ : V → E
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
v : V
⊢ 2 * π * (‖L‖ * ‖v‖) * ‖f v‖ = 2 * π * ‖L‖ * ‖v‖ * ‖f v‖
state_after: no goals
tactic: ring
Theorem: CategoryTheory.shift_shift'
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctor C j).map ((shiftFunctor C i).map f) =
    (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C j).map ((shiftFunctor C i).map f)
tactic: symm
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftAdd X i j).inv ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C j).map ((shiftFunctor C i).map f)
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctorAdd C i j).inv.app X ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C i ⋙ shiftFunctor C j).map f
tactic: rw [← Functor.comp_map, NatIso.app_inv]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftFunctorAdd C i j).inv.app X ≫ (shiftFunctor C (i + j)).map f ≫ (shiftAdd Y i j).hom =
    (shiftFunctor C i ⋙ shiftFunctor C j).map f
state_after: no goals
tactic: apply NatIso.naturality_1
Theorem: HasCompactSupport.integral_Ioi_deriv_eq
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

Proof steps:
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
⊢ ∫ (x : ℝ) in Ioi b, deriv f x = -f b
state_after: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ ∫ (x : ℝ) in Ioi b, deriv f x = -f b
tactic: have := fun x (_ : x ∈ Ioi b) ↦ hf.differentiable le_rfl x |>.hasDerivAt
state_before: E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ ∫ (x : ℝ) in Ioi b, deriv f x = -f b
state_after: case f'int
E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ IntegrableOn (deriv f) (Ioi b) volume

case hf
E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ Tendsto f atTop (𝓝 0)
tactic: rw [integral_Ioi_of_hasDerivAt_of_tendsto hf.continuous.continuousWithinAt this, zero_sub]
state_before: case hf
E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : HasCompactSupport f
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ Tendsto f atTop (𝓝 0)
state_after: case hf
E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : f =ᶠ[cocompact ℝ] 0
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ Tendsto f atTop (𝓝 0)
tactic: rw [hasCompactSupport_iff_eventuallyEq, Filter.coclosedCompact_eq_cocompact] at h2f
state_before: case hf
E : Type u_1
f f' : ℝ → E
g g' : ℝ → ℝ
a b✝ l : ℝ
m : E
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
hf : ContDiff ℝ 1 f
h2f : f =ᶠ[cocompact ℝ] 0
b : ℝ
this : ∀ x ∈ Ioi b, HasDerivAt f (deriv f x) x
⊢ Tendsto f atTop (𝓝 0)
state_after: no goals
tactic: exact h2f.filter_mono _root_.atTop_le_cocompact |>.tendsto
Theorem: Polynomial.integralNormalization_zero
File: Mathlib/RingTheory/Polynomial/IntegralNormalization.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
⊢ integralNormalization 0 = 0
state_after: no goals
tactic: simp [integralNormalization]
Theorem: infClosed_singleton
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
ι : Sort u_4
S : Set (Set α)
f : ι → Set α
s t : Set α
a : α
⊢ InfClosed {a}
state_after: no goals
tactic: simp [InfClosed]
Theorem: linearEquiv_det_rotation
File: Mathlib/Analysis/Complex/Isometry.lean

Proof steps:
state_before: a : ↥circle
⊢ LinearEquiv.det (rotation a).toLinearEquiv = 1
state_after: no goals
tactic: rw [← Units.eq_iff, LinearEquiv.coe_det, det_rotation, Units.val_one]
Theorem: map_mul_left_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x✝ : α
x : G
⊢ map (fun x_1 => x * x_1) (𝓝 1) = 𝓝 x
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Quotient.natIsoLift_hom
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type ?u.25950
inst✝¹ : Category.{?u.25954, ?u.25950} C
r : HomRel C
D : Type ?u.25982
inst✝ : Category.{?u.25986, ?u.25982} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ : functor r ⋙ F ≅ functor r ⋙ G
⊢ natTransLift r τ.hom ≫ natTransLift r τ.inv = 𝟙 F
state_after: no goals
tactic: rw [comp_natTransLift, τ.hom_inv_id, natTransLift_id]
state_before: C : Type ?u.25950
inst✝¹ : Category.{?u.25954, ?u.25950} C
r : HomRel C
D : Type ?u.25982
inst✝ : Category.{?u.25986, ?u.25982} D
F✝ : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F✝.map f₁ = F✝.map f₂
F G : Quotient r ⥤ D
τ : functor r ⋙ F ≅ functor r ⋙ G
⊢ natTransLift r τ.inv ≫ natTransLift r τ.hom = 𝟙 G
state_after: no goals
tactic: rw [comp_natTransLift, τ.inv_hom_id, natTransLift_id]
Theorem: Hyperreal.IsSt.lt
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x y : ℝ*
r s : ℝ
hxr : x.IsSt r
hys : y.IsSt s
hrs : r < s
⊢ x < y
state_after: case intro
y : ℝ*
r s : ℝ
hys : y.IsSt s
hrs : r < s
f : ℕ → ℝ
hxr : (ofSeq f).IsSt r
⊢ ofSeq f < y
tactic: rcases ofSeq_surjective x with ⟨f, rfl⟩
state_before: case intro
y : ℝ*
r s : ℝ
hys : y.IsSt s
hrs : r < s
f : ℕ → ℝ
hxr : (ofSeq f).IsSt r
⊢ ofSeq f < y
state_after: case intro.intro
r s : ℝ
hrs : r < s
f : ℕ → ℝ
hxr : (ofSeq f).IsSt r
g : ℕ → ℝ
hys : (ofSeq g).IsSt s
⊢ ofSeq f < ofSeq g
tactic: rcases ofSeq_surjective y with ⟨g, rfl⟩
state_before: case intro.intro
r s : ℝ
hrs : r < s
f : ℕ → ℝ
hxr : (ofSeq f).IsSt r
g : ℕ → ℝ
hys : (ofSeq g).IsSt s
⊢ ofSeq f < ofSeq g
state_after: case intro.intro
r s : ℝ
hrs : r < s
f : ℕ → ℝ
hxr : Tendsto f (↑(hyperfilter ℕ)) (𝓝 r)
g : ℕ → ℝ
hys : Tendsto g (↑(hyperfilter ℕ)) (𝓝 s)
⊢ ofSeq f < ofSeq g
tactic: rw [isSt_ofSeq_iff_tendsto] at hxr hys
state_before: case intro.intro
r s : ℝ
hrs : r < s
f : ℕ → ℝ
hxr : Tendsto f (↑(hyperfilter ℕ)) (𝓝 r)
g : ℕ → ℝ
hys : Tendsto g (↑(hyperfilter ℕ)) (𝓝 s)
⊢ ofSeq f < ofSeq g
state_after: no goals
tactic: exact ofSeq_lt_ofSeq.2 <| hxr.eventually_lt hys hrs
Theorem: SimpleGraph.Walk.isCycle_copy
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v w u u' : V
p : G.Walk u u
hu : u = u'
⊢ (p.copy hu hu).IsCycle ↔ p.IsCycle
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u' : V
p : G.Walk u' u'
⊢ (p.copy ⋯ ⋯).IsCycle ↔ p.IsCycle
tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w u' : V
p : G.Walk u' u'
⊢ (p.copy ⋯ ⋯).IsCycle ↔ p.IsCycle
state_after: no goals
tactic: rfl
Theorem: Submodule.torsion_int
File: Mathlib/Algebra/Module/Torsion.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : NoZeroDivisors R
inst✝¹ : Nontrivial R
G : Type u_3
inst✝ : AddCommGroup G
⊢ (torsion ℤ G).toAddSubgroup = AddCommGroup.torsion G
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : NoZeroDivisors R
inst✝¹ : Nontrivial R
G : Type u_3
inst✝ : AddCommGroup G
x : G
⊢ x ∈ (torsion ℤ G).toAddSubgroup ↔ x ∈ AddCommGroup.torsion G
tactic: ext x
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : NoZeroDivisors R
inst✝¹ : Nontrivial R
G : Type u_3
inst✝ : AddCommGroup G
x : G
⊢ x ∈ (torsion ℤ G).toAddSubgroup ↔ x ∈ AddCommGroup.torsion G
state_after: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : NoZeroDivisors R
inst✝¹ : Nontrivial R
G : Type u_3
inst✝ : AddCommGroup G
x : G
⊢ (∃ n, n ≠ 0 ∧ n • x = 0) ↔ x ∈ (torsion ℤ G).toAddSubgroup
tactic: refine ((isOfFinAddOrder_iff_zsmul_eq_zero (x := x)).trans ?_).symm
state_before: case h
R : Type u_1
M : Type u_2
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : NoZeroDivisors R
inst✝¹ : Nontrivial R
G : Type u_3
inst✝ : AddCommGroup G
x : G
⊢ (∃ n, n ≠ 0 ∧ n • x = 0) ↔ x ∈ (torsion ℤ G).toAddSubgroup
state_after: no goals
tactic: simp [mem_nonZeroDivisors_iff_ne_zero]
Theorem: CategoryTheory.Sieve.ofArrows_le_ofObjects
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
⊢ ofArrows Y f ≤ ofObjects Y X
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
hg : (ofArrows Y f).arrows g
⊢ (ofObjects Y X).arrows g
tactic: intro W g hg
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
hg : (ofArrows Y f).arrows g
⊢ (ofObjects Y X).arrows g
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
hg : ∃ i a, g = a ≫ f i
⊢ (ofObjects Y X).arrows g
tactic: rw [mem_ofArrows_iff] at hg
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
g : W ⟶ X
hg : ∃ i a, g = a ≫ f i
⊢ (ofObjects Y X).arrows g
state_after: case intro.intro
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
i : I
a : W ⟶ Y i
⊢ (ofObjects Y X).arrows (a ≫ f i)
tactic: obtain ⟨i, a, rfl⟩ := hg
state_before: case intro.intro
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✝
I : Type u_1
Y : I → C
X : C
f : (i : I) → Y i ⟶ X
W : C
i : I
a : W ⟶ Y i
⊢ (ofObjects Y X).arrows (a ≫ f i)
state_after: no goals
tactic: exact ⟨i, ⟨a⟩⟩
Theorem: AddConstMapClass.map_add_zsmul
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroup G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H a b
f : F
x : G
n : ℕ
⊢ f (x + ↑n • a) = f x + ↑n • b
state_after: no goals
tactic: simp
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroup G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H a b
f : F
x : G
n : ℕ
⊢ f (x + Int.negSucc n • a) = f x + Int.negSucc n • b
state_after: no goals
tactic: simp [← sub_eq_add_neg]
Theorem: Additive.isAddSubgroup_iff
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
⊢ IsAddSubgroup s → IsSubgroup s
state_after: case mk.mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
h₃ : ∀ {a : Additive G}, a ∈ s → -a ∈ s
h₁ : 0 ∈ s
h₂ : ∀ {a b : Additive G}, a ∈ s → b ∈ s → a + b ∈ s
⊢ IsSubgroup s
tactic: rintro ⟨⟨h₁, h₂⟩, h₃⟩
state_before: case mk.mk
G : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
h₃ : ∀ {a : Additive G}, a ∈ s → -a ∈ s
h₁ : 0 ∈ s
h₂ : ∀ {a b : Additive G}, a ∈ s → b ∈ s → a + b ∈ s
⊢ IsSubgroup s
state_after: no goals
tactic: exact @IsSubgroup.mk G _ _ ⟨h₁, @h₂⟩ @h₃