第1次热潮的开端

011955・名字与计划书

打出的夏季计划书

这个名字是在哪里、带着怎样的设想诞生的？

1955年8月31日，麦卡锡、明斯基、罗切斯特、香农四人写下了为次年夏天在达特茅斯学院举办的研讨会而作的计划书，向洛克菲勒基金会申请资金。计划书的题目里就有这个词。计划书从这样一个设想出发：学习的各个方面，乃至智能的任何特征，原则上都（译）。

右边的七个方框，是计划书里列出的研究课题。点一下就会显示内容：语言、神经网络、计算的规模、自我改进的机器。本章的许多页面，都是其中某一项的后续。

计划书预计时间为两个月、参加者10人。他们写道，只要挑选出的科学家们在一个夏天里聚在一起研究，就能在所列课题的（译）。申请的预算是13,500美元，而基金会实际资助的是7,500美元。

预算表各项加起来是13,000美元，与表上写的合计13,500美元差了500美元（据麦卡锡网站上的重印版核对，差额的原因没有写）。

常见说法常见说法：是大家一致同意定下的名字
原始资料里：这是麦卡锡选的名字，当时就有不同意见。纽厄尔和西蒙多年来一直用另一个叫法：。

常见说法常见说法：达特茅斯的参加者打算用一个夏天就把AI做出来
原始资料里：计划书的说法是（译）。并没有写要做成。

021956・达特茅斯

这个暑期研讨会是怎样的聚会

“AI诞生的那场大会议”，实际上是怎样的一次聚会？

1956年夏天，在达特茅斯学院数学系的顶层，聚集了一批关心会思考的机器的研究者。据参加者所罗门诺夫（Solomonoff）的笔记，时间大约从6月18日前后到8月17日，约8周。与其说是日程固定的会议，不如说是人们轮流来访、互相交谈的聚会。

在右边的图里点“详情：计划与记录”，就能把5月26日麦卡锡告诉基金会的计划（紫色框），和所罗门诺夫、摩尔（More）笔记里留下的“当天在场的人”（深蓝色圆点）叠在一起查看。全程在场的只有3个人，原定的11个人里有2个没来。每天参加讨论的人大约是3〜8人。

也有过让所有人一起攻克一个课题的提议。8月7日，麦卡锡提出了国际象棋，但没有变成共同研究。麦卡锡后来说，经费不够，大家又各有别的事，所有人整个夏天都聚齐的计划没有实现。

准确的名单没有保存下来（麦卡锡把自己的名单弄丢了）。圆点只是笔记里留有记录的日子，没有圆点的日子也不一定没来。

常见说法常见说法：达特茅斯的研讨会是诞生了AI的大型会议
原始资料里：实际上是人们轮流来访的夏季聚会，每天的讨论只有3〜8人左右。基金会给的资金约为希望额的一半，也没有出版研讨会的报告。

第6周（7月23〜27日）每天参加讨论的人数（摩尔的笔记）

031956・搜索

把证明一个不漏地全造出来

把能造出的证明按顺序全部造出来，总有一天会碰到想要的定理吧？

纽厄尔、肖、西蒙挑战的，是书《数学原理（Principia Mathematica）》中的逻辑定理。从5条公理出发，用三条规则造出新的定理：把式子代入字母的代入、改写成同义形式的替换、由A和“A则B”得到B的分离。

最简单的做法，是把能造出的证明按由短到长全部造出来，等目标的式子出现。三个人把这叫作大英博物馆算法（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）不把一切都造出来，而是从想要证明的式子那一端倒着去找。它依次试四种方法。代入法：把式子代入公理或已证明的定理的字母，看能否变得和问题完全一样。分离法：找“A则B”形式的定理，其中B与问题吻合，然后把A当作新的小问题。前向、后向的衔接，也会产生小问题。

1957年的报告中，在第2章最前面的 52条定理里，它找到了38条的证明。其中17条只靠代入法，19条用两步就解出。2.01约10秒，2.45约12分钟。2.31约23分钟后搜索无路可走。右边的图是本站做的小型LT。点“到最后”，树就会向下伸展，绿色的路就是证明。

报告打了个比方：从公理向前走，就像在草堆里找一根针；从目标往回走，则像是找针从草堆里出来的路。

