goldenseed（goldenseed 测试）

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()
assert next(gen1) == next(gen2)  # Always identical

Statistical Quality - Perfect 50/50 Coin Flip

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

Reproducible Testing

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!

Procedural World Generation

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']}")

Hash Verification

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

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:

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) + 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

References

• GitHub: https://github.com/COINjecture-Network/seed
• PyPI: https://pypi.org/project/golden-seed/
• Examples: See examples/ directory in repository
• Statistical Tests: See docs/ENTROPY_ANALYSIS.md

Multi-Language Support

Identical output across platforms:

• Python (this skill)
• JavaScript (examples/binary_fusion_tap.js)
• C, C++, Go, Rust, Java (see repository)

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.