第2次热潮的开端

011965〜1977・知识的力量

知识里有力量

要让计算机变聪明，需要的是巧妙的思考方式，还是大量的知识？

1965年，转到斯坦福大学的费根鲍姆等人，给一个会把分子结构全部列举出来的程序DENDRAL，装进了化学家解读质谱数据的经验——写成的规则，以此缩小候选范围。在Nilsson（2010）举的例子里，14,715,813种结构，靠数据规则缩小到约1,284,792种，再加上另一项测量，就缩小到了1种。

右边的图，是把3种部件排成6个的729种排法，靠不断加规则来缩小范围。知识越多，要查的数量就成数量级地减少。

1970年的论文里，3位作者写道：（译）。1977年，费根鲍姆把“把专家的知识移入计算机”的工作称为知识工程，并总结为（译）。

N_剩余 ≈ N × r₁ × r₂ × … × r_k

N: 全部候选数
r_i: 规则i留下的比例（≈ 表示规则之间互不相关时的估算）

常见说法常见说法：国家白皮书（2016）写着
原始资料里：把专家经验写成规则的 DENDRAL（1965年起）更早，当事人在1993年一篇论文的题目里，把DENDRAL称为（译）。从哪里开始算专家系统，答案就不一样。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_knowledge_prune.py

# u06 知識で候補を絞る：専門家の「決まり」を足すたびに、考える候補が減っていく
#
# どの出来事か：1965 年からの DENDRAL（記録 dendral_1965）と、1977 年のファイゲンバウムの論文
#   「知識の中に力がある」（記録 feigenbaum_knowledge_bottleneck_1977）。
#   DENDRAL は、化学式から考えられる分子構造を網羅し、化学者の経験的なルールで候補を絞り込んだ。
#   Nilsson（2010）の例では、14,715,813 通りの構造が、質量分析のデータで約 1,284,792 通りに、別の測定も加えると 1 通りに絞られた。
# 仕組み：分子の代わりに、A・B・C の 3 種類の部品を 8 個つなぐ「並べ方」を全通り生成する（3 の 8 乗＝6,561 通り）。
#   専門家のルール（このサイトが作った例）を 1 つずつ適用して、残る候補を数える。
#   力任せの探索よりも、候補を絞り込む知識のほうが、答えに早く近づけることが分かる。
# 試してみよう：
#   - RULES の順番を入れ替えると、途中の数はどう変わるか。最後の数は変わるか
#   - 部品の数 N を 10 にすると、全体の数と、残る数はどうなるか

import math
from itertools import product

N = 8
PARTS = "ABC"

# 専門家のルール（このサイトが作った例）。どれも「この形はありえない」という知識
RULES = [
    ("はじめは A", lambda s: s[0] == "A"),
    ("C と C はとなり合わない", lambda s: "CC" not in s),
    ("B はちょうど 2 個", lambda s: s.count("B") == 2),
    ("最後は C", lambda s: s[-1] == "C"),
    ("A の次に B は来ない", lambda s: "AB" not in s),
    ("C はちょうど 3 個", lambda s: s.count("C") == 3),
    ("3 番目と 6 番目は同じ", lambda s: s[2] == s[5]),
    ("B と B はとなり合わない", lambda s: "BB" not in s),
    ("2 番目は A", lambda s: s[1] == "A"),
]

cands = ["".join(p) for p in product(PARTS, repeat=N)]
print(f"部品 {N} 個の並べ方：全部で {len(cands):,} 通り")

def bar(n):
    """対数目盛のバー表示（# 6 個で 10 倍）"""
    return "#" * max(1, round(math.log10(max(n, 1)) * 6)) if n else ""

for name, ok in RULES:
    cands = [s for s in cands if ok(s)]
    print(f"  ＋ルール「{name}」→ 残り {len(cands):>5,} 通り  {bar(len(cands))}")

print("\n残った候補：", cands[:10], "…" if len(cands) > 10 else "")
print("\nDENDRAL の実際の数値（Nilsson 2010）：14,715,813 → 約 1,284,792 → 1")
print("ルール（知識）を加えるほど、調べる数が桁違いに減る。これが「知識の中に力がある」の意味の 1 つ")

021972〜1978・MYCIN

把“大概”连起来的确信度

含有“大概”的规则，要怎样连接起来？

1972年前后，斯坦福大学的肖特利夫等人做出了MYCIN，这个程序向医生建议治疗细菌性感染的用药。医生的知识被写成“如果（检验结果是……）那么（病菌大概是……）”这样的规则。规则起初约200条，1978年增加到约500条。

每条规则都带着一个表示有多可靠的确信度（−1〜+1）。条件不确定时，要用规则的确信度乘以条件的可靠程度。在开发者的书里，确信度0.7的规则，如果有一个条件的可靠程度是0.6，结果就是0.42。同一个结论被另一条规则也支持时，用下面的式子加起来。

在右边的图（用的是自行车的例子，不是医学）里，不断加入弱规则，不管多弱，确信度都会趋近于1。书里写道，这种加法是凭直觉定的，而不是依据概率理论。Nilsson（2010）引用的教科书写道，规则一多，别的规则的确信度也得跟着修改。

合并后的确信度＝x＋y（1 − x）

x: 到目前为止的确信度
y: 新规则给出的确信度（规则的确信度 × 条件的可靠程度。条件有2个以上时，取最低的可靠程度）

用到的规则数量，与合并后的确信度

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_expert_rules.py

# u06 エキスパートシステムの仕組み：「もし〜なら〜」のルールと確信度、「なぜ？」に答える
#
# どの出来事か：1972 年からの MYCIN（記録 mycin_1972）。医師の知識を「もし〜なら〜」のルールとして書き込み、
#   ルールごとに確からしさ（確信度）を設定し、なぜそう判断したかを説明できた。初めは約 200、1978 年に約 500 のルール。
# このサンプル：同じ仕組みで「自転車の調子が悪い理由」を診断する（医学の助言はしない）。
#   ゴール（原因の候補）から逆向きに、ルールを使って確かめていく（後ろ向き推論）。
# 試してみよう：
#   - FACTS の答えを変えると、結論と確信度がどう変わるか
#   - ルールにない症状（例：「ベルが鳴らない」）を入れると、何も判断できない → 知識を書き足す手間（知識獲得のボトルネック）

FACTS = {   # 利用者の回答（はい＝True、いいえ＝False）
    "こぐと音がする": True,
    "チェーンがさびている": True,
    "タイヤを押すとへこむ": False,
    "ブレーキをかけていないのに重い": True,
    "ベルが鳴らない": True,
}

RULES = [
    # (番号, 条件（すべて満たす場合）, 結論, ルールの確信度)
    ("R1", ["こぐと音がする", "チェーンがさびている"], "チェーンの油切れ", 0.8),
    ("R2", ["タイヤを押すとへこむ"], "空気が少ない", 0.9),
    ("R3", ["ブレーキをかけていないのに重い", "タイヤを押すとへこむ"], "空気が少ない", 0.6),
    ("R4", ["ブレーキをかけていないのに重い"], "ブレーキがこすれている", 0.5),
    ("R5", ["こぐと音がする"], "チェーンの油切れ", 0.3),
]
GOALS = ["チェーンの油切れ", "空気が少ない", "ブレーキがこすれている"]

def combine(a, b):
    """同じ結論を別のルールが支持したときの計算（MYCIN の確信度の合成。正の値同士）"""
    return a + b * (1 - a)

def prove(goal, depth=0):
    """ゴールの確信度を求め、どのルールを使ったかの説明も返す。"""
    cf, why = 0.0, []
    for no, conds, concl, strength in RULES:
        if concl != goal:
            continue
        cond_cfs = [1.0 if FACTS.get(c) else 0.0 for c in conds]
        if min(cond_cfs) > 0:
            this = strength * min(cond_cfs)
            cf = combine(cf, this)
            why.append(f"{no}：もし {'・'.join(conds)} なら {concl}（確信度 {strength}）")
    return cf, why

for g in GOALS:
    cf, why = prove(g)
    print(f"{g}：確信度 {cf:.2f}")
    for w in why:
        print(f"   なぜ？ → {w}")

unknown = [f for f, v in FACTS.items() if v and not any(f in conds for _, conds, _, _ in RULES)]
print("\nルールが 1 つもないため、何も判断できなかった回答：", unknown)
print(f"現在のルールの数：{len(RULES)}。MYCIN は 1978 年に約 500。ルールを書き足し、直し続けるのが大仕事だった")

031970年代・推理引擎

正向与反向

规则有很多的时候，机器先用哪一条？

把专家的知识写成规则，并给出答案和理由的程序，叫作专家系统。把规则连起来得出答案的部分，叫推理引擎。做出MYCIN的人们写的书（1984）把连接方式分成两种。正向（从数据出发）是从已知的事实出发，沿规则从“如果”走向“那么”。反向（从目标出发）是从想要确认的目标倒着往回找，只询问缺少的事实。MYCIN主要用反向，也被称为收集证据的程序。

在右边的图（自行车的例子）里比较一下这两种方式。正向会先把问题全问完再用规则，反向则只问与目标有关的问题。

MYCIN里，规则的集合（知识库）和推理引擎是分开的，所以人们做出了把医学规则抽掉的空壳EMYCIN（E是empty，空的意思），还被用在税务规划等咨询系统上。

