1. compute D[i] = a – S[i] for each S[i]
2. count = 0
3. for each D[i], if len(D[i]) = 0, count = count + 1
4. print count

Yeah that doesn’t really do any set comparisons. Probably not what you were going for. Posted for the lulz.

BTW, the paper I linked to has a practical algorithm that computes the height of *all* sets in S if this is what the original application required.

The amusing part comes when you figure out a “cheating solution” – for each set s compute (len(s), hash(s)), and sort according to that. If you do, it is guaranteed that if s1 <= s2, it will be before it in the ordering. The hash is there to keep the ordering well-defined for sets with the same cardinality.
It turns out that less mathematically inclined programmers think of this solution much faster :)

Main theme: the complexity heavily depends on the width of the poset, that is, the size of the largest antichain. An antichain is a subset A of S such that no two sets in A are a subset of one another.

Both of your solutions are equivalent, and they both work best when the set to test is small. This means that it will probably work best when the set to test is common. When it is rare, it will take more time.

The solution I originally thought of has it the other way around, although it has it’s drawbacks. I need to do a more thorough complexity analysis of both algorithms to be able to compare them correctly.

Another note regarding the problem where I needed this – in that problem I had to score a set according to its rarity. Since very common sets score low, a possible improvement for the real-life problem might be to return TOO_MANY (equivalent to zero score) for sets that appear more times than some threshold.
Regardless, I’m still very curious to see more solutions to the full problem as stated in the post.

create a dictionary of for each integer in one of the sets S, which sets it belongs to.
create a copy of S, let’s call it B.
Then, for every integer in the set a, B = intersect B with the set of sets to which it belongs (from the dictionary).
return the length of the resulting B

I hope my code can be more clear. This is almost entirely pasted out of my interpreter, so sorry about the tab issues.

[python]
def build_setdict(set_seq):
set_dict = {}
for some_set in set_seq:
for value in some_set:
try:
set_dict[value].add(some_set)
except KeyError:
set_dict[value] = set([some_set])
return set_dict

def get_containing_sets(sets, set_to_test):
sets = frozenset(map(frozenset, sets))
# integer->setlist mapping
setdict = build_setdict(sets)
remaining_sets = sets
try:
for i in set_to_test:
remaining_sets = remaining_sets.intersection(setdict[i])
except KeyError:
# Integer in no set
return set()
return remaining_sets

#example test case
>>> sets = [set(range(10)), set(range(10, 20)), set(range(20))]
>>> len(get_containing_sets(sets, range(5)))
2
>>> len(get_containing_sets(sets, range(5,15)))
1
>>> len(get_containing_sets(sets, range(5,25)))
0
>>> len(get_containing_sets(sets, range(11,16)))
2
[/python]