第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年前後，史丹佛大學的Shortliffe等人開發了MYCIN，這個程式會向醫師建議細菌感染的用藥。醫師的知識被寫成如果（檢驗結果是……）那麼（病菌可能是……）的規則。一開始約有200條規則，到1978年增加到約500條。

每條規則都有一個表示確定程度的確信度（−1〜+1）。條件不確定時，要把規則的確信度乘以條件的確定程度。開發者的書中舉例：確信度為0.7的規則，如果其中1個條件的確定程度是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）把串接方式分成2種。正向（從資料出發）是從已知事實出發，沿著規則從「如果」走向「那麼」。反向（從目標出發）是從想確認的目標往回找，只詢問缺少的事實。MYCIN主要使用反向推論，也被稱為收集證據的程式。

在右圖（腳踏車的例子）比較這2種方式。正向會先問完所有問題，再使用規則；反向則只問與目標有關的問題。

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月，麻省理工學院（MIT）的明斯基在報告中提出一個想法：人遇到新情境時，會從記憶中取出稱為框架的結構，修改細節以符合現實。框架是表示（譯）的資料結構，帶有空白欄位（slot）。欄位中暫時放著一般情況下的值（預設值）。報告以參加小孩的生日派對為例。

在右圖讓它每次讀1句故事。寫明的值會填入欄位，沒寫的部分則用預設值，判斷為。如果與預設值不同，就會變成紫色。

明斯基先聲明，這份報告是（譯）一套完整理論而寫的，並在最後一節寫道：（譯）。他本人沒有製作框架系統，幾年後由學生們做了出來（Nilsson 2010）。

以為知道的事常見說法：「第2次熱潮的AI，就是把大量知識寫成的規則或邏輯式」，常被這樣一概而論
原始資料中：同一時期的1個重要想法，框架，則試著用帶有一般情況預期的範本來表示知識。

這是用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位感染症專家，在不知道誰開處方的情況下，每次評1份（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 使用機率和貝氏法則。專家為每條規則給出2個數：條件成立時，勝算會變成幾倍（LS）；條件不成立時，會變成幾倍（LN）。在右圖按下線索，就會沿著網路推算，機率也會改變（倍率是本站設定的示例數值）。

1982年，它根據華盛頓州Mount Tolman的地圖資料，把鉬礦床的潛力畫成 +5〜−5的地圖。

勝算 ← 勝算 × LS（是）或 × LN（否）　　機率＝勝算 ÷（1＋勝算）

勝算: 發生的機率 ÷ 不發生的機率
LS·LN: 專家決定的2個倍率

以為知道的事常見說法：「PROSPECTOR發現了人類沒能找到的礦床」，常有人這樣說
原始資料中：根據開發方的說明，那是礦業公司已經鑽了超過200個孔並找到礦床的地方，它預測出（譯）和（譯）。而且（譯）。這件事只透過其中1位開發者的書確認。

這是用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的訂單決定零件配置。1台電腦通常約有90個零件，訂單上常缺少必要的零件。R1會發現並補齊，製作配置圖。從1980年1月起，它用在DEC工廠的日常工作中。

R1會查看工作紀錄，找出所有符合條件的規則，再執行其中1條，反覆進行。1980年的論文中，規則數量為772條。每1份訂單平均執行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月NATO會議的發表稿中。那場會議是在東京第五代國際會議（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·日本

這是第幾次熱潮

1980年代日本的AI熱潮，當時怎麼稱呼？

在國立國會圖書館的全文搜尋中，1982年10月的雜誌就已經有（譯）這句話。隔月的同一本雜誌，把約20年前的熱潮稱為（譯）。1985年，書中有（譯），國會上有（譯，意思是現在是第2次熱潮），雜誌專題標題則是（譯），計算次數的方式並不一致。

起因也因作者而異，有人提到第五代計畫、MYCIN的成功、費根鮑姆的知識工程，或製作AI的工具。熱潮正盛時，就已出現（譯）這樣冷淡的聲音。

1986年7月，700多人聚集起來，成立了人工智慧學會。成立宗旨書寫道，美國從1980年起就有AAAI，但（譯）。在右圖每次看1個名稱。

111984·期待與警告

同一場大會的2個房間

熱潮之中，銷售者和研究者看到的是同一個未來嗎？

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·預言

把常識寫成1冊百科全書

把常識全部寫進去，需要幾年？

