Computing ARI by finding patterns in a reduced graph - graph

Question

I have a graph in which items can be partitioned differently, i.e. clusters of items vary between two partitions. I'd like to calculate the Adjusted Rand Index between two different partitions to evaluate how much they differ.
The graph
This is the general structure of the graph:
(:Store)-[:SELLS]->(:Product)-[:SIMILAR]-(:Product)<-[:SELLS]-(:Store)
--- red_beans ------ orange_beans ---
/ / \
supermart ------ yellow_beans --- --- ecomart
\ \ /
--- blue_beans ------ green_beans ---
--- blue_jello ---
/ \
supermart --- purple_jello --- --- ecomart
\ /
--- red_jello ---
Each store sells different colored products.
Each product from a store can be similar to products in another store.
Additionally, each store can bundle different products together:
(:Product)-[:BUNDLED]-(:Product)
purple_jello --- red_beans --- blue_beans (supermart bundle)
red_jello --- orange_beans (ecomart bundle)
The question
Regardless of product color (different colors of a product are considered to be the same product), for products available in both stores (similar products are actually the same product available in both stores), how much do bundles differ between stores?
The process
The first step would be to reduce the graph to correspond to the question. It should (virtually) look like this:
(:Store)-[:SELLS]->(:Product)-[:SIMILAR]-(:Product)<-[:SELLS]-(:Store)
supermart --- super_beans --- eco_beans --- ecomart
supermart --- super_jello --- eco_jello --- ecomart
I would like to reduce different colors of a product into one by looking at their indirect similarities. Products from a same store that are indirectly linked by similarity will be considered the same:
(a:Store)-[:SELLS]->(:Product)-[:SIMILAR*]-(:Product)<-[:SELLS]-(a:Store)
The bundles will also be simplified like this:
(:Product)-[:BUNDLED]-(:Product)
super_jello --- super_beans (supermart bundle)
eco_jello --- eco_beans (ecomart bundle)
This should be a natural extension of the products reduction. Multiple edges will also be reduced into one.
The second step would be to extract the information necessary to calculate the ARI between the different partitions of products. The ARI is:
Three measures are needed to compute it:
The number of product pairs that are found in both stores' bundles. Basically, the number of times this pattern is present in the graph:
(a:Store)-[:SELLS]->(:Product)-[:SIMILAR]-(:Product)<-[:SELLS]-(b:Store)
| |
[:BUNDLED] [:BUNDLED]
| |
(a:Store)-[:SELLS]->(:Product)-[:SIMILAR]-(:Product)<-[:SELLS]-(b:Store)
The number of product pairs that are found in one store's bundles. Basically, the number of times this pattern is present in the graph, for each store:
(a:Store)-[:SELLS]->(:Product)
|
[:BUNDLED]
|
(a:Store)-[:SELLS]->(:Product)
The number of possible product pairs in one store. Since we consider only products that are available in both stores, each store has the same number of products, and this would be:
MATCH (a:Store)-[:SELLS]->(p:Product)
RETURN a, count(p)*(count(p)-1)/2
The implementation
Implementing this into cypher queries isn't as natural as I expected. I am having trouble translating my process, especially the first step, and would appreciate any help.
Edit: This is the graph I am working on:
with [
{
store: 'supermart',
products: ['red_beans','yellow_beans','blue_beans','purple_jello',
'orange_icecream','pink_icecream','blue_candy','brown_cake']
},
{
store: 'ecomart',
products: ['orange_beans','green_beans','blue_jello','red_jello',
'red_icecream','white_icecream','purple_candy','white_sugar']
}
] as sells
unwind sells as sell
merge (s:Store {name: sell.store})
with s, sell
unwind sell.products as product
merge (p:Product {name: product})
merge (s)-[:SELLS]->(p);
with [
['red_beans', 'purple_jello'],
['red_beans', 'blue_beans'],
['blue_beans', 'purple_jello'],
['yellow_beans', 'brown_cake'],
['orange_icecream', 'pink_icecream'],
['pink_icecream', 'blue_candy'],
['orange_beans', 'red_jello']
] as bundles
unwind bundles as bundle
match (p1:Product {name: bundle[0]})
match (p2:Product {name: bundle[1]})
merge (p1)-[:BUNDLED]-(p2);
with [
['red_beans', 'orange_beans'],
['yellow_beans', 'orange_beans'],
['yellow_beans', 'green_beans'],
['blue_beans', 'green_beans'],
['purple_jello', 'blue_jello'],
['purple_jello', 'red_jello'],
['orange_icecream', 'red_icecream'],
['pink_icecream', 'red_icecream'],
['pink_icecream', 'white_icecream'],
['blue_candy', 'purple_candy']
] as similarities
unwind similarities as similar
match (p1:Product {name: similar[0]})
match (p2:Product {name: similar[1]})
merge (p1)-[:SIMILAR]-(p2);
The ARI for this graph is 0.571428