From dd06091452418f6659305b1b4ef8d030140e9af1 Mon Sep 17 00:00:00 2001
From: Zach S <zsiegel92@gmail.com>
Date: Tue, 11 Jul 2017 23:10:22 -0700
Subject: [PATCH 1/3] Added invert function

---
 python/subsets.py | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)

diff --git a/python/subsets.py b/python/subsets.py
index 04a30d7..7cfd23c 100755
--- a/python/subsets.py
+++ b/python/subsets.py
@@ -72,7 +72,7 @@ def test(self):
                     b = self.generateSubset(l, k, i)
                     if b is None:
                         break
-                    print "%i %i %s: %s"%(l, k, i, b)
+                    print("%i %i %s: %s"%(l, k, i, b))
                     i += 1
 
         i = 0
@@ -80,14 +80,39 @@ def test(self):
             b = self.generateSubset(25, 24, i)
             if b is None:
                 break
-            print "%i %i %s: %s"%(25, 24, i, b)
+            print("%i %i %s: %s"%(25, 24, i, b))
             i += 1
 
         self.precacheChoose(10000, 12)
         i = 160000
         b = self.generateSubset(100, 3, i)
-        print "%i %i %s: %s"%(100, 3, i, b)
+        print("%i %i %s: %s"%(100, 3, i, b))
 
         i = 160000000000000000000000000000
         b = self.generateSubset(10000, 12, i)
-        print "%i %i %s: %s"%(10000, 12, i, b)
+        print("%i %i %s: %s"%(10000, 12, i, b))
+
+    def invert(self,n,l):
+        k=len(l)
+        assert(k<=n) #assert subset of {1,...,n}
+        assert(k==len(set(l)))#assert unique elements
+        assert(max(l)<n)
+        l.sort()
+        if k==1:
+            return l[0]
+        elif k==0:
+            return 0
+        else:
+            return self.choose(n,k)-self.choose(n-l[0],k)+self.invert(n-l[0]-1,list(map(lambda x: x-l[0]-1,l[1:])))
+
+
+if __name__=='__main__':
+    a = EnumeratedSubsets()
+    max_n = 10
+    for n in range(1,max_n):
+        for k in range(1,n+1):
+            for i in range(0,a.choose(n,k)):
+                l= a.generateSubset(n,k,i)
+                assert(a.invert(n,l)==i)
+    else:
+        print("Passed all tests")

From b994e4eb95bbd98ec97971012ecd1ab162bb5dde Mon Sep 17 00:00:00 2001
From: Zach S <zsiegel92@gmail.com>
Date: Tue, 11 Jul 2017 23:59:09 -0700
Subject: [PATCH 2/3] Added algebraic invert

---
 python/__pycache__/subsets.cpython-34.pyc | Bin 0 -> 3823 bytes
 python/subsets.py                         | 227 ++++++++++++----------
 2 files changed, 120 insertions(+), 107 deletions(-)
 create mode 100644 python/__pycache__/subsets.cpython-34.pyc

diff --git a/python/__pycache__/subsets.cpython-34.pyc b/python/__pycache__/subsets.cpython-34.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bca0aaec3d77448cf621f3903069f565fcc7d2a2
GIT binary patch
literal 3823
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
Rhb!R8H^7HC&6fF|^IuYQ#{&QW

literal 0
HcmV?d00001

diff --git a/python/subsets.py b/python/subsets.py
index 7cfd23c..6883cd1 100755
--- a/python/subsets.py
+++ b/python/subsets.py
@@ -6,113 +6,126 @@
 # This source is public domain.
 
 class EnumeratedSubsets(object):
