acceptodds
Under review as a conference paper at ICLR 2027

Learning Representations over Temporal Simplicial Complexes

17 views

Abstract

Temporal higher-order networks can be used to describe time-evolving complex systems in various domains, including biological, social, and collaboration networks, where groups of entities interact over time. Learning representations for these networks requires jointly modeling temporal evolution and higher-order topology while efficiently processing a continuous stream of interaction. Existing approaches typically rely on either clique-expanded graphs or hypergraphs: graph-based models offer computational efficiency but often fail to capture higher-order dependencies, whereas hypergraph-based models represent such dependencies explicitly at the expense of increased computational complexity and limited theoretical expressivity. To address these challenges, we introduce the Temporal Simplicial Complex (TSC), a formalism for representing time-evolving higher-order interactions as an event-driven sequence of simplicial complexes. We define TSC isomorphism and develop the Temporal Simplicial Weisfeiler-Lehman (TSWL) test to characterize the expressive power of temporal simplicial representation learning. Building on this framework, we propose the Temporal Simplicial State Space Model (), an online representation learning architecture that uses state space models to efficiently propagate information over the TSC. We establish an expressiveness bound for in terms of its state dimension, showing that its expressive power increases with the state dimension and reaches that of the TSWL test in the infinite-dimensional limit. Numerical experiments on dynamic higher-order interaction prediction across standard benchmark datasets show that achieves competitive predictive performance while delivering substantially faster training and inference compared to existing approaches.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Temporal Simplicial Complex, Dynamic Higher-Order Networks, State Space Models, Online Representation Learning, Topological Deep Learning

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_ype7OpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

The paper introduces the Temporal Simplicial State Space Model (TSSSM) utilising higher-order interactions between nodes to find evolving simplicial embeddings. This is built upon a foundation theory of Temporal Simpicial Complexes showing these satisfy an WL-like test for expressibility. Notationally, this is challenging to follow with many concepts to keep track of, but the theory is well-explaind to justify the TSSSM. The most innovative part of the work is to formalise the problem as a Embedding Reconstruction Problem, which generalises other topological reconstruction problems.

The TSSSM shows competitive performance among other methods designed to use higher-order interaction information such as FastHeP and CAT-Walk. While no method strictly dominates the others, they provided a marked improvement over clique-expansion methods especially for datasets where higher-order interactions are richest. The benefit of TSSSM over FastHeP and CAT-Walk is it's improvement in run-time with a much lower time per epoch.

The paper describes the simplest version of this admittedly complex model incorporating historical states through an additive weighting and single-layer linear aggregation. This paper provides the starting point for further investigation into the promising TSSSM.

Critical strengths

The paper does an excellent job of explaining the theory necessary for TSSSM (Sections 3-5). As someone new to the higher-order temporal interaction networks, I felt this work walked me through the key ideas to appreciate the purpose of these theorems. Unfortunately, the ICLR reviewing schedule means I do not have the time to fully work through proofs to my desired level, but this is something I plan to return to in future.

TSSSM shows competitive performance among other methods designed to use higher-order interaction information such as FastHeP and CAT-Walk, but at a much improved runtime per epoch. Given the paper focuses on the simplest version of TSSSM using additive weighting and single-layer aggregation, it provides an excellent foundation for further improvements for specific higher-order networks.

Critical weaknesses

Section 6 (Model Architecture) had a few vague statements which failed to fully explain the computational pipeline, for instance, simplex neighbour selection and the temporal encoder. These are listed as questions for the authors below. It noticeably lacked the level of detail seen in the rest of the theoretical work.

Section 7 (Numerical Experiments) also lacked details in places. For example, it is not clear how the TSSSM embedding output is used to predict higher-order links in the negative sampling experiment. Similarly, this is even less clear for the dynamic closure prediction which is relegated to a short paragraph. This feels a result of lack of space in an otherwise incredibly dense paper, rather than these details being unavailable.

Questions for authors
  • How are neighbouring simplices chosen as part of the sampling? Is this done uniformly over all possible neighbours, or is there a preference for simplices in B/C\mathbb{B}/\mathbb{C}? Changes in sampling here could offer improvements to the TSSSM training.
  • How is the temporal encoder defined in the decoder subsection of the Model Architecture? It was not clear what role this plays in the larger training. This could also help my understanding of the Numerical Experiments and the task-specific learnable transformation W\mathbf{W}.
