[table]capposition=top capbtabboxtable[][]

# Graph Hawkes Neural Network for Forecasting on Temporal Knowledge Graphs

Zhen Han<EMAIL_ADDRESS>
Yunpu Ma<EMAIL_ADDRESS>
LMU Munich $\&$ Siemens AG
Otto-Hahn-Ring 6, 81739 Munich, Germany Yuyi Wang<EMAIL_ADDRESS>
ETH Zürich
Rämistrasse 101, 8092 Zürich, Switzerland Stephan Günnemann
<EMAIL_ADDRESS>
Technical University of Munich
Boltzmannstr. 3, 85748 Garching b. München, Germany Volker Tresp∗
<EMAIL_ADDRESS>
LMU Munich $\&$ Siemens AG
Otto-Hahn-Ring 6, 81739 Munich, Germany Corresponding author

###### Abstract

The Hawkes process has become a standard method for modeling self-exciting
event sequences with different event types. A recent work has generalized the
Hawkes process to a neurally self-modulating multivariate point process, which
enables the capturing of more complex and realistic impacts of past events on
future events. However, this approach is limited by the number of possible
event types, making it impossible to model the dynamics of evolving graph
sequences, where each possible link between two nodes can be considered as an
event type. The number of event types increases even further when links are
directional and labeled. To address this issue, we propose the Graph Hawkes
Neural Network that can capture the dynamics of evolving graph sequences and
can predict the occurrence of a fact in a future time instance. Extensive
experiments on large-scale temporal multi-relational databases, such as
temporal knowledge graphs, demonstrate the effectiveness of our approach.

##  1 Introduction

If political relations between two countries becomes more tense, will it
affect the international trades between them? If yes, which industries will
bear the brunt? Modeling the relevant events that can be temporarily affected
by international relations is the key to answer this question. However, the
issue of how to model these complicated temporal events is an intriguing
question. A possible way is to embed events in a temporal knowledge graph,
which is a graph-structured multi-relational database that stores an event in
the form of a quadruple. Events are point processes and point process models,
in the past, have been widely applied to many real-world applications such as
the analysis of social networks Zhou et al. (2013), the prediction of
recurrent user behaviors Du et al. (2016), and the estimation of consumer
behaviors in finance Bacry et al. (2016). The well known Poisson process Palm
(1943) is limited to modeling temporal events that occur independently of one
another. Hawkes (1971) proposed a self-exciting point process, which is now
known as the Hawkes process, which assumes that past events have an excitation
effect on the likelihood of future events, and such excitation exponentially
decays with time. This model has been shown to be effective in modeling
earthquakes Ogata (1998). However, it is unable to capture some real-world
patterns where past events of a different type may have inhibitory effects on
future events, i.e., a skateboard purchase may inhibit a bike purchase. To
address this limitation, the neural Hawkes process Mei and Eisner (2017)
generalized the Hawkes process using recurrent neural networks with continuous
state spaces such that past events can excite and inhibit future events in a
complex and realistic way. Nevertheless, the neural Hawkes process is only
capable of modeling event sequences with a small number of event types and
fails to accurately capture the mutual influence in large-scale temporal
multi-relational data. An example would be the evolving links in a dynamic
graph sequence where the connections between nodes can be considered as
different event types. The problem becomes even more challenging when the
links are directional and labeled. In order to model the dynamics of
directional and labeled links in a graph sequence, we develop a novel Graph
Hawkes Process and apply it to large-scale temporal multi-relational
databases, such as temporal knowledge graphs.

Before introducing temporal knowledge graphs, we briefly review semantic
knowledge graphs (semantic KGs), which are multi-relational knowledge bases
for storing factual information. Semantic KGs such as the Google Knowledge
Graph Singhal (2012) represent an event as a semantic triplet$(s,p,o)$ in
which $s$ (subject) and $o$ (object) are entities (nodes), and $p$ (predicate)
is a directional labeled link (edge). Latent feature models Ma et al. (2018a);
Nickel et al. (2011) and graph feature models Minervini et al. (2014); Liu and
Lü (2010) are two popular approaches to develop statistical models for
semantic KGs. However, in contrast to static multi-relational data in semantic
KGs, relations between entities in many real-world scenarios are not fixed and
may change over time. Such temporal events can be represented as a quadruple
$(s,\,p,\,o,\,t)$ by extending the semantic triplet with a time instance $t$
describing when these events occurred. Further an event may last for a period
of time. For example, (John, lives in, Vancouver) could be true for many time
steps, and (Alice, knows, John) might be true always. We can simply discretize
such an event into a sequence of time-stamped events to store it in the form
of quadruples. Appendix A shows an example of a temporal KG. By considering
time, the semantic KGs are augmented into temporal knowledge graphs (tKGs),
which creates the need for statistical learning that can capture dynamic
relations between entities in tKGs. Modeling dynamic relations between
entities over tKGs becomes more challenging than normal event streams since
the number of event types is of order $N_{e}^{2}\cdot N_{p}$, where $N_{e}$
and $N_{p}$ are the number of entities and predicates respectively. Recent
studies on tKGs reasoning focused on augmenting entity embeddings with time-
dependent components in a low-dimensional space Kazemi et al. (2019); Sankar
et al. (2018). However, the existing temporal KG models either lack a
principled way to predict the occurrence time of future events or ignore the
concurrent facts within the same time slice.

In this paper, we propose a novel deep learning architecture to capture
temporal dependencies on tKGs, called Graph Hawkes Neural Network (GHNN). More
specifically, our main contributions are:

  * •

We propose a Graph Hawkes Neural Network for predicting future events on
large-scale tKGs. This is the first work that uses the Hawkes process to
interpret and capture the underlying temporal dynamics of tKGs.

  * •

Different from the previous tKG models with discrete state spaces, we model
the occurrence probability of an event in continuous time. In this way, our
model can compute the probability of an event at an arbitrary timestamp, which
considerably enhances model’s flexibility.

  * •

We analyze previous problematic evaluation metrics and propose a new ranking
metric for link prediction on temporal knowledge graphs.

  * •

Compared to state-of-the-art time prediction models on tKGs, our approach can
achieve more accurate results.

##  2 Background and Related Work

###  2.1 The Hawkes Process

The Hawkes process is a stochastic process for modeling sequential discrete
events occurring in continuous time where the time intervals between
neighboring events may not be identical. Moreover, the Hawkes process supposes
that past events can temporarily excite future events, which is characterized
via the intensity function. The intensity function $\lambda_{k}(t)$ represents
the expected number of events with type $k$ in the interval of unit length.
Thus, according to the survival analysis theory Aalen et al. (2008), the
density function that an event with the type $k$ occurs at $t_{i}$ is defined
as

$p_{k}(t_{i})=\lambda_{k}(t_{i})\exp(-\int^{t_{i}}_{t_{L}}\sum_{k}\lambda_{k}(s)ds),$
(1)

where $t_{L}$ denotes the latest occurrence of any event without regarding its
event type.

###  2.2 Future Prediction on Temporal Knowledge Graphs

Temporal knowledge graphs are multi-relational, directed graphs with labeled
timestamped edges (predicates) between nodes (entities). Each timestamped edge
represents a specific event that is formed by a predicate edge $p$ between a
subject entity $s$ and an object entity $o$ at a timestamp $t$ and is denoted
by a quadruple $(e_{s},e_{p},e_{o},t)$, where
$e_{s},e_{o}\in\\{1,...\,,N_{e}\\}$, $e_{p}\in\\{1,...\,,N_{p}\\}$,
$t\in\mathbb{R^{+}}$. A tKG can therefore be represented as an ordered
sequence of quadruples,
$\mathbb{E}=\\{e_{i}=(e_{s_{i}},e_{p_{i}},e_{o_{i}},t_{i})\\}_{i=1}^{N}$,
where $0\leq t_{1}\leq...\leq t_{n}$. A classic task in tKGs is to predict
either a missing subject entity $(?,e_{p_{i}},e_{o_{i}},t_{i})$ or a missing
object entity $(e_{s_{i}},e_{p_{i}},?,t_{i})$. While one aims to predict the
missing links in the existing graphs in the context of a semantic knowledge
graph, one wants to predict the future links at a future timestamp $t_{i}$
based on observed events that occurred before $t_{i}$. Besides predicting what
will happen in the future, another challenging problem is to predict when an
event will happen, which is referred as the time prediction task. More
concretely, one can precisely answer questions like:

  * •

Object prediction. Which country will Emmanuel Macron visit next?

  * •

Subject prediction. Who is the wife of Emmanuel Macron?

  * •

Time prediction. When will Emmanuel Macron tweet again?

Recently, several studies focussed on temporal knowledge graph reasoning.
Esteban et al. (2016) introduced an event model for modeling the temporal
evolution of KGs where the prediction of future events is based on the latent
representations of the knowledge graph tensor and of the time-specific
representations from the observed event tensor. Jiang et al. (2016) augmented
existing static knowledge graph models with temporal consistency constraints
such as temporal order information and formulated the time-aware inference as
an Integer Linear Program problem. In addition, Ma et al. (2018b) developed
extensions of static knowledge graph models by adding a timestamp embedding to
their score functions. Besides, Leblay and Chekol (2018) incorporated time
presentations into score functions of several static KG models such as TransE
Bordes et al. (2013) and RESCAL Nickel et al. (2011) in different ways.
Additionally, García-Durán et al. (2018) suggested a straight forward
extension of some existing static knowledge graph models that utilize a
recurrent neural network (RNN) to encode predicates with temporal tokens
derived by decomposing given timestamps. However, these models cannot
generalize to unseen timestamps because they only learn embeddings for
observed timestamps. In contrast, LiTSEE Xu et al. (2019) directly
incorporates time as a scale into entity representations by utilizing the
linear time series decomposition. Also, Know-Evolve Trivedi et al. (2017)
learns evolving entity representations using the Rayleigh process, being able
to capture the dynamic characteristics of tKGs. Additionally, RE-Net Jin et
al. (2019) augmented the R-GCN model Schlichtkrull et al. (2018) to tKGs and
uses the order of history event for predicting the future.

##  3 Notation

Throughout the following sections, $e_{i}$ denotes an event consisting of
$(e_{s_{i}},e_{p_{i}},e_{o_{i}})$ where $e_{s_{i}}$, $e_{o_{i}}$ and
$e_{p_{i}}$ written not in bold represent the subject entity, object entity
and predicate of the event $e_{i}$, respectively. Additionally, we use $t_{i}$
to denote the timestamp when the event $e_{i}$ occurred. Besides,
$\mathbf{e}_{s_{i}}$, $\mathbf{e}_{p_{i}}$, $\mathbf{e}_{o_{i}}$ written in
bold represent their embeddings. We denote vectors by bold lowercase letters,
such as $\mathbf{c}$, and matrices by bold capital Roman letters, e.g.,
$\mathbf{W}$. Additionally, subscripted bold letters denote specific vectors
or matrices such as $\mathbf{k}_{m}$. Moreover, scalar quantities, such as
$\lambda_{k}$, are written without bold. We denote the upper limits of scalar
quantities by capitalized scalars, for example, $1\leq n\leq N$.