正向：事实 → 结论　　反向：目标 → 提问

正向: 从“如果”（条件）走向“那么”（结论）
反向: 倒着从“那么”走向“如果”，只询问缺少的部分

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_forward_backward.py

# u06 前向き推論と後ろ向き推論：同じルールでも、適用する順番で「聞く質問の数」が変わる
#
# どの出来事か：MYCIN（記録 mycin_1972）。開発者たちの本（1984）は、分かっている事実からルールを左から右へ
#   つないでいくやり方を前向き（データから進む）、確かめたいゴールからルールを右から左へたどり、
#   足りない事実だけを聞くやり方を後ろ向き（ゴールから進む）と呼び、MYCIN は主に後ろ向きを使ったと書いている。
# このサンプル：医学ではなく「自転車の調子が悪い理由」の知識（このサイトが作ったルール）で比較する。
# 試してみよう：
#   - TRUTH（実際の状態）を変えて、それぞれ何問質問するかを比べる
#   - GOAL を「空気が少ない」に変える。後ろ向き推論は、どの質問を省略するか

TRUTH = {  # 使う人に聞けば分かる事実（実際の状態）
    "こぐと音がする": True,
    "チェーンがさびている": False,
    "雨の中に置いていた": True,
    "タイヤを押すとへこむ": False,
    "ブレーキをかけていないのに重い": True,
    "前に乗ったのは 1 か月以上前": True,
    "空気を入れたのは最近": False,
    "ブレーキのレバーが戻りにくい": False,
}

RULES = [  # (番号, もし（すべて満たせば）, なら)。「〜でない」は「not 〜」と書く
    ("R1", ["雨の中に置いていた"], "さびやすい所にあった"),
    ("R2", ["前に乗ったのは 1 か月以上前"], "しばらく乗っていない"),
    ("R3", ["こぐと音がする", "チェーンがさびている"], "チェーンの油切れ"),
    ("R4", ["こぐと音がする", "さびやすい所にあった"], "チェーンの油切れ"),
    ("R5", ["タイヤを押すとへこむ"], "空気が少ない"),
    ("R6", ["しばらく乗っていない", "ブレーキをかけていないのに重い", "not 空気を入れたのは最近"], "空気が少ない"),
    ("R7", ["ブレーキをかけていないのに重い", "ブレーキのレバーが戻りにくい"], "ブレーキがこすれている"),
]
GOAL = "チェーンの油切れ"

def forward():
    """前向き推論：まず事実をすべて確認し、使えるルールがなくなるまで適用を繰り返す"""
    known = dict(TRUTH)  # すべての質問を行う
    asked = len(TRUTH)
    changed = True
    while changed:
        changed = False
        for no, conds, concl in RULES:
            if concl not in known and all(known.get(c[4:]) is False if c.startswith("not ") else known.get(c) for c in conds):
                known[concl] = True
                changed = True
                print(f"   {no} を適用 → {concl}")
    return known.get(GOAL, False), asked

def backward(goal, known, asked, depth=0):
    """後ろ向き推論：ゴールを結論に持つルールを探し、その条件を新たなゴールとしてたどる。事実なら質問する"""
    if goal in known:
        return known[goal]
    concl_rules = [r for r in RULES if r[2] == goal]
    if not concl_rules:  # どのルールの結論でもない＝使う人に尋ねる事実
        known[goal] = TRUTH[goal]
        asked.append(goal)
        print("   " + "  " * depth + f"質問：{goal}？ → {'はい' if TRUTH[goal] else 'いいえ'}")
        return known[goal]
    for no, conds, _ in concl_rules:
        print("   " + "  " * depth + f"{no} を試す（{goal} を確かめるため）")
        ok = True
        for c in conds:
            neg = c.startswith("not ")
            v = backward(c[4:] if neg else c, known, asked, depth + 1)
            if v == neg:
                ok = False
                break
        if ok:
            known[goal] = True
            return True
    known[goal] = False
    return False

print("■ 前向き推論（データから）：")
ans, n = forward()
print(f"   答え：{GOAL} は {'あり' if ans else 'なし'}。聞いた質問 {n} 問\n")

print("■ 後ろ向き推論（ゴールから）：")
asked = []
ans = backward(GOAL, {}, asked)
print(f"   答え：{GOAL} は {'あり' if ans else 'なし'}。聞いた質問 {len(asked)} 問")
print("\n後ろ向き推論は、ゴールに関係のある質問しかしない。開発者たちが MYCIN を、証拠を集めるプログラムと呼んだ理由がここにある")

041970年代・解释

能问“为什么？”的机器

机器给出了答案，人要怎样才能相信它？

MYCIN的开发者，从一开始就把说明理由当作重要目标。MYCIN提问时，使用者可以输入WHY（为什么问这个？）。MYCIN会显示它正在确认的上一层目标，以及把这个目标和提问连起来的规则。重复输入WHY，就会再往上一层追溯。输入HOW（是怎么知道的？），它会显示用过的规则，或者说明那是使用者自己这样回答的。

右边的图是自行车的咨询。边回答问题，边点几次“为什么？”。图中会显示出此刻正在确认的规则链条。

在反向推理里，每个问题都是为了确认某条规则的条件才冒出来的。所以，可以用规则的链条来回答理由。

为什么？ → 上一层目标＋规则　　怎么知道的？ → 规则／答案

目标: 此刻想要确认的结论
链条: 从目标到提问之间规则的连接

书的第18章里有WHY和HOW问答的例子。那是医学的例子，图中换成了自行车。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_why_how.py

# u06 「なぜ？」と「どうやって？」に答える相談の機械
#
# どの出来事か：MYCIN（記録 mycin_1972）。開発者たちの本（1984）の第 18 章によると、MYCIN が質問している時、
#   使う人は WHY（なぜそれを聞くのか）と入力できた。MYCIN は、いま確かめようとしている上のゴールと、
#   そのゴールと質問をつなぐルールを示した。WHY を繰り返すと、さらに上のゴールへさかのぼった。
#   HOW（どうやってそれが分かったのか）と入力すると、使ったルールか、使う人自身が答えたことを示した。
# このサンプル：医学ではなく「自転車の調子が悪い理由」の小さな知識（このサイトが作ったルール）。
#   input() の代わりに、ANSWERS に答えを、COMMANDS に質問ごとに打つ言葉を書いておく。
# 試してみよう：
#   - COMMANDS に "なぜ" を 3 回並べると、どこまでさかのぼるか
#   - ANSWERS を変えると、どのルールが使われ、HOW の答えがどう変わるか

ANSWERS = {"こぐと音がする": True, "チェーンがさびている": False, "雨の中に置いていた": True}
COMMANDS = {"雨の中に置いていた": ["なぜ", "なぜ"]}  # この質問の時に打つ言葉
HOW_AT_END = ["チェーンの油切れ", "さびやすい所にあった", "こぐと音がする"]

RULES = [
    ("R3", ["こぐと音がする", "チェーンがさびている"], "チェーンの油切れ", 0.8),
    ("R4", ["こぐと音がする", "さびやすい所にあった"], "チェーンの油切れ", 0.6),
    ("R1", ["雨の中に置いていた"], "さびやすい所にあった", 0.7),
]

how = {}    # 分かったこと → どうやって分かったか
stack = []  # いま確かめているゴールと使っているルール（WHY のために記録）
known = {}  # 分かったこと → はい・いいえ

def ask(fact):
    print(f"質問：{fact}？")
    level = len(stack)  # WHY で、どこまでさかのぼったか
    for cmd in COMMANDS.get(fact, []):
        print(f"  ** {cmd}")
        if cmd == "なぜ":
            if level == 0:
                print("     （これが、いちばん上のゴールです）")
                continue
            level -= 1
            goal, (no, conds, concl, cf) = stack[level]
            print(f"     → {concl} を確かめるためです。{no}：もし {'・'.join(conds)} なら {concl}（確信度 {cf}）")
    ans = ANSWERS[fact]
    print(f"  答え：{'はい' if ans else 'いいえ'}")
    how[fact] = "あなたがそう答えた"
    return ans

def prove(goal):
    if goal in known:
        return known[goal]
    rules = [r for r in RULES if r[2] == goal]
    if not rules:
        known[goal] = ask(goal)
        return known[goal]
    for rule in rules:
        stack.append((goal, rule))
        ok = all(prove(c) for c in rule[1])  # all は、いいえが出たところで止まる
        stack.pop()
        if ok:
            how[goal] = f"{rule[0]} を使った（{'・'.join(rule[1])} がそろった）"
            known[goal] = True
            return True
    how[goal] = "使える決まりが無かった"
    known[goal] = False
    return False

result = prove("チェーンの油切れ")
print(f"\n結論：チェーンの油切れ は {'あり' if result else 'なし'}\n")
for f in HOW_AT_END:
    print(f"** どうやって「{f}」が分かった？ → {how.get(f, 'まだ分かっていない')}")

051974・框架

用场景的模板来储存知识

为什么一听到“生日会”，就会想到蛋糕和礼物？

1974年6月，麻省理工学院的明斯基在报告《一种表示知识的框架》里提出了这样的想法：人遇到新场景时，会从记忆里取出一种叫框架的结构，修改细节，使它与现实相符。框架是表示（译）的数据结构，带有空栏（槽）。空栏里临时放着“通常就是这样”的值（默认值）。报告举的例子是去参加小孩子的生日会。