3 comments

We thank the reviewer for their positive assessment of our work and appreciate the suggestions made regarding the explanations in Sections 6 and 7. We will incorporate these changes into the main manuscript to improve the clarity and readability of these sections.

Response to W1 :

We agree with the reviewer's assessment and will integrate detailed explanations for simplex neighbor selection, the temporal encoder, and other additional details into the main manuscript.

Response to W2 :

We appreciate the suggestion pointing out the lack of clarity in these parts and will add a detailed explanation for them.

For a query simplex (σ,t)(\sigma, t)—which may come from the link prediction task asking the model if simplex σ\sigma will be observed at some future time tt—we use Eq. 14 to generate its embedding for time tt. This uses the available state for simplex σ\sigma, the elapsed time Δt\Delta t between the last update of σ\sigma and time tt, and the states associated with its neighbors. We then apply a linear transformation to produce a scalar score from this embedding, and the model is trained to output higher scores for queries associated with positive samples and lower scores for those associated with negative samples. Because the embedding requires states from σ\sigma and its neighbors, and negative samples are generated with partially random combinations of nodes, we can encounter a simplex σ\sigma in the query that has never been observed before. For these simplices, the model provides a default 0\mathbf{0} state vector and a very high Δt≈1011\Delta t \approx 10^{11}, along with the states of its neighbors if they have been observed. In this case, the embeddings are primarily derived from the components aggregated from the neighbors and the temporal embedding.

Although this might give the impression that a default 0\mathbf{0} or a very high Δt\Delta t signals to the model that the sample is negative, this is ruled out in the strong inductive and inductive settings. In those settings, positive samples also include simplices that were not observed during training and thus have a 0\mathbf{0} state vector until their first encounter in the test split.

Similarly, for closure prediction at time tit_i and for a candidate triplet σ=\sigma = {a,b,ca, b, c}, we calculate the score for time ti+1t_{i+1} using the same ingredients: the state at tit_i, the elapsed time Δt=ti+1−ti\Delta t = t_{i+1} - t_i, and the neighbors' states. A higher score indicates the closure or formation of a closed triangle, whereas a lower score indicates an open triangle or hole.

Response to Q1:

For neighbor sampling, we implemented two policies: recency and uniform. Recency-based sampling selects the NN most recent neighbors, whereas uniform sampling draws uniformly from all neighbors. In our numerical experiments, we present results using recency-based sampling. We preferred this approach over uniform random sampling because most standard temporal graph networks adopt it. We will add this detail more clearly to the main manuscript.

Response to Q2:

Our work uses the standard Time2Vec temporal encoder with logarithmic scaling of the input xx to form an embedding xt\mathbf{x}_t of the form xt=Time2Vec(log⁡(1+x))\mathbf{x}_t = \text{Time2Vec}(\log(1+x)). This encoder primarily aids the model in generating embeddings for a given time tt.

Specifically, given a simplex that was last updated at tit_i and an embedding that is required for time t>tit > t_i, the model uses the simplex state from time tit_i, the elapsed time Δt=t−ti\Delta t = t - t_i, and the neighbor states of the simplex to generate the embedding for time tt.

Using this temporal embedding, the states of the simplex and its neighbors, and a transformation matrix WW, the model generates a scalar score for predictive tasks or a vector score if multi-class classification is required.


Finally, we thank the reviewer again for their efforts in providing this review, and we hope the explanation helps clarify their concerns. We would be happy to respond to any additional concerns or queries they may have regarding the manuscript or the submitted response.

Thank you for your rebuttals to me and the other reviewers. I will continue to follow discussions elsewhere and I will keep my positive rating.

We sincerely appreciate the reviewer’s continued support and positive assessment. Thank you for your time, thoughtful feedback, and constructive engagement through the review process.

Reviewer_WdqZOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces Temporal Simplicial Complexes (TSCs), an event-driven formalism for time-evolving higher-order interactions that is closed under inclusion and supports insertion, deletion, and update events. It defines TSC isomorphism and a Temporal Simplicial Weisfeiler–Lehman (TSWL) test, then introduces Temporal Simplicial Networks (TSNs) and derives an online state-space model, TS3M, through an Embedding Reconstruction Problem (ERP): each simplex maintains a finite-dimensional state updated by a HiPPO-style linear ODE. Experiments cover higher-order link prediction on seven datasets (transductive, weakly inductive, strongly inductive) and a new dynamic simplicial closure prediction (DCP) task. The central claim is that TS3M matches the strongest baselines in predictive performance while being substantially faster in both training and inference, and scales to continuous event streams.

