Minotaur AI 深度解析：无需语言模型实现类 AI 推理

在上一篇文章中，我们介绍了 Minotaur——一种基于 ELC 架构、无需语言模型也无需 GPU 即可进行推理的 AI。本文将探讨为什么语言模型会像人类一样思考，回顾在它们之前人们尝试过的各种路径以及各自止步于何处，并深入剖析 Minotaur 的“大脑”如何以完全不同的方式完成同类推理：它不是模仿人类如何将思考过程落于笔端，而是直接对所推理系统的底层结构进行操作。

引言

在上一篇文章中，我们介绍了 Minotaur，这是一种基于 ELC 构建的 AI 架构，它通过“测量”而非“预测”来得出答案。我们曾展示它如何比对真实监管法规与实际执行记录：找出哪家机构违反了哪项规则、违规程度有多大、发生在何处，并能够区分真正的违规行为与记录不良的测量误差。

比对规则与记录只是思考的一种形式。当今的语言模型之所以备受推崇，是因为它们具备更广泛的能力：能够演绎、解释、诊断、权衡假说、设想如果情况不同会发生什么（反事实推理），并在接收到新信息时改变观点。一台既没有语言模型、也没有 GPU 的机器，真的能做到这一切吗？

答案是肯定的：

• Minotaur 的大脑能够执行通常被归功于大型语言模型的核心推理类型：演绎推理、归纳推理、溯因推理、系统诊断、观察与干预（seeing against doing）的区分、选择足以解开疑问的实验方案、信念修正，以及针对“提问本身会改变答案”这类历史情境进行推理。
• 它仅依靠单个普通处理器核心，在单个网络上执行单一操作，针对描述系统的问题平均每问耗时约四分之一秒，即可完成所有这些推理。
• 在由从未见过其代码的人员设计的盲测中，它在文字逻辑推理、提问会改变证人记忆的警察问讯场景，以及仅凭数据学习、诊断和预测系统行为等方面，均达到了当前语言模型的水平。

为什么语言模型的思维方式像人

大型语言模型经过训练来预测一段文本的下一个词。它通过在数千张 GPU 上运行数万亿次计算，从海量人类文本（书籍、论文、教科书、论坛和代码）中习得这一能力。

要预测一道证明题的下一个词，你必须理解推导逻辑；要预测医生病历的下一行字，你必须跟上诊断思路。世界上大部分书写文本都是人类在纸面上思考的痕迹，因此，极其擅长续写文本的模型，最终也极其擅长模仿人类的思考方式。这也是为什么只要让模型“一步一步思考”（think step by step），它的回答质量就会显著提升的原因。

因此，语言模型映照出的是人类的思考方式。它继承了我们的优势：善于解释、善于打比方、具备常识，并能理解日常口语提出的问题。但研究人员也发现，它同样继承了我们的弱点。就像人类一样，当一个逻辑论证的结论听起来符合常理时，语言模型更容易接受它；反之则很难。它们的回答会随着问题的措辞方式或各要素的排列顺序而发生偏移。而且正如人类一样，模型的解释往往是事后编造的说辞，而非得出答案的真实计算记录。

模型从未真正目睹过这个世界，它看到的只是我们用来描述世界的词句。

这意味着，如果你想要的是可被精确检验、可重放且可验证认证的推理，那么模仿人类将思考写下来的方式，或许并不是一个最佳的起点。而在语言模型出现之前，追求精确、可检验的推理恰恰是 AI 领域绝大多数研究的核心目标。

探索其他路径的七十年

在语言模型诞生前的约六十年里，人们一直在尝试构建具备推理能力的机器。每一次尝试都在取得一定进展后遭遇瓶颈并停滞不前，而它们止步的原因，恰恰解释了为什么我们最终走向了语言模型。

搜索与定理证明

1956 年，艾伦·纽厄尔（Allen Newell）、克利夫·肖（Cliff Shaw）和赫伯特·西蒙（Herbert Simon）构建了逻辑理论家（Logic Theorist），该程序证明了怀特海和罗素《数学原理》（Principia Mathematica）中的定理。他们的下一个程序通用问题求解器（General Problem Solver），试图将这种思路推广到任何可形式化为“起始状态、目标状态和一系列操作步骤”的问题上。其核心理念是：推理即搜索——通过不断尝试可行的步骤，直到抵达目标。

这种方法在简单的逻辑谜题上很奏效。但在现实世界的问题中，可能采取的步骤数量增长极其迅猛，没有任何计算机能够穷尽搜索。1973 年，提交给英国政府的《莱特希尔报告》（Lighthill report）将这一现象称为“组合爆炸”（combinatorial explosion），英国随后大幅削减了相关领域的资助。