##  4 Our Model

In this section, we present the Graph Hawkes Neural Network (GHNN) for
modeling sequences of discrete large-scale multi-relational graphs in
continuous time. The GHNN consists of the following two major modules:

  * •

A neighborhood aggregation module for capturing the information from
concurrent events that happened at the same timestamp.

  * •

A Graph Hawkes Process for modeling the occurrence of a future fact where we
use a recurrent neural network to learn this temporal point process.

We take the temporal knowledge graph as an example and show how our model
deals with the link prediction task and the time prediction task. Besides,
GHNN also learns latent representations specified for entities and predicates.
In the rest of this section, we first define the relevant historical event
sequence for each inference task, which is the input of GHNN, and then provide
details on the proposed modules in GHNN.

###  4.1 Relevant Historical Event Sequences

In this work, we consider a temporal knowledge graph $\mathcal{G}$ as a
sequence of graph slices
$\\{\mathcal{G}_{1},\mathcal{G}_{2},....,\mathcal{G}_{T}\\}$, where
$\mathcal{G}_{t}=\\{(e_{s},e_{p},e_{o},t)\in\mathcal{G}\\}$ denote a graph
slice that consists of facts that occurred at the timestamp $t$. Additionally,
inspired by Jin et al. (2019), we assume that concurrent events belonging to
the same graph slice, which means that they occurred at the same timestamp,
are conditionally independent to each other given the past observed graph
slices. Thus, for predicting a missing object entity of an object prediction
query $(e_{s_{i}},e_{p_{i}},?,t_{i})$, we evaluate the conditional probability
$\mathbb{P}(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},\mathcal{G}_{t_{i-1}},\mathcal{G}_{t_{i-2}},...,\mathcal{G}_{1})$
of all object entity candidates. To simplify the model complexity in this
work, we assume that the conditional probability that an object entity forms a
link with a given subject entity $e_{s_{i}}$ with respect to a predicate
$e_{p_{i}}$ at a timestamp $t_{i}$ directly depends on past events that
include $e_{s_{i}}$ and $e_{p_{i}}$. We define these events as the relevant
historical event sequence $e^{h,sp}_{i}$ for predicting the missing object
entity $e_{o_{i}}$:

$e^{h,sp}_{i}=\\{\bigcup_{0\leq
t_{j}<t_{i}}(e_{s_{i}},e_{p_{i}},\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}}),t_{j})\,\\}$
(2)

where $\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})$ is a set of object entities
that formed a link with the subject entity $e_{s_{i}}$ under the predicate
$e_{p_{i}}$ at a timestamp $t_{j}\,(0\leq t_{j}<t_{i})$. Thus, we can rewrite
the conditional probability of an object entity candidate $e_{o}$ given a
query $(e_{s_{i}},e_{p_{i}},?,t_{i})$ and past graph slices, i.e., from
$1^{st}$ to ${(i-1)}^{th}$, into the following form:

$\displaystyle\mathbb{P}(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},{\mathcal{G}_{t_{i-1}},\mathcal{G}_{t_{i-2}},....,\mathcal{G}_{1}})=\mathbb{P}(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i}).$
(3)

To capture the impact of other past events that have different subject entity
or predicate than the query has, we use a shared latent representation for an
entity that appears in different quadruples. For each observed event in the
training set, two entities involved in the event propagate information from
the neighborhood of one entity to the other entity. Thus, after training, the
model is also able to capture dynamics between multi-hop neighbors with
various relations. Similarly, we define a relevant historical event sequence
$e^{h,op}_{i}$ for predicting the missing subject entity $e_{s_{i}}$ given a
subject prediction query $(?,e_{p_{i}},e_{o_{i}},t_{i})$. For the time
prediction task, we assume that the time of the next occurrence of an event
$(e_{s_{i}},e_{p_{i}},e_{o_{i}})$ is directly dependent on past events that
include either $(e_{s_{i}},e_{p_{i}})$ or $(e_{o_{i}},e_{p_{i}})$. This gives
the conditional probability density function at a timestamp $t$ given a query
$(e_{s_{i}},e_{p_{i}},e_{o_{i}},?)$ and past graph slices with the following
form:

$p(t|e_{s_{i}},e_{o_{i}},e_{p_{i}},{\mathcal{G}_{t_{i-1}},\mathcal{G}_{t_{i-2}},....,\mathcal{G}_{1}})=p(t|e_{s_{i}},e_{o_{i}},e_{p_{i}},e^{h,sp}_{i},e^{h,op}_{i}).$
(4)

###  4.2 Neighborhood Aggregation

Because a subject entity can form links with multiple object entities within
the same time slice, we use a mean aggregation module Hamilton et al. (2017)
to extract neighborhood information from concurrent events of a relevant
historical event sequence. For predicting the missing object entity in an
object prediction query $(e_{s_{i}},e_{p_{i}},?,t_{i})$, this module takes the
element-wise mean of the embedding vectors of object entities in
$\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})$:

$g(\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}}))=\frac{1}{|\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})|}\sum_{e_{o}\in
O_{t_{j}}(e_{s_{i}},e_{p_{i}})}\mathbf{e}_{o}$ (5)

where we denote the mean aggregation of embeddings of the neighboring object
entities as $g(\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}}))$.

###  4.3 The Graph Hawkes Process

The time span between events often has significant implications on the
underlying intricate temporal dependencies. Therefore, we model time as a
random variable and deploy the Hawkes process on temporal knowledge graphs to
capture the underlying dynamics. We call this the Graph Hawkes Process. In
contrast to the classic Hawkes process with a parametric form, we use a
recurrent neural network to estimate the intensity function $\lambda_{k}$ of
the graph Hawkes process. Traditionally, recurrent neural networks are
employed to sequential data with evenly spaced intervals. However, events in a
temporal KG are randomly distributed in the continuous time space. Thus,
inspired by the neural Hawkes process Mei and Eisner (2017) we use a
continuous-time LSTM with an explicit time-dependent hidden state, where the
hidden state is instantaneously updated with each event occurrence and also
continuously evolves, as time elapses between two neighbored events.
Specifically, given an object prediction query $(e_{s_{i}},e_{p_{i}},?,t_{i})$
and its relevant historical event sequence $e^{h,sp}_{i}$, we define the
intensity function of an object candidate $e_{o}$ as follows:

$\displaystyle\lambda(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})=f(\mathbf{W}_{\lambda}(\mathbf{e}_{s_{i}}\oplus\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})\oplus\mathbf{e}_{p_{i}})\cdot\mathbf{e}_{o})$
(6)

where $\mathbf{e}_{s_{i}},\mathbf{e}_{p_{i}},\mathbf{e}_{o}\in\mathbb{R}^{r}$
are embedding vectors of the subject $e_{s_{i}}$, predicate $e_{p_{i}}$ and
object $e_{o_{i}}$ of the event $e_{i}$,
$\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})\in\mathbb{R}^{d}$
denotes the hidden state of a continuous-time recurrent neural network that
takes $e^{h,sp}_{i}$ as input and summarizes information of the relevant
historical event sequence, and $\oplus$ represents the concatenation operator.
$r$ and $d$ denote the rank of embeddings and the number of hidden dimensions,
respectively. $\mathbf{W}_{\lambda}$ is a weight matrix which convert the
dimensionality of the concatenation from $2r+d$ to $r$ so that we can form a
dot-product between the concatenation and the embedding of the object
candidate $e_{o}$. This captures the compatibility between $e_{s_{i}}$ and
$e_{o}$ considering previous events they have been involved in.

Besides, to ensure that all elements of the intensity vector
$\lambda(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$ are strictly positive
definite, we use the scaled softplus function as the activation function of
the recurrent neural network, which is defined as:

$f(x)=s\log(1+\exp(x/s)).$ (7)

All output values of the scaled softplus function are strictly positive
definite and approach the corresponding outputs of the ReLU function as the
scale parameter $s>0$ approaches zero.

To let $\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$ learn
complex dependencies on the number, order and timing of the historical
sequence $e^{h,sp}_{i}$, we adopt the continuous-time Long Short-Term Memory
(cLSTM) (Mei and Eisner, 2017) since discrete-time approaches may fail to
model the change of hidden states between two events when the time interval
between them is considerable. We list some core functions in the following,
the complete algorithm of a cLSTM cell is provided in Appendix B.

$\displaystyle\mathbf{k}_{m}(e_{s_{i}},e_{p_{i}},e^{h,sp}_{i})$
$\displaystyle=g(\mathbf{O}_{t_{m}}(e_{s_{i}},e_{p_{i}}))\oplus\mathbf{e}_{s_{i}}\oplus\mathbf{e}_{p_{i}}$
(8) $\displaystyle\mathbf{c}(t)$
$\displaystyle=\mathbf{\bar{c}}_{m+1}+(\mathbf{c}_{m+1}-\mathbf{\bar{c}}_{m+1})\exp(-\boldsymbol{\delta}_{m+1}(t-t_{m}))$
(9) $\displaystyle\mathbf{h}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t,e^{h,sp}_{i})$
$\displaystyle=\mathbf{e}_{o_{i}}\cdot\tanh(\mathbf{c}(t))\;\;\;\;\rm{for}\,t\in(t_{m},t_{m+1}]$
(10)

For capturing cumulative knowledge in the historical event sequence, the
vector $\mathbf{k}_{m}(e_{s_{i}},e_{p_{i}},$ $e^{h,sp}_{i})$ concatenates the
neighborhood aggregation based on $\mathbf{O}_{t_{m}}(e_{s_{i}},e_{p_{i}})$
with the embedding vector of the corresponding subject and predicate as the
input of the cLSTM. Equations 9 and 10 make the memory cell vector
$\mathbf{c}(t)$ discontinuously jump to a initial cell state
$\mathbf{c}_{m+1}$ at each update of the cLSTM, and then continuously drift
toward a target cell state $\mathbf{\bar{c}}_{m+1}$, which in turn controls
the hidden state vector
$\mathbf{h}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t,e^{h,sp}_{i})$ as well as the
intensity function. The term $\mathbf{c}_{m+1}-\mathbf{\bar{c}}_{m+1}$ is
related to the degree to which the past events influence the current events.
The influence on each element of $\mathbf{c}(t)$ could be either excitatory or
inhibitory, depending on the sign of the corresponding element of the decaying
vector $\boldsymbol{\delta}_{m+1}$. Thus, the hidden state vector reflects how
the system’s expectations about the next occurrence of a specific event
changes as time elapses and models structural and temporal coherence in the
given tKG.