Critical strengths
  1. TSC/TSWL provides a theoretical language that temporal higher-order learning previously lacked. The paper does not simply transplant SWL onto a time axis; it first formalizes temporal higher-order interactions as an event-driven simplicial complex with closure, then defines isomorphism and color refinement. This gives a writable criterion for questions—whether two temporal higher-order systems are the same, and whether a model can distinguish them.

  2. ERP and TS3M move "online higher-order representation" from concept to implementable architecture. The paper adopts a projection perspective: it casts representation learning as a projection problem onto an orthogonal polynomial basis and derives a linear ODE that can be solved incrementally. The derivation chain is complete and connects cleanly to the existing SSM literature.

Critical weaknesses
  1. Figure 1 is an important first step, but is not yet sufficient to fully support the efficiency claim. Figure 1 can support the statement that "under the authors' experimental setup, TS3M has lower per-epoch training time." It does not yet support the full claim in the abstract that training and inference are both substantially faster:
  • Per-epoch time is not total training cost, and inference is not measured. Models may differ in epoch count, batch size, and early-stopping policy, so total wall-clock to a target AUC would be more convincing; and the inference speedup claimed in the abstract has no corresponding data in Figure 1 or the main text.
  • Figure 1 gives only relative values, and the Appendix H ablation suggests the bottleneck may not be the state update. Absolute numbers, error bars, and a profiling breakdown into data loading/sampling, encoder, state update, and decoder would make the source of the gap clearer; the fact that per-epoch time increases by only 10.22% on average (0.00% on Email-Enron) when the state dimension D grows from 16 to 1024 also needs explanation.
  • No scaling experiment. Curves of runtime versus number of events, hyperedge size, state dimension, and number of sampled neighbors would be more convincing than a single cross-dataset plot.
  1. The closure definition raises an important space-scaling question for large hyperedges. The TSC requires closure under inclusion: inserting an m-node simplex also inserts all of its nonempty faces (Section 2), whose number grows exponentially with m. This raises a space-scaling question that the paper does not yet answer:
  • The number of simplices after closure, and the associated memory, are not reported. Table 4 gives only the number of hyperedges |E|, the number of nodes, and the number of timestamps, but not |S(τ)|; TS3M maintains a D-dimensional state per simplex (M(τ) ∈ ℝ^{|S(τ)|×D}), so even with D fixed, total state memory grows exponentially with |S(τ)|. Together with features, adjacency, gradients, and optimizer states, this can create non-trivial GPU memory pressure for large hyperedges. Figure 12 shows event orders up to ~25 for Email-Eu/NDC, so large hyperedges do occur, but the paper does not explain how they are handled in the implementation.
  • Neighbor sampling reduces computation, not storage. The N_s sampling in Section 6 bounds the active pool per update. If the implementation uses lazy allocation, it should explain whether boundary/co-boundary neighborhoods remain complete, whether the closure axiom still holds, and how the processed object relates to the TSC defined in Section 2.

Both concerns are answerable with additional experiments and clarifications. But until that evidence is provided, the efficiency claim in the abstract and the usability of the model on realistically large higher-order data remain unsupported.

Questions for authors
  1. What is the measurement protocol for Figure 1? Please provide total training time, wall-clock to a target AUC (including early stopping), and inference latency/throughput, together with hardware, batch size, epoch count, and whether the baselines were re-run and tuned under the same protocol.

  2. For each dataset, how many simplices are actually materialized after closure, ∣S(τ)∣|\mathbb{S}(\tau)|? What are the maximum/mean hyperedge sizes and the peak CPU/GPU memory?

  3. For an mm-node hyperedge, do you actually insert all nonempty faces? If yes, how is memory handled for large events? If not, how are the closure axiom in Section 2 and the boundary/co-boundary neighborhoods used by the decoder preserved? Please describe state allocation, lazy materialization, and eviction/compression.

  4. Add a large-hyperedge stress test (public or synthetic data with hyperedges of size 10, 20, 50) and report runtime, memory, and simplex count as functions of hyperedge size; also extend the efficiency evaluation from per-epoch time to total wall-clock to a fixed AUC target.