专家系统

20 世纪 70 年代的应对方案是专家系统，它不再依赖盲目搜索，而是为机器注入知识：由人类专家总结归纳出的成百上千条形如“如果……那么……”（if this, then that）的手写规则。斯坦福大学开发的 MYCIN 系统用于为严重感染推荐抗生素，在 1979 年的评估中，其给出的建议已能与专业医生相媲美；DEC 公司的 XCON 系统用于自动化配置计算机订单，为公司节省了巨额成本。

专家系统的发展因两大原因止步。首先，每一条规则都必须从专家的脑海中挖掘出来并人工记录，这被称为“知识获取瓶颈”（knowledge acquisition bottleneck）；其次，它们非常脆弱：一旦超出既定规则覆盖的范围，系统就无法给出任何合理的回答。到 20 世纪 80 年代末，专家系统的商业市场全面崩溃。

逻辑编程

逻辑编程的目标是让机器在规范的形式逻辑中进行严格推理。这是 1972 年在马赛诞生的 Prolog 语言所押注的路线，也是日本在 1982 年至 1992 年间实施的“第五代计算机系统”（FGCS）国家级项目的核心支柱。

逻辑推理能给出确定无疑的精确答案，其衍生技术——用于检查一组条件能否同时满足的求解器（Solver）——至今每天都在用于计算机芯片的工程验证。然而，逻辑只能对已被人工形式化为逻辑命题的对象进行推理。真实世界呈现给我们的信息从来不是逻辑形式，第五代计算机项目最终未能兑现创造“思考机器”的承诺而黯然收场。

人工编纂常识

1984 年，道格拉斯·莱纳特（Douglas Lenat）启动了 Cyc 项目，试图通过纯手工录入的方式，为机器补全专家系统所缺失的人类常识：例如“水往低处流”、“人皆有母亲”、“一个物体不可能同时存在于两处”等。在随后的几十年里，其团队手动录入了数百万条此类事实。

这项工程证明了人类习以为常的常识体量是何等庞大，同时也表明仅凭人工手写录入常识是一条永远走不到尽头的道路。

概率与因果模型

从 20 世纪 80 年代后期开始，在朱迪亚·珀尔（Judea Pearl）的引领下，不确定性环境下的推理获得了严密可靠的数学基础。贝叶斯网络明确了变量之间的相互影响关系及其影响强度，使机器能够推导特定观察现象所蕴含的意义。随后，珀尔进一步厘清了“观察”（seeing）与“干预”（doing）之间的本质区别：看到地面湿了，暗示可能下雨了；但如果你自己拿水管冲洗地面，地面的湿润并不能说明任何天气状况。与此同时，雷蒙德·赖特尔（Raymond Reiter）、约翰·德·克利尔（Johan de Kleer）和布莱恩·威廉姆斯（Brian Williams）将故障诊断转化为一种精准定位复杂系统中失效组件的形式化方法。

这些是该领域中最顶尖的思想瑰宝，Minotaur 也对其进行了继承与重现。然而，这些系统必须先由人类为其构建并提供模型：无论是因果图还是每个组件的形式化描述。若只给它们一列原始数字，它们根本无法开展工作。

深度学习

自 2012 年起，在大规模数据上训练的神经网络——即深度学习——在图像和语音识别任务上全面超越了以往的所有技术。它们无需人类预先定义模型，只需要提供样本数据。

但它们学到的是统计模式，内部缺乏可用于推理的显式结构。一个学会了生产线运行规律的神经网络可以预测其产能输出，但它无法向你指出其输入端中哪一个是安全断路开关，也无法回答“如果该断路开关卡在开启位置会怎样？”的问题，因为在其网络内部根本不存在代表“断路器”并可被设置为“卡住”的实体结构。

随后，语言模型登场

基于 2017 年发表的 Transformer 架构构建的语言模型在 2022 年走向公众，并从 2024 年开始被训练在给出回答前进行逐步推理。语言模型之所以大获全胜，是因为它是迄今唯一一种“不需要人类预先输入形式化结构”的技术路线。你不需要为它编写特定问题的数学或逻辑模型；你只需用普通自然语言描述问题，它就能阅读理解。

但正如我们在上一篇文章中所讨论的，这种能力伴随着高昂的代价：推理过程必须跑在数据中心成千上万张 GPU 上、穿梭于数千亿个参数权重之间，而且输出的答案无法提供任何可供形式化验证的推导证明。

以往让机器具备推理能力的每种路径都各有其代价：

