Q:

In Neo4j, can one find all nodes whose relationships are a superset of another node's relationships?

Given the following contrived database:
CREATE (a:Content {id:'A'}),
  (b:Content {id:'B'}),
  (c:Content {id:'C'}),
  (d:Content {id:'D'}),
  (ab:Container {id:'AB'}),
  (ab2:Container {id:'AB2'}),
  (abc:Container {id:'ABC'}),
  (abcd:Container {id:'ABCD'}),
  ((ab)-[:CONTAINS]->(a)),
  ((ab)-[:CONTAINS]->(b)),
  ((ab2)-[:CONTAINS]->(a)),
  ((ab2)-[:CONTAINS]->(b)),
  ((abc)-[:CONTAINS]->(a)),
  ((abc)-[:CONTAINS]->(b)),
  ((abc)-[:CONTAINS]->(c)),
  ((abcd)-[:CONTAINS]->(a)),
  ((abcd)-[:CONTAINS]->(b)),
  ((abcd)-[:CONTAINS]->(c)),
  ((abcd)-[:CONTAINS]->(d))

Is there a query that can detect all Container node pairs where one CONTAINS either a superset of or the same Content nodes as the other Container node?
For my example database, I would want the query to return:
(ABCD) is a superset of (ABC), (AB), and (AB2)
(ABC) is a superset of (AB), and (AB2)
(AB) and (AB2) contain the same nodes

If cypher is unsuitable for this but another query language is well suited to it, or if Neo4j is unsuitable for this but another database is well suited to it, I'd appreciate input on that as well.

Answer query performance (as of 2017-02-28T21:56Z)
I am not experienced enough yet with Neo4j or graph DB querying to analyze the performance of the answers, and I have not yet constructed my large data set for a more meaningful comparison, but I thought I'd run each with the PROFILE command and list the DB hit cost.  I omitted the timing data as I could not make it consistent or meaningful with such a small data set.

stdob--: 129 total db hits
Dave Bennett: 46 total db hits
InverseFalcon: 27 total db hits

A:

// Get contents for each container
MATCH (SS:Container)-[:CONTAINS]->(CT:Content)
      WITH SS, 
           collect(distinct CT) as CTS
// Get all container not equal SS
MATCH (T:Container) 
      WHERE T <> SS
// For each container get their content
MATCH (T)-[:CONTAINS]->(CT:Content)
      // Test if nestd
      WITH SS, 
      CTS, 
      T, 
      ALL(ct in collect(distinct CT) WHERE ct in CTS) as test 
      WHERE test = true
RETURN SS, collect(T)