在右边的图里，让它一句一句地读故事。写明的值会填进空栏，没写的地方，就用默认值“大概是这样”来想。和默认值不一样，就会变成紫色。

明斯基声明，这是在（译）一套完整理论的情况下写的，并在最后一节写道：（译）。他本人没有做框架系统，几年后由学生们做了出来（Nilsson 2010）。

常见说法常见说法：“第2次热潮的AI，就是把大量知识写成‘如果……那么……’的规则或逻辑式放进去的东西”，常被这样一概而论
原始资料里：同一时期的有力想法之一——框架，则是想用带有“通常是这样”的预期的模板来表示知识。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_frames.py

# u06 フレーム：よくある場面のひな型に、スロット（空き欄）と「とりあえずの値」を持たせる
#
# どの出来事か：1974 年 6 月のミンスキーの報告「知識を表すための枠組み」（記録 minsky_frames_1974）。
#   人は新しい場面に出会うと、記憶からフレームという枠組みを取り出し、細かいところを直して現実に合わせる、という考え方。
#   フレームにはスロット（空き欄）があり、そこには、ふつうはこうだというデフォルト（とりあえずの値）が入っている。
#   報告は、子どもの誕生会に行く場面を例に挙げている。
# このサンプル：誕生会のフレーム（スロットととりあえずの値は、このサイトが作った例）に、物語の文を 1 つずつ読ませる。
#   文に書かれた値でスロットを埋め、書かれていない所は、とりあえずの値で「たぶん〜」と考える。
#   とりあえずの値と違うことが書かれていたら「予想とちがう」と知らせる。
# 試してみよう：
#   - STORY に「ケーキはなかった」の文を足すと、どうなるか
#   - レストランのフレームを作って、同じ物語を読ませる（スロットがどれだけ埋まるか）

FRAME = {  # スロット（空き欄） → とりあえずの値
    "主役": "誕生日の子",
    "場所": "主役の家",
    "食べ物": "ケーキ",
    "プレゼント": "おもちゃ",
    "遊び": "ゲーム",
    "終わりに": "ろうそくを吹き消す",
}

STORY = [  # (文, スロット, 書かれた値)。文から値を取り出す処理は、ここでは人が書いておく
    ("今日はケンの 8 歳の誕生会だ。", "主役", "ケン"),
    ("みんなで公園に集まった。", "場所", "公園"),
    ("ぼくは本を包んで持っていった。", "プレゼント", "本"),
    ("おやつは大きなすいかだった。", "食べ物", "すいか"),
]

filled = {}
for sentence, slot, value in STORY:
    filled[slot] = value
    mark = "予想とちがう！" if value != FRAME[slot] and slot != "主役" else "埋まった　"
    print(f"{sentence:<16} → {slot}＝{value}　{mark}（とりあえずの値は {FRAME[slot]}）")

print("\n現在のフレーム：")
for slot, default in FRAME.items():
    if slot in filled:
        print(f"  {slot:<6}：{filled[slot]}（物語に書いてあった）")
    else:
        print(f"  {slot:<6}：たぶん {default}（書いていないので、とりあえずの値）")

print("\n書いていないことまで「たぶん」で埋められるのが、フレームの強み。")
print("そのかわり、とりあえずの値が現実と違うこともある（すいかの誕生会）。")

061979・MYCIN的成绩

隐去名字来打分

机器的答案好不好，怎样才能公平地检验？

1979年的评估中，针对10位脑膜炎患者，每人收集了10份处方：MYCIN、斯坦福的5位感染科医生、感染科进修医生、内科住院医师、医学生，以及实际的治疗。然后，由斯坦福以外的8位感染病专家，在不知道是谁开的处方的情况下，逐份打分（8人 × 100份＝800次打分）。

MYCIN的处方有65% 被评为（译），5位医生是42.5〜62.5%（平均55.5%）。多数专家认可的病例，MYCIN在10例中也有7例。在右边的图里切换标准，把名字显示出来看看。

即便如此，开发者们的书（1984）仍写道：（译）。他们还认为，在日常使用之前，希望得到多数专家9成以上的认可。

常见说法常见说法：“MYCIN比专科医生更准，却因为法律和责任问题没能在医院里使用”，常有人这么说
原始资料里：开发者们的书列出的理由是：增加知识的费用和人手问题，想转去做下一项研究，而最主要的是（译）。其中多数是好不好用、费不费事的问题。

071979〜1982・PROSPECTOR

乘上倍率来推测

怎样从地表的线索，推测地下的矿床？

SRI的PROSPECTOR是为勘探矿物的地质专家提供建议的AI，1979年在东京举行的国际会议上，也发表过对它成绩的分析。它的规则这样相连：有晶体形状空洞的岩石是有硫化物的迹象，硫化物上面如果有重晶石，也许就是块状硫化物矿床，由此构成了推理网络。

与MYCIN的确信度不同，PROSPECTOR 使用了概率和贝叶斯法则。专家为每条规则给出两个数：条件成立时几率（odds）变成多少倍（LS），以及条件不成立时变成多少倍（LN）。在右边的图里点击线索，就会沿着网络推算，概率随之改变（倍率是本站自己设的数）。

1982年，他们用华盛顿州托尔曼山（Mount Tolman）的地图数据，把钼矿床的前景画成了 +5〜−5的地图。

几率 ← 几率 × LS（是）或 × LN（否）　　概率＝几率 ÷（1＋几率）

几率: 发生的可能 ÷ 不发生的可能
LS・LN: 由专家决定的两个倍率

常见说法常见说法：“PROSPECTOR发现了人类没能发现的矿床”，常有人这么说
原始资料里：据开发方的说明，那是矿业公司已经钻了200多个孔并发现了矿床的地方，它判断出了（译）和（译）。而且（译）。这只是靠开发方其中一人的书核实的说法。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_prospector_odds.py

# u06 PROSPECTOR の推論方法：「A は B を示す」ルールに、2 つの倍率をつけてオッズをかけ算する
#
# どの出来事か：SRI の PROSPECTOR（記録 prospector_mount_tolman_1982）。Nilsson（2010）によると、
#   ルールは「結晶の形の空洞がある岩は、硫化物がある印」（ルール 22）や、
#   「硫化物の上に重晶石があれば、塊状の硫化物の鉱床があるかもしれない」（ルール 3）のような形で、
#   ルール同士がつながった「推論の網」になっていた。地質の専門家はルールごとに 2 つの数値を与えた。
#   条件が正しい時にオッズが何倍に増えるか（ここでは LS）と、条件が誤りの時に何倍に減るか（ここでは LN）である。
#   それをベイズの規則で使い、結論の確率を計算した。
# このサンプル：同じ構造の小さなネットワーク（倍率と初期確率は、このサイトが作った数）。
#   手がかりの入力は はい（True）・いいえ（False）・分からない（None）。
#   ネットワーク途中の結論（硫化物がある）は確率で次へ渡す。その計算（はい と いいえ の間を直線で補間する）は、
#   このサンプルのやり方で、本物の PROSPECTOR の式そのものではない。
# 試してみよう：
#   - EVIDENCE の答えを変えて、鉱床の確率がどう動くかを見る
#   - LS を大きくすると、1 つの手がかりの影響がどれだけ変わるかを見る

PRIOR = {"硫化物がある": 0.10, "塊状の硫化物の鉱床": 0.01}

# (手がかり, 結論, LS＝正しい時の倍率, LN＝誤りの時の倍率)
RULES = [
    ("結晶の形の空洞がある岩", "硫化物がある", 20.0, 0.8),
    ("方鉛鉱が見つかった", "硫化物がある", 50.0, 0.9),
    ("硫化物がある", "塊状の硫化物の鉱床", 5.0, 0.2),
    ("重晶石が上にある", "塊状の硫化物の鉱床", 8.0, 0.6),
]

EVIDENCE = {"結晶の形の空洞がある岩": True, "方鉛鉱が見つかった": None, "重晶石が上にある": True}

def odds(p):
    return p / (1 - p)

def prob(o):
    return o / (1 + o)

def factor(pe, pe0, ph0, ls, ln):
    """手がかりの確率 pe から、結論のオッズを何倍にするかを計算する（はい＝LS、いいえ＝LN、初期値のまま＝1 倍）"""
    p_yes, p_no = prob(odds(ph0) * ls), prob(odds(ph0) * ln)
    if pe >= pe0:
        p = ph0 + (p_yes - ph0) * (pe - pe0) / (1 - pe0)
    else:
        p = p_no + (ph0 - p_no) * pe / pe0
    return odds(p) / odds(ph0)

def infer(node, depth=0):
    """結論の確率を、下の手がかりから順に計算する。手がかりの確率を返す"""
    pad = "  " * depth
    if node in EVIDENCE:
        v = EVIDENCE[node]
        return 0.5 if v is None else (1.0 if v else 0.0), 0.5
    o = odds(PRIOR[node])
    print(pad + f"{node}（初期確率 {PRIOR[node]:.3f}）")
    for ev, concl, ls, ln in RULES:
        if concl != node:
            continue
        pe, pe0 = infer(ev, depth + 1)
        f = factor(pe, pe0, PRIOR[node], ls, ln)
        o *= f
        print(pad + f"  ← {ev}（{pe:.2f}）：オッズ ×{f:.2f} → {prob(o):.3f}")
    return prob(o), PRIOR[node]