If the rebuttal can address the issues I raised and alleviate my concerns about the two weaknesses mentioned above, I will raise my rating.

7 comments

We thank the reviewer for their critical assessment and for highlighting the lack of sufficient evidence supporting some of our claims, as well as the missing implementation details regarding how we address the exponential memory growth associated with larger hyperedge sizes. We have addressed these concerns in detail below.


Response to W1:

We agree with the reviewers that Fig. 1, in isolation, did not provide sufficient evidence to substantiate our efficiency claims. Accordingly, following their suggestions, we have conducted a more comprehensive runtime analysis and profiling of the model.

Following the reviewer's suggestion, we have added inference time and total training time comparisons between TS3MTS^3M and the fastest hypergraph model among the baselines across three representative datasets in Table C. To ensure a fair comparison, all experiments were conducted under identical settings, including batch size, early-stopping policy, and maximum number of epochs, while maintaining the AUC values reported in the HLP results in Table 1 of the main manuscript.

Table C provides additional evidence supporting our claims regarding reduced inference time. This improvement can be attributed, in part, to the model's efficient embedding generation mechanism. Specifically, for any queried simplex, the model constructs its final embedding using the states of 1+NB+NC+N↑+N↓1+N_B+N_C+N_{\uparrow}+N_{\downarrow} simplices, which are directly retrieved from memory, while the temporal embedding of the target timestamp is obtained through a single linear transformation. Consequently, the overall computational complexity per query is O(D×(NB+NC+N↑+N↓)+dtime)\mathcal{O}(D \times (N_B+N_C+N_{\uparrow}+N_{\downarrow})+d_{\text{time}}).


Table C : Training and testing runtime comparison (in seconds) across datasets.

MetricDatasetFastHePTS$^3$M
Per-epoch Train Time (s)CB177.766.9
NDC32.010.1
EEN6.64.0
Total Train Time (s)CB3190.31059.50
NDC262.272.0
EEN146.385.6
Test Time (s)CB18.56.0
NDC3.21.0
EEN0.670.4

Note that CB contains approximately 260K events with a maximum simplex order of 24, EEN contains 11K events with a maximum simplex order of 16, and NDC contains 50K events with a maximum simplex order of 23. Figure 12 in Appendix I.2 illustrates the distribution of event orders across these datasets.

Although we acknowledge that, even with these additional results, the evidence remains largely empirical, we will clarify that our efficiency claims are limited to the experimental settings considered in this work.

Additionally, we provide a comprehensive profiling of TS3MTS^3M across these datasets in Table D, breaking down the time consumed by different components of the training process. This profiling highlights several important observations. In particular, negative sampling and neighbor sampling account for a substantial portion of the per-epoch training time, and their computational costs are not directly affected by the state dimension.


Table D: Time profiling breakdown across datasets (average time per epoch; all values are in seconds).

Component / BlockEENNDCCB
loss_and_backprop1.572.7644.75
negative_sampling0.750.978.51
update_states_complex0.741.115.72
scoring_function0.330.492.62
feature_assign0.290.432.63
neighbor_sampling0.160.202.29
data_loading0.030.050.30
other_overhead0.010.020.10
Total Epoch Time3.886.0866.92

Motivated by this observation of Table D, we further profiled the model on the EEN dataset with increasing state dimensions to investigate why the per-epoch training time showed no apparent change. The results are reported in Table E, which reveals a slight increase in runtime as the state dimension grows; however, the increase is only a few microseconds. Unlike the other datasets, which contain a larger number of events, EEN has a relatively small number of events. Consequently, the additional computational overhead introduced by increasing the state dimension is less pronounced in its overall per-epoch training time.


Table E: Scaled time profiling breakdown for the EEN dataset across varying state dimensions (average time per epoch; all values are in seconds).

Time Component16-dim32-dim64-dim128-dim256-dim512-dim1024-dim
Loss and Backprop1.421.421.461.491.531.731.70
Negative Sampling0.710.710.710.720.730.720.72
Update Timestamp Complex0.680.680.680.690.680.680.71
Scoring Function0.320.320.320.330.320.330.35
Feature Assign0.270.280.280.280.270.280.27
Neighbour Sampling0.140.140.140.140.140.140.14
Data Loading0.030.040.040.030.030.040.04
Other Overhead0.010.010.010.010.010.010.01
Total Epoch Time3.583.603.643.693.713.933.94

