changeset 1291:73ca89381cfa

benchmark, orlandi: deleted trailing whitespace
author Martin Geisler <mg@cs.au.dk>
date Fri, 16 Oct 2009 19:01:27 +0200
parents 622bf474f8c8
children 9c49d09e2dac
files apps/benchmark.py apps/benchmark_classes.py viff/orlandi.py viff/test/test_orlandi_runtime.py
diffstat 4 files changed, 91 insertions(+), 91 deletions(-) [+]
line wrap: on
line diff
--- a/apps/benchmark.py	Fri Oct 16 19:00:14 2009 +0200
+++ b/apps/benchmark.py	Fri Oct 16 19:01:27 2009 +0200
@@ -92,14 +92,14 @@
               "triple_gen": ("triple_gen", [], NullaryOperation)}
 
 runtimes = {"PassiveRuntime": PassiveRuntime,
-            "PaillierRuntime": PaillierRuntime, 
+            "PaillierRuntime": PaillierRuntime,
             "BasicActiveRuntime": BasicActiveRuntime,
             "OrlandiRuntime": OrlandiRuntime}
 
-mixins = {"TriplesHyperinvertibleMatricesMixin" : TriplesHyperinvertibleMatricesMixin, 
-          "TriplesPRSSMixin": TriplesPRSSMixin, 
+mixins = {"TriplesHyperinvertibleMatricesMixin" : TriplesHyperinvertibleMatricesMixin,
+          "TriplesPRSSMixin": TriplesPRSSMixin,
           "ComparisonToft05Mixin": ComparisonToft05Mixin,
-          "ComparisonToft07Mixin": ComparisonToft07Mixin, 
+          "ComparisonToft07Mixin": ComparisonToft07Mixin,
           "ProbabilisticEqualityMixin": ProbabilisticEqualityMixin}
 
 parser = OptionParser(usage="Usage: %prog [options] config_file")
@@ -136,7 +136,7 @@
 
 parser.set_defaults(modulus=2**65, threshold=1, count=10,
                     runtime="PassiveRuntime", mixins="", num_players=2, prss=True,
-                    operation=operations.keys()[0], parallel=True, fake=False, 
+                    operation=operations.keys()[0], parallel=True, fake=False,
                     args="", needed_data="")
 
 print "*" * 60
--- a/apps/benchmark_classes.py	Fri Oct 16 19:00:14 2009 +0200
+++ b/apps/benchmark_classes.py	Fri Oct 16 19:01:27 2009 +0200
@@ -46,10 +46,10 @@
 
 class Benchmark(object):
     """Abstract base class for all Benchmarks.
-    
+
     For concrete classes see the `ParallelBenchmark` and `SequentialBenchmark` classes.
     A concrete class must be mixed with a `BenchmarkStrategy` and an `Operator`.
-    """ 
+    """
 
     def __init__(self, rt, operation, field, count):
         self.rt = rt
@@ -57,7 +57,7 @@
         self.pc = None
         self.field = field
         self.count = count
-        
+
     def preprocess(self, needed_data):
         print "Preprocess", needed_data
         if needed_data:
@@ -147,7 +147,7 @@
 
     An operation can be nullary, unary, binary, etc.
     """
-    
+
     def generate_operation_arguments(self, _):
         """Generate the input need for performing the operation.
 
@@ -156,7 +156,7 @@
         raise NotImplemented("Override this abstract method in subclasses")
 
     def is_operation_done(self):
-        """Returns true if there are no more operations to perform. 
+        """Returns true if there are no more operations to perform.
         Used in sequential tests.
 
         Returns: Boolean.
@@ -201,7 +201,7 @@
 
 class NullaryOperation(Operation):
     """A nullary operation."""
-    
+
     def generate_operation_arguments(self, _):
         self.nullary_tests = self.count
         return None
@@ -233,7 +233,7 @@
 
 
 class NeededDataBenchmarkStrategy(BenchmarkStrategy):
-    """In a needed data benchmark strategy, all the needed data has to have been generated 
+    """In a needed data benchmark strategy, all the needed data has to have been generated
     before the test is run."""
 
     def benchmark(self, needed_data, pc, *args):
--- a/viff/orlandi.py	Fri Oct 16 19:00:14 2009 +0200
+++ b/viff/orlandi.py	Fri Oct 16 19:01:27 2009 +0200
@@ -124,7 +124,7 @@
     def _expect_orlandi_share(self, peer_id, field):
         """Waits for a number ``x``, ``rho``, and the commitment for ``x``."""
         xi = self._expect_share(peer_id, field)
-        Cx = Deferred()        
+        Cx = Deferred()
         rhoi1 = self._expect_share(peer_id, field)
         rhoi2 = self._expect_share(peer_id, field)
         self._expect_data(peer_id, TEXT, Cx)
@@ -170,12 +170,12 @@
     def secret_share(self, inputters, field, number=None, threshold=None):
         """Share the value, number, among all the parties using additive shareing.
 
-        To share an element ``x in Z_p``, choose random ``x_1, ..., x_n-1 in Z_p``, 
+        To share an element ``x in Z_p``, choose random ``x_1, ..., x_n-1 in Z_p``,
         define ``x_n = x - SUM_i=1^n-1 x_i mod p``.
 
-        Choose random values ``rho_x1, ..., rho_xn in (Z_p)^2``, define 
+        Choose random values ``rho_x1, ..., rho_xn in (Z_p)^2``, define
         ``rho_x = SUM_i=1^n rho_x,i`` and ``C_x = Com_ck(x, p_x)``.
-        
+
         Send ``[x]_i = (x_i, rho_xi, C_x)`` to party ``P_i``.
         """
         assert number is None or self.id in inputters
@@ -186,14 +186,14 @@
         def additive_shares_with_rho(x):
             """Returns a tuple of a list of tuples (player id, share, rho) and rho.
 
-            Chooses random elements ``x_1, ..., x_n-1`` in field and ``x_n`` st. 
+            Chooses random elements ``x_1, ..., x_n-1`` in field and ``x_n`` st.
             ``x_n = x - Sum_i=1^n-1 x_i``.
 
             Chooses random pair of elements ``rho_1, ..., rho_n in Z_p^2``
             and define ``rho_n = Sum_i=1^n rho_i``.
 
             Returns a pair of ``((player id, x_i, rho_i), rho)``.
-            """ 
+            """
             shares = []
             rhos = []
             sum = 0
@@ -206,7 +206,7 @@
                 sum += xi
                 rho1 += rhoi1
                 rho2 += rhoi2
-                shares.append((i, xi, (rhoi1, rhoi2)))    
+                shares.append((i, xi, (rhoi1, rhoi2)))
             xn = field(x) - sum
             rhon1 = field(rand.randint(0, field.modulus - 1))
             rhon2 = field(rand.randint(0, field.modulus - 1))
@@ -245,7 +245,7 @@
 
         Every partyi broadcasts a share pair ``(x_i', rho_x,i')``.
 
-        The parties compute the sums ``x'``, ``rho_x'`` and 
+        The parties compute the sums ``x'``, ``rho_x'`` and
         check ``Com_ck(x',rho_x' = C_x``.
 
         If yes, return ``x = x'``, else else return :const:`None`.
@@ -274,13 +274,13 @@
                 return x
             else:
                 #return x
-                raise OrlandiException("Wrong commitment for value %s, %s, %s, found %s expected %s." % 
+                raise OrlandiException("Wrong commitment for value %s, %s, %s, found %s expected %s." %
                                        (x, rho1, rho2, Cx1, Cx))
 
         def deserialize(ls):
             shares = [(field(long(x)), field(long(rho1)), field(long(rho2))) for x, rho1, rho2 in map(self.list_str, ls)]
             return shares
-            
+
         def exchange((xi, (rhoi1, rhoi2), Cx), receivers):
             # Send share to all receivers.
             ds = self.broadcast(self.players.keys(), receivers, str((str(xi.value), str(rhoi1.value), str(rhoi2.value))))
@@ -304,7 +304,7 @@
     def random_share(self, field):
         """Generate a random share in the field, field.
 
-        To generate a share of a random element ``r in Z_p``, party ``P_i`` 
+        To generate a share of a random element ``r in Z_p``, party ``P_i``
         chooses at random ``r_i, rho_ri in Z_p X (Z_p)^2`` and
         broadcast ``C_r^i = Com_ck(r_i, rho_ri)``.
 
@@ -317,7 +317,7 @@
         self.program_counter[-1] += 1
 
         # P_i chooses at random r_i, rho_ri in Z_p x (Z_p)^2
-        ri = field(rand.randint(0, field.modulus - 1))     
+        ri = field(rand.randint(0, field.modulus - 1))
         rhoi1 = field(rand.randint(0, field.modulus - 1))
         rhoi2 = field(rand.randint(0, field.modulus - 1))
 
@@ -347,7 +347,7 @@
         self.activate_reactor()
 
         return s
-    
+
     def add(self, share_a, share_b):
         """Addition of shares.
 
@@ -367,7 +367,7 @@
                 return OrlandiShare(self, field, v, rhov, Cv)
             return s
 
-        # Either share_a or share_b must have an attribute called "field". 
+        # Either share_a or share_b must have an attribute called "field".
         field = getattr(share_a, "field", getattr(share_b, "field", None))
 
         share_a = is_share(share_a, field)
@@ -401,7 +401,7 @@
                 return OrlandiShare(self, field, v, rhov, Cv)
             return s
 
-        # Either share_a or share_b must have an attribute called "field". 
+        # Either share_a or share_b must have an attribute called "field".
         field = getattr(share_a, "field", getattr(share_b, "field", None))
 
         share_a = is_share(share_a, field)
@@ -426,12 +426,12 @@
 
     def shift(self, inputters, field, number=None):
         """Shift of a share.
-        
+
         Useful for input.
 
         Communication cost: ???.
 
-        Assume the parties are given a random share ``[r]`` by a trusted dealer. 
+        Assume the parties are given a random share ``[r]`` by a trusted dealer.
         Then we denote the following protocol but ``[x] = Shift(P_i, x, [r])``.
 
         1. ``r = OpenTo(P_i, [r]``
@@ -490,7 +490,7 @@
 
         if len(results) == 1:
              return results[0]
-        return results       
+        return results
 
     def mul(self, share_x, share_y):
         """Multiplication of shares.
@@ -618,7 +618,7 @@
         """Multiplication of shares give a triple.
 
         Communication cost: ???.
-        
+
         ``d = Open([x] - [a])``
         ``e = Open([y] - [b])``
         ``[z] = e[x] + d[y] - [de] + [c]``
@@ -692,13 +692,13 @@
         2. Compute::
 
              for j = 1, ..., 2d+1 do
-             [F_j] = [x] + SUM_i=1^d [f_i]*j^i 
+             [F_j] = [x] + SUM_i=1^d [f_i]*j^i
              and
              [G_j] = [y] + SUM_i=1^d [g_i]*j^i
 
         3. ``for j = 1, ..., 2d+1 do [H_j] = Mul([F_j], [G_j], [a_j], [b_j], [c_j])``
 
-        4. compute ``[H_0] = SUM_j=1^2d+1 delta_j[H_j]`` where 
+        4. compute ``[H_0] = SUM_j=1^2d+1 delta_j[H_j]`` where
            ``delta_j = PRODUCT_k=1, k!=j^2d+1 k/(k-j)``
 
         5. output ``[z] = [H_0]``
@@ -738,9 +738,9 @@
 #             print "f:", f
 #             print "g:", g
             # 2) for j = 1, ..., 2d+1 do
-            # [F_j] = [x] + SUM_i=1^d [f_i]*j^i 
+            # [F_j] = [x] + SUM_i=1^d [f_i]*j^i
             # and
-            # [G_j] = [y] + SUM_i=1^d [g_i]*j^i 
+            # [G_j] = [y] + SUM_i=1^d [g_i]*j^i
             h0i, rhoh0, Ch0 = self._additive_constant(field(0), n)
             H0 = OrlandiShare(self, field, h0i, rhoh0, Ch0)
             xi, (rhoxi1, rhoxi2), Cx = x
@@ -752,9 +752,9 @@
                 rho2_Fji = rhoxi2
                 C_Fji = Cx
                 if f != []:
-                    # SUM_i=1^d [f_i]*j^i 
+                    # SUM_i=1^d [f_i]*j^i
                     vi, (rhovi1, rhovi2), Cv = self.sum_poly(j, f)
-                    # [F_j] = [x] + SUM_i=1^d [f_i]*j^i 
+                    # [F_j] = [x] + SUM_i=1^d [f_i]*j^i
                     Fji += vi
                     rho1_Fji += rhovi1
                     rho2_Fji += rhovi2
@@ -764,7 +764,7 @@
                 rho2_Gji = rhoyi2
                 C_Gji = Cy
                 if g != []:
-                    # SUM_i=1^d [g_i]*j^i 
+                    # SUM_i=1^d [g_i]*j^i
                     wi, (rhowi1, rhowi2), Cw = self.sum_poly(j, g)
                     # [G_j] = [y] + SUM_i=1^d [g_i]*j^i
                     Gji += wi
@@ -813,7 +813,7 @@
 
                 i. choose random ``d_ij in Z_p^3``
 
-                ii. compute and send 
+                ii. compute and send
                     ``gamma_ij = alpha_i^b_j Enc_ek_i(1;1)^d_ij`` to ``P_i``.
 
 
@@ -821,13 +821,13 @@
 
            a. compute ``c_i = SUM_j Dec_sk_i(gamma_ij) - SUM_j d_ij mod p``
 
-           b. pick random ``t_i in (Z_p)^2``, compute and 
+           b. pick random ``t_i in (Z_p)^2``, compute and
               broadcast ``C_i = Com_ck(c_i, t_i)``
 
         4. Everyone computes:
            ``(A, B, C) = (PRODUCT_i A_i, PRODUCT_i B_i, PRODUCT_i C_i)``
-        
-        5. Every party ``P_i`` outputs shares ``[a_i] = (a_i, r_i, A)``, 
+
+        5. Every party ``P_i`` outputs shares ``[a_i] = (a_i, r_i, A)``,
            ``[b_i] = (b_i, s_i, B)``, and ``[c_i] = (c_i, t_i, C)``.
 
         """
@@ -856,8 +856,8 @@
                   ``A = PRODUCT_i A_i``
                   ``B = PRODUCT_i B_i``
                   ``C = PRODUCT_i C_i``
-        
-               5) Every party ``P_i`` outputs shares ``[a_i] = (a_i, r_i, A)``, 
+
+               5) Every party ``P_i`` outputs shares ``[a_i] = (a_i, r_i, A)``,
                   ``[b_i] = (b_i, s_i, B)``, and ``[c_i] = (c_i, t_i, C)``.
             """
             A = product(As)
@@ -877,10 +877,10 @@
 
         def step3(gammas, alphas, alpha_randomness, As, Bs, ai, bi, r, s, dijs):
             """3) Every party ``P_i`` does:
-                  (a) compute 
+                  (a) compute
                   ``c_i = SUM_j Dec_sk_i(gamma_ij) - SUM_j d_ji mod p``
 
-                  (b) pick random ``t_i in (Z_p)^2``, compute and 
+                  (b) pick random ``t_i in (Z_p)^2``, compute and
                       broadcast ``C_i = Com_ck(c_i, t_i)``
             """
             # c_i = SUM_j Dec_sk_i(gamma_ij) - SUM_j d_ji mod p.
@@ -892,18 +892,18 @@
             t = (t1, t2)
             # C_i = Com_ck(c_i, t_i).
             Ci = commitment.commit(ci.value, t1.value, t2.value)
-            
+
             # Broadcast Ci.
             Cs = self.broadcast(self.players.keys(), self.players.keys(), repr(Ci))
             result = gatherResults(Cs)
-            result.addCallbacks(step45, self.error_handler, callbackArgs=(alphas, gammas, alpha_randomness, 
+            result.addCallbacks(step45, self.error_handler, callbackArgs=(alphas, gammas, alpha_randomness,
                                                                           As, Bs, ai, bi, ci, r, s, t, dijs))
             return result
 
         def step2c(Bs, As, alphas, alpha_randomness, ai, bj, r, s):
             """(c) P_j do, towards every other party:
                    i. choose random d_i,j in Z_p^3
-                   ii. compute and send 
+                   ii. compute and send
             gamma_ij = alpha_i^b_j Enc_ek_i(1;1)^d_ij to P_i.
             """
 
@@ -935,7 +935,7 @@
                 dijs[pi - 1] = dij
                 results[pi - 1] = d
             result = gatherResults(results)
-            self.schedule_callback(result, step3, alphas, alpha_randomness, 
+            self.schedule_callback(result, step3, alphas, alpha_randomness,
                                    As, Bs, ai, bj, r, s, dijs)
             result.addErrback(self.error_handler)
             return result
@@ -956,11 +956,11 @@
             # Broadcast B_j.
             results = self.broadcast(self.players.keys(), self.players.keys(), repr(Bj))
             result = gatherResults(results)
-            self.schedule_callback(result, step2c, As, alphas, alpha_randomness, 
+            self.schedule_callback(result, step2c, As, alphas, alpha_randomness,
                                    ai, bj, r, (s1, s2))
             result.addErrback(self.error_handler)
             return result
-        
+
         # 1) Every party P_i chooses random values a_i, r_i in Z_p X (Z_p)^2,
         #    compute alpha_i = Enc_eki(a_i) and Ai = Com_ck(a_i, r_i), and
         #    broadcast them.
@@ -970,7 +970,7 @@
         r1 = random_number(field.modulus)
         r2 = random_number(field.modulus)
 
-        # compute alpha_i = Enc_eki(a_i) 
+        # compute alpha_i = Enc_eki(a_i)
         n, g = self.players[self.id].pubkey
         alpha_randomness = rand.randint(1, long(n))
         alphai = encrypt_r(ai.value, alpha_randomness, (n, g))
@@ -993,23 +993,23 @@
         self.schedule_callback(result, step2ab, ai, (r1, r2), alpha_randomness)
         result.addErrback(self.error_handler)
         return result
-    
+
     def triple_test(self, field):
         """Generate a triple ``(a, b, c)`` where ``c = a * b``.
 
-        The triple ``(a, b, c)`` is checked against the 
+        The triple ``(a, b, c)`` is checked against the
         triple ``(x, y, z)`` and a random value ``r``.
 
         """
         triple1 = self.triple_gen(field)
         triple2 = self.triple_gen(field)
         r = self.open(self.random_share(field))
-        
+
         def check((v, oa, ob, oc, ox, oy, oz), a, b, c, ec):
             if v is 0:
                 return None
             return (a, b, c, ec)
-        
+
         def compute_value(((a, b, c, ec), (x, y, z, _), r)):
             oa = self.open(a)
             ob = self.open(b)
@@ -1071,10 +1071,10 @@
             r = self.output(r)
             self.schedule_callback(r, coin_flip, ls, [])
             r.addErrback(self.error_handler)
-            return r            
+            return r
 
         def step45(lists):
-            """For all i in test_set the parties reveal 
+            """For all i in test_set the parties reveal
             the randomness used for TripleTest() and checks that
             the randomness is consistent with the actual values."""
             M_without_test_set = lists[0]
@@ -1099,15 +1099,15 @@
                 return (share, rho1, rho2, commitment)
 
             def send_share(player_id, pc, a):
-                self._send_orlandi_share(player_id, pc, a.share, a.rho, a.commitment) 
-                
+                self._send_orlandi_share(player_id, pc, a.share, a.rho, a.commitment)
+
             def receive_shares(player_id):
                 Cx = Deferred()
                 xi = self._expect_share(player_id, field)
                 rho1 = self._expect_share(player_id, field)
                 rho2 = self._expect_share(player_id, field)
                 self._expect_data(player_id, TEXT, Cx)
-                Cx.addCallbacks(lambda Cx: commitment.deserialize(Cx), 
+                Cx.addCallbacks(lambda Cx: commitment.deserialize(Cx),
                                         self.error_handler)
                 return gatherResults([xi, rho1, rho2, Cx])
 
@@ -1145,7 +1145,7 @@
                 c = 0
                 c_rho1 = 0
                 c_rho2 = 0
-                
+
                 for x in xrange(len(ais)):
                     (ai, a_rhoi1, a_rhoi2, A) = ais[x]
                     (bi, b_rhoi1, b_rhoi2, B) = bis[x]
@@ -1283,12 +1283,12 @@
             self.schedule_callback(r, put_in_set, M_without_test_set, subsets)
             r.addErrback(self.error_handler)
             return r
-            
+
 
         def step7(Msets):
             """For i = 1,...,M do:
             a) [a] <- Fpp(rand,...), [b] <- Fpp(rand,...)
-            b) [r] <- Fpp(rand,...), 
+            b) [r] <- Fpp(rand,...),
             c) [c] <- LTMUL([a], [b], M_i)
             d) Open([c] + [r])
             """
--- a/viff/test/test_orlandi_runtime.py	Fri Oct 16 19:00:14 2009 +0200
+++ b/viff/test/test_orlandi_runtime.py	Fri Oct 16 19:01:27 2009 +0200
@@ -96,19 +96,19 @@
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
 
         def check(v):
-            self.assertEquals(True, True)           
+            self.assertEquals(True, True)
 
         x = runtime.random_share(self.Zp)
         d = runtime.open(x)
         d.addCallback(check)
         return d
- 
+
     @protocol
     def test_sum(self, runtime):
         """Test addition of two numbers."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
- 
+
         x1 = 42
         y1 = 7
 
@@ -187,7 +187,7 @@
 
         x1 = 42
         y1 = 7
- 
+
         def check(v):
             self.assertEquals(v, x1 - y1)
 
@@ -258,10 +258,10 @@
 
 class OrlandiAdvancedCommandsTest(RuntimeTestCase):
     """Test for advanced commands."""
-    
+
     # Number of players.
     num_players = 3
- 
+
     runtime_class = OrlandiRuntime
 
     timeout = 800
@@ -271,10 +271,10 @@
         """Test addition of the shift command."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-        
+
         def check(v):
             self.assertEquals(v, 42)
- 
+
         x = runtime.shift([2], self.Zp, 42)
         d = runtime.open(x)
         d.addCallback(check)
@@ -285,10 +285,10 @@
         """Test addition of the shift command."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-        
+
         def check(v):
             self.assertEquals(v, 42)
- 
+
         x, y = runtime.shift([1,3], self.Zp, 42)
         d1 = runtime.open(x)
         d1.addCallback(check)
@@ -301,11 +301,11 @@
         """Test addition of the shift command."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-        
+
         def r1(ls):
             x, y = ls
             self.assertEquals(runtime.program_counter, [4])
- 
+
         x = runtime.shift([1], self.Zp, 42)
         y = runtime.shift([2], self.Zp, 42)
         r = gather_shares([x, y])
@@ -317,14 +317,14 @@
         """Test addition of the shift command."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-        
+
         def check(v):
             self.assertEquals(v, 42)
 
         def r1((x, y)):
             self.assertEquals(x, 42)
             self.assertEquals(y, 42)
- 
+
         x = runtime.shift([1], self.Zp, 42)
         y = runtime.shift([2], self.Zp, 42)
         r = gather_shares([runtime.open(x), runtime.open(y)])
@@ -361,10 +361,10 @@
 
         x1 = 42
         y1 = 7
- 
+
         def check(v):
             self.assertEquals(v, x1 * y1)
- 
+
         x2 = runtime.shift([2], self.Zp, x1)
         y2 = runtime.shift([3], self.Zp, y1)
 
@@ -382,10 +382,10 @@
 
         x1 = 42
         y1 = 7
- 
+
         def check(v):
             self.assertEquals(v, x1 * y1)
- 
+
         x2 = runtime.shift([2], self.Zp, x1)
         y2 = runtime.shift([3], self.Zp, y1)
 
@@ -494,7 +494,7 @@
         f.append((self.Zp(7), (self.Zp(7), self.Zp(7)), self.Zp(7)))
         f.append((self.Zp(9), (self.Zp(9), self.Zp(9)), self.Zp(9)))
         f.append((self.Zp(13), (self.Zp(13), self.Zp(13)), self.Zp(13)))
-        
+
         x, (rho1, rho2), Cx = runtime.sum_poly(1, f)
         self.assertEquals(x, 29)
         self.assertEquals(rho1, 29)
@@ -507,7 +507,7 @@
         """Test implementation of sum_poly."""
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-        
+
         Cf1 = commitment.commit(21, 21, 21)
         Cf2 = commitment.commit(27, 27, 27)
         Cf3 = commitment.commit(39, 39, 39)
@@ -516,7 +516,7 @@
         f.append((self.Zp(7), (self.Zp(7), self.Zp(7)), Cf1))
         f.append((self.Zp(9), (self.Zp(9), self.Zp(9)), Cf2))
         f.append((self.Zp(13), (self.Zp(13), self.Zp(13)), Cf3))
-        
+
         x, (rho1, rho2), Cx = runtime.sum_poly(3, f)
         self.assertEquals(x, 453)
         self.assertEquals(rho1, 453)
@@ -538,7 +538,7 @@
         self.assertEquals(delta[4], 21)
         self.assertEquals(delta[5], -7)
         self.assertEquals(delta[6], 1)
- 
+
         return delta
 
     @protocol
@@ -547,7 +547,7 @@
         commitment.set_reference_string(long(2), long(6))
 
         self.Zp = GF(6277101735386680763835789423176059013767194773182842284081)
-       
+
         x1 = 42
         y1 = 7
 
@@ -555,7 +555,7 @@
 
         def check(v):
             self.assertEquals(v, x1 * y1)
- 
+
         x2 = runtime.shift([1], self.Zp, x1)
         y2 = runtime.shift([2], self.Zp, y1)
 
@@ -578,9 +578,9 @@
 
     # Number of players.
     num_players = 3
- 
+
     runtime_class = OrlandiRuntime
- 
+
     timeout = 1600
 
     @protocol