diff --git a/src/SparseConnectivityTracer.jl b/src/SparseConnectivityTracer.jl
index 0cff835d..a2791a79 100644
--- a/src/SparseConnectivityTracer.jl
+++ b/src/SparseConnectivityTracer.jl
@@ -19,9 +19,6 @@ include("settypes/duplicatevector.jl")
 include("settypes/recursiveset.jl")
 include("settypes/sortedvector.jl")
 
-abstract type AbstractPattern end
-abstract type AbstractTracer{P<:AbstractPattern} <: Real end
-
 include("patterns.jl")
 include("tracers.jl")
 include("exceptions.jl")
diff --git a/src/patterns.jl b/src/patterns.jl
index 9705c9a3..01116566 100644
--- a/src/patterns.jl
+++ b/src/patterns.jl
@@ -12,25 +12,7 @@ AbstractPattern
     └── IndexSetHessianPattern
 ```
 """
-AbstractPattern
-
-"""
-    myempty(P)
-
-Constructor for an empty pattern of type `P` representing a new number (usually an empty pattern).
-"""
-myempty(::P) where {P<:AbstractPattern} = myempty(P)
-myempty(::T) where {P,T<:AbstractTracer{P}} = T(myempty(P), true)
-myempty(::Type{T}) where {P,T<:AbstractTracer{P}} = T(myempty(P), true)
-
-"""
-seed(P, i)
-
-Constructor for a pattern of type `P` that only contains the given index `i`.
-"""
-seed(::P, i) where {P<:AbstractPattern} = seed(P, i)
-seed(::T, i) where {P<:AbstractPattern,T<:AbstractTracer{P}} = T(seed(P, i))
-seed(::Type{T}, i) where {P<:AbstractPattern,T<:AbstractTracer{P}} = T(seed(P, i))
+abstract type AbstractPattern end
 
 #==========================#
 # Utilities on AbstractSet #
diff --git a/src/tracers.jl b/src/tracers.jl
index daef5118..f2d2a1c2 100644
--- a/src/tracers.jl
+++ b/src/tracers.jl
@@ -1,3 +1,5 @@
+abstract type AbstractTracer{P<:AbstractPattern} <: Real end
+
 #====================#
 # ConnectivityTracer #
 #====================#
@@ -182,14 +184,41 @@ end
 # Utilities #
 #===========#
 
+"""
+  myempty(T)
+  myempty(tracer)
+  myempty(pattern)
+
+
+Constructor for an empty tracer or pattern of type `T` representing a new number (usually an empty pattern).
+"""
+myempty(::T) where {T<:AbstractTracer} = myempty(T)
+
+# myempty(::Type{T}) where {P,T<:AbstractTracer{P}}   = T(myempty(P), true) # JET complains about this
+myempty(::Type{T}) where {P,T<:ConnectivityTracer{P}} = T(myempty(P), true)
+myempty(::Type{T}) where {P,T<:GradientTracer{P}}     = T(myempty(P), true)
+myempty(::Type{T}) where {P,T<:HessianTracer{P}}      = T(myempty(P), true)
+
+"""
+  seed(T, i)
+  seed(tracer, i)
+  seed(pattern, i)
+
+Constructor for a tracer or pattern of type `T` that only contains the given index `i`.
+"""
+seed(::T, i) where {T<:AbstractTracer} = seed(T, i)
+
+# seed(::Type{T}, i) where {P,T<:AbstractTracer{P}}   = T(seed(P, i)) # JET complains about this
+seed(::Type{T}, i) where {P,T<:ConnectivityTracer{P}} = T(seed(P, i))
+seed(::Type{T}, i) where {P,T<:GradientTracer{P}}     = T(seed(P, i))
+seed(::Type{T}, i) where {P,T<:HessianTracer{P}}      = T(seed(P, i))
+
 """
     create_tracer(T, index) where {T<:AbstractTracer}
 
 Convenience constructor for [`ConnectivityTracer`](@ref), [`GradientTracer`](@ref) and [`HessianTracer`](@ref) from input indices.
 """
-function create_tracer(
-    ::Type{T}, ::Real, index::Integer
-) where {P<:AbstractPattern,T<:AbstractTracer{P}}
+function create_tracer(::Type{T}, ::Real, index::Integer) where {P,T<:AbstractTracer{P}}
     return T(seed(P, index))
 end