As suggested by the reviewer, we have added scaling experiments to evaluate the model's computational efficiency. To analyze runtime with respect to the number of events, we used three datasets: CB, NDC, and EEN.

To measure runtime across different event-stream lengths, we trained TS³M with a 128-dimensional state for a maximum of 30 epochs, using early stopping with a patience of 5 epochs, on subsets of these larger datasets. Specifically, for each setting, we selected an initial subset of events (e.g., the first 10K events) and applied the standard train/validation/test split, resulting in a final model trained on 7K training events.

Table F reports the mean runtime over five independent runs for each data point. Regarding runtime scaling, we observe an approximately linear increase in training time as the event-stream length grows, although the total training time exhibits some variations. This is because the total training time depends on both the per-epoch runtime and the total number of epochs required for convergence, which can vary across different dataset configurations.

This variation is expected because each event-stream length corresponds to a different dataset variant. For instance, a model trained on 20K events must learn the dynamics of a longer event stream than one trained on 10K events. Conversely, reducing the number of events also reduces the amount of training data, which may influence the model's convergence behavior and susceptibility to overfitting. However, since these experiments were conducted solely to analyse runtime scaling, we do not draw any conclusions regarding the model's learning or convergence characteristics from these results.


Table F: Total train time across varying maximum numbers of events for CB, NDC, and EEN datasets (values in seconds).

DatasetMax EventsValue (s)
CB10K45.84
CB21K62.35
CB40K130.86
CB80K422.51
CB158K901.71
CB183K1171.2
NDC10K45.84
NDC20K62.35
NDC32K130.86
EEN3.5K28.79
EEN7.7K51.035

To evaluate scalability with respect to hyperedge size, we randomly subsample nodes from hyperedges that exceed a predefined maximum size. For example, given an event {a,b,c,da,b,c,d}, if the maximum size is set to 3, we randomly sample three nodes from the event, thereby reducing it to a hyperedge of size 3.

We report the per-epoch training time under these settings because each maximum-size configuration results in a fundamentally different dataset being presented to the model. Consequently, reporting the overall runtime or total training time would also capture variations in model convergence speed across these different dataset variants, making it difficult to isolate the computational cost associated with hyperedge size. Table G reports the runtime and peak GPU memory consumption under these settings, demonstrating the computational efficiency of our model as hyperedge size increases across these datasets. Together with the strong predictive performance of TS3MTS^3M, these results highlight the effectiveness of our implementation strategy for modeling higher-order event streams.

Table G: Time profiling breakdown across varying maximum edge sizes (runtime values in seconds; GPU memory in GB).

Dataset NDC:

Time ComponentMax Edge = 3Max Edge = 5Max Edge = 10Max Edge = 15Max Edge = 25
loss_and_backprop3.953.883.994.114.43
negative_sampling2.792.892.812.882.83
update_timestamp_complex1.121.101.121.091.14
feature_assign0.510.520.560.590.66
scoring_function0.510.460.490.480.49
neighbour_sampling0.330.370.410.430.47
data_loading0.080.080.080.080.08
other_overhead0.020.020.020.020.02
Peak GPU Memory (GB)0.860.931.091.241.56
Total Mean Epoch Time9.309.319.479.6810.13

Dataset CB:

Time ComponentMax Edge = 3Max Edge = 5Max Edge = 10Max Edge = 15Max Edge = 25
loss_and_backprop32.1836.1940.5243.4346.18
negative_sampling8.228.188.629.748.70
update_timestamp_complex5.585.755.527.215.65
scoring_function2.662.662.613.232.65
feature_assign2.252.312.362.802.66
neighbour_sampling1.211.311.681.992.40
data_loading0.280.270.290.310.32
other_overhead0.090.100.100.120.10
Peak GPU Memory (GB)1.081.932.723.203.63
Total Mean Epoch Time52.4856.7761.7068.8468.67

Additionally, we have already presented the per-epoch train time of TS3MTS^3M under different numbers of sampled neighbors and state dimensions in Appendix H in the main manuscript to provide insight into runtime analysis with respect to these hyper-parameters.

Therefore, together with the additional tables presented, we hope to further strengthen the efficiency claims made in the main paper. All of these additional results will be included in the Appendix.

