GoldenSeed
by @beanapologist
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.
clawhub install goldenseedπ About This Skill
name: goldenseed description: 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. tags: [testing, procedural-generation, deterministic, reproducibility, golden-ratio] version: 1.0.0 author: beanapologist license: GPL-3.0+
GoldenSeed - Deterministic Entropy for Agents
Reproducible randomness when you need identical results every time.
What This Does
GoldenSeed generates infinite deterministic byte streams from tiny fixed seeds. Same seed β same output, always. Perfect for:
What This Doesn't Do
β οΈ NOT cryptographically secure - Don't use for passwords, keys, or security tokens. Use os.urandom() or secrets module for crypto.
Quick Start
Installation
pip install golden-seed
Basic Usage
from gq import UniversalQKDCreate 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
Statistical Quality - Perfect 50/50 Coin Flip
from gq import UniversalQKDdef 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
Reproducible Testing
from gq import UniversalQKDclass 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!
Procedural World Generation
from gq import UniversalQKDclass 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']}")
Hash Verification
from gq import UniversalQKD
import hashlibdef 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
Agent Use Cases
Debugging Flaky Tests
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 timeUse:
from gq import UniversalQKD
gen = UniversalQKD()
value = next(gen)[0] % 100 + 1 # Same value for same seed
Procedural Art Generation
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)
Competitive Game Fairness
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) + 1Players 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
References
examples/ directory in repositorydocs/ENTROPY_ANALYSIS.mdMulti-Language Support
Identical output across platforms:
examples/binary_fusion_tap.js)License
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.
π‘ Examples
Installation
pip install golden-seed
Basic Usage
from gq import UniversalQKDCreate 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
Statistical Quality - Perfect 50/50 Coin Flip
from gq import UniversalQKDdef 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
Reproducible Testing
from gq import UniversalQKDclass 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!
Procedural World Generation
from gq import UniversalQKDclass 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']}")
Hash Verification
from gq import UniversalQKD
import hashlibdef 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