第1次熱潮的開端

011955·名稱與計畫書

提出的夏季計畫書

這個名稱是在哪裡、帶著怎樣的展望誕生的？

1955年8月31日，麥卡錫、明斯基、Rochester、夏農4人寫下了為隔年夏天在達特茅斯學院舉辦研究會的計畫書，向洛克斐勒基金會申請經費。這個詞就出現在計畫書的標題中。計畫書從這樣的假設出發：學習或智慧的任何特徵，原則上都（譯）。

右邊的7個方框，是計畫書列出的研究課題。按下就會顯示內容：語言、類神經網路、計算的規模、自我改良的機器。本章的許多頁面，都是其中某一項的後續。

計畫預計進行2個月，參加者為10人。他們寫道，只要選出的科學家在一個夏天聚在一起研究，就能（譯）。申請的預算是13,500美元，但基金會實際補助了7,500美元。

預算表各項加起來是13,000美元，與表上寫的總額13,500美元相差500美元（已核對麥卡錫網站上的重刊版本，差額的原因沒有寫）。

以為知道的事常見說法：是大家一致同意的名稱
原始資料中：這是麥卡錫選的名稱，當時就有不同意見。Newell與賽門多年來一直使用另一個名稱：。

以為知道的事常見說法：達特茅斯的參加者打算用一個夏天就完成AI
原始資料中：計畫書的說法是（譯）。沒有寫要完成。

021956·達特茅斯

一個夏天的研究會是怎樣的聚會

「AI誕生的那場大型會議」，實際上是怎樣的聚會？

1956年夏天，達特茅斯學院數學系的頂樓聚集了一批關心會思考的機器的研究者。根據參加者Solomonoff的筆記，時間大約從6月18日前後到8月17日，約8週。與其說是議程固定的會議，更像是人們輪流來訪、互相討論的聚會。

在右邊的圖按「詳細說明：計畫與紀錄」，就能把5月26日麥卡錫告訴基金會的計畫（紫色框），與Solomonoff、More筆記中留下的「當天在場的人」（深藍色圓點）疊在一起查看。全程在場的只有3人，原定的11人中有2人沒來。每天參加討論的大約有3〜8人。

也有人提議讓所有人一起研究一個課題。8月7日，麥卡錫提議研究西洋棋，但沒有成為共同研究。麥卡錫後來說，經費不足，大家也各有其他事情，全員在整個夏天齊聚的計畫沒有實現。

確切的名單沒有保存下來（麥卡錫遺失了自己的名單）。圓點只代表筆記有留下紀錄的日子，沒有圓點的日子也不一定沒來。

以為知道的事常見說法：達特茅斯研究會是讓AI誕生的大型會議
原始資料中：實際上是人們輪流來訪的夏季聚會，每天討論的只有3〜8人左右。基金會提供的經費約為希望金額的一半，也沒有出版研究會的報告。

第6週（7月23〜27日）每天參加討論的人數（More的筆記）

031956·搜尋

把能做出的證明全都做出來

把能做出的證明依序全部做出來，總有一天會找到想要的定理吧？

Newell、Shaw、賽門挑戰的是《數學原理（Principia Mathematica）》中的邏輯定理。從5條公理出發，用3種規則產生新的定理：把式子代入字母的代入、改寫成同義形式的替換，以及由A和「若A則B」得到B的分離。

最簡單的做法，是把能做出的證明由短到長全部做出來，等目標的式子出現。3人把這叫作大英博物館演算法（British Museum algorithm），作為比較對象。根據報告的數字，到第4層共有42個，到第8層共有246個。要湊齊第2章的全部定理，可能需要1億個左右，他們估計得花幾十萬年。

依序檢查可能的答案，叫作搜尋。逐一檢查時，候選答案太多，因此需要用找捷徑的智慧（啟發式方法）來縮小檢查範圍。右邊的圖，依本站的計數方式逐步產生式子。

第n層的式子數 ≈（第n−1層的式子數）×（一處的改法數）

改法: 把p變成 ¬p、把 → 與 ¬…∨ 互相替換等

每一層的式子數（縱軸每格增加為10倍）

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_british_museum.py

# u03 「大英博物館のやり方」：証明を片っぱしから作ると、どれだけ増えるか
#
# どの出来事か：1957年1月のロジック・セオリストの報告（記録 logic_theorist_1956）。
#   ニューウェルたちは比較対象として、公理から作れる証明をすべて順に作っていく手法を考え、
#   冗談まじりに British Museum algorithm（大英博物館のやり方）と呼んだ。報告にある数値：
#   4段目までに42個、6段目までに115個、8段目までに246個、11段目までで約1,000個。
#   第2章の定理をすべてそろえるには1億個ほど要るかもしれず、何十万年もかかると見積もった。
# 仕組み：公理（5個）から出発し、1段ごとに、前の段の式の1か所だけを変えた式をすべて作る。
#   変え方は報告の図2と同じ2種類。文字を「でない＋その文字」にする（p → -p）、
#   「ならば」と「でない…または」を入れかえる（p > q ⇔ -p v q）。
#   ※ 数え方はこのサイト独自のもので、報告の数とは一致しない。増え方の傾向を見るためのもの。
# 試してみよう：
#   - SPECIALIZE を True にして、文字どうしの代入（q を p にするなど）も入れると、2.07 は出てくるか
#   - STEPS を 12 にすると、作る式の数はどれだけ増えるか

STEPS = 10
SPECIALIZE = False

AXIOMS = ["(p v p) > p", "p > (q v p)", "(p v q) > (q v p)", "(p v (q v r)) > (q v (p v r))", "(p > q) > ((r v p) > (r v q))"]
TARGETS = {"2.01": "(p > -p) > -p", "2.02": "p > (q > p)", "2.07": "p > (p v p)"}

def parse(s):
    toks = s.replace("(", " ( ").replace(")", " ) ").replace("-", " - ").split()
    pos = 0

def expr():
        nonlocal pos
        left = unary()
        if pos < len(toks) and toks[pos] in (">", "v"):
            op = toks[pos]
            pos += 1
            return ("i" if op == ">" else "o", left, expr())
        return left

def unary():
        nonlocal pos
        t = toks[pos]
        pos += 1
        if t == "-":
            return ("n", unary())
        if t == "(":
            e = expr()
            pos += 1
            return e
        return ("v", t)
    return expr()

def show(e):
    if e[0] == "v":
        return e[1]
    if e[0] == "n":
        return "-" + (show(e[1]) if e[1][0] in ("v", "n") else f"({show(e[1])})")
    a, b = show(e[1]), show(e[2])
    a = a if e[1][0] in ("v", "n") else f"({a})"
    b = b if e[2][0] in ("v", "n") else f"({b})"
    return f"{a} {'>' if e[0] == 'i' else 'v'} {b}"

def letters(e, out=None):
    out = set() if out is None else out
    if e[0] == "v":
        out.add(e[1])
    else:
        for x in e[1:]:
            letters(x, out)
    return out

def put(e, v, new):
    if e[0] == "v":
        return new if e[1] == v else e
    if e[0] == "n":
        return ("n", put(e[1], v, new))
    return (e[0], put(e[1], v, new), put(e[2], v, new))

def replacements(e):
    """1 か所だけ「ならば」⇔「でない…または」を入れかえた式をすべて作る。"""
    out = []
    if e[0] == "i":
        out.append(("o", ("n", e[1]), e[2]))
    if e[0] == "o" and e[1][0] == "n":
        out.append(("i", e[1][1], e[2]))
    if e[0] == "n":
        out += [("n", x) for x in replacements(e[1])]
    if e[0] in ("i", "o"):
        out += [(e[0], x, e[2]) for x in replacements(e[1])]
        out += [(e[0], e[1], x) for x in replacements(e[2])]
    return out

def one_change(e):
    ls = sorted(letters(e))
    out = [put(e, v, ("n", ("v", v))) for v in ls]           # p → -p
    if SPECIALIZE:
        out += [put(e, v, ("v", w)) for v in ls for w in ls if v != w]   # q → p
    return out + replacements(e)

