Variable-Length and Quantified Path Patterns: Bounds, Semantics, and Combinatorial Risk

Learning outcomes

AtlasMart wants to answer questions such as “which operational points can a supplier reach within four handoffs?” That sounds simple until branching and cycles turn one start node into many path candidates. This lesson builds the path mental model before the graph becomes large enough to hide mistakes.

1. Variable length means “many candidate paths,” not “one recursive lookup”

A path is an ordered alternating sequence of nodes and relationships. A path pattern describes which paths are acceptable. With a fixed-length pattern, each relationship position is explicit. With a variable-length or quantified pattern, one textual fragment may represent many path lengths and many concrete paths. The number of results therefore depends on graph degree, direction, relationship type, predicates, and the allowed depth—not only on the number of nodes.

2. Build the cyclic fixture, then count by bounded depth

CYPHER 25CREATE CONSTRAINT supplier_id IF NOT EXISTS FOR (s:Supplier) REQUIRE s.supplierId IS UNIQUE;CREATE CONSTRAINT category_id IF NOT EXISTS FOR (c:Category) REQUIRE c.categoryId IS UNIQUE;CREATE CONSTRAINT store_id IF NOT EXISTS FOR (s:Store) REQUIRE s.storeId IS UNIQUE;CREATE CONSTRAINT ops_point_id IF NOT EXISTS FOR (n:OpsPoint) REQUIRE n.pointId IS UNIQUE;MERGE (s1:Supplier {supplierId:'SUP-3001'}) SET s1:OpsPoint, s1.pointId='OP-SUP-1', s1.name='Northwind Optics';MERGE (s2:Supplier {supplierId:'SUP-3002'}) SET s2:OpsPoint, s2.pointId='OP-SUP-2', s2.name='Audio Forge';MERGE (c1:Category {categoryId:'CAT-CAMERAS'}) SET c1:OpsPoint, c1.pointId='OP-CAT-CAM', c1.name='Cameras';MERGE (c2:Category {categoryId:'CAT-AUDIO'}) SET c2:OpsPoint, c2.pointId='OP-CAT-AUD', c2.name='Audio';MERGE (st1:Store {storeId:'ST-001'}) SET st1:OpsPoint, st1.pointId='OP-ST-1', st1.name='Central', st1.region='west';MERGE (st2:Store {storeId:'ST-002'}) SET st2:OpsPoint, st2.pointId='OP-ST-2', st2.name='Harbor', st2.region='east';MERGE (st3:Store {storeId:'ST-003'}) SET st3:OpsPoint, st3.pointId='OP-ST-3', st3.name='Airport', st3.region='north';MATCH (s1:OpsPoint {pointId:'OP-SUP-1'}), (s2:OpsPoint {pointId:'OP-SUP-2'}),      (c1:OpsPoint {pointId:'OP-CAT-CAM'}), (c2:OpsPoint {pointId:'OP-CAT-AUD'}),      (st1:OpsPoint {pointId:'OP-ST-1'}), (st2:OpsPoint {pointId:'OP-ST-2'}), (st3:OpsPoint {pointId:'OP-ST-3'})MERGE (s1)-[:HANDOFF_TO {routeId:'R01', minutes:30, active:true}]->(st1)MERGE (s1)-[:HANDOFF_TO {routeId:'R02', minutes:10, active:true}]->(c1)MERGE (c1)-[:HANDOFF_TO {routeId:'R03', minutes:8, active:true}]->(st1)MERGE (c1)-[:HANDOFF_TO {routeId:'R04', minutes:5, active:true}]->(c2)MERGE (st1)-[:HANDOFF_TO {routeId:'R05', minutes:12, active:true}]->(s2)MERGE (st1)-[:HANDOFF_TO {routeId:'R06', minutes:11, active:false}]->(c2)MERGE (s2)-[:HANDOFF_TO {routeId:'R07', minutes:9, active:true}]->(c2)MERGE (s2)-[:HANDOFF_TO {routeId:'R08', minutes:6, active:true}]->(st2)MERGE (c2)-[:HANDOFF_TO {routeId:'R09', minutes:7, active:true}]->(st2)MERGE (st2)-[:HANDOFF_TO {routeId:'R10', minutes:14, active:true}]->(s1)MERGE (st2)-[:HANDOFF_TO {routeId:'R11', minutes:4, active:true}]->(st3)MERGE (st3)-[:HANDOFF_TO {routeId:'R12', minutes:13, active:true}]->(c1);

