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.
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
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.
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:
✅ Testing reproducibility: Debug flaky tests by replaying exact random sequences
✅ Procedural generation: Create verifiable game worlds, art, music from seeds
✅ Scientific simulations: Reproducible Monte Carlo, physics engines
✅ Statistical testing: Perfect 50/50 coin flip distribution (provably fair)
✅ Hash verification: Prove output came from declared seed
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 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()
(gen1) == (gen2)
assert
next
next
# Always identical
Statistical Quality - Perfect 50/50 Coin Flip
from gq import UniversalQKD
defcoin_flip_test(n=1_000_000):
"""Demonstrate perfect 50/50 distribution"""
gen = UniversalQKD()
heads = 0for _ inrange(n):
byte = next(gen)[0] # Get first byteif byte & 1: # Check LSB
heads += 1
ratio = heads / n
print(f"Heads: {ratio:.6f} (expected: 0.500000)")
returnabs(ratio - 0.5) < 0.001# Within 0.1%assert coin_flip_test() # ✓ Passes every time
Reproducible Testing
from gq import UniversalQKD
classTestDataGenerator:
def__init__(self, seed=0):
self.gen = UniversalQKD()
# Skip to seed positionfor _ inrange(seed):
next(self.gen)
defrandom_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 timedeftest_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 UniversalQKD
classWorldGenerator:
def__init__(self, world_seed=0):
self.gen = UniversalQKD()
for _ inrange(world_seed):
next(self.gen)
defchunk(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 hashlib
defgenerate_with_proof(seed=0, n_chunks=1000):
"""Generate data with hash proof"""
gen = UniversalQKD()
for _ inrange(seed):
next(gen)
chunks = [next(gen) for _ inrange(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 outputassert 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 time# Use: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:
defgenerate_art(seed):
gen = UniversalQKD()
for _ inrange(seed):
next(gen)
# Generate deterministic art parameters
palette = [next(gen)[i % 16] for i inrange(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:
classFairDice:
def__init__(self, game_seed):
self.gen = UniversalQKD()
for _ inrange(game_seed):
next(self.gen)
defroll(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 _ inrange(100)]
# Share seed 99999 - anyone can verify identical sequence
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.
