日本的第五代電腦

011946〜1981·名稱

為什麼叫

電腦的「世代」，是按什麼來劃分的？

電腦曾經按使用的電子元件來劃分世代。1981年，日本資訊處理開發協會（JIPDEC）出版的一本小冊子，把電腦分為第1代（真空管）、第2代（電晶體）、第3代（IC，積體電路）、第3.5代（LSI，大型積體電路）和第4代（超大型積體電路）。冊子寫道，當時正是第4代的開端，而且它們幾乎都遵循1946年馮紐曼提出的馮紐曼架構。

馮紐曼架構把指令和資料放在同一個記憶裝置裡，一次取出1條指令，依序執行。冊子主張，要突破這種結構的弱點，就需要（譯）的第5代。試著按右圖中各個世代的方框。只有第5代的元件被寫成（譯），內容則是（推論、知識庫、智慧介面）。世代交替的不是元件，而是想法。

為這項計畫進行的調查始於1979年度（委員長是東京大學的元岡達）。同樣在1979年8月，第6屆國際人工智慧聯合會議（IJCAI）在東京舉行。此前5屆的舉辦地依序是華盛頓、倫敦、史丹佛、提比里斯和劍橋。

021981·目標

有眼、耳、口，聽得懂話的電腦

1981年的文件寫道，第五代要追求什麼樣的電腦？

1981年11月JIPDEC的小冊子寫道，第5代電腦（譯），並說要（譯，也就是做出試製機），就得儘早開始研究。它列出了想要達成的樣貌，共有 8項功能。例如能直接處理聲音和影像的，能用自然語言交談，讓的（以上皆為譯文），以及具備常識、靠推論解決問題的電腦等。

右圖把分成3個階段，做了一個小例子（① 把說法改寫成邏輯問題，② 推論，③ 尋找知識）。說法稍微一變，就會卡在 ①。而「年紀比較大？」這樣的問題，如果沒有登錄父母比孩子年長這條常識，就答不出來。

1993年的最終評估報告記載，研究途中才發現，要把聲音和影像當作知識來處理，必須累積和整理龐大的背景知識。

以為知道的事常見說法：第五代承諾10年內做出像人一樣會說話的電腦
原始資料中：1981年的文件裡，確實寫著（譯）。但所長渕一博在1992年說過，1982年真正啟動的計畫，已把機器翻譯這類應用系統的開發排除在目標之外，專注於研究會推論的機器。看哪一年的哪份文件，所列的目標並不相同。

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

u07_knowledge_pipeline.py

# u07 「話がわかるコンピュータ」を小さく作る：日常の言葉 → 論理の問い → 推論 → 答え
#
# どの出来事か：1981年の冊子は、第五世代の目指す姿として「話がわかるコンピュータ」や
#   「常識ある問題解決型コンピュータ」などを挙げた（記録 fgcs_goals_prediction_1981）。
#   1993年の最終評価では、音声や画像を知識として扱うには、膨大な背景知識を蓄積して整理する必要があると
#   研究の途中で分かった、と総括された（記録 fgcs_final_evaluation_1993）。
# 仕組み：3つの段階に分ける。
#   ① 入出力（口・耳）：決まったパターンの文を、論理の問いに変換する（ここでは型の照合のみ）
#   ② 推論：事実と規則から、問いの答えを導く（後向き推論）
#   ③ 知識：事実と規則の集まり。ここに「常識」の規則がないと、答えられない問いがある
#   文のパターン・事実・規則は、このサイトが作った小さな例。
# 試してみよう：
#   - COMMON_SENSE の規則を 1 つずつ消して、どの問いに答えられなくなるか確かめる
#   - 言い回しを少し変えた問い（例：「はなこの おとうさんは だれ？」）を足す。①の段階で止まるはず

import re

FACTS = {
    ("親", "たろう", "はなこ"), ("親", "たろう", "じろう"), ("親", "うめ", "たろう"),
    ("男", "たろう"), ("男", "じろう"), ("女", "はなこ"), ("女", "うめ"),
    ("天気", "あした", "雨"),
}
RULES = [  # (頭部, [本体]) 大文字で始まる語は変数
    (("父", "X", "Y"), [("親", "X", "Y"), ("男", "X")]),
    (("祖母", "X", "Z"), [("親", "X", "Y"), ("親", "Y", "Z"), ("女", "X")]),
]
COMMON_SENSE = [
    (("年上", "X", "Y"), [("親", "X", "Y")]),                                   # 親は子より年上
    (("年上", "X", "Z"), [("親", "X", "Y"), ("年上", "Y", "Z")]),               # 年上の年上は年上
    (("要る", "かさ", "D"), [("天気", "D", "雨")]),                             # 雨の日は、傘が要る
]

# ① 文のパターン → 論理の問い
PATTERNS = [
    (r"^(\S+)の 父は だれ？$", lambda m: ("父", "W", m[1])),
    (r"^(\S+)の 祖母は だれ？$", lambda m: ("祖母", "W", m[1])),
    (r"^(\S+)は (\S+)より 年上？$", lambda m: ("年上", m[1], m[2])),
    (r"^(\S+)は かさが 要る？$", lambda m: ("要る", "かさ", m[1])),
]

is_var = lambda t: t[:1].isupper()

