日本的第五代计算机

011946〜1981・名称

为什么叫

计算机的“代”，是按什么来数的？

计算机曾经按所用的电子元件来划分代。1981年，日本情报处理开发协会（JIPDEC）出版的一本小册子，把计算机分为第1代（真空管）、第2代（晶体管）、第3代（IC，集成电路）、第3.5代（LSI，大规模集成电路）和第4代（超大规模集成电路）。册子写道，当时正是第4代的开端，而且它们几乎都遵循1946年冯·诺依曼提出的冯·诺依曼结构。

冯·诺依曼结构把指令和数据放在同一个存储器里，一条一条取出指令，按顺序执行。册子主张，要突破这种结构的弱点，就需要一种第5代。在右边的图里点一点各代的方框吧。只有第5代的元件被写成，内容是（推理、知识库、智能接口）。换代的不是元件，而是想法。

面向这个项目的调查始于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年，斯坦福大学计算机科学教授Feigenbaum，和写过AI历史书的作家McCorduck，出版了介绍日本计划的书《第五代》。在刊登该书节选的杂志文章里，两人写道，第五代只要有一部分成功，日本就会在世界信息产业中一骑绝尘，美国没有与之对抗的国家计划。他们还说，很多美国人心存怀疑，但这个国家这场赌博成功的可能性比想象的高。据历史书（Nilsson 2010），这本书加深了审议研究预算的国会的危机感。

两人是为了向美国人呼吁（译）才写的。在右边的预言时钟里拖动“当前年份”，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白皮书1991》（由通商产业省的一个课监修）写道，“从1985年前后起，‘AI热潮’一词被媒体大肆追捧”。并且说日本的热潮是第五代及其的。书中还写到，企业的高层仿佛抱着这种神话般的想法，自上而下地下令开发AI。1985年的国会上，也把AI说成。

这个词本身是从什么时候开始用的呢？在国立国会图书馆的全文检索里，把数字化的书和杂志按从旧到新排列，以AI的含义出现的最早一例，是1982年10月的杂志。《PRESIDENT》上有一句。在右边的图里搜索，先出来的是1978年和1981年的结果。它们是从书的作者名A.I. Bloomfield（日语写作“A.I.ブームフィールド”）和漫才（日本的舞台相声）的MANZAI热潮（MANZAIブーム）里读出来的字。字符串一致，不一定是同一个词。

常见说法常见说法：日本的第2次AI热潮，是日本自己的第五代让国内热闹起来的
原始资料里：据1991年通商产业省一个课监修的白皮书，日本的热潮是第五代及其的。

101984〜1988・所长的话

会招来反弹

计划进行期间，所长本人是怎么说的？

所长渕一博多次留下了抑制渲染梦想的话。1984年4月接受美国杂志采访时，他说自己长期对AI持怀疑态度，并回答说，期待在最初的10年里出应用并不现实。同年11月的主旨演讲中，他也说自己的框架是，这项计划就是要验证它，并表示不直接涉足。

在1988年的演讲中，他说这项计划。他把列为国家研究计划容易陷入的诱惑之一，并告诫说，历史上有过目标定得太高（或被误认为太高）而招来反弹的例子。

右边是表现这种想法的图（数值全部是本站的暂定值）。目标即使定得保守，只要在外界被传得很大，到了约定的年份，期待就会大幅跌落。

约定年份的期待＝实力 −（目标 × 倍率超出实力的部分）。期待的下限是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): 快了多少倍

台数与速度倍率（两者的刻度都是每次翻倍）

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亿5,600万次推理

推理的速度怎么测，又快到了什么程度？

第五代用 LIPS（每秒推理次数）来衡量推理的速度。据Nilsson（2010），1980年代初的计算机每秒约10万次，日本想把它提高到1,000倍以上。目标是每秒1亿次。

前期开发了扩展Prolog的语言ESP和单机推理的机器PSI，包括改良版在内，约500台用于研究。中期末开发了64台构成的Multi-PSI，后期开发了并行推理机PIM。据最终评估（1993），512台的PIM/p峰值为每秒1亿5,600万次，256台的PIM/m为1亿5,300万次，约为通用大型计算机的100倍。

右边的图让这个页面里的JavaScript解一道把列表倒过来的小题（30个元素，推理496次），并测量速度。PIM的一个单元处理器每秒处理30〜60万次。用右边的滑块，可以比较把各台的处理次数相加的计算例子与PIM/p的实际成绩。

LIPS＝推理次数 ÷ 秒数

推理1次: 用1次规则（本站的数法）

常见说法常见说法：第五代造出了连接1,000台计算机的推理机
原始资料里：作为一台机器，最大的是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次（拉丁方阵）。右边的图一格一格地填表来搜索，走进死胡同就退回去。只要所有的分情况都走进死胡同，就证明了这样的表不存在。满足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机上。据开发者之一的回忆，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月全部完成。

在右边的图里点“翻译一行”，逻辑的规则就会逐步被替换成一般编程语言的循环（for）和条件分支（if）。所长渕一博在1992年说，他期待这项计划诞生的，在世界各地发芽。

常见说法常见说法：第五代是1982〜1992年的计划
原始资料里：主体延长了1年，持续到1993年3月（1992年度末）。此后2年里，实施了让成果也能在UNIX计算机上运行并免费公开的计划。国家预算支持的研究全部结束，是在1995年3月。

为什么叫“第五代”

有眼、耳、口，听得懂话的计算机

从会议到研究所ICOT

用事实和规则作答

把形状对上：合一

报告书里的“日本”

《第五代》一书与预言的时钟

541亿日元，还是569亿日元？

“逆输入”的AI热潮

“过高的目标”会招来反弹

分活，以及连接的麻烦

数据没来就等着

每秒1亿5,600万次推理

机器证明了一部分未解决的问题

靠人手编出意义的词典

“失败了”，用的是哪把尺子？

专用机与普通计算机

100个软件飞散开去

这一章里，尚不清楚的事

为什么叫

会招来反弹