• 能够精确推理的系统，必须由人类预先手写构建模型。
• 能够从数据中学习的系统，无法提供可供逻辑推理的显式结构。
• 能够直接阅读自然语言的系统，需要依赖庞大的数据中心，且无法对其推理结果进行证明与认证。

Minotaur 正好处在这一“三难困境”的中间地带。它既可以直接接收系统描述，也能够从实际数据中自主学习系统结构；它会将系统映射为具有类型化角色的结构网络供其推理，并且推理足够精确，能够在单个普通处理器核心上对每一个给出的答案进行严格认证。

Minotaur 的大脑

ELC 背后的核心理念已在 MINOS 官方页面 上详述，上一篇文章也给出了简要说明。任何系统无论属于哪个领域，都会被抽象解读为三种核心角色：

• 某种驱动力量（能量，Energy，即 E）；
• 某种约束力量（控制，Control，即 C）；
• 以及系统自身将二者关联起来的方式（逻辑，Logic，即 L）。

E 与 C 之间绝不直接相连。驱动力量本身并不规定什么是被允许的，而约束限制也不会指明它在响应哪种驱动。二者之间的关系必须始终被明确给出，而提供这种关系正是系统逻辑（L）的本质所在。

系统中的每一个基本元素都被视为一种“分配/分流”（share）。在输入到达该元素时，一部分被允许通过，另一部分被拦截阻隔，两者的总和恒等于整体。在极端情况下，一端全量通过，另一端全量阻隔，而在二者之间则存在一个平衡点。

这是对系统的一种极小化表示（minimal representation）；MINOS 即代表“系统的极小有序表示”（minimal ordinal representation of systems）。例如，整座锅炉可以被抽象为一个单一元素：有驱动它的能量、约束它的控制条件，以及关联二者的逻辑。当需要更细粒度的分析时，同样的分析框架会递归应用到其各子部件中。于是整座锅炉被进一步细分为水泵、风机、燃烧器和燃气阀，每一个都是独立的 ELC 元素，拥有各自的驱动、约束和逻辑，并且彼此相连——一个元素传递出的输出，成为下一个元素的驱动输入。描述越发精细，但始终没有脱离 ELC 统一格式：在任何尺度层级上，都由这三个角色构成，只是被划分得更加精细、连接更加密集。

我们正是基于这种表示体系构建了 Minotaur 的大脑。

两面体系

事实证明，一个具备通用推理能力的大脑需要两种互不相同的功能，最好彼此独立分离，这有点类似于人类大脑的左右半脑。

ELC 侧负责承载正在被推理的系统，将其表现为由 ELC 元素构成的网络。它内部仅有唯一一种操作——收敛稳定（settling），下文将对此做进一步介绍。它还能够从系统过去的行为记录中，自主学习一个从未被告知过的系统。在设计层面上，它内部完全不包含计数、精确算术或文本字符串匹配。它的计算结果属于测量值：即网络在设定的公差范围内达到静止稳定状态，或者未能达到稳定。

精确侧则相当于一个计算器。它负责解析对系统的文本描述，在需要穷举检查时列出所有情况，执行精确的数学计算，并校验验证结果。它的计算结果是精确确定的：要么在所有情况下均成立，要么明确给出一个使其不成立的反例。

跨界通道

在两面之间，没有任何信息能够随意穿透，所有信息交互必须经过显式命名的单向跨界通道（crossing）：

跨界通道	方向	作用说明
DECLARE	精确侧 → ELC	将系统的某条法则构建到网络结构中
LEARN	数据 → ELC	网络根据系统行为记录自主学习该系统的一部分
OBSERVE	精确侧 → ELC	固定某一已知事实；该节点仍遵循其自身的法则
SUPPOSE	精确侧 → ELC	假想变体世界：复制系统并将部分条件作不同设置
INTERVENE	精确侧 → ELC	强制将某一节点设为指定值，并切断其原本遵循的内在法则

Minotaur AI Deep Dive: Achieving Reasoning Without a Language Model

In the last post we introduced Minotaur, an AI that reasons with no language model and no GPU. This post looks at why language models think the way people do, at what was tried before them and where each attempt stopped, and at how Minotaur’s brain does the same kinds of reasoning differently: not by imitating how people write their thinking down, but by working on the structure of the system it’s reasoning about.

Introduction

In the last post we introduced Minotaur , an AI architecture built on ELC that works out its answers by measuring rather than predicting. We showed it checking real regulations against records of how they were applied: finding which organisation broke a rule, by how much and where, and telling a broken rule from a badly recorded measurement.

Checking rules against records is one kind of thinking. Today’s language models are admired for something broader: they can deduce, explain, diagnose, weigh a hypothesis, imagine what would have happened if things had been different, and change their minds when told something new. Can a machine with no language model, and no GPU, do all of that?

