PowersetGenerationPost_Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating Power sets: Two Approaches (Part 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Contents\"><h2>Contents</h2></div>\n",
    "\n",
    "<ol>\n",
    "    <li><div style=\"text-align: left\"><a href=\"#Overview\"><cn1>Overview</cn1></a></div></li>\n",
    "    <li><div style=\"text-align: left\"><a href=\"#Define-a-set-container-class\"><cn1>Define a set container class</cn1></a></div></li>\n",
    "        <li><div style=\"text-align: left\"><a href=\"#Enforcing-uniqueness\"><cn1>Enforcing uniqueness</cn1></a></div>\n",
    "    <ol>\n",
    "        <li><div style=\"text-align: left\"><a href=\"#Testing-the-uniqness-enforcement-method\"><cn2>Testing the uniqness enforcement method</cn2></a></div></li>\n",
    "    </ol>\n",
    "    </li>\n",
    "    <li><div style=\"text-align: left\"><a href=\"#Set-operator-methods\"><cn1>Set operator methods</cn1></a></div>\n",
    "    <ol>\n",
    "        <li><div style=\"text-align: left\"><a href=\"#Testing-modset-union\"><cn2>Testing ModSet union</cn2></a></div></li>\n",
    "        <li><div style=\"text-align: left\"><a href=\"#Testing-modset-intersection\"><cn2>Testing ModSet intersection</cn2></a></div></li>\n",
    "        <li><div style=\"text-align: left\"><a href=\"#Testing-modset-set-difference\"><cn2>Testing ModSet set-difference</cn2></a></div></li>\n",
    "    </ol>\n",
    "    </li>\n",
    "    <li><div style=\"text-align: left\"><a href=\"#Sources-(part-2)\"><cn1>Sources (part 2)</cn1></a></div></li>\n",
    "    <li><div style=\"text-align: left\"><a href=\"#Get-modset\"><cn1>Get ModSet()</cn1></a></div></li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Overview\"><h2>Overview</h2></div>\n",
    "\n",
    "In <a href=\"https://nullexit.org/blog/index.php/2021/01/27/power-sets-in-python-an-object-oriented-approach-part-1/\">part one</a>, we showed that instances classes are hashable, so they can be included as elements of a `set` object. If the class instance happens to have a `set`-valued attribute, we effectively have a `set` with another `set` as a member, made possible by the instance acting as a \"container\" <a href=\"#ref1\">(Bernstein, M)</a>.  In the post that follows, we'll craft a new class that incorporates the container behavior illustrated in part one, as well as a number of other methods that will prove necessary when we build power sets in <a href=\"https://nullexit.org/blog/index.php/2021/01/29/power-sets-in-python-an-object-oriented-approach-part-3/\">part three</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <div id=\"Define-a-set-container-class\"><h2>Define a set container class</h2></div>\n",
    "\n",
    "Using the illustrative example in part one, we will define a new class, `ModSet()`, with the same constructor and representation methods. New instances of the class will require a set argument, either occupied or empty. In addition, we will define methods to copy, nest and unnest instances of the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModSet():\n",
    "    \n",
    "    # Instance constructor\n",
    "    def __init__(self, setElement):\n",
    "        self.val = setElement  # set arg saved in .val attribute\n",
    "    \n",
    "    # String eval representation of self instance \n",
    "    def __repr__(self):\n",
    "        return self.val.__repr__() # Return string eval represent.\n",
    "                                   # of string object in .val\n",
    "    \n",
    "    # Method to make a copy of self instance\n",
    "    def __copy__(self):\n",
    "        return ModSet(self.val)\n",
    "    \n",
    "    # Modify .val to contain the set of itself, of itself, ...\n",
    "    # nesting .val \"depth\" number of levels.\n",
    "    def pushDown(self, depth):\n",
    "        while depth > 0:\n",
    "            self.val = set([ModSet(self.val)])\n",
    "            depth -= 1     \n",
    "    \n",
    "    # Remove one nesting level from set in self.val.\n",
    "    # If un-nested, ignore.\n",
    "    def pullUpOneLevel(self):\n",
    "        listSet = list(self.val)\n",
    "        if len(listSet) == 1:\n",
    "            self.val = listSet[0].val\n",
    "        else:\n",
    "            pass\n",
    "    \n",
    "    # Remove height number of nesting levels from set in\n",
    "    # self.val by repeatedly calling above method\n",
    "    def pullUp(self, height):\n",
    "        while height > 0:\n",
    "            self.pullUpOneLevel()\n",
    "            height -= 1\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Testing these, let's define a set of mixed immutables and nest it three levels deep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{{{{2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}}}}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "worldlyPrez = ModSet(set([('televised', 'summit'), 'DMZ', 12.6, 2019, '\\\"bromance\\\"']))\n",
    "worldlyPrez.pushDown(3)\n",
    "worldlyPrez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Raising that result back up three levels should return the set to how it was originally defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "worldlyPrez.pullUp(3)\n",
    "worldlyPrez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you instruct to pull up greater than the set is deep, the extra ascents are ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "worldlyPrez.pullUp(2)\n",
    "worldlyPrez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Enforcing-uniqueness\"><h2>Enforcing uniqueness</h2></div>\n",
    "\n",
    "Just like Python's set class, we will make sure that each member of ModSet be unique according to the value of its `.val` attribute.  When a ModSet is comprised of immutables, the `set()` class enforces uniqueness for us automatically.  However, if a ModSet contains other ModSets, we require an additional method to enforce uniqueness among them as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModSet():\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    def removeDuplicates(self):\n",
    "        uniqueSet = set()  # initialize as empty the unique set to be built\n",
    "        for s in self.val:  # s is a member of the ModSet().val set\n",
    "            inUniqueSet = False  # initialize match detection flag as false\n",
    "            sTest = s  # default conditional testing value for s\n",
    "            for us in uniqueSet: # us is a member of the uniqueSet set\n",
    "                usTest = us  # default conditional testing value for us\n",
    "                if isinstance(us, ModSet): # if member us is a ModSet\n",
    "                    usTest = us.val        # change testing value to its attribute\n",
    "                if isinstance(s, ModSet):  # if member s is a ModSet\n",
    "                    sTest = s.val          # change testing value to its attribute\n",
    "                if usTest == sTest:  # compare us and s testing values on this run\n",
    "                    inUniqueSet = True  # if match, set existence flag to true\n",
    "            if not inUniqueSet:    # only add member s to uniqueSet if\n",
    "                uniqueSet.add(s)   # match is NOT detected\n",
    "        self.val = uniqueSet    # set .val to the uniqueSet from above"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Testing-the-uniqness-enforcement-method\"><h3>Testing the uniqness enforcement method</h3></div>\n",
    "\n",
    "After we added `removeDuplicates()` to our class definition, we can test it as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{140213840135112, 140213840135280, 140213840134832}\n",
      "{{2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}, {2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}, {2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}}\n"
     ]
    }
   ],
   "source": [
    "prez1 = ModSet(set([('televised', 'summit'), 'DMZ', 12.6, 2019, '\\\"bromance\\\"']))  # inst. 1\n",
    "prez2 = ModSet(set([('televised', 'summit'), 'DMZ', 12.6, 2019, '\\\"bromance\\\"']))  # inst. 2\n",
    "prez3 = ModSet(set([('televised', 'summit'), 'DMZ', 12.6, 2019, '\\\"bromance\\\"']))  # inst. 3\n",
    "print(set([id(prez1), id(prez2), id(prez3)]))  # each instance held in its own memory block\n",
    "\n",
    "modSetOfPrez = ModSet(set([prez1, prez2, prez3]))  # define a ModSet of ModSet instances\n",
    "print(modSetOfPrez.val)  # set class sees each instance as unique though they contain \n",
    "                         # equivalent values in their attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's call our uniqueness filter.  Only one member should remain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{{2019, ('televised', 'summit'), 12.6, '\"bromance\"', 'DMZ'}}\n"
     ]
    }
   ],
   "source": [
    "modSetOfPrez.removeDuplicates()  # enforce uniqueness according to attribute value\n",
    "print(modSetOfPrez)   # result after applying removeDuplicates()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Set-operator-methods\"><h2>Set operator methods</h2></div>\n",
    "\n",
    "For the power set routines to come, we need instances of `ModSet()` to join by union and also separate by set-subtraction.  Below, we define methods for these operations as well as set-intersection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModSet():\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    # union-join multiple items, enforce that ModSet members be unique\n",
    "    def union(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.union(modSet.val)  # this is union method from set class\n",
    "            self.removeDuplicates()  # removes duplicate-valued instances of ModSet members\n",
    "    \n",
    "    # take set intersection of multiple items\n",
    "    def intersection(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.intersection(modSet.val) # method from set class\n",
    "    \n",
    "    # take set difference of multiple items. Note: arg order matters here! \n",
    "    def difference(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.difference(modSet.val) # method from set class\n",
    "    \n",
    "    # version of above method that returns a new instance for assignment.\n",
    "    # Note: only two arguments here.\n",
    "    def diffFunc(modSet1, modSet2):\n",
    "        return ModSet(set.difference(modSet1.val, modSet2.val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Testing-modset-union\"><h3>Testing ModSet union</h3></div>\n",
    "\n",
    "With the set operation methods now included in the class, let's test union-joining of non-ModSet objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'power', 'Congress', 'abuse', 'insurrection', 'obstruction', 'incitement', 'of'}\n"
     ]
    }
   ],
   "source": [
    "charges = ModSet(set())\n",
    "charge1 = ModSet(set(['obstruction', 'of', 'Congress']))\n",
    "charge2 = ModSet(set(['abuse', 'of', 'power']))\n",
    "charge3 = ModSet(set(['incitement', 'of', 'insurrection']))\n",
    "\n",
    "charges.union(charge1, charge2, charge3)\n",
    "print(charges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The three separate ModSets have been merged into a single ModSet, `charges`.  Notice that string member `'of'` appears only once, as it should, though it is present in `charge1`, `charge2`, and `charge3`.  Now, we'll test union operation with ModSet members present as well.\n",
    "\n",
    "First, we'll nest down by one level each of the three charges, so that we can test `ModSet.union()`. This time we're interested in the case when ModSet-of-ModSets are present in the pool of objects to be joined.  By \"ModSet-of-ModSet\",  we mean a ModSet instance that has another ModSet instance as a member of its set-valued `.val` attribute--the result of `ModSet.pushDown(1)`. During the union call, these ModSet-of-ModSet objects will be routed through paths of `.removeDuplicates()` that we've set up specifically for them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'power', 'fake', 'news', 'Congress', {'power', 'of', 'abuse'}, 'abuse', 'insurrection', {'insurrection', 'incitement', 'of'}, 'all', {'Congress', 'of', 'obstruction'}, 'obstruction', 'incitement', 'of'}\n"
     ]
    }
   ],
   "source": [
    "charge1.pushDown(1)\n",
    "charge2.pushDown(1)\n",
    "charge3.pushDown(1)\n",
    "\n",
    "charges.union(charge1, charge1, charge2, charge3, ModSet(set(['all', 'fake', 'news'])))\n",
    "print(charges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should notice that though we have included `charge1` twice in the method-call, its value, `{'Congress', 'obstruction', 'of'}`, appears just once in the output. So, we may conclude that the `.removeDuplicates()` method does correctly enforce uniqueness among ModSet-of-ModSet members.  Members of `{'all', 'fake', 'news'}` have been included as well. Now that we've shown that `.union()` works as expected, we can move on to test `.intersection()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Testing-modset-intersection\"><h3>Testing ModSet intersection</h3></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{{'power', 'of', 'abuse'}, 'the'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "claim1 = ModSet(set(['rounding', 'the', 'bend']))  # define a new instance of ModSet\n",
    "claim2 = ModSet(set(['dems', 'stole', 'the', 'election'])) # define another new instance\n",
    "claim1.union(charge1, charge2)  # union-join charges 1 and 2 from above with claim1 \n",
    "claim2.union(charge2, charge3)  # union-join charges 2 and 3 from above with claim2\n",
    "claim1.intersection(claim2)  # perform set-intersection of claims 1 and 2\n",
    "claim1  # output the post-intersection result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above we form two \"mixed\" `ModSet()` instances that contain both top-level strings as well as sub-ModSets as members. We can see, after joining the two by set intersection, the result is what we expect: only `'the'` remains from the strings and only `charge2` survives among the ModSets. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Testing-modset-set-difference\"><h3>Testing ModSet set-difference</h3></div>\n",
    "\n",
    "Above we included two methods for performing set-subtraction within the `ModSet()` class.  The first, called `.difference()`, is an inline function that modifies the original instance from which it is called. Removing `charge2` from `charges` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'power', 'fake', 'news', 'Congress', 'abuse', 'insurrection', {'insurrection', 'incitement', 'of'}, 'all', {'Congress', 'of', 'obstruction'}, 'obstruction', 'incitement', 'of'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "charges.difference(charge2)\n",
    "charges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "leaves `charges` with all but the `{'abuse', 'of', 'power'}` member in the result. So, check.  \n",
    "\n",
    "The second method, that we've named `.diffFunc()`, is a functional version of set-subtraction that returns the result as a new instance `ModSet()` leaving its originating instances unchanged. To test `.diffFunc()`, we'll now attempt to remove `charge1` from `charges` (since `charge2` has already been removed in the previous step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'power', 'fake', 'news', 'Congress', 'abuse', 'insurrection', {'insurrection', 'incitement', 'of'}, 'all', 'obstruction', 'incitement', 'of'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chargesReduced = ModSet.diffFunc(charges, charge1)\n",
    "chargesReduced"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the value from `charge1`, `{'obstruction', 'of', 'Congress'}`, is absent from `chargesReduced`, though all others from its parent, `charges`, are present.  \n",
    "\n",
    "Lastly, let's examine `charges` to make sure that this particular instance has *not* been modified since last step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'power', 'fake', 'news', 'Congress', 'abuse', 'insurrection', {'insurrection', 'incitement', 'of'}, 'all', {'Congress', 'of', 'obstruction'}, 'obstruction', 'incitement', 'of'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "charges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And there the charge remains, in all its glory, one could say...  \n",
    "\n",
    "Though our testing of `ModSet()` above has been far from exhaustive, we hope you are convinced that instances of it will behave as we intend them to. At this point, we can *finally* move on to our main objective: building power sets.  We'll do this in <a href=\"https://nullexit.org/blog/index.php/2021/01/29/power-sets-in-python-an-object-oriented-approach-part-3/\">part three</a> to come. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Sources-(part-2)\"><h2>Sources (part 2)<h2></div>\n",
    "\n",
    "<a id=\"ref1\">1.</a> Bernstein, M. <a href=\"https://bernsteinbear.com/blog/recursive-python-objects/\">Recursive Python Objects</a>, https://bernsteinbear.com/blog. 2019."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"Get-modset\"><h2>Get ModSet()</h2></div>\n",
    "\n",
    "The above code comprises the core of our `ModSet()` class. We'll walk-through the power set generating methods in <a href=\"https://nullexit.org/blog/index.php/2021/01/29/power-sets-in-python-an-object-oriented-approach-part-3/\">part three</a>. You can download `ModSet()`'s complete definition from github: <a href=\"https://github.com/rweaton/NullExitBlogPosts/blob/main/PowersetGenerationPost/modset.py\">modset.py</a>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">The ModSet() class</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"nullexit.org\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">nullexit.org</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModSet():\n",
    "    \n",
    "    # Instance constructor\n",
    "    def __init__(self, setElement):\n",
    "        self.val = setElement  # set arg saved in .val attribute\n",
    "    \n",
    "    # String eval representation of self instance \n",
    "    def __repr__(self):\n",
    "        return self.val.__repr__() # Return string eval represent.\n",
    "                                   # of string object in .val\n",
    "    \n",
    "    # Method to make a copy of self instance\n",
    "    def __copy__(self):\n",
    "        return ModSet(self.val)\n",
    "    \n",
    "    # Modify .val to contain the set of itself, of itself, ...\n",
    "    # nesting .val \"depth\" number of levels.\n",
    "    def pushDown(self, depth):\n",
    "        while depth > 0:\n",
    "            self.val = set([ModSet(self.val)])\n",
    "            depth -= 1     \n",
    "    \n",
    "    # Remove one nesting level from set in self.val.\n",
    "    # If un-nested, ignore.\n",
    "    def pullUpOneLevel(self):\n",
    "        listSet = list(self.val)\n",
    "        if len(listSet) == 1:\n",
    "            self.val = listSet[0].val\n",
    "        else:\n",
    "            pass\n",
    "    \n",
    "    # Remove \"height\" nesting levels from set in\n",
    "    # self.val by repeatedly calling above method\n",
    "    def pullUp(self, height):\n",
    "        while height > 0:\n",
    "            self.pullUpOneLevel()\n",
    "            height -= 1\n",
    "    \n",
    "    # Within a single set, multiple ModSets with \n",
    "    # equivalent .val attributes can exist.  \n",
    "    # This can occur because each instance of ModSet\n",
    "    # allocated its own location in memory. For sets\n",
    "    # to have unique members in terms of ModSet.val\n",
    "    # values, we define the following filtering method.\n",
    "    def removeDuplicates(self):\n",
    "        uniqueSet = set()  # initialize as empty the unique set to be built\n",
    "        for s in self.val:  # s is a member of the ModSet().val set\n",
    "            inUniqueSet = False  # initialize match detection flag as false\n",
    "            sTest = s  # default conditional testing value for s\n",
    "            for us in uniqueSet: # us is a member of the uniqueSet set\n",
    "                usTest = us  # default conditional testing value for us\n",
    "                if isinstance(us, ModSet): # if member us is a ModSet\n",
    "                    usTest = us.val        # change testing value to its attribute\n",
    "                if isinstance(s, ModSet):  # if member s is a ModSet\n",
    "                    sTest = s.val          # change testing value to its attribute\n",
    "                if usTest == sTest:  # compare us and s testing values on this run\n",
    "                    inUniqueSet = True  # if match, set existence flag to true\n",
    "            if not inUniqueSet:    # only add member s to uniqueSet if\n",
    "                uniqueSet.add(s)   # match is NOT detected\n",
    "        self.val = uniqueSet    # set .val to the uniqueSet from above\n",
    "    \n",
    "    # union join multiple items, enforce that ModSet members be unique\n",
    "    def union(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.union(modSet.val)  # this is union method from set class\n",
    "            self.removeDuplicates()  # removes duplicate-valued instances of ModSet members\n",
    "    \n",
    "    # set intersect multiple items\n",
    "    def intersection(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.intersection(modSet.val)\n",
    "    \n",
    "    # set difference multiple items. note: arg order matters here! \n",
    "    def difference(self, *modSets):\n",
    "        for modSet in modSets:\n",
    "            self.val = self.val.difference(modSet.val)\n",
    "    \n",
    "    # version of above method that returns a new instance,\n",
    "    # only takes two arguments.\n",
    "    def diffFunc(modSet1, modSet2):\n",
    "        return ModSet(set.difference(modSet1.val, modSet2.val))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}