## 4 Deep Learning-Based Minimum Timeline Cover  
To solve Problem 2 in a data-driven fashion, we propose integrating DL techniques to derive actionable insights from temporal graph data, aiming to optimize decisions dynamically over time. To compute the function as in Equation (1), we can use a pointer mechanism as described in [37]. The pointer mechanism enables the model to _point_ directly to elements within the input sequence, rather than generating new output tokens. This is achieved by learning a probability distribution over the input positions, effectively guiding the network to select certain elements based on their relevance to the task. As a result, PNs can dynamically adapt their outputs based on the input structure, making them highly effective for problems where the order and relationships between elements are essential, such as in graph-based CO tasks. Thus, the key goal is to transform the temporal graph's data into a format that a PN can effectively utilize to make informed decisions. This involves embedding the graph data into a numerical form that captures both the structural and temporal dynamics, and then using these embeddings to drive a PN decision-making process. For background on the DL models adopted, please refer to Appendix A. Among the possible solutions for temporal graph embeddings, we argue that the best choice for solving MinTCover in a data-driven fashion is represented by models that can scale to instances of different sizes and complexities. Moreover, considering that there exists a trade-off between the amount of processed information and scalability, we believe that, to find an activity timeline, it is better to focus on the temporal distribution of nodes within the entire span, with respect to building a timestamped node representation considering the entire network topology at a given point in time. According to these assumptions, we designed a DL approach enforced with an iterative procedure to solve the MinTCover problem in a data-driven fashion. The procedure is broken down into the following stages, better highlighted in Figure 2:  
1. Node Representation: Firstly, each node is represented by computing the degree of that node in the temporal graph, injecting information on the topology of the network at each timestamp (bottom-left part of Figure 2). 2. Graph Embedding: The process begins with the embedding of the temporal graph, where node features are encoded at each timestamp. This captures the topology of each graph over time, mainly considering local features (bottom-right part of Figure 2). 3. Temporal Aggregation: Nodes' sequences through time are defined and processed to transform the representation of each node in each timestamp considering the entire sequence (top-left part of Figure 2). 4. Pointer Mechanism: A pointer mechanism uses these embeddings across time, producing an output that encapsulates the temporal evolution of node features (top-right part of Figure 2). Iterative Adjustment: The output of the pointer mechanism includes the interval to be assigned to each node; however, they may not be a valid cover. Thus, an iterative algorithm is proposed to adjust the intervals to grant that the output is a coverage (top part of Figure 2). Figure 2: Schema of the DL-based method for the MinTCover problem. The input of the model is represented by a graph \(G=(V,E)\) in the bottom-left part of the image. Information then flows following the direction of the arrows. The first stage is node representation. The input graph is split into temporal snapshots (one for each timestamp \(t_{i}\), where each snapshot always contains all the nodes, but only contains the edges \((u,v,t)\) such that \(t=t_{i}\)). For each node \(v_{i}\) in each snapshot graph, its degree is computed as a feature, which in the picture is reported as \([deg(v_{i})]\).