Reviewer_XfuxOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper models time-evolving group interactions as temporal simplicial complexes and defines a temporal simplicial Weisfeiler–Lehman (TSWL) test to characterize expressivity. It then derives TS^3M, a state-space model that summarizes each simplex's embedding history with HiPPO polynomial projections. On seven datasets from Benson et al., TS^3M is competitive with temporal hypergraph methods (CAT-Walk, FastHeP) on hyperedge prediction while training much faster. It is also evaluated on simplicial closure prediction.

Critical strengths
  • The paper demonstrates good training efficiency and performance compared to baseline
  • The paper extends simplicial WL theory to continuous-time event streams.
Critical weaknesses
  • The theorems require an injective encoder and the full neighbourhood structure. The experiments, however, sample no upper or lower adjacencies, and the paper does not show that its encoder is injective.
  • The step from polynomial projections to TSWL equivalence relies on L2L^2 completeness, which cannot distinguish histories that differ only at a single instant, such as an update exactly at the query time.
  • Every group event implies all of its faces, so an event involving k+1k+1 nodes has 2k+1−22^{k+1}-2 faces, and several datasets contain events with about 20–25 nodes. The paper reports only per-epoch training time.
Questions for authors
  • Every event implies all of its faces. How many simplices are actually stored for each dataset, and what are the preprocessing time, peak memory and inference time?
  • Can you report closure-prediction AUCs with standard deviations, including CAT-Walk, FastHeP and HIT? Please also explain how candidate triplets and negatives are constructed.
3 comments

We would like to thank the reviewer for their valuable insight in our work, and would like the address their concerns below:


Response to W1 :

In Theorem 1, we present the conditions required to design a TSN that matches the expressivity of the TSWL test. This breaks the expressivity requirements of a TSN into two modules: the structural encoder and the sequence encoder. While the literature on designing structural encoders -- using convolutions, attention, and message-passing architectures to achieve varying levels of expressivity -- is well established, our work focuses on integrating structural and temporal encoding to form an online learning architecture, TS3MTS^3M, and providing a state-dimension-based expressivity analysis under the stated assumptions. This conditional characterization is one of our main theoretical results. However, using a complete neighbourhood structure and an injective structural encoder for increased expressivity comes at a higher computational cost. Therefore, for an efficient implementation, we have used a simple encoder and neighborhood sampling.

However it should be noted that, TS3M{TS^{3}M} supports all four neighborhood types, namely, upper, lower, boundary, and co-boundary neighbors, and sampling sizes as configurable hyperparameters. In the reported experiments, we disabled upper- and lower-neighbor sampling because enabling them did not provide additional predictive benefit on the evaluated link-prediction tasks ( a representative per epoch training time and validation AP is provided in Table A ). These settings can be changed to include all four neighborhood types and, where computationally feasible, to use their full neighborhoods. Thus, the choice made in the experiments is not an architectural restriction.

Moreover, the TSN framework is compatible with more expressive structural encoders, including nonlinear encoders in the state update of Equation 11, at potentially higher computational cost. We agree that the evaluated configuration, which uses a simple encoder and sampled neighborhoods, has not been shown to satisfy the injectivity and full-neighborhood conditions of Theorem 1. Its predictive performance is therefore an empirical evidence showcasing its ability to effectively model higher-order event stream, rather than a claim that this particular configuration attains TSWL-level expressivity. We will make this distinction explicit in the manuscript.

Response to W2 :

We agree with the reviewer that completeness of the polynomial basis distinguishes trajectories in L2([0,τ],μ)L^2([0,\tau],\mu), as stated in Theorem 2, and therefore does not distinguish differences confined to a zero-measure interval. In particular, an embedding change occurring only at the query endpoint τ\tau is not captured by the projection over [0,τ][0,\tau]. Which aligns with the statement made in the theorem that it can only distinguish trajectories in L2([0,τ])L^2([0,\tau]), but we would add remark to convey this more clearly. Specially we will add a remark making the zero-measure limitation explicit and qualify Theorem 2's final implication to TSWL: it applies to compared embedding histories whose distinctions induce differences on a set of positive μ\mu-measure within the projection interval.

It is worth noting, however, that the abstract ERP projection’s limitation regarding zero-measure differences should be distinguished from the discrete updates in Equations 12–13 used to implement TS³M. In the event-driven implementation, zero-order-hold (ZOH) interpolation and the event-processing order make the updated state available to a query made after the updates at time tt have been processed. This mitigates the practical endpoint issue and prevent the model from inheriting this limitation.


