SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Complement Operators:  $\mathcal{C}_e$  and  $\mathcal{C}_t$ . The aim of  $\mathcal{C}_e$  is to identify the complement of query set  $[[q]]$  such that  $[[\neg q]] = \mathcal{V} \backslash [[q]]$ , while  $\mathcal{C}_t$  aims to calculate the complement  $[[\neg q]] = \mathcal{T} \backslash [[q]]$  by the time parts. Suppose that  $\mathbf{V}_q = (\pmb{q}_f^e, \pmb{q}_l^e, \pmb{q}_f^t, \pmb{q}_l^t)$ , we define the complement operator  $\mathcal{C}_e$  and  $\mathcal{C}_t$  as:
$$
\mathcal {C} _ {e} \left(\mathbf {V} _ {q}\right) = \left(f _ {\text {n o t}} ^ {e} \left(\boldsymbol {q} _ {f} ^ {e}\right), \mathbf {N O T} \left(\boldsymbol {q} _ {l} ^ {e}\right), \boldsymbol {q} _ {f} ^ {t}, \boldsymbol {q} _ {l} ^ {t}\right), \quad \mathcal {C} _ {t} \left(\mathbf {V} _ {q}\right) = \left(\boldsymbol {q} _ {f} ^ {e}, \boldsymbol {q} _ {l} ^ {e}, f _ {\text {n o t}} ^ {t} \left(\boldsymbol {q} _ {f} ^ {t}\right), \mathbf {N O T} \left(\boldsymbol {q} _ {l} ^ {t}\right)\right) \tag {4}
$$
where  $f_{\mathrm{not}}^e (\pmb {q}_f) = \tanh (\mathbf{MLP}_3([\pmb {q}_f^e;\pmb {q}_l^e ]))$ ,  $f_{\mathrm{not}}^{t}(\pmb{q}_{f}^{t}) = \tanh (\mathbf{MLP}_{4}([\pmb{q}_{f}^{t};\pmb{q}_{l}^{t}]))$  are feature negation functions, two  $\mathbf{MLP}_{3,4}:\mathbb{R}^{2d}\to \mathbb{R}^d$  are MLP networks, NOT is negation in fuzzy logic.
Temporal Operators: After  $\mathcal{A}_t$ , Before  $\mathcal{B}_t$  and Between  $\mathcal{D}_t$ . The operator After  $\mathcal{A}_t:\mathbf{V}_q\mapsto \mathbf{V}_q'$  (Before  $\mathcal{B}_t:\mathbf{V}_q\mapsto \mathbf{V}_q^{\prime}$ ) aims to deduce the timestamps after(before) a given fuzzy time set  $[q]]$ . Let  $\mathbf{V}_q = (\pmb {q}_f^e,\pmb {q}_l^e,\pmb {q}_f^t,\pmb {q}_l^t)$ , we define  $\mathcal{A}_t$  and  $\mathcal{B}_t$  as:
$$
\mathcal {A} _ {t} \left(\mathbf {V} _ {q}\right) = \left(\boldsymbol {q} _ {f} ^ {e}, \boldsymbol {q} _ {l} ^ {e}, \boldsymbol {q} _ {f} ^ {t} + \frac {1 + \boldsymbol {q} _ {l} ^ {t}}{2}, \frac {1 - \boldsymbol {q} _ {l} ^ {t}}{2}\right), \quad \mathcal {B} _ {t} \left(\mathbf {V} _ {q}\right) = \left(\boldsymbol {q} _ {f} ^ {e}, \boldsymbol {q} _ {l} ^ {e}, \boldsymbol {q} _ {f} ^ {t} - \frac {1 + \boldsymbol {q} _ {l} ^ {t}}{2}, \frac {1 - \boldsymbol {q} _ {l} ^ {t}}{2}\right) \tag {5}
$$
The entity part does not change after computation because temporal operator only affects the time part (time feature  $\pmb{q}_f^t$  and time logic  $\pmb{q}_l^t$ ). The motivation of computation is illustrated in Figure 2. Since  $\pmb{q}_l^t$  is the uncertainty of time feature  $\pmb{q}_f^t$ , the time part can be viewed as an interval  $[q_f^t - q_l^t, q_f^t + q_l^t]$  whose center is  $\pmb{q}_f^t$  and half-length is  $\pmb{q}_l^t$ . The interval is covered by  $[q_f^t - 1, q_f^t + 1]$  because the probability  $\pmb{q}_l^t < 1$ . Then, after interval  $[q_f^t - q_l^t, q_f^t + q_l^t]$  is the interval  $[q_f^t + q_l^t, q_f^t + 1]$  whose center is  $\pmb{q}_f^t + \frac{1 + q_l^t}{2}$  and half-length is  $\frac{1 - q_l^t}{2}$ , which gives the time part of embedding  $\mathcal{A}_t(\mathbf{V}_q)$ . Similarly, the time part of embedding  $\mathcal{B}_t(\mathbf{V}_q)$  is  $\pmb{q}_f^t - \frac{1 + q_l^t}{2}$  (time feature) and  $\frac{1 - q_l^t}{2}$  (time logic), which are generated from  $[q_f^t - 1, q_f^t - q_l^t]$  before  $[q_f^t - q_l^t, q_f^t + q_l^t]$ . The operator Between  $\mathcal{D}_t: \mathbf{V}_{q_1}, \mathbf{V}_{q_2} \mapsto \mathbf{V}_q'$  inferences the time set after  $[q_1]$  and before  $[q_2]$ . Therefore, we define between  $\mathcal{D}_t$  as  $\mathcal{D}_t(\mathbf{V}_{q_1}, \mathbf{V}_{q_2}) = \mathcal{I}_t(\mathcal{A}_t(\mathbf{V}_{q_1}), \mathcal{B}_t(\mathbf{V}_{q_2}))$  to output the time between  $[q_1]$  and  $[q_2]$ .
4.3 Learning Temporal Feature-Logic Embeddings
We expect the model to achieve high scores for the answers to the given query  $q$ , and low scores for  $v' \notin [[q]]$ . Therefore, we firstly define a distance function to measure the distance between a given answer embedding and a query embedding, and then we train the model with negative sampling loss.
Distance Function Given an entity embedding  $\mathbf{v} = (v_{f}^{e},0,0,0)$ , a timestamp embedding  $\mathbf{t} = (0,0,t_{f}^{t},0)$  and a query embedding  $\mathbf{V}_{q} = (q_{f}^{e},q_{l}^{e},q_{f}^{t},q_{l}^{t})$ , we define the distance  $d$  between the answer and the query  $q$  as the sum of the feature distance (between the feature parts) and the logic part (to expect uncertainty to be 0). If the query answers entities, the distance is  $d^{e}(\mathbf{v};\mathbf{V}_{q}) = \| v_{f}^{e} - q_{f}^{e}\|_{1} + q_{l}^{e}$ . Otherwise, the distance is  $d^{t}(\mathbf{t};\mathbf{V}_{q}) = \| t_{f}^{t} - q_{f}^{t}\|_{1} + q_{l}^{t}$  for queries answering timestamp set, where  $\| \cdot \| _1$  is the  $L_{1}$  norm and  $+$  is element-wise addition. The distance function aims to optimize two losses. One is to push the answers to the neighbor of query in the embedding
space. It corresponds to the term L1 distance between answer and query. The other is to reduce the uncertainty of the query (the probability interpretation of the logic part), to make the answers more accurate.
Loss Function Given a training set of queries, we optimize a negative sampling loss
$$
L = - \log \sigma (\gamma - d (\mathbf {v}; \mathbf {V} _ {q})) - \frac {1}{k} \sum_ {i = 1} ^ {k} \log \sigma \left(d \left(\mathbf {v} _ {i} ^ {\prime}; \mathbf {V} _ {q}\right) - \gamma\right) \tag {6}
$$
where  $\gamma > 0$  is a fixed margin,  $k$  is the number of negative entities, and  $\sigma(\cdot)$  is the sigmoid function. When query  $q$  is answering entities (timestamps),  $v \in [[q]]$  is a positive entity (timestamp),  $v_i' \notin [[q]]$  is the  $i$ -th negative entity (timestamp).
In this section, we evaluate the ability of TFLEX to reason over TKGs. We first introduce experimental settings in Section 5.1, and then present the experimental results in Section 5.2.
Datasets and Query Generation Experiments are performed on three new datasets generated from standard benchmarks for TKGC: ICEWS14 [37], ICEWS05-15 [37], and GDELT-500 [38] (with statistics in Appendix B.1). We predefined 40 kinds of complex queries for each dataset. The definition of the 40 kinds of complex queries and the query generation process details are described in Appendix B.2. We consider 27 kinds of queries for training and all 40 kinds for evaluation and testing. Please refer to Appendix B.3 for summaries of the final datasets.
To briefly summarize the results, we aggregate groups of queries that can be answered: entities  $(\mathrm{avg}_e)$ , timestamps  $(\mathrm{avg}_t)$ , entities with negation  $(\mathrm{avg}_{e,\mathcal{C}_e})$ , timestamps with negation  $(\mathrm{avg}_{t,\mathcal{C}_t})$ , entities with unseen union  $(\mathrm{avg}_{\{\mathcal{U}_e\}})$ , timestamps with unseen union  $(\mathrm{avg}_{\{\mathcal{U}_t\}})$ , and other hybrid unseen structures  $(\mathrm{avg}_x)$ . These groups are inspired by the experiment settings of existing static QEs [1-4]. The detail that which query belongs to which group will be shown in Appendix B.7. Note that the training set only involves 4 groups of queries:  $\mathrm{avg}_e$ ,  $\mathrm{avg}_t$ ,  $\mathrm{avg}_{e,\mathcal{C}_e}$ , and  $\mathrm{avg}_{t,\mathcal{C}_t}$ .
Evaluation Given a test query  $q$ , for each non-trivial answer  $v \in [[q]]_{\mathrm{test}} - [[q]]_{\mathrm{valid}}$  of the query  $q$ , we rank it against non-answer entities  $\mathcal{V} - [[q]]_{\mathrm{test}}$  (or non-answer timestamps  $\mathcal{T} - [[q]]_{\mathrm{test}}$  if the query is answering timestamps). Then we calculate Mean Reciprocal Rank (MRR) based on the rank. The higher, the better. Please refer to Appendix B.5 for the definition of MRR.
For each group, we report the average MRR in Table 1. The raw MRR results on all query structures for each dataset in detail are presented in Appendix B.7.
How well can TFLEX answer temporal complex queries?. We compare TFLEX with state-of-the-art query embeddings Query2box [2], BetaE [3] and ConE [4] on answering entities. Existing query embeddings only handle FOL on entity set, but unable to cope with temporal logic over timestamp set. Therefore, the results of these three methods have to be obtained by ignoring the timestamps, so that the  $\mathrm{avg}_t$ ,  $\mathrm{avg}_{t,\mathcal{C}_t}$ ,  $\mathrm{avg}_{\{\mathcal{U}_t\}}$  and  $\mathrm{avg}_x$  of three methods are zeros. Comparing the results of these methods in Table 1, we can see that TFLEX outperforms all the baselines on all the metrics. These results demonstrate that TFLEX can perform reasoning over TKGs well, at least better than the existing query embeddings.
Ablation on entity part. The variant  $\mathbf{X}(\mathbf{ConE})$  replaces the entity part of TFLEX with ConE [4] to handle the logic over entity sets. In the entity part, ConE is geometric while TFLEX is fuzzy. The variant performs even worse than TFLEX and ConE. The dropping MRR indicates that the entity part plays an important role in the framework. Considering the performance of ConE, we think there is semantic conflict between the time part of TFLEX and the entity part of ConE. Simply combining static QEs with dynamic QEs is not a clever way to achieve the best performance.
Table 1: Average MRR results for different groups of temporal complex queries. X denotes the variant of TFLEX. X(ConE) replaces the entity part with ConE [4]. FLEX ablates the time part. X-1F merges entity feature and timestamp feature into one feature. X-logic removes the logic part.
Dataset	Metrics	Query2box	BetaE	ConE	TFLEX	X(ConE)	FLEX	X-1F	X-logic
ICEWS14	avge	25.06	37.19	41.94	56.79	40.93	43.67	56.89	56.64
avge,Ce	36.69	44.88	50.82	42.15	44.41	49.78	51.17
avgt	17.56	16.41	18.77	18.03
avgt,Ct	36.37	35.24	37.73	36.39
avg{Ue}	19.95	26.47	35.74	25.46	29.25	34.48	34.68
avg{Ut}	26.24	24.07	28.04	26.36
avgx	28.03	26.65	29.31	28.61
AVG	35.93	30.13	36.43	35.98
ICEWS05-15	avge	24.00	31.33	40.93	48.99	36.29	38.96	49.90	44.80
avge,Ce	29.70	43.52	46.17	38.12	42.10	46.11	41.92
avgt	4.39	4.41	4.43	3.29
avgt,Ct	30.16	29.49	30.26	28.34
avg{Ue}	21.54	43.02	54.37	36.37	44.38	54.05	45.36
avg{Ut}	28.69	26.40	27.70	23.39
avgx	24.26	21.69	24.41	21.95
AVG	33.72	27.54	33.98	29.86
GDELT-500	avge	9.67	14.75	18.44	19.60	17.83	19.07	17.92	17.36
avge,Ce	11.15	12.67	13.52	12.34	13.35	12.13	12.11
avgt	5.38	3.16	5.49	5.75
avgt,Ct	6.31	3.93	6.50	6.86
avg{Ue}	6.20	6.96	7.58	7.41	7.44	6.92	6.91
avg{Ut}	6.71	6.35	6.59	6.80
avgx	6.17	6.17	6.47	6.64
AVG	9.32	8.17	8.86	8.92
Ablation on time part. The variant FLEX removes the time part of the temporal feature-logic embedding. Then, FLEX can only answer entities. The results show that FLEX slightly outperforms ConE. However, the performance of FLEX is worse than TFLEX with a large margin on all the datasets. Therefore, we conclude that the time part also plays an important role in the framework.
Ablation on feature part. If we remove the entity and timestamp feature, the embeddings of entities and timestamps will crash to zeros. Instead, we consider another way to explore the impact of the feature part. Noticing that some TKGC approaches [36, 39] embed entities and timestamps into the same semantic space, we propose X-1F to merge the entity and timestamp features into one feature. Compared with TFLEX, X-1F achieves higher scores on ICEWS14 and ICEWS05-15, but lower on GDELT. The results imply that unifying the feature of entity and timestamp is potentially beneficial in some datasets.
Ablation on logic part. The variant X-logic removes both entity logic and time logic. It achieves lower scores than TFLEX on all the datasets. This is because the logic part is responsible for reasoning over TKGs. Removing the logic part results in that neural logical operators completely rely on neural network to learn the logic, which is not enough to handle various temporal complex queries.
Out-of-data reasoning. The results on  $\mathrm{avg}_{\{\mathcal{U}_e\}}$ ,  $\mathrm{avg}_{\{\mathcal{U}_t\}}$ ,  $\mathrm{avg}_x$  support that the framework can reason over unseen entity logic, unseen time logic as well as their hybrid. The entity union and time union operators are not included in the training set, but the framework can still handle them well.
Sensitive analysis. (1) The selection of hyperparameters (embedding dimension  $d$ , the margin  $\gamma$ ) has a substantial influence on the effectiveness of TFLEX. We train the model with embedding dimension  $d \in \{300, 400, 500, 600, 700, 800, 900, 1000\}$ , the margin  $\gamma \in \{5, 10, 15, 20, 25, 30, 35, 40\}$ . The best performance is achieved when  $d = 800$  and  $\gamma = 15$ . Too small and too large  $d, \gamma$  both lead to worse results, reported in Appendix B.6. (2) Besides, we also investigate the stability of TFLEX. We train and test for five times with different random seeds and report the error bars in Appendix B.6. The small standard variances demonstrate that the performance of TFLEX is stable.
Comparison between TFLEX and TKGC methods. It's natural to compare TFLEX with SOTA TKGC methods, since all of them can answer one-hop temporal queries. We present the comparison results in Table 2. We can see that TFLEX is competitive with translation-based methods
Table 2: TKGC Results (\%) on ICEWS14, ICEWS05-15, and GDELT. The results from top to bottom are organized as static KGEs, timestamp-based transformation TKGEs, tensor decomposition, autoregressive models and ours. Best results are in bold.  $\dagger$ ,  $\star$  indicate the results taken from [40, 17]. Other results are the best numbers reported in their respective paper.
Model	ICEWS14	ICEWS05-15	GDELT
MRR	Hit@1	Hit@3	Hit@10	MRR	Hit@1	Hit@3	Hit@10	MRR	Hit@1	Hit@3	Hit@10
TransE* [35]	28.0	9.4	-	63.7	29.4	9.0	-	66.3	11.3	0.0	15.8	31.2
DistMult* [41]	43.9	32.3	-	67.2	45.6	33.7	-	69.1	19.6	11.7	20.8	34.8
SimpleE* [42]	45.8	34.1	51.6	68.7	47.8	35.9	53.9	70.8	20.6	12.4	22.0	36.6
ConT [43]	18.5	11.7	20.5	31.5	16.3	10.5	18.9	27.2	14.4	8.0	15.6	26.5
TTransE [36]	25.5	7.4	-	60.1	27.1	8.4	-	61.6	11.5	0.0	16.0	31.8
HyTE [44]	29.7	10.8	41.6	65.5	31.6	11.6	44.5	68.1	11.8	0.0	16.5	32.6
TA-DistMult [45]	47.7	36.3	-	68.6	47.4	34.6	-	72.8	20.6	12.4	21.9	36.5
DE-TransE [46]	32.6	12.4	46.7	68.6	31.4	10.8	45.3	68.5	12.6	0.0	18.1	35.0
DE-DistMult [46]	50.1	39.2	56.9	70.8	48.4	36.6	54.6	71.8	21.3	13.0	22.8	37.6
DE-SimpleE [46]	52.6	41.8	59.2	72.5	51.3	39.2	57.8	74.8	23.0	14.1	24.8	40.3
ChronoR [17]	62.5	54.7	66.9	77.3	67.5	59.6	72.3	82.0	-	-	-	-
TuckERT [39]	59.4	51.8	64.0	73.1	62.7	55.0	67.4	76.9	41.1	31.0	45.3	61.4
TuckERTNT [39]	60.4	52.1	65.5	75.3	63.8	55.9	68.6	78.3	38.1	28.3	41.8	57.6
RGCRN†[47, 40]	33.3	24.0	36.5	51.5	35.9	26.2	40.0	54.6	18.6	11.5	19.8	32.4
CyGNet†[48]	34.6	25.3	38.8	53.1	35.4	25.4	40.2	54.4	18.0	11.1	19.1	31.5
RE-NET†[28]	35.7	25.9	40.1	54.8	36.8	26.2	41.8	57.6	19.6	12.0	20.5	33.8
RE-GCN†[40]	37.7	27.1	42.5	58.8	38.2	27.4	43.0	59.9	19.1	11.9	20.4	33.1
TFLEX-1p	43.9	31.4	49.6	64.4	40.6	29.1	47.5	66.1	16.5	8.6	17.3	33.1
TFLEX	48.2	35.7	56.5	72.3	43.0	30.0	49.8	69.5	18.5	10.1	19.6	34.9
Figure 3: Score distributions of Pt, bPt and aPt.
Table 3: MRR of Pe on ICEWS14, ICEWS05-15, and GDELT-500. The best results are in bold. Results of TTransE and HyTE are taken from Goel et al. [46].
Datasets	TTransE*	HyTE*	TFLEX-1p	TFLEX
ICEWS14	25.5	29.7	42.9	48.2
ICEWS05-15	27.1	31.6	40.6	43.0
GDELT-500	11.5	11.8	16.5	18.5
(ConT [43], TTransE [36], HyTE [44], etc.), but it doesn't outperform the SOTA TKGC methods like ChronoR [17] and TuckERT [39]. However, the result doesn't affect the novelty and contribution of this paper. Please note that the projection operator of TFLEX is as simple as TTransE, not further optimized for TKGC tasks only. Upgrading the projection operator to outperform SOTA TKGC methods remains a future work.
Necessity of training on temporal complex queries. Our experiments demonstrate that training on complex queries is necessary to achieve the best performance. We compare with translation-based  $\mathcal{P}_e$  operators (TTransE [36], HyTE [44] and TFLEX's variant TFLEX-1p) using only one-hop Pe queries for training. We choose TTransE and HyTE because our projection operator is also translation-based  $(\mathcal{P}_e(\mathbf{V}_q, \mathbf{r}, \mathbf{V}_t) \propto \mathbf{V}_q + \mathbf{r} + \mathbf{V}_t)$ . From the result table 3, we observe that TFLEX achieves the best performance when comparing with these translation-based baselines on all datasets. Besides, compared with TFLEX-1p, TFLEX achieves  $7.9\%$  relative improvement on average on MRR, which demonstrates that training on complex queries could improve the one-hop query-answering ability.
Effectiveness of neural temporal operators. We found that the temporal operators  $\mathcal{A}_t$  and  $\mathcal{B}_t$  change the semantic of predicted timestamp embedding logically. We randomly select an event  $(s, r, o)$  from ICEWS14 and consider three temporal queries  $\mathbf{P}t$ ,  $\mathbf{bP}t$  and  $\mathbf{aP}t$ . Then,  $\mathbf{P}t(= \mathcal{P}_t(s, r, o))$  predicts the date  $t$  when this event happened. And  $\mathbf{bP}t(= \mathcal{B}_t(\mathcal{P}_t(s, r, o)))$  should predict the date before  $t$ , while  $\mathbf{aP}t(= \mathcal{A}_t(\mathcal{P}_t(s, r, o)))$  is supposed to predict the time after  $t$ . The output of three queries are time embeddings. Because the time embedding is fuzzy, we score it to all possible Timesteps, and visualize the normalized similarity score distribution over all days in a year, from 0 to 365 in ICEWS14. The higher the score, the more possible the predicted date is the day. We plot the three score distributions in Figure 3. For each distribution, we highlight the periods of the highest scores
with a colored background. These colored blocks represent the most likely happening time interval of the event. We observe that the order of colored blocks (corresponding to the predictions of bPt, Pt, and aPt) matches the logical meanings of these operators (Before the event, On the event, After the event). The visualization shows that neural temporal operators perform the time transformation correctly. More examples are attached in Appendix D.
Explaining answers with temporal feature-logic framework. We take query Pe2 for example. Given temporal query Pe2:  $q[V_{?}] = V_{?}, \exists V_{a}, r_{1}(e_{1}, V_{a}, t_{1}) \land r_{2}(V_{a}, V_{?}, t_{2})$ , let's try an example which can be written as: On 2014-04-04, who consulted the man who was appealed to or requested by the Head of Government (Latvia) on 2014-08-01? In this example,  $e_{1}$  is "Head of Government (Latvia)",  $r_{1}$  is "Make an appeal or request",  $t_{1}$  is "2014-08-01",  $r_{2}$  is "consult $^{-1}$ ", and  $t_{2}$  is "2014-04-04". Then we use TFLEX to execute the query and get answers. We classify the answers into easy, hard and wrong ones. The easy answer is the correct answer that appears in the training set, while the hard answer is the correct answer that exists in the testing set instead of training set.
We present five most likely answers for interpretation in Figure 4. From the table we observe that TFLEX ranks easy answers "François Hollande", "Taavi Röivas" and hard answer "Andris Berzins" higher than wrong answers "Angela Merkel" and "Head of Government (Latvia)". This shows that TFLEX successfully finds the hard answer by performing complex reasoning, and distinguishes the right answers from the wrong ones.
We provide 36 examples in Appendix E, including the visualization and intermediate explanation of answers for each query structure.
Figure 4: Intermediate variable assignments and ranks for example Pe2 query. Correctness indicates whether the answer belongs to the ground-truth set of answers.
In this paper, we firstly define a temporal multi-hop logical reasoning task on temporal knowledge graphs. Then we generate three new TKG datasets and propose the Temporal Feature-Logic embedding framework, TFLEX, to handle temporal complex queries in datasets. Fuzzy logic is used to guide all FOL transformations on the logic part of embeddings. We also further extended fuzzy logic to implement extra temporal operators (Before, After and Between). To the best of our knowledge, TFLEX is the first framework to support multi-hop complex reasoning on temporal knowledge graphs. Experiments on benchmark datasets demonstrate the efficacy of the proposed framework in handling different operations in complex queries.
This work is supported by the National Science Foundation of China (Grant No. 62176026) and Beijing Natural Science Foundation (M22009); Engineering Research Center of Information Networks, Ministry of Education. We would like to express our sincere gratitude to our corresponding authors, Prof. Haihong E and Dr. Chengjin Xu, for their guidance, expertise, and unwavering support throughout the project. Furthermore, we would like to thank Fenglong Su, Gengxian Zhou, Tianyi Hu, Ningyuan Li, Mingzhi Sun, and Haoran Luo for their individual contributions and collaboration in various aspects of this project. Their expertise and dedication have significantly enriched the final outcome. Additionally, we extend our thanks to the anonymous reviewers for their time and efforts in reviewing our work. Their constructive feedback and comments have been instrumental in improving the overall clarity and rigor of this research.
Multi-hop reasoning makes the information stored in TKGs more valuable. With the help of multi-hop reasoning, we can digest more hidden and implicit information in TKGs. It will broaden and deepen KG applications in various fields, such as question answering, recommend systems, and information retrieval. It may also bring about risks exposing unexpected personal information on public data.
Finance temporal knowledge graph is a good example to illustrate the broader impact of multi-hop reasoning. In the financial field, the information stored in TKGs is very sensitive. The one-hop reasoning can complete the hidden financial transaction, while the multi-hop reasoning can help to detect the fraud. The After operator could also be used to predict the future financial transaction. People may take the advantages of logical reasoning to digest financial factor to obtain excess returns.
Military temporal knowledge graph is another example. With the help of multi-hop logical reasoning, we may predict the future military strategy of a country. Besides, with the fuzzy completion of the hidden military information, we can also detect the hidden militarily moves, which may save thousands of soldiers' lives.
The last example is social temporal knowledge graph. The behaviors of people are left and stored in TKGs. With the help of logical reasoning, we may predict a short future of a person. For example, the query may answer the evolution of user profiles: how long may a person transfer to another role, from student to worker, becoming a parent, or being a grandparent. Tracking the user's identity change can provide super benefits for merchants' advertising. Detecting the role of a person is also helpful to provide more personalized services.
However, we should agree that the multi-hop reasoning is still at an extremely early stage, though it may bring about risks. Therefore, we should pay more attention to the security of TKGs and the privacy of users at the mean time when we explore the technology of multi-hop reasoning over TKGs.
Limitation & Future Work
In this section, we list 4 limitations and talk about the possible future work.
Limitation 1: The temporal operators are not enough.. We define three extra temporal operators (Before, After and Between) in query generation. However, there exists more temporal operators in the real world. For example, Allen [49] defined 13 types of temporal relations represented by two intervals, including before/after, during/contains, overlaps/overlapped-by, meets/met-by, starts/start-by, finishes/finished-by and equal. In the future we would like to promote these temporal operators to TKGs.