targets = {k: parse(s) for k, s in TARGETS.items()}
seen = {parse(a) for a in AXIOMS}
level = list(seen)
total = len(seen)
found = {}
print(f"段  作った式の合計   （公理 5 個から）")
print(f" 1  {total:>8}")
for step in range(2, STEPS + 1):
    new = []
    for e in level:
        for x in one_change(e):
            if x not in seen:
                seen.add(x)
                new.append(x)
                for k, t in targets.items():
                    if x == t and k not in found:
                        found[k] = (step, total + len(new))
    total += len(new)
    level = new
    hits = "、".join(f"{k} が見つかった（{n} 個目）" for k, (s, n) in found.items() if s == step)
    print(f"{step:>2}  {total:>8}  " + "■" * min(60, total // 100) + ("  " + hits if hits else ""))

for k in TARGETS:
    if k not in found:
        print(f"{k} {TARGETS[k]} は、{STEPS} 段までに見つからなかった")
print("\n例：最後の段で作った式の最初の 5 個")
for e in level[:5]:
    print("   ", show(e))

041956·邏輯理論家

從答案那一端，往回找

搜尋定理的證明時，怎麼像人一樣先判斷可能的方向？

邏輯理論家（LT）沒有把所有證明都做出來，而是從想要證明的式子那一端往回找。它依序嘗試4種方法。代入法：把式子代入公理或已證明定理中的字母，看能不能變成與問題完全相同的形式。分離法：找「若A則B」形式的定理，其中B與問題相符，再把A當作新的小問題。向前、向後的銜接，也會產生小問題。

1957年的報告中，在第2章最前面的 52條定理裡，它找到了38條的證明。其中17條只靠代入法，19條用2步就解出。2.01約10秒，2.45約12分鐘。2.31約23分鐘後就用盡搜尋的方法。右邊的圖是本站製作的小型LT。按「做到最後」，樹就會向下伸展，綠色的路徑就是證明。

報告用了這樣的比喻：從公理向前走，就像在乾草堆裡找一根針；從目標往回走，則像是找針從乾草堆裡出來的路。

圖中的LT在細節上與1956年的程式不同。報告寫道，用這4種方法無法證明2.13，但本站的例子在對齊形式的方式與預先準備的定理條件上有所不同，因此勾選「也使用預備定理」時，連2.13的證明也能找到。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_logic_theorist.py

# u03 ロジック・セオリスト：証明を「答えの側から、逆向きに」探す（1956 年の仕組みを小さくした例）
#
# どの出来事か：1956 年、ニューウェル、ショー、サイモンのロジック・セオリスト（記録 logic_theorist_1956）。
#   ホワイトヘッドとラッセルの著書『プリンキピア・マテマティカ』第 2 章の定理の証明を探索した。
#   1957 年の報告では、最初の 52 の定理のうち 38 の証明を見つけた。2.01 は約 10 秒、2.45 は約 12 分。
# 仕組み：原著と同じ 5 つの公理から出発する。証明したい式（問題）に対して、次の 4 つの「方法」を順に試す。
#   1. 代入法：公理や、すでに証明した定理の文字（p, q, r）に式を代入し、問題と一致させられるか調べる
#   2. 切り離し法：「A ならば B」の形の定理で、B が問題と一致するものを探し、A を新しい小さな問題にする
#   3. 前向きのつなぎ：問題が「a ならば c」のとき、「a ならば b」の定理を探し、「b ならば c」を新しい問題にする
#   4. 後ろ向きのつなぎ：「b ならば c」の定理を探し、「a ならば b」を新しい問題にする
#   新しい問題は、すぐ代入法で解けないか試し、解けなければ「あとで考える問題の列」に並べる。
#   ※「A ならば B」は「A でない、または B」と同じとして、形をそろえてから比べる（原著の「置きかえ」の決まり）。
#   ※ これはこのサイトが作成した小さな例。1956 年のプログラムの細かい点（似ているかの判定方法など）は同じではない。
#   報告と同じく、ある定理を証明するときは、公理と、それより前の定理を全部「使ってよい物」として渡す。
# 試してみよう：
#   - ONLY_AXIOMS を True にして、公理だけで始めると、証明できる定理と調べる回数はどう変わるか
#   - GOALS に "2.13" を足すと？（報告では、1956 年のプログラムの 4 つの方法では 2.13 は証明できない。
#     このプログラムは形のそろえ方が違うため、結果が違うことがある。どこが違うか考えてみよう）

AXIOMS = {
    "1.2": "(p v p) > p",
    "1.3": "p > (q v p)",
    "1.4": "(p v q) > (q v p)",
    "1.5": "(p v (q v r)) > (q v (p v r))",
    "1.6": "(p > q) > ((r v p) > (r v q))",
}
# 報告に形が出てくる第 2 章の定理（> は「ならば」、v は「または」、- は「でない」）
THEOREMS = {
    "2.01": "(p > -p) > -p",
    "2.02": "p > (q > p)",
    "2.06": "(p > q) > ((q > r) > (p > r))",
    "2.07": "p > (p v p)",
    "2.12": "p > --p",
    "2.15": "(-p > q) > (-q > p)",
    "2.16": "(p > q) > (-q > -p)",
    "2.17": "(-q > -p) > (p > q)",
    "2.2": "p > (p v q)",
    "2.45": "-(p v q) > -p",
    "2.13": "p v ---p",
    "2.31": "(p v (q v r)) > ((p v q) v r)",
}
GOALS = ["2.01", "2.02", "2.06", "2.07", "2.12", "2.15", "2.16", "2.17", "2.2", "2.45"]
ONLY_AXIOMS = False
MAX_TRIES = 20000          # 調べる定理の数の上限（制限時間の代わり）

# ---------- 式を読む・書く ----------
def parse(s):
    toks = s.replace("(", " ( ").replace(")", " ) ").replace("-", " - ").split()
    pos = 0

def expr():
        nonlocal pos
        left = unary()
        if pos < len(toks) and toks[pos] in (">", "v"):
            op = toks[pos]
            pos += 1
            right = expr()
            return ("i" if op == ">" else "o", left, right)
        return left

def unary():
        nonlocal pos
        t = toks[pos]
        pos += 1
        if t == "-":
            return ("n", unary())
        if t == "(":
            e = expr()
            pos += 1  # ")"
            return e
        return ("v", t)
    return expr()

def show(e):
    if e[0] == "v":
        return e[1]
    if e[0] == "n":
        return "-" + (show(e[1]) if e[1][0] in ("v", "n") else f"({show(e[1])})")
    a, b = show(e[1]), show(e[2])
    a = a if e[1][0] in ("v", "n") else f"({a})"
    b = b if e[2][0] in ("v", "n") else f"({b})"
    return f"{a} {'>' if e[0] == 'i' else 'v'} {b}"

def canon(e):
    """「A ならば B」を「A でない、または B」に直して、形をそろえる。"""
    if e[0] == "v":
        return e
    if e[0] == "n":
        return ("n", canon(e[1]))
    if e[0] == "i":
        return ("o", ("n", canon(e[1])), canon(e[2]))
    return ("o", canon(e[1]), canon(e[2]))

def match(pat, e, sub):
    """定理 pat の文字に式を代入して e と一致させられるか調べる。できれば代入の辞書を返す。"""
    if pat[0] == "v":
        name = pat[1]
        if name in sub:
            return sub if sub[name] == e else None
        s2 = dict(sub)
        s2[name] = e
        return s2
    if pat[0] != e[0]:
        return None
    if pat[0] == "n":
        return match(pat[1], e[1], sub)
    s1 = match(pat[1], e[1], sub)
    return None if s1 is None else match(pat[2], e[2], s1)

def subst(e, sub):
    if e[0] == "v":
        return sub.get(e[1], e)
    if e[0] == "n":
        return ("n", subst(e[1], sub))
    return (e[0], subst(e[1], sub), subst(e[2], sub))

def letters(e, out=None):
    out = set() if out is None else out
    if e[0] == "v":
        out.add(e[1])
    else:
        for x in e[1:]:
            letters(x, out)
    return out

def as_implication(e):
    """形をそろえた式が「A ならば B」（= A でない、または B）なら (A, B) を返す。"""
    if e[0] == "o" and e[1][0] == "n":
        return e[1][1], e[2]
    return None

# ---------- ロジック・セオリスト（小さくした例） ----------
def prove(goal, known):
    tries = 0
    theorems = [(name, canon(parse(s))) for name, s in known]
    root = canon(goal)

def by_substitution(problem):
        nonlocal tries
        for name, t in theorems:
            tries += 1
            if match(t, problem, {}) is not None:
                return name
        return None

first = by_substitution(root)
    if first:
        return [f"代入法：{first} から"], tries
    queue = [(root, [])]
    seen = {root}
    while queue and tries < MAX_TRIES:
        problem, path = queue.pop(0)
        new = []
        for name, t in theorems:
            imp = as_implication(t)
            if not imp:
                continue
            a, b = imp
            tries += 1
            s = match(b, problem, {})                      # 切り離し法
            if s is not None and letters(a) <= set(s):
                new.append((subst(a, s), f"切り離し法：{name}"))
            pi = as_implication(problem)
            if pi:
                pa, pc = pi
                tries += 1
                s = match(a, pa, {})                       # 前向きのつなぎ
                if s is not None and letters(b) <= set(s):
                    new.append((("o", ("n", subst(b, s)), pc), f"前向きのつなぎ：{name}"))
                tries += 1
                s = match(b, pc, {})                       # 後ろ向きのつなぎ
                if s is not None and letters(a) <= set(s):
                    new.append((("o", ("n", pa), subst(a, s)), f"後ろ向きのつなぎ：{name}"))
        for sub_problem, how in new:
            if sub_problem in seen:
                continue
            seen.add(sub_problem)
            done = by_substitution(sub_problem)
            if done:
                return path + [how, f"代入法：{done} から"], tries
            queue.append((sub_problem, path + [how]))
    return None, tries

print("公理：", "  ".join(f"{k} {v}" for k, v in AXIOMS.items()))
print("（> は「ならば」、v は「または」、- は「でない」）\n")
proved = []
for i, g in enumerate(GOALS):
    known = list(AXIOMS.items())
    if ONLY_AXIOMS:
        known += [(k, THEOREMS[k]) for k in proved]            # 自分で証明できたものだけ
    else:
        known += [(k, THEOREMS[k]) for k in GOALS[:i]]         # 報告と同じ：前の定理は全部使ってよい
    steps, tries = prove(parse(THEOREMS[g]), known)
    if steps:
        proved.append(g)
        print(f"{g:<5} {THEOREMS[g]:<30} 見つけた（定理を {tries:,} 回 調べた）")
        print("      問題 → " + " → ".join(steps))
    else:
        print(f"{g:<5} {THEOREMS[g]:<30} 見つからない（{tries:,} 回 調べて打ち切り）")
print(f"\n{len(GOALS)} 個のうち {len(proved)} 個の証明を見つけた（1957 年の報告では、52 個のうち 38 個）")

051957·會學習的機器

只在答錯時修正權重

只給機器看例子，就能讓它學會辨識的方法嗎？

1957年，康乃爾航空研究所的心理學家羅森布拉特，在海軍研究局的支持下，開始研究。這是模仿神經細胞連結的人工神經元：把輸入（0或1）乘以權重（重視輸入的程度）再加總，總和大於或等於門檻值時，就輸出1。

學習方法很簡單：只在答錯時，把權重朝正確答案的方向稍微修正。在右邊的圖放上●與○，按「繼續學習」，紫色的線會轉動或平移，錯誤（紫色圓圈）的數量也隨之改變。同在康乃爾的數學家Block證明了：只要存在能分類的直線，用這種修正方法就一定能找到。

類神經網路的歷史，從這裡開始。一條直線分不開的問題在第5章，堆疊多層的內容在第8章介紹。

y＝1（w₁x₁ ＋w₂x₂ ≧ t），其餘情況為0。答錯時w ← w＋η（正確答案 − y）x，t ← t − η（正確答案 − y）

t: 門檻值
η: 修正的幅度（圖中為0.5）
紫色的線: w₁x₁ ＋w₂x₂ 等於t的分界線

每一輪的錯誤數

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_perceptron_line.py

# u03 パーセプトロン：間違えた時だけ、重みを正解の向きに修正する
#
# どの出来事か：1957 年からのローゼンブラットのパーセプトロン（記録 perceptron_1957）。
#   入力に重みを掛けて足し合わせ、しきい値以上なら 1、そうでなければ 0 を出力するニューロンを使う。
#   答えを間違えた時だけ重みを直す学習のしかた（誤り訂正学習）で、例から識別のしかたを学習した。
#   同じコーネル大学の数学者ブロックは、分ける境界（直線や平面）が存在するなら、この修正手順で必ず見つかることを証明した。
# 仕組み：点 (x1, x2) を「●」か「○」に分類する。w1·x1 + w2·x2 がしきい値 t 以上なら「●」。
#   間違えたら：●なのに○と判定した → w に x を足し、t を 1 下げる。逆なら引いて、t を上げる。
#   w1·x1 + w2·x2 = t が「分ける線」。重みを変えると線が回転し、t を変えると線が平行移動する。
#   データ点はこのサイトが作った例（固定した乱数）。
# 試してみよう：
#   - OVERLAP を 1.5 にして 2 つの集まりを重ねると、間違いはいつまでも 0 にならないか
#   - 点を 1 つ、わざと反対のグループに入れると、どうなるか

import random

random.seed(1957)
OVERLAP = 0.0   # 2 つの集まりの重なり具合（0 なら直線 1 本で分離できる）
ROUNDS = 20     # すべてのデータを学習させる回数

def make_points(n=12):
    pts = []
    for _ in range(n):
        pts.append((random.uniform(0, 3), random.uniform(3.3 - OVERLAP, 6), 1))    # ●（左上の集まり）
        pts.append((random.uniform(3.3 - OVERLAP, 6), random.uniform(0, 3), 0))    # ○（右下の集まり）
    random.shuffle(pts)
    return pts

def answer(w1, w2, t, x1, x2):
    return 1 if w1 * x1 + w2 * x2 >= t else 0

points = make_points()
w1, w2, t = 0.0, 0.0, 0.0
for r in range(1, ROUNDS + 1):
    mistakes = 0
    for x1, x2, want in points:
        got = answer(w1, w2, t, x1, x2)
        if got != want:
            mistakes += 1
            d = want - got               # +1 か -1
            w1 += d * x1
            w2 += d * x2
            t -= d
    print(f"{r:2d} 周目：間違い {mistakes:2d} 回 " + "■" * mistakes + f"   線：{w1:+.1f}·x1 {w2:+.1f}·x2 = {t:+.1f}")
    if mistakes == 0:
        print("   間違いが 0 になったので、線が止まった")
        break

print("\n点と線の図（● ○ はデータ点、· はモデルが●と判定する場所、空白は○と判定する場所）")
grid = {(round(x1), round(x2)): ("●" if k else "○") for x1, x2, k in points}
for y in range(6, -1, -1):
    row = ""
    for x in range(0, 7):
        row += grid.get((x, y), "·" if answer(w1, w2, t, x, y) else "　")
    print("  " + row)

061957·預言

「10年之內」的4個預言

1957年的研究者，怎麼展望10年後？

1957年11月14日，在匹茲堡學術會議的晚宴上，賽門發表了與Newell合寫的演講（隔年刊登在雜誌上）。他先總結說，當時的電腦能用類似人的方法，解決沒有固定解法的問題，也能從經驗中學習，接著預言10年之內會發生4件事。

成為西洋棋世界冠軍（〈譯〉）；發現並證明一個重要的新數學定理；寫出得到評論家認可的樂曲；大多數心理學理論採取程式的形式。他接著還說：（譯）。

也有一些成果可作為線索：證明邏輯定理的程式、會下西洋棋基本棋步的電腦，以及會作曲的伊利諾大學ILLIAC。在右邊的圖往後推進年份，就會顯示核對預言的年份（1968年）與此後發生的事。

電腦打敗當時在位的西洋棋世界冠軍是在1997年，距離預言約40年。電腦本身從未獲得世界冠軍的頭銜。

071958·批評與回應

他們自己訂下了核對預言的日期

要讓預言可以被檢驗，需要什麼？

演講刊登在雜誌上後，Bellman寫信批評。根據兩人的回應，批評的內容是預言（譯）。1958年的回應中，兩人寫道：（譯）。

兩人解釋說，附上期限、說得具體，是為了避免成為像諾斯特拉達穆斯那樣無法檢驗的預言。不過，要檢驗，除了什麼事會在何時之前發生，還需要怎樣才算預言成真的判定標準。在右邊的圖，試著移除期限與判定標準。西洋棋的結果很明確，但定理、樂曲與心理學的預言，即使期限到了，評價仍會因人而異。

關於心理學的預言，兩人也在回應中寫道，程式是心理學理論的有力候選這一點，（譯）。

西洋棋的判定標準（在對局中打敗當時在位的世界冠軍），是本站暫時設定的。

以為知道的事常見說法：早期的AI研究者毫無根據地誇口
原始資料中：當時就已有批評，說出預言的研究者解釋，附上期限是為了讓預言可以被檢驗，還親自指定了核對預言的日期（1968年1月1日前後）。

081958·海軍的示範

卡片上的記號，在右邊還是左邊

報紙寫下巨大期待的那天，機器實際做了什麼？

1958年7月，美國海軍在華盛頓向記者展示。當時在氣象局（負責天氣的政府機關）的大型電腦IBM 704上執行感知器的模擬，經過約50次嘗試，就能辨識卡片上的記號在右邊還是左邊。專用機器當時還沒有製作。

隔天《紐約時報》的標題是。報導寫道，海軍期待這個「胚胎」將來有一天（譯）。

右邊的圖是把當天的示範縮小重現的例子（卡片大小與記號是本站設定的）。按「連續50張」，權重圖上就會逐漸形成右半邊投票給右、左半邊投票給左的模式。機器學到的，只是每個格子要投票給哪一邊。它並不懂右和左這些詞。

以為知道的事常見說法：羅森布拉特說過『感知器會走路、會說話、有意識』
原始資料中：報導中寫有這種期待的是。他本人也說它會成為（譯），但在1961年的報告中，他批評報紙的做法像（譯）。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_perceptron_cards.py

# u03 パーセプトロン：カードの印は右か左か（1958 年の実演を小さく再現）
#
# どの出来事か：1958 年 7 月、アメリカ海軍が記者に公開した実演（記録 perceptron_navy_demo_1958）。
#   ふつうのコンピュータ IBM 704 の上で、ローゼンブラットのパーセプトロンが、カードの印が右か左かを
#   50 回ほどの試行で識別できるようになった。
# 仕組み：マス目ごとに「重み」があり、印のあるマスの重みを足して、正なら「右」、負なら「左」と判定する。
#   間違えた時だけ、正解の方向に重みを更新する（パーセプトロンの学習規則）。
# 試してみよう：
#   - TRIALS を 20 にすると、まだ誤りが残るか？
#   - MARK を 1 にすると（印が小さいと）、学習に何枚かかるか？
#   - 最後の「重みの地図」は何を表しているか？（コンピュータは「右と左」という言葉を知らない）

import random

random.seed(1958)
SIZE = 10      # カードの大きさ（10×10 のマス目）
MARK = 3       # 印の大きさ（3×3 のマス目）
TRIALS = 60    # 学習のために見せるカードの枚数

def make_card():
    """印を左半分か右半分のどちらかに置いたカードを 1 枚作る。"""
    side = random.choice(["左", "右"])
    if side == "左":
        x0 = random.randint(0, SIZE // 2 - MARK)
    else:
        x0 = random.randint(SIZE // 2, SIZE - MARK)
    y0 = random.randint(0, SIZE - MARK)
    pixels = [0] * (SIZE * SIZE)
    for y in range(y0, y0 + MARK):
        for x in range(x0, x0 + MARK):
            pixels[y * SIZE + x] = 1
    answer = 1 if side == "右" else -1
    return pixels, answer

weights = [0] * (SIZE * SIZE)   # 重みの初期値はすべて 0
bias = 0

def guess(pixels):
    total = bias + sum(w * p for w, p in zip(weights, pixels))
    return 1 if total > 0 else -1

mistakes = []
for trial in range(1, TRIALS + 1):
    pixels, answer = make_card()
    if guess(pixels) != answer:
        # 間違えた時だけ更新する：印のあるマスの重みを、正解の方向に 1 動かす
        for i, p in enumerate(pixels):
            weights[i] += answer * p
        bias += answer
        mistakes.append(trial)

print("間違えたカードの番号:", mistakes)
for start in range(1, TRIALS + 1, 10):
    n = sum(1 for m in mistakes if start <= m < start + 10)
    print(f"  {start:3d}〜{start + 9:3d} 枚目：誤り {n} 回 " + "■" * n)

# 学習後に、新しいテストデータ 200 枚で試す
correct = 0
for _ in range(200):
    pixels, answer = make_card()
    correct += guess(pixels) == answer
print(f"新しいカード 200 枚でテストすると、正解したのは {correct} 枚")

# 重みの可視化（＋は「右」方向、－は「左」方向、・は 0）
print("重みの地図:")
for y in range(SIZE):
    row = ""
    for x in range(SIZE):
        w = weights[y * SIZE + x]
        row += "＋" if w > 0 else ("－" if w < 0 else "・")
    print("  " + row)

091958·LISP

用層層括號，直接處理式子

要計算的不是數字，而是符號式子本身，該怎麼做？

1958年秋天，麥卡錫與明斯基在MIT啟動了。他們沒有寫計畫書，被問到需要什麼時，回答說要1間房間、2名程式設計師、1名祕書、1台在卡片上打孔的機器。同一個秋天，他們開始製作處理符號序列的程式語言LISP（串列處理）。

在LISP中，像 (TIMES X (PLUS X A) Y) 這樣，用層層括號來寫式子。第一個詞表示要做什麼，其餘表示處理對象。基本操作只有幾個：取開頭的car、取剩餘部分的cdr、接到開頭的cons等。1960年的論文只用這些操作，加上條件分支與呼叫自己的函式，就寫出了式子的微分。

在右邊的圖選擇「X(X+A)Y·論文範例」，取消勾選「簡化1與0（本站新增）」，再按「對X微分（DIFF）」，就會以樹狀圖給出與論文相同的答案。表示1的ONE與表示0的ZERO都原樣保留。LISP家族的語言，此後很長一段時間都是AI研究的主要工具。

d(u·v·w)/dX＝u′·v·w＋u·v′·w＋u·v·w′

′: 對X微分的結果。DIFF用層層括號直接產生這個形式

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_mini_lisp.py

# u03 小さな LISP：かっこの入れ子の式を、式のまま微分する
#
# どの出来事か：1958 年秋から MIT の AI グループが開発したプログラミング言語 LISP（記録 lisp_1958・mit_ai_project_1958）。
#   マッカーシーの 1960 年の論文は、記号式（S 式）を扱う基本操作 car・cdr・cons・atom・eq と、
#   条件分岐、再帰関数だけで、数式の微分を計算する例を示した。
# 仕組み：(TIMES X (PLUS X A) Y) は X(X+A)Y のこと。最初の要素が「何をするか」、残りが「何に」を表す。
#   car はリストの先頭、cdr は先頭を除いた残り、cons は先頭に要素を追加する操作。
#   DIFF（微分）は論文の式をそのまま LISP で書いたもの。MAPLIST は、リストの残りを 1 つずつ関数に渡す。
#   論文と同じく、計算結果の整理は行わない（ONE は 1、ZERO は 0 のこと）。
#   ※ LISP を解釈して実行する部分（eval）は、このサイトが Python で書いた小さな例。
# 試してみよう：
#   - EXPR を (PLUS X (TIMES X X)) に変えてみる（X + X·X の微分）
#   - DIFF に「ZERO をかける項は消す」整理を足すには、どこを変えればよいか

EXPR = "(TIMES X (PLUS X A) Y)"

class Cons:
    def __init__(self, car, cdr):
        self.car, self.cdr = car, cdr

def read(text):
    toks = text.replace("(", " ( ").replace(")", " ) ").split()

def walk(i):
        if toks[i] != "(":
            return (None if toks[i] == "NIL" else toks[i]), i + 1
        items, i = [], i + 1
        while toks[i] != ")":
            x, i = walk(i)
            items.append(x)
        lst = None
        for x in reversed(items):
            lst = Cons(x, lst)
        return lst, i + 1
    return walk(0)[0]

def show(x):
    if x is None:
        return "NIL"
    if isinstance(x, str):
        return x
    parts = []
    while isinstance(x, Cons):
        parts.append(show(x.car))
        x = x.cdr
    return "(" + " ".join(parts) + ")"

BUILTIN = {
    "CAR": lambda x: x.car,
    "CDR": lambda x: x.cdr,
    "CONS": lambda a, b: Cons(a, b),
    "ATOM": lambda x: "T" if not isinstance(x, Cons) else None,
    "EQ": lambda a, b: "T" if (a == b if isinstance(a, str) or a is None else a is b) else None,
    "NULL": lambda x: "T" if x is None else None,
    "NOT": lambda x: "T" if x is None else None,
}
DEFS = {}

def evaluate(e, env):
    if e is None or e == "T":
        return e
    if isinstance(e, str):
        return env[e] if e in env else DEFS.get(e, BUILTIN.get(e))
    head = e.car
    if head == "QUOTE":
        return e.cdr.car
    if head == "COND":
        clause = e.cdr
        while clause is not None:
            if evaluate(clause.car.car, env) is not None:
                return evaluate(clause.car.cdr.car, env)
            clause = clause.cdr
        return None
    if head == "LAMBDA":
        return ("closure", e.cdr.car, e.cdr.cdr.car, env)
    fn = evaluate(head, env)
    args = []
    a = e.cdr
    while a is not None:
        args.append(evaluate(a.car, env))
        a = a.cdr
    if callable(fn):
        return fn(*args)
    _, params, body, fenv = fn
    new = dict(fenv)
    p = params
    for v in args:
        new[p.car] = v
        p = p.cdr
    return evaluate(body, new)

def define(name, text):
    DEFS[name] = evaluate(read(text), {})

define("MAPLIST", "(LAMBDA (X F) (COND ((NULL X) NIL) (T (CONS (F X) (MAPLIST (CDR X) F)))))")
define("DIFF", """(LAMBDA (Y X) (COND
  ((ATOM Y) (COND ((EQ Y X) (QUOTE ONE)) (T (QUOTE ZERO))))
  ((EQ (CAR Y) (QUOTE PLUS)) (CONS (QUOTE PLUS) (MAPLIST (CDR Y) (LAMBDA (Z) (DIFF (CAR Z) X)))))
  ((EQ (CAR Y) (QUOTE TIMES)) (CONS (QUOTE PLUS) (MAPLIST (CDR Y) (LAMBDA (Z)
      (CONS (QUOTE TIMES) (MAPLIST (CDR Y) (LAMBDA (W)
          (COND ((NOT (EQ Z W)) (CAR W)) (T (DIFF (CAR W) X)))))))))))))""")

e = read(EXPR)
print("式           ", show(e))
print("car（先頭）  ", show(evaluate(read("(CAR (QUOTE " + EXPR + "))"), {})))
print("cdr（残り）  ", show(evaluate(read("(CDR (QUOTE " + EXPR + "))"), {})))
print("cons で A を前に", show(evaluate(read("(CONS (QUOTE A) (QUOTE " + EXPR + "))"), {})))
print()
d = evaluate(read("(DIFF (QUOTE " + EXPR + ") (QUOTE X))"), {})
print("X で微分すると")
print("  ", show(d))
print("（1960 年の論文の答えと同じ形：積の微分は、1 つずつ微分した項を足し合わせる）")

101958·常識

推導出去機場前要先做的行動

只要把事實寫成句子，機器就能由此推導出行動嗎？

1958年11月，英國國家物理實驗室舉辦了國際會議。麥卡錫在會上發表了。這個構想是把事實與建議寫成邏輯式，從中推論，得出「要做……」的結論後就執行（Advice Taker）。

論文的例子，是我在家裡的書桌旁，要去機場的問題。從at(I, desk)（我在書桌旁）、at(car, home)（車在家裡）、walkable(home)（家裡可以步行）、drivable(county)（郡內可以開車）等17個前提，依序推導出8個結論，最後得出do(go(desk, car, walking))，也就是先走到車旁。

在右邊的圖按「推導下一步」試試。只要移除1個前提，就找不到計畫了。

論文寫道，如何收集17個前提、如何推導，仍無法完全回答。圖中的推導順序，是按照論文結論的排列設定的。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_advice_taker.py

# u03 アドバイス・テイカー：「空港へ行きたい」から、最初にすることを導く
#
# どの出来事か：1958 年 11 月、イギリスの会議でマッカーシーが出した「常識を持つプログラム」の提案
#   （記録 mtp_symposium_1958・lisp_1958）。事実や助言を文の形で書いておき、そこから結論を導いて、
#   「〜せよ」という結論が出たらそれを実行する。論文の例は「机の前にいる私が、空港へ行く」。
# 仕組み：前提（論文の 17 個のうち、この例に使うもの）を、そのまま Python のデータにした。
#   at(x, y)＝x は y にある。walkable(家)＝家の中は歩ける。drivable(郡)＝郡の中は車で行ける。
#   1. 歩く・車の規則から「この状況なら、この行き方ができる」を作る。
#   2. 「行ったら、そこにいる」と組み合わせて、canachult（その状況で、その行動をすれば、次の状況になる）を作る。
#   3. 2 つの canachult をつないで机から空港までの計画を作り、want（望み）と一致したら、最初の行動を do にする。
#   ※ 論文は、前提の集め方や導き方について、この論文では完全には答えられないと書いている。
#     ここの導き方（順番や候補の作り方）は、このサイトが決めたもの。
# 試してみよう：
#   - FACTS から ("at", "car", "home") を消すと（車が家にないと）、計画は見つかるか
#   - ("drivable", "county") を消すとどうなるか

FACTS = [
    ("at", "I", "desk"), ("at", "desk", "home"), ("at", "car", "home"),
    ("at", "home", "county"), ("at", "airport", "county"),
    ("walkable", "home"), ("drivable", "county"),
]
WANT = ("at", "I", "airport")

# (6) at の推移：at(x,y), at(y,z) → at(x,z)。私（I）は動くので、物の場所だけでつなぐ
at = {(f[1], f[2]) for f in FACTS if f[0] == "at" and f[1] != "I"}
changed = True
while changed:
    changed = False
    for (x, y) in list(at):
        for (y2, z) in list(at):
            if y == y2 and (x, z) not in at:
                at.add((x, z))
                changed = True
places = {p for pair in at for p in pair}
now = next(f[2] for f in FACTS if f[:2] == ("at", "I"))

can = []   # (状況, 行動)
for f in FACTS:
    if f[0] == "walkable":                      # (9)
        x = f[1]
        for y in sorted(places):
            for z in sorted(places):
                if y != z and (y, x) in at and (z, x) in at:
                    can.append((("at", "I", y), ("go", y, z, "walking")))
    if f[0] == "drivable":                      # (10)
        x = f[1]
        for y in sorted(places):
            for z in sorted(places):
                if y != z and (y, x) in at and (z, x) in at and ("car", y) in at:
                    can.append((("at", "I", "car"), ("go", y, z, "driving")))

def after(action):                              # (13) did(go(x,y,z)) → at(I, y)
    return ("at", "I", action[2])

chult = [(s, a, after(a)) for s, a in can]      # (15)

def fmt(t):
    return t[0] + "(" + ", ".join(fmt(x) if isinstance(x, tuple) else x for x in t[1:]) + ")"

plan = None
for s1, a1, r1 in chult:                        # (16) 2 つをつなぐ
    for s2, a2, r2 in chult:
        if r1 == s2 and s1 == ("at", "I", now) and r2 == WANT:
            plan = (s1, a1, r1, a2, r2)
            break
    if plan:
        break

print("前提：", "  ".join(fmt(f) for f in FACTS), "  want(" + fmt(WANT) + ")")
print(f"（at を推移でつなぐと {len(at)} 個。行き方の候補 {len(can)} 個を作った）\n")
if plan:
    s1, a1, r1, a2, r2 = plan
    steps = [
        f"{fmt(s1)} → can({fmt(a1)})",
        f"{fmt(r1)} → can({fmt(a2)})",
        f"did({fmt(a1)}) → {fmt(r1)}",
        f"did({fmt(a2)}) → {fmt(r2)}",
        f"canachult({fmt(s1)}, {fmt(a1)}, {fmt(r1)})",
        f"canachult({fmt(r1)}, {fmt(a2)}, {fmt(r2)})",
        f"canachult({fmt(s1)}, prog({fmt(a1)}, {fmt(a2)}), {fmt(r2)})",
        f"do({fmt(a1)})",
    ]
    for i, s in enumerate(steps, 1):
        print(f"{i}. {s}")
    print("\n→ 最初にすることは、机から車まで歩くこと（論文の 8 つの結論と同じ順）")
else:
    print("机から空港までの計画が見つからない。どの前提が足りないか考えてみよう")

111958·模式辨識

用惡魔們的喊聲辨識文字

辨識文字的機制，能拆成許多小零件嗎？

在同一場會議上，Selfridge發表了名為（意思是所有惡魔聚集的地方）的機制。最底層的資料惡魔，各自尋找文字的一部分（橫線、縱線、圓弧等），並按照找到的把握程度大聲喊叫。上層的辨識惡魔，收集符合自己文字的喊聲，再喊出來；最上層的決策惡魔，則把喊聲最大的文字當作答案。

他也提出了學習方法：從外部一點點改變惡魔們的擴音器音量，選出成績提升最多的調整，持續重複（爬山法）。在右邊的圖按「繼續調整」，正確率就會從音量為0的狀態開始上升。

找出特徵、乘以權重再組合的結構，與感知器及後來的類神經網路是同一種機制。

辨識惡魔k的聲音＝Σ_i 音量_k,i × 資料惡魔i的聲音

音量_k,i: 惡魔k聽惡魔i聲音時的權重（學習的部分）
答案: 聲音最大的k

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_pandemonium.py

# u03 パンデモニウム：小さな悪魔たちの叫び声で、文字を識別する
#
# どの出来事か：1958年11月、イギリスの会議でセルフリッジが発表した「パンデモニウム」（記録 mtp_symposium_1958）。
#   最下層の「データの悪魔」は、文字の特徴（横棒・縦棒など）を探し、見つかった確かさに応じた大きさの声で叫ぶ。
#   中間の「認識の悪魔」は、自分の文字に合う叫び声の組み合わせを聞いて叫び、最上部の「決める悪魔」が、
#   いちばん大きな声の文字を答えにする。メガホンの音量は外部から少しずつ調整し、
#   成績が最も上がる変更を選ぶ（山登り法）。※説明は Nilsson（2010）による。
#   ここでは成績の点に「全部の声のうち、正しい字の声がしめる割合」を使う（このサイトの決め方）。
# 仕組み：5×5の文字（このサイトが作った例の A・E・L・O・T）に、ノイズ（マスの白黒反転）を加えて見せる。
#   データの悪魔 8 匹（7 匹が文字の部分を探し、1 匹はいつも同じ大きさの声）→ 認識の悪魔 5 匹（文字ごと）→ 決める悪魔。
#   音量の初期値はすべて 0。
# 試してみよう：
#   - NOISE を 0.2 にすると、学習後の成績はどれだけ下がるか
#   - データの悪魔を 1 匹（たとえば「まん中の縦棒」）消すと、どの文字を間違えやすくなるか

import math
import random

random.seed(1958)
NOISE = 0.08      # 1マスの白黒が反転する割合
ROUNDS = 60       # 音量を調整する最大反復回数
STEP = 1.0        # 1回の調整で音量を変更する幅

LETTERS = {
    "A": [".###.", "#...#", "#####", "#...#", "#...#"],
    "E": ["#####", "#....", "####.", "#....", "#####"],
    "L": ["#....", "#....", "#....", "#....", "#####"],
    "O": [".###.", "#...#", "#...#", "#...#", ".###."],
    "T": ["#####", "..#..", "..#..", "..#..", "..#.."],
}
DEMONS = ["上の横棒", "まん中の横棒", "下の横棒", "左の縦棒", "右の縦棒", "まん中の縦棒", "白い角", "いつも"]

def shouts(img):
    """データの悪魔たちの声の大きさ（0〜1）。img は 5×5 の 0/1 配列。"""
    row = lambda r: sum(img[r]) / 5
    col = lambda c: sum(img[r][c] for r in range(5)) / 5
    return [row(0), row(2), row(4), col(0), col(4),
            sum(img[r][2] for r in range(1, 5)) / 4,
            sum(1 - img[r][c] for r, c in ((0, 0), (0, 4), (4, 0), (4, 4))) / 4,
            1.0]   # 「いつも」＝常に一定の声で叫ぶ悪魔（文字ごとの基準値）

def noisy(letter):
    return [[(1 if ch == "#" else 0) ^ (random.random() < NOISE) for ch in rowtxt] for rowtxt in LETTERS[letter]]

def decide(vol, s):
    loud = {k: sum(v * x for v, x in zip(vol[k], s)) for k in LETTERS}
    return max(loud, key=loud.get), loud

def score(vol, data):
    return sum(decide(vol, s)[0] == k for k, s in data) / len(data)

def grade(vol, data):
    """成績の点：すべての声のうち、正しい文字の悪魔の声が占める割合（対数）の平均。0 に近いほどよい。"""
    total = 0
    for k, s in data:
        _, loud = decide(vol, s)
        top = max(loud.values())
        total += (loud[k] - top) - math.log(sum(math.exp(v - top) for v in loud.values()))
    return total / len(data)

train = [(k, shouts(noisy(k))) for k in LETTERS for _ in range(8)]
test = [(k, shouts(noisy(k))) for k in LETTERS for _ in range(40)]
vol = {k: [0.0 for _ in DEMONS] for k in LETTERS}   # 音量の初期値はすべて 0（どの悪魔の声も聞かない）

print(f"初め：訓練データで {score(vol, train):.0%}、テストデータで {score(vol, test):.0%}")
for r in range(1, ROUNDS + 1):
    best, best_s = None, grade(vol, train)
    for k in LETTERS:                       # 各音量を少し増減させてすべて試す
        for i in range(len(DEMONS)):
            for d in (STEP, -STEP):
                vol[k][i] += d
                s = grade(vol, train)
                vol[k][i] -= d
                if s > best_s:
                    best, best_s = (k, i, d), s
    if best is None:
        print(f"{r:2d} 回目：どの変更でもスコアが上がらないため終了（山の頂上に到達）")
        break
    k, i, d = best
    vol[k][i] += d
    if r <= 3 or r % 15 == 0:
        print(f"{r:2d} 回目：「{k}」の悪魔が「{DEMONS[i]}」を聞く音量を{'上げ' if d > 0 else '下げ'}る → 点 {best_s:.2f}、訓練データで {score(vol, train):.0%} 正解")

print(f"\n学習後：テストデータ（{len(test)} 個）を {score(vol, test):.0%} 正しく識別")
k, s = test[3]
ans, loud = decide(vol, s)
print(f"\n例：本当は「{k}」の文字 → データの悪魔の声 " + " ".join(f"{d}{x:.1f}" for d, x in zip(DEMONS, s)))
print("   認識の悪魔の声 " + "  ".join(f"{c}:{v:+.1f}" for c, v in loud.items()) + f" → 決める悪魔の答え「{ans}」")

121959·GPS

選擇能縮小與目標的一步

能設計出適用於任何問題的解法嗎？

Newell、Shaw、賽門在邏輯理論家的基礎上製作了，以1959年6月巴黎會議的預刊論文形式發表報告（報告日期是1958年12月30日）。之所以叫作「通用」，是因為他們把問題的內容（邏輯、代數、三角公式等）與解法分開設計。

解法的核心是手段—目的分析。比較目前狀態與目標，找出差異，選擇能減少這個差異的一步。如果使用這一步的條件還沒滿足，就把滿足條件當作新的小目標。這樣在目標中產生目標，同樣的步驟便能層層重複使用。

右邊圖中的第一個問題，是本站設計的製作奶油吐司問題。只要替換哪一步能減少哪種差異的那張表，同樣的解法就能用在其他問題上。

報告的目的之一，是讓程式的行為接近大學生一邊出聲思考、一邊解邏輯題的紀錄。報告中給出的例子是符號邏輯、初等代數與三角公式。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_gps_means_ends.py

# u03 GPS の「目的と手段の分析」：現在と目標の「ちがい」を見つけ、それを小さくする操作を選ぶ
#
# どの出来事か：1958 年 12 月 30 日付の報告、ニューウェル、ショー、サイモンの GPS（一般問題解決器。記録 gps_1959）。
#   ロジック・セオリストから生まれ、「問題の中身」（論理・代数・三角の公式 など）と「解き方」を分けて作った。
#   解き方の中心が「目的と手段の分析」：現在の状態と目標を比較して違いを見つけ、違いを減らす操作を選ぶ。
#   操作が使えない時は、「その手を使える形にする」ことを新しい小さな目標にする（目標の中に目標ができる）。
# 仕組み：問題の内容は、このサイトが作った例「朝ごはんのバタートーストを作る」。
#   操作ごとに「使う条件」「できること」を書いた表（問題の中身）と、解き方（transform・apply）を分けてある。
#   表を取りかえれば、同じ解き方がほかの問題にも使える。これが GPS の「一般」の意味。
# 試してみよう：
#   - START に "冷蔵庫が開いている" を足すと、操作の数はどう変わるか
#   - OPERATORS を別の問題（たとえば、学校へ行く）に書きかえて、同じ transform で解いてみる

OPERATORS = [   # (操作の名前, 使う条件, できること, なくなること)
    ("冷蔵庫を開ける", [], ["冷蔵庫が開いている"], []),
    ("バターを出す", ["冷蔵庫が開いている"], ["バターが出ている"], []),
    ("パンの袋を開ける", [], ["袋が開いている"], []),
    ("パンを出す", ["袋が開いている"], ["パンを持っている"], []),
    ("パンをトースターに入れる", ["パンを持っている"], ["パンがトースターの中"], ["パンを持っている"]),
    ("パンを焼く", ["パンがトースターの中"], ["パンが焼けている"], []),
    ("バターをぬる", ["パンが焼けている", "バターが出ている"], ["バタートーストができた"], []),
]
START = []
GOAL = ["バタートーストができた"]
steps = []

def transform(state, goal, depth=0):
    """現在の state を、goal を満たす状態にする（GPS の目標の型 1）。"""
    pad = "  " * depth
    for want in goal:
        if want in state:
            continue
        print(f"{pad}ちがい：「{want}」がまだ無い")
        op = next((o for o in OPERATORS if want in o[2]), None)   # 違いを減らす操作を表から探す
        if op is None:
            print(f"{pad}  → 減らす操作が無い。あきらめる")
            return None
        print(f"{pad}  → 減らす操作：「{op[0]}」")
        state = apply(state, op, depth + 1)
        if state is None:
            return None
    return state

def apply(state, op, depth):
    """操作 op を適用する（GPS の目標の型 2）。条件が足りなければ、まずそれを目標にする。"""
    name, need, add, remove = op
    missing = [c for c in need if c not in state]
    if missing:
        print("  " * depth + f"「{name}」を使う条件が足りない → 小さな目標：" + "、".join(missing))
        state = transform(state, missing, depth + 1)
        if state is None:
            return None
    steps.append(name)
    print("  " * depth + f"★ 操作 {len(steps)}：{name}")
    return [s for s in state if s not in remove] + [a for a in add if a not in state]

print("目標：", "、".join(GOAL), "\n")
final = transform(list(START), GOAL)
print("\nできあがり：" if final else "\n解けなかった", "→".join(steps))
print(f"使った操作の数 {len(steps)}")

131959·日本

我喜歡音樂

當時的日本，製作了怎樣的「會思考的機器」？

1958年夏天前後，電氣試驗所開始了把英語翻譯成日語的專用電腦「Yamato」的計畫。當時手邊沒有配備能存放字典的大容量記憶裝置的電腦，於是用電晶體電腦ETL Mark IV的電路製作專用機。預算是600萬日圓，記憶裝置是82萬位元的磁鼓。1959年2月，放入以打孔方式記錄I like music的紙帶，它就印出了（ワレガオンガクヲコノム）。

為了避開日語輸入（漢字與詞語切分）的困難，他們選擇從英語翻譯成日語。即便如此，仍需要把動詞移到句末、移動介系詞、補上日語助詞（ガ、ヲ等）。代名詞方面，把I譯成「我」（ワレ），you譯成「你」（ナレ），he譯成「他」（カレ）。在右邊的圖，一步一步走完翻譯流程吧。

指示執行計畫的和田弘回憶說，直到開始印出第一句譯文的13秒，讓他覺得非常漫長。成果於1959年6月，在巴黎的第1屆國際資訊處理會議上發表。

圖中的字典與規則，除了代名詞的譯法之外，都是本站製作的例子。Yamato如何翻譯在巴黎展示的 I have some eggs in my hand.，資料裡沒有記載。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_yamato_translate.py

# u03 「やまと」のように訳す：英文を、辞書と並べ替えの規則でカタカナの日本語に
#
# どの出来事か：1959年、電気試験所の英日翻訳専用機「やまと」（記録 etl_yamato_mt_1959）。
#   最初に訳した「I like music.」は「ワレガ オンガクヲ コノム」。訳を打ち始めるまで13秒かかった。
#   和田弘の回想によると、英文和訳には動詞を文末に置くこと、前置詞を動かすこと、
#   格助詞（ガ・ヲなど）を補うことなどが必要だった。代名詞 I, you, he, she, it, this, that, who は
#   ワレ、ナレ、カレ、サレ、ソレ、コレ、アレ、タレにした（本人は「ヤマトコトバ」と呼んだ）。
# 仕組み：1語ずつ辞書を引く → 主語・動詞・目的語・前置詞のまとまりに分ける → 日本語の順に並べ替える →
#   助詞を補ってカタカナで出力する。辞書と規則は、代名詞を除き、このサイトが作った小さな例。
#   2番目の文は1959年6月のパリの会議で示された文。やまとの実際の訳は資料にないため、ここの訳はこのサイトの規則による。
# 試してみよう：
#   - SENTENCES に "She likes the moon." を足す（辞書に moon を足す必要がある）
#   - 「I like music very much.」のような文は、この規則でどうなるか

PRONOUN = {"i": "ワレ", "you": "ナレ", "he": "カレ", "she": "サレ", "it": "ソレ", "this": "コレ", "that": "アレ", "who": "タレ"}
POSSESSIVE = {"my": "ワレノ", "your": "ナレノ", "his": "カレノ", "her": "サレノ"}
NOUN = {"music": "オンガク", "egg": "タマゴ", "hand": "テ", "book": "ホン", "moon": "ツキ"}
VERB = {"like": "コノム", "have": "モツ", "read": "ヨム", "see": "ミル"}
PREP = {"in": "ニ", "on": "ノウエニ", "with": "ト"}
DET = {"some": "イクツカノ", "the": "", "a": ""}
SENTENCES = ["I like music.", "I have some eggs in my hand.", "He likes music.", "You read a book."]

def base(word):
    """名詞・動詞の語尾（-s）を取り除き、辞書の形に戻す。"""
    if word in NOUN or word in VERB:
        return word
    if word.endswith("s") and (word[:-1] in NOUN or word[:-1] in VERB):
        return word[:-1]
    return word

def translate(sentence, show=True):
    words = [base(w) for w in sentence.lower().rstrip(".").split()]
    if show:
        print("1. 単語に分けて、語尾を取り除く：", words)
    subj, verb = words[0], words[1]
    rest = words[2:]
    obj, phrases, cur = [], [], None
    for w in rest:                                   # 目的語と、前置詞のまとまりに分ける
        if w in PREP:
            cur = [w]
            phrases.append(cur)
        elif cur is not None:
            cur.append(w)
        else:
            obj.append(w)
    if show:
        print(f"2. 文の役割を決める：主語 {subj} ／ 動詞 {verb} ／ 目的語 {obj} ／ 前置詞のまとまり {phrases}")

def noun_phrase(ws):
        parts = [DET.get(w, "") + POSSESSIVE.get(w, "") + NOUN.get(w, "") + PRONOUN.get(w, "") for w in ws]
        return " ".join(p for p in parts if p)
    jp = [PRONOUN.get(subj, NOUN.get(subj, subj)) + "ガ"]            # 主語＋ガ
    for p in phrases:                                                # 前置詞は名詞の後ろへ
        jp.append(noun_phrase(p[1:]) + PREP[p[0]])
    if obj:
        jp.append(noun_phrase(obj) + "ヲ")                            # 目的語＋ヲ
    jp.append(VERB.get(verb, verb))                                  # 動詞は文末へ
    if show:
        print("3. 日本語の語順に並べて、助詞を補う：", jp)
    return " ".join(jp)

for s in SENTENCES:
    print(f"【{s}】")
    print("   → " + translate(s) + "\n")
print("（やまとは、最初の訳を打ち始めるまで 13 秒かかった。この Python は 1 秒もかからない）")

141959·機器學習

自己修正評分方式

程式能變得比寫出它的人更強嗎？

IBM的Samuel持續研究讓電腦從經驗中學習下西洋跳棋（在8×8棋盤上，跳過棋子互相吃子的遊戲）。能學習的版本在1956年2月24日於電視上示範。1959年論文的摘要寫道，經過8〜10小時的對局，程式能下得比寫出它的人更好。

棋局的分數，是把棋子數量差、可走的步數、是否占據中央等特徵，乘以權重後加總。程式往前看幾步，假設自己選分數大的、對手選分數小的，把分數向上傳遞（極小極大法）。學習方法之一，是修正權重，讓往前看之前的分數，接近看過後傳上來的分數。在右邊的圖按「學習」試試。

不把解法全部寫出來，而是讓它從例子或經驗中學習，這就是機器學習。

w ← w＋η（傳上來的分數 − 往前看之前的分數）× 特徵

w: 權重
η: 修正的幅度
分數: 特徵 × 權重的總和（圖中的數值是本站製作的例子）

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_samuel_weights.py

# u03 サミュエルの学習法：先を読んだ評価値に近づくように、重みを自分で直す
#
# どの出来事か：1959年、IBMのサミュエルの論文「チェッカーのゲームを使った、機械が学ぶことの研究」（記録 samuel_checkers_1959）。
#   盤面から駒の数の差・動ける手の多さ・中央の支配など「特徴」の数値を集め、重みをかけて足し合わせて局面の評価値にした。
#   数手先まで読み、自分は最大、相手は最小を選ぶミニマックス法で手を決めた。
#   学習方法の 1 つは、先読み前の評価値が先読み後の評価値に近づくように重みを直すこと（説明は Nilsson 2010 による）。
# 仕組み：チェッカーは大きいので、三目並べで同じ仕組みを動かす（ゲームと特徴はこのサイトが作った例）。
#   特徴：自分があと1つでそろう列・相手があと1つでそろう列・自分だけが置いている列・中央・角。
#   自己対戦しながら、1手ごとに「読む前の点数」を「2 手先まで読んだ点数」に少し近づける。
# 試してみよう：
#   - GAMES を 0 にして学習させないと、ランダムに打つ相手への成績はどうなるか
#   - RATE を大きくすると、重みはどう変化するか

import random

random.seed(1959)
GAMES = 300       # 学習用の自己対戦の回数
RATE = 0.01       # 1回に重みを更新する大きさ（学習率）
LINES = [(0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7), (2, 5, 8), (0, 4, 8), (2, 4, 6)]
NAMES = ["あと 1 つでそろう（自分）", "あと 1 つでそろう（相手）", "自分だけの列", "まん中", "角"]
w = [0.0] * len(NAMES)      # 重みの初期値（最初はどの特徴も重視しない）

def winner(b):
    for i, j, k in LINES:
        if b[i] != "." and b[i] == b[j] == b[k]:
            return b[i]
    return None

def features(b, me):
    you = "O" if me == "X" else "X"
    f = [0, 0, 0, 0, 0]
    for line in LINES:
        cells = [b[i] for i in line]
        if cells.count(me) == 2 and cells.count(".") == 1:
            f[0] += 1
        if cells.count(you) == 2 and cells.count(".") == 1:
            f[1] += 1
        if cells.count(me) == 1 and cells.count(".") == 2:
            f[2] += 1
    f[3] = (b[4] == me) - (b[4] == you)
    f[4] = sum((b[i] == me) - (b[i] == you) for i in (0, 2, 6, 8))
    return f

def static(b, me):
    """先読み前の評価値：特徴 × 重み の合計。勝敗が決まっていれば ±10。"""
    win = winner(b)
    if win:
        return 10 if win == me else -10
    if "." not in b:
        return 0
    return sum(wi * fi for wi, fi in zip(w, features(b, me)))

def moves(b):
    return [i for i, c in enumerate(b) if c == "."]

def search(b, me, turn, depth):
    """ミニマックス法：自分の番は最大、相手の番は最小を選んで、評価値を上の局面へ運ぶ。"""
    if depth == 0 or winner(b) or "." not in b:
        return static(b, me), None
    best = None
    for m in moves(b):
        nb = b[:m] + turn + b[m + 1:]
        v, _ = search(nb, me, "O" if turn == "X" else "X", depth - 1)
        if best is None or (v > best[0] if turn == me else v < best[0]):
            best = (v, m)
    return best

def play(first, second, learn=False):
    b, turn = "." * 9, "X"
    players = {"X": first, "O": second}
    while not winner(b) and "." in b:
        if players[turn] == "random":
            m = random.choice(moves(b))
        else:
            v, m = search(b, turn, turn, 2)
            if learn:                            # 先読み前の評価値を、先読み後の評価値に近づける
                f, s = features(b, turn), static(b, turn)
                for i in range(len(w)):
                    w[i] += RATE * (v - s) * f[i]
        b = b[:m] + turn + b[m + 1:]
        turn = "O" if turn == "X" else "X"
    return winner(b)

def test(n=200):
    r = {"勝ち": 0, "引き分け": 0, "負け": 0}
    for g in range(n):
        me = "X" if g % 2 == 0 else "O"
        res = play("ai", "random") if me == "X" else play("random", "ai")
        r["勝ち" if res == me else "負け" if res else "引き分け"] += 1
    return r

random.seed(1)
print("学習前：ランダムに打つ相手と 200 回対戦 →", test())
random.seed(1959)
for g in range(GAMES):
    play("ai", "ai", learn=True)
print("重み：", "  ".join(f"{n} {x:+.2f}" for n, x in zip(NAMES, w)))
random.seed(1)
print(f"自己対戦を {GAMES} 回行って学習した後 →", test())

151960·Mark I

隨機接線與馬達轉動的旋鈕

把會學習的機器做成實體機器，而非程式，會怎樣？

1960年6月23日，感知器的專用機器Mark I首次公開。權重用馬達轉動的（電位器）來調整，接線則透過大型插接板連接。根據1961年的報告，它配備了512個A細胞與8個輸出答案的R細胞。組裝由Wightman與Martin負責，實驗由Hay負責。

結構分3層。從視網膜（S）的點到A細胞，只是隨機選點連接，這部分不學習。學習的只有A細胞到R細胞的權重。右邊的圖仿照同一份報告的實驗1，在上下、左右首尾相連成環的視網膜上，辨識橫棒與豎棒。

如果不經過A細胞，直接連接視網膜，不管學習多少輪，錯誤都不會消失。因為無論權重設成多少，所有橫棒的平均分數與所有豎棒的平均分數都相同。中間加入80個隨機的A細胞後，其中就會有能捕捉點的組合的細胞，幾輪之內錯誤就降到0。

報告還記錄了一項實驗：即使擔任教師的人故意有30%教錯，機器仍能100%辨識E與X（這與修正錯誤的學習法是不同的方法）。Mark I目前保存在史密森學會。

每一輪（16條）的錯誤數

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_mark1_alpha.py

# u03 Mark I の構造：ランダムな配線（A 細胞）と、学習するつまみ（重み）
#
# どの出来事か：1960 年に公開されたローゼンブラットのパーセプトロン Mark I（記録 perceptron_1957）。
#   ローゼンブラットの 1961 年の報告によると、Mark I は A 細胞 512 個・出力の R 細胞 8 個をもち、
#   重みはモーターで回すつまみ（ポテンショメーター）、配線は大きな差し替え盤だった。
#   網膜（S）→ A 細胞 → R 細胞 と並ぶ構造で、網膜から A 細胞への配線はランダムに選んだ点につなぐだけで学習しない。
#   学習するのは A 細胞から R 細胞への重みだけで、間違えた時だけ修正する（誤り訂正学習）。
# 仕組み：同じ報告の実験 1 にならって、横の棒と縦の棒を識別させる（網膜はここでは 8×8 の小さなもの。
#   上と下、左と右がつながった「輪」になっていて、棒はどの位置にも置ける）。
#   A 細胞が 0 個（網膜を R 細胞に直接つなぐ）だと、何回学習しても誤りが残る。
#   横の棒も縦の棒も光る点の数は同じで、どの重みでも「全部の横の棒の点数の平均」と「全部の縦の棒の点数の平均」が
#   同じになってしまうからだ。ランダムな A 細胞を挟むと、識別できるようになる。
# 試してみよう：
#   - LINKS（A 細胞 1 個が見る点の数）を 1 にすると、どうなるか
#   - A 細胞の数を 512（Mark I と同じ）にしてみる

import random

random.seed(1960)
N = 8          # 網膜は 8×8
WIDTH = 2      # 棒の太さ
LINKS = 4      # A 細胞 1 個が見る網膜の点の数
SWEEPS = 60    # 全部の棒を見せる回数（いちばん多くて）

def bars():
    out = []
    for p in range(N):
        h = [[1 if (r - p) % N < WIDTH else 0 for c in range(N)] for r in range(N)]
        v = [[1 if (c - p) % N < WIDTH else 0 for c in range(N)] for r in range(N)]
        out += [(h, 1), (v, -1)]          # 横の棒＝+1、縦の棒＝-1
    return out

def make_a_units(n):
    units = []
    for _ in range(n):
        pts = [(random.randrange(N), random.randrange(N), random.choice((1, -1))) for _ in range(LINKS)]
        units.append(pts)                 # ランダムな点と、+（光ると上げる）か -（光ると下げる）。＋－の決め方はこのサイトが決めたもの
    return units

def a_layer(img, units):
    if not units:                          # A 細胞なし：網膜の点をそのまま使う
        return [x for row in img for x in row]
    return [1 if sum(s * img[r][c] for r, c, s in u) >= 1 else 0 for u in units]

def train(n_units):
    units = make_a_units(n_units)
    data = [(a_layer(img, units), t) for img, t in bars()]
    w = [0] * len(data[0][0])
    b = 0
    for sweep in range(1, SWEEPS + 1):
        mistakes = 0
        for x, t in data:
            y = 1 if sum(wi * xi for wi, xi in zip(w, x)) + b > 0 else -1
            if y != t:                     # 間違えた時だけ、つまみ（重み）を回す
                mistakes += 1
                w = [wi + t * xi for wi, xi in zip(w, x)]
                b += t
        if mistakes == 0:
            return sweep, 0
    return SWEEPS, mistakes

print(f"横の棒 {N} 本と縦の棒 {N} 本（8×8 の輪の網膜）を識別する\n")
for n in (0, 5, 20, 80, 320):
    sweeps, left = train(n)
    name = "A 細胞なし（網膜を直接つなぐ）" if n == 0 else f"ランダムな A 細胞 {n} 個"
    if left == 0:
        print(f"  {name:<22} → {sweeps} 回目で、誤りが 0 になった")
    else:
        print(f"  {name:<22} → {sweeps} 回学習しても、誤りが {left} 個残る " + "■" * left)

161960·人與電腦

一台電腦，大家分著用

在讓機器負責所有思考之前，人與電腦該怎麼合作？

1960年3月，Licklider發表了論文。如同無花果樹與傳播花粉的昆蟲互相幫助，他構想了一種合作方式：由人決定目標、提出假設、訂定標準並評估，電腦負責固定流程的工作。他曾在1957年春夏記錄自己的工作，結果發現，思考時間約有85%用於思考前的準備（尋找、計算、畫圖表等）。

為此需要的技術之一，是分時系統（把一台電腦的時間切成小段，分給許多人使用的機制）。他認為，當時的大型電腦若只跟一個人一起思考，速度太快、費用也太高，因此應該讓許多人分享使用時間。在右邊的圖與排隊等候比較看看。即使電腦處理時間的總和相同，收到第一次回應前的等待時間也會短很多。

以為知道的事常見說法：Licklider預言到1980年機器就會思考
原始資料中：論文中的是在介紹空軍研究會的估計。對於人與電腦合作的時代會持續多久，他本人則保留了很大的範圍：（譯）。

171976·核對預言

四色問題：人的推理與電腦的大量計算

什麼時候，才能說電腦證明了定理？

對於（譯）這個預言，在這10年之內，找不到足以這樣說的事件紀錄。1976年，Appel與Haken證明了（任何地圖都能用4種顏色上色、讓相鄰區域顏色不同的問題，起源於1852年前後）。然而，證明的思路與形狀分類的步驟是人設計的，電腦負責逐一檢查將近2000種形狀。

右邊的圖，是讓電腦替本站製作的範例地圖著色。一個國家接著一個國家上色，沒有可用顏色時就退回前一步（回溯）。A、B、C、D彼此全都相鄰，因此不管怎麼試，3種顏色都不夠。替一張地圖著色的搜尋計算，與證明對所有地圖都成立的定理，是兩回事。

1996年10月，證明搜尋程式EQP花了約8天，自動找到自1930年代起一直未解的的證明。這兩件事中，問題本身都是人早已提出的。

以為知道的事常見說法：1976年電腦證明了四色定理
原始資料中：發表的本文寫的是，分類步驟由人手動設計，電腦負責逐一檢查許多形狀。

這是用Python寫的程式碼，原理和「動手試試」裡的一樣。按下▶ 執行，結果會顯示在下方。改改數字，再執行一次試試。

u03_four_colors.py

# u03 4色で塗り分ける：隣同士が同じ色にならないように、試しては戻る
#
# どの出来事か：1957 年の予言「10 年以内に、計算機が大事な新しい数学の定理を見つけて証明する」の、その後
#   （記録 simon_newell_theorem_1958）。1976年、アペルとハーケンは四色定理（どんな地図も4色で塗り分けられる）を
#   証明した。証明の筋道と形の分類手順は人間が作り、コンピュータは2000近くの形を1つずつ調べる役だった。
# 仕組み：このサイトが作った例の地図（国A〜J）を、隣同士が同じ色にならないように塗る。
#   国を1つずつ順に塗り、塗れる色がなくなったら、1つ前の国に戻って色を変える（バックトラック法）。
#   これは1枚の地図を塗る計算で、定理の証明（すべての地図について成り立つこと）とは別のものである。
# 試してみよう：
#   - COLORS を 3 にすると、この地図は塗れるか（A・B・C・D の 4 つの国は、互いにすべて隣り合っている）
#   - SMART を False にすると（隣が多い国から先に塗る工夫をやめると）、試す回数はどう変わるか。
#     3色の時と4色の時で比べる

COLORS = 4
SMART = True
MAP = [   # このサイトが作った例（1文字が1マス。同じ文字が1つの国）
    "BBBCCCC",
    "BBAACCC",
    "BDAACFF",
    "DDDDDFF",
    "EEGGGII",
    "EHHJJII",
]
NAMES = ["赤", "青", "黄", "緑", "紫"]

NEIGHBORS = {}   # マスが上下・左右で接している国同士が「となり」
for r, row in enumerate(MAP):
    for c, a in enumerate(row):
        NEIGHBORS.setdefault(a, set())
        for rr, cc in ((r + 1, c), (r, c + 1)):
            if rr < len(MAP) and cc < len(row) and MAP[rr][cc] != a:
                b = MAP[rr][cc]
                NEIGHBORS[a].add(b)
                NEIGHBORS.setdefault(b, set()).add(a)

order = sorted(NEIGHBORS, key=lambda c: (-len(NEIGHBORS[c]), c)) if SMART else sorted(NEIGHBORS)
color = {}
tries = backs = 0

def paint(i):
    global tries, backs
    if i == len(order):
        return True
    country = order[i]
    for k in range(COLORS):
        tries += 1
        if all(color.get(n) != k for n in NEIGHBORS[country]):
            color[country] = k
            if paint(i + 1):
                return True
            del color[country]
    backs += 1          # どの色もだめ → 1つ前に戻る
    return False

ok = paint(0)
print(f"{COLORS} 色で、塗る順番 {' → '.join(order)}")
if ok:
    print("塗れた：", "  ".join(f"{c}={NAMES[color[c]]}" for c in sorted(color)))
else:
    print("塗れなかった")
print(f"色を試した回数 {tries}、戻った回数 {backs}")
bad = [(a, b) for a in sorted(NEIGHBORS) for b in sorted(NEIGHBORS[a]) if a < b and ok and color[a] == color[b]]
print("隣同士で同じ色：", bad if bad else "なし")
if ok:
    print("\n地図（色の1文字目）")
    for row in MAP:
        print("  " + "".join(NAMES[color[a]][0] for a in row))

提出「人工智慧」的夏季計畫書

一個夏天的研究會是怎樣的聚會

把能做出的證明全都做出來

從答案那一端，往回找

只在答錯時修正權重

「10年之內」的4個預言

他們自己訂下了核對預言的日期

卡片上的記號，在右邊還是左邊

用層層括號，直接處理式子

推導出去機場前要先做的行動

用惡魔們的喊聲辨識文字

選擇能縮小與目標「差異」的一步

我喜歡音樂

自己修正評分方式

隨機接線與馬達轉動的旋鈕

一台電腦，大家分著用

四色問題：人的推理與電腦的大量計算

本章仍然不清楚的事

提出的夏季計畫書

選擇能縮小與目標的一步