Table A : Per-epoch training time and Validation AP for TS3MTS^3M configuration with upper/lower adj. neighbours and one without.

DatasetMetricTS3MTS^3M with Upper/Lower Adj.TS3MTS^3M without Upper/Lower Adj.
EEUPer-epoch time (s)185140
Validation AP0.9730.969
EENPer-epoch time (s)43
Validation AP0.9570.952
CHSPer-epoch time (s)5945
Validation AP0.9680.967

Response to W3 and Q1:

While the theoretical TSC requires adding all sub-faces when a new event occurs to maintain strict closure, we relax this requirement in our implementation for memory efficiency. Specifically, our implementation operates in two modes: for datasets with a simplex order K<5K < 5, we add all sub-faces of the simplices, whereas for datasets with a higher order K≥5K \ge 5, we store only the boundary faces associated with the event. This strategy reduces the computational and storage complexity from 2k+1−22^{k+1}-2 down to k+1k+1 for a kk-simplex, preventing combinatorial explosion while preserving the topological structure and maintaining competitive predictive performance.

For brevity, we present the peak GPU memory, inference time, and pre-processing time (the time required to generate boundary/coboundary adjacency lists and simplex-to-vector IDs) for three representative datasets (one with K<5K < 5 and two with K>5K > 5) in Table B.

A complete empirical analysis across multiple datasets and a section dedicate to this explanation is incorporated into the appendix of the fiinal manuscript.

Response to Q2:

We value the reviewer's suggestion to add hypergraph-based baselines to DCP. However, the closure-prediction experiment was designed to compare a simplicial-based model with clique-expanded graph models on a task that explicitly depends on higher-order closure. We therefore focused the initial DCP evaluation on these baselines; the HLP experiments separately compare against temporal hypergraph models. We agree that CAT-Walk, FastHeP, and HIT would provide a useful additional comparison for DCP. We cannot report verified results for these models within the rebuttal period, but we will add them to the revised manuscript if the experiments can be completed. Accordingly, we have limited our DCP conclusions to the baselines actually evaluated.

Regarding the candidate triplets, positive samples are defined as triplets that close into a 2-simplex (forming a filled triangle) at the next timestamp. Conversely, negative candidates are open triangles (holes) persisting up to the next timestamp; for instance, a sequence of interactions involving {a,b,xa, b, x} at t1t_1, {b,c,qb, c, q} at t2t_2, and {c,a,zc, a, z} at t3t_3 forms a topological hole {a,b,ca, b, c} for t>t3t > t_3 until an event containing {a,b,ca, b, c} as a subset occurs at some time tkt_k. Thus, {a,b,ca, b, c} can be used as a negative candidate up to time tk−2t_{k-2}, and becomes a positive triplet at time tk−1t_{k-1}. Meanwhile, for an event at time tit_i that contains a 2-simplex such as {p,q,rp, q, r} as a subset, the triplet {p,q,rp, q, r} can be used as a positive candidate at time ti−1t_{i-1}, as it will close to form a filled triangle at tit_i.

Thus, the state of {a,b,ca, b, c} at tk−2t_{k-2} is trained to predict an open triangle at tk−1t_{k-1}, whereas the state of {p,q,rp, q, r} at ti−1t_{i-1} is trained to predict a closed triangle at tit_i.


Table B : Computational complexity metrics including inference time, peak memory, and pre-processing time across datasets with different simplex order thresholds.

MetricCHS (K=4K = 4)CB (K=24K = 24)NDC (K=23K = 23)
Total Events (×103\times 10^3)17226050
Unique Simplices in Memory (×103\times 10^3)8.7767.97.2
Inference Time (sec)461
Peak Memory, Test (GB)0.251.210.48
Peak Memory, Train (GB)0.783.631.56
Pre-Processing Time (sec)2292

We again appreciate the efforts put by the reviewer into studying our work and hope our response has addressed their concerns sufficiently. Moreover, we are happy to address any additional concerns the reviewer might have regarding our response or the manuscript.

Finally, we kindly request the reviewer to reconsider their score if they find our response satisfactory.

Dear Reviewer,

We sincerely appreciate your time and effort in reviewing our submission. We would be grateful if you could kindly take a moment to review our rebuttal responses and share any further thoughts or concerns you may have. Your feedback would be valuable in helping us clarify any remaining issues.

Thank you again for your time and consideration.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.