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:
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.
More importantly, an attempt of a straw man deception dishonest.
Less importantly, an attempt to distract with an irrelevancy is
dishonest, too.
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.
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:
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 -Not relevant to the halting problem,
recursive pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH returns 0 >>>>>>>
Saying that the halting problem proof counter-example
input is not relevant to the halting problem is dishonest.
More importantly, an attempt of a straw man deception dishonest.
Less importantly, an attempt to distract with an irrelevancy is
dishonest, too.
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.
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:
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 - recursiveNot relevant to the halting problem,
pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH returns 0 >>>>>>>>
Saying that the halting problem proof counter-example
input is not relevant to the halting problem is dishonest.
More importantly, an attempt of a straw man deception dishonest.
Less importantly, an attempt to distract with an irrelevancy is
dishonest, too.
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)
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:
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 identifiesNot relevant to the halting problem,
Non-input (DD-as-directly-executed): Halts because HHH returns 0 >>>>>>>>>
Saying that the halting problem proof counter-example
input is not relevant to the halting problem is dishonest.
More importantly, an attempt of a straw man deception dishonest. >>>>>>> Less importantly, an attempt to distract with an irrelevancy is
dishonest, too.
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.
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:D simulated by H measures the semantic property of
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:
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 - recursiveNot relevant to the halting problem,
pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH returns 0 >>>>>>>>>>
Saying that the halting problem proof counter-example
input is not relevant to the halting problem is dishonest.
More importantly, an attempt of a straw man deception dishonest. >>>>>>>> Less importantly, an attempt to distract with an irrelevancy is >>>>>>>> dishonest, too.
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. >>>
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.
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:
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.
More importantly, an attempt of a straw man deception dishonest. >>>>>>>>> Less importantly, an attempt to distract with an irrelevancy is >>>>>>>>> dishonest, too.
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
be easier to do and would be
more erelvant to the topic of Turing computability. In C there
is too much unnecessary complesity and ambiguity.
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:D simulated by H measures the semantic property of
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 - recursiveNot relevant to the halting problem,
pattern that HHH correctly identifies
Non-input (DD-as-directly-executed): Halts because HHH returns 0 >>>>>>>>>>>>
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. >>>>>
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.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,075 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 90:34:43 |
| Calls: | 13,798 |
| Calls today: | 1 |
| Files: | 186,989 |
| D/L today: |
5,330 files (1,536M bytes) |
| Messages: | 2,438,212 |