Question: Can they also provide reference to some relevant works that have explicitly identified such patterns?
Evidence: We begin with bridging logical expressions and graph patterns based on two intuitions/assumptions:
• A relation can often be inferred from other relations with a combination of simple logical rules that do not involve too many nodes. • One can predict relation existence by finding whether the subgraphs containing the pair are similar to the subgraphs containing an edge with the same relation.
Take Figure as an example where we wish to predict whether Person E lives in London.
An example of the first intuition goes as follows: if Person E watches the soccer matches with club Arsenal, which is based in London, then Person E may also live in London. However, such logical rules (so called chain-like logic rules in) may not always hold, requiring probabilistic inference. For instance, Person G watches the matches with FC Barcelona, which is Based in Barcelona, but he does not live in the same city. To make more accurate predictions, we need to combine other possible logical rules, such as "Friends often live in the same city" -in this case, Person E and Person H are friends, and Person H lives in London (some of them construct certain patterns are called tree-like logic rules or graph-like rules).
The second intuition tells us that we can predict whether Person E lives in London by checking if the subgraphs containing the pair (Person E, London) (named target subgraphs, e.g. Person E -Arsenal -London) are similar to the subgraphs containing a live relation (named supporting subgraphs, e.g. Person I -Chelsea -London). Similarity computation is done by a neural network. To determine whether the two sets of subgraphs are similar, we additionally compare the target subgraphs against another set of subgraphs that do not contain the relation (named refuting subgraphs, e.g. Person E -Person G -Barcelona) as a baseline. A variety of options exist for selecting the refuting subgraphs, ranging from selecting those having the same topology regardless of the actual relation types, to those having both the same shape and relation types.
In addition, we do not include the edge of live in the supporting subgraphs to avoid information leakage. We also require the supporting subgraphs and refuting subgraphs to have the same shape as that of the target subgraphs in order to make similarity computation focus more on the node features and relation types rather than the topology, and that is why we call both supporting subgraphs and refuting subgraphs analogy subgraphs. This enables us to predict live relation with the pipeline above without learning an explicit embedding for live relation, unlike prior works. The reason is that the information of live relation can be implicitly expressed by the other relations found in the supporting and refuting subgraphs, e.g. live can be expressed by watch and based. This serves as the basis for our model's generalizability to relations that have no occurrence in the training set.
We can describe what kind of subgraphs we are looking for in the above example with logical expressions. The target subgraphs above will have the logical expression Source(x) ∧ Target(y) ∧ Edge(x, z) ∧ Edge(z, y), where Source(x) means if node x is the source node s, Target(y) means if node y is the target node t, and Edge(x, z) means if there exists an edge regardless of relation type between x and z. Our task is to determine whether an edge of relation type r exists between s and t. The supporting subgraphs will have Edge(x, z) ∧ Edge(z, y) ∧ Edge r (x, y), meaning that the subgraph can be any 3-cycle except that there must be an edge with relation type r. The refuting subgraphs will have Edge(x, z) ∧ Edge(z, y) ∧ ¬Edge r (x, y), meaning that it can be any 2-path except that the starting node and ending node must not have an edge with relation r in between. This leads to the concept of graph patterns, defined as follows:
Definition 1 (Graph Pattern). A graph pattern is a logical function that takes in a subgraph as input and returns a boolean value, consisting of logical operators (¬, ∧, ∨) as well as indicator operators determined by the existence of nodes and edges, the latter includes:
• Source(x) and Target(x), returning true iff x is the source node and target node, respectively.
• Edge(x, y), returning true iff there exists an edge between node x and y.
• Edge r (x, y), returning true iff there exists an edge of relation r between node x and y.
We call a subgraph S matches a graph pattern Π if true is returned when S is applied to Π. Such operation is already well supported in graph databases, and in the following sections we give more efficient algorithms that perform matching with simple patterns.
Take Figure 1 as an example where we wish to predict whether Person E lives in London. An example of the ﬁrst intuition goes as follows:  if Person E watches the soccer matches with club Arsenal, which is based in London, then Person E may also live in London. However, such logical rules (so called chain-like logic rules in (Yang et al., 2017)) may not always hold, requiring probabilistic inference. For instance, Person G watches the matches with FC Barcelona, which is Based in Barcelona, but he does not live in the same city. To make more accurate predictions, we need to combine other possible logical rules, such as “Friends often live in the same city” - in this case, Person E and Person H are friends, and Person H lives in London (some of them construct certain patterns are called tree-like logic rules (Yang & Song, 2019) or graph-like rules (Shi et al., 2020)).
Answer: We added some references about using chain [3], tree [4], and graph [5] structures to represent the logical rules. We have updated Section 2 in the revised PDF.
[3] Differentiable Learning of Logical Rules for Knowledge Base Reasoning. Yang et al., NIPS 2017.
[4] Learn to Explain Efficiently via Neural Logic Inductive Learning. Yang et al., ICLR 2020.
[5] Differentiable Learning of Graph-like Logical Rules from Knowledge Graphs. Shi et al., arXiv 2021.