On 2025-11-01 13:43:46 +0000, olcott said:
On 11/1/2025 4:56 AM, Mikko wrote:
On 2025-10-31 12:50:30 +0000, olcott said:
On 10/31/2025 6:40 AM, Mikko wrote:
On 2025-10-30 13:38:17 +0000, olcott said:
On 10/30/2025 6:06 AM, Mikko wrote:
On 2025-10-29 16:32:16 +0000, olcott said:
On 10/29/2025 5:04 AM, Mikko wrote:
On 2025-10-28 14:56:16 +0000, olcott said:
On 10/28/2025 4:18 AM, Mikko wrote:
On 2025-10-27 13:47:17 +0000, olcott said:
On 10/27/2025 4:39 AM, Mikko wrote:More importantly, an attempt of a straw man deception dishonest. >>>>>>>>>>> Less importantly, an attempt to distract with an irrelevancy is >>>>>>>>>>> dishonest, too.
On 2025-10-26 14:46:33 +0000, olcott said:
Summary of the key point:
The halting problem's self-referential construction >>>>>>>>>>>>>> creates two distinct computational entities:
The halting problem does refer itself nor requires that any >>>>>>>>>>>>> entity
should refer to itself. At most the descriptions of the >>>>>>>>>>>>> program and
can be seen as references to the program and input asked >>>>>>>>>>>>> about, and
some formulations of the problem don't mention even that. >>>>>>>>>>>>> The program
asked about does not refer to anything outside itself and >>>>>>>>>>>>> the input
asked about. No semantics of the input asked about is >>>>>>>>>>>>> relevant fo the
halting problem so in that context nothing in the input >>>>>>>>>>>>> refers to
anything.
Input (DD-as-simulated-by-HHH): Shows non-halting behavior >>>>>>>>>>>>>> - recursive pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH >>>>>>>>>>>>>> returns 0
Not relevant to the halting problem,
Saying that the halting problem proof counter-example
input is not relevant to the halting problem is dishonest. >>>>>>>>>>>
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
When simulating halt decider H is reporting on the
behavior that its input specifies then H is correct
to reject D as non-halting.
Deciders only compute a mapping from their actual
inputs. Computing the mapping from non-inputs is
outside of the scope of Turing machines.
Nice to see that you don't disagree.
So you have agreed that I proved the halting problem
itself is a category error on the basis that it requires
halt deciders to report on behavior other than the behavior
specified by their inputs.
No, it is not my style to agree with obvious falsehoods. But I do >>>>>>> find
it nice that you don't disagree with my opinion that you are
dishones
when you try to dstract reader's attention from truth with an
irrevancy.
D simulated by H measures the semantic property of
the actual input as opposed to and contrast with
the semantic property of a non-input.
We can tell an input from an input because an
input is an argument to the function H.
D.input_to_H
specifies different behavior than
D.input_to_H1.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0;
H1 simulates D
that calls H(D) to simulate D
then H(D) returns 0 to caller D
then H1 returns 1;
int sum(int x, int y){ return x + y;}
int product(int x, int y){ return x * y;}
// same input different results
sum(3,4) != product(3,4)
Thank you for an example of an attempt to dever attention in a way
that I called dishonest and you din't disagree.
It has been a verified fact for three years.
What you call dishonest is your own lack of
comprehension. It looks like I will be able
to rewrite it using a C interpreter.
A Turing machine interpreter would
Takes a million steps just to move data from one
memory location to another.
Which could be simulated in a few senconds with a modern computer,
or even less with a fast one.
On 11/2/2025 6:48 AM, Mikko wrote:
On 2025-11-01 13:43:46 +0000, olcott said:
On 11/1/2025 4:56 AM, Mikko wrote:
On 2025-10-31 12:50:30 +0000, olcott said:
On 10/31/2025 6:40 AM, Mikko wrote:
On 2025-10-30 13:38:17 +0000, olcott said:
On 10/30/2025 6:06 AM, Mikko wrote:
On 2025-10-29 16:32:16 +0000, olcott said:
On 10/29/2025 5:04 AM, Mikko wrote:
On 2025-10-28 14:56:16 +0000, olcott said:
On 10/28/2025 4:18 AM, Mikko wrote:
On 2025-10-27 13:47:17 +0000, olcott said:
On 10/27/2025 4:39 AM, Mikko wrote:More importantly, an attempt of a straw man deception dishonest. >>>>>>>>>>>> Less importantly, an attempt to distract with an irrelevancy is >>>>>>>>>>>> dishonest, too.
On 2025-10-26 14:46:33 +0000, olcott said:
Summary of the key point:
The halting problem's self-referential construction creates two
distinct computational entities:
The halting problem does refer itself nor requires that any entity
should refer to itself. At most the descriptions of the program and
can be seen as references to the program and input asked about, and
some formulations of the problem don't mention even that. The program
asked about does not refer to anything outside itself and the input
asked about. No semantics of the input asked about is relevant fo the
halting problem so in that context nothing in the input refers to
anything.
Input (DD-as-simulated-by-HHH): Shows non-halting behavior - recursive
pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH returns 0
Not relevant to the halting problem,
Saying that the halting problem proof counter-example >>>>>>>>>>>>> input is not relevant to the halting problem is dishonest. >>>>>>>>>>>>
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
When simulating halt decider H is reporting on the
behavior that its input specifies then H is correct
to reject D as non-halting.
Deciders only compute a mapping from their actual
inputs. Computing the mapping from non-inputs is
outside of the scope of Turing machines.
Nice to see that you don't disagree.
So you have agreed that I proved the halting problem
itself is a category error on the basis that it requires
halt deciders to report on behavior other than the behavior
specified by their inputs.
No, it is not my style to agree with obvious falsehoods. But I do find >>>>>>>> it nice that you don't disagree with my opinion that you are dishones >>>>>>>> when you try to dstract reader's attention from truth with an irrevancy.
D simulated by H measures the semantic property of
the actual input as opposed to and contrast with
the semantic property of a non-input.
We can tell an input from an input because an
input is an argument to the function H.
D.input_to_H
specifies different behavior than
D.input_to_H1.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0;
H1 simulates D
that calls H(D) to simulate D
then H(D) returns 0 to caller D
then H1 returns 1;
int sum(int x, int y){ return x + y;}
int product(int x, int y){ return x * y;}
// same input different results
sum(3,4) != product(3,4)
Thank you for an example of an attempt to dever attention in a way >>>>>> that I called dishonest and you din't disagree.
It has been a verified fact for three years.
What you call dishonest is your own lack of
comprehension. It looks like I will be able
to rewrite it using a C interpreter.
A Turing machine interpreter would
Takes a million steps just to move data from one
memory location to another.
Which could be simulated in a few senconds with a modern computer,
or even less with a fast one.
Yet the whole program would exceed the human
capacity that can at most keep track of a
dozen thing simultaneously.
C simplifies the actual algorithm eliminating
the purely extraneous and irrelevant details.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 76:03:06 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
4,753 files (1,565M bytes) |
| Messages: | 2,443,114 |