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

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.

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

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.

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

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.

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

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.

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

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.

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).

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).

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

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.

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

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.

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

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.

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,

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.

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.

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.

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

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.

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