From 12a98d1dcc17a46892eb09291e3d8326bfc93ea2 Mon Sep 17 00:00:00 2001 From: spqrz Date: Wed, 15 Apr 2026 12:22:01 +0100 Subject: [PATCH] Paper: strengthen Section 4.1 --- paper.tex | 21 +++++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/paper.tex b/paper.tex index f157cc8..40abe7d 100644 --- a/paper.tex +++ b/paper.tex @@ -365,9 +365,15 @@ Consider: ``The gear on the left turns clockwise. It meshes with the middle gear, which meshes with the gear on the right. Which direction does the right gear turn?'' -To answer, you must simulate the mechanism. Left gear clockwise $\to$ +To answer questions like this with 100\% accuracy, +you must simulate the mechanism. Left gear clockwise $\to$ middle gear counterclockwise (meshing reverses direction) $\to$ right -gear clockwise. You cannot determine this by inspecting the words. You +gear clockwise. You cannot determine this by inspecting the words and +expect the result to be accurate in all cases. Suppose for example you +tried to use a simple heuristic like ``every mention of `gear' flips the +answer'': that would fail as soon as somebody replaced ``which'' with +``and that gear''. Other heuristics may survive more variations, but to +get it right in 100\% of cases you need to model the semantics. You must run the described process in your head, stepping through the causal chain. Add more gears, add branching gear trains, and the computation becomes arbitrarily long --- but the structure is the same. The sentence @@ -383,10 +389,17 @@ program. Understanding it means running it. Rice's Theorem (1953) makes this precise: no non-trivial semantic property of Turing-complete programs is decidable without -running them. You cannot determine what a program does by inspecting it. +running them. You cannot determine what a program does by inspecting it +and be 100\% correct in finite time no matter what the input. You can +have heuristics that work {\em some} of the time, and even formal proof +methods that work for {\em some} inputs, but no inspection can survive +100\% of programs if a 100\% accuracy is required. You must execute it. Natural language has Turing-complete expressive power. Therefore you cannot determine what a natural language utterance -\textit{means} without executing the computation it describes. +\textit{means} without executing at least some of the computation it +describes. (You can understand the Ackermann function without having to +compute the whole thing, but you'll need at least a demonstrative run of +a few steps to understand its pattern.) The halting problem tells us the same thing from a different angle. A system that could determine the meaning of arbitrary natural language -- 2.49.1