Deterministic entropy streams for reproducible testing and procedural generation. Perfect 50/50 statistical distribution with hash verification. Not cryptographically secure - use for testing, worldgen, and scenarios where reproducibility matters more than unpredictability.
Reproducible randomness when you need identical results every time.
GoldenSeed generates infinite deterministic byte streams from tiny fixed seeds. Same seed → same output, always. Perfect for:
⚠️ NOT cryptographically secure - Don't use for passwords, keys, or security tokens. Use os.urandom() or secrets module for crypto.
pip install golden-seed
from gq import UniversalQKD
# Create generator with default seed
gen = UniversalQKD()
# Generate 16-byte chunks
chunk1 = next(gen)
chunk2 = next(gen)
# Same seed = same sequence (reproducibility!)
gen1 = UniversalQKD()
gen2 = UniversalQKD()
assert next(gen1) == next(gen2) # Always identical
from gq import UniversalQKD
def coin_flip_test(n=1_000_000):
"""Demonstrate perfect 50/50 distribution"""
gen = UniversalQKD()
heads = 0
for _ in range(n):
byte = next(gen)[0] # Get first byte
if byte & 1: # Check LSB
heads += 1
ratio = heads / n
print(f"Heads: {ratio:.6f} (expected: 0.500000)")
return abs(ratio - 0.5) < 0.001 # Within 0.1%
assert coin_flip_test() # ✓ Passes every time
from gq import UniversalQKD
class TestDataGenerator:
def __init__(self, seed=0):
self.gen = UniversalQKD()
# Skip to seed position
for _ in range(seed):
next(self.gen)
def random_user(self):
data = next(self.gen)
return {
'id': int.from_bytes(data[0:4], 'big'),
'age': 18 + (data[4] % 50),
'premium': bool(data[5] & 1)
}
# Same seed = same test data every time
def test_user_pipeline():
users = TestDataGenerator(seed=42)
user1 = users.random_user()
# Run again - identical results!
users2 = TestDataGenerator(seed=42)
user1_again = users2.random_user()
assert user1 == user1_again # ✓ Reproducible!
from gq import UniversalQKD
class WorldGenerator:
def __init__(self, world_seed=0):
self.gen = UniversalQKD()
for _ in range(world_seed):
next(self.gen)
def chunk(self, x, z):
"""Generate deterministic chunk at coordinates"""
data = next(self.gen)
return {
'biome': data[0] % 10,
'elevation': int.from_bytes(data[1:3], 'big') % 256,
'vegetation': data[3] % 100,
'seed_hash': data.hex()[:16] # For verification
}
# Generate infinite world from single seed
world = WorldGenerator(world_seed=12345)
chunk = world.chunk(0, 0)
print(f"Biome: {chunk['biome']}, Elevation: {chunk['elevation']}")
print(f"Verifiable hash: {chunk['seed_hash']}")
from gq import UniversalQKD
import hashlib
def generate_with_proof(seed=0, n_chunks=1000):
"""Generate data with hash proof"""
gen = UniversalQKD()
for _ in range(seed):
next(gen)
chunks = [next(gen) for _ in range(n_chunks)]
data = b''.join(chunks)
proof = hashlib.sha256(data).hexdigest()
return data, proof
# Anyone with same seed can verify
data1, proof1 = generate_with_proof(seed=42, n_chunks=100)
data2, proof2 = generate_with_proof(seed=42, n_chunks=100)
assert data1 == data2 # ✓ Same output
assert proof1 == proof2 # ✓ Same hash
When your tests pass sometimes and fail sometimes, replace random values with GoldenSeed to reproduce exact scenarios:
# Instead of:
import random
value = random.randint(1, 100) # Different every time
# Use:
from gq import UniversalQKD
gen = UniversalQKD()
value = next(gen)[0] % 100 + 1 # Same value for same seed
Generate art, music, or NFTs with verifiable seeds:
def generate_art(seed):
gen = UniversalQKD()
for _ in range(seed):
next(gen)
# Generate deterministic art parameters
palette = [next(gen)[i % 16] for i in range(10)]
composition = next(gen)
return create_artwork(palette, composition)
# Seed 42 always produces the same artwork
art = generate_art(seed=42)
Prove game outcomes were fair by sharing the seed:
class FairDice:
def __init__(self, game_seed):
self.gen = UniversalQKD()
for _ in range(game_seed):
next(self.gen)
def roll(self):
return (next(self.gen)[0] % 6) + 1
# Players can verify rolls by running same seed
dice = FairDice(game_seed=99999)
rolls = [dice.roll() for _ in range(100)]
# Share seed 99999 - anyone can verify identical sequence
examples/ directory in repositorydocs/ENTROPY_ANALYSIS.mdIdentical output across platforms:
examples/binary_fusion_tap.js)GPL-3.0+ with restrictions on military applications.
See LICENSE in repository for details.
Remember: GoldenSeed is for reproducibility, not security. When debugging fails, need identical test data, or generating verifiable procedural content, GoldenSeed gives you determinism with statistical quality. For crypto, use secrets module.