Recreates tests with different entropy values

Author: alxmirap

shuffle/README.md

@@ -5,13 +5,13 @@ This section presents two definitions, a recursive one that uses an integer sequ
 
 The implementation of Eq 329 is not generally used in the Gray Paper, and so we present test vectors only for the version of Eq 331. However, the present script creates these test cases with recourse to the Eq 329 implementation, to reproduce exactly the definition of the Gray Paper.
 
+Note: All gray paper references in this document are to version 0.4.3, October 21st 2024.
+
 ## Notes about test parameters
 
 In every case, the output must be a permutation of the input sequence, and this is checked by the generating script.
 In the GP, at the moment, this function is used only to shuffle sequences of validators or cores, both of which are identified by integers. For that reason, all test cases use integers as the input type. All the input elements are distinct to ensure the final positions of each element are unambiguously determined.
 
-All test cases use the same entropy, which is a 32-byte sequence with values from 0 to 31.
-
 All the inputs to each test case are integer sequences, ranging from 0 to n-1, where n is the length. The test cases are described only by the entropy and the length of the input, and so the actual input sequence has to be recreated when using these test cases.
 
 ## Test vectors

shuffle/main.py

@@ -26,21 +26,44 @@ def compute_shuffle_eq329(s, r):
 def number_vector(n): 
     return [x for x in range(n)]
 
-def default_seed():
-    return [i for i in range(32)]
+def uniform_seed(n):
+    return [n] * 32
 
-def inputs_Eq331():
-    seed = default_seed()
+def linear_seed():
+    return [i for i in range(32)]
 
-    yield(number_vector(0), seed)
-    yield(number_vector(8), seed)
-    yield(number_vector(16), seed)
-    yield(number_vector(20), seed)
+def varied_seed(n):
+    # large 32 bit prime
+    large_prime = 2147483647 
+    result = []
+    next = n % large_prime
+
+    # next is always a 32-bit prime, so it fits in 4 bytes.
+    # this loop generates a cycle of modular exponents of a generator.
+    # if this generator is unknown, this cycle is in practice unpredictable,
+    # so this should generate a sequence that looks a bit like random
+    # and should be enough for simple tests.
+    for i in range(8):
+        result = result + list(to_le_bytes(next, 4))
+        next = next * n % large_prime
+    
+    return result
 
-    yield(number_vector(50), seed)
-    yield(number_vector(100), seed)
-    yield(number_vector(200), seed)
-    yield(number_vector(341), seed)
+def inputs_Eq331():
+    zero_seed = uniform_seed(0)
+    ff_seed = uniform_seed(255)
+    simple_seed = linear_seed()
+    irregular_seed = varied_seed(1_000_000_000_000)
+
+    yield(number_vector(0), zero_seed)
+    yield(number_vector(8), ff_seed)
+    yield(number_vector(16), simple_seed)
+    yield(number_vector(20), irregular_seed)
+
+    yield(number_vector(50), zero_seed)
+    yield(number_vector(100), ff_seed)
+    yield(number_vector(200), simple_seed)
+    yield(number_vector(341), irregular_seed)
 
 
 def to_le_bytes(n, k):