Cypher: Quantifying over zero or more node-then-relations - neo4j

Question

I want to return all nodes a and b, where b is not downstream of a via any path that begins with relation rel. I keep finding myself having to write one condition for the case where a is linked directly to b via rel, and one for the indirect case, leading to something like this:
//Semi-pseudo-code.
match (a)-[*]->(b)
optional match dir=(a)-[:rel]->(b)
optional match indir=(a)-[:rel]-()-[*]->(b)
where length(dir)=0
and length(indir)=0
return a,b
Is there any easier way? Really I want something like this, where the bare quantifier means "zero or more nodes-then-relations":
match (a)-[*]->(b)
match not (a)-[:rel]-*->(b)
return a,b
Note: I suspect this may at root be the same as my last question: Cypher: Matching nodes at arbitrary depth via a strictly alternating set of relations

Answer 1

We can use WHERE NOT to formulate negative conditions, in a similar fashion to your second semi-pseudocode:
MATCH (a)-[*]->(b)
WHERE NOT ((a)-[:rel]->()-[*1..]->(b))
RETURN a, b
Of course, this will be anything but efficient, so you should at least try to restrict the labels of a and b and the relationships between them, e.g. (a:Label1)-[:rel1|rel2*]->(b:Label2)
An example:
CREATE
(n1:N {name: "n1"}),
(n2:N {name: "n2"}),
(n3:N {name: "n3"}),
(n4:N {name: "n4"}),
(n5:N {name: "n5"}),
(n1)-[:x]->(n2),
(n3)-[:rel]->(n4),
(n4)-[:x]->(n5)
The query results in:
╒══════════╤══════════╕
│a │b │
╞══════════╪══════════╡
│{name: n1}│{name: n2}│
├──────────┼──────────┤
│{name: n4}│{name: n5}│
└──────────┴──────────┘
As you can see, it does not include n3 and n5, as it starts with a :rel relationship.

Answer 2

This should work:
MATCH (a)-[rs*]->(b)
WHERE TYPE(rs[0]) <> 'rel'
RETURN a, b;
However, the query below should be much more performant, as it filters out all unwanted path beginnings before it does the very expensive variable-length path search. The *0.. syntax makes the variable-length search use a lower bound of 0 for the length (so x will also be returnable as b).
MATCH (a)-[r]->(x)
WHERE TYPE(r) <> 'rel'
MATCH (x)-[*0..]->(b)
RETURN a, b;