图中的LT在细节上和1956年的程序不同。报告写道，用这四种方法证明不了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年之内”的四个预言

1957年的研究者，是怎样展望十年后的？

1957年11月14日，在匹兹堡学会的晚宴上，西蒙做了一场与纽厄尔合写的演讲（次年刊登在杂志上）。他总结说，现在的计算机能用类似人的方法解决没有固定解法的问题，也能从经验中学习，在此基础上，预言10年之内会发生四件事。

成为国际象棋世界冠军（〈译〉）；发现并证明一个重要的新数学定理；写出得到评论家认可的乐曲；大部分心理学理论采取程序的形式。他接着还说：（译）。

也有可作为线索的成果：证明逻辑定理的程序、会下国际象棋入门棋步的计算机、作曲的伊利诺伊大学ILLIAC。在右边的图里推进年份，会显示核对答案的年份（1968年）以及此后发生的事。

计算机战胜在任的国际象棋世界冠军是在1997年，距离预言约40年后。计算机本身从未获得过世界冠军的头衔。

071958・批评与回应

他们自己写下了核对答案的日子

要让预言可以被检验，需要什么？

演讲刊登在杂志上后，贝尔曼写信批评。据两人的回应，批评是说预言（译）。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启动了。没有写计划书，被问到需要什么时，他们回答说：一间屋子、两名程序员、一名秘书、一台在卡片上打孔的机器。同一个秋天，他们开始制作处理符号序列的编程语言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))，也就是先走到车那里。

在右边的图里点“推导下一步”试试。只要去掉一个前提，就找不到计划了。

论文写道，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

选择能缩小与目标的一步

能造出适用于任何问题的解法吗？

纽厄尔、肖、西蒙在逻辑理论家的基础上造出了，作为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年夏天前后，电气试验所（Electrotechnical Laboratory，ETL）开始了英译日专用计算机“Yamato”（やまと）的计划。手头没有配备能存放词典的大容量存储装置的计算机，于是用晶体管计算机ETL Mark IV的电路造了专用机。预算600万日元，存储装置是82万比特的磁鼓。1959年2月，把穿了I like music孔的纸带放进去，它打印出了（ワレガオンガクヲコノム）。

为了避开日语输入（汉字和词的切分）的困难，他们选择了从英语翻译成日语。即便如此，也需要把动词挪到句末、移动前置词、补上日语助词（ガ、ヲ等）。代词方面，把I译成“我”（ワレ），you译成“你”（ナレ），he译成“他”（カレ）。在右边的图里，一步一步地走完翻译的流程吧。

下达计划指示的和田弘回忆说，到开始打出第一句译文为止的13秒，让他觉得非常漫长。成果于1959年6月，在巴黎的第1届国际信息处理会议上发表。

图中的词典和规则，除了代词的译法之外，都是本站做的例子。在巴黎展示的 I have some eggs in my hand.，Yamato是怎样翻译的，资料里没有记载。

这是用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）负责。

结构分三层。从视网膜（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月，利克莱德发表了论文《人与计算机的共生》。就像无花果树和传粉的昆虫互相帮助一样，他设想了一种协作形式：由人决定目标、提出假设、定好标准来评价，计算机承担固定套路的工作。他本人曾在1957年的春夏记录自己的工作，结果发现，思考时间的大约85%都花在为思考做准备上（查找、计算、画图表等）。

为此所需的技术之一，是分时（把一台计算机的时间，细细地分给许多人使用的机制）。他论证说，当时的大型计算机，和一个人一起思考的话速度太快、费用也太高，所以应该把使用时间分给很多人。在右边的图里和排队等候做个比较吧。即使计算机处理的时间总和相同，到第一次回应为止的等待时间也会短得多。

常见说法常见说法：利克莱德预言到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年之内”的四个预言

他们自己写下了核对答案的日子

卡片上的记号，在右还是在左

用括号的嵌套，把式子当作式子来处理

推导出去机场要先做的行动

用恶魔们的喊叫声来认字

选择能缩小与目标“差异”的一步

我喜欢音乐

自己修正打分的方式

用杂乱的接线和电机转动的旋钮

一台计算机，大家分着用

四色问题：人的思路与计算机的蛮力

这一章里，仍然不清楚的事

打出的夏季计划书

选择能缩小与目标的一步