Why Represent Event Types Explicitly?
A counting process records how many events have occurred by each time. In competing-risks and multi-state data, however, the type of event is often as important as its timing. A first event might be one of several mutually exclusive causes; in a multi-state history, different transitions may be counted separately. There are two closely related ways to retain this information: attach a mark to each event, or keep a separate count process for each type.
The representations are not automatically interchangeable in every data structure. Their clean equivalence relies on a simple event history in which each event contributes one unit to exactly one type. If a process has a jump larger than one, or different components jump simultaneously, the total-count identity still holds, but an ordinary sequence of distinct event times with one mark per event may not represent the history without extra conventions.
Marks and Type-Specific Components
Suppose one subject has a simple event history on the observation interval \([0,\tau]\). Write its event times in strictly increasing order as \(T_1,T_2,\ldots,T_{N(\tau)}\), and let \(J_j\in\{1,\ldots,K\}\) denote the type of event at \(T_j\). Here the finite set \(\{1,\ldots,K\}\) is the mark set. Each event has exactly one mark, so the types are mutually exclusive for an event and the mark is observed for every event.
For each type \(k\), count only events carrying that mark. The resulting component process \(N_k(t)\) is the number of type-\(k\) events observed by time \(t\). This definition gives an exact relationship between the total count and its components.
The first equation filters the ordered event list by mark. For the second, each event contributes one to exactly one component because its mark belongs to exactly one category. Adding the components therefore counts every event once and no event twice. This is a pathwise identity: it holds for each observed history, not merely on average.
The same idea works when the data are introduced as component processes \(N_1(t),\ldots,N_K(t)\). One may define the total by \(N_{\bullet}(t)=\sum_{k=1}^{K}N_k(t)\). In general its jump size is the sum of the component jump sizes at that time. If each component is simple, that jump size equals the number of components that jump at that time. It equals either zero or one only when at most one component jumps at any given time.
Worked Example: From Event Marks to Component Counts
Consider a hypothetical subject followed through day 12. The subject has four events at days 2, 5, 8, and 11, with marks \(1,2,1,3\), respectively. Find the type-specific counts at day 10 and verify the total-count identity.
There are three possible types, and each listed event has one mark. By day 10, the included events are at days 2, 5, and 8. Type 1 occurs at days 2 and 8, type 2 at day 5, and type 3 has not yet occurred. Thus \(N_1(10)=2\), \(N_2(10)=1\), and \(N_3(10)=0\).
The total marked count is also \(N(10)=3\), since three events have occurred by day 10. The component counts preserve the type composition of that total; at day 12, the counts are \((2,1,1)\), which sum to four.
When Can Components Be Written as One Marked Sequence?
A sequence of distinct event times with one mark per event is an appropriate representation when the aggregate history consists of separate, unit-sized events. For component processes, sufficient conditions are that each component is simple and that no two components jump at the same time. Under these conditions, every aggregate jump is of size one, so all component event times can be sorted into one strictly increasing list. The mark at each listed time is the index of the component that jumped.
Both conditions matter. Simplicity within each component rules out a single component contributing two or more events at one instant. No simultaneous jumps across components rules out multiple components contributing at the same instant. Without both conditions, the total count is still the sum of the component counts, but the distinct-time, one-mark-per-event representation requires modification.
Worked Example: Simultaneous Component Jumps
Suppose three hypothetical component processes are simple. At time 4, components 1 and 3 each jump by one; at time 7, only component 2 jumps by one. Calculate the total jumps and explain whether the aggregate history is simple.
At time 4, \(\Delta N_1(4)=1\), \(\Delta N_2(4)=0\), and \(\Delta N_3(4)=1\). Therefore,
At time 7, the component jumps are \(0,1,0\), so \(\Delta N_{\bullet}(7)=0+1+0=1\). The total process is not simple, because its jump at time 4 is two. It is incorrect to describe that jump as a single event with one type mark: two component events occurred at the same time. Keeping the vector of component counts records the history without imposing an ordering between those simultaneous events.
Worked Example: A Multiple Jump Within One Component
Consider two component processes. At time 3, component 1 jumps by two, while component 2 does not jump. At time 6, component 2 jumps by one. Find the total jumps and assess whether sorting component jump times alone would produce a simple marked sequence.
At time 3, the component jump vector is \((2,0)\), so the total jump is \(2+0=2\). At time 6, it is \((0,1)\), so the total jump is \(0+1=1\). Although no two components jump simultaneously, component 1 is not simple: its jump at time 3 has size two. Consequently, the total has two units recorded at one time, not two events at distinct ordered times. A list containing the distinct times 3 and 6 with one mark each would lose one of the two units at time 3. A representation that records multiplicity or allows multiple event records with the same time would be needed instead.
Justification of the Component-Sum Identity
The identity can be checked event by event. Under the simple marked-history assumptions, let the total number of events by time \(t\) be \(m=N(t)\). For each event \(j\leq m\), exactly one indicator \(\mathbf{1}(J_j=k)\) equals one, and the other \(K-1\) indicators equal zero. Thus the indicators for that event sum to one. Summing over all \(m\) events yields the total count.
For component processes defined directly, no event-by-event mark argument is required for the total identity: the total is their sum by definition. Taking the difference between its value just after \(t\) and just before \(t\) gives the jump formula. If all components are simple, each summand in that jump formula is zero or one, so the total jump is the number of jumping components. If any component can have a larger jump, its jump size—not merely whether it jumped—must be included.
Choosing a Representation and Checking the Data
An event-level marked representation is natural when the observational unit is a sequence of distinct event occurrences and each occurrence has one recorded category. A vector of component processes is often clearer when the analysis needs type-specific counts directly or when events of different types can occur at the same recorded time. These are alternative data representations, not different definitions of what an event is.
| Feature | Marked event sequence | Component count vector |
|---|---|---|
| Basic record | Event time and one mark per event | One count process for each type |
| Useful when | Events are distinct, unit-sized, and typed | Type-specific totals or simultaneous jumps must be retained |
| Potential issue | Tied times or multiplicity need explicit handling | Components alone may not encode an ordering among simultaneous events |
A practical check is to compare the total count with the sum of the component counts at several times, including immediately before and after observed jumps. Also inspect jumps rather than only final totals: equal end-of-follow-up totals do not reveal whether intermediate jumps were simultaneous or larger than one. Confirm that each event has exactly one valid type if using an exclusive-mark representation. If an event can carry several labels, or its type is missing, the simple partition argument no longer applies as stated.
The representation itself does not establish a probabilistic model for event timing or type. In particular, the count identity alone gives no claim about independence, event rates, or causal mechanisms. Those questions require additional assumptions and methods. Here the goal is the precise bookkeeping structure on which later stochastic-process calculations can be built.
Common Mistakes and Limitations
- Counting jumping components instead of jump size. In general, the total jump is \(\sum_k\Delta N_k(t)\). It equals the number of components that jump only if each component is simple.
- Assuming no simultaneous jumps is sufficient for a simple marked sequence. It is not: a component can jump by two at a time when no other component jumps. Simplicity of every component is also required.
- Treating a simultaneous pair as one event with one mark. That loses information when two components each contribute a count. Preserve both component jumps or specify a representation that records multiplicity and tied times.
- Using component counts when event ordering matters. Component counts show how many events of each type have occurred by time \(t\), but simultaneous jumps do not encode an ordering among events at that time.
These representations are bookkeeping devices. A marked sequence can be compact and informative under the required conditions; a component vector handles a broader range of jump structures directly. Neither representation, by itself, resolves ambiguities in the underlying event definition or supplies assumptions about how events arise.
Check Your Understanding
Answer each question, then compare your reasoning with the brief solutions.
- A simple marked history has event marks \(2,1,2,3\) by time \(t\). What are the type-specific counts and their total?
- Two simple components both jump by one at the same time. What is the total jump, and is the total process simple at that time?
- One component jumps by three while all other components remain unchanged. What is the total jump, and how many components jumped?
- What conditions allow component histories to be combined into a single strictly ordered event-time sequence with one mark per event?
Solutions. (1) The component counts are \(N_1(t)=1\), \(N_2(t)=2\), and \(N_3(t)=1\); their sum is \(1+2+1=4\), the total number of events. (2) The total jump is \(1+1=2\), so the total is not simple at that time. (3) The total jump is three, although only one component jumps; the total jump is the sum of jump sizes, not the number of jumping components. (4) Every component must be simple, and no two components may jump simultaneously. Then each aggregate jump is one, and its component index supplies the event mark.