###  4.4 Inference and Parameter Learning

In this section, we will provide details about how the GHNN perform link
prediction task and time prediction task. Besides, we will introduce the
training procedure of the GHNN.

#### Link prediction

Given an object prediction query $(e_{s_{i}},e_{p_{i}},?,t_{i})$ and its
relevant historical event sequence $e^{h,sp}_{i}$ , we derive the conditional
density function of an object candidate $e_{o}$ from Equation 1, which gives
the following equation,

$\displaystyle
p(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})=\lambda(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})\exp(-\int_{t_{L}}^{t_{i}}\lambda_{surv}(e_{s_{i}},e_{p_{i}},\tau)\,d\tau)$
(11)

where $t_{L}$ denotes the timestamp of the most recent event in
$e^{h,sp}_{i}$, and the integral represents the survival term Daley and Vere-
Jones (2007) of all possible events
$\\{e_{s_{i}},e_{p_{i}},e_{o}=j\\}_{j=1}^{N_{e}}$ with regarding to the given
subject entity $e_{s_{i}}$ and the predicate $e_{p_{i}}$, which is defined as:

$\lambda_{surv}(e_{s_{i}},e_{p_{i}},t)=\sum_{e_{o}=1}^{N_{e}}\lambda(e_{s_{i}},e_{p_{i}},e_{o},t).$
(12)

As shown in Equation 11, all object candidates share the same survival term
$\lambda_{surv}(e_{s_{i}},e_{p_{i}},t)$ and the same value of $t_{L}$. Thus,
at inference time, instead of comparing the conditional density function of
each object candidate $e_{o}$, we can directly compare their intensity
function $\lambda(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$ to avoid the
computationally expensive evaluation of the integrals.

#### Time prediction

For the time prediction task, given an event
$(e_{s_{i}},e_{p_{i}},e_{o_{i}})$, we aim to predict the expected time
instance of its next occurrence based on observed events. Since we have full
information about the involving subject entity and the object entity, we can
utilize both $e^{h,sp}_{i}$ and $e^{h,op}_{i}$. Hence, the intensity that an
event type $(e_{s_{i}},e_{p_{i}},e_{o_{i}})$ occurs at a future time $t$ is
defined as follows:

$\displaystyle\lambda(t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})$
$\displaystyle=f(\mathbf{W}_{\lambda}(\mathbf{e}_{s_{i}}\oplus\mathbf{h}(e_{o_{i}},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})\oplus\mathbf{e}_{p_{i}})\cdot\mathbf{e}_{o_{i}})$
(13)
$\displaystyle+f(\mathbf{W}_{\lambda}(\mathbf{e}_{o_{i}}\oplus\mathbf{h}(e_{s_{i}},e_{o_{i}},e_{p_{i}},t_{i},e^{h,op}_{i})\oplus\mathbf{e}_{p_{i}})\cdot\mathbf{e}_{s_{i}}).$

In the literature, the Hawkes process predicts when the next event will happen
without regarding the event type. In contrast, our task here is to predict the
time instance of the next occurrence of the given event type
$(e_{s_{i}},e_{p_{i}},e_{o_{i}})$. Thus, we use a Hawkes process with a single
event type to perform the time prediction111It can be easily derived from the
Equation 1 that the integration of the density function of the Hawkes process
with a single event type is one.. This gives the corresponding conditional
density function,

$\displaystyle p(t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})=$
(14)
$\displaystyle\lambda(t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})\exp(-\int_{t_{L}}^{t}\lambda(\tau|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})\,d\tau).$

Accordingly, the expectation of the next event time is computed by:

$\hat{t}_{i}=\int_{t_{L}}^{\infty}t\cdot
p(t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})\;dt$ (15)

where the integrals in Equation 14 and 15 are estimated by the trapezoidal
rule (Atkinson, 2008).

#### Parameter learning

Because the link prediction can be viewed as a multi-class classification
task, where each class corresponds to an entity candidate, we use the cross-
entropy loss for learning the link prediction:

$\displaystyle\mathcal{L}_{\rm{link}}^{\rm{sp}}$
$\displaystyle=-\sum_{i=1}^{N}\sum_{c=1}^{N_{e}}y_{c}\log(p(e_{o_{i}}=c|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i}))$
(16) $\displaystyle\mathcal{L}_{\rm{link}}^{\rm{op}}$
$\displaystyle=-\sum_{i=1}^{N}\sum_{c=1}^{N_{e}}y_{c}\log(p(e_{s_{i}}=c|e_{o_{i}},e_{p_{i}},t_{i},e^{h,op}_{i}))$
(17)

where $\mathcal{L}_{\rm{link}}^{\rm{sp}}$ is the loss of object prediction
given the query $(e_{s_{i}},e_{p_{i}},?,t_{i})$ and
$\mathcal{L}_{\rm{link}}^{\rm{op}}$ is the loss of subject prediction given
the query $(?,e_{p_{i}},e_{o_{i}},t_{i})$, and $y_{c}$ is a binary indicator
of whether class label $c$ is the correct classification for predicting
$e_{o_{i}}$ and $e_{s_{i}}$. In addition, we use the mean square error as the
time prediction loss
$\mathcal{L}_{\rm{time}}=\sum_{i=1}^{N}(t_{i}-\hat{t}_{i})^{2}$. Hence, the
total loss is the sum of the time prediction loss and the link prediction
loss:

$\mathcal{L}=\mathcal{L}_{\rm{link}}^{\rm{sp}}+\mathcal{L}_{\rm{link}}^{\rm{op}}+\nu\mathcal{L}_{\rm{time}}.$
(18)

Additionally, we balance the time prediction loss and the link prediction loss
by scaling the former using a hyperparameter $\nu$. The gradient
backpropagation is automatically done by PyTorch (Paszke et al., 2019). The
learning algorithm of the GHNN is described in the Appendix D. Also, we
illustrated the architecture of the GHNN in Appendix E.

##  5 Experiments

###  5.1 Experimental Setup

#### Datasets

Global Database of Events, Language, and Tone (GDELT) Leetaru and Schrodt
(2013) dataset and Integrated Crisis Early Warning System (ICEWS) Boschee et
al. (2015) dataset have been drawing attention in the community as suitable
examples of tKGs Schein et al. (2016). The GDELT dataset is an initiative to
construct a database of all the events across the globe, connecting people,
organizations, and news sources. We use a subset of the GDELT dataset, which
contains events occurring from January 1, 2018 to January 31, 2018. The ICEWS
dataset contains information about political events with specific time
annotations, e.g. (Ban Ki-moon, Secretary-General of, the United Nations,
2007-01-01). We apply our model on a subset ICEWS14 of the ICEWS dataset,
which contains events occurring in 2014. We compare our approach and baseline
methods by performing the link prediction task as well as the time prediction
task on the GDELT dataset and the ICEWS14 dataset. Appendix F provides
detailed statistics about the datasets.

#### Implementation details of the GHNN

By training the GHNN, we set the maximal length of historical event sequences
to be 10, the size of embeddings of entities/predicates to be 200, and the
learning rate to be 0.001. The model is trained using the Adam optimizer. We
set the weight decay rate to be 0.00001, and the batch size to be 1024. The
above configurations were used for all experiments that were done on GeForce
GTX 1080 Ti.

#### Evaluation metrics

In the literature, there are different metrics for evaluating the results of
link prediction on semantic KGs. The mean reciprocal rank (MRR) is one of
those commonly used evaluation metrics, where we remove an entity (subject or
object) of a test triplet $(e_{s_{i}},e_{p_{i}},e_{o_{i}})$, replace it with
by all entities that can potentially be the missing entity, find the rank of
the actual missing entity, and then take the reciprocal value. Besides, some
researchers use Hits@$K$ to evaluate the model’s performance, which is the
percentage that the actual missing entity is ranked in the top $K$. However,
these metrics can be flawed when some corrupted triplets end up being valid
ones, from the training set for instance. In this case, those may be ranked
above the actual missing entity, but this should not be seen as an error
because both triplets are true. Bordes et al. (2013) suggested removing from
the list of corrupted triplets all the triplets that appear either in the
training, validation, or test set except the test triplet of interest, which
ensures that all corrupted triplets do not belong to the dataset. Trivedi et
al. (2017) and Jin et al. (2019) used the ranking technique described in
Bordes et al. (2013) for evaluating the link prediction on temporal KGs. For
example, there is a test quadruple (Barack Obama, visit, India, Jan. 25,
2015), and we perform the object prediction (Barack Obama, visit, ?, Jan. 25,
2015). Besides, we observe (Barack Obama, visit, Germany, Jan. 18, 2013) in
the training set. According to the ranking technique described in Bordes et
al. (2013), (Barack Obama, visit, Germany, Jan. 25, 2015) is considered to be
valid since the triplet (Barack Obama, visit, Germany) appears in the training
set. However, we think this ranking technique is not appropriate for temporal
KGs since the triplet (Barack Obama, visit, Germany) is only temporally valid
on Jan. 18, 2013 but not on Jan. 25, 2015. Therefore, we define a new ranking
procedure. For the object prediction (Barack Obama, visit, ?, Jan. 25, 2015),
instead of removing from the list of corrupted events all the events that
appear either in the training, validation or test set, we only filter from the
list all the events that occur on Jan. 25, 2015. This ensures that the triplet
(Barack Obama, visit, Germany) is still considered as invalid on Jan. 25,
2015. Additionally, since all object candidates are ranked by their scores,
some entities may have identical scores. In this case, most papers give the
highest rank of all entities, leading that the rank may be incredibly high
even if the estimator makes a trivial prediction, i.e. giving identical scores
to all entity candidates. For a fair evaluation, we give a mean rank to
entities that have same scores. For the time prediction task, Trivedi et al.
(2017) used the mean absolute error (MAE) between the predicted time and the
ground-truth to evaluate the experiment results. However, a small part of bad
predictions may lead to a high MAE although the majority of predictions has
good quality. Thus, we propose the continuous Hits@$k$ (cHits@$k$) for the
time prediction task where cHits@$k$ is defined as the ratio of data samples
whose MAE is smaller than $k$.

#### Baseline methods

For the link prediction task, we compare the performance of our model with
several state-of-the-art methods for tKGs, including TTransE Leblay and Chekol
(2018), TA-TransE/Distmult García-Durán et al. (2018), Know-Evolve Trivedi et
al. (2017), and RE-Net Jin et al. (2019). For the time prediction task, we
compare our model only with LiTSEE Xu et al. (2019) and Know-Evolve since only
these two models are capable of performing the time prediction task on tKGs to
the best of our knowledge. We provide the implemetation details of these
baselines in Appendix G.