-    def __init__(self):
-        self.cache = {}
-    def choose(self, n, k):
-        # handle the simple cases
-        k = min(k, n-k)
-        if k == 0:
-            return 1
-        elif k < 0:
-            raise Exception("negative k?")
-        elif k == 1:
-            return n
-        # handle caching and subcalls
-        c = (n,k)
-        if c not in self.cache:
-            self.cache[c] = self.choose(n-1, k) + self.choose(n-1, k-1)
-        return self.cache[c]
-
-    def precacheChoose(self, n, k=None):
-        # adjust your bounds
-        if k is None:
-            k = (n+1)//2 - 1
-        for k_i in xrange(1, k+1):
-            for n_i in xrange(k_i, n+1):
-                self.choose(n_i, k_i)
-
-    def generateSubset(self, n, k, i):
-        # non-recursive generateSubset(n, k, i), which will choose the i'th
-        # subset of size k from n items (numbered 0..n-1)
-        b = None
-        offset = 0
-        while 1:
-            if b is None:
-                b = set()
-
-            upperBound = self.choose(n,k)
-            if i >= upperBound:
-                return None
-
-            zeros = 0
-            low = 0
-            high = self.choose(n-1, k-1)
-            while i >= high:
-                zeros += 1
-                low = high
-                high += self.choose(n-zeros-1, k-1)
-
-            if (zeros + k) > n:
-                raise Exception("Too many zeros!")
-
-            b.add(offset + zeros)
-            if k == 1:
-                return sorted(b)
-            else:
-                n -= zeros + 1
-                k -= 1
-                i -= low
-                offset += zeros+1
-
-    def test(self):
-        for l in xrange(1, 10):
-            for k in xrange(1, min(l, 5)):
-                i = 0
-                while 1:
-                    b = self.generateSubset(l, k, i)
-                    if b is None:
-                        break
-                    print("%i %i %s: %s"%(l, k, i, b))
-                    i += 1
-
-        i = 0
-        while 1:
-            b = self.generateSubset(25, 24, i)
-            if b is None:
-                break
-            print("%i %i %s: %s"%(25, 24, i, b))
-            i += 1
-
-        self.precacheChoose(10000, 12)
-        i = 160000
-        b = self.generateSubset(100, 3, i)
-        print("%i %i %s: %s"%(100, 3, i, b))
-
-        i = 160000000000000000000000000000
-        b = self.generateSubset(10000, 12, i)
-        print("%i %i %s: %s"%(10000, 12, i, b))
-
-    def invert(self,n,l):
-        k=len(l)
-        assert(k<=n) #assert subset of {1,...,n}
-        assert(k==len(set(l)))#assert unique elements
-        assert(max(l)<n)
-        l.sort()
-        if k==1:
-            return l[0]
-        elif k==0:
-            return 0
-        else:
-            return self.choose(n,k)-self.choose(n-l[0],k)+self.invert(n-l[0]-1,list(map(lambda x: x-l[0]-1,l[1:])))
+	def __init__(self):
+		self.cache = {}
+	def choose(self, n, k):
+		# handle the simple cases
+		if (k>n):
+			return 0
+		k = min(k, n-k)
+		if k == 0:
+			return 1
+		elif k < 0:
+			raise Exception("negative k?")
+		elif k == 1:
+			return n
+		# handle caching and subcalls
+		c = (n,k)
+		if c not in self.cache:
+			self.cache[c] = self.choose(n-1, k) + self.choose(n-1, k-1)
+		return self.cache[c]
+
+	def precacheChoose(self, n, k=None):
+		# adjust your bounds
+		if k is None:
+			k = (n+1)//2 - 1
+		for k_i in xrange(1, k+1):
+			for n_i in xrange(k_i, n+1):
+				self.choose(n_i, k_i)
+
+	def generateSubset(self, n, k, i):
+		# non-recursive generateSubset(n, k, i), which will choose the i'th
+		# subset of size k from n items (numbered 0..n-1)
+		b = None
+		offset = 0
+		while 1:
+			if b is None:
+				b = set()
+
+			upperBound = self.choose(n,k)
+			if i >= upperBound:
+				return None
+
+			zeros = 0
+			low = 0
+			high = self.choose(n-1, k-1)
+			while i >= high:
+				zeros += 1
+				low = high
+				high += self.choose(n-zeros-1, k-1)
+
+			if (zeros + k) > n:
+				raise Exception("Too many zeros!")
+
+			b.add(offset + zeros)
+			if k == 1:
+				return sorted(b)
+			else:
+				n -= zeros + 1
+				k -= 1
+				i -= low
+				offset += zeros+1
+
+	def test(self):
+		for l in xrange(1, 10):
+			for k in xrange(1, min(l, 5)):
+				i = 0
+				while 1:
+					b = self.generateSubset(l, k, i)
+					if b is None:
+						break
+					print("%i %i %s: %s"%(l, k, i, b))
+					i += 1
+
+		i = 0
+		while 1:
+			b = self.generateSubset(25, 24, i)
+			if b is None:
+				break
+			print("%i %i %s: %s"%(25, 24, i, b))
+			i += 1
+
+		self.precacheChoose(10000, 12)
+		i = 160000
+		b = self.generateSubset(100, 3, i)
+		print("%i %i %s: %s"%(100, 3, i, b))
+
+		i = 160000000000000000000000000000
+		b = self.generateSubset(10000, 12, i)
+		print("%i %i %s: %s"%(10000, 12, i, b))
+
+	def invert(self,n,l):
+		k=len(l)
+		assert(k<=n) #assert subset of {1,...,n}
+		assert(k==len(set(l)))#assert unique elements
+		assert(max(l)<n)
+		l.sort()
+		if k==1:
+			return l[0]
+		elif k==0:
+			return 0
+		else:
+			return self.choose(n,k)-self.choose(n-l[0],k)+self.invert(n-l[0]-1,list(map(lambda x: x-l[0]-1,l[1:])))
+	def algebraicInvert(self,n,l):
+		k=len(l)
+		l.sort()
+		return  self.choose(n,k) - self.choose(n-l[0],k) + sum([self.choose(n-l[i-1]-1,k-i) - self.choose(n-l[i],k-i) for i in range(1,k)])
 
 
 if __name__=='__main__':
