XPost: comp.theory, sci.logic

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H.

When H returns 1 for inputs that it determines do halt and returns 0 for
inputs that either do not halt or do the opposite of whatever Boolean
value that H returns then these pathological inputs are no longer
contradictory and become decidable.

Can D correctly simulated by H terminate normally?

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above)
relationship to H.

The x86utm operating system (includes several termination analyzers) https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15




*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H.

So, you agree with the Halting Theorem that says that a correct Halting
Decider can't be made?

Then way are you trying to refute it?

When H returns 1 for inputs that it determines do halt and returns 0 for inputs that either do not halt or do the opposite of whatever Boolean
value that H returns then these pathological inputs are no longer contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of the
Halting Problem, so your "Termination Analyzer" is NOT a "Solution to
the Halting Problem"

Can D correctly simulated by H terminate normally?

Which again, isn't the question of the Halting Problem.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot possibly terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above) relationship to H.

The x86utm operating system (includes several termination analyzers) https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15

*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

So, you are just admitting that none of you work applies to the Halting Problem, but just your POOP which you are trying to make smell better by calling it (incorrectly) a Termination Analyzer.

It isn't actually a "Termination Analyzer", because again, that theory
taks about the behavior of the actual program, and not that of the
decider, and the correct answer is if the actual program will terminate.

Since D(D) does terminate, you have shown that your POOP still stinks,
and you just can't help but being a liar.

Sorry, you are just showing that you writing is just a mass of error and mistakes based on faulty assumptions resulting in erroneous answers.

You can't seem to keep yourself from lying about what you are doing.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H.

So, you agree with the Halting Theorem that says that a correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does
the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

When H returns 1 for inputs that it determines do halt and returns 0 for
inputs that either do not halt or do the opposite of whatever Boolean
value that H returns then these pathological inputs are no longer
contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of the
Halting Problem, so your "Termination Analyzer" is NOT a "Solution to
the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So if the halting problem requires its halt decider to report on
different behavior than it actually sees then the halting problem is
incorrect for another different reason.

Can D correctly simulated by H terminate normally?

Which again, isn't the question of the Halting Problem.

Yet professor Sipser seems to agree is equivalent and several people on
this forum took to be a tautology, AKA necessarily true.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot possibly
terminate normally on the basis that H recognizes a dynamic behavior
pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above)
relationship to H.

The x86utm operating system (includes several termination analyzers)
https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition
https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15



*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

So, you are just admitting that none of you work applies to the Halting Problem, but just your POOP which you are trying to make smell better by calling it (incorrectly) a Termination Analyzer.

I am opening my work to the much broader field of termination analysis
where it is dead obvious that a termination analyzer is not allowed to
report on behavior that it can't see.

It isn't actually a "Termination Analyzer", because again, that theory
taks about the behavior of the actual program, and not that of the
decider, and the correct answer is if the actual program will terminate.

No that is not the case with software engineering. With software
engineering it is understood that when D correctly simulated by H cannot possibly reach its last instruction and terminate normally that D is
correctly determined to be non-halting. It is much more clear in
software engineering that H is not supposed to be clairvoyant.

Since D(D) does terminate, you have shown that your POOP still stinks,
and you just can't help but being a liar.

If it absolutely true that D(D) does halt then H would never have to
abort its simulation of D. Because H must abort its simulation of D that
proves from the frame-of-reference of H that D does not halt.

All this becomes moot when we understand that any input D to
termination analyzer H that does the opposite of whatever Boolean value
H returns is a contradictory thus semantically incorrect input.

Sorry, you are just showing that you writing is just a mass of error and mistakes based on faulty assumptions resulting in erroneous answers.

You can't seem to keep yourself from lying about what you are doing.

If D actually does halt in an absolute sense then H would never need to
abort its simulation. Because H does need to abort its simulation then
from the frame-of-reference of H its input does not halt.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H.

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does
the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not make a
decider that answers the exact question: "Does the machine represented
by the input halt".

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

The fact that you think you can change the question and come up with a
solution for that OTHER question (which isn't the actual Halting Problem
that you refer to), doesn't mean you have refuted that you can't
correctly answer the question you agreed can't be correctly answered.

When H returns 1 for inputs that it determines do halt and returns 0 for >>> inputs that either do not halt or do the opposite of whatever Boolean
value that H returns then these pathological inputs are no longer
contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of the
Halting Problem, so your "Termination Analyzer" is NOT a "Solution to
the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So, you don't belive the requirements as stated are the requirement.

I guess that means you believe it is ok to use strawmen instead of the
actual problem, and lie that you are doing the actual requirements.

YOU FAIL.

So if the halting problem requires its halt decider to report on
different behavior than it actually sees then the halting problem is incorrect for another different reason.

If the Halt Decider doesn't see the behavior that the Halting Problem
asks for, then the Decider is the one having the problem. The existance
of the UTM means that the decider has the ability to recreate as much of
that behavior as it wants to see. Thus, the data is theoretically
available to it. It just needs to figure out the right way to process it.

Can D correctly simulated by H terminate normally?

Which again, isn't the question of the Halting Problem.

Yet professor Sipser seems to agree is equivalent and several people on
this forum took to be a tautology, AKA necessarily true.

Nope, you are just showing that you don't understand the meaning of the
words you use.

To anyone who understands the theory, your reference to "Correct
Simulation" means the simulation by a UTM, i.e a simulaiton that exactly reproduces the behavior of the machine the input describes. If H can
CORRECTLY determine that THAT simulation wouldn't halt (for exactly this
input, the includes the H that does eventually abort its simulation and
return 0) then H would be correct in aborting and returning zero.

Since that doesn't actually happen for THIS H (which is the only one
viewable in the problem) it can't use that excuse to be correct about
aborting and returning 0.

You seem to believe it is ok to reason from false premises, which seems
to be why you lie so much.

The x86utm operating system based on an open source x86 emulator. This
system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for
D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot
possibly terminate normally on the basis that H recognizes a dynamic
behavior pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above)
relationship to H.

The x86utm operating system (includes several termination analyzers)
https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition
https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15



*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

So, you are just admitting that none of you work applies to the
Halting Problem, but just your POOP which you are trying to make smell
better by calling it (incorrectly) a Termination Analyzer.

I am opening my work to the much broader field of termination analysis
where it is dead obvious that a termination analyzer is not allowed to
report on behavior that it can't see.

But still try to claim it applies to the Halting Problem, thus you are
just a liar.

And "Termination Analysis" also looks at the behavior of the actual
machine as the standard for decision. It may be that Termination
analysis allows restrictions on the programs it will decide on, but the
correct answer for any machine it does decide on is based on the actual behavior when run.

It isn't actually a "Termination Analyzer", because again, that theory
taks about the behavior of the actual program, and not that of the
decider, and the correct answer is if the actual program will terminate.

No that is not the case with software engineering. With software
engineering it is understood that when D correctly simulated by H cannot possibly reach its last instruction and terminate normally that D is correctly determined to be non-halting. It is much more clear in
software engineering that H is not supposed to be clairvoyant.

So, you are just admitting again that you aren't working on the actual
Halting Problem of Computation Theory and just lying through your teeth
why you say you have refuted the proof of that theorm

Since D(D) does terminate, you have shown that your POOP still stinks,
and you just can't help but being a liar.

If it absolutely true that D(D) does halt then H would never have to
abort its simulation of D. Because H must abort its simulation of D that proves from the frame-of-reference of H that D does not halt.

Which is a statement based on a LIE. Since H DOES abort its simulation,
you can't talk about if H doesn't abort, the program that doesn't abort
is not the H that D is based on, since it isn't the machine claimed to
give the right answer.

Thus, your "proof" is just lies and invalid logic.

All this becomes moot when we understand that any input D to
termination analyzer H that does the opposite of whatever Boolean value
H returns is a contradictory thus semantically incorrect input.

But not to a Halt Decider of Computability Thheory.

I guess you don't understand what the word ALL means.

Sorry, you are just showing that you writing is just a mass of error
and mistakes based on faulty assumptions resulting in erroneous answers.

You can't seem to keep yourself from lying about what you are doing.

If D actually does halt in an absolute sense then H would never need to
abort its simulation. Because H does need to abort its simulation then
from the frame-of-reference of H its input does not halt.

Right, H doesn't NEED to abort its simulation except for the fact that
it was programmed to do so in error.

H MUST do as programmed, so the whole idea of acting contrary to its programming is just invalid logic.

This is what breaks all your logic, you assume the impossible can
happen, and thus your whole system is based on false premises, and is
thus just unsound.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H.

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does
the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not make a decider that answers the exact question: "Does the machine represented
by the input halt".

That is not the whole question. Ignoring the context really does not
make this context go away.

The whole question is what Boolean value can H return that corresponds
to the behavior of D(D) when D does the opposite of whatever value that
H returns?

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct
answer only because the question itself contradictory, thus incorrect.

The fact that you think you can change the question and come up with a solution for that OTHER question (which isn't the actual Halting Problem
that you refer to), doesn't mean you have refuted that you can't
correctly answer the question you agreed can't be correctly answered.

When the halting problem question is understood to be incorrect then it
places no limit on computation and an equivalent question is required.

When H returns 1 for inputs that it determines do halt and returns 0
for
inputs that either do not halt or do the opposite of whatever Boolean
value that H returns then these pathological inputs are no longer
contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of the
Halting Problem, so your "Termination Analyzer" is NOT a "Solution to
the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So, you don't belive the requirements as stated are the requirement.

When I require you to provide a correct (yes or no) answer to the
question: What time is it? You can't do this because the question is
incorrect.

If I ask you to tell me whether or not the Liar Paradox
"This sentence is not true" is true or false you cannot answer because
it is a contradictory question.

I guess that means you believe it is ok to use strawmen instead of the
actual problem, and lie that you are doing the actual requirements.

It seems that myself and Professor Sipser agree that another criteria is equivalent. When H would never stop running unless H aborted its
simulation of D proves that D does not halt from the point of view of H.

If H does not abort D then H never halts this proves that not aborting
is D is incorrect.

YOU FAIL.

So if the halting problem requires its halt decider to report on
different behavior than it actually sees then the halting problem is
incorrect for another different reason.

If the Halt Decider doesn't see the behavior that the Halting Problem
asks for, then the Decider is the one having the problem. The existance
of the UTM means that the decider has the ability to recreate as much of
that behavior as it wants to see. Thus, the data is theoretically
available to it. It just needs to figure out the right way to process it.

Can D correctly simulated by H terminate normally?

Which again, isn't the question of the Halting Problem.

Yet professor Sipser seems to agree is equivalent and several people on
this forum took to be a tautology, AKA necessarily true.

Nope, you are just showing that you don't understand the meaning of the
words you use.

To anyone who understands the theory, your reference to "Correct
Simulation" means the simulation by a UTM, i.e a simulaiton that exactly reproduces the behavior of the machine the input describes. If H can CORRECTLY determine that THAT simulation wouldn't halt (for exactly this input, the includes the H that does eventually abort its simulation and return 0) then H would be correct in aborting and returning zero.

Since that doesn't actually happen for THIS H (which is the only one
viewable in the problem) it can't use that excuse to be correct about aborting and returning 0.

You seem to believe it is ok to reason from false premises, which seems
to be why you lie so much.