Table 1: Link prediction results: MRR (%) and Hits@1/3/10 (%).

Datasets | ICEWS14 - filtered | GDELT - filtered
---|---|---
Metrics | MRR | Hits@1 | Hits@3 | Hits@10 | MRR | Hits@1 | Hits@3 | Hits@10
T-TransE | 7.15 | 1.39 | 6.91 | 18.93 | 5.45 | 0.44 | 4.89 | 15.10
TA-TransE | 11.35 | 0.00 | 15.23 | 34.25 | 9.57 | 0.00 | 12.51 | 27.91
TA-Dismult | 10.73 | 4.86 | 10.86 | 22.52 | 10.28 | 4.87 | 10.29 | 20.43
LiTSEE | 6.45 | 0.00 | 7.00 | 19.40 | 6.64 | 0.00 | 8.10 | 18.72
Know-Evolve | 1.42 | 1.35 | 1.37 | 1.43 | 2.43 | 2.33 | 2.35 | 2.41
RE-Net | 28.56 | 18.74 | 31.49 | 48.54 | 22.24 | 14.24 | 23.95 | 38.21
GHNN | 28.71 | 19.82 | 31.59 | 46.47 | 23.55 | 15.66 | 25.51 | 38.92

###  5.2 Performance Comparison on Temporal Knowledge Graphs

#### Link prediction results

Table 1 summarizes link prediction performance comparison on the ICEWS14 and
GDELT datasets. GHNN gives on-par results with RE-Net and outperforms all
other baseline models on these datasets considering MRR, Hits@1/3/10. Know-
Evolve shows poor performance due to its limited capability of dealing with
concurrent events. Additionally, our model beats RE-Net because they only
consider the temporal order between events. In comparison, GHNN explicitly
encodes time information into the intensity function, which improves the
expressivity of our model. The results indicate that the Graph Hawkes Process
substantially enhances the performance of reasoning on tKGs.

#### Time prediction results

Table 2 demonstrates that GHNN performs significantly better than LiTSEE for
the time prediction task on both the ICEWS14 dataset and the GDELT dataset.
This result shows the superiority of the GHNN compared to methods that model
tKGs by merely adding a temporal component into entity embeddings.
Furthermore, Know-Evolve has good results on the ICEWS14 dataset due to its
simplest ground-truth distribution, which is shown in Appendix H. In
particular, according to the settings of Know-Evolve, most ground-truth values
for the time prediction task are exactly zero. The reason is that, for a
ground-truth quadruple $(s,p,o,t)$, Know-Evolve defines the ground-truth value
for time prediction as the difference between the timestamp $t$ and the most
recent timestamp $t^{\prime}$ when either the subject entity $s$ or the object
entity $o$ was involved in an event. However, they do not consider concurrent
events. For example, we have events $e_{1}=(s,p,{o_{1}},t_{1})$ and
$e_{2}=(s,p,{o_{2}},t_{1})$. After $e_{1}$, $t^{\prime}$ becomes $t_{1}$ (most
recent event time of subject $s$), and thus the ground-truth value of $e_{2}$
for the time prediction task is $0$.

Table 2: Time prediction results: MAE and cHits@1/3/10 (%). + indicates
results in this row were taken from (Trivedi et al., 2017).

Datsets | ICEWS14 | GDELT
---|---|---
Metrics | MAE (days) | cHits@1 | cHits@10 | MAE (hours) | cHits@1 | cHits@10
Know-Evolve+ | 1.78 | - | - | 110.8 | - | -
LiTSEE | 108.00 | - | 25.10 | 303.78 | - | 0.00
GHNN | 6.10 | 68.73 | 90.80 | 7.18 | 58.79 | 89.38

##  6 Conclusion

We presented the Graph Hawkes Neural Network, a novel neural architecture for
forecasting on temporal knowledge graphs. To model the temporal dynamics of
tKGs, we proposed the Graph Hawkes Process, a multivariate point process model
of streams of timestamped events, that can capture underlying dynamics across
facts. The model parameters are learned via a continuous-time recurrent neural
network, which is able to estimate the probability of events at an arbitrary
instance in the future. We test our model on two temporal knowledge graphs,
where experimental results demonstrate that our approach outperforms the
state-of-the-art methods on link prediction and time prediction over tKGs.

## References

  * Aalen et al. (2008) Odd Aalen, Ornulf Borgan, and Hakon Gjessing.  _Survival and event history analysis: a process point of view_.  Springer Science & Business Media, 2008.
  * Atkinson (2008) Kendall E Atkinson.  _An introduction to numerical analysis_.  John wiley & sons, 2008.
  * Bacry et al. (2016) Emmanuel Bacry, Thibault Jaisson, and Jean-François Muzy.  Estimation of slowly decreasing hawkes kernels: application to high-frequency order book dynamics.  _Quantitative Finance_ , 16(8):1179–1201, 2016\.
  * Bordes et al. (2013) Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko.  Translating embeddings for modeling multi-relational data.  In _Advances in neural information processing systems_ , pages 2787–2795, 2013.
  * Boschee et al. (2015) Elizabeth Boschee, Jennifer Lautenschlager, Sean O’Brien, Steve Shellman, James Starz, and Michael Ward.  Icews coded event data.  _Harvard Dataverse_ , 12, 2015.
  * Daley and Vere-Jones (2007) Daryl J Daley and David Vere-Jones.  _An introduction to the theory of point processes: volume II: general theory and structure_.  Springer Science & Business Media, 2007.
  * Dettmers et al. (2018) Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel.  Convolutional 2d knowledge graph embeddings.  In _Thirty-Second AAAI Conference on Artificial Intelligence_ , 2018\.
  * Du et al. (2016) Nan Du, Hanjun Dai, Rakshit Trivedi, Utkarsh Upadhyay, Manuel Gomez-Rodriguez, and Le Song.  Recurrent marked temporal point processes: Embedding event history to vector.  In _Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining_ , pages 1555–1564. ACM, 2016.
  * Esteban et al. (2016) Cristóbal Esteban, Volker Tresp, Yinchong Yang, Stephan Baier, and Denis Krompaß.  Predicting the co-evolution of event and knowledge graphs.  In _2016 19th International Conference on Information Fusion (FUSION)_ , pages 98–105. IEEE, 2016.
  * García-Durán et al. (2018) Alberto García-Durán, Sebastijan Dumančić, and Mathias Niepert.  Learning sequence encoders for temporal knowledge graph completion.  _arXiv preprint arXiv:1809.03202_ , 2018.
  * Graves (2013) Alex Graves.  Generating sequences with recurrent neural networks.  _arXiv preprint arXiv:1308.0850_ , 2013.
  * Hamilton et al. (2017) Will Hamilton, Zhitao Ying, and Jure Leskovec.  Inductive representation learning on large graphs.  In _Advances in Neural Information Processing Systems_ , pages 1024–1034, 2017.
  * Hawkes (1971) Alan G Hawkes.  Spectra of some self-exciting and mutually exciting point processes.  _Biometrika_ , 58(1):83–90, 1971.
  * Jiang et al. (2016) Tingsong Jiang, Tianyu Liu, Tao Ge, Lei Sha, Baobao Chang, Sujian Li, and Zhifang Sui.  Towards time-aware knowledge graph completion.  In _Proceedings of COLING 2016, the 26th International Conference on Computational Linguistics: Technical Papers_ , pages 1715–1724, 2016\.
  * Jin et al. (2019) Woojeong Jin, He Jiang, Meng Qu, Tong Chen, Changlin Zhang, Pedro Szekely, and Xiang Ren.  Recurrent event network: Global structure inference over temporal knowledge graph.  _arXiv: 1904.05530_ , 2019.
  * Kazemi et al. (2019) Seyed Mehran Kazemi, Rishab Goel, Sepehr Eghbali, Janahan Ramanan, Jaspreet Sahota, Sanjay Thakur, Stella Wu, Cathal Smyth, Pascal Poupart, and Marcus Brubaker.  Time2vec: Learning a vector representation of time.  _arXiv preprint arXiv:1907.05321_ , 2019.
  * Leblay and Chekol (2018) Julien Leblay and Melisachew Wudage Chekol.  Deriving validity time in knowledge graph.  In _Companion Proceedings of the The Web Conference 2018_ , pages 1771–1776. International World Wide Web Conferences Steering Committee, 2018\.
  * Leetaru and Schrodt (2013) Kalev Leetaru and Philip A Schrodt.  Gdelt: Global data on events, location, and tone, 1979–2012.  In _ISA annual convention_ , volume 2, pages 1–49. Citeseer, 2013\.
  * Liu and Lü (2010) Weiping Liu and Linyuan Lü.  Link prediction based on local random walk.  _Europhysic Letter_ , 89, 01 2010.  doi: 10.1209/0295-5075/89/58007.
  * Ma et al. (2018a) Yunpu Ma, Marcel Hildebrandt, Volker Tresp, and Stephan Baier.  Holistic representations for memorization and inference.  In _UAI_ , pages 403–413, 2018a.
  * Ma et al. (2018b) Yunpu Ma, Volker Tresp, and Erik A Daxberger.  Embedding models for episodic knowledge graphs.  _Journal of Web Semantics_ , page 100490, 2018b.
  * Mei and Eisner (2017) Hongyuan Mei and Jason M Eisner.  The neural hawkes process: A neurally self-modulating multivariate point process.  In _Advances in Neural Information Processing Systems_ , pages 6754–6764, 2017.
  * Minervini et al. (2014) Pasquale Minervini, Claudia d’Amato, Nicola Fanizzi, and Volker Tresp.  Learning to propagate knowledge in web ontologies.  In _URSW_ , pages 13–24. Citeseer, 2014.
  * Nickel et al. (2011) Maximilian Nickel, Volker Tresp, and Hans-Peter Kriegel.  A three-way model for collective learning on multi-relational data.  In _ICML_ , volume 11, pages 809–816, 2011.
  * Ogata (1998) Yosihiko Ogata.  Space-time point-process models for earthquake occurrences.  _Annals of the Institute of Statistical Mathematics_ , 50(2):379–402, 1998.
  * Palm (1943) C. Palm.  _Intensitätsschwankungen im Fernsprechverkehr_.  Number 44. Ericsson technics, 1943.  URL https://books.google.com/books?id=5cy2NQAACAAJ.
  * Paszke et al. (2019) Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al.  Pytorch: An imperative style, high-performance deep learning library.  In _Advances in Neural Information Processing Systems_ , pages 8024–8035, 2019.
  * Sankar et al. (2018) Aravind Sankar, Yanhong Wu, Liang Gou, Wei Zhang, and Hao Yang.  Dynamic graph representation learning via self-attention networks.  _arXiv preprint arXiv:1812.09430_ , 2018.
  * Schein et al. (2016) Aaron Schein, Mingyuan Zhou, David M Blei, and Hanna Wallach.  Bayesian poisson tucker decomposition for learning the structure of international relations.  _arXiv preprint arXiv:1606.01855_ , 2016.
  * Schlichtkrull et al. (2018) Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling.  Modeling relational data with graph convolutional networks.  In _European Semantic Web Conference_ , pages 593–607. Springer, 2018\.
  * Singhal (2012) Amit Singhal.  Introducing the knowledge graph: things, not strings.  _Official google blog_ , 5, 2012.
  * Sun et al. (2019) Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang.  Rotate: Knowledge graph embedding by relational rotation in complex space.  _arXiv preprint arXiv:1902.10197_ , 2019.
  * Trivedi et al. (2017) Rakshit Trivedi, Hanjun Dai, Yichen Wang, and Le Song.  Know-evolve: Deep temporal reasoning for dynamic knowledge graphs.  In _Proceedings of the 34th International Conference on Machine Learning_ , volume 70, pages 3462–3471. JMLR. org, 2017.
  * Trouillon et al. (2017) Théo Trouillon, Christopher R Dance, Éric Gaussier, Johannes Welbl, Sebastian Riedel, and Guillaume Bouchard.  Knowledge graph completion via complex tensor factorization.  _The Journal of Machine Learning Research_ , 18(1):4735–4772, 2017.
  * Xu et al. (2019) Chengjin Xu, Mojtaba Nayyeri, Fouad Alkhoury, Jens Lehmann, and Hamed Shariat Yazdi.  Temporal knowledge graph embedding model based on additive time series decomposition.  _arXiv preprint arXiv:1911.07893_ , 2019.
  * Zhou et al. (2013) Ke Zhou, Hongyuan Zha, and Le Song.  Learning social infectivity in sparse low-rank networks using multi-dimensional hawkes processes.  In _Artificial Intelligence and Statistics_ , pages 641–649, 2013\.

