Intersection has to be applied usually to a sequence of lists, but as mostly often

Intersection works with any head, not just List:

So, if something isn't an atom

In[8]:= AtomQ[a[1]]
Out[8]= False

it has a head and this head remains unchanged, the content is intersected - as it is done with List[]:

In[8]:= AtomQ[a[1]]
Out[8]= False

In[9]:= a[1] \[Intersection] a[2]
Out[9]= a[]

In[10]:= {1} \[Intersection] {2}
Out[10]= {}

If the heads do not fit, you get it to know

In[11]:= a[1, 2, 3, 4] \[Intersection] a[2, 3, 4, 5] \[Intersection] b[1, 2, a[1, 2, 3, 4]]
During evaluation of In[11]:= Intersection::heads: Heads b and a at positions 3 and 1 are expected to be the same. >>
Out[11]= a[1, 2, 3, 4] \[Intersection] a[2, 3, 4, 5] \[Intersection] b[1, 2, a[1, 2, 3, 4]]

it's once again a reflection of the deep insight that heads are not as much different from each other as they appear in education for childs and students:

In[13]:= a[1, 2, 3, 4] \[Intersection] a[2, 3, 4, 5] \[Intersection]  a[1, 2, b[1, 2, 3, 4]]
Out[13]= a[2]

Moreover I think it suffices to look at all pairs of subsets of cp

This means that for let's say 4 non-empty sets $A,B,C,D$ the sets

$A_2 = A\cap B \vee A\cap C \vee A\cap D \vee B\cap C \vee B\cap D \vee C\cap D$

and

$A_{23} = A\cap B \vee A\cap C \vee A\cap D \vee B\cap C \vee B\cap D \vee C\cap D \vee A\cap B\cap C \vee A\cap B\cap D \vee A\cap C\cap D \vee B\cap C\cap D$

are identical $A_2 \equiv A_{23}$, which is clear because of the $\vee$ (logical OR) and the fact, that intersections of three sets are not more permissive as intersections of two sets. Actually I was driven by your other remark

Now again find elements in cp common to all members in cp comparing all subsets

to deliver a generic code sample which could deliver all subsets. It was restricted to the subsets with $2,3,...,n-1$ members and should be restricted even more in the given context, as you say.

Hi Udo, great, albeit somewhat complex. I wanted to show the single steps. Moreover I think it suffices to look at all pairs of subsets of cp, and it is not neccesary to look at all subsets of cp with more elements than 2. This would save time and memory. So I think one could write as well

First /@ (Complement[#, 
     Flatten[Intersection @@@ (Part[cp, #] & /@ 
         Subsets[Range[Length[cp]], {2}])]] & /@ cp)

The empty sets could indeed be an issue indicating that there are elements which don't occur in some of the original sets after removing the elements common to all sets. Perhaps you could include an error-variable ( perhaps Catch, Throw ?) in your 2-liner?

It's an interesting algorithm problem, but I cannot understand your example :(

Would you mind providing more sample cases?