These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps. >
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a decision criteria.
-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
On 2026-10-23 12:10, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps. >
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
The term 'description' as using in computational theory normally refers
to a 7-tuple as described here:
<https://en.wikipedia.org/wiki/Turing_machine#Formal_definition>
How is that any more vague that your alternative? Note also that the
term 'source code' isn't normally used for Turing Machines since Turing Machines are mathematical objects, not things that are compiled to run
on digital computers.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
strcmp() isn't a decider at all. A decider takes a single input and
either accepts it or rejects it. It is an algorithm implementing the membership function of a set.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
Since your example isn't a decider, it rather difficult to see how your claims somehow 'tightens' the term.
Andr|-
Nit-picky irrelevant details. The idea was to show
that the decision criteria restricts the steps to
those that are syntactically relevant.
This is a key missing element of the foundations
of computation that prevents computation from being
understood more deeply.
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a decision criteria.
-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated.
We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a decision criteria.
-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
Because Post canonical systems are Turing equivalent anything
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required.
-a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
Because Post canonical systems are Turing equivalent anything
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind
raw electronics.
Now go!
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string
-a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
Because Post canonical systems are Turing equivalent anything
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind
raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
On 10/31/2026 12:14 AM, olcott wrote:
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string >>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
Because Post canonical systems are Turing equivalent anything
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>> raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
That's just words on a screen.-a I was expecting a physical machine.-a Are you lazy or something?-a Is there something wrong with a physical string transformation machine?
Surely you can build a small one with 74xx logic chips?
On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/31/2026 12:14 AM, olcott wrote:
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:Because Post canonical systems are Turing equivalent anything
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string >>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>> -a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation? >>>>>>
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>>> raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
That's just words on a screen.-a I was expecting a physical machine.-a Are >> you lazy or something?-a Is there something wrong with a physical string
transformation machine?
Surely you can build a small one with 74xx logic chips?
x86utm is a minimal operating system that I wrote
that implements HHH/DD as fully operational code.
On 10/31/2026 12:53 AM, olcott wrote:
On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/31/2026 12:14 AM, olcott wrote:
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:Because Post canonical systems are Turing equivalent anything
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string >>>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>>> -a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION. >>>>>>>> At this point we only need to see what is semantically entailed >>>>>>>> by these corrections.
What exactly executes the new and corrected errors of computation? >>>>>>>
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>>
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't >>>>> mind
raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
That's just words on a screen.-a I was expecting a physical machine.-a Are >>> you lazy or something?-a Is there something wrong with a physical string >>> transformation machine?
Surely you can build a small one with 74xx logic chips?
x86utm is a minimal operating system that I wrote
that implements HHH/DD as fully operational code.
But it's not a physical machine of your design.-a It's merely an x86 op- erating system.
On 10/31/2026 12:14 AM, olcott wrote:
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string >>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the
-a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis.
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION.
At this point we only need to see what is semantically entailed
by these corrections.
What exactly executes the new and corrected errors of computation?
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you
-- not -- execute code with a Turing-machine?-a What else is there?
Because Post canonical systems are Turing equivalent anything
that cannot be derived by applying finite string transformations
to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't mind >>> raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
That's just words on a screen.-a I was expecting a physical machine.-a Are you lazy or something?-a Is there something wrong with a physical string transformation machine?
Surely you can build a small one with 74xx logic chips?
On 10/30/2026 11:54 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/31/2026 12:53 AM, olcott wrote:
On 10/30/2026 11:50 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/31/2026 12:14 AM, olcott wrote:
On 10/30/2026 11:02 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/30/2026 11:11 PM, olcott wrote:
On 10/30/2026 10:06 AM, Johann 'Myrkraverk' Oskarsson wrote:
On 10/24/2026 2:10 AM, olcott wrote:Because Post canonical systems are Turing equivalent anything
These terms are replaced:
(a) "Turing machine description" is replaced with
-a-a-a-a [Finite string source code for a Turing Machine]
The term: "description" is too vague the finite string
source code actually specifies an exact sequence of steps.
The term: "machine description" enables indirect
reference to behavior other than the behavior specified
by the input finite string of source code.
(b) "Decider" and replace it with sequence of inference
-a-a-a-a-a steps that are applied to an input static finite string >>>>>>>>> -a-a-a-a-a that are syntactically or semantically relevant to the >>>>>>>>> -a-a-a-a-a decision criteria.
-a-a-a-a-a Concrete example of a decider where relevance is required. >>>>>>>>> -a-a-a-a-a int strcmp(const char *str1, const char *str2);
-a-a-a-a-a and the finite string inputs are the entire basis. >>>>>>>>>
This tightens the term "decider" to the actual requirements
that are never expressly stated. We can see things much
more clearly with these additional details.
WE HAVE CORRECTED THE ERRORS AT THE FOUNDATION OF COMPUTATION. >>>>>>>>> At this point we only need to see what is semantically entailed >>>>>>>>> by these corrections.
What exactly executes the new and corrected errors of computation? >>>>>>>>
It wouldn't be an Antikythera mechanism, would it?
It would have to be a Turing-machine, right?-a Wrong?-a How can you >>>>>>>> -- not -- execute code with a Turing-machine?-a What else is there? >>>>>>>
that cannot be derived by applying finite string transformations >>>>>>> to finite strings is outside of the scope of computation.
Ok, so show me your finite string machine!-a Don't be shy.-a I don't >>>>>> mind
raw electronics.
Now go!
https://github.com/plolcott/x86utm/blob/master/README.md
That's just words on a screen.-a I was expecting a physical machine. >>>> Are
you lazy or something?-a Is there something wrong with a physical string >>>> transformation machine?
Surely you can build a small one with 74xx logic chips?
x86utm is a minimal operating system that I wrote
that implements HHH/DD as fully operational code.
But it's not a physical machine of your design.-a It's merely an x86 op-
erating system.
A virtual machine is equivalent to a physical machine.
VirtualBox, DOSBox and 86Box https://86box.net/
are concrete examples.
x86UTM enables one C function to run another
C function a DebugStep mode.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:49:23 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,582 |