##  A An Example for Illustrating Temporal Knowledge Graphs

Figure 1:  Illustration of a temporal knowledge graph between persons and
countries.

##  B A Cell of Feed-Forward Continuous-Time LSTM

In the following, we take the
$\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$ as an example to
show how the continuous-time LSTM works. Given an object entity query
$(e_{s_{i}},e_{p_{i}},?,t_{i})$ and its relevant historical event sequence
$e^{h,sp}_{i}$, we list the core functions of the continuous-time LSTM Mei and
Eisner [2017] in the following:

$\displaystyle\mathbf{k}_{m}$
$\displaystyle=g(\mathbf{O}_{t_{m}}(e_{s_{i}},e_{p_{i}}))\oplus\mathbf{e}_{s_{i}}\oplus\mathbf{e}_{p_{i}}$
(19) $\displaystyle\mathbf{i}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{i}\mathbf{k}_{m}+\mathbf{U}_{i}\mathbf{h}(t_{m})+d_{i})$
(20) $\displaystyle\mathbf{\bar{i}}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{\bar{i}}\mathbf{k}_{m}+\mathbf{U}_{\bar{i}}\mathbf{h}(t_{m})+d_{\bar{i}})$
(21) $\displaystyle\mathbf{f}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{f}\mathbf{k}_{m}+\mathbf{U}_{f}\mathbf{h}(t_{m})+d_{f})$
(22) $\displaystyle\mathbf{\bar{f}}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{\bar{f}}\mathbf{k}_{m}+\mathbf{U}_{\bar{f}}\mathbf{h}(t_{m})+d_{\bar{f}})$
(23) $\displaystyle\mathbf{z}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{z}\mathbf{k}_{m}+\mathbf{U}_{z}\mathbf{h}(t_{m})+d_{z})$
(24) $\displaystyle\mathbf{o}_{m+1}$
$\displaystyle=\sigma(\mathbf{W}_{o}\mathbf{k}_{m}+\mathbf{U}_{o}\mathbf{h}(t_{m})+d_{o})$
(25) $\displaystyle\mathbf{c}_{m+1}$
$\displaystyle=\mathbf{f}_{m+1}\cdot\mathbf{c}(t_{m})+\mathbf{i}_{m+1}\cdot\mathbf{z}_{m+1}$
(26) $\displaystyle\mathbf{\bar{c}}_{m+1}$
$\displaystyle=\mathbf{\bar{f}}_{m+1}\cdot\mathbf{\bar{c}}_{m}+\mathbf{\bar{i}}_{m+1}\cdot\mathbf{z}_{m+1}$
(27) $\displaystyle\boldsymbol{\delta}_{m+1}$
$\displaystyle=f(\mathbf{W}_{d}\mathbf{k}_{m}+\mathbf{U}_{d}\mathbf{h}(t_{m})+d_{d})\;\;\;\;\mathrm{where}f(x)=\psi\log(1+\exp(x/\psi))$
(28) $\displaystyle\mathbf{c}(t)$
$\displaystyle=\mathbf{\bar{c}}_{m+1}+(\mathbf{c}_{m+1}-\mathbf{\bar{c}}_{m+1})\exp(-\boldsymbol{\delta}_{m+1}(t-t_{m}))$
(29)

Here, $\mathbf{k}$ denotes the input vector; $\mathbf{f}$, $\mathbf{i}$,
$\mathbf{o}$, $\mathbf{z}$, and $\mathbf{c}$ denotes the forget gate, input
gate, output gate, cell update, and discrete cell, respectively;
$\mathbf{c}(t)$ represents the continuous-time cell function,
$\mathbf{\bar{i}}$ and $\mathbf{\bar{f}}$ are additional gates for computing
the continuous-time cell; $\mathbf{\bar{c}}$ represents the target cell state;
and $\boldsymbol{\delta}$ denotes the decaying function. At a timestamp
$t_{m}$, we feed the input $\mathbf{k}_{m}$ into the network and update gate
functions and memory cells. For capturing cumulative knowledge in the
historical event sequence, the input $\mathbf{k}_{m}$ concatenates the
neighborhood aggregation based on $\mathbf{O}_{t_{m}}(e_{s_{i}},e_{p_{i}})$
with the embedding vector of the corresponding subject entity $e_{s_{i}}$ and
predicate $e_{p_{i}}$ as the input of continuous-time LSTM. Formulas 20, 22,
24, 25 and 26 are as same as the gates and the cell in the discrete-time LSTM
Graves [2013] while the gate functions 23 and 21 are designed to formulate
Equation 27 that characterizes the target cell state that the continuous-time
cell function approaches to between two update timestamps $t_{m}$ and
$t_{m+1}$. Equation 28 defines how the continuous-time cell function
approaches to a target cell state $\mathbf{\bar{c}}_{m+1}$ from an initial
cell state $\mathbf{c}_{m+1}$ as the time continue to vary. Thus, The formulas
from 21 to 28 listed above make a discrete update to each state and gate
function. Noticeably, the update does not depend on the hidden state of the
last update $\mathbf{h}(t_{m-1})$ but rather the value $\mathbf{h}(t_{m})$ at
timestamp $t_{m}$.

Equations 29 makes the cell function $\mathbf{c}(t)$ instantaneously jump to a
initial cell state $\mathbf{c}_{m+1}$ at each update of the cLSTM and then
continuously drift toward a target cell state $\mathbf{\bar{c}}_{m+1}$, which
in turn controls the hidden state vector as well as the intensity function.
Thus, between two update timestamps $(t_{m},t_{m+1}]$, $\mathbf{c}(t)$ follows
an exponential curve to approach the target cell state. Equation 30 describes
how $\mathbf{c}(t)$ controls the hidden state vector
$\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t,e^{h,sp})$ that is analogous to
$h_{m}$ in a discrete-time LSTM model that extracts relevant information from
the past event sequence. However, in the architecture of the continuous-time
LSTM Mei and Eisner [2017], it will also reflect the interarrival times
$t_{1}-0$, $t_{2}-t_{1}$, … $t_{m+1}-t_{m}$. The interval $(t_{m},t_{m+1}]$
ends when the next event happens at some time $t_{m+1}$, where the continuous-
time LSTM takes $\mathbf{O}_{t_{m+1}}(e_{s_{i}},e_{p_{i}})$ as the input and
update the current memory cell $\mathbf{c}(t)$ to new initial value
$\mathbf{c}_{m+1}$ based on the hidden state at the timestamp $t_{m+1}$.
Additionally, the term $\mathbf{c}_{m+1}-\mathbf{\bar{c}}_{m+1}$ is related to
the degree to which the past relevant events influence the current events; the
influence on the elements of the vector $\mathbf{c}(t)$ could be either
excitatory or inhibitory, depending on the sign of the corresponding element
of the decaying vector $\boldsymbol{\delta}_{m+1}$.

$\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t,e^{h,sp}_{i})=\mathbf{e}_{o_{i}}\cdot\tanh(\mathbf{c}(t))\;\;\;\;\mathrm{for}\,t\in(t_{m},t_{m+1}]$
(30)

The hidden state $\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$
reflects how the system’s expectations about the next occurrence of a specific
triplet change as time elapses and models the structural and temporal
coherence in the given temporal knowledge graph. This is because, first, the
hidden state $\mathbf{h}(e_{o},e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})$
summarizes historical information of the subject entity $e_{s_{i}}$ involved
in the query and the edges it created in the past. This information is
utilized for computing the compatibility of the subject entity $e_{s_{i}}$ and
candidates for the missing object entity. Again, this accounts for the
behavior that entities tend to form edges with other entities that have
similar recent events. Thus, this recurrent architecture is able to use
historical information to model the intricate non-linear and evolving dynamics
of the given temporal knowledge graph.

##  C The Algorithm of a Continuous-Time LSTM Cell

The Algorithm of a cLSTM cell [Mei and Eisner, 2017] is shown in Algorithm 1.

Input : Input vector $\mathbf{k}_{i}$, $\mathbf{h}(t_{i}),\mathbf{c}(t_{i})$

Output : Memory cell $\mathbf{c}(t)$.

$\mathbf{k}_{m}=g(\mathbf{O}_{t_{m}}(e_{s_{i}},e_{p_{i}}))\oplus\mathbf{e}_{s_{i}}\oplus\mathbf{e}_{p_{i}}$

$\mathbf{i}_{m+1}=\sigma(\mathbf{W}_{i}\mathbf{k}_{m}+\mathbf{U}_{i}\mathbf{h}(t_{m})+d_{i})$

$\mathbf{\bar{i}}_{m+1}=\sigma(\mathbf{W}_{\bar{i}}\mathbf{k}_{m}+\mathbf{U}_{\bar{i}}\mathbf{h}(t_{m})+d_{\bar{i}})$

