Power Sets ~ Recursion ~ Hasse Diagrams - c++

Question

(SEE BELOW ALSO)
So I've got some functions and some operators for a set-manipulation program I'm coding, and I want to have power sets as a utility too (never mind the comments in the code). I don't want to use a binary approach, but I want to use recursion. I saw in Ralph Oberste-Vorth's book Bridge to Abstract Mathematics a definition of power sets (page 65), and on the next page I see all these equivalences like "if S = X, then P(S) = P(X)," and "if A and B are sets, then P(A) U P(B) = P(A U B)," and I'm reminded of recursion. I think recursion could work here but I'm not sure. I was playing around with Mathematica's Combinatorica package, and that one Haverford College paper on Hasse Diagrams, and I thought I could work out, in much the same way as is done here four minutes in, some kind of method based on the corresponding diagram for some set of size n, but I don't know that that will lead me the right way. I would like to build off of my already-built functions/operators.
#include <iostream>
#include <set>
#include <ostream>
#include <istream>
#include <vector>
using namespace std;
set<int> SetUnion( set<int> A , set<int> B ) // tus koj hlub
{
//A.insert( B.begin() , B.end() );
//return A;
set<int> pump;
for( set<int>::iterator cycle = A.begin() ; cycle != A.end() ; ++cycle )
{
pump.insert(*cycle);
}
for( set<int>::iterator cycle = B.begin() ; cycle != B.end() ; ++cycle )
{
pump.insert(*cycle);
}
return pump;
}
set<int> SetIntersection( set<int> A , set<int> B ) // tus koj hlub
{
set<int> pump;
for( set<int>::iterator cycle = A.begin ; cycle != A.end() ; ++cycle )
{
if( B.find(*cycle) != B.end() )
{
pump.insert(*cycle);
}
}
return pump;
}
set<int> SetDifference( set<int> A , set<int> B )
{
set<int> pump;
for( set<int>::iterator cycle = A.begin ; cycle != A.end() ; ++cycle )
{
if( B.find(*cycle) == B.end() )
{
pump.insert(*cycle);
}
}
return pump;
}
set<int> SymmetricDifference( set<int> A , set<int> B )
{
return SetUnion( SetDifference( A , B ) , SetDifference( B , A ) );
//return SetDifference( SetUnion( A , B ) , SetIntersection( A , B ) );
}
set<set<int>> PowerSet( set<int> A )
{
/*statements*/
}
set<int> Complement( set<int> A , int B )
{
set<int> pump;
for( int i = 1 ; i<=B ; i++ )
{
pump.insert(i);
}
set<int> collect = SetDifference( A , pump );
return collect;
}
set<int> operator+(set<int> A , set<int> B)
{
return SetUnion( A, B );
}
set<int> operator+(set<int> A , int B)
{
set<int> C;
C.insert(B);
return SetUnion( A , C );
}
set<int> operator+(int A , set<int> B)
{
set<int> C;
C.insert(A);
return SetUnion( B , C );
}
set<int> operator-(set<int> A , set<int> B)
{
set<int> pump;
for( set<int>::iterator cycle = A.begin ; cycle != A.end() ; ++cycle )
{
if( B.find(*cycle) == B.end() )
{
pump.insert(*cycle);
}
}
return pump;
}
set<int> operator-(set<int> A , int B)
{
set<int> C;
C.insert(B);
set<int> pump = SetDifference( A , C );
return C;
}
set<int> operator-(int A , set<int> B)
{
set<int> C;
C.insert(A);
set<int> pump = SetDifference( B , C );
return pump;
}
set<int> operator^(set<int> A , set<int> B)
{
return SetUnion( A , B );
}
set<int> operator^(set<int> A , int B)
{
set<int> C;
C.insert(B);
set<int> pump = SetUnion( A , C );
return pump;
}
set<int> operator^(int A , set<int> B)
{
set<int> C;
C.insert(A);
set<int> pump = SetUnion( B , C );
return pump;
}
set<int> operator%(set<int> A , set<int> B)
{
return SymmetricDifference( A , B );
}
set<int> operator%(set<int> A , int B)
{
set<int> C;
C.insert(B);
set<int> pump = SymmetricDifference( A , C );
return pump;
}
set<int> operator%(int A , set<int> B)
{
set<int> C;
C.insert(A);
set<int> pump = SymmetricDifference( B , C );
return pump;
}
set<int> operator~(set<int> A)
{
set<int> pump;
vector<int> hose;
for( set<int>::iterator cycle = A.begin() ; cycle != A.end() ; ++cycle )
{
hose.push_back(*cycle);
}
int last_value =
}
ostream& operator<<(ostream& out , set<int>& B) // tus koj hlub
{
int count=0;
if( B.size() == 0 )
{
out << "{}";
return out;
}
else
{
set<int>::iterator it;
out << "{";
for( it = B.begin() ; it != B.end() ; ++it )
{
++count;
if( count == B.size() )
{
out << *it;
}
else
{
out << *it << ", ";
}
}
out << "}";
return out;
}
}
istream& operator>>(istream& in , set<int>& B) // tus koj hlub
{
int user_input;
while(1)
{
in>>user_input;
if(user_input == -1)
break;
B.insert(user_input);
}
return in;
}
Also, why do I get an error on my "<<" operator symbol in the function here:
ostream& operator<<(ostream& out , set<set<int>>& B)
{
int count=0;
if( B.size() == 0 )
{
out << "{}";
return out;
}
else
{
set<set<int>>::iterator it;
out << "{";
for( it = B.begin() ; it != B.end() ; ++it )
{
count++;
if( count == B.size() )
{
out << *it;
}
else
{
out << *it << ", ";
}
}
out << "}";
return out;
}
}
The answer given by Mr. Shields produces the following error. I'm trying to figure out why it doesn't work:
Error: class "std::_Tree_const_iterator, std::allocator>>>> "has no member "insert"
ANSWER FROM AUTHOR:
set<set<int>> PowerSet( const set<int> A )
{
set<set<int>> ps;
if( A.size() == 0 )
{
ps.insert( set<int>() );
return ps;
}
set<int>::iterator it = A.begin();
int n = *it;
set<int> s1 = A;
s1.erase( n );
set<set<int>> ps1 = PowerSet( s1 );
set<set<int>> ps2;
for( set<set<int>>::iterator it = ps1.begin() ; it != ps1.end() ; ++it )
{
set<int> ss = *it;
ss.insert( n );
ps2.insert (ss );
}
for( set<set<int>>::iterator it = ps1.begin() ; it != ps1.end() ; ++it )
{
ps.insert(*it);
}
for( set<set<int>>::iterator it = ps2.begin() ; it != ps2.end() ; ++it )
{
ps.insert( *it );
}
return ps;
}

Answer 1

This C++ code below is horribly inefficient, but I think it should give you the idea for how to do this recursively. The recursion rule is basically this:
P({}) = {{}}
the power set of the empty set is the set containing the empty set
P({n} U S) = { {n} U T | T in P(S) } U P(S)
every set in the power set of {n} U S either contains n or does not contain n - exactly one of each for each set in the power set of S
Be aware that a set of cardinality K has a power set of cardinality 2^K. So you don't want to perform this operation on any large sets!
set<set<int>> PowerSet( set<int> A )
{
set<set<int>> PA;
if (A.empty())
{
//case: P({}) = {{}}
PA.insert(A);
}
else
{
//case: P({n} U S) = { {n} U T | T in P(S) } U P(S)
int n = *A.begin();
A.erase(A.begin());
//A is now "S" from the explanation above this code
auto PS = PowerSet(A);
for (auto T = PS.begin(); T != PS.end(); ++T)
{
//add each set T from P(S)
PA.insert(*T);
//add each set T from P(S) with n included as well
T->insert(n);
PA.insert(*T);
}
}
return PA;
}