p, _ = infer("塊状の硫化物の鉱床")
print(f"\n塊状の硫化物の鉱床がある確率：{p:.3f}（初期確率は {PRIOR['塊状の硫化物の鉱床']}）")
print("手がかりはかけ算で効く。専門家が決めるのは、ルールごとの 2 つの倍率だけである")

081980・R1（XCON）

发现缺少的部件

根据计算机的订单画出装配图的规则，是什么样的？

卡内基梅隆大学的麦克德莫特做出了R1（公司内部名称是XCON），根据DEC公司计算机VAX的订单来决定部件的构成。一台机器的部件通常约有90个，订单上常常漏掉必需的部件。R1会发现这一点并补上，画出布置图。从1980年1月起，它在DEC的工厂里投入了日常工作。

R1看着工作记录，找出所有条件符合的规则（规矩），再执行其中一条，如此反复。1980年的论文里规则数是772条。一份订单平均要执行1,056次规则，平均计算时间2.5分钟。在右边的图（部件和规则是本站自己编的例子）里，点“转1次”看看。

① 找出条件齐备的全部规则 → ② 选1条 → ③ 执行并改写记录 → ①

工作记录: 当前的工作（检查・布置・连接）与已知的信息

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_configurator.py

# u06 注文書から、足りない部品を足して、箱に並べる：「条件がそろった決まりを 1 つ実行する」をくり返す
#
# どの出来事か：R1（社内名は XCON）。1980 年 1 月から DEC の工場で使われた（記録 xcon_r1_dec_1980）。
#   1980 年の論文によると、R1 は OPS4 という言語で書かれ、作業のメモ（working memory）を見て、
#   条件を満たすルールをすべて見つけ、そのうち 1 つを実行する処理を繰り返した（recognize-act cycle）。
#   注文には必要な部品の不足が多く、それに気づいて補うのが大きな仕事だった。1 台は通常約 90 の部品。
# このサンプル：本物の VAX の部品ではなく、このサイトが作った小さな部品表と 8 つのルール。
#   ルールは「いまの作業（文脈）」ごとに分かれている（R1 のルールも、文脈の条件から始まっていた）。
# 試してみよう：
#   - ORDER のディスクを 5 台にすると、制御装置はいくつ追加されるか
#   - ルール R2 を消すと（RULES から外すと）、どんな誤った組み立てになるか

ORDER = {"CPU": 1, "メモリ": 3, "ディスク": 3, "端末": 2}
SLOTS_PER_BOX = 4          # 1 つの箱に入る基板の数（このサイトが作った数）
DISKS_PER_CONTROLLER = 2   # 1 つの制御装置につなぐディスクの数（このサイトが作った数）

wm = {"文脈": "点検", "部品": dict(ORDER), "箱": [[]], "置いた": {k: 0 for k in ORDER}, "ケーブル": 0, "足した": []}
BOARDS = ["CPU", "メモリ", "制御装置", "端末の板"]  # 箱の中に差し込む部品

def add(part, why):
    wm["部品"][part] = wm["部品"].get(part, 0) + 1
    wm["置いた"].setdefault(part, 0)
    wm["足した"].append(part)
    return f"{part} を追加（{why}）"

def next_unplaced():
    for p in BOARDS:
        if wm["置いた"].get(p, 0) < wm["部品"].get(p, 0):
            return p
    return None

def place(p):
    box = wm["箱"][-1]
    box.append(p)
    wm["置いた"][p] += 1
    return f"{p} を 箱 {len(wm['箱'])} の {len(box)} 番に配置"

RULES = [  # (名前, 条件, 実行)
    ("R1 制御装置が足りない", lambda: wm["文脈"] == "点検" and wm["部品"].get("制御装置", 0) * DISKS_PER_CONTROLLER < wm["部品"]["ディスク"],
     lambda: add("制御装置", "ディスクに対して不足")),
    ("R2 端末の板が無い", lambda: wm["文脈"] == "点検" and wm["部品"].get("端末", 0) > 0 and wm["部品"].get("端末の板", 0) == 0,
     lambda: add("端末の板", "端末をつなぐため")),
    ("R3 点検おわり", lambda: wm["文脈"] == "点検",
     lambda: wm.update(文脈="置く") or "不足なし → 文脈を「置く」へ"),
    ("R4 箱がいっぱい", lambda: wm["文脈"] == "置く" and next_unplaced() and len(wm["箱"][-1]) >= SLOTS_PER_BOX,
     lambda: wm["箱"].append([]) or add("箱", "空きが無い")),
    ("R5 次の板を置く", lambda: wm["文脈"] == "置く" and next_unplaced(),
     lambda: place(next_unplaced())),
    ("R6 置きおわり", lambda: wm["文脈"] == "置く",
     lambda: wm.update(文脈="ケーブル") or "配置完了 → 文脈を「ケーブル」へ"),
    ("R7 ディスクにケーブル", lambda: wm["文脈"] == "ケーブル" and wm["ケーブル"] < wm["部品"]["ディスク"],
     lambda: wm.update(ケーブル=wm["ケーブル"] + 1) or add("ケーブル", "ディスク 1 台に 1 本")),
    ("R8 おわり", lambda: wm["文脈"] == "ケーブル",
     lambda: wm.update(文脈="おわり") or "組み立て図を出力"),
]

cycle = 0
while wm["文脈"] != "おわり" and cycle < 100:
    cycle += 1
    ready = [r for r in RULES if r[1]()]          # ① 条件を満たすルールをすべて探す
    name, _, act = ready[0]                       # ② 1 つ選ぶ（ここでは表の上にあるもの＝特別なルールを優先）
    print(f"{cycle:>2} [{len(ready)} 個そろった] {name}：{act()}")   # ③ 実行して、作業のメモを書き換える

print("\n組み立て図：")
for i, box in enumerate(wm["箱"], 1):
    print(f"  箱 {i}：" + " ｜ ".join(box))
print(f"注文に無かったが追加した部品：{', '.join(wm['足した'])}")

091981・日本

模仿例句来翻译

不把语法规则写尽，也能做翻译吗？

京都大学的长尾真写道，以往的机器翻译有一个矛盾：（译）。于是他提出一种机制：像人学外语那样，让机器拥有大量英语和日语成对的例句。找出与要翻译的句子最相似的例句，替换其中的单词来翻译。这个想法写在1981年10月在北约会议上发表的稿子里。那次会议，在东京举行的第五代国际会议（10月19〜22日）的下一周。

稿子里的例子是：由例句A man eats vegetables.（人は野菜をたべる。），把He eats potatoes. 译成日语（彼はじゃがいもをたべる。）。这是因为在同义词词典里，man和he、vegetable和potato很接近。Acid eats metal. 与这个例句不相近，所以还需要另一个例句，译成（酸は金属を侵す。）。在右边的图里试一试。

2015年学会杂志的卷首文写道，从这种出发，使用大量文本数据和统计的翻译研究得到了发展。

常见说法常见说法：“长尾真1984年的论文开创了从例子来翻译的机器翻译”，常有人这么说
原始资料里：这个想法早已写在1981年10月的会议稿里。变成书是在1984年。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_example_mt.py

# u06 例文をまねて訳す：最も似た例文を探し、単語を入れ替える（長尾真さんの 1981 年の着想）
#
# どの出来事か：長尾真さんの 1981 年 10 月の原稿（記録 nagao_analogy_translation_1981）。
#   英語と日本語の対訳例文を蓄えておき、訳したい文に最も似た例文を探す。
#   対応する単語を置き換えられるか（意味が近いか）をシソーラス（類語辞典）で確認し、
#   適切であれば、例文の訳語を置き換えて訳文を作る。
# このサンプル：例文と訳は、原稿の表にある例（A man eats vegetables. など）。
#   シソーラス（単語の分類）と類似度のスコアは、このサイトが作った小さな例。
# 試してみよう：
#   - EXAMPLES から「酸は金属を侵す」の組を消すと、Sulphuric acid eats iron. はどう訳されるか
#   - 自分で例文の組と、辞書の単語を追加してみる

EXAMPLES = [  # (主語, 動詞, 目的語) の英語と、その訳の (主語, 目的語, 動詞)
    (("man", "eats", "vegetables"), ("人", "野菜", "たべる")),
    (("acid", "eats", "metal"), ("酸", "金属", "侵す")),
]
# 類語の辞書：言葉 → (仲間の名前, 日本語)。仲間の木：生き物 > 人、物 > 食べ物・化学の物・金属
THESAURUS = {
    "man": ("人", "人"), "he": ("人", "彼"), "she": ("人", "彼女"), "president": ("人", "大統領"),
    "vegetables": ("食べ物", "野菜"), "potatoes": ("食べ物", "じゃがいも"), "bread": ("食べ物", "パン"),
    "acid": ("化学の物", "酸"), "sulphuric acid": ("化学の物", "硫酸"),
    "metal": ("金属", "金属"), "iron": ("金属", "鉄"), "copper": ("金属", "銅"),
}
PARENT = {"人": "生き物", "食べ物": "物", "化学の物": "物", "金属": "物"}