$\mathbf{f}_{m+1}=\sigma(\mathbf{W}_{f}\mathbf{k}_{m}+\mathbf{U}_{f}\mathbf{h}(t_{m})+d_{f})$

$\mathbf{\bar{f}}_{m+1}=\sigma(\mathbf{W}_{\bar{f}}\mathbf{k}_{m}+\mathbf{U}_{\bar{f}}\mathbf{h}(t_{m})+d_{\bar{f}})$

$\mathbf{z}_{m+1}=\sigma(\mathbf{W}_{z}\mathbf{k}_{m}+\mathbf{U}_{z}\mathbf{h}(t_{m})+d_{z})$

$\mathbf{o}_{m+1}=\sigma(\mathbf{W}_{o}\mathbf{k}_{m}+\mathbf{U}_{o}\mathbf{h}(t_{m})+d_{o})$

$\mathbf{c}_{m+1}=\mathbf{f}_{m+1}\cdot\mathbf{c}(t_{m})+\mathbf{i}_{m+1}\cdot\mathbf{z}_{m+1}$

$\mathbf{\bar{c}}_{m+1}=\mathbf{\bar{f}}_{m+1}\cdot\mathbf{\bar{c}}_{m}+\mathbf{\bar{i}}_{m+1}\cdot\mathbf{z}_{m+1}$

$\boldsymbol{\delta}_{m+1}=f(\mathbf{W}_{d}\mathbf{k}_{m}+\mathbf{U}_{d}\mathbf{h}(t_{m})+d_{d})\;\;\;\;\mathrm{where}f(x)=\psi\log(1+\exp(x/\psi))$

$\mathbf{c}(t)=\mathbf{\bar{c}}_{m+1}+(\mathbf{c}_{m+1}-\mathbf{\bar{c}}_{m+1})\exp(-\boldsymbol{\delta}_{m+1}(t-t_{m}))$

Algorithm 1 A cell of feed-forward continuous-time LSTM

##  D Parameter Learning

The learning algorithm of Graph Hawkes Neural Network is described in the
Algorithm 2. As mentioned in Section 4.2 in the main body we define the set of
object entities interacting with a subject entity $e_{s_{i}}$ under a
predicate $e_{p_{i}}$ at a timestamp $t_{j}(0\leq t_{j}\leq t_{i})$ as
$\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})$. Similarly, we denote the set of
subject entities interacted with the corresponding object entity and the
predicate at $t_{j}$ as $\mathbf{S}_{t_{j}}(e_{o_{i}},e_{p_{i}})$.
Additionally, this algorithm utilizes the cLSTM cell described in the
Algorithm 1.

Input : Sequence of training quadruples $\mathbb{E}$, entity set $E$,
hyperparameter $\nu$, historical event sequences $e^{h,sp}$ and $e^{h,op}$.

Output : A trained network for the time prediction task and the link
prediction task; embeddings for each entity and predicate.

while  _loss does not converge_ do

for  _$e_{i}=(e_{s_{i}},e_{p_{i}},e_{o_{i}},t_{i})$ in $\mathbb{E}$_ do

Initialize the hidden state $\mathbf{h}_{sub},\mathbf{h}_{obj}$ with zero
vector, $t_{L}=0$.

for  _$e^{h,sp}_{i}[t_{j}]$ in $e^{h,sp}_{i}$_ do

if  _$e^{h,sp}_{i}[t_{j}]$ is not a empty set_ then

$g(\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}}))=\frac{1}{|\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})|}\sum_{e_{o}\in\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}})}\mathbf{e}_{o}$

$\mathbf{k}_{j}^{sub}=g(\mathbf{O}_{t_{j}}(e_{s_{i}},e_{p_{i}}))\oplus\mathbf{e}_{s_{i}}\oplus\mathbf{e}_{p_{i}}$

$\mathbf{c}(t)\leftarrow{\rm
cLSTM\\_Cell}(\mathbf{k}_{j}^{sub},\mathbf{h}_{sub},c(t))$

$\mathbf{h}_{sub}(t)=\mathbf{e}_{o_{i}}\cdot\tanh(\mathbf{c}(t))$

$t_{L}=t_{j}$

end if

end for

for  _$e^{h,op}_{i}[t_{j}]$ in $e^{h,op}_{i}$_ do

if  _$e^{h,op}_{i}[t_{j}]$ is not a empty set_ then

$g(\mathbf{S}_{t_{j}}(e_{o_{i}},e_{p_{i}}))=\frac{1}{|\mathbf{S}_{t_{j}}(e_{o_{i}},e_{p_{i}})|}\sum_{e_{s}\in\mathbf{S}_{t_{j}}(e_{o_{i}},e_{p_{i}})}\mathbf{e}_{s}$

$\mathbf{k}_{j}^{obj}=g(\mathbf{S}_{t_{j}}(e_{o_{i}},e_{p_{i}}))\oplus\mathbf{e}_{o_{i}}\oplus\mathbf{e}_{p_{i}}$

$c(t)\leftarrow{\rm cLSTM\\_Cell}(\mathbf{k}_{j}^{obj},\mathbf{h}_{obj},c(t))$

$\mathbf{h}_{obj}(t)=\mathbf{e}_{s_{i}}\cdot\tanh(\mathbf{c}(t))$

$t_{L}\leftarrow\max(t_{L},t_{j})$

end if

end for

$\lambda_{sub}(e_{s_{i}},e_{p_{i}},e_{o},t_{i},e^{h,sp}_{i})=f(\mathbf{W}_{\lambda}(\mathbf{e}_{s_{i}}\oplus\mathbf{W}_{h}\mathbf{h}_{sub}(t)\oplus\mathbf{e}_{p_{i}})\cdot\mathbf{e}_{o})$

$\lambda_{obj}(e_{s},e_{p_{i}},e_{o_{i}},t_{i},e^{h,op}_{i})=f(\mathbf{W}_{\lambda}(\mathbf{e}_{o_{i}}\oplus\mathbf{W}_{h}\mathbf{h}_{obj}(t)\oplus\mathbf{e}_{p_{i}})\cdot\mathbf{e}_{s})$

$p(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i})=\lambda_{sub}(e_{s_{i}},e_{p_{i}},e_{o},t_{i},e^{h,sp}_{i})\exp(-\int_{t_{L}}^{t_{i}}\lambda_{surv}(e_{s_{i}},e_{p_{i}},\tau)\,d\tau)$

$p(e_{s}|e_{o_{i}},e_{p_{i}},t_{i},e^{h,op}_{i})=\lambda_{obj}(e_{s},e_{p_{i}},e_{o_{i}},t_{i},e^{h,op}_{i})\exp(-\int_{t_{L}}^{t_{i}}\lambda_{surv}(e_{o_{i}},e_{p_{i}},\tau)\,d\tau)$

${\mathcal{L}}_{link}(e_{i})=CrossEntropy(p(e_{o}|e_{s_{i}},e_{p_{i}},t_{i},e^{h,sp}_{i}))+CrossEntropy(p(e_{s}|e_{o_{i}},e_{p_{i}},t_{i},e^{h,op}_{i}))$

$\lambda_{t}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t,e^{h,sp}_{i},e^{h,op}_{i})=\frac{1}{2}(\lambda_{sub}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t,e^{h,sp}_{i})+\lambda_{obj}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t,e^{h,op}_{i}))$

$p(t_{i}=t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i})=\lambda_{t}(e_{s_{i}},e_{p_{i}},e_{o_{i}},t)\exp(-\int_{t_{L}}^{t}\lambda_{t}(e_{s_{i}},e_{p_{i}},e_{o_{i}},\tau)\,d\tau)$

${\mathcal{L}}_{time}(e_{i})=(t_{i}-\int_{t_{L}}^{\infty}t\cdot
p(t|e_{s_{i}},e_{p_{i}},e_{o_{i}},e^{h,sp}_{i},e^{h,op}_{i}))^{2}$

${\mathcal{L}}_{e_{i}}={\mathcal{L}}_{{link}}(e_{i})+\mathrm{\nu}{\mathcal{L}}_{\rm{time}}(e_{i})$

end for

$\mathcal{L}=\sum_{e_{i}\in\mathbb{E}}{\mathcal{L}}_{e_{i}}$

Update model parameters.

end while

Algorithm 2 Learning parameters of the GHNN.

##  E Illustration of the GHNN Architecture

As illustrated in figure 2, here we focus on a specific training quadruple
$(e_{s_{i}},e_{p_{i}},e_{o_{i}},t_{i})$, where the embeddings of $e_{s_{i}}$,
$e_{p_{i}}$, and $e_{o_{i}}$ are represented as green nodes, blue nodes and
cyan nodes, respectively. h(t) stands for hidden vector in the cLSTM. $f$ is
the scaled soft-plus function where $f(x)=\psi\log(1+\exp(x/\psi))$. The Graph
Hawkes Neural Network uses the neighborhood aggregation and the Graph Hawkes
Process to summarize events between subject entity $e_{s_{i}}$ and object
entities in $\mathbf{O}_{t}$ as well as events between object entity
$e_{o_{i}}$ with subject entities in $\mathbf{S}_{t}$ at different
timestampes, and derives an intensity function of the quadruple for prediction
tasks.

Figure 2:  Visualization of the Graph Hawkes Neural Network Architecture.

##  F Dataset Statistics

Table 3 provides statistics about the ICEWS14 and GDELT datasets.

Table 3: Statistics of the GDELT dataset and the ICEWS14 dataset. Dataset Name | # Entities | # Predicates | # Quadruples | # Timestamps
---|---|---|---|---
GDELT | 7398 | 239 | 1.97M | 2591
ICEWS14 | 12498 | 254 | 0.49M | 269

##  G Implementation Details of Baseline Methods

We implement TTransE, and TA-TransE/DistMult based on the implementation
provided in Jin et al. [2019]. We use the Adam optimizer to train the baseline
models and optimize hyperparameters by early validation stopping according to
MRR on the validation set. We set the iterations to 1000, the batch size to
1024, the margin to 1.0, and the negative sample ratio to 1. We implement
LiTSEE based on the implementation of TransE Bordes et al. [2013]. We
implement KnowEvolve in PyTorch based on the
sourcecode222https://github.com/rstriv/Know-Evolve. We use the sourcecode for
RE-Net333https://github.com/INK-USC/RE-Net.

##  H Additional Experiments

Table 4 shows the performance comparison on the ICEWS14 and GDELT datasets
with raw metrics. To evaluate static knowledge graph representation learning
methods including ComplEx[Trouillon et al., 2017], RotatE[Sun et al., 2019],
and ConvE[Dettmers et al., 2018], we compress temporal knowledge graphs into a
static, cumulative graph for all the training events by ignoring the edge
timestamps. The results of these static approaches were taken from [Jin et
al., 2019].