The answer is yes:

• Minotaur’s brain does the main kinds of reasoning usually credited to large language models: deduction, induction, abduction, diagnosis, seeing against doing, choosing the experiment that settles a question, revising a belief, and reasoning about histories in which asking a question changes the answer.
• It does all of them with one operation on one network , on one ordinary processor core, at about a quarter of a second per question on a described system.
• On blind tests written by people who never saw its code, it matched a current language model reasoning in words, on a police interview where the questions change the witness’s memory, and on learning, diagnosing and predicting systems from their data alone.

Why a Language Model Thinks Like a Person

A large language model is trained to predict the next word of a piece of text. It learns this from an enormous amount of writing, from books, papers, textbooks, forums and code, by doing it trillions of times on thousands of GPUs.

To predict the next word of a proof, you have to follow the proof. To predict the next line of a doctor’s notes, you have to follow the diagnosis. Much of the writing in the world is people thinking on paper, so a model that gets very good at continuing it ends up very good at imitating the thinking. That’s why simply asking a model to “think step by step” makes its answers better.

So a language model mirrors the way people think. It inherits our strengths: explaining, drawing analogies, using common sense, taking a question in ordinary words. Researchers have also found that it inherits our weaknesses. Like people, language models find a logical argument easier to accept when its conclusion sounds believable, and harder when it doesn’t. Their answers can shift with how a question is framed or the order things are put in. And like ours, its explanations are often written after the fact, not a record of how the answer was reached.

The model never sees the world, only our words about it.

It does mean that if you want reasoning that can be checked, replayed and certified, imitating the way people write their thinking down may not be the best place to start. Exact, checkable reasoning was what most approaches to AI before language models were trying for.

Seventy Years of Trying Something Else

People tried to build machines that reason for some sixty years before language models. Each attempt worked up to a point and then stopped, and where they stopped explains why we ended up with language models.

Search and theorem proving

In 1956 Allen Newell, Cliff Shaw and Herbert Simon built the Logic Theorist, a program that proved theorems from Whitehead and Russell’s Principia Mathematica. Their next program, the General Problem Solver, tried to do the same for any problem that could be written as a starting point, a goal and a set of moves. The idea was that reasoning is search: try the possible steps until you reach the goal.

It worked on puzzles. On real problems the number of possible steps grows so fast that no computer could search them. In 1973 the Lighthill report to the British government named this the combinatorial explosion, and funding in Britain was cut sharply.

Expert systems

The answer in the 1970s was the expert system, which gave the machine knowledge instead of search: hundreds or thousands of hand-written rules of the form if this, then that , collected from human experts. MYCIN, built at Stanford, recommended antibiotics for serious infections, and in a 1979 evaluation its advice compared well with that of specialists. XCON, at Digital Equipment Corporation, configured computer orders and saved the company a great deal of money.

They stopped for two reasons. Every rule had to be got out of an expert’s head and written down by hand, which came to be called the knowledge acquisition bottleneck. And they were brittle: just outside what the rules covered, the system had nothing sensible to say. By the end of the 1980s the market for them had collapsed.

Logic programming

Logic programming aimed to have the machine reason exactly, in a proper logic. That was the bet behind Prolog, created in Marseille in 1972, and behind Japan’s Fifth Generation Computer Systems project, which ran from 1982 to 1992 and was built around logic programming.

Logic gives exact answers, and its descendants, the solvers that check whether a set of conditions can all be true at once, are now used every day to verify computer chips. But logic only reasons about what someone has written down as logic. The world doesn’t arrive in that form, and the Fifth Generation project ended without the thinking machines it had promised.

Hand-built common sense

In 1984 Douglas Lenat started Cyc, an attempt to write down, by hand, the common sense that expert systems lacked: that water runs downhill, that people have mothers, that a thing can’t be in two places at once. Over the following decades its team entered millions of such facts.

It showed how large the common sense people take for granted is, and that writing it down by hand never comes to an end.

Probability and causal models

From the late 1980s, led above all by Judea Pearl, reasoning under uncertainty got a proper mathematical footing. A Bayesian network says which things affect which and how strongly, and lets a machine work out what an observation implies. Pearl went on to make precise the difference between seeing something and doing it: seeing a wet pavement suggests it rained, but hosing the pavement yourself tells you nothing about the weather. In the same years, Raymond Reiter, Johan de Kleer and Brian Williams turned diagnosis into a precise method for finding which component of a system has failed.

These are some of the best ideas in the field, and Minotaur reproduces them. But someone has to hand them the model first: the causal graph, or a description of every component. Given only a column of numbers, they can’t begin.