def subst(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def unify(a, b, env):
    if len(a) != len(b):
        return None
    env = dict(env)
    for x, y in zip(a, b):
        x, y = subst(x, env), subst(y, env)
        if x == y:
            continue
        if is_var(x):
            env[x] = y
        elif is_var(y):
            env[y] = x
        else:
            return None
    return env

def solve(goals, env, rules, depth=0, n=[0]):
    if not goals:
        yield env
        return
    if depth > 12:
        return
    g, rest = goals[0], goals[1:]
    for f in sorted(FACTS):
        e = unify(g, f, env)
        if e is not None:
            yield from solve(rest, e, rules, depth, n)
    for head, body in rules:
        n[0] += 1
        ren = lambda t: tuple(f"{x}_{n[0]}" if is_var(x) else x for x in t)
        e = unify(g, ren(head), env)
        if e is not None:
            yield from solve([ren(b) for b in body] + rest, e, rules, depth + 1, n)

def show(q):
    return f"{q[0]}({', '.join(q[1:])})"

def answer(text, rules):
    for pat, make in PATTERNS:
        m = re.match(pat, text)
        if m:
            q = make(m)
            break
    else:
        return "①で止まった：この言い回しは登録されていない"
    found = [subst("W", e) if "W" in q else "はい" for e in solve([q], {}, rules)]
    if not found:
        return f"②③で止まった：{show(q)} を導けない（知識が足りない）"
    return f"{show(q)} → " + "、".join(dict.fromkeys(found))

QUESTIONS = ["はなこの 父は だれ？", "はなこの 祖母は だれ？", "うめは はなこより 年上？",
             "あしたは かさが 要る？", "はなこの おとうさんは だれ？"]

for label, rules in (("常識の規則 なし", RULES), ("常識の規則 あり", RULES + COMMON_SENSE)):
    print(f"--- {label}（規則 {len(rules)} 個・事実 {len(FACTS)} 個）")
    for q in QUESTIONS:
        print(f"  {q:18}  {answer(q, rules)}")
print("\n文の型を合わせるだけでは、言い回しが少し変わると止まる。常識が足りないと、推論はできても答えが出ない")

031981〜1995·研究所

從會議到研究所ICOT

這項國家計畫，是由哪些人、怎麼推動的？

1981年10月19〜22日，在東京舉行。根據主辦方的小冊子，有來自15個國家的約300人參加。

1982年4月，財團「新世代電腦技術開發機構（ICOT）」成立，6月研究所開始研究。所長由電子技術綜合研究所的渕一博出任。研究人員由電子技術綜合研究所、日本電信電話公社和8家電腦公司派來，起初約40人，原則上每3〜4年輪替一次。經費全數來自通商產業省的委託費。

右圖呈現研究所的席位和輪替的人員。內田俊一（2005）寫道，包括延長的時間在內，13年間派駐ICOT的人約有200人。40個席位每3〜4年輪替一次，總人數大致就是這個數字。

曾在這裡任職的人數 ≈ S ×（1＋（T − 1）÷ L）

S: 席位數
T: 年數（13）
L: 1個人任職的年數（3〜4）

曾來任職的人數累計（逐年）

041972〜1984·邏輯程式設計

用事實和規則回答

寫程式，就只是寫步驟嗎？

1972年，馬賽的Colmerauer和Roussel創造了Prolog語言，把邏輯敘述排在一起，就直接成了程式。一同參與構想的Kowalski回憶那年夏天時說：（譯）。

在Prolog裡寫的不是計算步驟，而是事實（太郎是花子的父母之一）和規則（如果X是Y的父母之一、Y是Z的父母之一，那麼X是Z的祖父母）。問題一來，電腦就從上往下試規則，不符合就退回去試下一條（回溯）。試著按右圖的「走1步」。

第五代把邏輯程式設計放在核心位置。根據Nilsson（2010），後來成為ICOT副所長的古川康一，在1970年代於SRI接觸到Prolog，把它的處理系統帶回日本。渕一博在1984年說，他對選擇Prolog越來越有信心。

祖父母(X, Z) ← 父母(X, Y), 父母(Y, Z)

X, Y, Z: 變數
←: 右邊全部成立，左邊也就成立

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

u07_mini_prolog.py

# u07 論理プログラミング言語 Prolog の簡易実装：事実と規則から推論で問いに答える
#
# どの出来事か：1972年、マルセイユで Prolog が誕生した（記録 prolog_marseille_1972）。第五世代コンピュータ
#   プロジェクト（1982〜）は論理推論を行うマシンを目指し、1992年の並列推論マシン PIM/p（512台のコンピュータ）は
#   1秒に1億5,600万回の推論を達成した（記録 fgcs92_pim_kl1_1992。目標は1秒に1億回）。
# 仕組み：「親(たろう, はなこ)」のような事実と、「祖父母(X, Z) は 親(X, Y) かつ 親(Y, Z)」のような規則を定義する。
#   問いを入力すると、規則の左辺と問いを照合し（単一化）、右辺の条件を順に検証する。成立しなければ戻って別の道を試す（後戻り）。
#   ここでは規則を1つ適用した回数を「推論 1 回」と数える（推論速度の単位 LIPS の考え方）。
# 試してみよう：
#   - 事実を追加して、いとこや先祖を問い合わせる
#   - 最後の「1 秒に何回推論できたか」を、PIM/p の 1 億 5,600 万回と比較する

import time

# 大文字で始まる名前は「変数」、それ以外は「物の名前」
FACTS_AND_RULES = [
    (("親", "いちろう", "たろう"), []),
    (("親", "いちろう", "じろう"), []),
    (("親", "たろう", "はなこ"), []),
    (("親", "たろう", "さくら"), []),
    (("親", "じろう", "けんた"), []),
    (("祖父母", "X", "Z"), [("親", "X", "Y"), ("親", "Y", "Z")]),
    (("きょうだい", "X", "Y"), [("親", "P", "X"), ("親", "P", "Y"), ("ちがう", "X", "Y")]),
    (("いとこ", "X", "Y"), [("親", "P", "X"), ("親", "Q", "Y"), ("きょうだい", "P", "Q")]),
]
count = [0]

def is_var(t):
    return isinstance(t, str) and t[:1].isupper()

def walk(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def unify(a, b, env):
    a, b = walk(a, env), walk(b, env)
    if a == b:
        return env
    if is_var(a):
        return {**env, a: b}
    if is_var(b):
        return {**env, b: a}
    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b):
        for x, y in zip(a, b):
            env = unify(x, y, env)
            if env is None:
                return None
        return env
    return None

def rename(t, n):
    if is_var(t):
        return f"{t}_{n}"
    if isinstance(t, tuple):
        return tuple(rename(x, n) for x in t)
    return t

def solve(goals, env, depth=0):
    if not goals:
        yield env
        return
    first, rest = goals[0], goals[1:]
    if first[0] == "ちがう":   # 組み込みの規則：2つが異なる値なら成り立つ
        if walk(first[1], env) != walk(first[2], env):
            yield from solve(rest, env, depth)
        return
    for head, body in FACTS_AND_RULES:
        count[0] += 1
        n = count[0]
        e = unify(first, rename(head, n), env)
        if e is not None:
            yield from solve([rename(g, n) for g in body] + rest, e, depth + 1)

def ask(query):
    answers = []
    for env in solve([query], {}):
        answers.append({v: walk(v, env) for v in query[1:] if is_var(v)})
    return answers

print("祖父母(いちろう, Z) ？ →", ask(("祖父母", "いちろう", "Z")))
print("きょうだい(はなこ, W) ？ →", ask(("きょうだい", "はなこ", "W")))
print("いとこ(はなこ, W) ？ →", ask(("いとこ", "はなこ", "W")))

count[0] = 0
start = time.perf_counter()
for _ in range(300):
    ask(("いとこ", "A", "B"))
sec = time.perf_counter() - start
lips = count[0] / sec
print(f"\nこのコンピュータでの小さな Prolog：1 秒に約 {lips:,.0f} 回の推論（{count[0]:,} 回を {sec:.2f} 秒）")
print(f"1992 年の PIM/p（512 台）：1 秒に 1 億 5,600 万回 → この小さな Prolog の約 {156_000_000 / lips:,.0f} 倍")
print("（この Prolog は Python 上で動く、わざと読みやすくした低速な作り。速さは実装の仕方で何十倍も変わる）")

05邏輯程式設計·合一

把形式對齊：合一

問題和規則「對得上」，指的是什麼？

Prolog使用規則之前一定要做的，是合一。把問題和規則的頭部（←的左邊）從頭開始逐項比較，看看能不能在變數（內容還沒決定的盒子）裡填入值，讓兩邊變成相同的形式。父母(X, 花子)和父母(太郎, Y)，只要讓X是太郎、Y是花子，就一樣了。父母(X, 花子)和父母(太郎, 次郎)則對不上。

按右圖的「走1步」，正在比較的地方會亮成紫色。在點(X, X)裡，先填入X的值，對後面的比較也有效。如果把變數填成含有它自身的形式，例如X和f(X)，形式就會無限延續。防止這種情況的是出現檢查。

最終評估（1993）寫道，平行推論機器PIM的處理器有專用指令，用來沿著填入變數的值所形成的鏈條往下查（解參照）。

f(X, b)與f(a, Y) → X＝a, Y＝b

f: 結構的名稱
X, Y: 變數
a, b: 常數的名稱
→: 為了對齊而填入變數的值

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

u07_unify.py

# u07 単一化：変数に値を代入して、2つの式を一致させる
#
# どの出来事か：1972年にマルセイユで生まれたProlog（記録 prolog_marseille_1972）は、問いと規則の頭部を
#   「単一化」で照合して推論を進める。第五世代の並列推論マシン PIM のプロセッサには、変数の参照を
#   たどる（デレファレンス）専用の命令もあった（記録 fgcs92_pim_kl1_1992、最終評価 1993）。
# 仕組み：左右の式を先頭から順に比較する。
#   - 同じもの同士 → そのまま次へ進む
#   - 片方が変数 → その変数にもう片方を代入する（代入した値は、後で参照する時にたどる）
#   - 異なるもの同士（名前や要素の数が違う）→ 一致しない（失敗）
#   - 変数を、その変数自身を含む式に代入しようとした → 一致しない（出現検査。式が無限に続いてしまうため）
# 試してみよう：
#   - PAIRS に自分で式を追加してみる。大文字で始まる名前が変数、( ) の中が引数
#   - 出現検査（OCCURS）を False にして、最後の例がどうなるか確認する（式が f(f(f(… と無限に続いて終わらなくなる）

OCCURS = True

def parse(s):
    """'親(X, はなこ)' → ('親', 'X', 'はなこ')。入れ子にも対応"""
    s = s.replace(" ", "")
    pos = 0

def term():
        nonlocal pos
        start = pos
        while pos < len(s) and s[pos] not in "(),":
            pos += 1
        name = s[start:pos]
        if pos < len(s) and s[pos] == "(":
            pos += 1
            args = [term()]
            while s[pos] == ",":
                pos += 1
                args.append(term())
            pos += 1
            return (name, *args)
        return name
    return term()

def show(t):
    return t if isinstance(t, str) else f"{t[0]}({', '.join(show(a) for a in t[1:])})"

is_var = lambda t: isinstance(t, str) and t[:1].isupper()

def walk(t, env):
    while is_var(t) and t in env:
        t = env[t]
    return t

def occurs(v, t, env):
    t = walk(t, env)
    if t == v:
        return True
    return isinstance(t, tuple) and any(occurs(v, a, env) for a in t[1:])

def unify(a, b, env, log, depth=0):
    a, b = walk(a, env), walk(b, env)
    pad = "    " * depth
    if a == b:
        log.append(f"{pad}{show(a)} と {show(b)}：同じ → 次へ進む")
        return env
    if is_var(a) or is_var(b):
        v, t = (a, b) if is_var(a) else (b, a)
        if OCCURS and occurs(v, t, env):
            log.append(f"{pad}{v} を {show(t)} に代入したいが、中に {v} 自身が含まれている → 失敗（出現検査）")
            return None
        log.append(f"{pad}{v} ← {show(t)}")
        return {**env, v: t}
    if isinstance(a, tuple) and isinstance(b, tuple):
        if a[0] != b[0] or len(a) != len(b):
            log.append(f"{pad}{show(a)} と {show(b)}：名前か引数の数が違う → 失敗")
            return None
        log.append(f"{pad}{a[0]}(…) 同士：中身を1つずつ照合する")
        for x, y in zip(a[1:], b[1:]):
            env = unify(x, y, env, log, depth + 1)
            if env is None:
                return None
        return env
    log.append(f"{pad}{show(a)} と {show(b)}：異なる値 → 失敗")
    return None

def resolve(t, env, depth=0):
    if depth > 6:
        return "…"                      # 出現検査をしないと、式が無限に続いてしまうことがある
    t = walk(t, env)
    return t if isinstance(t, str) else (t[0], *(resolve(a, env, depth + 1) for a in t[1:]))

PAIRS = [
    ("親(X, はなこ)", "親(たろう, Y)"),
    ("親(X, はなこ)", "親(たろう, じろう)"),
    ("点(X, X)", "点(3, Y)"),
    ("箱(赤, 中(Y, 青))", "箱(X, 中(黄, Z))"),
    ("列(A, 列(B, C))", "列(1, 列(2, 列(3, 空)))"),
    ("X", "f(X)"),
]
for left, right in PAIRS:
    log = []
    env = unify(parse(left), parse(right), {}, log)
    print(f"■ {left}  と  {right}")
    for line in log:
        print("   " + line)
    if env is None:
        print("   → 一致しない\n")
    else:
        print("   → 一致：" + "、".join(f"{v} = {show(resolve(v, env))}" for v in env) + f"   式全体は {show(resolve(parse(left), env))}\n")

061982〜1984·世界的反應

報告書裡的「日本」

世界各地是為了對抗日本的計畫才行動的嗎？

東京會議之後，各地都有大型計畫啟動。英國在1982年3月，由負責資訊科技的大臣成立委員會，並在當年的報告裡建議展開一項由政府、企業和大學共同研究，為期5年、經費3億5千萬英鎊的計畫。美國方面，企業聯合成立共同研究公司MCC，國防部的研究機構DARPA在1983年10月發表了的計畫書。歐洲共同體在1983年提出了ESPRIT。

然而，這些文件描述日本的方式，卻完全不同。右圖的線條粗細，表示那份文件提到日本時的強調程度。英國的報告在正文開頭就寫道，委員會成立的契機是（譯）。歐洲的提案書只在註解裡舉例提到1次，DARPA的計畫書則一次也沒有提到日本，也沒有提到第五代。

切換到「日本方面的看法（1995）」，就變成1995年《通產研究評論》的寫法：這些全都是受到第五代啟發而誕生的計畫。

以為知道的事常見說法：世界各地為了對抗日本，開始了自己的AI計畫
原始資料中：英國的報告明確寫道，契機是日本的發表。另一方面，美國國防部研究機構的計畫書（1983年）裡，日本和第五代一次也沒有出現（歷史書寫道，它在營造說服國會的氛圍上倒是有很大影響）。歐洲的提案文件（1983年）裡，也只在註解裡作為例子出現過1次。

071983·預言

一書與預言時鐘

把日本的計畫描繪成巨大威脅的，是誰？

1983年，史丹佛大學電腦科學教授費根鮑姆，和寫過AI歷史書的作家McCorduck，出版了介紹日本計畫的書。在刊登該書節錄的雜誌文章裡，2人寫道，第五代只要有一部分成功，日本就會在世界資訊產業中獨占鰲頭，美國沒有與之對抗的國家計畫。他們還說，很多美國人心存懷疑，但這個國家這場賭注成功的可能性比想像的高。根據歷史書（Nilsson 2010），這本書加深了審議研究預算的國會的危機感。

2人是為了向美國人呼籲（譯）才寫的。拖動右邊預言時鐘的「目前年份」，1981年的小冊子、這本書、1992年所長的展望，各自到了該揭曉結果的年份，之後的情況就會顯示出來。

關於美國企業聯合成立的MCC，Nilsson寫道，到1987年第一任總裁卸任時，第五代已經不再被認為是那麼大的威脅了。

以為知道的事常見說法：第五代的威脅是日本自己誇大宣傳的
原始資料中：把日本的計畫描繪成巨大威脅並加以傳播的人裡，也有美國的AI研究者自己。這本書是為了指出美國沒有國家計畫這個問題而寫的。

081982〜1995·經費

541億日圓，還是569億日圓？

國家為第五代電腦支出了多少錢？

根據1995年《通產研究評論》刊載的表格（來源是通商產業省的資料），國家支出的預算在 1982〜1992年度的11年間約為541億日圓（前期83億、中期216億、後期242億）。之後，在1993〜1994年度2年的後續計畫又支出約28億，合計約569億日圓。從1986年度起，除一般會計（一般預算）外，還從另外設立的特別會計中支出。

拖動右邊長條圖的「加到哪一年」看看。停在1992年度是541億日圓，加到1994年度就是569億日圓。常見的「約540億日圓」（1993年的最終評估）和「570億日圓」（2017年國會上的發言等）的差別，在於統計的期間不同。按按鈕，還能顯示海外的估算。

合計＝Σ（一般會計＋特別會計）

Σ: 逐個年度加總
年度: 從4月到隔年3月

以為知道的事常見說法：國外曾認為，日本向第五代投入了巨額資金，並隱瞞了真實金額
原始資料中：1982年英國的報告寫下了（譯）的看法，而1993年的最終評估報告的是（譯），1995年的報告還刊出了各年度的明細表。海外的估算有4億5千萬美元、5億美元、8億5千萬美元，差距不小，最大的數字出自計畫結束之後寫的一部百科全書。

091982〜1991·日本的熱潮

逆向輸入的AI熱潮

日本的第2次AI熱潮，是從哪裡來的？

（由通商產業省的一個課監修）寫道，（譯）。並且說日本的熱潮是第五代及其（譯）的。書中還寫到，企業的高層似乎抱著（譯）這種神話般的想法，由上而下命令開發AI。1985年的國會上，也把AI說成（譯）。

這個詞本身是從什麼時候開始使用的呢？在國立國會圖書館的全文搜尋裡，把數位化的書和雜誌按從舊到新排列，以AI的含義出現的最早一例，是1982年10月的雜誌。上有一句（譯）。在右圖搜尋，先出現的是1978年和1981年的結果。它們是從書的作者名A.I. Bloomfield的日文寫法，以及漫才（日本的舞台相聲）的MANZAI熱潮裡辨識出來的文字。字串相同，不一定是同一個詞。

以為知道的事常見說法：日本的第2次AI熱潮，是日本自己的第五代讓國內熱絡起來的
原始資料中：根據1991年通商產業省一個課監修的白皮書，日本的熱潮是第五代及其（譯）的。

101984〜1988·所長的話

會招來反彈

計畫進行期間，所長本人是怎麼說的？

所長渕一博多次留下了勸人別把夢想說得太大的話。1984年4月接受美國雜誌訪問時，他說自己長期對AI持懷疑態度，並回答說，期待在最初的10年裡出現應用並不實際。同年11月的專題演講中，他也說自己的架構是（譯），這項計畫就是要驗證它，並表示不直接參與。

在1988年的演講中，他說這項計畫（譯）。他把（譯）列為國家研究計畫容易陷入的1種誘惑，並告誡說，歷史上有過目標訂得太高（或被誤認為太高）而招來反彈的例子。

右邊是呈現這種想法的圖（數值全都是本網站假設的）。目標即使訂得保守，只要在外界被傳得很大，到了約定的年份，期待就會大幅下降。

約定年份的期待＝實力 −（目標 × 倍率超出實力的部分）。期待的下限是0。

實力: 到期限為止實際達成的成果
目標 × 倍率: 社會所接收到的承諾

以為知道的事常見說法：第五代是國家把能說話、會思考的電腦夢想說得太大才失敗的
原始資料中：計畫進行期間，所長本人的話多半是在抑制過度的期待。不過，同一時期周遭傳開了過大的形象，這一點在其他資料裡有記錄（本章的02・07）。

111985〜1992·平行處理

分配工作，以及連接的成本

把電腦增加到512台，就能快512倍嗎？

第五代的核心是讓許多台電腦同時進行推論的平行處理。把尋找答案時按不同情況分支的樹，切成各個分支的工作，分配給各台電腦。但分支的大小不一，每次交付工作還得花費連接的時間。

在右圖增加台數看看。一開始只是依序分配的話，會有先做完而等待的電腦。讓空閒的電腦去領取剩下的工作，就能達到接近台數的速度倍數。即使如此，也不可能比完成最大的那1份工作所需的時間更早結束（樹是本網站做的例子）。

最終評估（1993）寫道，在邏輯模擬中 256台快了166倍，視問題而定，512台時能接近500倍，並把分配工作的方法（負載平衡）做成元件發布。Nilsson（2010）寫道，除了適合的特殊問題之外，很難充分發揮平行處理的優點。

S(P)＝T(1) ÷ T(P)

P: 台數
T(P): P台完成所有工作的時間（含交付工作的時間）
S(P): 速度提高的倍數

台數與速度倍數（兩者的刻度都是每次增加到2倍）

121985〜1992·GHC與KL1

資料沒來就等著

好幾台電腦使用同一份資料時，要怎麼確保順序？

要讓Prolog在好幾台電腦上同時執行很困難（Nilsson 2010）。根據渕一博1992年的演講，中期初期，研究員上田和紀提出了GHC（Guarded Horn Clauses）。室長近山隆以此為基礎設計了KL1，後期的研究全部統一使用KL1。

GHC的規則帶有守衛條件（guard）。一旦需要查看還沒有值的變數，工作就會在那裡睡著（停下來等待），值一到就醒來。選定通過守衛條件的規則之後，就不再回頭重試。在右圖中，第1台傳送數字，第2台逐一累加。下一個數字沒送到，第2台就睡著。「移除產生資料的一方」之後，所有工作都睡著不動了（死結）。

根據最終評估（1993），用KL1寫的作業系統PIMOS，第一版約有44,000行，除錯工具能自動發現死結（圖是把這個想法縮小後的例子）。

頭部 :- 守衛條件 | 本體

守衛條件: 是否可以選用的條件（沒有值就等待）
本體: 選定之後的工作

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

u07_ghc_stream.py

# u07 KL1 と GHC の並行処理：データが来るまで待ち、来たら 1 つに決めて進む
#
# どの出来事か：Prolog を多数のコンピュータで並列に動かすのは難しく、第五世代コンピュータ計画では GHC（Guarded Horn Clauses）
#   という論理プログラミング言語が作られた（Nilsson 2010）。所長の渕一博の 1992 年の講演によると、中期の初めに
#   上田和紀が GHC を提案し、それをもとに近山隆が KL1 を設計した。1993 年の最終評価報告書では、互いに通信し合うプロセスを
#   論理言語で記述する手法が、OS の PIMOS をはじめ、ほとんどの KL1 ソフトウェアで使われたと書かれている（記録 fgcs92_pim_kl1_1992）。
# 仕組み（GHC の考え方を簡略化したモデル。KL1 そのものではない）：
#   - 仕事（ゴール）は、規則の「見張り」（ガード）の条件が確かめられるまで待つ。値がまだ無い変数を見ようとすると、値が入るまで眠る（止まって待つ）
#   - 見張りが通った規則が 1 つ見つかったら、それに決めて進む（コミット。Prolog のようにバックトラックしてやり直すことはしない）
#   - 2 つの仕事が、同じ変数を通して、リスト（数の列）を少しずつ渡し合う。これが「流れ（ストリーム）」
# 試してみよう：
#   - MAX と WORK を変えてみる。WORK を 1 にすると、消費側の待機時間が短くなる
#   - PRODUCER を False にすると、だれもリストを作らないため、全部の仕事が眠ったまま止まる（デッドロック）

MAX = 5
WORK = 2          # 生成側が 1 つの数値を生成するのにかかる時間ステップ（遅いと消費側が待機する）
PRODUCER = True

class Var:
    n = 0

def __init__(self):
        Var.n += 1
        self.name, self.value, self.bound = f"S{Var.n}", None, False
        self.sleepers = []

def set(self, v, wake):
        self.value, self.bound = v, True
        wake.extend(self.sleepers)
        self.sleepers.clear()

def show(x):
    out = []
    while isinstance(x, Var) and x.bound:
        x = x.value
        if x == "nil":
            return "[" + ", ".join(out) + "]"
        head, x = x
        out.append(str(head))
    tail = x.name if isinstance(x, Var) else str(x)
    return "[" + ", ".join(out) + (" | " if out else "") + tail + "]"

# 仕事の形：(名前, 引数…)
def reduce(goal, wake):
    """1 回の書き換え（簡約）。('ok', 新しい仕事, メッセージ) か ('wait', 変数, メッセージ) を返す"""
    name = goal[0]
    if name == "gen":                         # gen(N, S)：N から MAX までの数値を S に順次出力する
        _, n, s, k = goal
        if k + 1 < WORK:
            return "ok", [("gen", n, s, k + 1)], f"gen({n}) 計算中"
        if n > MAX:
            s.set("nil", wake)
            return "ok", [], f"gen({n}) → {s.name} = []（終了）"
        s2 = Var()
        s.set((n, s2), wake)
        return "ok", [("gen", n + 1, s2, 0)], f"gen({n}) → {s.name} = [{n} | {s2.name}]"
    if name == "sum":                         # sum(S, Acc, R)：S から受け取った数値を累積加算する
        _, s, acc, r = goal
        if not s.bound:                        # 見張り：S の形が分からないうちは、決めて進めない
            return "wait", s, f"sum → {s.name} の値がまだ無いので眠る"
        if s.value == "nil":
            r["答え"] = acc
            return "ok", [], f"sum → {s.name} = [] なので 答え = {acc}"
        x, s2 = s.value
        return "ok", [("sum", s2, acc + x, r)], f"sum → {x} を受信、合計 {acc + x}"

s0, result = Var(), {}
queues = {"台1": [("gen", 1, s0, 0)] if PRODUCER else [], "台2": [("sum", s0, 0, result)]}
home = {"gen": "台1", "sum": "台2"}
sleeping = []
t = 0
while any(queues.values()) and t < 40:
    t += 1
    wake, line = [], []
    for cpu, q in queues.items():
        if not q:
            line.append(f"{cpu}：（手が空いている）")
            continue
        goal = q.pop(0)
        kind, x, msg = reduce(goal, wake)
        if kind == "ok":
            q.extend(x)
        else:
            x.sleepers.append(goal)
            sleeping.append(goal)
        line.append(f"{cpu}：{msg}")
    for g in wake:                            # 値が入った変数を待っていた仕事を起こす
        sleeping.remove(g)
        queues[home[g[0]]].append(g)
        line.append(f"（{g[0]} が起きる）")
    print(f"時刻 {t:2}  " + "   ".join(line))

print(f"\n流れたリスト：{show(s0)}")
if "答え" in result:
    print(f"答え：{result['答え']}（2 台が、同じリストの生成側と消費側に分かれて同時に動いた）")
else:
    print(f"全部の仕事が眠ったまま：デッドロック（眠っている仕事 {len(sleeping)} 個）。PIMOS のデバッガは、このような止まり方を自動で検出できた（最終評価 1993）")

131982〜1992·PIM

每1秒推論1億5,600萬次

推論的速度要怎麼測量，又快到了什麼程度？

第五代用 LIPS（每1秒的推論次數）來衡量推論的速度。根據Nilsson（2010），1980年代初的電腦每1秒約10萬次，日本想把它提高到1,000倍以上。目標是每1秒1億次。

前期開發了擴充Prolog的語言ESP和單機推論的機器PSI，包括改良版在內，約500台用於研究。中期末開發了64台組成的Multi-PSI，後期開發了平行推論機器PIM。根據最終評估（1993），512台的PIM/p峰值為每1秒1億5,600萬次，256台的PIM/m為1億5,300萬次，約為通用大型電腦的100倍。

右圖讓這個頁面裡的JavaScript解一道把串列順序反轉的小問題（30個元素，推論496次），並測量速度。PIM的1台基本處理器每1秒處理30〜60萬次。用右邊的滑桿，可以比較把各台處理量相加的計算例子與PIM/p的實際成績。

LIPS＝推論次數 ÷ 秒數

推論1次: 使用1次規則（本網站的計算方式）

以為知道的事常見說法：第五代做出了連接1,000台電腦的推論機器
原始資料中：作為1台機器，最大的是512台的PIM/p。把5種型號（512、256、256、16、16台）加起來超過1,000台，這是最終評估的寫法。

PIM的5種型號的台數

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

u07_lips_meter.py

# u07 推論速度 LIPS を測る：1 秒に何回、推論（規則の適用）ができるか
#
# どの出来事か：第五世代コンピュータプロジェクトは、推論速度を LIPS（1 秒あたりの推論回数）で測った。
#   1980 年代初めのコンピュータは 1 秒に約 10 万回で、これを 1,000 倍以上にしようとした（Nilsson 2010）。
#   目標は 1 秒に 1 億回。1992 年の並列推論マシン PIM/p（512 台）は 1 秒に 1 億 5,600 万回、PIM/m（256 台）は
#   1 億 5,300 万回を達成した（ピーク性能）。要素プロセッサ 1 台は 1 秒に 30〜60 万回の性能を持つ
#   （最終評価 1993。記録 fgcs92_pim_kl1_1992）。
# 仕組み：リストを逆順にする小さな問題（nrev）を、小さな Prolog で解かせる。長さ 30 のリストを逆順にすると、
#   規則を適用する回数（推論回数）はちょうど 496 回になる。これを繰り返し解き、かかった時間で割る。
#   ここでは「問いと決まりの頭が合って、その決まりを使った回数」を推論 1 回と数える。
# 試してみよう：
#   - N（リストの長さ）を変えて、推論回数が (N+1)(N+2)/2 になるか確かめる
#   - 最後の表で、このコンピュータの速度と、1980 年代の約 10 万回や PIM/p を比べる

import math
import time

N = 30

class V:                                     # 変数（まだ値の無い箱）
    __slots__ = ("ref",)

def __init__(self):
        self.ref = None

def deref(t):
    while isinstance(t, V) and t.ref is not None:
        t = t.ref
    return t

trail = []

def unify(a, b):
    a, b = deref(a), deref(b)
    if a is b:
        return True
    if isinstance(a, V):
        a.ref = b; trail.append(a); return True
    if isinstance(b, V):
        b.ref = a; trail.append(b); return True
    if isinstance(a, tuple) and isinstance(b, tuple) and len(a) == len(b) and a[0] == b[0]:
        return all(unify(x, y) for x, y in zip(a[1:], b[1:]))
    return a == b

def undo(mark):
    while len(trail) > mark:
        trail.pop().ref = None

cons = lambda h, t: (".", h, t)

def app_1():                                  # app([], L, L).
    L = V(); return ("app", "[]", L, L), []

def app_2():                                  # app([H|T], L, [H|R]) :- app(T, L, R).
    H, T, L, R = V(), V(), V(), V(); return ("app", cons(H, T), L, cons(H, R)), [("app", T, L, R)]

def nrev_1():                                 # nrev([], []).
    return ("nrev", "[]", "[]"), []

def nrev_2():                                 # nrev([H|T], R) :- nrev(T, RT), app(RT, [H], R).
    H, T, R, RT = V(), V(), V(), V(); return ("nrev", cons(H, T), R), [("nrev", T, RT), ("app", RT, cons(H, "[]"), R)]

DB = {"app": [app_1, app_2], "nrev": [nrev_1, nrev_2]}
count = 0

def solve(goals):
    global count
    if not goals:
        yield True
        return
    g, rest = goals[0], goals[1:]
    for make in DB[g[0]]:
        head, body = make()
        mark = len(trail)
        if unify(head, g):
            count += 1
            yield from solve(body + rest)
        undo(mark)

def to_list(xs):
    t = "[]"
    for x in reversed(xs):
        t = cons(x, t)
    return t

def from_list(t):
    out = []
    t = deref(t)
    while t != "[]":
        out.append(deref(t[1])); t = deref(t[2])
    return out

R = V()
count = 0
next(solve([("nrev", to_list(list(range(1, N + 1))), R)]))
print(f"nrev（{N} 個）の答え：{from_list(R)[:8]} …")
print(f"推論回数：{count}（(N+1)(N+2)/2 = {(N + 1) * (N + 2) // 2}）")
undo(0)

count, runs, start = 0, 0, time.perf_counter()
while time.perf_counter() - start < 0.8:
    R = V()
    next(solve([("nrev", to_list(list(range(N))), R)]))
    undo(0)
    runs += 1
sec = time.perf_counter() - start
lips = count / sec
print(f"{runs} 回解いて {count:,} 回の推論を {sec:.2f} 秒 → このコンピュータ上の小さな Prolog：1 秒に約 {lips:,.0f} 回\n")

rows = [
    ("この Python の小さな Prolog（測定値）", lips),
    ("1980 年代初めのコンピュータ（Nilsson）", 1e5),
    ("PIM の要素プロセッサ 1 台（30〜60 万回の下限）", 3e5),
    ("第五世代の目標", 1e8),
    ("PIM/m（256 台）", 153e6),
    ("PIM/p（512 台）", 156e6),
]
for name, v in rows:
    print(f"{name:34} {v:15,.0f}  " + "■" * max(1, round(math.log10(v) * 3)))
print("（■ は 10 倍ごとに 3 つ。ピーク性能は、実際の問題で出る速度とは異なる）")
print(f"\n1 台 30 万回 × 512 台 = {3e5 * 512:,.0f} 回。PIM/p の 1 億 5,600 万回は、プロセッサ台数にほぼ比例して高速化した計算になる")

141992·定理證明

機器證明了一部分未解問題

電腦要怎麼證明「沒有這種東西」？

根據最終評估（1993），PIM上的定理證明程式MGTP，自動證明了加拿大數學家Bennett提出的擬群未解問題的一部分。它用256台達到200倍以上的速度，還設法抑制了按不同情況分支造成的組合爆炸。渕一博在1992年說，這個證明器也被用作進行法律推論的系統的推論引擎。

擬群的乘法表是這樣一種表：每一行、每一列裡，各個符號都恰好出現1次（拉丁方陣）。右圖每次填入1格來搜尋，遇到死路就退回去。只要所有的分支都走到死路，就證明了這樣的表不存在。滿足x*x＝x和x*y＝y*x的表，在3、5時能找到，在4、6時不存在（條件是本網站選的例子）。

x*x＝x, x*y＝y*x

x*y: 第x行、第y列格子裡的符號
預先檢查: 提早發現沒有符號可填的格子，藉此停止搜尋

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

u07_latin_square.py

# u07 機械が証明する：場合分けをすべてたどって、「そんな表は無い」まで確かめる
#
# どの出来事か：PIM の上で動いた定理証明プログラム MGTP は、カナダの数学者 Bennett が提示した
#   「準群」の未解決問題の一部を自動で証明した。場合分けで起きる組み合わせ爆発を抑える工夫も施された
#   （最終評価 1993。記録 fgcs_final_evaluation_1993、fgcs92_pim_kl1_1992）。
# 仕組み：準群の掛け算の表は、どの行にもどの列にも同じ記号が 1 回ずつ現れる表（ラテン方陣）。
#   条件を満たす表を、マスを 1 つずつ埋めながら探索する。行き詰まったら 1 つ戻って別の記号を試す（バックトラック法）。
#   すべての場合分けで行き詰まれば「条件を満たす表は無い」ことの証明になる。
#   「先読み」を行うと、マスを埋めた時点で、残りの空きマスに入る記号がなくなった枝を早く切り捨てられる。
#   ここで試す条件（どの x も x*x = x、x*y = y*x）は、このサイトが選んだ例。Bennett の問題そのものではない。
# 試してみよう：
#   - n を 3〜7 で変えて、表がある大きさとない大きさを確認する
#   - 調べたマスの数（場合分けの数）を、先読みあり・なしで比べる。表がない大きさ（4・6）で差が出る

import time

PRUNE = True

def search(n, idem, comm, prune):
    T = [[None] * n for _ in range(n)]
    nodes = 0
    cells = [(r, c) for r in range(n) for c in range(n) if not (idem and r == c) and not (comm and c < r)]
    if idem:
        for i in range(n):
            T[i][i] = i

def ok(r, c, v):
        return all(T[r][k] != v for k in range(n)) and all(T[k][c] != v for k in range(n))

def alive():                                 # 先読み：空いているマスに、まだ入れられる記号があるか調べる
        for r in range(n):
            for c in range(n):
                if T[r][c] is None and not any(ok(r, c, v) for v in range(n)):
                    return False
        return True

def put(i):
        nonlocal nodes
        if i == len(cells):
            return True
        r, c = cells[i]
        for v in range(n):
            if ok(r, c, v) and (not comm or r == c or ok(c, r, v)):
                nodes += 1
                T[r][c] = v
                if comm:
                    T[c][r] = v
                if (not prune or alive()) and put(i + 1):
                    return True
                T[r][c] = None
                if comm:
                    T[c][r] = None
        return False

found = put(0)
    return found, T, nodes

for n in range(3, 8):
    t0 = time.perf_counter()
    found, T, nodes = search(n, idem=True, comm=True, prune=PRUNE)
    sec = time.perf_counter() - t0
    other = search(n, idem=True, comm=True, prune=not PRUNE)[2]
    print(f"n = {n}：x*x = x と x*y = y*x を満たす表は {'ある' if found else 'ない（すべての場合分けで行き詰まった）'}")
    print(f"      調べたマス：先読み{'あり' if PRUNE else 'なし'} {nodes:,}（{sec:.3f} 秒）／ 先読み{'なし' if PRUNE else 'あり'} {other:,}")
    if found and n <= 5:
        for row in T:
            print("      " + " ".join("abcdefg"[v] for v in row))
print("\n先読み（PRUNE）を無効にすると、同じ結果でも調べる場合分けが増える。表があるときは1つ示せば済むが、ないときはすべて調べる必要がある")

151986〜1995·電子化詞典

靠人手編出意義的詞典

要讓電腦處理詞語的意義，需要什麼？

1986年4月，為了建立讓電腦處理日常語言的基礎，製作大型「電子化詞典」的「日本電子化詞典研究所（EDR）」9年計畫啟動了。它由連結單字和意義（概念）的「單字詞典」、表示概念上下位關係的「概念詞典」、記錄詞語搭配的「共現詞典」、日英「雙語對譯詞典」等組成。

右圖借用這個想法，做了一部小詞典。日文的「atsui」（可表示厚、燙、天氣熱），靠一起出現的詞語組合來選擇意義。即使沒有直接的組合，沿著概念往上找（咖啡 → 飲料），如果有組合也能選出意義。

目前的介紹頁面寫的是：日文單字約27萬個，概念約41萬個，共現約90萬句。最終評估也寫道，蒐集語言之外的知識，光靠ICOT是有限度的，因此寄望於EDR和美國MCC的CYC。

得分＝有直接共現時為2，沒有直接共現但上位概念有共現時為1，兩者都沒有時為0

共現: 一起出現的詞語組合
得分的決定方式: 本網站自訂的計分

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

u07_cooccurrence.py

# u07 電子化辞書で言葉の意味を判別する：単語 → 概念、概念の上位・下位、共起
#
# どの出来事か：1986〜1995年、日本電子化辞書研究所（EDR）は、コンピュータが日本語と英語の意味を扱うための
#   大規模な辞書を手作業で作成した。単語と概念（意味）を結ぶ単語辞書、概念どうしの上位・下位関係を記述する概念辞書、
#   共起（いっしょに使われる言葉の組み合わせ）を記録した共起辞書などからなる（記録 edr_electronic_dictionary_1986）。
#   現在の案内ページでは、日本語単語約27万語、概念約41万、日本語共起約90万句。
# 仕組み（EDRの辞書の仕組みを参考にした、このサイト独自の小さな例）：
#   ① 単語辞書で、読みから意味の候補（概念）を引く：「あつい」→ 厚い・熱い・暑い
#   ② 共起辞書に、候補といっしょに使われる組み合わせがあれば加点する
#   ③ 組み合わせがなくても、概念辞書で上位概念（例：コーヒー → 飲み物）にさかのぼって一致すれば少し加点する
#   もっとも得点の高い候補を、その文での意味として選ぶ。
# 試してみよう：
#   - SENTENCES に「あつい スープ」「あつい ふろ」を足す。辞書に何を足せば正しく判別できるか
#   - UPPER（上位概念）の行を消すと、③が使えずに判別できない文が出る

WORDS = {  # 読み → 意味の候補（概念）
    "あつい": ["厚い", "熱い", "暑い"],
    "ほん": ["本"], "おちゃ": ["お茶"], "コーヒー": ["コーヒー"], "きょう": ["今日"], "なつ": ["夏"],
    "じしょ": ["辞書"], "へや": ["部屋"], "スープ": ["スープ"],
}
UPPER = {  # 概念 → 上位概念（概念の上位・下位関係）
    "本": "平たい物", "辞書": "本", "お茶": "飲み物", "コーヒー": "飲み物", "スープ": "食べ物",
    "今日": "時", "夏": "時", "部屋": "場所", "平たい物": "物", "飲み物": "物", "食べ物": "物",
}
COOC = {  # 共起：いっしょに使われる意味の組み合わせ
    ("厚い", "本"), ("厚い", "平たい物"), ("熱い", "お茶"), ("熱い", "飲み物"), ("暑い", "夏"), ("暑い", "時"),
}

def uppers(c):
    out = []
    while c in UPPER:
        c = UPPER[c]
        out.append(c)
    return out

def decide(words):
    amb = [w for w in words if len(WORDS.get(w, [])) > 1][0]
    others = [WORDS[w][0] for w in words if w != amb]
    score = {}
    why = {}
    for sense in WORDS[amb]:
        s, reason = 0, []
        for o in others:
            if (sense, o) in COOC:
                s += 2; reason.append(f"{sense}+{o}（共起）")
            else:
                for u in uppers(o):
                    if (sense, u) in COOC:
                        s += 1; reason.append(f"{sense}+{o}→{u}（上位概念）")
                        break
        score[sense], why[sense] = s, reason
    best = max(score.values())
    winners = [k for k, v in score.items() if v == best]
    return amb, score, why, (winners[0] if best > 0 and len(winners) == 1 else None)

SENTENCES = [["あつい", "ほん"], ["あつい", "おちゃ"], ["あつい", "コーヒー"], ["あつい", "じしょ"], ["きょう", "あつい"], ["あつい", "へや"]]
for words in SENTENCES:
    amb, score, why, pick = decide(words)
    print(f"「{' '.join(words)}」の「{amb}」：" + "  ".join(f"{k} {v} 点" for k, v in score.items()))
    for k in score:
        if why[k]:
            print(f"      {k}：{'、'.join(why[k])}")
    print(f"   → {pick if pick else '判別できない（辞書に手がかりがない）'}\n")
print("EDRの辞書（現在の案内ページ）：日本語単語 約27万語・概念 約41万・日本語共起 約90万句を手作業で作成した")

161992〜1995·評估

「失敗了」，用的是哪把尺？

第五代是成功了，還是失敗了？

1992年6月，在發表成果的國際會議FGCS'92之後，報紙The Baltimore Sun的社論寫道，這項計畫的（譯）。但在那次會議的專題演講裡，所長渕一博介紹說：（譯）。渕解釋說，這類評論的源頭是1981年會議上描述的宏大想像，而1982年啟動的計畫內容要保守得多，並表示自己相信這是成功的。

1993年的最終評估按目標彙整了成果。推論速度超過目標，但透過聲音和影像與人互動的機制，尚未做到實際建成的程度。整體而言，它寫道（譯）。1995年的《通產研究評論》認為，因為沒有成為產品就說失敗的看法，沒有充分理解計畫的理念，但同時寫道，硬體的機制可能不會用在未來的技術上。Nilsson（2010）寫道，很多人認為，多數成果如今只有歷史意義。在右圖切換衡量的尺，同一項計畫的成績單就會改變。

以為知道的事常見說法：第五代失敗了（日本也承認了）
原始資料中：1992年的會議上，所長並未承認失敗，而是解釋說，認為失敗的評論源自1981年的宏大想像。最終評估也是按目標分開寫的。做出的電腦和軟體沒有在社會上普及這一點，《通產研究評論》和外部研究者的書都有指出。把什麼當作目標，答案就不同。

171987〜1995·小型化

專用機與一般電腦

世界上最快的電腦，為什麼沒有普及？

PIM的推論速度約為通用大型電腦的100倍。然而根據Nilsson（2010），就連一般的工作站和個人電腦，效能也提高了，超越了PIM。《通產研究評論》（1995）也寫道，由於小型化（轉向使用小型電腦）等變化，硬體的機制可能不會用在未來的技術上。

在右圖調整一般機器的成長方式看看。專用機的速度停留在製造時的水準。即使差100倍，只要一般機器每年變成1.5倍，大約11年就追上了（成長方式是假設的數值）。

同樣的事也發生在AI專用的Lisp機器上。根據1位開發者的回憶，Lisp在Sun等工作站上也能順利執行了，專用機的優勢突然變小。1991年的白皮書也寫道，日本用於AI的電腦，以個人電腦等一般機型為主。

n＝log（差距）÷ log（G）

n: 追上所需的年數
差距: 最初的速度差（100）
G: 一般機器1年變成幾倍

181992〜1995·後續

100套軟體散播出去

國家的計畫結束時，做出的成果怎麼了？

第五代的主體比預定的10年延長了1年，於1993年3月結束。從4月起，又持續了2年。開發出的軟體只能在專用的平行推論機器上執行，因此開發了把KL1轉換成C語言的語言處理系統KLIC，讓軟體在當時開始普及的UNIX平行機器等設備上也能執行。

軟體以「ICOT自由軟體」的名義免費公開。1992年6月的FGCS'92公開了71套，1993年6月新增6套，1994年11月新增包括KLIC在內的7套，1995年3月底新增16套，合計100套。對於著作權屬於ICOT而非國家的軟體，移除了會妨礙研究的限制後公開。由國家預算支持的研究，於1995年3月全部完成。

按右圖的「翻譯1行」，邏輯規則就會逐步轉換成一般程式語言的迴圈（for）和條件分支（if）。所長渕一博在1992年說，他期待這項計畫誕生的（譯），在世界各地發芽。

以為知道的事常見說法：第五代是1982〜1992年的計畫
原始資料中：主體延長了1年，持續到1993年3月（1992年度末）。此後2年間，實施了讓成果也能在UNIX電腦上執行並免費公開的計畫。國家預算支持的研究全部結束，是在1995年3月。

為什麼叫「第五代」

有眼、耳、口，聽得懂話的電腦

從會議到研究所ICOT

用事實和規則回答

把形式對齊：合一

報告書裡的「日本」

『第五代』一書與預言時鐘

541億日圓，還是569億日圓？

逆向輸入的AI熱潮

「過高的目標」會招來反彈

分配工作，以及連接的成本

資料沒來就等著

每1秒推論1億5,600萬次

機器證明了一部分未解問題

靠人手編出意義的詞典

「失敗了」，用的是哪把尺？

專用機與一般電腦

100套軟體散播出去

這一章裡，尚不清楚的事

為什麼叫

一書與預言時鐘

會招來反彈