def close(a, b):
    """2つの単語の類似度：同じ単語 1.0、同じ仲間 0.8、同じ上位概念 0.3、その他 0"""
    if a == b:
        return 1.0
    ga, gb = THESAURUS[a][0], THESAURUS[b][0]
    if ga == gb:
        return 0.8
    return 0.3 if PARENT[ga] == PARENT[gb] else 0.0

def translate(subj, obj):
    best, best_s = None, -1
    for (es, ev, eo), jp in EXAMPLES:
        s = close(subj, es) * close(obj, eo)  # 両方とも置き換えられるときだけ、スコアが高くなる
        print(f"   例文「{es} {ev} {eo}」との近さ {s:.2f}")
        if s > best_s:
            best, best_s = ((es, ev, eo), jp), s
    if best_s < 0.5:
        return None
    (_, _, _), (js, jo, jv) = best
    return f"{THESAURUS[subj][1]}は{THESAURUS[obj][1]}を{jv}。"

for subj, obj in [("he", "potatoes"), ("sulphuric acid", "iron"), ("acid", "vegetables")]:
    print(f"訳したい文：{subj.capitalize()} eats {obj}.")
    out = translate(subj, obj)
    print(f"   → {out if out else '似た例文がないため、訳を出力しない'}\n")
print("eat の訳が「たべる」か「侵す」かは、文法規則ではなく、似た例文によって決まった")

101982〜1986・日本

这是第几次热潮

在20世纪80年代的日本，AI的流行，当时是怎么称呼的？

在国立国会图书馆的全文检索里，1982年10月的杂志上就已经有了一句。第二个月的同一本杂志，把大约20年前的热潮称为。1985年，书里有，国会上有（意思是现在是第2次热潮），杂志专题的标题则是，数法五花八门。

起因也因作者而异，有的说是第五代计划，有的说是MYCIN的成功，有的说是费根鲍姆的知识工程，有的说是制造AI的工具。热潮正盛的时候，就已有冷冷的声音：。

1986年7月，700多人聚集起来，成立了人工智能学会。宗旨书写道，美国从1980年起就有AAAI，而。在右边的图里，一个一个地看这些叫法。

111984・期待与警告

同一场大会的两个房间

热潮之中，卖东西的人和做研究的人，看到的是同一个未来吗？

1984年8月，美国人工智能学会（AAAI）的大会在得克萨斯大学奥斯汀分校召开。在展览会场上，一款装入专家知识的AI工具TIMM的宣传册宣称（译），还写道：专家系统不会生病，不会辞职，也不会提前退休。在记者听来，卖家们的声音有时就像（译）。

在同一场大会上的讨论“AI的黑暗时代”中，主持人麦克德莫特列出了（译）。大约5年之内，美国的战略计算计划失败，日本的第五代也陷入僵局，新公司倒闭，资金断绝，每个人都把自己的研究改个名字。有人把这叫作，他说。在右边的图里推进年份，看看哪一项在什么时候发生。

常见说法常见说法：“1984年的讨论准确地预言了AI寒冬（应验的警告）”，常有人这么说
原始资料里：主持人自己说过（译）。情景的很多部分后来确实发生了，但并不是5年后一下子全部发生。

121983〜1984・常识

男性患者的“羊水”

规则里没写的事情，机器能察觉“不对劲”吗？

MYCIN的书（1984）的注释里有这样一件事。约翰·麦卡锡（译）把男性患者的检验材料（培养部位）输入为羊水，结果MYCIN没有发现错误，就接受了。因为男性没有羊水这种谁都知道的常识，规则里哪里都没写。

麦卡锡在1984年的文章《有些专家系统需要常识》中指出，MYCIN对治疗之后会怎样没有预见，连（译）也回答不了。Nilsson（2010）用“脆（brittle）”这个词来形容这类系统的弱点。

在右边的图（自行车咨询）里，试着选一个不可能的答案。加上常识的规则就能发现，但答案的种类一多，要检查是否相容的组合数就会急剧增加。

要检查的组数＝n（n − 1）／2

n: 答案（事实）的种类数。n＝100时是4,950组，1,000时是499,500组

常见说法常见说法：“据说麦卡锡取笑过MYCIN（传闻）”，常这样流传
原始资料里：MYCIN的开发者自己，在1984年的书的注释里，把写成了出处。不过麦卡锡1984年的文章里没有这件事。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_common_sense.py

# u06 常識の穴：ルールに書いていない「ありえない組み合わせ」を、システムはそのまま受け入れてしまう
#
# どの出来事か：MYCIN の本（1984）の注に書かれた話（記録 mycin_mccarthy_amniotic_1983）。ジョン・マッカーシーさんが
#   男性患者の検査材料を羊水と入力したところ、MYCIN は間違いに気づかず受け入れた。
#   マッカーシーさんは 1984 年の文章で、いくつかのエキスパートシステムには常識が必要だ、と書いた。
# このサンプル：医学ではなく自転車の相談（このサイトが作った知識）。ありえない答えを入力しても、ルールは動いてしまう。
#   「常識の決まり」（2 つの答えが両立するか）を足すと気づけるが、答えの種類 n が増えると、
#   確認する組み合わせの数は n（n − 1）／ 2 で増えていく。
# 試してみよう：
#   - COMMON_SENSE を空にすると、どうなるか
#   - n を 10・100・1000 にして、組み合わせの数を見る

FACTS = {"車輪の数": 3, "こぐと音がする": True, "チェーンの無い自転車": True, "空気を入れたのは今朝": True, "タイヤを押すとへこむ": True}

RULES = [
    (lambda f: f["こぐと音がする"], "チェーンの油切れ（確信度 0.3）"),
    (lambda f: f["タイヤを押すとへこむ"], "空気が少ない（確信度 0.9）"),
]

COMMON_SENSE = [  # 両立しない組み合わせ（このサイトが作った常識のルール）
    (lambda f: f["車輪の数"] != 2, "自転車の車輪は 2 つのはず（三輪車の相談ではない）"),
    (lambda f: f["チェーンの無い自転車"] and f["こぐと音がする"], "チェーンが無いのに、チェーンの油切れは考えられない"),
    (lambda f: f["空気を入れたのは今朝"] and f["タイヤを押すとへこむ"], "今朝入れたのにへこむなら、パンクを先に疑う"),
]

print("■ ルールだけ：")
for cond, concl in RULES:
    if cond(FACTS):
        print("   結論：", concl)

print("\n■ 常識のルールを足すと：")
for bad, why in COMMON_SENSE:
    if bad(FACTS):
        print("   おかしい！", why)

print("\n答えの種類 n と、両立するか確認する組み合わせの数 n(n-1)/2：")
for n in (5, 10, 100, 1000, 10000):
    print(f"   n = {n:>6,} → {n * (n - 1) // 2:>12,} 組")
print("常識は、書き出そうとすると膨大な数になる。この「もろさ」を、常識を大量に書き込んで乗り越えようとしたのが、1985 年の CYC プロジェクトだ。")

131985・预言

把常识写成一本百科全书

要把常识全部写进去，需要多少年？

1985年，得克萨斯州奥斯汀MCC的莱纳特等人发表了CYC计划。这是想用大量常识来克服专家系统的和获取知识的困难。今后10年，写出1卷百科全书（约3万个条目）的知识，以及它的基础常识。约400个条目由他们自己仔细地写，其余的由许多录入者复制并修改。工作量为（译）。他们还写道，如果10年左右达不到，就要大幅重新审视这个计划。

2023年，莱纳特和马库斯把CYC称为（译），知识库由数千万条手写的断言组成，并写道花了40年、2,000人年才造出来。在右边的图里推进年份看看。

不过，150人年是录入百科全书的人的工作量，2,000人年是整个知识库的工作量，计算的范围并不相同。常识要写多少才够，1985年不知道，现在也不知道。

人年＝人数 × 年数　　2,000人年 ÷ 40年＝平均50人

人年: 1个人工作1年的工作量

141982〜1987・日本

翻译软件与

用规则来翻译的机器翻译，在20世纪80年代能用到什么程度？

1982年度，国家（科学技术厅）的机器翻译计划Mu启动。这是一个要证明科技论文摘要可以在日语和英语之间互译的计划，以京都大学的长尾真等人为中心，持续到1986年。他们做出了三个阶段的语法和词典：分析句子，把结构转换成对方语言的形式，再生成句子。

企业也推出了翻译软件（1984年富士通的ATLAS，1986年5月起日立的HICATS/JE等）。1987年9月，在箱根举行的机器翻译峰会上，长尾说：（译）。他把使用者（译）的期待直言为（译），并说企业的夸大宣传也是原因之一。马自达把它用在维修手册的翻译上，起初（译）的译文只有40%，不过报告说，与富士通调整之后，正确率提高到了约80%。

在右边的图里，加入专业术语词典试试。手册里的句子能翻译了，但普通句子的翻译没有变化。

常见说法常见说法：“机器翻译真正用到实际工作中，是很久以后（21世纪10年代的深度学习翻译）的事”，常被这样认为
原始资料里：据1987年会议的记录，日本有10多家公司在销售翻译软件，也有马自达这样用在手册翻译上的企业。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_transfer_mt.py