Deep learning

From 2012, neural networks trained on large amounts of data, known as deep learning, began to beat everything else at recognising images and speech. They need nothing handed to them except examples.

What they learn is a pattern, with no structure to reason on. A network that has learned how a production line behaves can predict its output. It can’t tell you that one of its inputs is a safety cut-off, or answer the question “what if that cut-off were stuck open?”, because there’s no cut-off anywhere inside it to be stuck.

And then, language models

Language models, built on the transformer design published in 2017, reached the public in 2022, and from 2024 began to be trained to reason step by step before answering. Language models won because they’re the one approach that needs nothing handed to it. You don’t write a model of your problem for it; you describe the problem in plain words, and it reads them.

The price is the one we discussed in the last post. The reasoning runs through hundreds of billions of weights on data-centre GPUs, and the answer comes with no certificate of how it was reached.

Each way of getting a machine to reason has had a price:

• The ones that reason exactly need the model handed to them.
• The ones that learn from data give you no structure to reason on.
• The one that reads the prose needs a data centre, and can’t certify its answers.

Minotaur sits in the middle. It can be given a description or learn one from data, puts it into typed roles it can reason on, and reasons exactly enough to certify each answer, on one ordinary processor core.

Minotaur’s Brain

The ideas behind ELC are set out on the MINOS page, and the last post gave the short version. Every system, whatever it’s about, is read in three roles:

• something drives it (Energy, or E);
• something constrains it (Control, or C);
• and the system has its own way of relating the two (Logic, or L).

E and C never connect directly. A drive doesn’t say what is allowed, and a limit doesn’t say which drive it answers. The relation between them always has to be supplied, and supplying it is what the system’s logic is.

Each element of a system is read as a share. Of what arrives at it, some passes and some is held back, and the two always add up to the whole. At one end everything passes, at the other everything is held, and in between there is a balance point.

This is a minimal representation of a system; MINOS stands for the minimal ordinal representation of systems. A whole boiler can be read as a single element: something drives it, something constrains it, and its logic relates the two. When more detail is needed, the same reading is applied to its parts. The boiler becomes a pump, a fan, a burner and a gas valve, each an ELC element with its own drive, constraint and logic, connected so that what one element passes on becomes the next one’s drive. The description gets finer, but it never leaves the ELC format: it’s the same three roles at every scale, just more finely divided and more interconnected.

On this representation we built Minotaur’s brain.

Two sides

A brain that reasons in general turned out to need two kinds of faculty, best kept apart, a little like the two hemispheres of a human brain.

The ELC side holds the system being reasoned about, as a network of ELC elements. It has exactly one operation, settling , described below. It can also learn a system it has never been told about, from records of what that system did. By design, it contains no counting, no exact arithmetic and no matching of text. Its results are measured : the network came to rest, or it didn’t, to within a stated tolerance.

The exact side is a calculator. It reads a description of a system, lists every case when every case has to be checked, does exact arithmetic and checks results. Its results are exact : true in every case, or here is a case where it isn’t.

The crossings

Nothing passes between the two sides except through a named, one-way crossing :

Crossing	Direction	What it does
DECLARE	exact to ELC	a law of the system is built into the network
LEARN	data to ELC	the network learns a part of the system from records of what it did
OBSERVE	exact to ELC	a fact is held fixed; the node still obeys its own law
SUPPOSE	exact to ELC	a variant world: a copy with some things set otherwise
INTERVENE	exact to ELC	a node is forced to a value, and its own law is cut
ASK	exact to ELC	a node is left free, for the network to settle
READ	ELC to exact	a settled value is read as passes , holds or undecided
REQUEST	ELC to exact	a sum the network can’t settle is sent to the calculator

Every crossing is recorded, along with the certificate it carries. When an answer rests on several steps, it carries the weakest certificate among them.

That record is also the brain’s chain of thought. When a language model shows its reasoning, it writes a new piece of text. When Minotaur shows its reasoning, it shows the crossings it actually made, in order.

Settling

Picture the network as a set of nodes, each holding a share between “all passed” and “all held”, joined along the lines ELC allows: drives into logic, constraints into logic, logic on to logic and to constraints. Never drives straight to constraints, or back.

To ask a question, you say what each node is doing:

• some are held : these are the facts you’re given;
• some are cut : forced to a value, with their own law switched off;
• some are left free : these are the holes, the things you want to know.

The rest follow their laws. Then the network settles, a little like water finding its level:

1. Every lawful node takes the value its law gives it.
2. Minotaur measures the stress : how much of what was held fails to come back as it was held.
3. That misfit is carried backwards, but only through the logic nodes and only to the holes, so the rule that drives and constraints never connect directly applies backwards as well as forwards.
4. Each hole is pushed to commit to one end or the other: passes or holds. A hole that comes to rest at the balance point hasn’t really been answered.
5. The result is read, with its stress shown.

If the stress falls to almost nothing and every fact reads back as it was held, the world closes : there’s a way for things to be that fits everything given. If no setting of the holes will close it, the stress says where the contradiction sits.

One network, many questions

Every kind of reasoning is the same settle, asked differently. What changes is only which nodes are held, which are cut and which are left free.

The ELC side has no special code for any of these kinds of reasoning. Where an answer needs every case checked, as deduction does, the exact side lists the cases and the ELC side settles each one. So deduction gets an exact certificate, because no case is left out.

Following the Brain Through

All of the systems below were written in a simple format that lists a system’s drives, constraints and laws. The first two were written by us for development. The others were written by people who never saw Minotaur’s code, and we come to how they were tested afterwards.

A diagnosis

Start with a house’s lighting. The supply comes in through a main breaker and splits into a hall circuit and a kitchen circuit, each with its own fuse, switch and bulb, and the kitchen circuit also feeds a socket and a kettle. All the switches are on. The kitchen lamp is lit and the hall lamp is dark. What has failed?

The exact side supposes, one at a time, that each part has failed, starting with the smallest possibilities. For each supposition, the ELC side settles the network and reports whether the world closes. Supposing nothing has failed, it doesn’t close, and the stress is at the hall lamp. Supposing the hall bulb has failed, it closes. The kitchen bulb doesn’t close. The hall fuse closes. Larger combinations that already contain one of those answers are skipped, because a smaller explanation is always better. None of the rest closes.

The answer is either the hall bulb or the hall fuse , which is what a good electrician would say. Asked for an experiment to tell the two apart, Minotaur says that no setting of the switches can: both faults leave the hall dark whatever you do. That is also correct.

The same lighting circuit answered 29 questions of every kind, and all 29 matched the answers of an independent checker. On 40 planted faults it found the exact set of possible explanations 40 times out of 40, with no false ones. The whole question file took about a second and a half.

Seeing is not doing

The second system is a greenhouse watering controller, with a hidden cause in it. When it rains, the beds get wet, and the rain gauge also reads wet. When the gauge reads wet, the controller stops the pump.

Ask: if we see the gauge reading wet, are the beds wet? Minotaur holds the gauge as an observed fact, with its law intact. The misfit is carried back through the gauge to its cause, rain, and the answer is yes : the gauge says it rained, so the beds are wet.

Now ask: if we force the gauge to read wet, are the beds wet? This time the gauge is held and its own law is cut , because forcing it says nothing about what caused it. Nothing is carried back through it. The pump stops, rain stays unknown, and the answer is undetermined.

This is Pearl’s distinction between seeing and doing. In Minotaur it comes from the difference between holding a node and cutting it, not from a special rule.

A boiler, from deduction to induction

The third system was written by someone outside the project, from the format alone: a home combination boiler with 30 parts, including a timer, a pump, a fan, an igniter, a flame sensor, a gas valve, and a mains supply that feeds both the fan and the pump. Here are some of the 36 questions it was asked, with Minotaur’s answers. Each one matched the independent answer key.

Question	Minotaur’s answer
Mains on, timer on, hot tap closed, room reading 0.40, pressure reading 0.50. Must the radiators be warm?	No. Counterexample: the gas supply is off. (Exact: every case checked.)
The radiators are cold. Which of mains, gas or pump would explain it?	Any one of the three: mains, gas or pump.
The radiators are cold and the lockout light is on. Now what explains it?	The flame sensor, or the gas supply. The lockout light rules the others out.
The radiators are cold, the lockout light is off and the pump is running. Which parts could have failed?	The fan, the fuse, the igniter or the overheat stat.
Has the diverter valve failed, or the pump? What test would tell?	Close the hot tap and switch the timer on.
With the mains off: has the igniter failed, or the gas valve? What test would tell?	None. With the mains off, no test can.
Pressure gauge readings of 0.20 (low), 0.35 (fine) and 0.28 (low). Where’s the line?	Above 0.28 and at most 0.35. (Exact: the whole range the readings allow.)

Saying no test exists , as in the second-to-last row, is a valid answer, and a reasoner that always proposes a test will sooner or later propose a useless one. In the last row, Minotaur doesn’t invent a single threshold; it reports the exact range the cases seen allow, and where to look next to narrow it.

When asking changes the answer