CYPHER 25MATCH (s:OpsPoint {pointId:'OP-SUP-1'})CALL (s) {  MATCH p=(s)-[:HANDOFF_TO]->{1,2}(:OpsPoint)  RETURN count(p) AS upTo2}CALL (s) {  MATCH p=(s)-[:HANDOFF_TO]->{1,4}(:OpsPoint)  RETURN count(p) AS upTo4}CALL (s) {  MATCH p=(s)-[:HANDOFF_TO]->{1,6}(:OpsPoint)  RETURN count(p) AS upTo6}RETURN upTo2, upTo4, upTo6;

The exact counts are deterministic for this fixture but are intentionally not hard-coded here because the generation environment did not execute Neo4j. The invariant to prove is monotonic growth: allowing more depth cannot reduce the set of matching paths. On a branching cyclic graph, the increase can be much faster than the node count suggests.

3. Quantified path patterns can prune while traversing

Current quantified path patterns allow predicates inside the repeated fragment. That is more useful than enumerating every path first and filtering afterward because the engine can reject candidate extensions during traversal.

CYPHER 25MATCH (s:OpsPoint {pointId:$source}),      (target:Store:OpsPoint {storeId:$storeId})MATCH p=(s)        ((a:OpsPoint)-[r:HANDOFF_TO]->(b:OpsPoint)          WHERE r.active = true){1,5}        (target)RETURN length(p) AS hops,       [n IN nodes(p) | n.pointId] AS points,       [r IN relationships(p) | r.routeId] AS routesORDER BY hops, points;

The predicates belong inside the quantified fragment because they describe which relationship extensions are legal. Bounds remain essential even when predicates are selective: a future data change can increase degree or create new cycles.

4. Make planning and execution evidence explicit

CYPHER 25 EXPLAINMATCH p=(:OpsPoint {pointId:'OP-SUP-1'})-[:HANDOFF_TO]->{1,5}(:OpsPoint)RETURN count(p);CYPHER 25 PROFILEMATCH p=(:OpsPoint {pointId:'OP-SUP-1'})-[:HANDOFF_TO]->{1,5}(:OpsPoint)RETURN count(p);

EXPLAIN does not execute; use it to inspect estimated cardinality and access choices. PROFILE executes and adds actual row/db-hit/memory evidence. Operator names and estimates can change by release/runtime, so record the server/Cypher version and interpret the trend rather than teaching one plan screenshot as universal truth.

5. Deliberately wrong approach: “no upper bound because the graph is small”

CYPHER 25MATCH (s:OpsPoint {pointId:$source})MATCH p=(s)-[:HANDOFF_TO]->{1,4}(target:Store:OpsPoint)WHERE target.region=$regionRETURN target.storeId, min(length(p)) AS minimumHopsORDER BY minimumHops, target.storeId;

Production judgment starts with a question contract: maximum meaningful depth, acceptable timeout, expected degree distribution, target selectivity and whether the application needs all paths, one path, existence, or only the nearest result. The next lesson shows another cardinality trap: optional patterns that preserve rows until a predicate is placed in the wrong scope.

Summary and next step

Variable-Length and Quantified Path Patterns: Bounds, Semantics, and Combinatorial Risk is useful only when its assumptions and observed evidence stay attached to the decision. The examples above establish a reproducible mechanism and boundary; they do not turn one lab result into a universal production rule.

Next, continue to OPTIONAL MATCH and Null Introduction: Preserving Rows Without Accidentally Filtering Them Away. Carry forward the verified assumptions, fixture state, version/edition boundaries, and measurements from this lesson instead of treating the next topic as an isolated recipe.

Authoritative references

• Current Neo4j versions — Official current-release and 5.26 LTS patch snapshot.
• Cypher Manual introduction — Current Cypher 25 baseline and Cypher 5 compatibility framing.
• Patterns — Current graph/path matching overview, including shortest paths and match/path modes.
• Variable-length paths — Quantified path patterns, quantified relationships, group variables and inline predicates.
• Variable-length path reference — Formal syntax and rules for quantified and legacy variable-length patterns.
• Path-pattern reference — Path values, path-pattern composition and matching rules.
• Unique relationship paths — Default relationship-uniqueness behavior and DIFFERENT RELATIONSHIPS semantics.
• Match modes and path modes — Current Cypher 25 WALK/TRAIL/ACYCLIC and match-mode compatibility rules.
• OPTIONAL MATCH — Outer-row preservation and null introduction when a pattern is absent.
• WHERE — WHERE as a subclause of MATCH/OPTIONAL MATCH and its pattern-scoping consequences.
• Path functions — nodes(), relationships(), length()/path_length() and path-related list/predicate functions.
• Shortest paths — Current SHORTEST/ALL SHORTEST path selector semantics.
• Query plans and operators — Execution-plan operators and row/db-hit/memory evidence.
• GDS graph algorithms — Graph Data Science algorithm families including path finding.
• GDS Dijkstra source-target — Weighted positive-edge shortest-path algorithm for projected GDS graphs.