-    a = EnumeratedSubsets()
-    max_n = 10
-    for n in range(1,max_n):
-        for k in range(1,n+1):
-            for i in range(0,a.choose(n,k)):
-                l= a.generateSubset(n,k,i)
-                assert(a.invert(n,l)==i)
-    else:
-        print("Passed all tests")
+	a = EnumeratedSubsets()
+	max_n = 15
+	for n in range(8,max_n):
+		for k in range(1,n+1):
+			for i in range(0,a.choose(n,k)):
+				l= a.generateSubset(n,k,i)
+				assert(a.invert(n,l)==i)
+				assert(a.invert(n,l)==a.algebraicInvert(n,l))
+
+				print("generateSubset(" + str(n) + "," + str(k) + "," + str(i) + ") = " + str(l))
+				print("invert(" + str(n) + "," + str(l) + ") = " + str(a.invert(n,l)))
+				print("algebraicInvert(" + str(n) + "," + str(l) + ") = " + str(a.algebraicInvert(n,l)))
+				print()
+
+	else:
+		print("Passed all tests")

From edcb6c1b2b3deff6efaa671118a5f2099c4d4bac Mon Sep 17 00:00:00 2001
From: Zach S <zsiegel92@gmail.com>
Date: Wed, 12 Jul 2017 00:01:11 -0700
Subject: [PATCH 3/3] cleaned up main

---
 python/subsets.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/subsets.py b/python/subsets.py
index 6883cd1..0918447 100755
--- a/python/subsets.py
+++ b/python/subsets.py
@@ -115,7 +115,7 @@ def algebraicInvert(self,n,l):
 if __name__=='__main__':
 	a = EnumeratedSubsets()
 	max_n = 15
-	for n in range(8,max_n):
+	for n in range(1,max_n):
 		for k in range(1,n+1):
 			for i in range(0,a.choose(n,k)):
 				l= a.generateSubset(n,k,i)