Table 4: Additional link prediction results with raw metrics: MRR (%) and
Hits@1/3/10 (%).

Datasets | ICEWS14 - raw | GDELT - raw
---|---|---
Metrics | MRR | Hits@1 | Hits@3 | Hits@10 | MRR | Hits@1 | Hits@3 | Hits@10
RotatE | 9.79 | 3.77 | 9.37 | 22.24 | 3.62 | 0.52 | 2.26 | 8.37
ComplEx | 11.20 | 5.68 | 12.11 | 24.17 | 9.84 | 5.17 | 9.58 | 18.23
ConvE | 21.32 | 12.83 | 23.45 | 38.44 | 18.37 | 11.29 | 19.36 | 32.13
Know-Evolve | 0.05 | 0.00 | 0.00 | 0.10 | 0.11 | 0.00 | 0.02 | 0.10
T-TransE | 4.34 | 0.81 | 3.27 | 10.47 | 5.53 | 0.46 | 4.97 | 15.37
LiTSEE | 5.16 | 0.00 | 4.66 | 14.65 | 6.40 | 0.00 | 7.15 | 18.99
TA-Dismult | 11.29 | 5.11 | 11.60 | 23.71 | 10.34 | 4.44 | 10.44 | 21.63
Re-Net | 23.85 | 14.63 | 26.52 | 42.58 | 19.60 | 12.03 | 20.56 | 33.89
GHNN | 27.36 | 18.51 | 30.27 | 44.90 | 22.34 | 14.78 | 24.09 | 36.92

##  I Time Prediction Ground-Truth Statistics of Know-Evolve and GHNN

As shown in Figure I, the most ground-truth values in the ICEWS14 dataset as
well as in the GDELT dataset for the time prediction task are exactly zero
according to the settings in Know-Evolve. The reason is that, for a ground-
truth quadruple $(s,p,o,t)$, Know-Evolve defines the ground-truth value for
the time prediction task as the difference between the timestamp $t$ and the
most recent timestamp $t^{\prime}$ when either the subject entity $s$ or the
object entity $o$ was involved in an event. However, they don’t consider
concurrent event at the same timestamp, and thus $t$ will become $t^{\prime}$
after one event. For example, we have events $e_{1}=(s,p,{o_{1}},t_{1})$,
$e_{2}=(s,p,{o_{2}},t_{1})$. After $e_{1}$, $t^{\prime}$ will become $t_{1}$,
(most recent interacting timestamp of subject $s$), and thus the ground-truth
value of $e_{2}$ for time prediction will be $0$. Thus, compared to GHNN,
Know-Evolve cannot make long-term predictions since it only predicts $t_{i}$
at latest event time of either $e_{s_{i}}$ or $e_{o_{i}}$, which is very near
to $t_{i}$.

Figure 3: Ground truth of the time prediction task on the GDELT dataset (the
left figure) and the ICEWS14 dataset (the right figure) with regarding to the
settings in Know-Evolve and in GHNN. The orange bars represent the proportions
of each ground-truth value in Know-Evolve while the blue bars represent the
proportions of each ground-truth value in GHNN. Here we can see that the most
ground-truth values in Know-Evolve are zeros, leading to the fact that Know-
Evolve can easily learn the statistics and have high hits@$k$ value for the
time prediction task.


Bogdan Mielnik, Geometry and Quanta

Ingemar Bengtsson111Stockholms Universitet, Fysikum, ORCID:
0000-0002-4203-3180, email<EMAIL_ADDRESS>and Karol
Życzkowski222Institute of Theoretical Physics, Jagiellonian University, Cracow
and Center for Theoretical Physics, Polish Academy of Sciences, Warsaw; ORCID:
0000-0002-0653-3639, email<EMAIL_ADDRESS>
Abstract. We review selected achievements of the late Bogdan Mielnik in the
field of theoretical physics, with an emphasis on his attempts to go beyond
quantum mechanics. Some of his original views on the problems of contemporary
society and organization of science are also recalled.

keywords: Quantum Theory, Foundations of Physics, Bogdan Mielnik

Bogdan Mielnik (1936-2019) graduated in theoretical physics in 1958 at the
University of Warsaw, which at the time was one of the select few places where
the renaissance of general relativity as a central field of physics was being
prepared. Invited by his supervisor Jerzy Plebański, Bogdan went to Mexico and
submitted his PhD thesis [1] on October 22, 1964. He was the very first Ph.D.
graduate of the Physics Department at the Center for Research and Advanced
Studies of the National Polytechnic Institute Cinvestav founded in Mexico City
in 1961. He returned to Poland in 1965. In 1975 he made a memorable visit to
Stockholm, one of the quiet places where the theory of open quantum systems
saw the light of day. He went again to Mexico in 1981 and afterwards shared
his time between the University of Warsaw and Cinvestav. Eventually he
described some of his adventures in the Plebański Festschrift [2].

Figure 1: The entire scientifc career of Bogdan Mielnik was strongly linked to
the University of Warsaw and Cinvestav in Mexico City.

A central theme of Bogdan’s work was to understand why quantum mechanics takes
the shape it does, and whether it needs to be changed (perhaps when taking
gravity into account). When he started out quantum logic gave its answers to
the first question, and made it seem as if no changes in the formalism were
possible. Bogdan—inspired by Günther Ludwig and by Rudolf Haag, if we read his
reference lists correctly—took a more geometrical view of the axioms. Instead
of a lattice of propositions his starting point was the more flexible lattice
of faces of convex bodies. In the late sixties he published two notable papers
[3, 4] in Commun. Math. Phys., in which he explained how the geometry of the
set of states of a physical system is determined by the transition
probabilities associated to idealized experiments. If we impose suitable
‘crystalline symmetries’ on the convex body (the statistical figure in
Bogdan’s terminology) the lattice of faces can be identified with the lattice
of subpaces in a Hilbert space, and hence quantum logic is recovered.

Here we must admit that when (many years later) we wrote a book on the
geometry of quantum theory we borrowed its title [5] from one of these papers.
Fascinated by the originality of his thoughts we also opened our book with a
quotation from another paper of his [6]:

What picture does one see, looking at a physical theory from a distance, so
that the details disappear? Since quantum mechanics is a statistical theory,
the most universal picture which remains after the details are forgotten is
that of a convex set.

Bogdan’s pioneering ideas were appreciated later on, when the development of
the field of quantum information science made the space of quantum states into
a stage on which quantum algorithms can be played.

Figure 2: Sketch of the intrinsic structure of quantum mechanics presented in
the paper of Bogdan on generalized quantum theories [10].

In particular Bogdan took an original view of the concept of the state of a
system. For him the physical system is always open, and subject to the
influences of the universe in which it is placed. It is this mobility that
defines the system. This means that the one-parameter group transformations
generated by a definite Hamiltonian loses its central status. Instead we have
to ask for the motion group, the set of all transformations that the universe
may cause the system to undergo. This leads to the dynamical manipulation
problem that Bogdan initiated in Stockholm, this time inspired by the works of
Willis Lamb and Elihu Lubkin. This problem has a rich technical content in the
framework of orthodox quantum mechanics, and it was to occupy much of his
attention in later years (although the idea to challenge orthodoxy was still
with him, as one can see in his grand review of factorization and
supersymmetric quantum mechanics [7]).

With a persistent enthusiasm Bogdan analyzed the interrelations between
quantum theory and general relativity. He stressed the flexibility introduced
by the latter theory when it went from a fixed spacetime to a dynamically
determined one, and he felt—not surprisingly given his background—that joining
it to the rigid structure of quantum mechanics may violate the innate
aesthetics of general relativity [8].

In the end no satisfactory alternative presented itself. And over the past
fifty years some very important developments have taken place: Quantum theory
has been tested in the laboratory in a wide range of qualitatively new
circumstances, and it has never been found wanting. But one of Bogdan’s papers
[6] starts with a quotation from Stanisław Lem, worth repeating here: It is
well known that dragons do not exist. But each one does it in a different way.
Bogdan presumably quoted from memory, because his version is snappier than the
original. These words can be considered as a prophetic prediction of the
enormous scientific interest in generalized probabilistic theories developed
in the current century, and intended to go beyond standard quantum mechanics.
The contributions in the book edited by Chiribella and Spekkens [9] can be
recommended for an update. We mean no offence if we add that for charm,
originality, and seriousness, Bogdan’s papers still stand supreme.

And concerning quantum gravity, there is as yet no need to make changes to the
conclusion of his 1974 paper [10]: The incompleteness of the present day
science at this point is, perhaps, one more reason why the scheme of quantum
mechanics should not be prematurely closed.

In the late spring of 2000 Ingemar was visiting Poland during a time when
Bogdan was temporarily working in Warsaw. We met him in the small bar at the
old building of the Faculty of Physics at Hoża street, and our discussion
turned out to be inspiring and unforgettable. We recall the details after 20
years. Sipping barszcz (beet root soup) we learned more about the key ideas of
Bogdan on what he referred to as the game of quantum mechanical pick-a-stick
(or ‘jack-straws’—none of us knew the English term). Others know this game as
the problem of quantum control [11]. We also learned about his ideas
concerning nonlinear quantum mechanics [12] and, while savouring pierogi, we
could appreciate his novel approach to the Floquet theory [13, 14] of time
dependent quantum systems. Bogdan’s story was told in such a convincing and
emotional way that we felt that we should put aside all current projects and
start working on this very topic.

A decade later all three of us met again in Białowieża at the 2011 workshop
Geometric Methods in Physics, organized by Anatol Odzijewicz and his
colleagues from Białystok and Mexico to celebrate the 75-th birthday of
Bogdan. It was a remarkable experience to attend several talks explaining the
contribution of Bogdan to our understanding of quanta, and to hear Bogdan
himself describe the state of the art of his programme to explore the role of
convex geometry at the root of physics [15]. Furthermore, we had a unique
chance to meet a crowd of Bogdan’s friends and former students from Mexico,
and to see how much they admire him and his achievements.

Getting to know the Mexican friends of Bogdan in Białowieża Karol was also
admitted to the clan and invited to attend a Quantum Fest event in Mexico
City. During this conference Bogdan presented his view on Non-Inertial
Quantization [16]. It was a remarkable experience to watch Bodgan in action in
his Spanish-speaking environment. Each time he appeared in the Institute or
entered a conference room or even a dining room he immediately attracted
attention, as numerous people wanted to hear what he had to say. It was clear
to us that Bogdan Mielnik has played a key role in the development of
theoretical physics in Mexico.333It is worth mentioning that Bogdan has an
extensive wikipedia webpage in the Spanish version, but up till now, he has
none in Polish nor in English. A brief review of his activity there was
presented by Fernandez [17].

