Only Satoshi's single computer mining on the entire network
Very low difficulty, blocks found in seconds
Tens of thousands of blocks per day

Millions of professional mining machines worldwide
Still the same low difficulty
Countless blocks produced every second
Network completely collapses

Observe student performance → Manually adjust question difficulty → Next exam

Observe mining performance → Automatically adjust mining difficulty → Next cycle

python
def difficulty_adjustment_analogy():
    """Difficulty adjustment analogy demo"""
    print("🎯 Bitcoin difficulty adjustment = Smart thermostat")
    print()

    situations = [
        ("Summer gets hot", "Room temp rises", "AC auto-cools", "Temp returns to 25°C"),
        ("Winter gets cold", "Room temp drops", "Heater auto-warms", "Temp returns to 25°C"),
        ("Miners flood in", "Blocks come faster", "Difficulty auto-increases", "Blocks return to 10 min"),
        ("Miners leave en masse", "Blocks slow down", "Difficulty auto-decreases", "Blocks return to 10 min")
    ]

    for situation, change, action, result in situations:
        print(f"📍 {situation} → {change} → {action} → {result}")

difficulty_adjustment_analogy()

python
def simple_difficulty_calculation():
    """Simplified difficulty adjustment calculation"""
    print("📊 Difficulty adjustment formula (simplified):")
    print()

    # Simulated data
    target_time = 20160  # Target time: 14 days (in minutes)
    actual_time = 15000  # Actual time: assume 10.4 days
    current_difficulty = 100  # Current difficulty

    print(f"Target time: {target_time:,} minutes (14 days)")
    print(f"Actual time: {actual_time:,} minutes ({actual_time/1440:.1f} days)")
    print(f"Current difficulty: {current_difficulty}")
    print()

    # Calculate new difficulty
    new_difficulty = current_difficulty * target_time / actual_time
    adjustment_ratio = new_difficulty / current_difficulty

    print("Calculation process:")
    print(f"New difficulty = Current difficulty × (Target time ÷ Actual time)")
    print(f"New difficulty = {current_difficulty} × ({target_time:,} ÷ {actual_time:,})")
    print(f"New difficulty = {current_difficulty} × {target_time/actual_time:.3f}")
    print(f"New difficulty = {new_difficulty:.1f}")
    print()

    print(f"📈 Difficulty change: {adjustment_ratio:.1%} ({'increase' if adjustment_ratio > 1 else 'decrease'})")

simple_difficulty_calculation()

python
def adjustment_limits_demo():
    """Difficulty adjustment limits demo"""
    print("⚡ Why are adjustment limits needed?")
    print()

    scenarios = [
        {
            "scenario": "99% of miners suddenly leave",
            "without_limits": "Difficulty drops to near zero, causing inflation",
            "with_limits": "Difficulty drops by at most 75%, requires several rounds to gradually adjust"
        },
        {
            "scenario": "Computing power suddenly increases 100x",
            "without_limits": "Difficulty spikes, possibly hours between blocks",
            "with_limits": "Difficulty increases by at most 4x, requires several rounds to gradually adjust"
        }
    ]

    for scenario in scenarios:
        print(f"🔍 {scenario['scenario']}")
        print(f"❌ Without limits: {scenario['without_limits']}")
        print(f"✅ With limits: {scenario['with_limits']}")
        print()

adjustment_limits_demo()

python
def historical_events():
    """Difficulty adjustment during major historical events"""
    events = [
        {
            "date": "November 2017",
            "event": "Bitcoin price surges to $20,000",
            "impact": "Massive miner influx",
            "difficulty_change": "Rapid increase",
            "result": "Block time remains stable"
        },
        {
            "date": "2018 bear market",
            "event": "Price drops from $20,000 to $3,000",
            "impact": "Many miners shut down and exit",
            "difficulty_change": "Rapid decrease",
            "result": "Block time remains stable"
        },
        {
            "date": "May 2021",
            "event": "China bans Bitcoin mining",
            "impact": "50% of computing power disappears instantly",
            "difficulty_change": "Record-breaking drop",
            "result": "Network continues operating normally"
        }
    ]

    print("📚 Historical tests of Bitcoin difficulty adjustment:")
    print()

    for event in events:
        print(f"📅 {event['date']}: {event['event']}")
        print(f"💥 Impact: {event['impact']}")
        print(f"🔧 Response: {event['difficulty_change']}")
        print(f"✅ Result: {event['result']}")
        print()

historical_events()

python
def stability_statistics():
    """15-year stability statistics"""
    print("📊 Bitcoin 15-year stability data:")
    print()

    stats = {
        "Total blocks": "850,000+",
        "Average block time": "9.8 minutes (target: 10 minutes)",
        "Longest block interval": "116 minutes (rare event)",
        "Shortest block interval": "1 second (pure luck)",
        "Difficulty adjustments": "400+ times",
        "Network downtime": "0 seconds",
        "Adjustment success rate": "100%"
    }

    for metric, value in stats.items():
        print(f"・{metric}: {value}")

    print()
    print("🏆 Conclusion: Bitcoin's clock is more accurate than a Swiss watch!")

stability_statistics()

python
def miner_perspective():
    """Difficulty adjustment from a miner's perspective"""
    print("⛏️ Miner Wang's daily routine:")
    print()

    daily_life = [
        "6 AM: Check overnight mining earnings — 'Not bad, mined 0.5 BTC'",
        "9 AM: News says another big mining farm just opened — 'Competition is about to heat up'",
        "2 PM: Notice blocks are coming faster — 'Only 8 minutes for a new block, difficulty will adjust'",
        "Two weeks later: Difficulty adjustment takes effect — 'Sure enough, difficulty increased 15%'",
        "One month later: Earnings basically recover — 'Still the same earnings level, the system is really stable'"
    ]

    for life in daily_life:
        print(f"📍 {life}")

    print()
    print("💡 Insight: No matter how miners change, earnings always return to equilibrium")

miner_perspective()

python
def difficulty_simulation():
    """Difficulty adjustment simulator"""
    import random

    print("🎮 Difficulty Adjustment Simulator")
    print("=" * 50)

    # Initial parameters
    current_difficulty = 1000
    target_block_time = 10  # minutes
    period_blocks = 10  # Simplified to 10 blocks per cycle

    print(f"Initial difficulty: {current_difficulty}")
    print(f"Target block time: {target_block_time} minutes")
    print(f"Adjustment cycle: every {period_blocks} blocks")
    print()

    for cycle in range(3):
        print(f"--- Cycle {cycle + 1} ---")

        # Simulate block times for this cycle
        total_time = 0
        for block in range(period_blocks):
            # Calculate block time based on current difficulty (with randomness)
            base_time = 1000 / current_difficulty  # Base time
            actual_time = base_time * (0.5 + random.random())  # Add randomness
            total_time += actual_time

        average_time = total_time / period_blocks
        target_total_time = target_block_time * period_blocks

        print(f"Actual average block time: {average_time:.1f} minutes")
        print(f"Target average block time: {target_block_time} minutes")

        # Calculate new difficulty
        adjustment_factor = target_total_time / total_time
        new_difficulty = current_difficulty * adjustment_factor

        # Apply adjustment limits
        max_increase = current_difficulty * 4
        min_decrease = current_difficulty * 0.25
        new_difficulty = min(max_increase, max(min_decrease, new_difficulty))

        change_percent = (new_difficulty / current_difficulty - 1) * 100

        print(f"Difficulty adjustment: {current_difficulty:.0f} → {new_difficulty:.0f} ({change_percent:+.1f}%)")
        print()

        current_difficulty = new_difficulty

# Run the simulation
difficulty_simulation()