1985年，德州奧斯汀MCC的Lenat等人發表CYC計畫，想用大量常識克服專家系統的和取得知識的困難。他們打算在接下來10年內，寫出1冊百科全書（約3萬個條目）的知識，以及作為基礎的常識。約400個條目由他們自己仔細撰寫，其餘由大量輸入人員複製並修改。所需工作量約為（譯）。他們也寫道，如果約10年內做不到，就要大幅重新檢討計畫。

2023年，Lenat和Marcus把CYC稱為（譯），知識庫由數千萬條手寫陳述組成，並寫道花了40年、2,000人年才建成。在右圖推進年份看看。

不過，150人年計算的是輸入百科全書的人力，2,000人年則是整個知識庫的工作量，計算範圍不同。常識要寫多少才夠，1985年不知道，現在也不知道。

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

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

141982〜1987·日本

翻譯軟體與

依靠規則的機器翻譯，在1980年代能用到什麼程度？

1982年度，日本政府（科學技術廳）的機器翻譯計畫Mu啟動。計畫要證明科技論文摘要可以在日文和英文之間互譯，以京都大學的長尾真等人為核心，持續到1986年。他們建立了3階段的文法與詞典：分析句子、把結構轉成另一種語言的形式，再產生句子。

企業也推出翻譯軟體（1984年富士通的ATLAS、1986年5月起日立的HICATS/JE等）。1987年9月，在箱根的機器翻譯高峰會上，長尾說：（譯）。他把使用者（譯）的期待稱為（譯），並說企業誇大的宣傳也是原因之一。馬自達用它翻譯維修手冊，一開始（譯）的譯文只有40%，但報告說，與富士通調整後，正確率提高到約80%。

在右圖加入專業術語詞典試試看。手冊中的句子可以翻譯了，但一般句子的翻譯沒有改變。

以為知道的事常見說法：「機器翻譯真正用在實際工作中，是很久以後（2010年代的深度學習翻譯）的事」，常有人這樣想
原始資料中：根據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·模糊集合

「個子高」是從幾cm開始？

「高個子的人」的分界線是幾cm？

1965年，加州大學柏克萊分校的Zadeh在論文中，對（譯）這種界線不清楚的集合，用 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年的文章，它結合了以下3項：用（如果……那麼……的形式）（譯）寫成的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月，Zadeh寫道，模糊集合的理論已開始用在工業製程控制到醫療診斷等領域，（譯）。他沒有給出期限年份。

7年後的1987年，仙台市的地下鐵採用這項技術；1989年，48家公司成立國際模糊工程研究所（LIFE）。1990年2月1日，松下電器推出洗衣機「愛妻號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推出新產品，組裝工作本身就會改變。

根據DEC人員在1984年寫的文章，持續增加知識，每年約需要4個人的工作量，維護（譯），而且需要專門培訓的人員。同樣在1984年，展場宣傳冊還宣稱專家系統不會辭職，也不會退休。

新規則需要確認是否與既有規則矛盾。在右圖按下圓點，就會顯示當時的規則數量，以及2條規則配對的組合數。

2條規則配對的組合數＝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條規則。

同一篇論文介紹了其中1條讓管子變粗的路：程式META-DENDRAL能從結構已知分子的測量資料中自動找出規則。據說，它找出的規則，品質與專家的規則相當。右圖是從附有答案的例子中，每次找出1個的最簡單做法。

人寫的規則需要持續花工夫維護。從資料學習的路，會在第8章和第9章繼續發展。

以為知道的事常見說法：「第2次熱潮的AI，只能靠人手寫入專家的知識；從資料學習要到第3次才開始」，常有人這樣區分
原始資料中：寫下瓶頸問題的1977年論文本身，就把從資料自動找出規則的META-DENDRAL，介紹為1種解決方法。

這是用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)} 個の例から、人に聞かずにルールを作った。ただし、例にないことは分からない")

力量蘊含在知識之中

把「也許」串起來的確信度

正向與反向

可以問「為什麼？」的機器

用情境範本表示知識

隱藏名字再評分

乘上倍率來推估

發現缺少的零件

模仿例句來翻譯

這是第幾次熱潮

同一場大會的2個房間

男性病患的「羊水」

把常識寫成1冊百科全書

翻譯軟體與「幻想」

配合歌聲演奏的機器人

「個子高」是從幾cm開始？

用模糊控制讓地下鐵停下

「標準工具」用在洗衣機上

規則持續增加

怎麼把細管變粗

本章仍不清楚的事

把串起來的確信度

翻譯軟體與