# u06 ルールに基づく翻訳機：解析 → 変換 → 生成の 3 段階と、専門用語の追加による精度の向上
#
# どの出来事か：国の機械翻訳プロジェクト Mu（1982〜1986 年、記録 mu_mt_project_1982）と、1980 年代の日本企業の翻訳ソフト
#   （記録 japan_commercial_mt_1984_1987）。Mu の 1985 年の論文では、解析・変換・生成の 3 段階の文法と辞書が示された。
#   1987 年の会議で、マツダは翻訳ソフトで自動車の整備マニュアルを翻訳し、初めは「よい、または直せる」訳が 40% だったが、
#   富士通と調整して約 80% の精度にしたと報告した。
# このサンプル：短い英文を日本語に翻訳する、このサイトが作った小さな翻訳機（本物の Mu や ATLAS ではない）。
#   ①解析：単語の品詞を辞書で引き、主語・動詞・目的語を見つける。
#   ②変換：英語の語順（主語・動詞・目的語）を日本語の語順（主語・目的語・動詞）へ並べ替える。
#   ③生成：助詞を補って文にする。辞書にない単語があると、訳を出さずに元の単語を残す。
# 試してみよう：
#   - ADD_DOMAIN を True にして、マニュアルの文の翻訳精度がどう変わるかを見る
#   - 日常の文（EVERYDAY）の精度は変わるか

ADD_DOMAIN = False

DICT = {  # 単語 → (品詞, 訳)。n＝名詞、v＝動詞
    "the": ("det", ""), "a": ("det", ""), "mechanic": ("n", "整備士"), "checks": ("v", "点検する"),
    "replace": ("v", "交換する"), "car": ("n", "車"), "engine": ("n", "エンジン"), "he": ("n", "彼"),
    "eats": ("v", "食べる"), "bread": ("n", "パン"), "reads": ("v", "読む"), "book": ("n", "本"),
}
DOMAIN = {  # 整備マニュアルの用語（専門用語の辞書）
    "technician": ("n", "整備士"), "tightens": ("v", "締める"), "tighten": ("v", "締める"), "bolt": ("n", "ボルト"),
    "drain": ("v", "抜く"), "oil": ("n", "オイル"), "inspect": ("v", "点検する"), "brake": ("n", "ブレーキ"),
    "pads": ("n", "パッド"), "coolant": ("n", "冷却水"),
}
MANUAL = ["the technician tightens the bolt", "drain the oil", "inspect the brake pads", "replace the coolant",
          "the mechanic checks the engine"]
EVERYDAY = ["he eats bread", "a child reads the book", "he reads a letter"]

def translate(sentence, dic):
    words = sentence.split()
    tags = [dic.get(w, ("?", w)) for w in words]                      # ① 解析：辞書を引く
    if any(t == "?" for t, _ in tags):
        return None, "辞書にない：" + ", ".join(w for w, (t, _) in zip(words, tags) if t == "?")
    nouns = [tr for t, tr in tags if t == "n"]
    verb = next((tr for t, tr in tags if t == "v"), None)
    vi = next(i for i, (t, _) in enumerate(tags) if t == "v")
    subj = next((tr for t, tr in tags[:vi] if t == "n"), None)          # 動詞より前の名詞＝主語
    obj = next((tr for t, tr in tags[vi + 1:] if t == "n"), None)       # 動詞より後の名詞＝目的語
    obj = "".join(tr for t, tr in tags[vi + 1:] if t == "n") or obj     # 名詞が 2 つ続く時は連結する
    out = (f"{subj}は" if subj else "") + (f"{obj}を" if obj else "") + verb   # ② 変換 ③ 生成
    return out + "。", ""

dic = dict(DICT, **(DOMAIN if ADD_DOMAIN else {}))
for name, test in (("整備マニュアルの文", MANUAL), ("日常の文", EVERYDAY)):
    ok = 0
    print(f"■ {name}（専門用語の辞書 {'あり' if ADD_DOMAIN else 'なし'}）")
    for s in test:
        out, why = translate(s, dic)
        ok += out is not None
        print(f"   {s:<32} → {out or '（訳せない）' + why}")
    print(f"   翻訳できた割合：{ok}/{len(test)}\n")
print("ルールに基づく翻訳機は、専門辞書とルールを追加するほど、その分野では精度が上がる。ただし分野外の文の精度は上がらない。")

151985・日本

配合歌声弹奏的机器人

有人把调子唱高了一点，伴奏要怎样才能跟上？

早稻田大学的多个研究室从1980年开始准备，从1981年起制作了会演奏乐器的机器人WABOT-2。它不是什么都做的机器人，而是把目标限定在需要灵巧和智慧的上。它能用日语和人对话，用摄像头约15秒读取市售乐谱，用双手手指和双脚弹奏电子琴。自由度合计50，仅动作控制就用了53台小型计算机。

在配合歌声的机制中，它从歌声里当场生成音符数据，与记忆里的乐谱比较，找出偏差。偏差超过某个值（阈值）时，下一次演奏就会配合歌声给乐曲转调。音的高度用12进制表示，高位表示八度，低位表示半音。统管全体的控制，是用if-then形式的规则写的。在右边的图里，拖动一下歌唱者的偏差。

半音数＝12 × log₂（歌声的频率 ÷ 乐谱音的频率）

log₂: 2的几次方等于这个数
频率变成2倍: 1个八度（12个半音）

常见说法常见说法：“在筑波世博会上弹电子琴的是早稻田大学的WABOT-2”，常有人这么说
原始资料里：据开发者们1985年和1987年的论文，在科学世博会日本政府出展主题馆里演奏的，是以WABOT-2为基础、由住友电气工业制造的WASUBOT。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_transpose.py

# u06 歌声に合わせて移調する：歌の高さのずれを半音単位で測り、伴奏を移調する
#
# どの出来事か：1985 年の演奏ロボット WABOT-2（記録 wabot2_wasubot_expo85_1985）。開発者らの 1985 年の論文によると、
#   歌声トラッキングの仕組みは、歌声からその場で音符コードを生成し、記憶させた楽譜と比較して演奏と歌声のずれを検出した。
#   ずれが一定のしきい値を超えると、次の演奏時に歌声に合わせて曲を移調した。
#   音の高さは 12 進数で表し、上の桁がオクターブ、下の桁が半音の違いを表した。
# このサンプル：同じ考え方で作った小さなモデル。歌声の周波数（Hz）は、このサイトが作った数（歌う人が 3 半音高く歌い出したと仮定）。
#   半音の数 ＝ 12 × log₂（歌の周波数 ÷ 楽譜の音の周波数）
# 試してみよう：
#   - SHIFT を -2 や 0.4 に変える（しきい値より小さいずれでは移調しない）
#   - THRESHOLD を変える

import math
import random

SCORE = [60, 60, 67, 67, 69, 69, 67, 65, 65, 64, 64, 62, 62, 60]  # 楽譜の音（番号 60 ＝ ド。1 つ上がると半音上）
SHIFT = 3.0       # 歌う人が楽譜より何半音高く歌うか（このサイトが作った数）
THRESHOLD = 0.5   # これより大きなずれで移調する（このサイトが作った数）
random.seed(6)

def hz(n):
    """音の番号 → 周波数（番号 69 ＝ 440 Hz のラ）"""
    return 440 * 2 ** ((n - 69) / 12)

def note_code(n):
    """論文と同じ考え方の 12 進法：上の桁＝オクターブ、下の桁＝半音（0〜11）"""
    o, s = divmod(round(n), 12)
    return f"{o}{'0123456789AB'[s]}"

sung = [hz(n + SHIFT) * (1 + random.gauss(0, 0.01)) for n in SCORE]   # 歌声（わずかに揺れる）
diffs = [12 * math.log2(f / hz(n)) for f, n in zip(sung, SCORE)]
print("楽譜 → 歌声（音符コード）  ずれ（半音）")
for n, f, d in zip(SCORE, sung, diffs):
    print(f"  {note_code(n)} → {note_code(69 + 12 * math.log2(f / 440))}   {d:+.2f}")

mean = sum(diffs) / len(diffs)
print(f"\nずれの平均：{mean:+.2f} 半音")
if abs(mean) > THRESHOLD:
    k = round(mean)
    print(f"しきい値 {THRESHOLD} を超えた → 伴奏を {k:+d} 半音移調する")
    print("移調した伴奏：", " ".join(note_code(n + k) for n in SCORE))
else:
    print("ずれが小さいので、そのまま演奏する")

161965・模糊集合

“个子高”是从多少厘米开始？

“高个子”的分界线，是多少厘米呢？

1965年，加州大学伯克利分校的扎德在论文《模糊集合》里，对于（译）这类边界不清楚的集合，用0〜1的数（隶属度）来表示元素在多大程度上属于它。论文举的例子（译），给出了f(10)＝0.2、f(100)＝0.95等数值。

运算规则也定好了。“非A”是1 − f，“A或B”取大的一方，“A且B”取小的一方。在右边的图里，比较一下在175 cm处突然从0变成1的普通集合，和平滑变化的模糊集合。论文还写道，这与统计是完全不同的想法。

他本人在1980年回顾说，一开始就知道fuzzy（模糊）这个词带有轻视的意味。

非A：1 − f_A　A或B：max（f_A, f_B）　A且B：min（f_A, f_B）

f_A: 属于集合A的程度（0〜1）
max・min: 大的一方・小的一方

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_membership.py

