spqrz/consciousness
1
0
Fork 0
forked from kent/consciousness
Code Pull requests Activity

Paper: strengthen Section 4.1

Browse source
This commit is contained in:
spqrz 2026-04-15 12:22:01 +01:00
parent d5aad5c1a4
commit 12a98d1dcc
No known key found for this signature in database
1 changed files with 17 additions and 4 deletions
Download patch file Download diff file Expand all files Collapse all files

21
paper.tex
View file

@ -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