The Trust Problem with Currency and the Birth of Bitcoin: Why Decentralization is Necessary

The Evolution of Money and the Origins of Bitcoin — Why Decentralized Currency Was Needed

On Monday morning, September 15, 2008. Lehman Brothers, with 158 years of history, went bankrupt. The fourth-largest investment bank in America vanished overnight, and the global financial system collapsed like dominoes. On October 31st of that same year, someone posted a 9-page paper to a cryptography mailing list. The title: "Bitcoin: A Peer-to-Peer Electronic Cash System." The author: Satoshi Nakamoto. Nobody knew who this person was.

I first read this whitepaper in 2017. Honestly, my initial reaction was "what on earth is this saying?" But after studying the Lehman Brothers collapse and reading it again, the whitepaper's opening sentence looked completely different. "An electronic cash system that allows direct transactions without a trusted third party." By the end of today's lesson, you'll fully understand why that single sentence was revolutionary.

📉 The Case: Lehman Brothers and the Collapse of Trust

Background: In the early 2000s, American banks were handing out mortgage loans (subprime mortgages) to people with poor credit, fueled by a single belief: "housing prices always go up." Banks bundled these loans into financial products (MBS, CDOs) and sold them worldwide. Credit rating agencies (Moody's, S&P) assigned the highest ratings (AAA) to these products.

The Decision: Lehman Brothers invested $613 billion in subprime mortgage-related assets. Leverage exceeding 30 times their equity. The reasoning: "The central credit rating agencies gave it AAA, so it's fine."

The Outcome:

• Lehman Brothers bankruptcy → $613 billion in assets wiped out
• Global stock markets lost approximately $10 trillion
• U.S. government bailed out banks with $700 billion in taxpayer money (TARP)
• 26 million additional unemployed worldwide

Here's the core point. When banks fail, it's not the banks that collapse — it's our money that disappears. We "trusted" the banks, and the banks converted that trust into leverage and put it on the gambling table.

# Lehman Brothers leverage ratio simulation
equity = 200       # $20 billion (unit: $100 million)
total_assets = 6130  # $613 billion
leverage_ratio = total_assets / equity

print(f"Equity: ${equity}00M")
print(f"Total assets (invested): ${total_assets}00M")
print(f"Leverage ratio: {leverage_ratio:.1f}x")
print(f"→ A {100/leverage_ratio:.1f}% drop in asset value means bankruptcy!")

# Output:
# Equity: $20000M
# Total assets (invested): $613000M
# Leverage ratio: 30.6x
# → A 3.3% drop in asset value means bankruptcy!

Sit with what this code reveals. A structure where everything collapses from just a 3.3% drop in asset prices. Credit rating agencies that called this "safe." Regulators who let it slide. This entire system was teetering precariously on trust in a handful of central institutions.

🤔 Think about it: If your bank is making 30x leveraged investments with your deposits, is your money truly "safe"?

💰 The Evolution of Money — From Barter to Bitcoin

The Lehman crisis exposed how fragile "trust in central institutions" truly is. But why were we trapped in a structure that required trusting banks in the first place? To understand this, we need to ask a more fundamental question: "What exactly is money?"

When I first presented at a blockchain conference, I skipped the "history of money" and jumped straight to the technical discussion — and lost half the audience. Technology exists to solve problems, and to truly understand those problems, you need to know the history.

The Three Functions of Money

For something to be money, it must satisfy three conditions:

# Money function validator
def validate_money(name, medium_of_exchange, store_of_value, unit_of_account):
    """Validates whether something functions as money"""
    functions = {
        "Medium of Exchange": medium_of_exchange,  # Can you buy things with it?
        "Store of Value": store_of_value,           # Does it retain value over time?
        "Unit of Account": unit_of_account          # Can it price goods?
    }
    
    passed = sum(functions.values())
    print(f"\n=== {name} ===")
    for function, satisfied in functions.items():
        status = "✅" if satisfied else "❌"
        print(f"  {status} {function}")
    print(f"  → {passed}/3 satisfied {'→ Qualifies as money' if passed == 3 else '→ Not full money'}")

# Validate each monetary form
validate_money("Seashells", medium_of_exchange=True, store_of_value=False, unit_of_account=True)
validate_money("Gold", medium_of_exchange=True, store_of_value=True, unit_of_account=True)
validate_money("US Dollar (USD)", medium_of_exchange=True, store_of_value=True, unit_of_account=True)
validate_money("Bitcoin (BTC)", medium_of_exchange=True, store_of_value=True, unit_of_account=True)

# Output:
# === Seashells ===
#   ✅ Medium of Exchange
#   ❌ Store of Value
#   ✅ Unit of Account
#   → 2/3 satisfied → Not full money
#
# === Gold ===
#   ✅ Medium of Exchange
#   ✅ Store of Value
#   ✅ Unit of Account
#   → 3/3 satisfied → Qualifies as money
#
# === US Dollar (USD) ===
#   ✅ Medium of Exchange
#   ✅ Store of Value
#   ✅ Unit of Account
#   → 3/3 satisfied → Qualifies as money
#
# === Bitcoin (BTC) ===
#   ✅ Medium of Exchange
#   ✅ Store of Value
#   ✅ Unit of Account
#   → 3/3 satisfied → Qualifies as money

This code validates each monetary form against the three functions. "Wait, Bitcoin gets a ✅ for store of value?" — Yes, it's debatable. The volatility is real. But looking at the long-term trend since 2009, its value against the dollar has risen, and with a fixed total supply of 21 million, its inflation resistance is stronger than gold. We'll dig deeper into this debate later.

Timeline of Monetary Evolution

There's a notable pattern in this timeline. At each stage, the previous currency's limitations were solved while simultaneously creating new problems:

🤔 Think about it: What is the "double coincidence of wants"? You have rice and need fish, but the fisherman doesn't want rice — he wants clothes. What then?

🔄 The Double Spending Problem — Digital Currency's Achilles' Heel

As money shed its physical form and went digital, a problem emerged that hadn't existed for thousands of years. A fatal flaw unique to digital money that doesn't exist in physical money.

Physical money: When I hand you a $10 bill, it disappears from my wallet. The laws of physics prevent double spending.

Digital files: When I send you an MP3, the original stays on my computer. Copying is free.

So can "digital money" be copied too? Yes. This is the Double Spending Problem.

# Double spending problem simulation
class CentralizedBank:
    def __init__(self):
        self.balance = {}
    
    def open_account(self, name, amount):
        self.balance[name] = amount
    
    def transfer(self, sender, receiver, amount):
        if self.balance[sender] >= amount:
            self.balance[sender] -= amount
            self.balance[receiver] += amount
            return f"✅ {sender} → {receiver}: ${amount} transferred"
        else:
            return f"❌ Insufficient funds! {sender} balance: ${self.balance[sender]}"

# Simulation
bank = CentralizedBank()
bank.open_account("Alice", 10000)
bank.open_account("Bob", 0)
bank.open_account("Charlie", 0)

print("--- Normal Transaction ---")
print(f"Alice balance: ${bank.balance['Alice']}")
print(bank.transfer("Alice", "Bob", 10000))
print(f"Alice balance: ${bank.balance['Alice']}")

print("\n--- Double Spending Attempt ---")
print(bank.transfer("Alice", "Charlie", 10000))  # Should fail — already sent to Bob

# Output:
# --- Normal Transaction ---
# Alice balance: $10000
# ✅ Alice → Bob: $10000 transferred
# Alice balance: $0
#
# --- Double Spending Attempt ---
# ❌ Insufficient funds! Alice balance: $0

The bank in this code does exactly one thing: manage the ledger. Because the bank recorded "Alice balance: $0," double spending is blocked. But what if there were no bank? If Alice told both Bob and Charlie simultaneously "I have $10,000, I'll send it to you" — who would stop her?

The existing digital financial system's solution was simple: the bank (central authority) records and verifies all transactions. But as we saw in the Lehman crisis — what happens when this central authority itself collapses?

This was precisely Satoshi Nakamoto's starting point: "How do you prevent double spending without a central authority?"

🔀 The Evolution of Double Spending Solutions — From Wrong Approaches to the Best Solution

Now that we understand the double spending problem, let's directly compare three approaches to solving it in code. These are the actual stages that digital currency projects before Satoshi went through one by one.

❌ WRONG WAY: Each user manages their own balance (trust-based self-reporting)

# ❌ WRONG WAY: Self-reported balance management
# "Users will honestly report their own balances" — a naive approach

class SelfReportingSystem:
    def __init__(self):
        self.users = {}
    
    def open_account(self, name, amount):
        self.users[name] = {"balance": amount}
    
    def transfer(self, sender, receiver, amount):
        # Problem: the sender directly reports "their own balance"
        # There's no verification entity!
        self.users[sender]["balance"] -= amount
        self.users[receiver]["balance"] += amount
        return f"{sender} → {receiver}: ${amount}"

system = SelfReportingSystem()
system.open_account("Alice", 10000)
system.open_account("Bob", 0)
system.open_account("Charlie", 0)

print("=== ❌ Self-Reporting System ===")
print(system.transfer("Alice", "Bob", 10000))
print(f"Alice balance: ${system.users['Alice']['balance']}")

# 💀 Fatal flaw: Alice directly manipulates her balance!
system.users["Alice"]["balance"] = 10000  # Nobody can stop this
print(f"\n[Alice manipulates balance!] Alice balance: ${system.users['Alice']['balance']}")
print(system.transfer("Alice", "Charlie", 10000))
print(f"Charlie balance: ${system.users['Charlie']['balance']}  ← Money appeared from nowhere!")

# Output:
# === ❌ Self-Reporting System ===
# Alice → Bob: $10000
# Alice balance: $0
#
# [Alice manipulates balance!] Alice balance: $10000
# Alice → Charlie: $10000
# Charlie balance: $10000  ← Money appeared from nowhere!

Why it's wrong: There's no verification entity. If users manage their own data directly, anyone can manipulate their balance. Early digital currency experiments of the 1990s fell into this trap. The assumption that "people will be honest" crumbles when money is involved.

🤔 BETTER: A central server verifies all transactions (DigiCash, e-gold approach)

# 🤔 BETTER: Central server verification approach
# The approach used by DigiCash (1989), e-gold (1996)

class CentralServerSystem:
    def __init__(self, server_name):
        self.server_name = server_name
        self.ledger = {}
        self.transaction_log = []
        self.server_online = True
    
    def open_account(self, name, amount):
        self.ledger[name] = amount
    
    def transfer(self, sender, receiver, amount):
        # If the server is down, no transactions are possible
        if not self.server_online:
            return f"🚫 [{self.server_name}] Server down! Transactions unavailable"
        
        # Central server verifies balance — much safer than self-reporting
        if self.ledger[sender] >= amount:
            self.ledger[sender] -= amount
            self.ledger[receiver] += amount
            self.transaction_log.append(f"{sender}→{receiver}: ${amount}")
            return f"✅ {sender} → {receiver}: ${amount} (server verified)"
        return f"❌ Insufficient funds!"
    
    def server_down(self):
        self.server_online = False

server = CentralServerSystem("DigiCash Server")
server.open_account("Alice", 10000)
server.open_account("Bob", 0)
server.open_account("Charlie", 0)

print("=== 🤔 Central Server Verification System ===")
print(server.transfer("Alice", "Bob", 10000))
print(server.transfer("Alice", "Charlie", 10000))  # ✅ Double spending blocked!
print(f"→ Double spending successfully blocked!\n")

# ⚠️ Fatal weakness: What if the server goes down?
print("[Scenario: Company bankrupt, server down]")
server.server_down()
print(server.transfer("Bob", "Charlie", 5000))
print("→ Single Point of Failure!")

# Output:
# === 🤔 Central Server Verification System ===
# ✅ Alice → Bob: $10000 (server verified)
# ❌ Insufficient funds!
# → Double spending successfully blocked!
#
# [Scenario: Company bankrupt, server down]
# 🚫 [DigiCash Server] Server down! Transactions unavailable
# → Single Point of Failure!

Why it's "better but not enough": Double spending can be prevented. But everything depends on a single server. DigiCash disappeared when the company went bankrupt in 1998. e-gold was forcibly shut down by the U.S. government in 2007. When one server goes off — whether due to company bankruptcy, government pressure, or hacking — the entire system stops. The exact same structural flaw the Lehman Brothers collapse revealed.

✅ BEST: All participants share a ledger and reach consensus (Bitcoin's approach)

# ✅ BEST: Distributed consensus approach (Bitcoin's core idea)
import hashlib

class DistributedConsensusSystem:
    def __init__(self, node_count):
        # All nodes hold identical copies of the ledger
        self.node_count = node_count
        self.ledger = {}
        self.transaction_log = []  # Replicated across all nodes
    
    def open_account(self, name, amount):
        self.ledger[name] = amount
    
    def transaction_hash(self, tx_content):
        """Cryptographically seals a transaction — tampering detected immediately"""
        return hashlib.sha256(tx_content.encode()).hexdigest()[:16]
    
    def transfer(self, sender, receiver, amount):
        tx_content = f"{sender}→{receiver}:{amount}"
        
        # Step 1: All nodes independently verify balance
        if self.ledger[sender] < amount:
            return f"❌ All {self.node_count} nodes rejected: Insufficient funds!"
        
        # Step 2: Majority of nodes approve the transaction (consensus)
        approving_nodes = self.node_count  # In normal state, all approve
        required_majority = self.node_count // 2 + 1
        
        if approving_nodes >= required_majority:
            self.ledger[sender] -= amount
            self.ledger[receiver] += amount
            tx_hash = self.transaction_hash(tx_content)
            self.transaction_log.append({"tx": tx_content, "hash": tx_hash})
            return (f"✅ {sender} → {receiver}: ${amount}\n"
                    f"   Verified: {approving_nodes}/{self.node_count} nodes approved "
                    f"(majority {required_majority} met)\n"
                    f"   Hash: {tx_hash}")
    
    def nodes_partial_down(self, down_count):
        """System continues working even if some nodes die"""
        remaining_nodes = self.node_count - down_count
        required_majority = self.node_count // 2 + 1
        status = "✅ Operating normally" if remaining_nodes >= required_majority else "❌ Cannot reach consensus"
        return (f"{down_count} of {self.node_count} nodes down → "
                f"{remaining_nodes} remaining (majority {required_majority} needed) → {status}")

network = DistributedConsensusSystem(node_count=7)
network.open_account("Alice", 10000)
network.open_account("Bob", 0)
network.open_account("Charlie", 0)

print("=== ✅ Distributed Consensus System (Bitcoin approach) ===\n")
print(network.transfer("Alice", "Bob", 10000))
print()
print(network.transfer("Alice", "Charlie", 10000))  # Double spending blocked
print()

# Key point: system stays alive even if some nodes die!
print("[Fault tolerance test]")
print(network.nodes_partial_down(2))   # 5/7 remain → OK
print(network.nodes_partial_down(3))   # 4/7 remain → OK (majority is 4)
print(network.nodes_partial_down(4))   # 3/7 remain → cannot reach consensus

# Output:
# === ✅ Distributed Consensus System (Bitcoin approach) ===
#
# ✅ Alice → Bob: $10000
#    Verified: 7/7 nodes approved (majority 4 met)
#    Hash: 5a4d2e8f1c3b7a90
#
# ❌ All 7 nodes rejected: Insufficient funds!
#
# [Fault tolerance test]
# 2 of 7 nodes down → 5 remaining (majority 4 needed) → ✅ Operating normally
# 3 of 7 nodes down → 4 remaining (majority 4 needed) → ✅ Operating normally
# 4 of 7 nodes down → 3 remaining (majority 4 needed) → ❌ Cannot reach consensus

Why this is the best: The key differences between the three approaches come down to this:

This comparison shows why Satoshi Nakamoto's innovation was not "simply better technology" but a paradigm shift. He didn't build "a better bank" — he built a structure that doesn't need banks.

📄 Satoshi Nakamoto's Solution — 3 Core Ideas from the Whitepaper

Standing on the code of predecessors who failed for 20 years, Satoshi fit the last piece of the puzzle into place. The whitepaper released on October 31, 2008, is just 9 pages. As a blockchain developer, I find these 9 pages far clearer than Ethereum's hundreds-of-pages Yellow Paper. Let me compress it into three core ideas.

Idea 1: Distributed Ledger

Instead of one bank holding a ledger, every participant in the network holds the same ledger.

# Centralized vs distributed ledger comparison
class CentralizedLedger:
    def __init__(self):
        self.ledger = []  # Exists in only one place — the bank
    
    def record_transaction(self, tx):
        self.ledger.append(tx)
        print(f"🏦 Recorded in central ledger: {tx}")

class DistributedLedger:
    def __init__(self, node_count):
        # Every participant holds an identical copy of the ledger
        self.nodes = [[] for _ in range(node_count)]
    
    def record_transaction(self, tx):
        for node in self.nodes:
            node.append(tx)
        print(f"🌐 Simultaneously recorded on {len(self.nodes)} nodes: {tx}")
    
    def verify_ledger_consistency(self):
        reference = self.nodes[0]
        consistent = all(node == reference for node in self.nodes)
        print(f"Ledger consistency: {'✅ All identical' if consistent else '❌ Discrepancy found'}")

# Distributed ledger test
network = DistributedLedger(node_count=5)
network.record_transaction("Alice → Bob: 1 BTC")
network.record_transaction("Bob → Charlie: 0.5 BTC")
network.verify_ledger_consistency()

# Output:
# 🌐 Simultaneously recorded on 5 nodes: Alice → Bob: 1 BTC
# 🌐 Simultaneously recorded on 5 nodes: Bob → Charlie: 0.5 BTC
# Ledger consistency: ✅ All identical

This code clearly shows the difference between a centralized and distributed ledger. If a bank's server is hacked? One ledger is tampered with, and that's it. But if 5,000+ nodes all hold the same ledger? Tampering with one or two is pointless — the other 4,998 will say "this is a fake."

Idea 2: Proof of Work

"Then who organizes transactions and puts them into blocks?" → The person who solves a math problem fastest does. This process is called mining. We'll cover it in depth in the third lesson, but for now let's just grasp the concept.

Idea 3: Economic Incentives

Why would a miner pay their own electricity bill to solve math problems? Because they receive Bitcoin as a reward. The system is designed so that participating honestly is more economically beneficial than attacking it. It creates a structure where guarding is more profitable than stealing.

🤔 Think about it: Why did Satoshi remain anonymous? Was it simply about privacy?

⚔️ Bitcoin vs Traditional Finance — A Structural Comparison

Now that we understand the three core ideas, it's time to place traditional finance and Bitcoin side by side. "So what's actually different?" — one table and one piece of code will answer that.

# Inflation comparison: Dollar vs Bitcoin
import math

def dollar_purchasing_power(year, annual_inflation=0.03):
    """Change in real purchasing power of $1 (assuming 3% annual inflation)"""
    years_elapsed = year - 2024
    return round(1 / ((1 + annual_inflation) ** years_elapsed), 4)

def bitcoin_issuance_rate(year):
    """Bitcoin halves every 4 years → issuance is cut in half"""
    # Started in 2009, halves every 4 years
    years_elapsed = year - 2009
    halvings = years_elapsed // 4
    initial_reward = 50  # BTC per block
    current_reward = initial_reward / (2 ** halvings)
    return round(current_reward, 4)

print("Year  | $1 Purchasing Power | BTC Block Reward")
print("------|---------------------|----------------")
for year in [2009, 2012, 2016, 2020, 2024, 2028, 2032]:
    power = dollar_purchasing_power(year)
    reward = bitcoin_issuance_rate(year)
    print(f"{year}  | ${power:<19} | {reward} BTC")

# Output:
# Year  | $1 Purchasing Power | BTC Block Reward
# ------|---------------------|----------------
# 2009  | $1.5513             | 50 BTC
# 2012  | $1.4198             | 25.0 BTC
# 2016  | $1.2668             | 12.5 BTC
# 2020  | $1.1303             | 6.25 BTC
# 2024  | $1.0                | 3.125 BTC
# 2028  | $0.8885             | 1.5625 BTC
# 2032  | $0.7894             | 0.7813 BTC

This code shows the two currencies diverging in opposite directions as numbers. The dollar's purchasing power melts away year after year, while Bitcoin's new issuance shrinks year after year. Around 2140, Bitcoin's new issuance reaches 0. For the first time in history, a currency has been created that no politician or central bank governor can change the supply of.

🎯 Application — What If You Were the Head of Financial Regulation in 2008?

Lehman Brothers is on the verge of collapse. You have three options before you:

Option A: $700 billion bailout — saving banks with taxpayer money
Option B: Let it go bankrupt — leave it to the market's self-correction
Option C: Promote a new financial system (decentralized) — foster alternatives through deregulation

📊 Numbers That Matter — Key Bitcoin Figures

Numbers you absolutely need to have in your head to understand Bitcoin:

# Bitcoin key numbers dashboard
key_numbers = {
    "Total supply cap": "21,000,000 BTC",
    "Current supply (March 2026)": "~19,640,000 BTC (93.5%)",
    "Block generation time": "~10 minutes",
    "Current block reward": "3.125 BTC (post-2024 halving)",
    "Next halving": "2028 (estimated)",
    "Genesis block date": "January 3, 2009",
    "Global node count": "~50,000+",
    "Satoshi (smallest unit)": "0.00000001 BTC",
    "Whitepaper page count": "9 pages",
    "Satoshi's estimated holdings": "~1,000,000 BTC",
}

print("=== Bitcoin Key Numbers ===\n")
for item, value in key_numbers.items():
    print(f"  📌 {item}: {value}")

# Output:
# === Bitcoin Key Numbers ===
#
#   📌 Total supply cap: 21,000,000 BTC
#   📌 Current supply (March 2026): ~19,640,000 BTC (93.5%)
#   📌 Block generation time: ~10 minutes
#   📌 Current block reward: 3.125 BTC (post-2024 halving)
#   📌 Next halving: 2028 (estimated)
#   📌 Genesis block date: January 3, 2009
#   📌 Global node count: ~50,000+
#   📌 Satoshi (smallest unit): 0.00000001 BTC
#   📌 Whitepaper page count: 9 pages
#   📌 Satoshi's estimated holdings: ~1,000,000 BTC

🤔 Think about it: If Bitcoin's total supply is fixed at 21 million, and the world's 8 billion people split it equally, how much would each person get?

✅ Actionable Takeaways — 3 Things You Can Do Right Now

1. Read the Satoshi Nakamoto whitepaper yourself

It's only 9 pages. If the English original is difficult, Korean translations are available. Read at least the Abstract. Everything in this course starts from those 9 pages.

2. Check the message in the Bitcoin Genesis Block

The message Satoshi left in the first block (the genesis block):

"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"

He embedded a newspaper headline from The Times verbatim. This was no accident. It's a declaration: "This is why I built this."

3. Apply the centralized vs decentralized mindset to everyday life

KakaoTalk goes down? → Central server problem (centralized)
Torrents go down? → Individual seeds disappear (decentralized — the whole network stays up)

Once you start seeing the world through this lens, you'll feel viscerally why blockchain is necessary.

🔨 Project Update

The final project for this course is the Bitcoin On-Chain Insights Report. We build it piece by piece each lesson. Today is the first milestone: generating the report template + writing the core glossary.

Run the code below to generate the report's skeleton:

# Bitcoin On-Chain Insights Report — Chapter 1 Template Generator
# Running this code generates a report_template.md file

report_content = """
# 📊 Bitcoin On-Chain Insights Report
**Author**: [Enter your name here]
**Date**: March 2026
**Version**: v0.1 (Lesson 1)

---

## Table of Contents
1. [What Is Bitcoin?](#chapter-1-what-is-bitcoin)
2. [Blockchain Structure Analysis](#chapter-2-blockchain-structure-analysis)
3. [Network and Consensus Mechanisms](#chapter-3-network-and-consensus-mechanisms)
4. [On-Chain Data Analysis](#chapter-4-on-chain-data-analysis)
5. [Market Cycles and Insights](#chapter-5-market-cycles-and-insights)

---

## Chapter 1: What Is Bitcoin?

### Core Concept Glossary

| #  | Term | Definition |
|----|------|------------|
| 1  | Double Spending | The problem of using the same digital currency more than once. Bitcoin solves this with a distributed ledger |
| 2  | Decentralization | A structure where the network is operated by all participants without a central administrator |
| 3  | P2P | Peer-to-Peer: a network model where individuals transact directly without intermediaries |
| 4  | Distributed Ledger | A system where all participants hold identical copies of the transaction record |
| 5  | Proof of Work | A consensus method where transactions are verified and blocks are created by solving math problems |
| 6  | Mining | The act of performing proof of work to generate new blocks and receive rewards |
| 7  | Genesis Block | The first block of the Bitcoin blockchain, created on January 3, 2009 |
| 8  | Halving | Bitcoin's issuance policy where block rewards are cut in half approximately every 4 years |
| 9  | Satoshi | The smallest unit of Bitcoin (0.00000001 BTC = 1 satoshi) |
| 10 | Fiat Currency | Currency issued by a government and legally guaranteed in value (KRW, USD, etc.) |

### Chapter 1 Key Summary
- 2008 financial crisis → structural risks of centralized finance exposed
- Satoshi Nakamoto proposes "electronic cash without a trusted third party"
- Bitcoin = a decentralized solution to the double spending problem

---

## Chapter 2: Blockchain Structure Analysis
> 🔜 To be updated in Lesson 2

## Chapter 3: Network and Consensus Mechanisms
> 🔜 To be updated in Lessons 3–4

## Chapter 4: On-Chain Data Analysis
> 🔜 To be updated in Lessons 5–8

## Chapter 5: Market Cycles and Insights
> 🔜 To be updated in Lessons 9–10
"""

# Create file
with open("report_template.md", "w", encoding="utf-8") as f:
    f.write(report_content)

print("✅ report_template.md has been created!")
print(f"📄 File size: {len(report_content)} characters")
print("\n--- Glossary Preview ---")
terms = ["Double Spending", "Decentralization", "P2P", "Distributed Ledger", "Proof of Work",
         "Mining", "Genesis Block", "Halving", "Satoshi", "Fiat Currency"]
for i, term in enumerate(terms, 1):
    print(f"  {i}. {term}")

# Output:
# ✅ report_template.md has been created!
# 📄 File size: 1417 characters
#
# --- Glossary Preview ---
#   1. Double Spending
#   2. Decentralization
#   3. P2P
#   4. Distributed Ledger
#   5. Proof of Work
#   6. Mining
#   7. Genesis Block
#   8. Halving
#   9. Satoshi
#   10. Fiat Currency

What was added in this lesson:

• Full report skeleton (cover, table of contents, 5 section headers)
• Chapter 1: Core concept glossary (10 defined terms)
• Chapter 1: 3-line key summary

Try running the project you've built so far. Running python report_template.py generates the report_template.md file. Open it in a markdown viewer (VS Code, Notion, Typora, etc.) to check it out.

🗺️ Summary Diagram

🔜 Preview of Next Lesson

Today we covered the "why" of Bitcoin. The next lesson digs into the first key of "how" it works: hash functions. A function where changing even a single bit of input completely flips the output — this one thing is the pillar supporting all of blockchain's security. We'll run hash functions directly in Python and hand-build a mini block ourselves.

Difficulty Fork

# Challenge starting code
class ByzantineDistributedLedger:
    def __init__(self, node_count, malicious_node_count):
        self.honest_nodes = [[] for _ in range(node_count - malicious_node_count)]
        self.malicious_nodes = [[] for _ in range(malicious_node_count)]
        # TODO: Implement majority consensus mechanism