Ordinary logic assumes that facts don’t change when you look at them, but a witness’s memory can. Ask a witness a leading question, “did he have a beard?” , and you can plant the beard you asked about.

The fourth system, again written by someone outside the project, was a police interview. It has a robbery, a witness, a line-up, a detective who may or may not ask leading questions, a lawyer who may or may not be present, and a video recorder. And it has a list of what each question does to the witness’s memory: a leading question about a beard plants one, a leading question about a jacket can wipe the jacket out, and picking someone in a line-up makes the witness more confident.

Minotaur handles this by reasoning over a chain of worlds. The first world is things as they happened. Each question produces the next world: the answer is read in the world before, and then whatever the question changes is reset. The whole chain is turned into one network and answered by the same settle.

In the diagram, the witness was asked twice, with leading questions, whether the robber had a beard, and answered no and then yes. Did the robber have a beard? Minotaur answers no. The first answer was the true memory, and the first question planted the beard behind the second.

Reasoning over fixed facts can’t do this. To it, “no” and then “yes” about the same fact is a contradiction, so it calls the story impossible. On the 15 questions whose answers depend on the order of asking, fixed-fact reasoning got 0 of 15. Minotaur got 15 of 15 , and all 30 questions in all, including one in which leading questions led to a wrongful charge. The whole set took seven and a half seconds.

Learning a system it was never told about

Everything so far started from a description of the system. The harder test is a system nobody has described.

So we gave Minotaur 400 rows of what a production line did. Each row had four readings, demand, feed, pressure and the ambient temperature, plus the line’s output. It got no laws, no diagram and no labels saying which column did what. Behind the scenes the line was driven by demand and feed, shut off by a safety cut-off when the pressure rose too high, and unaffected by the temperature. Then we broke the line, without saying how, and gave Minotaur 80 rows of what it did afterwards.

First Minotaur learned the line, into ELC’s typed roles. It found that demand and feed were drives, that pressure was a constraint that shut the line off above a certain level, and that the temperature was inert. When the network learns, the drive part and the constraint part can come out the wrong way round, each fitting the data equally well. ELC’s own algebra says how to put them back the right way round without changing anything the network does.

Then it supposed , one at a time, each kind of fault a system with those roles can have: the cut-off has moved, the cut-off is stuck open, it’s stuck shut, a drive has stopped counting. It fitted each supposition to the 80 new rows. One fitted far better than the rest: the pressure cut-off has moved to 0.557. We had planted it at 0.55.

Finally it went back out. The altered network predicted what the broken line would now do under new conditions, with an average error of 0.023, against 0.080 for the network before the fault was found.

On ten fresh lines, each with its own planted fault, Minotaur named the fault ten times out of ten and predicted the broken line’s behaviour every time, with errors between 0.002 and 0.023. Each line took about 10 to 15 seconds on one processor core, learning included.

The faults it could suppose, the cut-off has moved or a drive has gone dead , are faults of typed roles. A generic learner can fit the same 400 rows just as well, but it has no cut-off inside it to move and no drive to lose, so “what if the cut-off were stuck open?” isn’t a question it can be asked. The ELC neural network that does this learning is patent pending.

Carrying a conclusion into a second system

Our production line feeds a packing station, and the packing station keeps its own books, in kilograms a minute rather than shares. It was learned separately, from its own records alone.

MINOS holds that two systems framed independently can only be joined through a supplied relation between their frames, which we call a transport. So the exact side fitted one from 30 rows logged on both systems: how the line’s output shows up at the station, in the station’s units. Then Minotaur ran its conclusion about the broken line forward, through the transport, into the station: what will the station pack now?

On ten fresh pairs it predicted the station’s output ten times out of ten, with errors between 0.010 and 0.034. Leaving the transport out, and pretending the two systems speak the same units, made the predictions 2.6 to 12 times worse , every time. Asked to find a single fault that could be anywhere in either system, it found the right system and the right fault eight times out of ten.

Aristotle, recovered

Any new way of reasoning should first give back the old logic that we know is right. Physicists call this the correspondence principle: a new theory has to agree with the old one where the old one is secure.

So we read Aristotle’s four classical statements in ELC’s own terms. “S is P” becomes the share of S that passes into P, which MINOS writes as an angle. Every S is P is the end where everything passes. No S is P is the end where everything is held. Some S is P and some S is not P are everything short of one end or the other. Checked on every small case, 1,302 pairs of terms, every one came out right.