Figure 3: Bogdan Mielnik during the conference Quantum Fest, Tecnológico de
Monterrey, Campus Estado de México, October 2015. Fot. Marco Enriquez

Visiting Mexico City for the very first time is a kind of an adventure even
for an accomplished globetrotter. One can be amazed even looking at the trafic
jams in broad streets with several lanes, which are not resolved by highways
constructed in parallel, the upper lanes just above the lower lanes. For any
visitor driving in this city looks as a real challenge and orientation without
any navigation devices seems impossible.

Bogdan knew the city very well and he explained to us his way of using cabs,
he mastered far before the age of smartphones. You do not tell the driver your
final destination. You just look around and keep saying: La derecha, por
favor. Gire a la izquierda aquí, until you reach your destination. This is
simple. And is really safe.

It looks like the life in Mexico City is not very easy, unless one gets used
to it. As Bogdan did, as he really enjoyed his stay in Mexico and his work in
this culture.

We had a privilege to discuss with Bogdan numerous issues far beyond current
problems of quantum theory. In particular we were interested to learn his
original opinions on contemporary society, organization of science [18] and
recent economic problems [19]. To give reader a glimpse of his thoughts in
this direction we present in the Appendix some quotations from the article on
bureaucracy in science [18].

Appendix. Bogdan’s thoughts on the Bureaucratic World

Selected quotations from the paper of Bogdan [18] are presented below.

* * *

Esteemed Colleagues: The remarks below concern a certain lack of equilibrium
in the present day legislation, affecting the life and science, with rather
adverse consequences for our work.

The damage to science consists not only in our loss of time, but much more in
the fact that the scientist of today is forced to subordinate himself to some
counter-intellectual patterns of reports and planning, forcing him indeed to
accept the professional dishonesty. The most absurd demand he faces is to
present the program (and the time-table) of his future discoveries. Such plans
can bring the best results if they fail …The excursion of Christopher Columbus
[did not] accomplish his original plan to discover the shortest way to India.
The only thing discovered by CC was an obstacle, on which we live today!

New forms of business appear: the enterprises which help the scientists to
formulate their grant requests in terms convincing for the bureaucrats. (The
corruptive consequences are not difficult to guess!)

Four Laws of Bureaucracy:

I. All attempts of the state administrations to improve the scientific work by
bureaucratic projects, reports, etc. will be reduced to zero by the social
organism – though not gratis: the price is an enormous increase of socially
useless work.

II. What is the source of the incredible facility of public administrations in
multiplying endlessly the prescriptions, formalities and obligatory documents?
The reason is that the bureaucrats do not perform the bureaucratic work: they
leave it to their victims.

III. In the bureaucratic environment the problems of little importance are
always infinitely more urgent than the truly important ones. This is why thou
will never do anything important.

IV. The knowledge of the four bureaucracy laws won’t help you in anything.

## References

  * [1] B. Mielnik, Analytic functions of the displacement operator, PhD Thesis, Cinvestav, Mexico City, 1964.
  * [2] B. Mielnik et al., Jerzy Plebański: The quest for new worlds, in Topics in Mathematical Physics, General Relativity and Cosmology in Honor of Jerzy Plebański, ed. H. García-Compeán et al., p. 3, World Scientific 2006.
  * [3] B. Mielnik, Geometry of quantum states, Comm. Math. Phys. 9, 55 (1968).
  * [4] B. Mielnik, Theory of filters, Comm. Math. Phys. 15, 1 (1969).
  * [5] I. Bengtsson and K. Życzkowski, Geometry of Quantum States, Cambridge University Press, Cambridge, 2006.
  * [6] B. Mielnik, Quantum theory without axioms, in Quantum Gravity II. A Second Oxford Symposium, edited by C. J. Isham, R. Penrose, and D. W. Sciama, p. 638, Oxford University Press, 1981.
  * [7] B. Mielnik and O. Rosas-Ortiz, Factorization: little or great algorithm?, J. Phys. A37, 10007, 2004.
  * [8] B. Mielnik, Quantum logic: is it necessarily orthocomplemented?, in Quantum Mechanics, Determinism, Causality and Particles, ed. M. Flato et al., p. 117, Reidel, Dordrecht 1976.
  * [9] Quantum Theory: Informational Foundations and Foils, edited by G. Chiribella and R. W. Spekkens, Springer 2016.
  * [10] B. Mielnik, Generalized quantum mechanics, Comm. Math. Phys. 37, 221 (1974).
  * [11] D. J. Fernández, B. Mielnik, Controlling quantum motion, J. Math. Phys. 35, 2083 (1994).
  * [12] B. Mielnik, Nonlinear quantum mechanics: a conflict with the Ptolomean structure?, Phys. Lett. A 289, 1 (2001).
  * [13] F. J. Delgado–Cepeda and B. Mielnik, Are there Floquet Quanta? Phys. Lett. A 249, 369 (1997).
  * [14] S. Cruz y Cruz and B. Mielnik, The parity phenomenon of the Floquet spectra, Phys. Lett. A 352, 36 (2006).
  * [15] B. Mielnik, Convex geometry: a travel to the limits of our knowledge, in Geometric Methods in Physics XXX Workshop 2011, ed. P. Kielanowski et al., p. 253, Springer, Basel 2013.
  * [16] S. Cruz y Cruz and B. Mielnik, Non-Inertial Quantization: Truth or Illusion? Quantum Fest 2015, J. Physics: Conference Series 698, 012002 (2016).
  * [17] D. J. Fernández, Bogdan Mielnik: Contributions to Quantum Control, in Geometric Methods in Physics XXX Workshop 2011, ed. P. Kielanowski et al., p. 135, Springer, Basel 2013.
  * [18] B. Mielnik, Bureaucratic World: Is it Unavoidable? in Geometric Methods in Physics XXX Workshop 2011, ed. P. Kielanowski et al., p. 425, Springer, Basel 2013.
  * [19] B. Mielnik, From Nicolaus Copernicus’ Economic Law up to the Present Day Economic Disasters, (Report of a Dilettante), in Geometric Methods in Physics XXXIII Workshop 2014, ed. P. Kielanowski et al. p. 315, Birkhäuser, Cham, 2015.


CIFAR10 | 18,894,848 | 27,283,456 | 9,222,848
CIFAR100 | 18,899,456 | 27,288,064 | 9,227,456
Table 1: Number of parameters for model-dataset combinations.

###  F.3 Training and hyperparameters

As described in the main text, the models were trained with SGD until
convergence on the training set. The convergence criteria for MNIST and
CIFAR-10 is a training negative log-likelihood (NLL) of $<5\times 10^{-5}$ and
a training accuracy of $100\%$, and for CIFAR-100 these are a NLL of $<1\times
10^{-2}$ and a training accuracy of $>99\%$. We use two different batch sizes
($b=50,100$) and a diversity of learning rates ($\eta$) to generate a large
range of $\eta/b$ values. Table 2 presents the $\eta/b$ values created for
each experiment setting. The varying nature of these ranges are due to the
fact that different $\eta/b$ values might lead to heavy-tailed behavior or
divergence under different points in this hyperparameter space. Source code
includes the enumerations of specific combinations of these hyperparameters
for all settings.

| FCN4 | FCN6 | CNN
---|---|---|---
MNIST |  $5\times 10^{-5}$ to $1.14\times 10^{-2}$ |  $5\times 10^{-5}$ to $8.8\times 10^{-3}$ |  $1\times 10^{-5}$ to $6.35\times 10^{-3}$
CIFAR10 |  $5\times 10^{-5}$ to $2.7\times 10^{-3}$ |  $2.5\times 10^{-5}$ to $4\times 10^{-3}$ |  $1\times 10^{-5}$ to $1.5\times 10^{-3}$
CIFAR100 |  $1\times 10^{-5}$ to $1.6\times 10^{-3}$ |  $1\times 10^{-5}$ to $2.25\times 10^{-3}$ |  $1\times 10^{-5}$ to $7\times 10^{-4}$
Table 2: The ranges of $\eta/b$ for all experiments.

###  F.4 Tail-index estimation

The multivariate estimator proposed by [36] was used for tail-index
estimation:

######  Theorem 14 ([36, Corollary 2.4]).

Let $\\{X_{i}\\}_{i=1}^{K}$ be a collection of i.i.d. random vectors where
each $X_{i}$ is multivariate strictly stable with tail-index $\alpha$, and
$K=K_{1}\times K_{2}$. Define $Y_{i}:=\sum_{j=1}^{K_{1}}X_{j+(i-1)K_{1}}\>$
for $i\in\\{1,\dots,K_{2}\\}$. Then, the estimator

$\displaystyle\widehat{\phantom{a}\frac{1}{\alpha}\phantom{a}}\triangleq\frac{1}{\log
K_{1}}\Bigl{(}\frac{1}{K_{2}}\sum_{i=1}^{K_{2}}\log\|Y_{i}\|-\frac{1}{K}\sum_{i=1}^{K}\log\|X_{i}\|\Bigr{)}$
(63)

converges to $1/{\alpha}$ almost surely, as $K_{2}\rightarrow\infty$.

Previous deep learning research such as [47, 45, 3] have also used this
estimator. As described in the main text, tail-index estimation is conducted
on the ergodic averaged version of the parameters, an operation which does not
change the tail-index of the parameters, to conform to this estimator’s
assumptions. We use the columns of parameters in FCN’s and specific filter
parameters in CNN as the random vectors instances for the multivariate
distribution. Before conducting the tail-index estimation we center the
parameters using the index-wise median values. We observe that (i) centering
with mean values, and/or (ii) using the alternative univariate tail-index
estimator [36, Corollary 2.2] from the same paper produces qualitatively
identical results. We also observe that using alternative tail index
estimators with symmetric $\alpha$-stable assumption produces no qualitatively
significant differences in the estimated values [42].

###  F.5 Hardware and software resources

The computational resources for the experiments were provided by a research
institute. The bulk of the resources were expended on the real data
experiments, where a roughly equal division of labor between Nvidia Titan X,
1080 Ti, and 1080 model GPU’s. Our results rely on 273 models, training of
which brings about a GPU-heavy computational workload. The training of a
single model took approximately 4.5 hours, with an approximate estimated total
GPU time for the ultimate results 1270 hours. This total also includes the
training time for the 40 models which diverged during training, with the
training stopping around 1 hour mark on average. The computational time
expended for tail-index estimation in real data experiments and the totality
of synthetic experiments amounted to approximately 20 hours of computation
with similar hardware as described above.

The experiments were implemented in the Python programming language. For the
real data experiments, the deep learning framework PyTorch [38] was
extensively used, including the implementation methodology in some of its
tutorials444https://github.com/pytorch/vision/blob/master/torchvision/models/vgg.py.
PyTorch is shared under the Modified BSD License.