The x86utm operating system based on an open source x86 emulator. This >>>> system enables one C function to execute another C function in debug
step mode. When H simulates D it creates a separate process context for >>>> D with its own memory, stack and virtual registers. H is able to
simulate D simulating itself, thus the only limit to recursive
simulations is RAM.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06   int Halt_Status = H(x, x);
07   if (Halt_Status)
08     HERE: goto HERE;
09   return Halt_Status;
10 }
11
12 void main()
13 {
14   H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach its own line 09.

H correctly determines that D correctly simulated by H cannot
possibly terminate normally on the basis that H recognizes a dynamic
behavior pattern equivalent to infinite recursion.

H outputs: "H: Infinitely Recursive Simulation Detected Simulation
Stopped" indicating that D has defined a pathological (see above)
relationship to H.

The x86utm operating system (includes several termination analyzers)
https://github.com/plolcott/x86utm

It compiles with the 2017 version of the Community Edition
https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15



*Termination Analyzer H is Not Fooled by Pathological Input D*

https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

So, you are just admitting that none of you work applies to the
Halting Problem, but just your POOP which you are trying to make
smell better by calling it (incorrectly) a Termination Analyzer.

I am opening my work to the much broader field of termination analysis
where it is dead obvious that a termination analyzer is not allowed to
report on behavior that it can't see.

But still try to claim it applies to the Halting Problem, thus you are
just a liar.

And "Termination Analysis" also looks at the behavior of the actual
machine as the standard for decision. It may be that Termination
analysis allows restrictions on the programs it will decide on, but the correct answer for any machine it does decide on is based on the actual behavior when run.

It isn't actually a "Termination Analyzer", because again, that
theory taks about the behavior of the actual program, and not that of
the decider, and the correct answer is if the actual program will
terminate.

No that is not the case with software engineering. With software
engineering it is understood that when D correctly simulated by H cannot
possibly reach its last instruction and terminate normally that D is
correctly determined to be non-halting. It is much more clear in
software engineering that H is not supposed to be clairvoyant.

So, you are just admitting again that you aren't working on the actual Halting Problem of Computation Theory and just lying through your teeth
why you say you have refuted the proof of that theorm

Since D(D) does terminate, you have shown that your POOP still
stinks, and you just can't help but being a liar.

If it absolutely true that D(D) does halt then H would never have to
abort its simulation of D. Because H must abort its simulation of D that
proves from the frame-of-reference of H that D does not halt.

Which is a statement based on a LIE. Since H DOES abort its simulation,
you can't talk about if H doesn't abort, the program that doesn't abort
is not the H that D is based on, since it isn't the machine claimed to
give the right answer.

Thus, your "proof" is just lies and invalid logic.

All this becomes moot when we understand that any input D to
termination analyzer H that does the opposite of whatever Boolean value
H returns is a contradictory thus semantically incorrect input.

But not to a Halt Decider of Computability Thheory.

I guess you don't understand what the word ALL means.

Sorry, you are just showing that you writing is just a mass of error
and mistakes based on faulty assumptions resulting in erroneous answers. >>>
You can't seem to keep yourself from lying about what you are doing.

If D actually does halt in an absolute sense then H would never need to
abort its simulation. Because H does need to abort its simulation then
from the frame-of-reference of H its input does not halt.

Right, H doesn't NEED to abort its simulation except for the fact that
it was programmed to do so in error.

H MUST do as programmed, so the whole idea of acting contrary to its programming is just invalid logic.

This is what breaks all your logic, you assume the impossible can
happen, and thus your whole system is based on false premises, and is
thus just unsound.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no
answer to a contradictory question it cannot be solved. Any input D
defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative to H. >>>>

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does
the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not make
a decider that answers the exact question: "Does the machine
represented by the input halt".

That is not the whole question. Ignoring the context really does not
make this context go away.

No, that IS the whole question. Please show a relaible reference that
makes the question anything like what you are saying it is.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and give a
specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming things
that are not true, because you have made yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that corresponds
to the behavior of D(D) when D does the opposite of whatever value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND.

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct
answer only because the question itself contradictory, thus incorrect.

But only your altered question is contradictory, the original question
has a definite answer for all inputs.

You just don't understand what is being talked about and are replacing computations with some imaginary concept that just doesn't exist.

The fact that you think you can change the question and come up with a
solution for that OTHER question (which isn't the actual Halting
Problem that you refer to), doesn't mean you have refuted that you
can't correctly answer the question you agreed can't be correctly
answered.

When the halting problem question is understood to be incorrect then it places no limit on computation and an equivalent question is required.

Nope, the problem is the problem. If you think there is something wrong
with the question, then you can try to argue why that question is wrong,
but you don't get to change it. You can try to create an ALTERNATE field
with a different question, but that doesn't say anything about the
behavior of the original.

You just don't understand how things work, and thus you make yourself
inot a LIAR.

When H returns 1 for inputs that it determines do halt and returns
0 for
inputs that either do not halt or do the opposite of whatever Boolean >>>>> value that H returns then these pathological inputs are no longer
contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of
the Halting Problem, so your "Termination Analyzer" is NOT a
"Solution to the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So, you don't belive the requirements as stated are the requirement.

When I require you to provide a correct (yes or no) answer to the
question: What time is it? You can't do this because the question is incorrect.

SO? That isn't the question. You are just going off onto Red Herrings.

Your use of Red Herrings just shows that you are getting "desperate" as
your logic is falling apart, so you need a diversion away from the
actual truth.

Since you have started by changing the question, NOTHING You have said
applies to the actual problem, so everything you try to say about that
original problem is just a LIE.

If I ask you to tell me whether or not the Liar Paradox
"This sentence is not true" is true or false you cannot answer because
it is a contradictory question.

SO? Again, a Red Herring. The Liar's Paradox is a question that doesn't
have a truth value.

The Halt Question, "Does the machine represented by the input to the
decider Halt" always does, thus your claiming they are equivalent is
just a LIE.

Yes, your alternate question, which is just a Strawman, is very similar
to the Liar's Paradox, which is one reason you can't change the question
to that,

I guess that means you believe it is ok to use strawmen instead of the
actual problem, and lie that you are doing the actual requirements.

It seems that myself and Professor Sipser agree that another criteria is equivalent. When H would never stop running unless H aborted its
simulation of D proves that D does not halt from the point of view of H.

If H does not abort D then H never halts this proves that not aborting
is D is incorrect.

That isn't what he said, so you are just LYING agin. He didn't agree to
a different requirement, you provided an example of something you
claimed H could show and asked if it was good enough. He said it was,
but you H doesn't actually prove that condition, because you don't
understand what a "Correct Simulation" means in the field.

YOU used the wrong "Context" to the words, and thus were LYING.

Face it, you need to change the question because you know the original
question proves what it claims, but you just don't understand that once
you do that you are no longer dealing with the "Halting Problem of Computability Theory". but just with your stinky POOP.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no >>>>>> answer to a contradictory question it cannot be solved. Any input D >>>>>> defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative
to H.

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does
the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not make
a decider that answers the exact question: "Does the machine
represented by the input halt".

That is not the whole question. Ignoring the context really does not
make this context go away.

No, that IS the whole question. Please show a relaible reference that
makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an input, whether the program will finish running, or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and give a
specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming things
that are not true, because you have made yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that corresponds
to the behavior of D(D) when D does the opposite of whatever value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND.

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct
answer only because the question itself contradictory, thus incorrect.

But only your altered question is contradictory, the original question
has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are replacing computations with some imaginary concept that just doesn't exist.

The fact that you think you can change the question and come up with
a solution for that OTHER question (which isn't the actual Halting
Problem that you refer to), doesn't mean you have refuted that you
can't correctly answer the question you agreed can't be correctly
answered.

When the halting problem question is understood to be incorrect then
it places no limit on computation and an equivalent question is required.

Nope, the problem is the problem. If you think there is something wrong
with the question, then you can try to argue why that question is wrong,
but you don't get to change it. You can try to create an ALTERNATE field
with a different question, but that doesn't say anything about the
behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

When the halting problem question is understood to be incorrect for
a set of finite string pairs then the halting problem proofs
counter-examples (and thus the proof itself) becomes a mere ruse.

You just don't understand how things work, and thus you make yourself
inot a LIAR.

When H returns 1 for inputs that it determines do halt and returns >>>>>> 0 for
inputs that either do not halt or do the opposite of whatever Boolean >>>>>> value that H returns then these pathological inputs are no longer
contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of
the Halting Problem, so your "Termination Analyzer" is NOT a
"Solution to the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So, you don't belive the requirements as stated are the requirement.

When I require you to provide a correct (yes or no) answer to the
question: What time is it? You can't do this because the question is
incorrect.

SO? That isn't the question. You are just going off onto Red Herrings.

When the halting problem question:
"Does input halt?" is applied to the

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Your use of Red Herrings just shows that you are getting "desperate" as
your logic is falling apart, so you need a diversion away from the
actual truth.

It is the case that H does divide its input up three ways into halting non-halting and incorrect question. H recognizes and reject D as a
pathological input that does the opposite of whatever Boolean value that
H returns.

Since you have started by changing the question, NOTHING You have said applies to the actual problem, so everything you try to say about that original problem is just a LIE.

Everything that I said is about the fact that the actual problem is a
mere ruse, like betting someone ten dollars if the can correctly tell
you whether or not this sentence is true or false:
"This sentence is not true"
(1) They must sat true or false
(2) They must be correct
(3) Or they lose ten dollars.

If I ask you to tell me whether or not the Liar Paradox
"This sentence is not true" is true or false you cannot answer because
it is a contradictory question.

SO? Again, a Red Herring. The Liar's Paradox is a question that doesn't
have a truth value.

No element of the {TMD1, TMD2} finite string pairs has a correct
Boolean return value for input TMD2 to decider TMD1.

The Halt Question, "Does the machine represented by the input to the
decider Halt" always does, thus your claiming they are equivalent is
just a LIE.

It never does for every element of the {TMD1, TMD2} finite string pairs.

Yes, your alternate question, which is just a Strawman, is very similar
to the Liar's Paradox, which is one reason you can't change the question
to that,

It is merely the ordinary halting problem question:
Does this input halt?" applied to the

*The halting problem proof counter-example cases*
resulting in both true and false being incorrect return values
from every TMD1 for its corresponding TMD2 input that does the
opposite of whatever Boolean value that TMD1 returns.

I guess that means you believe it is ok to use strawmen instead of
the actual problem, and lie that you are doing the actual requirements.

It seems that myself and Professor Sipser agree that another criteria
is equivalent. When H would never stop running unless H aborted its
simulation of D proves that D does not halt from the point of view of H.

If H does not abort D then H never halts this proves that not aborting
is D is incorrect.

That isn't what he said,

MIT Professor Michael Sipser has agreed that the following verbatim
words are correct (he has not agreed to anything else):

(a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running
unless aborted then

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

It is correct that D correctly simulated by H never reaches its own last instruction from the point of view of H.

If it was absolutely true that TMD2 halts then there would be no need
for TMD1 to ever abort its simulation of TMD2. Therefore that TMD2 halts
is not true from an absolute point of view, it is only true relative to
the direct execution of TMD2(TMD2).

From the frame-of-reference of TMD1, TMD2 must be aborted because it
meets the spec and not aborting it crashes the system.

so you are just LYING agin. He didn't agree to
a different requirement, you provided an example of something you
claimed H could show and asked if it was good enough. He said it was,
but you H doesn't actually prove that condition, because you don't
understand what a "Correct Simulation" means in the field.

YOU used the wrong "Context" to the words, and thus were LYING.

Face it, you need to change the question because you know the original question proves what it claims, but you just don't understand that once
you do that you are no longer dealing with the "Halting Problem of Computability Theory". but just with your stinky POOP.

If we leave the concept of undecidability as it is then the question:
"What time is it (yes or no)?" becomes a correct yet undecidable
decision problem.

That people previously simply did not pay close enough attention to the
nuances of natural language semantics by making sure to ignore the full
context of the halting problem question merely proves that people
weren't paying complete attention. It does not prove that the question
is correct.

When the halting problem question: "Does the input halt?"
is applied to:

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.




--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no >>>>>>>> answer to a contradictory question it cannot be solved. Any input D >>>>>>>> defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative >>>>>>>> to H.

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does >>>>>> the opposite of whatever Boolean value that H returns the question: >>>>>> "Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not
make a decider that answers the exact question: "Does the machine
represented by the input halt".

That is not the whole question. Ignoring the context really does not
make this context go away.

No, that IS the whole question. Please show a relaible reference that
makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to run
forever.

Turing Machines don't HAVE "Context", they have an input, and give a
specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming
things that are not true, because you have made yourself IGNORANT of
the actual subjust.

The whole question is what Boolean value can H return that corresponds >>>> to the behavior of D(D) when D does the opposite of whatever value that >>>> H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND.

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct >>>> answer only because the question itself contradictory, thus incorrect.

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just doesn't
exist.

The fact that you think you can change the question and come up
with a solution for that OTHER question (which isn't the actual
Halting Problem that you refer to), doesn't mean you have refuted
that you can't correctly answer the question you agreed can't be
correctly answered.

When the halting problem question is understood to be incorrect then
it places no limit on computation and an equivalent question is
required.

Nope, the problem is the problem. If you think there is something
wrong with the question, then you can try to argue why that question
is wrong, but you don't get to change it. You can try to create an
ALTERNATE field with a different question, but that doesn't say
anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should predict
the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

It is very important that this issue is recognized because until it is recognized we can never have any AI that can reliably distinguish
between truth and falsehoods because the Tarski undefinability theorem
that is isomorphic to the Halting Problem proofs proves that True(L,x)
can never be defined.

If everyone believes that True(L,x) cannot be defined (even though
it can be defined) then no one will work on defining True(L,x) and
AI will be forever in the dark about True(L,x).

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct yes/no >>>>>>> answer to a contradictory question it cannot be solved. Any input D >>>>>>> defined to do the opposite of whatever Boolean value that its
termination analyzer H returns is a contradictory input relative >>>>>>> to H.

So, you agree with the Halting Theorem that says that a correct
Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that does >>>>> the opposite of whatever Boolean value that H returns the question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not
make a decider that answers the exact question: "Does the machine
represented by the input halt".

That is not the whole question. Ignoring the context really does not
make this context go away.

No, that IS the whole question. Please show a relaible reference that
makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to run
forever.

Turing Machines don't HAVE "Context", they have an input, and give a
specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming things
that are not true, because you have made yourself IGNORANT of the
actual subjust.

The whole question is what Boolean value can H return that corresponds
to the behavior of D(D) when D does the opposite of whatever value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND.

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct
answer only because the question itself contradictory, thus incorrect.

But only your altered question is contradictory, the original question
has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are replacing
computations with some imaginary concept that just doesn't exist.

The fact that you think you can change the question and come up with
a solution for that OTHER question (which isn't the actual Halting
Problem that you refer to), doesn't mean you have refuted that you
can't correctly answer the question you agreed can't be correctly
answered.

When the halting problem question is understood to be incorrect then
it places no limit on computation and an equivalent question is
required.

Nope, the problem is the problem. If you think there is something
wrong with the question, then you can try to argue why that question
is wrong, but you don't get to change it. You can try to create an
ALTERNATE field with a different question, but that doesn't say
anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should predict
the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't do that, thus
TMD1 is incorrect, and since NO TMD1 can be defined (with the TMD2 built
from TMD1 by the template) this means that it is IMPOSSIBLE to define a
TMD1 that is a correct Halt Decider.

Thus, this is a PROOF of the Halting Problem Theorem, not a refutation
of it.

Remember TMD2 is really TMD2(TMD1) as TMD2 is derived from the TMD1 it
is to confound.

When the halting problem question is understood to be incorrect for
a set of finite string pairs then the halting problem proofs
counter-examples (and thus the proof itself) becomes a mere ruse.

And what is incorrect about it?

Remember, TMD1, as a SPECIFIC string will always give a specific answer
for a given input, Thus, if we look at you two cases, and give them
distinct names we have TMDT1 and TMDF1 as the machines that return True
and false respectfully when applied to TMDT2 and TMDF2 (note, we get
DIFFERENT inputs for the two, since TMD2 is a function of the machine it
is designed for).

So we have UTM TMDT1 TMDT2 TMDT2 returns true, but UTM TMDT TMDT2 will
run forever by its design, and UTM TMDF1 TMDF2 TMDF2 returns false, but
UTM TMDF2 TMDF2 will halt.

In both cases TMDx1 is WRONG, and there IS a correct answer for the
question about its input, so there is no "contradiction".

You claimed contradiction is because you ignore that changing the
decider changes the input that will be give to it in the proof.

You just don't understand how things work, and thus you make yourself
inot a LIAR.

When H returns 1 for inputs that it determines do halt and
returns 0 for
inputs that either do not halt or do the opposite of whatever
Boolean
value that H returns then these pathological inputs are no longer >>>>>>> contradictory and become decidable.

So, you are admitting that you criteria is DIFFERENT then that of
the Halting Problem, so your "Termination Analyzer" is NOT a
"Solution to the Halting Problem"

No I am not. I do not believe that a termination analyzer can be
required to report on different behavior than the behavior that it
actually sees.

So, you don't belive the requirements as stated are the requirement.

When I require you to provide a correct (yes or no) answer to the
question: What time is it? You can't do this because the question is
incorrect.

SO? That isn't the question. You are just going off onto Red Herrings.

When the halting problem question:
"Does input halt?" is applied to the

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

And the correct answer for the TMDT1 machine is False, and the correct
answer for the TMDF1 machine is True, so both machines are just wrong,
and there is no actual "contradiction" since the machine are given
different input.

If you look at UTM TMDT1 TMDF2 TMDF2 then it gets the right answer, but
this isn't the "pathological" case of the proof, so the fact that it can
solve it doesn't show anything, except that you are a LIAR.

Your use of Red Herrings just shows that you are getting "desperate"
as your logic is falling apart, so you need a diversion away from the
actual truth.

It is the case that H does divide its input up three ways into halting non-halting and incorrect question. H recognizes and reject D as a pathological input that does the opposite of whatever Boolean value that
H returns.

But there is no "incorrect question", and you are just shown to be a
liar about working on the Halting Problem.

Also, your machine does NOT divide its input into 3 classes, as it only
returns 2 values. The Flibble decider gives 3 answers, but you reject
that, it list that one admits it isn't doing the actual halting problem,
for it, the only question would be if shcu a 3 way division is actually
useful for something.

Since you have started by changing the question, NOTHING You have said
applies to the actual problem, so everything you try to say about that
original problem is just a LIE.

Everything that I said is about the fact that the actual problem is a
mere ruse, like betting someone ten dollars if the can correctly tell
you whether or not this sentence is true or false:
"This sentence is not true"
(1) They must sat true or false
(2) They must be correct
(3) Or they lose ten dollars.

So, the fact that you don't understand the problem means it is just a ruse.

That is the sign of a weak mind.

Note, no one "loses" anything by the fact that Halting isn't decidable.
Even if we didn't ask that question, the effect of it still exist, it
just becomes a clear way to show the limits of the power of logic.

If I ask you to tell me whether or not the Liar Paradox
"This sentence is not true" is true or false you cannot answer
because it is a contradictory question.

SO? Again, a Red Herring. The Liar's Paradox is a question that
doesn't have a truth value.

No element of the {TMD1, TMD2} finite string pairs has a correct
Boolean return value for input TMD2 to decider TMD1.

So, that just means that no correct TMD1 exists, that isn't a problem
except in your mind,

You break your whole logic system to try to make an impossible thing
possible, which is much worse than known that there are limits to what
can be known.

The Halt Question, "Does the machine represented by the input to the
decider Halt" always does, thus your claiming they are equivalent is
just a LIE.

It never does for every element of the {TMD1, TMD2} finite string pairs.

????

Every UTM TMD2 TMD2 execution will either Halt or Not, so there is a
correct answer for EVERY case.

UTM TMD1 TMD2 TMD@ just never produces it.

Maybe your mind is incapable of any real intelegence and is stuck trying
to be artificially intelegent.

Yes, your alternate question, which is just a Strawman, is very
similar to the Liar's Paradox, which is one reason you can't change
the question to that,

It is merely the ordinary halting problem question:
Does this input halt?" applied to the

*The halting problem proof counter-example cases*
resulting in both true and false being incorrect return values
from every TMD1 for its corresponding TMD2 input that does the
opposite of whatever Boolean value that TMD1 returns.

No, it isn't.

You ask your question before you have defined TMD1, as asking about what
CAN it do to be correct, says you are asking how to program the machine,
so the program doesn't yet exist.

The actual quesition is asked AFTER you have actually designed your
machine, and at that point the answers are fixed, so we can see what
ACTUALLY happens for this case.

I guess that means you believe it is ok to use strawmen instead of
the actual problem, and lie that you are doing the actual requirements. >>>>

It seems that myself and Professor Sipser agree that another criteria
is equivalent. When H would never stop running unless H aborted its
simulation of D proves that D does not halt from the point of view of H. >>>
If H does not abort D then H never halts this proves that not
aborting is D is incorrect.

That isn't what he said,

MIT Professor Michael Sipser has agreed that the following verbatim
words are correct (he has not agreed to anything else):

(a) If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running
unless aborted then

So, *IF* H can *CORRECTLY* determine that a *CORRECT* simulation would
not halt. The only *CORRECT* simulation (in computablity theory) is a simulation that never aborts, then H can abort its simulation.

(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

But if H aborts its simulation, then H never does a correct simulation,
so the precondition was not satisfied. Remember if H aborts its
simulation, then its simulation is NOT correct by the definitions in place.

It is correct that D correctly simulated by H never reaches its own last instruction from the point of view of H.

Except that the statement is a contradiction. If H aborts its
simulation, it didn't correctly simulate its input, and if H correctly simulates its input, it never aborts its simulation to give an answer.

At best, H can conclude that it can't ever see the final state in its simulation of the input, but that isn't the same as non-halting.

If it was absolutely true that TMD2 halts then there would be no need
for TMD1 to ever abort its simulation of TMD2. Therefore that TMD2 halts
is not true from an absolute point of view, it is only true relative to
the direct execution of TMD2(TMD2).

Except that TMD1 has defined behavior that affects the code of TMD2. If
TMD1 is the TMD1N that never aborts, then TMD2N built on it, will in
fact be non-halting.

If TMD1 is TMD1A that tries to use this fact, it is given TMD2A, not
TMD2N, and UTM TMD2A TMD2A will halt, so TMD1A is wrong.

Yes UTM TMD1A TMD2N TMD2N will give a correct answer, but that isn't the
case that needs refuting, UTM TMD1A TMD2A TMD2A is the case, and it gets
that wrong.

You are just gaslighting yourself with your deceptive lies by reusing
progaram names.

From the frame-of-reference of TMD1, TMD2 must be aborted because it
meets the spec and not aborting it crashes the system.

Except that it doesn't, because each variation of TMD1 gets a different
TMD2. You keep missing that fact because you believe your own lies.

so you are just LYING agin. He didn't agree to a different
requirement, you provided an example of something you claimed H could
show and asked if it was good enough. He said it was, but you H
doesn't actually prove that condition, because you don't understand
what a "Correct Simulation" means in the field.

YOU used the wrong "Context" to the words, and thus were LYING.

Face it, you need to change the question because you know the original
question proves what it claims, but you just don't understand that
once you do that you are no longer dealing with the "Halting Problem
of Computability Theory". but just with your stinky POOP.

If we leave the concept of undecidability as it is then the question:
"What time is it (yes or no)?" becomes a correct yet undecidable
decision problem.

Nope. Red Herring.

The Halting Question HAS a valid answer as the input either Halts or not.

The input is just cleverly designed so THIS decider won't get the right
answer.

That people previously simply did not pay close enough attention to the nuances of natural language semantics by making sure to ignore the full context of the halting problem question merely proves that people
weren't paying complete attention. It does not prove that the question
is correct.

Nope, you aren't paying attention and d

When the halting problem question: "Does the input halt?"
is applied to:

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You keep repeating that statement, and it is still wrong.

Remember TMD2 is actually a function of TMD1, so you need to keep that
into account. Failure to do so just shows that you are being a LIAR.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct >>>>>>>>>> yes/no
answer to a contradictory question it cannot be solved. Any >>>>>>>>>> input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>>> termination analyzer H returns is a contradictory input
relative to H.

So, you agree with the Halting Theorem that says that a correct >>>>>>>>> Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that >>>>>>>> does
the opposite of whatever Boolean value that H returns the question: >>>>>>>> "Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct >>>>>>> answer, which is EXACTLY what the theorem says, that you can not >>>>>>> make a decider that answers the exact question: "Does the machine >>>>>>> represented by the input halt".

That is not the whole question. Ignoring the context really does not >>>>>> make this context go away.

No, that IS the whole question. Please show a relaible reference
that makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever >>>> Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue
to run forever.

Turing Machines don't HAVE "Context", they have an input, and give
a specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming
things that are not true, because you have made yourself IGNORANT
of the actual subjust.

The whole question is what Boolean value can H return that
corresponds
to the behavior of D(D) when D does the opposite of whatever value >>>>>> that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND. >>>>>

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a
correct
answer only because the question itself contradictory, thus
incorrect.

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just
doesn't exist.

The fact that you think you can change the question and come up
with a solution for that OTHER question (which isn't the actual
Halting Problem that you refer to), doesn't mean you have refuted >>>>>>> that you can't correctly answer the question you agreed can't be >>>>>>> correctly answered.

When the halting problem question is understood to be incorrect
then it places no limit on computation and an equivalent question
is required.

Nope, the problem is the problem. If you think there is something
wrong with the question, then you can try to argue why that
question is wrong, but you don't get to change it. You can try to
create an ALTERNATE field with a different question, but that
doesn't say anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should
predict the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't do
that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return
values from H will not correspond to the behavior of the directly
executed D(D).

Within the context of who is being asked Jack's question and the D
input to H have no correct answer / return value only because the
question / input is contradictory within this context even though it is
not contradictory in other different contexts.

If I ask you if you are a little girl the correct answer is no. If I ask
a little girl the exact same question it has a different answer because
the context of who is asked changes the meaning of the question.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct >>>>>>>>> yes/no
answer to a contradictory question it cannot be solved. Any
input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>> termination analyzer H returns is a contradictory input
relative to H.

So, you agree with the Halting Theorem that says that a correct >>>>>>>> Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D that >>>>>>> does
the opposite of whatever Boolean value that H returns the question: >>>>>>> "Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the correct
answer, which is EXACTLY what the theorem says, that you can not
make a decider that answers the exact question: "Does the machine
represented by the input halt".

That is not the whole question. Ignoring the context really does not >>>>> make this context go away.

No, that IS the whole question. Please show a relaible reference
that makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and
an input, whether the program will finish running, or continue to
run forever.

Turing Machines don't HAVE "Context", they have an input, and give a
specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming
things that are not true, because you have made yourself IGNORANT of
the actual subjust.

The whole question is what Boolean value can H return that corresponds >>>>> to the behavior of D(D) when D does the opposite of whatever value
that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system UNSOUND. >>>>

You can either fail to comprehend this or pretend to fail to
comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a correct >>>>> answer only because the question itself contradictory, thus incorrect. >>>>

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just doesn't
exist.

The fact that you think you can change the question and come up
with a solution for that OTHER question (which isn't the actual
Halting Problem that you refer to), doesn't mean you have refuted
that you can't correctly answer the question you agreed can't be
correctly answered.

When the halting problem question is understood to be incorrect
then it places no limit on computation and an equivalent question
is required.

Nope, the problem is the problem. If you think there is something
wrong with the question, then you can try to argue why that question
is wrong, but you don't get to change it. You can try to create an
ALTERNATE field with a different question, but that doesn't say
anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should
predict the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't do
that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been
determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

It is very important that this issue is recognized because until it is recognized we can never have any AI that can reliably distinguish
between truth and falsehoods because the Tarski undefinability theorem
that is isomorphic to the Halting Problem proofs proves that True(L,x)
can never be defined.

Except you don't seem to understand that programs don't have free-will
and their behavior is defined by their program, which is fixed.

If everyone believes that True(L,x) cannot be defined (even though
it can be defined) then no one will work on defining True(L,x) and
AI will be forever in the dark about True(L,x).

Except you don't understand what was meant by True(L,x), so your
argument is just bogus.


You are just proving that you speak out of stupiditiy.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct >>>>>>>>>>>> yes/no
answer to a contradictory question it cannot be solved. Any >>>>>>>>>>>> input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>>>>> termination analyzer H returns is a contradictory input >>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a
correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D >>>>>>>>>> that does
the opposite of whatever Boolean value that H returns the
question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the
correct answer, which is EXACTLY what the theorem says, that >>>>>>>>> you can not make a decider that answers the exact question:
"Does the machine represented by the input halt".

That is not the whole question. Ignoring the context really does >>>>>>>> not
make this context go away.

No, that IS the whole question. Please show a relaible reference >>>>>>> that makes the question anything like what you are saying it is. >>>>>>>

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1 >>>>>> is a decider and TMD2 is its input. TMD2 does the opposite of
whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>> return values are the wrong answer for their corresponding input TMD2 >>>>>> because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>> returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program >>>>>>> and an input, whether the program will finish running, or
continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and
give a specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming
things that are not true, because you have made yourself IGNORANT >>>>>>> of the actual subjust.

The whole question is what Boolean value can H return that
corresponds
to the behavior of D(D) when D does the opposite of whatever
value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the >>>>>>> Strawman is a valid logic form, which makes your logic system
UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>> comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a >>>>>>>> correct
answer only because the question itself contradictory, thus
incorrect.

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>> return values are the wrong answer for their corresponding input TMD2 >>>>>> because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>> returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just
doesn't exist.

The fact that you think you can change the question and come up >>>>>>>>> with a solution for that OTHER question (which isn't the actual >>>>>>>>> Halting Problem that you refer to), doesn't mean you have
refuted that you can't correctly answer the question you agreed >>>>>>>>> can't be correctly answered.

When the halting problem question is understood to be incorrect >>>>>>>> then it places no limit on computation and an equivalent
question is required.

Nope, the problem is the problem. If you think there is something >>>>>>> wrong with the question, then you can try to argue why that
question is wrong, but you don't get to change it. You can try to >>>>>>> create an ALTERNATE field with a different question, but that
doesn't say anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>> return values are the wrong answer for their corresponding input TMD2 >>>>>> because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>> returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should
predict the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't
do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been
determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return
values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your definition of H.

I am showing that the original halting question is contradictory for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the
opposite of whatever Boolean value that TM1 returns.

When I say that John has a black cat the fact that Harry has a black dog
is no rebuttal.

When I say that every input TMD2 is contradictory for its corresponding
TM1 the fact that it is not contradictory for TM2 is not a rebuttal.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a correct >>>>>>>>>>> yes/no
answer to a contradictory question it cannot be solved. Any >>>>>>>>>>> input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>>>> termination analyzer H returns is a contradictory input
relative to H.

So, you agree with the Halting Theorem that says that a
correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D
that does
the opposite of whatever Boolean value that H returns the
question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the
correct answer, which is EXACTLY what the theorem says, that you >>>>>>>> can not make a decider that answers the exact question: "Does
the machine represented by the input halt".

That is not the whole question. Ignoring the context really does not >>>>>>> make this context go away.

No, that IS the whole question. Please show a relaible reference
that makes the question anything like what you are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of whatever >>>>> Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2 >>>>> because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue >>>>>> to run forever.

Turing Machines don't HAVE "Context", they have an input, and give >>>>>> a specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming
things that are not true, because you have made yourself IGNORANT
of the actual subjust.

The whole question is what Boolean value can H return that
corresponds
to the behavior of D(D) when D does the opposite of whatever
value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the
Strawman is a valid logic form, which makes your logic system
UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>> comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a
correct
answer only because the question itself contradictory, thus
incorrect.

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2 >>>>> because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just
doesn't exist.

The fact that you think you can change the question and come up >>>>>>>> with a solution for that OTHER question (which isn't the actual >>>>>>>> Halting Problem that you refer to), doesn't mean you have
refuted that you can't correctly answer the question you agreed >>>>>>>> can't be correctly answered.

When the halting problem question is understood to be incorrect
then it places no limit on computation and an equivalent question >>>>>>> is required.

Nope, the problem is the problem. If you think there is something
wrong with the question, then you can try to argue why that
question is wrong, but you don't get to change it. You can try to
create an ALTERNATE field with a different question, but that
doesn't say anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false
return values are the wrong answer for their corresponding input TMD2 >>>>> because TMD2 does the opposite of whatever Boolean value that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should
predict the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't
do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been
determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return
values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your definition of H.

The Question given to H is "Does the machine represented by your input
Halt?". SInce you claim H is returning 0 correctly, it must be returning
0, and thus we know that the input WILL HALT.

Please show how that can be wrong for THIS H. You don't get to change
the input, and thus you don't get to change the H that D is built on.

This shows that you are just a LIAR.

Your probo

Within the context of who is being asked Jack's question and the D
input to H have no correct answer / return value only because the
question / input is contradictory within this context even though it is
not contradictory in other different contexts.

And since H has to have been defined to ask the question, the answer it
gives if fixed, (and is wrong), and the actual question has a difinative answer.

Since your H answers 0, D(D) Halts, so the correct answer was 1, and
thus H was wrong.

PERIOD.

If I ask you if you are a little girl the correct answer is no. If I ask
a little girl the exact same question it has a different answer because
the context of who is asked changes the meaning of the question.

Right, because the question has "YOU" in it, and the binding of the
pronoun changed.

The Halting problem doesn't have that same sort of thing happening. Yes,
the way we form the description of the machine might change based on the decider we are giving it to, but the thing being asked about, the
machine so descibed, doesn't change.

Note in particular, the question isn't about a machine based on the
decider, but that it must be able to handle ANY input, so one possible
input is a machine based on it. Thus, when we look at the answer to the question, we are asking ALL the deciders the exact same question, and
many of them can answer it, but we know that one in particular, the one
this particular input was based on, can't.

Note, to try to refute, you need to show that you can make a particular
decider ansswer the particular machine built on it, but the question is
still not self-referential, as the question is about the input that is
given without reference to how it was made, the "self-reference" is just
in the meta-logic.

You are just showing how stupid you are, and how poor you are at logic,
so you keep resorting to red herring.

I guess you must like fish.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be solved. Any >>>>>>>>>>>>> input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>>>>>> termination analyzer H returns is a contradictory input >>>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a >>>>>>>>>>>> correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D >>>>>>>>>>> that does
the opposite of whatever Boolean value that H returns the >>>>>>>>>>> question:
"Does D halt on its input" is a contradictory question.

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the
correct answer, which is EXACTLY what the theorem says, that >>>>>>>>>> you can not make a decider that answers the exact question: >>>>>>>>>> "Does the machine represented by the input halt".

That is not the whole question. Ignoring the context really
does not
make this context go away.

No, that IS the whole question. Please show a relaible reference >>>>>>>> that makes the question anything like what you are saying it is. >>>>>>>>

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1 >>>>>>> is a decider and TMD2 is its input. TMD2 does the opposite of
whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>> return values are the wrong answer for their corresponding input >>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>> returns.

The question is, and only is:

In computability theory, the halting problem is the problem of >>>>>>>> determining, from a description of an arbitrary computer program >>>>>>>> and an input, whether the program will finish running, or
continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and
give a specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming >>>>>>>> things that are not true, because you have made yourself
IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that
corresponds
to the behavior of D(D) when D does the opposite of whatever >>>>>>>>> value that
H returns?

Nope, you are changing the problem, thus you seem to beleive the >>>>>>>> Strawman is a valid logic form, which makes your logic system
UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>>> comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a >>>>>>>>> correct
answer only because the question itself contradictory, thus
incorrect.

But only your altered question is contradictory, the original
question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>> return values are the wrong answer for their corresponding input >>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>> returns.

You just don't understand what is being talked about and are
replacing computations with some imaginary concept that just
doesn't exist.

The fact that you think you can change the question and come >>>>>>>>>> up with a solution for that OTHER question (which isn't the >>>>>>>>>> actual Halting Problem that you refer to), doesn't mean you >>>>>>>>>> have refuted that you can't correctly answer the question you >>>>>>>>>> agreed can't be correctly answered.

When the halting problem question is understood to be incorrect >>>>>>>>> then it places no limit on computation and an equivalent
question is required.

Nope, the problem is the problem. If you think there is
something wrong with the question, then you can try to argue why >>>>>>>> that question is wrong, but you don't get to change it. You can >>>>>>>> try to create an ALTERNATE field with a different question, but >>>>>>>> that doesn't say anything about the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>> return values are the wrong answer for their corresponding input >>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>> returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should
predict the behavior of UTM TMD2 TMD2 if TMD1 was correct, doesn't >>>>>> do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been
determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return
values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your definition
of H.

I am showing that the original halting question is contradictory for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the
opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong any particular set, just that there does not exist any possible TMD1 that
gets the right answer for its TMD2, which just proves the Halting Problem.

Remember every TMD1 gives just a single answer for a given input, and
every different TMD1 generates a different TMD2 that it needs to get
right to be a counter example, so you can't look across elements for help.

When I say that John has a black cat the fact that Harry has a black dog
is no rebuttal.

When I say that every input TMD2 is contradictory for its corresponding
TM1 the fact that it is not contradictory for TM2 is not a rebuttal.

The problem is that the question of TMD2 halts has a definite answer, so
isn't the same contrdiction of Jack's question.

Remember every different TMD1 creates a DIFFERENT TMD2, so you never
have a single TMD2 that generates contradictory answers for the Halting Question, thus, your claim of contradiction is rebutted.

Maybe the issue is you don't actually know what "contradictory" means.

I recently found a fairly simple explanation of the problem, and maybe
even you could understand what is being said.

https://www.youtube.com/watch?v=sG0obNcgNJM

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be solved. >>>>>>>>>>>>>> Any input D
defined to do the opposite of whatever Boolean value that its >>>>>>>>>>>>>> termination analyzer H returns is a contradictory input >>>>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a >>>>>>>>>>>>> correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D >>>>>>>>>>>> that does
the opposite of whatever Boolean value that H returns the >>>>>>>>>>>> question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the >>>>>>>>>>> correct answer, which is EXACTLY what the theorem says, that >>>>>>>>>>> you can not make a decider that answers the exact question: >>>>>>>>>>> "Does the machine represented by the input halt".

That is not the whole question. Ignoring the context really >>>>>>>>>> does not
make this context go away.

No, that IS the whole question. Please show a relaible
reference that makes the question anything like what you are >>>>>>>>> saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that TMD1 >>>>>>>> is a decider and TMD2 is its input. TMD2 does the opposite of
whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>> return values are the wrong answer for their corresponding input >>>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>> returns.

The question is, and only is:

In computability theory, the halting problem is the problem of >>>>>>>>> determining, from a description of an arbitrary computer
program and an input, whether the program will finish running, >>>>>>>>> or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and >>>>>>>>> give a specific output for every specific input.

You don't seem to understand this, and are incorrectly assuming >>>>>>>>> things that are not true, because you have made yourself
IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that >>>>>>>>>> corresponds
to the behavior of D(D) when D does the opposite of whatever >>>>>>>>>> value that
H returns?

Nope, you are changing the problem, thus you seem to beleive >>>>>>>>> the Strawman is a valid logic form, which makes your logic
system UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>>>> comprehend this yet the actual facts remain unchanged.

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have a >>>>>>>>>> correct
answer only because the question itself contradictory, thus >>>>>>>>>> incorrect.

But only your altered question is contradictory, the original >>>>>>>>> question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>> return values are the wrong answer for their corresponding input >>>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>> returns.

You just don't understand what is being talked about and are >>>>>>>>> replacing computations with some imaginary concept that just >>>>>>>>> doesn't exist.

The fact that you think you can change the question and come >>>>>>>>>>> up with a solution for that OTHER question (which isn't the >>>>>>>>>>> actual Halting Problem that you refer to), doesn't mean you >>>>>>>>>>> have refuted that you can't correctly answer the question you >>>>>>>>>>> agreed can't be correctly answered.

When the halting problem question is understood to be
incorrect then it places no limit on computation and an
equivalent question is required.

Nope, the problem is the problem. If you think there is
something wrong with the question, then you can try to argue >>>>>>>>> why that question is wrong, but you don't get to change it. You >>>>>>>>> can try to create an ALTERNATE field with a different question, >>>>>>>>> but that doesn't say anything about the behavior of the original. >>>>>>>>>

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>> return values are the wrong answer for their corresponding input >>>>>>>> TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>> returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should >>>>>>> predict the behavior of UTM TMD2 TMD2 if TMD1 was correct,
doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't been
determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return
values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your definition
of H.

I am showing that the original halting question is contradictory for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the
opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong any particular set, just that there does not exist any possible TMD1 that
gets the right answer for its TMD2, which just proves the Halting Problem.

We can know in advance that any answer that Jack provides and any return
value that TM1 returns on input TMD2 is the wrong answer / return value.

Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect
question.



--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 8:03 PM, olcott wrote:

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be solved. >>>>>>>>>>>>>>> Any input D
defined to do the opposite of whatever Boolean value that >>>>>>>>>>>>>>> its
termination analyzer H returns is a contradictory input >>>>>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a >>>>>>>>>>>>>> correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input D >>>>>>>>>>>>> that does
the opposite of whatever Boolean value that H returns the >>>>>>>>>>>>> question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>>

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the >>>>>>>>>>>> correct answer, which is EXACTLY what the theorem says, that >>>>>>>>>>>> you can not make a decider that answers the exact question: >>>>>>>>>>>> "Does the machine represented by the input halt".

That is not the whole question. Ignoring the context really >>>>>>>>>>> does not
make this context go away.

No, that IS the whole question. Please show a relaible
reference that makes the question anything like what you are >>>>>>>>>> saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that >>>>>>>>> TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of >>>>>>>>> whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>>> return values are the wrong answer for their corresponding
input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>>> returns.

The question is, and only is:

In computability theory, the halting problem is the problem of >>>>>>>>>> determining, from a description of an arbitrary computer
program and an input, whether the program will finish running, >>>>>>>>>> or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and >>>>>>>>>> give a specific output for every specific input.

You don't seem to understand this, and are incorrectly
assuming things that are not true, because you have made
yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that >>>>>>>>>>> corresponds
to the behavior of D(D) when D does the opposite of whatever >>>>>>>>>>> value that
H returns?

Nope, you are changing the problem, thus you seem to beleive >>>>>>>>>> the Strawman is a valid logic form, which makes your logic >>>>>>>>>> system UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>>>>> comprehend this yet the actual facts remain unchanged. >>>>>>>>>>>>

No, you don't seem to understand what you are saying.

You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have >>>>>>>>>>> a correct
answer only because the question itself contradictory, thus >>>>>>>>>>> incorrect.

But only your altered question is contradictory, the original >>>>>>>>>> question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>>> return values are the wrong answer for their corresponding
input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>>> returns.

You just don't understand what is being talked about and are >>>>>>>>>> replacing computations with some imaginary concept that just >>>>>>>>>> doesn't exist.

The fact that you think you can change the question and come >>>>>>>>>>>> up with a solution for that OTHER question (which isn't the >>>>>>>>>>>> actual Halting Problem that you refer to), doesn't mean you >>>>>>>>>>>> have refuted that you can't correctly answer the question >>>>>>>>>>>> you agreed can't be correctly answered.

When the halting problem question is understood to be
incorrect then it places no limit on computation and an
equivalent question is required.

Nope, the problem is the problem. If you think there is
something wrong with the question, then you can try to argue >>>>>>>>>> why that question is wrong, but you don't get to change it. >>>>>>>>>> You can try to create an ALTERNATE field with a different
question, but that doesn't say anything about the behavior of >>>>>>>>>> the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and false >>>>>>>>> return values are the wrong answer for their corresponding
input TMD2
because TMD2 does the opposite of whatever Boolean value that TMD1 >>>>>>>>> returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which should >>>>>>>> predict the behavior of UTM TMD2 TMD2 if TMD1 was correct,
doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory.

But the difference is that when we ask Jack, the answer hasn't
been determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded.

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return >>>>> values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your definition
of H.

I am showing that the original halting question is contradictory for the >>> set halting problem proof instances: {TM1, TMD2} where TMD2 does the
opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong any
particular set, just that there does not exist any possible TMD1 that
gets the right answer for its TMD2, which just proves the Halting
Problem.

We can know in advance that any answer that Jack provides and any return value that TM1 returns on input TMD2 is the wrong answer / return value.

Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

No, because for the halting Problem, TMD1 is a FIXED MACHINE in any
asking of the question, and their IS a correct answer to the question,
it just isn't the one that TMD1 gives.

That is the difference.

Thus, TMD1 is just WRONG, the question isn't a "Contradiction". TMD2
might have contradicted TMD1, but no contradiciton appears in the
question itself.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect
question.

Except you don't define "Contradiction" in a proper manner.

Remember, the Halting Question is about a SPECIFIC machine each time it
is asked, and for that SPECIFIC machine, there is a correct answer to
the question, "Does this machine Halt?", and that answer just happens to
be always that opposite of what your claimed correct decider, that the
input is constructed from gives.

Until you speify that decider, you don't have a question.

Thus, when you try your "set" concept, you need to evalutate the
question for each member of the set, and for each member of the set,
there *IS* a correct answer, so the question itself isn't
"Contradictory" in the manner that makes a question invalid. It HAS a
valid answer, it is just that the decider can never give it, thus the
problem is undecidable, not "invalid"

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 8:32 PM, olcott wrote:

On 6/23/2023 7:16 PM, Richard Damon wrote:

On 6/23/23 8:03 PM, olcott wrote:

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be solved. >>>>>>>>>>>>>>>>> Any input D
defined to do the opposite of whatever Boolean value >>>>>>>>>>>>>>>>> that its
termination analyzer H returns is a contradictory input >>>>>>>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a >>>>>>>>>>>>>>>> correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input >>>>>>>>>>>>>>> D that does
the opposite of whatever Boolean value that H returns the >>>>>>>>>>>>>>> question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>>>>

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the >>>>>>>>>>>>>> correct answer, which is EXACTLY what the theorem says, >>>>>>>>>>>>>> that you can not make a decider that answers the exact >>>>>>>>>>>>>> question: "Does the machine represented by the input halt". >>>>>>>>>>>>>>

That is not the whole question. Ignoring the context really >>>>>>>>>>>>> does not
make this context go away.

No, that IS the whole question. Please show a relaible >>>>>>>>>>>> reference that makes the question anything like what you are >>>>>>>>>>>> saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such >>>>>>>>>>> that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of >>>>>>>>>>> whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>>> TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem >>>>>>>>>>>> of determining, from a description of an arbitrary computer >>>>>>>>>>>> program and an input, whether the program will finish
running, or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, >>>>>>>>>>>> and give a specific output for every specific input.

You don't seem to understand this, and are incorrectly >>>>>>>>>>>> assuming things that are not true, because you have made >>>>>>>>>>>> yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that >>>>>>>>>>>>> corresponds
to the behavior of D(D) when D does the opposite of
whatever value that
H returns?

Nope, you are changing the problem, thus you seem to beleive >>>>>>>>>>>> the Strawman is a valid logic form, which makes your logic >>>>>>>>>>>> system UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>>>>>>> comprehend this yet the actual facts remain unchanged. >>>>>>>>>>>>>>

No, you don't seem to understand what you are saying. >>>>>>>>>>>>>>
You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot >>>>>>>>>>>>> have a correct
answer only because the question itself contradictory, thus >>>>>>>>>>>>> incorrect.

But only your altered question is contradictory, the
original question has a definite answer for all inputs. >>>>>>>>>>>>

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>>> TMD1
returns.

You just don't understand what is being talked about and are >>>>>>>>>>>> replacing computations with some imaginary concept that just >>>>>>>>>>>> doesn't exist.

The fact that you think you can change the question and >>>>>>>>>>>>>> come up with a solution for that OTHER question (which >>>>>>>>>>>>>> isn't the actual Halting Problem that you refer to), >>>>>>>>>>>>>> doesn't mean you have refuted that you can't correctly >>>>>>>>>>>>>> answer the question you agreed can't be correctly answered. >>>>>>>>>>>>>>

When the halting problem question is understood to be >>>>>>>>>>>>> incorrect then it places no limit on computation and an >>>>>>>>>>>>> equivalent question is required.

Nope, the problem is the problem. If you think there is >>>>>>>>>>>> something wrong with the question, then you can try to argue >>>>>>>>>>>> why that question is wrong, but you don't get to change it. >>>>>>>>>>>> You can try to create an ALTERNATE field with a different >>>>>>>>>>>> question, but that doesn't say anything about the behavior >>>>>>>>>>>> of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>>> TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which
should predict the behavior of UTM TMD2 TMD2 if TMD1 was
correct, doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory. >>>>>>>>

But the difference is that when we ask Jack, the answer hasn't >>>>>>>> been determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded. >>>>>>>>

This is not true. We know in advance that both of Jack's possible >>>>>>> answers are the wrong answer and we know in advance that both return >>>>>>> values from H will not correspond to the behavior of the directly >>>>>>> executed D(D).

Note, you are changing the Halting question. It is NOT "What can H >>>>>> return to be correct", as What H returns is FIXED by your
definition of H.

I am showing that the original halting question is contradictory
for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the >>>>> opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong
any particular set, just that there does not exist any possible TMD1
that gets the right answer for its TMD2, which just proves the
Halting Problem.

We can know in advance that any answer that Jack provides and any return >>> value that TM1 returns on input TMD2 is the wrong answer / return value. >>>
Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

No, because for the halting Problem, TMD1 is a FIXED MACHINE in any
asking of the question, and their IS a correct answer to the question,
it just isn't the one that TMD1 gives.

That is the difference.

Thus, TMD1 is just WRONG, the question isn't a "Contradiction". TMD2
might have contradicted TMD1, but no contradiciton appears in the
question itself.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect
question.

Except you don't define "Contradiction" in a proper manner.

That I don't define it in a conventional manner does not mean that I am defining it incorrectly.

No, but it means you can't use any attribute from the previous definition.

If you are going to make up a term, don't reuse an existing one.

This is just one of the ways you lie about things, you redefine terms
and try to pick and chose what you can import from the original terms
without trying to prove that you can. This is just more of your Hypocracy.

Remember, the Halting Question is about a SPECIFIC machine each time
it is asked,

No it is not. It is always about every element of the entire set of
{TM1, TMD2} (halting problem proof instance) pairs.

Every element INDIVIDUALLY,

A set is not a program, and you trying to make it one just shows your stupidity.

You are just admitting you don't have a bit of ground to stand on for
you claims.

You have proved yourself to be a Hypocritical Ignorant Pathological
Lying Insane Idiot.

Your work is in the trash heap.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 7:16 PM, Richard Damon wrote:

On 6/23/23 8:03 PM, olcott wrote:

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be solved. >>>>>>>>>>>>>>>> Any input D
defined to do the opposite of whatever Boolean value >>>>>>>>>>>>>>>> that its
termination analyzer H returns is a contradictory input >>>>>>>>>>>>>>>> relative to H.

So, you agree with the Halting Theorem that says that a >>>>>>>>>>>>>>> correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H input >>>>>>>>>>>>>> D that does
the opposite of whatever Boolean value that H returns the >>>>>>>>>>>>>> question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>>>

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives the >>>>>>>>>>>>> correct answer, which is EXACTLY what the theorem says, >>>>>>>>>>>>> that you can not make a decider that answers the exact >>>>>>>>>>>>> question: "Does the machine represented by the input halt". >>>>>>>>>>>>>

That is not the whole question. Ignoring the context really >>>>>>>>>>>> does not
make this context go away.

No, that IS the whole question. Please show a relaible
reference that makes the question anything like what you are >>>>>>>>>>> saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such that >>>>>>>>>> TMD1
is a decider and TMD2 is its input. TMD2 does the opposite of >>>>>>>>>> whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>> TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the problem >>>>>>>>>>> of determining, from a description of an arbitrary computer >>>>>>>>>>> program and an input, whether the program will finish
running, or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, and >>>>>>>>>>> give a specific output for every specific input.

You don't seem to understand this, and are incorrectly
assuming things that are not true, because you have made >>>>>>>>>>> yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return that >>>>>>>>>>>> corresponds
to the behavior of D(D) when D does the opposite of whatever >>>>>>>>>>>> value that
H returns?

Nope, you are changing the problem, thus you seem to beleive >>>>>>>>>>> the Strawman is a valid logic form, which makes your logic >>>>>>>>>>> system UNSOUND.

You can either fail to comprehend this or pretend to fail to >>>>>>>>>>>>>> comprehend this yet the actual facts remain unchanged. >>>>>>>>>>>>>

No, you don't seem to understand what you are saying. >>>>>>>>>>>>>
You yourself just said "It can not be solved".

When a question is construed as contradictory it cannot have >>>>>>>>>>>> a correct
answer only because the question itself contradictory, thus >>>>>>>>>>>> incorrect.

But only your altered question is contradictory, the original >>>>>>>>>>> question has a definite answer for all inputs.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>> TMD1
returns.

You just don't understand what is being talked about and are >>>>>>>>>>> replacing computations with some imaginary concept that just >>>>>>>>>>> doesn't exist.

The fact that you think you can change the question and >>>>>>>>>>>>> come up with a solution for that OTHER question (which >>>>>>>>>>>>> isn't the actual Halting Problem that you refer to), >>>>>>>>>>>>> doesn't mean you have refuted that you can't correctly >>>>>>>>>>>>> answer the question you agreed can't be correctly answered. >>>>>>>>>>>>>

When the halting problem question is understood to be
incorrect then it places no limit on computation and an >>>>>>>>>>>> equivalent question is required.

Nope, the problem is the problem. If you think there is
something wrong with the question, then you can try to argue >>>>>>>>>>> why that question is wrong, but you don't get to change it. >>>>>>>>>>> You can try to create an ALTERNATE field with a different >>>>>>>>>>> question, but that doesn't say anything about the behavior of >>>>>>>>>>> the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true and >>>>>>>>>> false
return values are the wrong answer for their corresponding >>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value that >>>>>>>>>> TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which
should predict the behavior of UTM TMD2 TMD2 if TMD1 was
correct, doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack.

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because
from their frame-of-reference their questions are contradictory. >>>>>>>

But the difference is that when we ask Jack, the answer hasn't
been determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded. >>>>>>>

This is not true. We know in advance that both of Jack's possible
answers are the wrong answer and we know in advance that both return >>>>>> values from H will not correspond to the behavior of the directly
executed D(D).

Note, you are changing the Halting question. It is NOT "What can H
return to be correct", as What H returns is FIXED by your
definition of H.

I am showing that the original halting question is contradictory for
the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the
opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong any
particular set, just that there does not exist any possible TMD1 that
gets the right answer for its TMD2, which just proves the Halting
Problem.

We can know in advance that any answer that Jack provides and any return
value that TM1 returns on input TMD2 is the wrong answer / return value.

Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

No, because for the halting Problem, TMD1 is a FIXED MACHINE in any
asking of the question, and their IS a correct answer to the question,
it just isn't the one that TMD1 gives.

That is the difference.

Thus, TMD1 is just WRONG, the question isn't a "Contradiction". TMD2
might have contradicted TMD1, but no contradiciton appears in the
question itself.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect
question.

Except you don't define "Contradiction" in a proper manner.

That I don't define it in a conventional manner does not mean that I am defining it incorrectly.

Remember, the Halting Question is about a SPECIFIC machine each time it
is asked,

No it is not. It is always about every element of the entire set of
{TM1, TMD2} (halting problem proof instance) pairs.



--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 8:32 PM, Richard Damon wrote:

On 6/23/23 9:16 PM, olcott wrote:

On 6/23/2023 7:55 PM, Richard Damon wrote:

On 6/23/23 8:32 PM, olcott wrote:

On 6/23/2023 7:16 PM, Richard Damon wrote:

On 6/23/23 8:03 PM, olcott wrote:

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be >>>>>>>>>>>>>>>>>>>> solved. Any input D
defined to do the opposite of whatever Boolean value >>>>>>>>>>>>>>>>>>>> that its
termination analyzer H returns is a contradictory >>>>>>>>>>>>>>>>>>>> input relative to H.

So, you agree with the Halting Theorem that says that >>>>>>>>>>>>>>>>>>> a correct Halting Decider can't be made? >>>>>>>>>>>>>>>>>>>
Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H >>>>>>>>>>>>>>>>>> input D that does
the opposite of whatever Boolean value that H returns >>>>>>>>>>>>>>>>>> the question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>>>>>>>

No, you confirmed it and refuted a Strawman. >>>>>>>>>>>>>>>>>
You just said that you can not create an H that gives >>>>>>>>>>>>>>>>> the correct answer, which is EXACTLY what the theorem >>>>>>>>>>>>>>>>> says, that you can not make a decider that answers the >>>>>>>>>>>>>>>>> exact question: "Does the machine represented by the >>>>>>>>>>>>>>>>> input halt".

That is not the whole question. Ignoring the context >>>>>>>>>>>>>>>> really does not
make this context go away.

No, that IS the whole question. Please show a relaible >>>>>>>>>>>>>>> reference that makes the question anything like what you >>>>>>>>>>>>>>> are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such >>>>>>>>>>>>>> that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite >>>>>>>>>>>>>> of whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>>> that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the >>>>>>>>>>>>>>> problem of determining, from a description of an >>>>>>>>>>>>>>> arbitrary computer program and an input, whether the >>>>>>>>>>>>>>> program will finish running, or continue to run forever. >>>>>>>>>>>>>>>
Turing Machines don't HAVE "Context", they have an input, >>>>>>>>>>>>>>> and give a specific output for every specific input. >>>>>>>>>>>>>>>
You don't seem to understand this, and are incorrectly >>>>>>>>>>>>>>> assuming things that are not true, because you have made >>>>>>>>>>>>>>> yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return >>>>>>>>>>>>>>>> that corresponds
to the behavior of D(D) when D does the opposite of >>>>>>>>>>>>>>>> whatever value that
H returns?

Nope, you are changing the problem, thus you seem to >>>>>>>>>>>>>>> beleive the Strawman is a valid logic form, which makes >>>>>>>>>>>>>>> your logic system UNSOUND.

You can either fail to comprehend this or pretend to >>>>>>>>>>>>>>>>>> fail to
comprehend this yet the actual facts remain unchanged. >>>>>>>>>>>>>>>>>

No, you don't seem to understand what you are saying. >>>>>>>>>>>>>>>>>
You yourself just said "It can not be solved". >>>>>>>>>>>>>>>>>

When a question is construed as contradictory it cannot >>>>>>>>>>>>>>>> have a correct
answer only because the question itself contradictory, >>>>>>>>>>>>>>>> thus incorrect.

But only your altered question is contradictory, the >>>>>>>>>>>>>>> original question has a definite answer for all inputs. >>>>>>>>>>>>>>>

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>>> that TMD1
returns.

You just don't understand what is being talked about and >>>>>>>>>>>>>>> are replacing computations with some imaginary concept >>>>>>>>>>>>>>> that just doesn't exist.

The fact that you think you can change the question and >>>>>>>>>>>>>>>>> come up with a solution for that OTHER question (which >>>>>>>>>>>>>>>>> isn't the actual Halting Problem that you refer to), >>>>>>>>>>>>>>>>> doesn't mean you have refuted that you can't correctly >>>>>>>>>>>>>>>>> answer the question you agreed can't be correctly >>>>>>>>>>>>>>>>> answered.

When the halting problem question is understood to be >>>>>>>>>>>>>>>> incorrect then it places no limit on computation and an >>>>>>>>>>>>>>>> equivalent question is required.

Nope, the problem is the problem. If you think there is >>>>>>>>>>>>>>> something wrong with the question, then you can try to >>>>>>>>>>>>>>> argue why that question is wrong, but you don't get to >>>>>>>>>>>>>>> change it. You can try to create an ALTERNATE field with >>>>>>>>>>>>>>> a different question, but that doesn't say anything about >>>>>>>>>>>>>>> the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>>> that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which >>>>>>>>>>>>> should predict the behavior of UTM TMD2 TMD2 if TMD1 was >>>>>>>>>>>>> correct, doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack. >>>>>>>>>>>

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because >>>>>>>>>>>> from their frame-of-reference their questions are
contradictory.

But the difference is that when we ask Jack, the answer
hasn't been determined until he actually gives an answer. >>>>>>>>>>>
When we ask H, the answer was determined the moment H was coded. >>>>>>>>>>>

This is not true. We know in advance that both of Jack's possible >>>>>>>>>> answers are the wrong answer and we know in advance that both >>>>>>>>>> return
values from H will not correspond to the behavior of the directly >>>>>>>>>> executed D(D).

Note, you are changing the Halting question. It is NOT "What >>>>>>>>> can H return to be correct", as What H returns is FIXED by your >>>>>>>>> definition of H.

I am showing that the original halting question is contradictory >>>>>>>> for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does >>>>>>>> the
opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong >>>>>>> any particular set, just that there does not exist any possible
TMD1 that gets the right answer for its TMD2, which just proves
the Halting Problem.

We can know in advance that any answer that Jack provides and any
return
value that TM1 returns on input TMD2 is the wrong answer / return
value.

Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

No, because for the halting Problem, TMD1 is a FIXED MACHINE in any
asking of the question, and their IS a correct answer to the
question, it just isn't the one that TMD1 gives.

That is the difference.

Thus, TMD1 is just WRONG, the question isn't a "Contradiction".
TMD2 might have contradicted TMD1, but no contradiciton appears in
the question itself.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect >>>>>> question.

Except you don't define "Contradiction" in a proper manner.

That I don't define it in a conventional manner does not mean that I am >>>> defining it incorrectly.

No, but it means you can't use any attribute from the previous
definition.

If you are going to make up a term, don't reuse an existing one. >
This is just one of the ways you lie about things, you redefine terms
and try to pick and chose what you can import from the original terms
without trying to prove that you can. This is just more of your
Hypocracy.

Remember, the Halting Question is about a SPECIFIC machine each
time it is asked,

No it is not. It is always about every element of the entire set of
{TM1, TMD2} (halting problem proof instance) pairs.

Every element INDIVIDUALLY,

Yes and you cannot tell that there is no integer N such that
N > 5 & N < 3 until after you try every element of the infinite
set of integers and can't find one that works.

Right, no integer individually meets the requirement.

But there IS an answer to the ACTUAL Halting Question, does the machine
given as a description, Halt.

In EVERY case, if UTM TMD1 TMD2 TMD2 returns Halting, then it is an
absolute fact that the answer to the question, which is the behavior of
UTM TMD2 TMD2 is to not halt, and if UTM TMD2 TMD2 TMD2 returns
non-halting, then it is a fact that UTM TMD2 TMD2 will Halt.

Thus there IS an answer for every case, so the question is not a contradiction.

Yes, no TMD1 gave the right answer, but that just means they all were
wrong, and when you show that this applies to ALL possible TMD1, we can
show that the Halting Question can not be computed. That doesn't make it
an invalid  question, it means it is an undecidable question.

On the other hand I can see that every element of the set of {TM1, TMD2}
where TMD2 does the opposite of the Boolean return value of TM1 does
contradict every TM1 that is intended to report on the behavior of TMD2.

But that doesn't matter as that isn't the question.

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for everyone
because the exact same word-for-word question is false for you.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for everyone because the exact same word-for-word question is false for you.

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

The Halting problem identifies the machine, by what input the decider is
given, and what machine it describes.

Your failure to understand THAT just shows you are STUPID.

You are just playing mind gaems with yourself, and losing.

Just think of what people are going to think of your mental capacity
when they read these conversation, you keep on going back to disproven arguements, thus showing you are incapable of learning.

Sorry.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 9:16 PM, olcott wrote:

On 6/23/2023 7:55 PM, Richard Damon wrote:

On 6/23/23 8:32 PM, olcott wrote:

On 6/23/2023 7:16 PM, Richard Damon wrote:

On 6/23/23 8:03 PM, olcott wrote:

On 6/23/2023 6:42 PM, Richard Damon wrote:

On 6/23/23 7:08 PM, olcott wrote:

On 6/23/2023 5:48 PM, Richard Damon wrote:

On 6/23/23 5:41 PM, olcott wrote:

On 6/23/2023 4:26 PM, Richard Damon wrote:

On 6/23/23 5:05 PM, olcott wrote:

On 6/23/2023 3:46 PM, Richard Damon wrote:

On 6/23/23 11:39 AM, olcott wrote:

On 6/23/2023 7:11 AM, Richard Damon wrote:

On 6/23/23 1:06 AM, olcott wrote:

On 6/22/2023 11:32 PM, Richard Damon wrote:

On 6/22/23 11:16 PM, olcott wrote:

On 6/22/2023 9:25 PM, Richard Damon wrote:

On 6/22/23 9:27 PM, olcott wrote:

When the halting problem is construed as requiring a >>>>>>>>>>>>>>>>>>> correct yes/no
answer to a contradictory question it cannot be >>>>>>>>>>>>>>>>>>> solved. Any input D
defined to do the opposite of whatever Boolean value >>>>>>>>>>>>>>>>>>> that its
termination analyzer H returns is a contradictory >>>>>>>>>>>>>>>>>>> input relative to H.

So, you agree with the Halting Theorem that says that >>>>>>>>>>>>>>>>>> a correct Halting Decider can't be made?

Then way are you trying to refute it?

I just refuted it. From the frame-of-reference of H >>>>>>>>>>>>>>>>> input D that does
the opposite of whatever Boolean value that H returns >>>>>>>>>>>>>>>>> the question:
"Does D halt on its input" is a contradictory question. >>>>>>>>>>>>>>>>

No, you confirmed it and refuted a Strawman.

You just said that you can not create an H that gives >>>>>>>>>>>>>>>> the correct answer, which is EXACTLY what the theorem >>>>>>>>>>>>>>>> says, that you can not make a decider that answers the >>>>>>>>>>>>>>>> exact question: "Does the machine represented by the >>>>>>>>>>>>>>>> input halt".

That is not the whole question. Ignoring the context >>>>>>>>>>>>>>> really does not
make this context go away.

No, that IS the whole question. Please show a relaible >>>>>>>>>>>>>> reference that makes the question anything like what you >>>>>>>>>>>>>> are saying it is.

*The halting problem proof counter-example cases*
There are a set of finite string pairs: {TMD1, TMD2} such >>>>>>>>>>>>> that TMD1
is a decider and TMD2 is its input. TMD2 does the opposite >>>>>>>>>>>>> of whatever
Boolean value that TMD1 returns.

For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>> that TMD1
returns.

The question is, and only is:

In computability theory, the halting problem is the >>>>>>>>>>>>>> problem of determining, from a description of an arbitrary >>>>>>>>>>>>>> computer program and an input, whether the program will >>>>>>>>>>>>>> finish running, or continue to run forever.

Turing Machines don't HAVE "Context", they have an input, >>>>>>>>>>>>>> and give a specific output for every specific input. >>>>>>>>>>>>>>
You don't seem to understand this, and are incorrectly >>>>>>>>>>>>>> assuming things that are not true, because you have made >>>>>>>>>>>>>> yourself IGNORANT of the actual subjust.

The whole question is what Boolean value can H return >>>>>>>>>>>>>>> that corresponds
to the behavior of D(D) when D does the opposite of >>>>>>>>>>>>>>> whatever value that
H returns?

Nope, you are changing the problem, thus you seem to >>>>>>>>>>>>>> beleive the Strawman is a valid logic form, which makes >>>>>>>>>>>>>> your logic system UNSOUND.

You can either fail to comprehend this or pretend to >>>>>>>>>>>>>>>>> fail to
comprehend this yet the actual facts remain unchanged. >>>>>>>>>>>>>>>>

No, you don't seem to understand what you are saying. >>>>>>>>>>>>>>>>
You yourself just said "It can not be solved". >>>>>>>>>>>>>>>>

When a question is construed as contradictory it cannot >>>>>>>>>>>>>>> have a correct
answer only because the question itself contradictory, >>>>>>>>>>>>>>> thus incorrect.

But only your altered question is contradictory, the >>>>>>>>>>>>>> original question has a definite answer for all inputs. >>>>>>>>>>>>>>

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>> that TMD1
returns.

You just don't understand what is being talked about and >>>>>>>>>>>>>> are replacing computations with some imaginary concept >>>>>>>>>>>>>> that just doesn't exist.

The fact that you think you can change the question and >>>>>>>>>>>>>>>> come up with a solution for that OTHER question (which >>>>>>>>>>>>>>>> isn't the actual Halting Problem that you refer to), >>>>>>>>>>>>>>>> doesn't mean you have refuted that you can't correctly >>>>>>>>>>>>>>>> answer the question you agreed can't be correctly answered. >>>>>>>>>>>>>>>>

When the halting problem question is understood to be >>>>>>>>>>>>>>> incorrect then it places no limit on computation and an >>>>>>>>>>>>>>> equivalent question is required.

Nope, the problem is the problem. If you think there is >>>>>>>>>>>>>> something wrong with the question, then you can try to >>>>>>>>>>>>>> argue why that question is wrong, but you don't get to >>>>>>>>>>>>>> change it. You can try to create an ALTERNATE field with a >>>>>>>>>>>>>> different question, but that doesn't say anything about >>>>>>>>>>>>>> the behavior of the original.

*The halting problem proof counter-example cases*
For the set of {TMD1 TMD2} finite string pairs both true >>>>>>>>>>>>> and false
return values are the wrong answer for their corresponding >>>>>>>>>>>>> input TMD2
because TMD2 does the opposite of whatever Boolean value >>>>>>>>>>>>> that TMD1
returns.

Turing Machines are NOT "Finite Strings".

They can be represented by finite strings.

And, all you are saying is that UTM TMD1 TMD2 TMD2, which >>>>>>>>>>>> should predict the behavior of UTM TMD2 TMD2 if TMD1 was >>>>>>>>>>>> correct, doesn't do that, thus

I am saying that the question:
"Does input D halt on input D" posed to H
is exactly isomorphic to the question:
"Will Jack's answer to this question be no?" posed to Jack. >>>>>>>>>>

You can say it, but its a lie.

Neither H nor Jack can answer their questions only because >>>>>>>>>>> from their frame-of-reference their questions are contradictory. >>>>>>>>>>

But the difference is that when we ask Jack, the answer hasn't >>>>>>>>>> been determined until he actually gives an answer.

When we ask H, the answer was determined the moment H was coded. >>>>>>>>>>

This is not true. We know in advance that both of Jack's possible >>>>>>>>> answers are the wrong answer and we know in advance that both >>>>>>>>> return
values from H will not correspond to the behavior of the directly >>>>>>>>> executed D(D).

Note, you are changing the Halting question. It is NOT "What can >>>>>>>> H return to be correct", as What H returns is FIXED by your
definition of H.

I am showing that the original halting question is contradictory >>>>>>> for the
set halting problem proof instances: {TM1, TMD2} where TMD2 does the >>>>>>> opposite of whatever Boolean value that TM1 returns.

Except that you don't actually show that there is any thing wrong
any particular set, just that there does not exist any possible
TMD1 that gets the right answer for its TMD2, which just proves
the Halting Problem.

We can know in advance that any answer that Jack provides and any
return
value that TM1 returns on input TMD2 is the wrong answer / return
value.

Furthermore we can know it is the wrong answer / return value
specifically because every answer / return value is contradicted.

No, because for the halting Problem, TMD1 is a FIXED MACHINE in any
asking of the question, and their IS a correct answer to the
question, it just isn't the one that TMD1 gives.

That is the difference.

Thus, TMD1 is just WRONG, the question isn't a "Contradiction". TMD2
might have contradicted TMD1, but no contradiciton appears in the
question itself.

The new part that I am adding (that you partially agreed to?)
Is that any question that contradicts every answer is an incorrect
question.

Except you don't define "Contradiction" in a proper manner.

That I don't define it in a conventional manner does not mean that I am
defining it incorrectly.

No, but it means you can't use any attribute from the previous
definition.

If you are going to make up a term, don't reuse an existing one. >
This is just one of the ways you lie about things, you redefine terms
and try to pick and chose what you can import from the original terms
without trying to prove that you can. This is just more of your
Hypocracy.

Remember, the Halting Question is about a SPECIFIC machine each time
it is asked,

No it is not. It is always about every element of the entire set of
{TM1, TMD2} (halting problem proof instance) pairs.

Every element INDIVIDUALLY,

Yes and you cannot tell that there is no integer N such that
N > 5 & N < 3 until after you try every element of the infinite
set of integers and can't find one that works.

Right, no integer individually meets the requirement.

But there IS an answer to the ACTUAL Halting Question, does the machine
given as a description, Halt.

In EVERY case, if UTM TMD1 TMD2 TMD2 returns Halting, then it is an
absolute fact that the answer to the question, which is the behavior of
UTM TMD2 TMD2 is to not halt, and if UTM TMD2 TMD2 TMD2 returns
non-halting, then it is a fact that UTM TMD2 TMD2 will Halt.

Thus there IS an answer for every case, so the question is not a
contradiction.

Yes, no TMD1 gave the right answer, but that just means they all were
wrong, and when you show that this applies to ALL possible TMD1, we can
show that the Halting Question can not be computed. That doesn't make it
an invalid question, it means it is an undecidable question.

On the other hand I can see that every element of the set of {TM1, TMD2} where TMD2 does the opposite of the Boolean return value of TM1 does contradict every TM1 that is intended to report on the behavior of TMD2.

But that doesn't matter as that isn't the question.

Every TMD2 defines a correct answer, so the question is valid.

When anyone disagrees with tautologies my first guess is that they are a liar. The actual case might really be that they are not too bright.

What Tautolgy? One that doesn't show what you are trying to prove?
Remember, you claim to be refuting the ACTUAL proof Halting Problem of Computation Theory, so if your arguement doesn't apply to that, you are
just lying.

*tautology* in logic, a statement so framed that it cannot be denied
without inconsistency. Thus, “All humans are mammals” is held to assert with regard to anything whatsoever that either it is not a human or it
is a mammal. But that universal “truth” follows not from any facts noted about real humans but only from the actual use of human and mammal and
is thus purely a matter of definition. https://www.britannica.com/topic/tautology

Right, So what Tautolgy THAT MATTERS are you claiming. That you can't
find a TMD1 that gives the answer is actually a proof of the thing you
are trying to refute, so your logic is 180 degrees backwards.

You confuse yourself by redefining terms and then forgetting that you
have done that and thus can't use any of the standard properties of the
term.

Without an explicit redefinition, using an alternate definition is just
a lie, and with an explicit redefinition, using a property that you
haven't proven still applies is a lie.

So, you have been lying.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for everyone
because the exact same word-for-word question is false for you.

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2
returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element
does the opposite of the value that this TM1 element returns.



--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false for you. >>>

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2
returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element
does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a single instance of the question in view.

That is exactly the same as your arguement about the question: "Are you
a gitl?". The fact that some people will answer yes and some no doesn't
make it a contradictory question, because each instance of the question
is asking about a different subject.

Thus, you haven't shown an actual problem with the Halting Question
(Does the machine described by the input Halt?) just that it is
impossible to find a answer, which is EXACTLY what the Halting Theorem
states, so you are not refuting its proof.

You just don't seem to understand what you are saying because you have
gaslit yourself with your false ideas.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false for
you.

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2
returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element
does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

That is exactly the same as your arguement about the question: "Are you
a gitl?". The fact that some people will answer yes and some no doesn't
make it a contradictory question, because each instance of the question
is asking about a different subject.

Thus, you haven't shown an actual problem with the Halting Question
(Does the machine described by the input Halt?) just that it is
impossible to find a answer, which is EXACTLY what the Halting Theorem states, so you are not refuting its proof.

You just don't seem to understand what you are saying because you have
gaslit yourself with your false ideas.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false for
you.

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2
returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element
does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct
Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

You are just proving that you don't understand how correct logic works.

That is exactly the same as your arguement about the question: "Are
you a gitl?". The fact that some people will answer yes and some no
doesn't make it a contradictory question, because each instance of the
question is asking about a different subject.

Thus, you haven't shown an actual problem with the Halting Question
(Does the machine described by the input Halt?) just that it is
impossible to find a answer, which is EXACTLY what the Halting Theorem
states, so you are not refuting its proof.

You just don't seem to understand what you are saying because you have
gaslit yourself with your false ideas.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false
for you.

Nooe, because THAT question uses a pronoun to reference what it is
talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2
returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element
does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct
Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid.

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false
for you.

Nooe, because THAT question uses a pronoun to reference what it is >>>>>> talking about, so the question veries based on who it is said to.

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2 >>>>> returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element >>>>> does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct
Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point out
that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid. >>>>>>>>

Thus the question: "Are you a little girl?" must be false for
everyone because the exact same word-for-word question is false >>>>>>>> for you.

Nooe, because THAT question uses a pronoun to reference what it
is talking about, so the question veries based on who it is said to. >>>>>>>

Referring every element of the infinite set of {TM1, TMD2} pairs
such that TMD2 does the opposite of whatever Boolean value that TMD2 >>>>>> returns.

Is the reason why no TM1 element of this set returns a value that
corresponds to the behavior of its TMD2 input that each TMD2 element >>>>>> does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a correct
Halt Decider, not that the Halting Question is self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point out
that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black
and you said you don't know you have to check them one at a time.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid. >>>>>>>>>

Thus the question: "Are you a little girl?" must be false for >>>>>>>>> everyone because the exact same word-for-word question is false >>>>>>>>> for you.

Nooe, because THAT question uses a pronoun to reference what it >>>>>>>> is talking about, so the question veries based on who it is said >>>>>>>> to.

Referring every element of the infinite set of {TM1, TMD2} pairs >>>>>>> such that TMD2 does the opposite of whatever Boolean value that TMD2 >>>>>>> returns.

Is the reason why no TM1 element of this set returns a value that >>>>>>> corresponds to the behavior of its TMD2 input that each TMD2 element >>>>>>> does the opposite of the value that this TM1 element returns.

Which means that you have proven it is impossible to make a
correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point
out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, but
a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black
and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which are
just lies.

Note, you didn't give the ACTUAL question you asked, because if you did,
it could be shown that you weren't asking what you are claiming you were asking.

This is just showing how ingrained lying is into you communication.

If you want to quote my actual lie, it would be appreciated, and if I
was actually incorrect, I will correct my statement.

I suspect, you will find that I didn't actually deny what you thought I
was denying, but the false assumption you were deriving from the statement.

You like saying the equivalent of:

1 + 1 = 2
Therefore, Sam is a big Cat.

Using the quoting of an actual true statement as support for an
statement that is actually unrelated statement (maybe that sounds a bit related).

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid. >>>>>>>>>>

Thus the question: "Are you a little girl?" must be false for >>>>>>>>>> everyone because the exact same word-for-word question is
false for you.

Nooe, because THAT question uses a pronoun to reference what it >>>>>>>>> is talking about, so the question veries based on who it is
said to.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value
that corresponds to the behavior of its TMD2 input that each
TMD2 element does the opposite of the value that this TM1
element returns.

Which means that you have proven it is impossible to make a
correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a >>>>>>> single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point
out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, but
a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black
and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which are
just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value
that corresponds to the behavior of its TMD2 input that each
TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid. >>>>>>>>>>>

Thus the question: "Are you a little girl?" must be false for >>>>>>>>>>> everyone because the exact same word-for-word question is >>>>>>>>>>> false for you.

Nooe, because THAT question uses a pronoun to reference what >>>>>>>>>> it is talking about, so the question veries based on who it is >>>>>>>>>> said to.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value >>>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>>>>> TMD2 element does the opposite of the value that this TM1
element returns.

Which means that you have proven it is impossible to make a
correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a >>>>>>>> single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point
out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION,
but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black
and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which are
just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value
that corresponds to the behavior of its TMD2 input that each
TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is always
true in every situation.

I guess you are just proving your ignorance.

Note, to this I replied:

Which means that you have proven it is impossible to make a
correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't a
single instance of the question in view.

So I didn't say the statement was FALSE, I said it didn't prove what you
wanted it to prove.

The fact that no TMD1 can exist that gives the right answer does NOT
mean the question is contradictory, but that the problem of designing a
halt decider is impossible.

Which EXACT question, including context, showed contradictory results.
Remember if you change TMD1, you change TMD2

Or, do you think the question "Are you a girl?" is a contradictory sentence.


GAME - SET - MATCH

You are proved to be a LIAR and an idiot that can't read normal English.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is valid. >>>>>>>>>>>>

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>> for everyone because the exact same word-for-word question >>>>>>>>>>>> is false for you.

Nooe, because THAT question uses a pronoun to reference what >>>>>>>>>>> it is talking about, so the question veries based on who it >>>>>>>>>>> is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value >>>>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>>>>>> TMD2 element does the opposite of the value that this TM1
element returns.

Which means that you have proven it is impossible to make a
correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't >>>>>>>>> a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse point
out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION,
but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black >>>> and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which are
just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value
that corresponds to the behavior of its TMD2 input that each
TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is always
true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?



--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>>> for everyone because the exact same word-for-word question >>>>>>>>>>>>> is false for you.

Nooe, because THAT question uses a pronoun to reference what >>>>>>>>>>>> it is talking about, so the question veries based on who it >>>>>>>>>>>> is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value >>>>>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>>>>>>> TMD2 element does the opposite of the value that this TM1 >>>>>>>>>>> element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>> correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there isn't >>>>>>>>>> a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse
point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION,
but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are black >>>>> and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which
are just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value
that corresponds to the behavior of its TMD2 input that each
TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

What is ACTUALY wrong with my statement?

You are just proving yourself to be a pathological lying idiot who
doesn't know how to use any logic.

You think throwing insults actually can prove an arguement.

At least I throw my insults BECAUSE I have proven my arguement, so it
isn't fallacious reasoning (like you use).

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>>>> for everyone because the exact same word-for-word question >>>>>>>>>>>>>> is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>> what it is talking about, so the question veries based on >>>>>>>>>>>>> who it is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value >>>>>>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>>>>>>>> TMD2 element does the opposite of the value that this TM1 >>>>>>>>>>>> element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>>> correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse
point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, >>>>>>> but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are
black
and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which
are just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value >>>>  >>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>  >>>>>>>> TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

What is ACTUALY wrong with my statement?

You are just proving yourself to be a pathological lying idiot who
doesn't know how to use any logic.

You think throwing insults actually can prove an arguement.

At least I throw my insults BECAUSE I have proven my arguement, so it
isn't fallacious reasoning (like you use).

In other words when I am obviously correct you spout out pure ad hominem because that is all that you have when you know that I am correct.



--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 4:10 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>>>>> for everyone because the exact same word-for-word >>>>>>>>>>>>>>> question is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>>> what it is talking about, so the question veries based on >>>>>>>>>>>>>> who it is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 input >>>>>>>>>>>>> that each TMD2 element does the opposite of the value that >>>>>>>>>>>>> this TM1 element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>>>> correct Halt Decider, not that the Halting Question is >>>>>>>>>>>> self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse
point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a
QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are >>>>>>> black
and you said you don't know you have to check them one at a time. >>>>>>>

So, still unable to provide refernce to show you statements which
are just lies.

Referring every element of the infinite set of {TM1, TMD2} >>>>>  >>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>  >>>>>>>> value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value >>>>>  >>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>  >>>>>>>> TMD2 element does the opposite of the value that this TM1 >>>>>  >>>>>>>> element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

What is ACTUALY wrong with my statement?

You are just proving yourself to be a pathological lying idiot who
doesn't know how to use any logic.

You think throwing insults actually can prove an arguement.

At least I throw my insults BECAUSE I have proven my arguement, so it
isn't fallacious reasoning (like you use).

In other words when I am obviously correct you spout out pure ad hominem because that is all that you have when you know that I am correct.

Nope, and the fact you can't actually point out where you see the error
means you are just spouting out pure LIES. Specify the actual error you
claim or you are just admitting your lock of basis.

Note, the fact that you don't even know the meaning of ad hominem shows
how stupid you are. I have never said you are wrong because you are
stupid, (that would be ad hominem) I show you are stupid because you
insist on wrong statements (that is just applying definitions)

You show you have no useful knowledge of how to do logic.

To you "Obviously correct" means that you think it must be correct, even
if it is actually wrong. Since you appear to have lost touch with
reality, this doesn't mean a lot

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>>>> for everyone because the exact same word-for-word question >>>>>>>>>>>>>> is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>> what it is talking about, so the question veries based on >>>>>>>>>>>>> who it is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a value >>>>>>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>>>>>>>> TMD2 element does the opposite of the value that this TM1 >>>>>>>>>>>> element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>>> correct Halt Decider, not that the Halting Question is
self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse
point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a QUESTION, >>>>>>> but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are
black
and you said you don't know you have to check them one at a time.

So, still unable to provide refernce to show you statements which
are just lies.

Referring every element of the infinite set of {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value >>>>  >>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>  >>>>>>>> TMD2 element does the opposite of the value that this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has property P.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be false >>>>>>>>>>>>>>> for everyone because the exact same word-for-word >>>>>>>>>>>>>>> question is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>>> what it is talking about, so the question veries based on >>>>>>>>>>>>>> who it is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 input >>>>>>>>>>>>> that each TMD2 element does the opposite of the value that >>>>>>>>>>>>> this TM1 element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>>>> correct Halt Decider, not that the Halting Question is >>>>>>>>>>>> self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse
point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a
QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are >>>>>>> black
and you said you don't know you have to check them one at a time. >>>>>>>

So, still unable to provide refernce to show you statements which
are just lies.

Referring every element of the infinite set of {TM1, TMD2} >>>>>  >>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>  >>>>>>>> value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a value >>>>>  >>>>>>>> that corresponds to the behavior of its TMD2 input that each >>>>>  >>>>>>>> TMD2 element does the opposite of the value that this TM1 >>>>>  >>>>>>>> element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has property P.

So?

I didn't disagree that every element of the set has a TMD2 that does the opposite of what TMD1 says. I disagreed that this mean the Halting
Question, i.e, the question of the behaivor of TMD2 has a problem. The
Halting Question ALWAYS has a correct answer, it is just that TMD1 never
gives it.

Thus, your claim that the Halting Question is just like the Liar's
paradox is a LIE, and your arguement is shown to be unsound.

You just keep fighting strawmen, and losing.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question is >>>>>>>>>>>>>>>>> valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>> false for everyone because the exact same word-for-word >>>>>>>>>>>>>>>> question is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>>>> what it is talking about, so the question veries based on >>>>>>>>>>>>>>> who it is said to.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>>>>>>>> value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 input >>>>>>>>>>>>>> that each TMD2 element does the opposite of the value that >>>>>>>>>>>>>> this TM1 element returns.

Which means that you have proven it is impossible to make a >>>>>>>>>>>>> correct Halt Decider, not that the Halting Question is >>>>>>>>>>>>> self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse >>>>>>>>> point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a
QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia are >>>>>>>> black
and you said you don't know you have to check them one at a time. >>>>>>>>

So, still unable to provide refernce to show you statements which >>>>>>> are just lies.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>  >>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>  >>>>>>>> value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a

value

that corresponds to the behavior of its TMD2 input that >>>>>> each
TMD2 element does the opposite of the value that this TM1 >>>>>>  >>>>>>>> element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has property P.

So?

I didn't disagree that every element of the set has a TMD2 that does the opposite of what TMD1 says. I disagreed that this mean the Halting
Question, i.e, the question of the behaivor of TMD2 has a problem. The Halting Question ALWAYS has a correct answer, it is just that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds to
the actual behavior of TMD2?


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote:

Every TMD2 defines a correct answer, so the question >>>>>>>>>>>>>>>>>> is valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>>> false for everyone because the exact same word-for-word >>>>>>>>>>>>>>>>> question is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>>>>> what it is talking about, so the question veries based >>>>>>>>>>>>>>>> on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of whatever >>>>>>>>>>>>>>> Boolean value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 input >>>>>>>>>>>>>>> that each TMD2 element does the opposite of the value >>>>>>>>>>>>>>> that this TM1 element returns.

Which means that you have proven it is impossible to make >>>>>>>>>>>>>> a correct Halt Decider, not that the Halting Question is >>>>>>>>>>>>>> self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>>>> isn't a single instance of the question in view.

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse >>>>>>>>>> point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a
QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia >>>>>>>>> are black
and you said you don't know you have to check them one at a time. >>>>>>>>>

So, still unable to provide refernce to show you statements
which are just lies.

Referring every element of the infinite set of {TM1, TMD2} >>>>>>>  >>>>>>>> pairs such that TMD2 does the opposite of whatever Boolean >>>>>>>  >>>>>>>> value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a >>>>>>> value
that corresponds to the behavior of its TMD2 input that >>>>>>> each
TMD2 element does the opposite of the value that this TM1 >>>>>>>  >>>>>>>> element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is
always true in every situation.

So you disagree that all of the black cats in Australia are black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has property P. >>>

So?

I didn't disagree that every element of the set has a TMD2 that does
the opposite of what TMD1 says. I disagreed that this mean the Halting
Question, i.e, the question of the behaivor of TMD2 has a problem. The
Halting Question ALWAYS has a correct answer, it is just that TMD1
never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds to
the actual behavior of TMD2?

That a problem with the programmer, or the fact that the function being
asked for isn't computable. It is NOT an indication that the problem is incorrect.

The fact that you can't create a program to compute the right value is a perfectly valid case, as computers can't computer everything.

In fact, if you look at the number of possible input -> output mappings
that can exist, and the number that are computable, the fraction that is computable is infinitesimal, so the fact that a given one isn't
computable isn't a surprise.

Did you look at the video I linked to the other day, it has a nice
simple explanation about these sorts of problems, and how Hilbert found
out his ideas (which you seem to share a lot of) just didn't work.

Mathematics, once sufficiently complicated, is not:

1) Complete, there are Truths that can not be proven
2) Provable Consistent within itself
3) Decidable, there are problems that can not be computed.

If you want these properties, you need to keep your mathematics very simple.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 4:08 PM, Richard Damon wrote:

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so the question >>>>>>>>>>>>>>>>>>> is valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>>>> false for everyone because the exact same
word-for-word question is false for you.

Nooe, because THAT question uses a pronoun to reference >>>>>>>>>>>>>>>>> what it is talking about, so the question veries based >>>>>>>>>>>>>>>>> on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of whatever >>>>>>>>>>>>>>>> Boolean value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 input >>>>>>>>>>>>>>>> that each TMD2 element does the opposite of the value >>>>>>>>>>>>>>>> that this TM1 element returns.

Which means that you have proven it is impossible to make >>>>>>>>>>>>>>> a correct Halt Decider, not that the Halting Question is >>>>>>>>>>>>>>> self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>>>>> isn't a single instance of the question in view. >>>>>>>>>>>>>>>

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong verse >>>>>>>>>>> point out that it doesn't prove what you want it to?

I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a
QUESTION, but a STATEMENT.

You seem to have category errors built into your brain.

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia >>>>>>>>>> are black
and you said you don't know you have to check them one at a time. >>>>>>>>>>

So, still unable to provide refernce to show you statements
which are just lies.

Referring every element of the infinite set of {TM1, >>>>>>>> TMD2}
pairs such that TMD2 does the opposite of whatever

Boolean

value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns a >>>>>>>> value
that corresponds to the behavior of its TMD2 input

that each

TMD2 element does the opposite of the value that this TM1 >>>>>>>>  >>>>>>>> element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is >>>>>>> always true in every situation.

So you disagree that all of the black cats in Australia are black? >>>>>> Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has
property P.

So?

I didn't disagree that every element of the set has a TMD2 that does
the opposite of what TMD1 says. I disagreed that this mean the
Halting Question, i.e, the question of the behaivor of TMD2 has a
problem. The Halting Question ALWAYS has a correct answer, it is just
that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds to
the actual behavior of TMD2?

That a problem with the programmer,

In other words the only reason that halting cannot be solved is
that every programmer in the universe is simply too stupid?

or the fact that the function being
asked for isn't computable.

In other words it can't be done simply because it just
can't be done, no circular reasoning here.

It is NOT an indication that the problem is
incorrect.

Why is halting not computable?

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 6:02 PM, Richard Damon wrote:

On 6/24/23 5:39 PM, olcott wrote:

On 6/24/2023 4:08 PM, Richard Damon wrote:

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so the >>>>>>>>>>>>>>>>>>>>> question is valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>>>>>> false for everyone because the exact same >>>>>>>>>>>>>>>>>>>> word-for-word question is false for you. >>>>>>>>>>>>>>>>>>>>

Nooe, because THAT question uses a pronoun to >>>>>>>>>>>>>>>>>>> reference what it is talking about, so the question >>>>>>>>>>>>>>>>>>> veries based on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of >>>>>>>>>>>>>>>>>> whatever Boolean value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 >>>>>>>>>>>>>>>>>> input that each TMD2 element does the opposite of the >>>>>>>>>>>>>>>>>> value that this TM1 element returns.

Which means that you have proven it is impossible to >>>>>>>>>>>>>>>>> make a correct Halt Decider, not that the Halting >>>>>>>>>>>>>>>>> Question is self-contradictory.

The problem is that since TMD2 changes in the set, >>>>>>>>>>>>>>>>> there isn't a single instance of the question in view. >>>>>>>>>>>>>>>>>

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong >>>>>>>>>>>>> verse point out that it doesn't prove what you want it to? >>>>>>>>>>>>>
I think you don't understand what you read and write. >>>>>>>>>>>>>
Also, how do you "ASK" a tautology. A Tautology isn't a >>>>>>>>>>>>> QUESTION, but a STATEMENT.

You seem to have category errors built into your brain. >>>>>>>>>>>>

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia >>>>>>>>>>>> are black
and you said you don't know you have to check them one at a >>>>>>>>>>>> time.

So, still unable to provide refernce to show you statements >>>>>>>>>>> which are just lies.

Referring every element of the infinite set of {TM1, >>>>>>>>>> TMD2}
pairs such that TMD2 does the opposite of whatever >>>>>>>>>> Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns >>>>>>>>>> a value
that corresponds to the behavior of its TMD2 input >>>>>>>>>> that each
TMD2 element does the opposite of the value that >>>>>>>>>> this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that >>>>>>>>> is always true in every situation.

So you disagree that all of the black cats in Australia are black? >>>>>>>> Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has
property P.

So?

I didn't disagree that every element of the set has a TMD2 that
does the opposite of what TMD1 says. I disagreed that this mean the
Halting Question, i.e, the question of the behaivor of TMD2 has a
problem. The Halting Question ALWAYS has a correct answer, it is
just that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds
to the actual behavior of TMD2?

That a problem with the programmer,

In other words the only reason that halting cannot be solved is
that every programmer in the universe is simply too stupid?

Nope, because it is mathematically shown not be computable (see below)

or the fact that the function being asked for isn't computable.

In other words it can't be done simply because it just
can't be done, no circular reasoning here.

It can't be done because the "pathological" program is a valid program.

Syntactically valid is not the same as semantically valid.

Every polar (yes/no) question that contradicts both answers is an
incorrect question. Likewise for inputs to a decider.


--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 5:39 PM, olcott wrote:

On 6/24/2023 4:08 PM, Richard Damon wrote:

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote:

On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so the question >>>>>>>>>>>>>>>>>>>> is valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>>>>> false for everyone because the exact same >>>>>>>>>>>>>>>>>>> word-for-word question is false for you. >>>>>>>>>>>>>>>>>>>

Nooe, because THAT question uses a pronoun to >>>>>>>>>>>>>>>>>> reference what it is talking about, so the question >>>>>>>>>>>>>>>>>> veries based on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of >>>>>>>>>>>>>>>>> whatever Boolean value that TMD2 returns.

Is the reason why no TM1 element of this set returns a >>>>>>>>>>>>>>>>> value that corresponds to the behavior of its TMD2 >>>>>>>>>>>>>>>>> input that each TMD2 element does the opposite of the >>>>>>>>>>>>>>>>> value that this TM1 element returns.

Which means that you have proven it is impossible to >>>>>>>>>>>>>>>> make a correct Halt Decider, not that the Halting >>>>>>>>>>>>>>>> Question is self-contradictory.

The problem is that since TMD2 changes in the set, there >>>>>>>>>>>>>>>> isn't a single instance of the question in view. >>>>>>>>>>>>>>>>

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out.

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong >>>>>>>>>>>> verse point out that it doesn't prove what you want it to? >>>>>>>>>>>>
I think you don't understand what you read and write.

Also, how do you "ASK" a tautology. A Tautology isn't a >>>>>>>>>>>> QUESTION, but a STATEMENT.

You seem to have category errors built into your brain. >>>>>>>>>>>

I asked you if a tautology is true and you denied it.

It is like I asked you if all of the black cats in Australia >>>>>>>>>>> are black
and you said you don't know you have to check them one at a >>>>>>>>>>> time.

So, still unable to provide refernce to show you statements >>>>>>>>>> which are just lies.

Referring every element of the infinite set of {TM1, >>>>>>>>> TMD2}
pairs such that TMD2 does the opposite of whatever >>>>>>>>> Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set returns >>>>>>>>> a value
that corresponds to the behavior of its TMD2 input >>>>>>>>> that each
TMD2 element does the opposite of the value that this >>>>>>>>> TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that is >>>>>>>> always true in every situation.

So you disagree that all of the black cats in Australia are black? >>>>>>> Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has
property P.

So?

I didn't disagree that every element of the set has a TMD2 that does
the opposite of what TMD1 says. I disagreed that this mean the
Halting Question, i.e, the question of the behaivor of TMD2 has a
problem. The Halting Question ALWAYS has a correct answer, it is
just that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds to
the actual behavior of TMD2?

That a problem with the programmer,

In other words the only reason that halting cannot be solved is
that every programmer in the universe is simply too stupid?

Nope, because it is mathematically shown not be computable (see below)

or the fact that the function being asked for isn't computable.

In other words it can't be done simply because it just
can't be done, no circular reasoning here.

It can't be done because the "pathological" program is a valid program.
Program complexity grows faster then the ability for it to analyze.

It is NOT an indication that the problem is incorrect.

Why is halting not computable?

Because computations are powerful enough to make their halting
uncomputable. It comes in part because one program can include another
within it, so a program can be programmed to act contray to any one
decider that is thought to be able to handle all cases. Thus every
decider can have an input taylored to defeat it.

You really need to view that video.

Why do you think it SHOULD be computable?

Remember, there are N^N different functions and only N computations to
try to do them, which makes trying to compute them all impossible.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/23 7:11 PM, olcott wrote:

On 6/24/2023 6:02 PM, Richard Damon wrote:

On 6/24/23 5:39 PM, olcott wrote:

On 6/24/2023 4:08 PM, Richard Damon wrote:

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote:

On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so the >>>>>>>>>>>>>>>>>>>>>> question is valid.

Thus the question: "Are you a little girl?" must be >>>>>>>>>>>>>>>>>>>>> false for everyone because the exact same >>>>>>>>>>>>>>>>>>>>> word-for-word question is false for you. >>>>>>>>>>>>>>>>>>>>>

Nooe, because THAT question uses a pronoun to >>>>>>>>>>>>>>>>>>>> reference what it is talking about, so the question >>>>>>>>>>>>>>>>>>>> veries based on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of >>>>>>>>>>>>>>>>>>> whatever Boolean value that TMD2 returns. >>>>>>>>>>>>>>>>>>>
Is the reason why no TM1 element of this set returns >>>>>>>>>>>>>>>>>>> a value that corresponds to the behavior of its TMD2 >>>>>>>>>>>>>>>>>>> input that each TMD2 element does the opposite of the >>>>>>>>>>>>>>>>>>> value that this TM1 element returns.

Which means that you have proven it is impossible to >>>>>>>>>>>>>>>>>> make a correct Halt Decider, not that the Halting >>>>>>>>>>>>>>>>>> Question is self-contradictory.

The problem is that since TMD2 changes in the set, >>>>>>>>>>>>>>>>>> there isn't a single instance of the question in view. >>>>>>>>>>>>>>>>>>

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out. >>>>>>>>>>>>>>>>

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong >>>>>>>>>>>>>> verse point out that it doesn't prove what you want it to? >>>>>>>>>>>>>>
I think you don't understand what you read and write. >>>>>>>>>>>>>>
Also, how do you "ASK" a tautology. A Tautology isn't a >>>>>>>>>>>>>> QUESTION, but a STATEMENT.

You seem to have category errors built into your brain. >>>>>>>>>>>>>

I asked you if a tautology is true and you denied it. >>>>>>>>>>>>>
It is like I asked you if all of the black cats in
Australia are black
and you said you don't know you have to check them one at a >>>>>>>>>>>>> time.

So, still unable to provide refernce to show you statements >>>>>>>>>>>> which are just lies.

Referring every element of the infinite set of >>>>>>>>>>> {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever >>>>>>>>>>> Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set

returns a value

that corresponds to the behavior of its TMD2 input >>>>>>>>>>> that each
TMD2 element does the opposite of the value that >>>>>>>>>>> this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that >>>>>>>>>> is always true in every situation.

So you disagree that all of the black cats in Australia are black? >>>>>>>>> Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has
property P.

So?

I didn't disagree that every element of the set has a TMD2 that
does the opposite of what TMD1 says. I disagreed that this mean
the Halting Question, i.e, the question of the behaivor of TMD2
has a problem. The Halting Question ALWAYS has a correct answer,
it is just that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds
to the actual behavior of TMD2?

That a problem with the programmer,

In other words the only reason that halting cannot be solved is
that every programmer in the universe is simply too stupid?

Nope, because it is mathematically shown not be computable (see below)

or the fact that the function being asked for isn't computable.

In other words it can't be done simply because it just
can't be done, no circular reasoning here.

It can't be done because the "pathological" program is a valid program.

Syntactically valid is not the same as semantically valid.

There is no "Semantic" limitation in the requirement of ALL PROGRAMS.

Every polar (yes/no) question that contradicts both answers is an
incorrect question. Likewise for inputs to a decider.

But it DOESN'T. You keep on forgetting that before we can ask the
question, we have fixed the H, so its answer is fixed.

Then the question is on the behavior of the machine represented by the
input, and that has a definite answer, so no problem.

Since your H(D,D) that you claim to be correct returns 0, the CORRECT
answer is 1, and H is just wrong, and you are shown to be a liar.

You keep on forgetting that the decider is a program that has been
actually designed, not something with the mystical "Get the Right
Answer" instruction.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 6/24/2023 6:51 PM, Richard Damon wrote:

On 6/24/23 7:11 PM, olcott wrote:

On 6/24/2023 6:02 PM, Richard Damon wrote:

On 6/24/23 5:39 PM, olcott wrote:

On 6/24/2023 4:08 PM, Richard Damon wrote:

On 6/24/23 4:59 PM, olcott wrote:

On 6/24/2023 3:41 PM, Richard Damon wrote:

On 6/24/23 4:35 PM, olcott wrote:

On 6/24/2023 2:31 PM, Richard Damon wrote:

On 6/24/23 3:22 PM, olcott wrote:

On 6/24/2023 1:19 PM, Richard Damon wrote:

On 6/24/23 1:42 PM, olcott wrote:

On 6/24/2023 12:29 PM, Richard Damon wrote:

On 6/24/23 1:01 PM, olcott wrote:

On 6/24/2023 11:37 AM, Richard Damon wrote:

On 6/24/23 11:57 AM, olcott wrote:

On 6/24/2023 10:13 AM, Richard Damon wrote:

On 6/24/23 9:53 AM, olcott wrote:

On 6/24/2023 6:16 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 6/23/23 10:44 PM, olcott wrote:

On 6/23/2023 9:14 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 6/23/23 9:46 PM, olcott wrote:

On 6/23/2023 8:32 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> Every TMD2 defines a correct answer, so the >>>>>>>>>>>>>>>>>>>>>>> question is valid.

Thus the question: "Are you a little girl?" must >>>>>>>>>>>>>>>>>>>>>> be false for everyone because the exact same >>>>>>>>>>>>>>>>>>>>>> word-for-word question is false for you. >>>>>>>>>>>>>>>>>>>>>>

Nooe, because THAT question uses a pronoun to >>>>>>>>>>>>>>>>>>>>> reference what it is talking about, so the question >>>>>>>>>>>>>>>>>>>>> veries based on who it is said to.

Referring every element of the infinite set of {TM1, >>>>>>>>>>>>>>>>>>>> TMD2} pairs such that TMD2 does the opposite of >>>>>>>>>>>>>>>>>>>> whatever Boolean value that TMD2 returns. >>>>>>>>>>>>>>>>>>>>
Is the reason why no TM1 element of this set returns >>>>>>>>>>>>>>>>>>>> a value that corresponds to the behavior of its TMD2 >>>>>>>>>>>>>>>>>>>> input that each TMD2 element does the opposite of >>>>>>>>>>>>>>>>>>>> the value that this TM1 element returns. >>>>>>>>>>>>>>>>>>>>

Which means that you have proven it is impossible to >>>>>>>>>>>>>>>>>>> make a correct Halt Decider, not that the Halting >>>>>>>>>>>>>>>>>>> Question is self-contradictory.

The problem is that since TMD2 changes in the set, >>>>>>>>>>>>>>>>>>> there isn't a single instance of the question in view. >>>>>>>>>>>>>>>>>>>

I asked you a tautology and you disagreed.

You asked a Red Herring, and I pointed it out. >>>>>>>>>>>>>>>>>

I asked a tautology and you denied it.

WHERE did I say that your statement was factually wrong >>>>>>>>>>>>>>> verse point out that it doesn't prove what you want it to? >>>>>>>>>>>>>>>
I think you don't understand what you read and write. >>>>>>>>>>>>>>>
Also, how do you "ASK" a tautology. A Tautology isn't a >>>>>>>>>>>>>>> QUESTION, but a STATEMENT.

You seem to have category errors built into your brain. >>>>>>>>>>>>>>

I asked you if a tautology is true and you denied it. >>>>>>>>>>>>>>
It is like I asked you if all of the black cats in >>>>>>>>>>>>>> Australia are black
and you said you don't know you have to check them one at >>>>>>>>>>>>>> a time.

So, still unable to provide refernce to show you statements >>>>>>>>>>>>> which are just lies.

Referring every element of the infinite set of >>>>>>>>>>>> {TM1, TMD2}
pairs such that TMD2 does the opposite of whatever >>>>>>>>>>>> Boolean
value that TMD2 returns.
;
Is the reason why no TM1 element of this set >>>>>>>>>>>> returns a value
that corresponds to the behavior of its TMD2 input >>>>>>>>>>>> that each
TMD2 element does the opposite of the value that >>>>>>>>>>>> this TM1
element returns.

Are all the black cats in Australia black?

So, what is the "Tautology" there? There is no STATEMENT that >>>>>>>>>>> is always true in every situation.

So you disagree that all of the black cats in Australia are >>>>>>>>>> black?
Maybe some of the black cats in Australia are white dogs?

Thats just bad logic speaking a Strawmen.

Every member of set X that has property P and property Q has
property P.

So?

I didn't disagree that every element of the set has a TMD2 that
does the opposite of what TMD1 says. I disagreed that this mean
the Halting Question, i.e, the question of the behaivor of TMD2
has a problem. The Halting Question ALWAYS has a correct answer, >>>>>>> it is just that TMD1 never gives it.

Why is it that TM1 cannot provide a Boolean value that corresponds >>>>>> to the actual behavior of TMD2?

That a problem with the programmer,

In other words the only reason that halting cannot be solved is
that every programmer in the universe is simply too stupid?

Nope, because it is mathematically shown not be computable (see below)

or the fact that the function being asked for isn't computable.

In other words it can't be done simply because it just
can't be done, no circular reasoning here.

It can't be done because the "pathological" program is a valid program.

Syntactically valid is not the same as semantically valid.

There is no "Semantic" limitation in the requirement of ALL PROGRAMS.

Every polar (yes/no) question that contradicts both answers is an
incorrect question. Likewise for inputs to a decider.

Can any decider X possibly correctly return any Boolean value to any
input Y that does the opposite of whatever Boolean value that X returns?
(a) Yes
(b) No
(c) Richard is a Troll

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)