SapienTronic AI (previously called Minotaur AI) reasons by measuring rather than predicting, with no language model and no GPU. In this post we show it doing Aristotle’s logic. Given every standard three-term syllogism, it reproduced the known classifications without applying a single rule of inference. The representation of systems it runs on already contains the connectives of logic, so a logic puzzle can be built as a system and left to settle.
The machine does compute; what it never does is apply a rule of logic. Nobody tells it how to solve the puzzle, and it never works out a method of its own. It solves the problem without knowing how it solved it.
Introduction #
SapienTronic AI reasons about systems. In its representation, which the MINOS page sets out, a system is anything with something driving it, something constraining it, and its own way of holding the two together: a boiler, a production line, a market, a rulebook and the records of how it was applied. The two earlier posts, the introduction and the deep dive, showed the machine reasoning about systems of that kind.
This post is about logic. Logic is the oldest kind of reasoning there is, and Aristotle wrote the rules for it: statements, and rules for getting from one statement to the next. A system, by contrast, is a thing that runs. On the face of it the two have nothing to do with each other.
They meet at one point. MINOS joins the parts of a system together in three ways, and at their ends those three ways are and, or and not: the three words from which every statement in Aristotle’s logic can be built. So a logic puzzle can be built out of the same parts as a model of a boiler, and then settled like one.
So we built Aristotle’s own logic as a system. The standard syllogistic is finite: with three terms there are 256 possible forms of argument, and read in the two usual ways that makes 512 questions, every standard three-term syllogism under both readings. We put all 512 to the system. Its verdicts matched the known answers on every one, with no rule of inference anywhere in the machine. Every counterexample it found could be checked by hand, and the valid cases were confirmed separately by checking every possibility. It also did something we value even more: when it couldn’t decide a question, it said so, and said why.
This post explains what we did and what we think it means. The full account, with the history, the diagrams and an interactive version of the puzzle, is on the Logic Without Rules page, and the paper is on Zenodo.
Two Ways of Knowing #
There are two ways to know a thing. You can say it, in words or symbols, and reason about it by rules. Or you can build it, as a system, and learn what it does by letting it run.
Knowledge as something said
Aristotle’s way is the first. Take the oldest example in the book: every man is mortal; Socrates is a man; so Socrates is mortal. Aristotle noticed that the argument is sound because of its shape, not because of what it’s about. Put every bird has feathers; a robin is a bird into the same shape and you get a robin has feathers, which is just as sound. He catalogued the shapes that work, and reasoning became a matter of putting your statements into one of those shapes and applying the rule.
That idea has held for two and a half thousand years, and it has grown a great deal. In the nineteenth century Frege turned the rules into an exact written notation, and modern logic began. In 1936 Turing described a machine that applies simple rules to symbols one step at a time, and that machine became the computer. Most programs are lists of steps to apply in order; the declarative and constraint languages that aren’t still hand their work to a solver that searches step by step. The expert systems of the 1970s were thousands of rules of the form if this, then that. A language model is trained on words and gives back words.
The medium keeps changing, from speech to symbols to code to tokens. The assumption underneath it stays the same: knowledge is something said, and reasoning is something done to what is said.
Knowledge as a system
The engineer’s way is the second. A network of water pipes under pressure doesn’t work anything out. The water pushes and backs up until every junction balances, and the flow in each pipe is whatever that balance makes it. The engineer reads the answer off the meters. A circuit does the same: its currents and voltages settle into an arrangement consistent with Kirchhoff’s laws and the parts the circuit is made of, and nobody applies a rule to get there. To know something this way is to know its parts and how they act on one another, and to trust that what it does follows from how it’s built.
This way is as old as the other. Heraclitus, a century and a half before Aristotle, said that a thing is held together by the opposites it holds. A bow is a bow only while the stave and the string pull against each other; slacken either and you have a stick and a cord. That is a system in the engineer’s sense: a drive and a constraint held together, and what it does follows from how it holds them. Aristotle read Heraclitus as denying that a thing can’t be both one way and the other, and set him aside. In a sense, the tradition of knowledge in words began by ruling the systems view out of logic.
Where MINOS stands
The two ways have rarely spoken to each other. Words can reason, but they aren’t the world. Systems are the world, but nobody trusted them to reason, for a reason we come to below. MINOS is built on the engineer’s side: it reads a tree, a market, a circuit and a lattice in the same three roles, as things that are driven, constrained and held together. What we found is that it carries Aristotle’s own logic inside it.
A Puzzle About a Town #
We’ll use one puzzle all the way through. A town has three guilds: lamplighters, wardens and keyholders. A person can belong to more than one. One person can answer to another. Four things are known:
- Every lamplighter answers to at least one warden.
- No warden answers to a lamplighter.
- Anyone who answers to a keyholder is a warden.
- At least one lamplighter answers to a keyholder.
Six questions can be asked about the town:
- Q1. Is at least one lamplighter also a warden?
- Q2. Does every lamplighter answer to a keyholder?
- Q3. Does some warden answer to a warden?
- Q4. Is it true that no keyholder is also a lamplighter?
- Q5. Is every warden a keyholder?
- Q6. Can the four clues all hold at once?
Try Q1. Clue 4 gives a lamplighter who answers to a keyholder. Clue 3 says anyone who does that is a warden. So that lamplighter is a warden: yes. You picked the two clues that mattered, put them in order and drew the conclusion. That’s a derivation: Aristotle’s way of reasoning. The skill is in choosing which rule to apply, to what, and when. The system we built answers the same questions without any of that choosing. Why nobody expected that to work comes first.
Why Nobody Trusted a System to Reason #
The idea of letting a system settle to a logical answer isn’t new. Hopfield‘s networks of 1982 settle into states of low energy. Analog solvers for logical constraints followed, and more recently circuits whose resting states are solutions to Boolean problems. When one of these finds a solution, checking it is easy: test it against every constraint.
The hard question was always the other outcome. What do you conclude when the system fails to find a solution? A network that comes to rest in a state satisfying nothing hasn’t shown that no solution exists. It may have stuck in a shallow dip. It may be balanced halfway between two answers. And nothing about the state tells you which.
That is why logic stayed with words. A proof can be handed to someone who has never met its author and checked line by line, and a proof that there’s no solution is as checkable as any other. A settling machine that had found nothing had nothing of the kind to show.
An analog computer at NASA’s Lewis laboratory, 1949. The problem was wired into it; the machine settled; the answer was read off its instruments. Photo: NASA, public domain.
The analog computer makes the same point from the other side. For thirty years in the middle of the last century, engineers wired up circuits whose voltages obeyed the same equations as a bridge or a rocket, switched them on, and read the dials. It worked. The digital computer replaced it within a decade, for the usual reasons: it could be reprogrammed by changing a text rather than rewiring, it could store its results, it was as precise as you liked and it scaled. One further difference is the one that matters here. A digital computer can be programmed to keep a repeatable record of its calculations. An analog machine could record how its quantities changed, on a chart recorder or a plotter, but that record was not a proof that its answer was right. And when it failed to settle, watching it fail did not establish whether a solution existed.
So our question had two parts: can what a system settles to be checked, and can it say something useful when it fails?
The Systems Logical Element, and the Three Ways of Joining #
MINOS describes a system in three roles, which the earlier posts covered: something drives it (Energy), something constrains it (Control), and the system has its own way of holding the two together (Logic). The smallest part is an element. Something reaches it; the element passes some of it on and holds the rest back; and those two shares are the only things about the element you can see from outside.
Because the two shares add up to the whole, an element sits somewhere on a line from all passed to all held. For logic, we read the two ends as true and false. An element at an end is a statement that has been settled. An element in between is a statement that hasn’t been settled yet, leaning one way or the other. Nothing about the element had to change for this reading to work.
Elements are joined in three ways. The MINOS paper left the question of joining open; we filled it in by looking at how real systems are put together, a reservoir fed by several streams, a circuit, a market.
- Series. Elements in a chain. What passes the whole chain is what passes every link; one closed link stops everything.
- Parallel. Elements side by side, each a separate route. Something gets through if it gets through any one route.
- Transposition. The same element with its two shares read the other way round.
Now look at the ends. A series chain is true only if every link is true: that’s and. A parallel set is true if any route is true: or. A transposed element is true where the original was false: not. Nobody chose these three joins in order to get the connectives. They were chosen to describe how reservoirs and circuits are built. The logic was already there, in the way systems are put together.
Building the Town #
If the joins are the connectives, then a clue about the town can be built, out of elements, the way a model of a boiler is built. The town becomes a board of cells, one for each fact that could be true: whether Ann is a lamplighter, whether Ann answers to Ben, and so on. Each clue becomes a law about the cells, made of and, or and not. In a town of fixed size, “every” is a long and across the people and “at least one” is a long or. Each clue is written once, as what it means. Nothing says how the clues are to be used; they are constraints on the town, like “water in equals water out” at a junction.
A question is put the way an engineer fixes the water in and out. To ask whether a claim follows, the system holds every clue true, holds the claim false, and lets the board settle. If it comes to rest in a town where every clue holds and the claim is false, it has found a counterexample, and the claim doesn’t follow. If it can’t find such a town, the question stays open until the absence of a counterexample is established some other way. Everything that follows depends on keeping those two outcomes apart.
This looks upside down at first. Logic is about statements; how can a thing be a statement? But the clue hasn’t been turned into a machine. The town has been built as a system, and the clue has become one of its laws, which is what it was to begin with. Modern solvers also produce a town in the end, as an assignment of true and false to every fact; they get there by searching over the statements, choosing a value and testing what follows, one step at a time. Here the town is built and left to find its own shape.
Checking the answer
A settled board isn’t yet logic’s kind of answer. Before it counts, it’s checked. Each cell is read as true or false, so the board is now a plain picture of one town. The system works forward again from that picture alone, and every clue, and the denied claim, must come back as it was held. We call this the witness rule. A board that passes it is a counterexample in the logician’s own sense: a case where every premise is true and the conclusion false. Anyone can check it by hand, without knowing anything about the system that found it.
What Happened #
Take Q4: is it true that no keyholder is also a lamplighter? The system held the clues, denied the claim, and settled in about a quarter of a second, in a town where Ann belongs to all three guilds and answers to Ben and Cal. Every clue holds there, and Ann is a keyholder who is also a lamplighter. The claim doesn’t follow. Certificate: exact.
Now Q1, the one you proved by hand above. The claim is true, so no town exists in which the clues hold and no lamplighter is a warden. The board couldn’t settle. It stopped, and reported:
stalled in the interior, three facts open: some lamplighter is a warden, some lamplighter answers to some keyholder, whoever answers to some keyholder is a warden
Those are the claim itself, clue 4 and clue 3. Clue 4 and clue 3 are the two clues you used in your proof. The system was never asked for a proof and has no idea what a proof is. It reported where its attempt to deny the claim broke down, and that place is the premises of the proof.
Then Q2, whether every lamplighter answers to a keyholder. The answer is no: a town with two lamplighters, the second answering only to a warden without a key, satisfies every clue. The system didn’t find that town. It reported:
stalled in the interior, one fact open: every lamplighter answers to some keyholder
So on this question the search failed. What counts is what the system said about it. It said undecided. It didn’t say the claim follows. It named the one statement it couldn’t settle, and left the question open for anyone who knows the missing town to hand it in and have it checked. A careless system, having found no town where the claim fails, would have answered yes, and been wrong, with nothing in the answer to show it. Its search failed; its answer did not.
Three Labels, and Why the Third Matters Most #
Every answer carries one of three labels, and the system can’t mix them up.
- Exact. A counterexample was found and passed the witness rule, or every possible completion was enumerated. The claim is refuted, or proved for a town of that size.
- Measured. The board settled within a stated tolerance, and the answer is what the settled state says.
- Undecided. The board didn’t settle cleanly, or a search ran out. The report names the statements that wouldn’t fit together and says what would settle them.
The label follows from what happened, not from what the resting state looks like. Across about a thousand questions in the paper, no answer was ever given a stronger label than it had earned.
We’ve come to think the third label is the most important thing the system does. Reporting that a question is open isn’t new in itself; a modern solver can answer unknown and give a reason. What’s particular here is where the report comes from and what it contains: which cells reached an end and which didn’t, which statements held and which stayed open, read off the resting state of the same operation that finds and checks the counterexamples.
And a certified open question is a result you can act on. You can hand in a town of your own and have it checked. You can enlarge the town and ask again. You can free just the cells the broken clue is about, keep everything else where it settled, and let the board settle once more; in the paper’s runs, that found towns that thirty-two fresh starts had missed. Or you can set the question aside, knowing exactly what’s open. Every one of those moves is safe, because the report has told you where you stand. An uncertified yes licenses none of them, because nothing in it says whether it’s a finding or a failure, and every conclusion built on it inherits a doubt it can’t see.
Experiments work the same way. An experiment can support a hypothesis, refute it, or come out inconclusive, and each of the three, written up with its conditions, is something a field can build on. An inconclusive experiment says what to investigate next. Q2 is of that kind. One distinction has to be kept, though: what’s certified is that the search failed, and where. That no town exists isn’t certified. The first is a report about the search; the second would be a proof about the world; and the system never passes off one as the other.
The Numbers #
The standard syllogistic is finite. With three terms there are 256 possible forms of argument, and asking each under the two usual readings gives 512 questions. We fixed in advance what would count as success, and checked every answer against independent programs that share no code with the system.
Of the 512 questions, 39 are valid inferences, 15 under the modern reading and 24 under Aristotle’s, and the other 473 are invalid. The system’s own verdict was right on all 512: it left every valid form unrefuted, refuted every invalid form with a checked counterexample, and gave no wrong verdict either way, even with a single attempt from a single random start. The verdicts don’t all certify the same thing, and that’s by design: every no was exact on its own, by the witness rule, and every yes was then proved separately by checking every possible completion.
Above Aristotle’s fragment there are harder logics: more terms, relations between individuals, statements nested inside statements. We took the system three steps up that ladder, into worlds too large for it to check case by case.
| Rung | World | Invalid inferences refuted, usual construction of or | With series, parallel and transposition |
|---|---|---|---|
| 1 | Three terms (Aristotle) | 473 / 473 | 473 / 473 |
| 2 | Four terms, combinations | 111 / 120 | 120 / 120 |
| 3 | A relation between individuals | 66 / 80 | 80 / 80 |
| 4 | Nested statements | 52 / 80 | 79 / 80 |
On every rung, no valid inference was ever wrongly refuted. Every miss was an invalid inference whose counterexample the search didn’t find, and every miss came back as undecided. The third column is worth a look. The usual way of building or into a network treats a wide or as satisfied while its parts are still undecided, so the network never feels the clue; every miss in that column sat behind a wide or. Building or as a parallel join of elements instead removed all but one of them, and a control experiment showed why. On towns of four and five people, checked against an industrial constraint solver, the system agreed on 117 and 116 of 120 questions; the remaining three and four came back as undecided, not as wrong answers, and again there was no false no.
What we’re not claiming:
- The worlds are small: eight to forty cells, towns of three to five people.
- The specialist solvers built for this task are faster. Speed was never the question.
- The answer doesn’t yet state the size of world it covers. The paper proposes that as a necessary extension, and the puzzle’s charter, which no town of any fixed size can satisfy, shows why.
- Nothing here is about learning, probability, or intelligence in general.
Conclusion #
We take three things from this. The first two are results. The third is where the work is going.
The logic was found, not designed. Series, parallel and transposition were written down to describe how systems are assembled. That they are and, or and not was noticed afterwards. So the same representation that describes a reservoir, a circuit or a market can be given Aristotle’s syllogistic and settle it. The correspondence gives the representation the means to express the logic; the settling and the witness rule do the work; and it is the two together that make a reasoning system. Logic is one of the things the representation already does, rather than a module bolted on in a language of its own. For the syllogistic this has been shown on every case.
Reasoning without rules and without words. The words tradition reasons by operating on statements. In a derivation a rule is applied and a symbol rewritten; in a language model the next piece of text is produced from patterns learned in training. The mechanisms differ; what they share is the material. Here the statements are built as a system once, and the system’s own settling gives the answer. There’s no derivation, no procedure for applying the rules, and no language in the loop. Yet the answer comes back in logic’s own currency: a counterexample anyone can check, or the premises a proof would use, or an honest undecided that names what’s missing.
One substrate, many kinds of reasoning. This one is a proposition, not yet a result. The operation that does the logic is the same operation the earlier posts showed doing diagnosis, what-if reasoning, revision and the rest. The paper measures only the logic, and we say so.
There is a larger idea behind this, about where reasoning lives. In the machines we usually build, the part that reasons stands apart from the thing it reasons about: a rules engine beside the business, a language model beside everything. If the representation that describes a system is also the thing that reasons about it, then reasoning stops being a component and becomes a property of how the system is built, the way a bridge carries its loads as a consequence of its structure. And a part of a system built that way can do what the paper’s system does when it can’t answer: say so, name what it couldn’t fit together, and say what would settle it.
Think about what that would do to the complexity of the systems we build. A procedure for applying business rules grows by cases until it breaks, and it grows because the parts it coordinates are mute: they can’t report, so the procedure must check; they can’t correct, so the procedure must handle. Parts that could report and correct themselves wouldn’t need most of that scaffolding to exist. The experiments show this for the reasoning system as a whole, on small worlds. Whether it holds for every part described in MINOS, and at scale, is what we’re testing next.
Where to Read More #
The Logic Without Rules page tells the whole story at length, with the history from Heraclitus to Hopfield, diagrams of every step, and an interactive version of the town puzzle that you can change and watch settle. The paper, A Logic Solver Without Rules of Inference, is on Zenodo, and the representation it’s built on is described on the MINOS page and in its own paper.