# u06 ファジィ集合：「入る・入らない」ではなく、「どのくらい入るか」を 0〜1 の数で表す
#
# どの出来事か：1965 年のザデーの論文「ファジィ集合」（記録 zadeh_fuzzy_sets_1965）。
#   論文は、ものがどれくらいその集合に含まれるかを、0 から 1 の数値（所属度）で表した。
#   例として「1 よりずっと大きい実数」の集合を挙げ、f(0)=0、f(1)=0、f(5)=0.01、f(10)=0.2、f(100)=0.95、f(500)=1 とした。
#   また、「でない」は 1 − f、「または」は大きい方（Max）、「かつ」は小さい方（Min）と定めた。
# このサンプル：①論文の数値を、あいだを直線でつないで使う ②「背が高い」「重い」の度合い（このサイトが作った例）から、
#   かつ・または・でない を計算する。
# 試してみよう：
#   - tall() の 160・185 を変えて、「背が高い」の度合いの形を変える
#   - 通常の集合（175 cm 以上なら 1、それ以外は 0）と比べる

POINTS = [(0, 0), (1, 0), (5, 0.01), (10, 0.2), (100, 0.95), (500, 1)]  # 論文の例

def much_greater_than_1(x):
    for (x0, y0), (x1, y1) in zip(POINTS, POINTS[1:]):
        if x0 <= x <= x1:
            return y0 + (y1 - y0) * (x - x0) / (x1 - x0)
    return 1.0

def ramp(x, a, b):
    """a 以下で 0、b 以上で 1、その間を直線でつなぐ（このサイトが作った例）"""
    return 0.0 if x <= a else 1.0 if x >= b else (x - a) / (b - a)

def tall(cm):
    return ramp(cm, 160, 185)

def heavy(kg):
    return ramp(kg, 55, 85)

print("「1 よりずっと大きい数」の度合い（論文の数値を直線で補間）")
for x in (1, 5, 10, 50, 100, 300):
    print(f"  {x:>4} → {much_greater_than_1(x):.2f}")

print("\n背が高い（ファジィ）と通常の集合（175 cm 以上）")
for cm in (158, 168, 174, 176, 182, 190):
    print(f"  {cm} cm → ファジィ {tall(cm):.2f}   通常 {1 if cm >= 175 else 0}")

print("\nかつ・または・でない（身長 178 cm・体重 62 kg の人）")
t, h = tall(178), heavy(62)
print(f"  背が高い {t:.2f}、重い {h:.2f}")
print(f"  背が高い かつ 重い   ＝ min = {min(t, h):.2f}")
print(f"  背が高い または 重い ＝ max = {max(t, h):.2f}")
print(f"  背が高く ない        ＝ 1 − f = {1 - t:.2f}")

171987・日本

用模糊控制让地铁停下

优秀的司机，是怎样既停得准，又不让车晃的？

1987年7月15日，仙台市的地铁开通。日立制作所开发的自动驾驶装置用上了（译）。据该公司1988年的文章，它由下面三样组合而成：用（如果……那么……的形式）（译）写成的AI（知识工程）规则、取代优秀司机技术的模拟，以及把多个评价项目用0〜1的满意度表示并汇总的模糊理论。乘坐舒适度、停车位置的准确性和节能性能都得到了提高，文章称其为（译）（这是制造公司自己的话）。

右边的图是同一思路的简单例子，并不是仙台那套装置本身。用只用1条规则、混合多条规则、预测前方并选出满意度高的制动这3种方法，比较停车位置的误差和制动的变化（晃动）。

满意度＝min（停车位置的满意度, 乘坐舒适度的满意度）→ 选出最高的制动

停车位置的满意度: 预测前方，越接近目标停下就越接近1
乘坐舒适度的满意度: 制动的变化越小就越接近1（这张图里的设定）

常见说法常见说法：“模糊是家电的流行词”，常被这样认为
原始资料里：在家电之前，1987年开通的仙台市地铁的自动驾驶里就已经用上了。

随时间变化的制动强度

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_fuzzy_brake.py

# u06 ファジィ制御で電車を止める：「近くて速ければ、強めにブレーキ」のあいまいなルール
#
# どの出来事か：1987 年 7 月 15 日、仙台市の地下鉄が開業。列車の自動運転に「予見ファジィ制御」を使った
#   （記録 sendai_subway_fuzzy_ato_1987）。上手な運転士の技を、「もし〜なら〜する」の形のルールで書いた。
#   ファジィ集合そのものは、1965 年のザデーの論文から始まった（記録 zadeh_fuzzy_sets_1965）。
# このサンプル：同じ考え方の小さなモデル（仙台の装置そのものではない）。ホームの停止位置の 200m 手前から
#   時速 60km で入ってくる電車を止める。ルールはどちらも同じ 3 つ（少し→弱く、中くらい→中くらい、たくさん→強く）。
#   ①通常のルール：最も当てはまる 1 つだけを使う　②ファジィ制御：あてはまり具合に応じて 3 つを混ぜて使う。
#   停止位置の誤差と、ブレーキの強さの変わり方（乗り心地）を比べる。
# 試してみよう：
#   - OUT（ルールごとのブレーキの強さ）を変えてみる
#   - DT（制御の間隔の秒数）を 1.0 にすると、止まり方はどう変わるか

DT = 0.5           # 0.5 秒ごとに計算して制御する
MAX_DECEL = 1.2    # 最大ブレーキで 1 秒に速さが何 m/s 落ちるか（仮の数）

def tri(x, a, b, c):
    """三角形の「あてはまり具合」（0〜1）。b でいちばん 1 に近い"""
    if x <= a or x >= c:
        return 0.0
    return (x - a) / (b - a) if x < b else (c - x) / (c - b)

def need_ratio(dist, speed):
    """停止位置でちょうど止まるのに必要な減速度が、最大ブレーキの何倍か（先を読む＝予見）"""
    return speed * speed / (2 * max(dist, 0.5)) / MAX_DECEL

def memberships(dist, speed):
    ratio = need_ratio(dist, speed)                   # 1 なら最大ブレーキが必要
    few = tri(ratio, -1.0, 0.0, 0.6)                  # 必要な減速度は「少し」
    mid = tri(ratio, 0.3, 0.7, 1.0)                   # 「中くらい」
    big = min(1.0, max(0.0, (ratio - 0.8) / 0.3))     # 「たくさん」
    return few, mid, big

OUT = (0.1, 0.6, 1.0)   # ルールごとのブレーキの強さ：少し → 弱く、中くらい → 中くらい、たくさん → 強く

def fuzzy_brake(dist, speed):
    """ファジィ制御：3 つのルールを、あてはまり具合で重みをつけて混ぜる"""
    m = memberships(dist, speed)
    w = sum(m)
    return sum(mi * o for mi, o in zip(m, OUT)) / w if w else 0.0

def crisp_brake(dist, speed):
    """通常のルール：同じ 3 つのルールのうち、いちばん当てはまる 1 つだけを使う（はい・いいえ）"""
    m = memberships(dist, speed)
    return OUT[m.index(max(m))]

def run(brake):
    pos, v, t, last = 0.0, 60 / 3.6, 0.0, 0.0
    jumps, biggest = 0.0, 0.0
    while v > 0 and t < 300:
        b = brake(200 - pos, v)
        jumps += abs(b - last)
        biggest = max(biggest, abs(b - last))
        last = b
        v = max(0.0, v - b * MAX_DECEL * DT)
        pos += v * DT
        t += DT
    return 200 - pos, jumps, biggest, t

for name, f in (("通常のルール（1 つだけ使う）", crisp_brake), ("ファジィ制御（混ぜて使う）", fuzzy_brake)):
    err, jumps, biggest, t = run(f)
    print(f"{name}：停止位置の誤差 {err:+.1f} m（＋は手前）、ブレーキの強さの変化の合計 {jumps:.1f}、1 回での最大変化 {biggest:.2f}、停止まで {t:.0f} 秒")
print("ブレーキの強さの変化が小さいほど、乗っている人はがくんと揺れない")

181980〜1990・验证预言

“标准工具”变成了洗衣机

模糊理论的前景，在哪里有了答案？

1980年9月，扎德写道，模糊集合的理论已经开始被用于从工业过程控制到医疗诊断的各个领域，（译）。他没有给出期限的年份。

7年后的1987年，仙台市的地铁采用了它；1989年，48家公司成立了国际模糊工程研究所（LIFE）。1990年2月1日，松下电器推出了洗衣机“爱妻号Day Fuzzy”（愛妻号Dayファジィ）。它根据水的浑浊平静下来所需的时间，以及平静下来时的透光度，按（译）等 6条规则来决定洗涤时间。这一年新词·流行语大奖的新词类金奖，是“模糊”（ファジィ）。在右边的图里，改变污垢的量和种类看看。

洗涤时间＝Σ（符合程度 × 规则的时间）÷ Σ符合程度

符合程度: min（T的程度, V的程度）
T: 浑浊平静下来所需的时间
V: 平静下来时的透光度

透光度随时间的变化（曲线和规则都是本站自己编的例子）

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_fuzzy_washer.py

