如何编写 Cypher 查询来检查节点之间的交换性

Question

我需要检查节点之间的交换性。跨节点有 3 个关系被跟踪如下：aabbca、aabcba、aacbba。现在可以清楚地看到，每个 b 和 c 节点放在一起的地方它们通勤。下面我使用关于如何生成图表的查询。

这是我的图表：

CREATE (x1:Node {title:'a'})

CREATE (x2:Node {title:'a'})

CREATE (x3:Node {title:'b'})

CREATE (x4:Node {title:'b'})

CREATE (x5:Node {title:'c'})

CREATE (x6:Node {title:'a'})

CREATE (x1) - [:transition {id:[1]}] -> (x2)

CREATE (x2) - [:transition {id:[1]}] -> (x3)

CREATE (x3) - [:transition {id:[1]}] -> (x4)

CREATE (x4) - [:transition {id:[1]}] -> (x5)

CREATE (x5) - [:transition {id:[1]}] -> (x6)

CREATE (x1) - [:transition {id:[2]}] -> (x2)

CREATE (x2) - [:transition {id:[2]}] -> (x3)

CREATE (x3) - [:transition {id:[2]}] -> (x5)

CREATE (x5) - [:transition {id:[2]}] -> (x4)

CREATE (x4) - [:transition {id:[2]}] -> (x6)

CREATE (x1) - [:transition {id:[3]}] -> (x2)

CREATE (x2) - [:transition {id:[3]}] -> (x5)

CREATE (x5) - [:transition {id:[3]}] -> (x3)

CREATE (x3) - [:transition {id:[3]}] -> (x4)

CREATE (x4) - [:transition {id:[3]}] -> (x6)

这会产生如下内容：

现在为了清楚地识别可交换节点，我继续使用以下查询根据关系 id 1 & 2、1 & 3 和 2 & 3 进行过滤，我得到了相应的图表：

MATCH (a)-[r]->(b) WHERE 1 IN r.id OR 2 In r.id  RETURN a,r,b 
MATCH (a)-[r]->(b) WHERE 1 IN r.id OR 3 In r.id  RETURN a,r,b
MATCH (a)-[r]->(b) WHERE 2 IN r.id OR 3 In r.id RETURN a,r,b

案例 1： 案例 2:: 案例3：

case 2 的圆圈部分，对于我们的示例只有 2 个节点，但在一般情况下它可以有 1 个 （就像我们在 case 1 中看到的> & case 3) 到 N 个节点，其中 N 是有限数。

现在已经说过了，我想创建一个密码查询来检查图中是否存在这样的可交换节点，并基于此我需要使用如下查询从图中获取节点和关系：

MATCH (a)-[r]->(M)-[r]->(K)-[r]->[b], 
(b)-[s]->(K)-[s]->(M)-[s]->(a)
WHERE r.id <> s.id 
AND M is returning minimum 1 node
AND K is returning minimum 1 node
RETURN a,r,M,K,s,b

K = M 

M = MATCH (O)-[r]->(b1), (N)-[r]->(P)->[s]->(N)
WHERE  
(b1 = b
RETURN b)
OR 
(N = M AND P = M
AND N is returning at least 1 node
AND P is returning at least 1 node 
RETURN N,r,P,s)

此时我可能还没有清楚地定义我的约束，但我需要帮助的是正确表示上述查询。任何人都可以帮忙吗？

---

更新： 我刚刚解决了案例 1 和案例 3（它们基本上是相同类型的条件），但这不是通用解决方案。在通用解决方案中，案例 2 也可以。：

MATCH (a)-[r]->(b)-[s]->(c)-[t]->(d)
WHERE (1 IN r.id OR 2 IN r.id) 
AND (1 IN s.id OR 2 IN s.id) 
AND (1 IN t.id OR 2 IN t.id)
WITH a,r,b,s,c,t,d
MATCH (a)-[r1]->(c)-[s1]->(b)-[t1]->(d)
WHERE ( r <> r1 AND (1 IN r1.id OR 2 IN r1.id)) AND
(s<>s1 AND (1 IN s1.id OR 2 IN s1.id)) AND
(t<>t1 AND (1 IN t1.id OR 2 IN t1.id)) 
RETURN a,r,r1,b,s,s1,c,t,t1,d

MATCH (a)-[r]->(b)-[s]->(c)-[t]->(d)
WHERE (3 IN r.id OR 2 IN r.id) 
AND (3 IN s.id OR 2 IN s.id) 
AND (3 IN t.id OR 2 IN t.id)
WITH a,r,b,s,c,t,d
MATCH (a)-[r1]->(c)-[s1]->(b)-[t1]->(d)
WHERE ( r <> r1 AND (3 IN r1.id OR 2 IN r1.id)) AND
(s<>s1 AND (3 IN s1.id OR 2 IN s1.id)) AND
(t<>t1 AND (3 IN t1.id OR 2 IN t1.id)) 
RETURN a,r,r1,b,s,s1,c,t,t1,d

Answer 1

// A nested loop through the IDs:
UNWIND RANGE(1,3) as i1 WITH i1
    UNWIND RANGE(i1+1,3) as i2 WITH i1, i2

// Take a pathways for each pair of IDs:
MATCH p1 = (N1:Node)-[:transition*5 {id:[i1]}]->(N2:Node), 
      p2 = (N1:Node)-[:transition*5 {id:[i2]}]->(N2:Node)

// Take the nodes of each path:
WITH i1, i2, 
     nodes(p1) as p1, 
     nodes(p2) as p2

WITH i1, i2, p1, p2, 
     // Check whether the nodes are different:
     REDUCE(acc = [], x in RANGE(0, size(p1)-1) | 
            acc + [ { i:x, 
                      is: (p1[x] <> p2[x]) AND 
                          (p1[x]['title'] <> p2[x]['title']) 
                    } ]
     ) as isComm

WITH i1, i2, p1, p2,
     // Take only those nodes that are different: 
     FILTER(pair in isComm WHERE pair['is'] = true) as isComm

RETURN i1 as id1, i2 as id2,
       // Convert a map to an array:
       REDUCE(acc = [], pair in isComm | 
              acc + [ [ p1[pair['i']], 
                        p2[pair['i']]
                    ] ] 
       ) as commutative