Cypher query to find shortest partial paths and aggregate the result - neo4j

Question

I am trying to find the minimum checkpoints that were traversed between the nodes for each person. There are multiple paths that can be traversed by each person.
Example:
CREATE
(:person {id: 0}),
(:person {id: 1})-[:rel1]->(:chkpt1 {id: '1'})-[:rel2]->(:chkpt2 {id: '2'}),
(:person {id: 2})-[:rel1]->(:chkpt1 {id: '1_1'}),
(:person {id: 2})-[:rel1]->(:chkpt1 {id: '1_2'})-[:rel2]->(:chkpt2 {id: '2_1'}),
(:person {id: 2})-[:rel1]->(:chkpt1 {id: '1_3'})-[:rel2]->(:chkpt2 {id: '2_2'})-[:rel3]->(:chkpt3 {id: '3_1'}),
(:person {id: 3})-[:rel1]->(:chkpt1 {id: '1_4'})-[:rel2]->(:chkpt2 {id: '2_3'})-[:rel3]->(:chkpt3 {id: '3_2'}),
(:person {id: 3})-[:rel1]->(:chkpt1 {id: '1_5'})-[:rel2]->(:chkpt2 {id: '2_4'})-[:rel3]->(:chkpt3 {id: '3_3'}),
(:person {id: 3})-[:rel1]->(:chkpt1 {id: '1_6'})-[:rel2]->(:chkpt2 {id: '2_5'})-[:rel3]->(:chkpt3 {id: '3_4'})
Currently, I am using the OPTIONAL MATCH clause and running multiple queries as follows:
MATCH (p:person)
OPTIONAL MATCH (p)-[:rel1]-(cp1:chkpt1)
WITH p, cp1
WHERE cp1 IS NULL
RETURN p.id
Returns: person0
Then I run a separate query to find all the persons that didn't make it to the next checkpoint.
MATCH (p:person)-[:rel1]-(cp1:chkpt1)
OPTIONAL MATCH (cp1)-[:rel2]-(cp2:chkpt2)
WITH p, cp1, cp2
WHERE cp2 IS NULL
RETURN DISTINCT p.id, cp1.id
Returns: person2
Similarly for the next checkpoint.
MATCH (p:person)-[:rel1]-(cp1:chkpt1)-[:rel2]-(cp2:chkpt2)
OPTIONAL MATCH (cp2)-[:rel3]-(cp3:chkpt3)
WITH p, cp1, cp2, cp3
WHERE cp3 IS NULL
RETURN DISTINCT p.id, cp1.id, cp2.id
Returns: person1 and person2
I want to return only person1 as person2 missed previous traversals.
MATCH (p:person)-[:rel1]-(cp1:chkpt1)-[:rel2]-(cp2:chkpt2)-[:rel3]-(cp3:chkpt3)
RETURN DISTINCT p.id, cp1.id, cp2.id
Returns: person2 and person3
However, I want to only return person3 as person2 did not make it to chkpt3 and chkpt2.
I need to not include the persons that have already been excluded because they did not make it to the previous checkpoint on another traversal.
Example:
person1 should only show up that they did not make it to chkpt1.
person2 should only show up that they did not make it to chkpt3.
person3 shows up in chkpt3 as they completed all the paths to the final chkpt3.
I would like to summarize the counts of the persons that made it to a certain checkpoint. As there could be multiple persons that made it to the shortest checkpoint.
I also tried to combine all queries with multiple OPTIONAL MATCH clauses but that slows down a lot when the number of nodes increases.
There will be 100.000 to a million total nodes. The actual traversal will only involve 1000s of nodes as the persons will be filtered based on some value.

Answer 1

However, I want to only return person3 as person2 did not make it to chkpt3 and chkpt2.
How about this query? It counts the number of traversals a person is involved in and checks whether they made it to checkpoint 3 in all traversals.
MATCH (p:person)-[r]-()
WITH p, count(r) AS allTraversals
MATCH (p)-[:rel1]-(cp1:chkpt1)-[:rel2]-(cp2:chkpt2)-[:rel3]-(cp3:chkpt3)
WITH p, allTraversals, count(cp3) AS cp3s
WHERE allTraversals = cp3s
RETURN p
(Note: this will not work for person0.)
Additionally, a couple of observations:
(1.) You can use the WHERE NOT <pattern> construct to formulate negative conditions in a more succinct way.
MATCH (p:person)
WHERE NOT (p:person)-[:rel1]->(:chkpt1)
RETURN p
(2.) If it's possible, you might consider reviewing your data model and store persons and checkpoints as a single node and add the paths between them. This is a more graph-like representation and should help in formulating efficient queries.