Then the syllogism, Aristotle’s two-premise argument such as every M is P, every S is M, so every S is P. We gave Minotaur none of the classical rules. It had only the angle, the fact that what passes and what is held always add up to the whole, and the MINOS rule for chaining two elements one after another. Out of the 256 possible forms it proved exactly the 24 that are valid, proved nothing false, and refused the other 232, each with a reason. It even said, for each argument that needs it, which term has to be non-empty for the argument to hold, which matches the classical account term by term.

One of the oldest mistakes in logic, the undistributed middle (every S is M, every P is M, so every S is P), is, in this reading, an attempt to chain two elements without a transport between their frames. It’s the same mistake, at the scale of a sentence, as leaving the transport out between the production line and the packing station.

How It Did Against a Language Model

How it was tested

Every result in this post was produced under the same rules:

1. The pass marks were written down before each run. Nothing could be tuned afterwards to fit.
2. The right answers came from someone else. Each answer was scored against a checker written separately, from the format’s rules alone, sharing no code with Minotaur.
3. The tests were blind. The boiler and the police interview were written by AI agents that saw only the format. Minotaur’s code was fingerprinted and frozen before each one was opened.
4. There was a competitor. A fresh language model, given the same system described in plain words, answered every question by reasoning in words, with no code allowed, and was scored by the same checker.
5. The claims are made only on fresh tests. Development was done on separate data.

The results

Test	What it asks	Minotaur	Language model	Reasoning over fixed facts
A police interview, 30 questions	reasoning when asking changes the answer	30 of 30	30 of 30	15 of 30; 0 of the 15 that depend on order
A production line, ten fresh lines	learn it from data, find the fault, predict it back	10 of 10 faults named; errors 0.002 to 0.023	3 of 3 (three lines); errors about the same	can’t start: nothing described
A line feeding a packing station, ten fresh pairs	carry a conclusion into a second system in other units	10 of 10 predictions; 8 of 10 faults found	3 of 3, on an earlier version of the test; errors about the same	can’t start
Aristotle’s logic	does the classical logic come back out?	1,302 of 1,302; 24 of 24 valid forms, 0 false	—	—

On the police interview and the two learned systems, Minotaur matched the language model, on one ordinary processor core and with every answer certified. Where there was nothing described to start from, reasoning over fixed facts couldn’t begin.

Where ELC Earns Its Keep

Each of the older methods does one kind of reasoning well, in its own specialty, once it’s handed a description. Minotaur does every kind with one operation, typed and certified, on one processor.

And where the system isn’t described, ELC can’t be replaced. For every other approach, the question is what it would have to be handed to do what Minotaur did.

Approach	Good at	Would have to be handed
Language models	reasoning in words	nothing, but it needs a data centre, and its answers can’t be certified or replayed exactly
Logic solvers	exact consequences and counterexamples	a written model; can’t start from data
Diagnosis engines	finding failed components	a description of every component
Causal models	seeing against doing	the causal graph and its functions; can’t learn the roles from data alone
Bayesian networks and causal discovery	learning which things affect which	the kind of relation (a cut-off, not just an influence) and the kinds of fault to suppose
Logics of actions	histories of events	the actions and their effects, written down
Neural networks	fitting data	everything needed to reason: there’s no cut-off inside to suppose stuck

ELC supplies, from its form alone, what the others have to be handed: the roles of drive, constraint and logic, the places where a fault can be, and the frames and transports between systems. In the learned tests, ELC’s own algebra decided which learned part was the drive and which the constraint. Every diagnosis was a fault of a typed role. And leaving the transport out made the predictions up to twelve times worse.

Where This Leaves Us

A language model reasons the way people do because it learned from people writing. That has made it the best general reasoner we have, and also a reasoner that inherits our habits: confident when it shouldn’t be, swayed by framing, and unable to show what its answers rest on. The alternatives of the previous seventy years either had to be handed the model or had nothing to reason on.

Minotaur’s brain reasons in a different way. It doesn’t imitate how people write about a system; it holds the system itself in ELC’s typed roles, whether described or learned from data, and answers every kind of question with one operation: hold some things, cut some, leave some free, and settle. Every answer comes with the chain of steps it actually took and a certificate of what kind of answer it is, and gives the same result every time it’s run. Head to head on blind tests, it reached the level of a current language model, on one ordinary processor.

One network, one operation, every kind of reasoning: and the working is always shown.

The ideas behind Minotaur, from the three roles of Energy, Logic and Control to the mathematics of MINOS, are set out onthe MINOS page. The mathematics itself is in the paper An Operational Representation of Systems: A Worked Construction in Lattice Gauge Theory (doi:10.5281/zenodo.23491024). The first post, Introducing Minotaur: A GPU’less AI Architecture, describes the ELC adapter and its tests on real regulations. The ELC adapter and the ELC neural network are patent pending.