# u06 ファジィ洗濯機：水の濁り方から、洗い時間を 6 つの「もし〜なら〜」ルールで決める
#
# どの出来事か：1990 年 2 月 1 日に発売された松下電器の全自動洗濯機（記録 fuzzy_washer_ryukogo_1990 と、
#   ザデーの 1980 年の予測記録 zadeh_fuzzy_standard_tool_prediction_1980）。開発者の 1990 年の記事によると、
#   排水弁の近くで光を当て、洗濯水を通る光の強さ（透過度）を測定する。洗い始めると汚れが溶け出して透過度が下がり、
#   やがて落ち着く。落ち着くまでの時間 T（泥の汚れは早く、脂の汚れは遅い）と、落ち着いたときの透過度 V（汚れが多いほど低い）
#   から、6 つのルールのファジィ推論で洗い時間を決めた。ルールは「飽和時間が長く、かつ透過度が低ければ
#   洗濯時間をとても長くする」のような形式で、家庭で集めたデータと作る人のコツから作られた。
# このサンプル：同じ仕組みの簡易推論。6 つのルールの中身・形・時間（分）の数は、このサイトが作った例。
#   「かつ」は最小値（min）をとる。ルールごとの洗い時間を、あてはまり具合で重みをつけて平均する（後件部が数値の簡便法）。
# 試してみよう：
#   - T と V を変えて、洗い時間がなめらかに変化するか確認する
#   - ルールを 1 つ削除すると、どこで時間が急変するか確かめる

def ramp(x, a, b):
    return 0.0 if x <= a else 1.0 if x >= b else (x - a) / (b - a)

def t_short(t): return 1 - ramp(t, 60, 180)     # 落ち着くのが早い（秒）
def t_long(t): return ramp(t, 60, 180)          # 落ち着くのが遅い
def v_high(v): return ramp(v, 0.4, 0.8)         # 透過度が高い（きれい）
def v_mid(v): return 1 - abs(v - 0.55) / 0.25 if abs(v - 0.55) < 0.25 else 0.0
def v_low(v): return 1 - ramp(v, 0.3, 0.6)      # 透過度が低い（汚れが多い）

RULES = [  # (T の形, V の形, 洗い時間（分）)
    (t_short, v_high, 4), (t_short, v_mid, 7), (t_short, v_low, 10),
    (t_long, v_high, 6), (t_long, v_mid, 10), (t_long, v_low, 15),   # 飽和時間が長く、かつ透過度が低い → とても長く
]

def wash_time(T, V, show=False):
    w = [min(ft(T), fv(V)) for ft, fv, _ in RULES]
    if show:
        for (ft, fv, m), wi in zip(RULES, w):
            print(f"   もし T が{'短い' if ft is t_short else '長い'}、かつ V が{ {v_high: '高い', v_mid: '中くらい', v_low: '低い'}[fv]} なら {m:>2} 分 … あてはまり {wi:.2f}")
    return sum(wi * m for wi, (_, _, m) in zip(w, RULES)) / sum(w)

T, V = 150, 0.35   # 脂の汚れが多い場合（このサイトが作った数）
print(f"T = {T} 秒、V = {V}")
print(f"→ 洗い時間 {wash_time(T, V, show=True):.1f} 分\n")

print("T を変えたときの洗い時間（V = 0.5）")
for t in range(40, 221, 30):
    m = wash_time(t, 0.5)
    print(f"   T = {t:>3} 秒 → {m:4.1f} 分 " + "■" * round(m))

191980〜1989・维护

规则一直在增加

装入规则的AI，是不是做出来就完事了？

R1（XCON）的规则，从1980年6月的772条一路增加。DEC接手维护时约1,000条，1982年7月前后约2,000条，1984年是2,500条，到1989年，连同相关系统一共达到了17,500条。因为每当DEC推出新产品，装配的工作本身就会发生变化。

据1984年DEC的人们写的文章，要持续增加知识，每年大约需要4个人的工作量，维护（译），而且需要专门培养的人。同样在1984年，展览会场的宣传册还宣称，专家系统不会辞职，也不会退休。

新规则需要确认不与已有的规则矛盾。在右边的图里点击圆点，就会显示那时的规则数，以及两两成对的组数。

两两成对的组数＝n（n − 1）／2

n: 规则的数量。772条是297,606组，17,500条约是1亿5,300万组

常见说法常见说法：“XCON是每年节省4,000万美元的大成功AI”，常有人这么说
原始资料里：这个数字来自1989年DEC一位员工论文里（译）的估算，本站只通过Nilsson的引用核实过。1984年DEC的人们的文章里没有金额，写的是维护的功夫。

201977〜・获取知识

怎样把细管变粗

专家头脑中的知识，要怎样转移到计算机里？

1977年，费根鲍姆在特邀论文《人工智能的艺术》中写道：（译）。瓶颈，指的是像瓶子的颈部那样最狭窄的通道。也有问出来的功夫很小的例子。肺部检查的诊断程序PUFF，靠与专家不到50个小时的交流、不到10人周的功夫，做出了55条规则。

同一篇论文介绍了把管子变粗的一条路：从测量数据中自动找出规则的程序META-DENDRAL，用的是结构已知的分子。据说它找出的规则，质量与专家的规则不相上下。右边的图，是从附有答案的例子里一条一条地找出的最简单做法。

人写的规则，需要持续花功夫维护。从数据中学习的路，会在第8章和第9章里发展起来。

常见说法常见说法：“第2次热潮的AI只能靠人手工写入专家的知识，从数据中学习要等到第3次”，常被这样划分
原始资料里：写下瓶颈的1977年论文本身，就把从数据中自动找出规则的META-DENDRAL作为答案之一介绍了出来。

这是用Python写的代码，原理和“动手试试”里的一样。点击▶ 运行，结果会显示在下面。改一改数字，再运行一次试试。

u06_rule_induction.py

# u06 データからルールを見つける：人から聞き出す代わりに、正解付きのデータから「もし〜なら〜」を作る
#
# どの出来事か：1977 年のファイゲンバウムの論文（記録 feigenbaum_knowledge_bottleneck_1977）。
#   論文は、専門分野の知識を手に入れることがボトルネック（いちばん狭い通り道）の問題だった、と書いた。
#   その答えの 1 つとして、構造の分かっている分子の測定データからルールを見つけるプログラム META-DENDRAL を紹介した。
# このサンプル：分子ではなく、自転車の相談の例（このサイトが作ったデータ）。正解（原因）の付いた事例から、
#   「多くの例をまちがいなく説明できる条件」を 1 つずつ選んでルールにし、説明できた例を除いて繰り返す
#   （例を順にカバーしていくやり方。META-DENDRAL の手順そのものではない）。
# 試してみよう：
#   - EXAMPLES の正解を 1 つ変えると、見つかるルールはどう変わるか
#   - 例を減らすと、ルールはどうなるか

EXAMPLES = [  # (こぐと音, さび, 雨ざらし, へこむ, 重い, 答え)
    (1, 1, 1, 0, 0, "油切れ"), (1, 0, 1, 0, 1, "油切れ"), (1, 1, 0, 0, 0, "油切れ"), (1, 0, 1, 0, 0, "油切れ"),
    (0, 0, 0, 1, 1, "空気"), (0, 0, 1, 1, 1, "空気"), (1, 0, 0, 1, 1, "空気"), (0, 1, 0, 1, 0, "空気"),
    (0, 0, 0, 0, 1, "ブレーキ"), (0, 1, 0, 0, 1, "ブレーキ"), (0, 0, 1, 0, 1, "ブレーキ"),
]
NAMES = ["こぐと音がする", "さびている", "雨ざらし", "タイヤがへこむ", "重い"]

def conds():
    """1 つか 2 つの「〜がある／無い」の組み合わせをすべて作る"""
    single = [((i, v),) for i in range(len(NAMES)) for v in (1, 0)]
    pairs = [(a[0], b[0]) for a in single for b in single if a[0][0] < b[0][0]]
    return single + pairs

def fits(ex, cond):
    return all(ex[i] == v for i, v in cond)

def say(cond):
    return " かつ ".join(NAMES[i] + ("" if v else " でない") for i, v in cond)

left = list(EXAMPLES)
while left:
    best = None
    for cond in conds():
        covered = [ex for ex in left if fits(ex, cond)]
        labels = {ex[-1] for ex in covered}
        # 説明できる例が多く、誤りがない（答えが 1 種類だけ）条件を選ぶ。同じなら短く、「ある」の多い条件を優先する
        score = (len(covered), -len(cond), sum(v for _, v in cond))
        if len(labels) == 1 and (best is None or score > best[2]):
            best = (cond, covered, score)
    if best is None:
        print("これ以上、誤りのないルールは作れない")
        break
    cond, covered, _ = best
    print(f"見つけたルール：もし {say(cond)} なら {covered[0][-1]}（{len(covered)} 個の例を説明）")
    left = [ex for ex in left if ex not in covered]

print(f"\n{len(EXAMPLES)} 個の例から、人に聞かずにルールを作った。ただし、例にないことは分からない")

知识里有力量

把“大概”连起来的确信度

正向与反向

能问“为什么？”的机器

用场景的模板来储存知识

隐去名字来打分

乘上倍率来推测

发现缺少的部件

模仿例句来翻译

这是第几次热潮

同一场大会的两个房间

男性患者的“羊水”

把常识写成一本百科全书

翻译软件与“幻觉”

配合歌声弹奏的机器人

“个子高”是从多少厘米开始？

用模糊控制让地铁停下

“标准工具”变成了洗衣机

规则一直在增加

怎样把细管变粗

本章里尚不清楚的事

翻译软件与