HH(PP,PP) correctly determines that its input never halts

[olcott]

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. https://en.wikipedia.org/wiki/Halting_problem

This definition of the halting problem measures correctness in a non-
pathological way, thus in the same way that ZFC (redefined set theory
and) eliminated Russell's Paradox the previously "impossible" input
ceases to be impossible.

In computability theory, the halting problem is the problem of defining
a machine that correctly determines from a description of an arbitrary
computer program and an input, whether or not its specified input pair
would terminate normally by reaching it own final state.

The conventional proofs do not actually show that such a machine cannot
be defined. HH(PP, PP) does correctly determine that its correctly
simulated input cannot possibly reach the final state of PP and
terminate normally. (See pages 5-6 of this paper)

https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem


If the simulation is incorrect then there must a line of the simulation
that behaves differently than what its corresponding line of machine-
code specifies.

On pages 5 and 6 the correct semantics of the x86 language conclusively
proves that PP correctly simulated by HH cannot possibly reach the final
state of PP and terminate normally.

HH correctly determines that PP never halts

void PP(ptr x)
{
int Halt_Status = HH(x, x);
if (Halt_Status)HERE:
goto HERE;
return;
}

int main()
{
HH(PP, PP);
}

All of my reviewers that disagreed that the input to HH(PP, PP) was
simulated correctly could not point to a single step of the simulation
of PP by HH where the execution trace of PP was not the exact behavior
that the x86 machine code of PP specified.

These reviewers seemed to believe that the execution trace of PP need
not have the same behavior that its machine code specifies. That is like
saying that 2 + 3 = 17 on the basis of arbitrary whim rather than
correct arithmetic.

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

[Richard Damon]

On 1/24/23 10:41 AM, olcott wrote:
> 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.  https://en.wikipedia.org/wiki/Halting_problem
>
> This definition of the halting problem measures correctness in a non-
> pathological way, thus in the same way that ZFC (redefined set theory
> and) eliminated Russell's Paradox the previously "impossible" input
> ceases to be impossible.
>
> In computability theory, the halting problem is the problem of defining
> a machine that correctly determines from a description of an arbitrary
> computer program and an input, whether or not its specified input pair
> would terminate normally by reaching it own final state.

Right, the Decider must decide if the actual running of the program
described by the input would halt when given the input that is the rest
of that input.

It is NOT asking if the

>
> The conventional proofs do not actually show that such a machine cannot
> be defined. HH(PP, PP) does correctly determine that its correctly
> simulated input cannot possibly reach the final state of PP and
> terminate normally. (See pages 5-6 of this paper)
>
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
> If the simulation is incorrect then there must a line of the simulation
> that behaves differently than what its corresponding line of machine-
> code specifies.

No, it is incorrect because it is incomplete.

You are just usong the INCORRECT definition of "Correct", and since you
have been told this in the past, it just shows that you are a LIAR about
this fact.

"Correct Simulation" is defined as a simulation that exactly matches the
actual behavior of the machine the input describes.

Thus the only possible correct simulation of the machine PP given input
PP is a simulation that shows it will halt, since that IS the behavior
that will happen when you run PP and give it the input PP, since you
have STIPULATED that HH(PP,PP) will return non-halting (0).

>
> On pages 5 and 6 the correct semantics of the x86 language conclusively
> proves that PP correctly simulated by HH cannot possibly reach the final
> state of PP and terminate normally.
>
> HH correctly determines that PP never halts

Then why will PP(PP) Halt snce PP(PP) will call HH(PP,PP) which will
return 0 and thus PP will return?

Either HH fails to meet the requirements of being a computation (being a
fixed mapping of inputs to outputs) or it gave an incorrect answer.

>
> void PP(ptr x)
> {
>   int Halt_Status = HH(x, x);
>   if (Halt_Status)HERE:
>     goto HERE;
>   return;
> }
>
> int main()
> {
>   HH(PP, PP);
> }
>
> All of my reviewers that disagreed that the input to HH(PP, PP) was
> simulated correctly could not point to a single step of the simulation
> of PP by HH where the execution trace of PP was not the exact behavior
> that the x86 machine code of PP specified.
>
> These reviewers seemed to believe that the execution trace of PP need
> not have the same behavior that its machine code specifies. That is like
> saying that 2 + 3 = 17 on the basis of arbitrary whim rather than
> correct arithmetic.
>

No, the execution trace of PP actually DOES need to match the behavior
of the code, and thus the call HH must actually act as if HH was
actually called and the behavior assumed of that call match what
HH(PP,PP) actual does, which is return 0.

You analysis looks at a DIFFERENT HH than actually presented, and thus
your claim that it "Correctly" simulated the input is just a LIE.

HH incorrectly simulates the call to HH as it presumes bhavior different
that what actually happens, because it presume a different HH.

[olcott]

It turns out that is incorrect. The ultimate measure of a correct
simulation is whether or not the simulated input exactly matches the
behavior specified by its machine code.

whether or not HH ever aborts its correct simulation of PP.

> You analysis looks at a DIFFERENT HH than actually presented, and thus
> your claim that it "Correctly" simulated the input is just a LIE.
>
> HH incorrectly simulates the call to HH as it presumes bhavior different
> that what actually happens, because it presume a different HH.

[Richard Damon]

Nope, Sourcd for that claim.

Prove it or you are admitting you are lying.

Remember, even YOU said that the correct answer for the Halt Decider is
whether THE PROGRAM (i.e. the one given as the input) would finish
runnibng (Halt) or not.

That makes as much sense as the logic that

If this statement is true, then Peter Olcott is a Pathological Lyihg Idiot.

proves that you are a Pathological Lying Idiot.

If HH can refer to a hypothetical simulation of a DIFFERENT set of op
codes to determine the correct answer just because that is one way to
interpret the words, your whole logic system falls to the above rule.

YOU FAIL.

HH NEVER DOES a correct simulation of the input, so by that reasoning
there is no corrct answer to the question, so HH is just always WRONG.

We don't need the faulty logic of the above statement, by your own
claims you are proving that you are the Pathological Lying Idiot.

You think that HH can answer about a DIFFERENT input than it was giving,
different because HH treats the HH that it calls as if it was a
different function than it is.

You know this, and by claiming it is correct, you show you are a LIAR.

That you keep repeating it show the Lying is Pathological.

That you seem to expect people to beleive it show you are an IDIOT.

[olcott]

Counter-examples cannot possibly exist.
Try and show any correct simulation where the simulator does not
simulate what the machine language specifies.

> Prove it or you are admitting you are lying.

It is dead obvious that I am correct. A simulator is only correct when
it simulates exactly what the machine code specifies and incorrect
otherwise.

[Richard Damon]

This is the counter example.

Since the direct eecution of the machine language of PP(PP) will Halt,
the correct simulation of it must match.

Since HH deterines that the call HH(PP,PP) will not return, it has
INCORRECTLY simulated that instruction,

Perhaps by NOT actually simulating it but using faulty logic, and thus
making an error.

>
>> Prove it or you are admitting you are lying.
>
> It is dead obvious that I am correct. A simulator is only correct when
> it simulates exactly what the machine code specifies and incorrect
> otherwise.
>

No, it is obviouys that you are wrong.

BY YOUR OWN DEFINITION at the begining, the CORRECT answer for the Halt
Decider is what the program actually does.

Since you stipulate that HH(PP,PP) will "correctly" return 0, you have
stipulated that it DOES return 0 (the correctly can be ignored, as you
can not stipulate correctness).

SInce H(H(PP,PP) returns 0, by trivial inspection of PP(PP) we see that
it will return, and thus BY THE DEFINITION of a halt decider, the
correct answer is Halting, so HH returning 0 is incorrect.

If you want to claim that the "correct simulation" of the input to
HH(PP,PP) and the direct execution of PP(PP) can differ, please show the
exact assembly instruction correctly simulated and executed where they
do differ.

Note, you have to show where that difference occurs for an actually
exucted and simulated instruction, of exactly the same assembly code
difffer.

You have a mental defect where you seem to not be able to distinguish
when to things are different. This is one definition of Insanity.

Your claim "eqivalent" rule is not equivalent and you insistance that
they are even though they give different answers shows this problem.

GET HELP.

[olcott]

That is merely a provably false assumption.

Try and provide a 100% specific counter-example where you show a line of
machine code such as [mov eax, 1] and the simulator simulates another
different line instead such as [push ebx] and the simulator is correct.

If no such counter-example exists then it is proven that the ultimate
measure of correct simulation is that the simulator simulates line-by-
line exactly what the machine code specifies.

[Richard Damon]

Then do so.

Remember, your HH has been admitted to return 0 from HH(PP,PP), and to
be a computation, it must do the same to EVERY call.

YOU have posted the execution trace of the direct execution of the
equivalent to PP, which shows it halts.

Are you admitting you are a liar?

>
> Try and provide a 100% specific counter-example where you show a line of
> machine code such as [mov eax, 1] and the simulator simulates another
> different line instead such as [push ebx] and the simulator is correct.

You simulation of the call HH says it will not return.

The actual execution of the program shows it does.

QED, the simulation is WRONG.
'

>
> If no such counter-example exists then it is proven that the ultimate
> measure of correct simulation is that the simulator simulates line-by-
> line exactly what the machine code specifies.
>

Nope, in fact making such a claim shows you are a hypocrite, dooed to go
to Hell (by your own quotes).

To be true, you need to show an actual coneection to the truth maker
axioms of the system.

You know, thing like you DEFINIION of what a Halt decider is, that the
correct answer is based on the actual execution.

You are just proving that you are a DOOM PATHALOGICAL LYING IDIOT.

[Richard Damon]

On 1/24/23 10:51 PM, olcott wrote:
> On 1/24/2023 9:40 PM, Richard Damon wrote:
>>
>> Since the direct eecution of the machine language of PP(PP) will Halt,
>> the correct simulation of it must match.
>>
>
> That is merely a provably false assumption.

Simple question for a counter.

You seem to be saying that when PP calls HH(PP,PP) then HH will not
return, but when main call HH(PP,PP) it will


Please show the first assembly instruction of these two exectution paths
that differ in operation.

Failure to provide this shows you are just a pathological liar.

[olcott]

You can see on pages 5-6 that PP correctly simulated by HH cannot
possibly reach it own final state.

https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

> Are you admitting you are a liar?

You should be smart enough to determine that I am not a Liar.
A mere Liar could not stay motivated for this long.
A mere liar would not have created an operating system.

>
>>
>> Try and provide a 100% specific counter-example where you show a line of
>> machine code such as [mov eax, 1] and the simulator simulates another
>> different line instead such as [push ebx] and the simulator is correct.
>
> You simulation of the call HH says it will not return.
>
> The actual execution of the program shows it does.

[Richard Damon]

But that isn't the questipon, since that question, like the Liar's
paradox has no answer.

The question, as you stated at the begining is what does the execution
of the program at the input do? (It Halts since HH(PP,PPP) is said to
return 0)

Which by the definition of a UTM, what does the simulation of a UTM of
this input do? (Which Halts, since HH(PP,PP) is said to return 0).

Since an actual Correct Simulation of this input Halts, any simulation
done by HH, if it was "Correct" needs to say the input will Halt.

Since HH's simulation, by your claims, says it doesn't halt, it, BY
DEFINNITION, can't be correct.

We can see the "error" in several ways:

1) First, the idea that the fact that a partial simulation being
"correct" by just matching the leading subset of the actual behaivor is,
by itself, enough to tell what the final results of the behavior, is
just an insaine idea. That is like saying you can tell how long a trail
is by walking the first 50 feet of it.

2) The idea that you have gathered enough information from the partial
simulation of PP up to the call to HH to predict is absurd. Since you
haven't traced into HH, you can't tell from the trace, what its behavior
will be, so you don't can't actually tell what will happen. If you use
the knowledge that it is matching yourself, then you need to use logic
that says it WILL do what you will do, so if you abort, it will abort,
so you can't just assume it will go on forevrer, unless you will do that.

This has been explained to you many times, your failure to see shows
your self imposed ignorance, and utter stupidity,

>
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
>
>> Are you admitting you are a liar?
>
> You should be smart enough to determine that I am not a Liar.
> A mere Liar could not stay motivated for this long.
> A mere liar would not have created an operating system.

No, you aren't a mere liar, you are a Pathological Lying Idiot.

You admit this because you didn't answer the question I put in my other
post.

You have just proved you can't tell the difference between same and
different.

>
>>
>>>
>>> Try and provide a 100% specific counter-example where you show a line of
>>> machine code such as [mov eax, 1] and the simulator simulates another
>>> different line instead such as [push ebx] and the simulator is correct.
>>
>> You simulation of the call HH says it will not return.
>>
>> The actual execution of the program shows it does.
>> --
> Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
> hits a target no one else can see." Arthur Schopenhauer
>

And an insane person tries to hit targets that are not there.

[olcott]

On 1/24/2023 10:22 PM, Richard Damon wrote:
> On 1/24/23 10:51 PM, olcott wrote:
>> On 1/24/2023 9:40 PM, Richard Damon wrote:
>>>
>>> Since the direct eecution of the machine language of PP(PP) will
>>> Halt, the correct simulation of it must match.
>>>
>>
>> That is merely a provably false assumption.
>
> Simple question for a counter.
>
> You seem to be saying that when PP calls HH(PP,PP) then HH will not
> return, but when main call HH(PP,PP) it will
>

Whenever a simulated P calls a simulated H, this simulated P cannot
possibly reach its final state.

Whenever a directly executed P calls a directly executed H, this
directly executed P reaches its final state.

>
> Please show the first assembly instruction of these two exectution paths
> that differ in operation.
>

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

On page 5 there are three calls to H(P,P) from P(P):
(1) The first one from directly executed P(P) eventually returns to
12f7.

(2) The second one causes the simulated P(P) to be simulated again.

(3) The third one from the second simulated P(P) would cause the
simulated P(P) to be simulated a third time is aborted.

[olcott]

That makes the Halting Problem ill-defined:

In the study of problem solving, any problem in which the initial state
or starting position, the allowable operations, and the goal state are
clearly specified, *and a unique solution can be shown to exist*

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947



Now finally Oxford agrees with me on this 8 years later:
Feb 20, 2015, 11:38:48 AM sci.lang
The logical law of polar questions

When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.

All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions
Copyright Olcott 2015
https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ


In the same way that ZFC eliminated Russell's Paradox by redefining set
theory to eliminate a key element of Russell's Paradox a set as a member
of itself, the Halting Problem is redefined eliminating its pathology.

The halting problem is the problem of defining a machine that correctly

determines from a description of an arbitrary computer program and an
input, whether or not its specified input pair would terminate normally

by reaching it own final state on the basis of its correct simulation of
this input pair.

MIT Professor Michael Sipser has agreed that the following verbatim
paragraph is correct (he has not reviewed or agreed to anything else):
If simulating halt decider H correctly simulates its input D until
H correctly determines that its simulated D would never stop running
unless aborted then H can abort its simulation of D and correctly
report that D specifies a non-halting sequence of configurations.

[Jeffrey Rubard]

"Yeah, right."

[Richard Damon]

No, your RESTATEMENT is ill-defined. The behavior of P is well defined
given a proper definition of H

H(P,P) can do one of 4 things, and can't do anything else.

1) H(P,P) can return 0, in which case P(P) will halt, and H is shown to
be wrong. This is what you claim your H does when directly called.

2) H(P,P) can retrun 1, in which case, P(P) will go into an infinite
loop, and H is shown to be wrong.

3) H(P,P) can just dies and halt and not return an answer, in which case
H fails to be the needed halt decider, and P(P) will be halting.

4) H(P,P) can get stuck in an infinte loop, and never return an answer,
in which case H fails to be the needed halt decider, and P(P) will be
non-halting. This is what you seem to claim is what H does when
simulated inside P.

>
> In the study of problem solving, any problem in which the initial state
> or starting position, the allowable operations, and the goal state are
> clearly specified, *and a unique solution can be shown to exist*

Right, and given an actual definition of the complete algorithm of H
(and 'Get the right answer' is NOT an complete algorithm) there is a
precise correct answer to the problem.

Unfortunately of H, H can never give that answer.

>
> https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
>
>
> Now finally Oxford agrees with me on this 8 years later:
> Feb 20, 2015, 11:38:48 AM  sci.lang
> The logical law of polar questions
>
> When posed to a man whom has never been married,
> the question: Have you stopped beating your wife?
> Is an incorrect polar question because neither yes nor
> no is a correct answer.

But That isn't what the halting problem is.

>
> All polar questions (including incorrect polar questions)
> have exactly one answer from the following:
> 1) No
> 2) Yes
> 3) Neither // Only applies to incorrect polar questions
> Copyright Olcott 2015
> https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
>

And the correct answer to the Halting Problem is always Yes or No.

The Polar question that yoyu are mistakenly replacing the halting
problem questiono is what answer should H give, that is NOT the actual
question.

>
> In the same way that ZFC eliminated Russell's Paradox by redefining set
> theory to eliminate a key element of Russell's Paradox a set as a member
> of itself, the Halting Problem is redefined eliminating its pathology.
>
> The halting problem is the problem of defining a machine that correctly
> determines from a description of an arbitrary computer program and an
> input, whether or not its specified input pair would terminate normally
> by reaching it own final state on the basis of its correct simulation of
> this input pair.

Right, and given an actual definition of your program H, we can
determine precisely the actual behavior of the program P, it will be
halting or non-halting.

>
> MIT Professor Michael Sipser has agreed that the following verbatim
> paragraph is correct (he has not reviewed or agreed to anything else):
>   If simulating halt decider H correctly simulates its input D until
>   H correctly determines that its simulated D would never stop running
>   unless aborted then H can abort its simulation of D and correctly
>   report that D specifies a non-halting sequence of configurations.
>

Right, if H CORRECTLY simulates its input until it CORRECTLY determining
the answer

H doesn't dp that. It may do a correct partial simulation, but then uses
an INCORRECT rules, that P(P) calling H(P,P) proves non-halting
behavior, so you can't use his answer.

Until you can actually PROVE that statement, you are just being a
hypocritical pathological liar stating it. You need to connect this
statement to the ACTUAL truth makers of the logic system (not your made
up one, those just make the system inconsistent)

You are just proving you don't understand the meaning of the word CORRECCT.

[Richard Damon]

On 1/25/23 11:28 AM, olcott wrote:
> On 1/24/2023 10:22 PM, Richard Damon wrote:
>> On 1/24/23 10:51 PM, olcott wrote:
>>> On 1/24/2023 9:40 PM, Richard Damon wrote:
>>>>
>>>> Since the direct eecution of the machine language of PP(PP) will
>>>> Halt, the correct simulation of it must match.
>>>>
>>>
>>> That is merely a provably false assumption.
>>
>> Simple question for a counter.
>>
>> You seem to be saying that when PP calls HH(PP,PP) then HH will not
>> return, but when main call HH(PP,PP) it will
>>
>
> Whenever a simulated P calls a simulated H, this simulated P cannot
> possibly reach its final state.

Why, a proper simulation of the H will see that it aborts its processing
are return non-halting.

H can't show that because H can't correctly simulate itself.

This is basically the same issue as a statement trying to assert about
its own truth.

>
> Whenever a directly executed P calls a directly executed H, this
> directly executed P reaches its final state.

Which shows that the simulation done by H is incorrect.

>
>>
>> Please show the first assembly instruction of these two exectution
>> paths that differ in operation.
>>
>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
> On page 5 there are three calls to H(P,P) from P(P):
> (1) The first one from directly executed P(P) eventually returns to
>     12f7.
>
> (2) The second one causes the simulated P(P) to be simulated again.
>
> (3) The third one from the second simulated P(P) would cause the
>     simulated P(P) to be simulated a third time is aborted.
>

And why do they behave "Differently"?

The CORRECT behavior, is what happens when main call P(P) which calls
H(P,P) which will go into the code of HH and eventally returs to
000012F7 and PP thus halts, This is your (1)

In (2) Why does the call the H(P,P) immediately cause P(P) to be
simulated again. That is NOT what happened in (1), so H is INCORRECT in
this simulation.

In (3) your describe behavior is again NOT what happened ib (1), so is
also incorrect. Yes, it is consistet which H's error of thinking that a
call to H(P,P) just immediately doing a call to P(P), but that isn't
what it actually dooes.

Thus NONE of H's simulation of calls to H(P,P) were correct, which is
why H gets the worn answer.

So you haven't actually shown what instruction CORRECTLY
executed/simulated differed, you have show that H doesn't correctly
simulate its input.

Remember, the code of H that P calls is part of the program P that H
needs to analyse/simulate.


YOU HAVE SHOWN YOU HAVE FAILED.

[olcott]

Thus making the halting problem ill-defined.

[olcott]

No machine can possibly be defined that divides all pairs of finite
strings into those that represent machines would halt on their input
when directly executed and those that do not in the same way and for the
same reason that there is no barber that shaves all and only those that
do not shave themselves. ZFC eliminated this problem by declaring it is
erroneous.

Every decision problem where
*a unique solution CANNOT be shown to exist*
is erroneous.

[Python]

Peter Olcott wrote:
...

> No machine can possibly be defined that divides all pairs of finite
> strings into those that represent machines would halt on their input
> when directly executed and those that do not

So at least you admit that there no program can be written that
is an halt decider! It took time for you to abandon your delusions!

All these years pretending you have written one... You should feel
sad, right? You shouldn't, at end you've admitted the obvious
truth.

Note that a function that is an halt decider is perfectly well
defined. So no, the "problem" is NOT ill-defined (whatever that
means).

[Richard Damon]

Why?


The question posed always hax an answer. It just is that the answer
can't be computed. Since it always has an answer, it is well defined.

YOUR alternate question, "What can H return to be correct?" is
ill-defined, not the Halting Problem.

It is just like not all truths can be proven.

This is a natural consequence of an expressive enough system.

You are just showing your mind it too small to comprehend the issue.

[Richard Damon]

Right, which shows that the Haltng Theorm is CORRECT, that that the
Halting Function is not computable.

So, you agree with the Theorem that you have been arguing against for 2
decades?

> Every decision problem where
> *a unique solution CANNOT be shown to exist*
> is erroneous.
>

Nope, just shows that the problem is not computable.

If you think uncompuatable problems are erroneous, then you can't handle
all of mathematics.

[Richard Damon]

One simple comment that comes to mind that points out the error in your
thinking:

The number of possible computing machines is a countable infinite,
because we can express every such machine as a finite string of a finite
symbol set.

The number of possible deciders that can be defined is an UNCOUNTABLE
infinite.

Thus, there are deciders that can not be computed, in fact, MOST
deciders can't be computed. (Admittedly a randomly chosen decider likely
isn't useful).

I suspect you aren't going to understand this, as you can't seem to
handle the actual concept of infinity.

[olcott]

On 1/25/2023 6:05 PM, Python wrote:
> Peter Olcott wrote:
> ...
>> No machine can possibly be defined that divides all pairs of finite
>> strings into those that represent machines would halt on their input
>> when directly executed and those that do not
>
> So at least you admit that there no program can be written that
> is an halt decider! It took time for you to abandon your delusions!
>

*I didn't say that* There is a program H that can divide all of its
inputs into halting and non-halting on the basis of the behavior of this
input D correctly simulated by H.

In the study of problem solving, any problem in which the
initial state or starting position, the allowable operations,

and the goal state are clearly specified, and a unique
solution can be shown to exist.

*a unique solution can be shown to exist* or the problem itself is
ill-defined

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947


When a simulating halt decider H is only required to report on the the
behavior of D correctly simulated by H, then the problem has a solution.

> All these years pretending you have written one... You should feel
> sad, right? You shouldn't, at end you've admitted the obvious
> truth.
>
> Note that a function that is an halt decider is perfectly well
> defined. So no, the "problem" is NOT ill-defined (whatever that
> means).
>

[olcott]

clearly specified, and a unique solution can be shown to exist.

*a unique solution can be shown to exist* or the problem itself is
ill-defined

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947


When a simulating halt decider H is only required to report on the the

behavior of D correctly simulated by H, then this problem has a
solution.

An H so defined can correctly divide all of its inputs into halting and
non-halting.

[Python]

Exactly. This is something Ben Bacarisse pointed out several times
here. Then the fact there is no program being an Halt Decider is
not much a surprise. It is only the first of this kind of problem that
has been found not to be able to be solve by a program.

[Python]

Le 26/01/2023 à 01:40, olcott a écrit :
> On 1/25/2023 6:05 PM, Python wrote:
>> Peter Olcott wrote:
>> ...
>>> No machine can possibly be defined that divides all pairs of finite
>>> strings into those that represent machines would halt on their input
>>> when directly executed and those that do not
>>
>> So at least you admit that there no program can be written that
>> is an halt decider! It took time for you to abandon your delusions!
>>
>
> *I didn't say that*

This is exactly what you wrote. For once it was a correct statement.

[olcott]

I had a very very long debate about this with a PhD computer scientist.
When we make one single universal halt decider that correctly determines
the halt status of any arbitrary input pair then the countability issue
ceases to exist.

[olcott]

*This makes the current definition of the halting problem ill-defined*

In the study of problem solving, any problem in which the
initial state or starting position, the allowable operations,
and the goal state are clearly specified, and a unique
solution can be shown to exist.

*a unique solution can be shown to exist* or the problem itself is
ill-defined

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947

*This corrects the error with the definition of the halting problem*

When a simulating halt decider H is only required to report on the

behavior of D correctly simulated by H, then this problem has a
solution.

*ZFC eliminated Russell's Paradox by redefining the problem*

[Richard Damon]

On 1/25/23 7:40 PM, olcott wrote:
> On 1/25/2023 6:05 PM, Python wrote:
>> Peter Olcott wrote:
>> ...
>>> No machine can possibly be defined that divides all pairs of finite
>>> strings into those that represent machines would halt on their input
>>> when directly executed and those that do not
>>
>> So at least you admit that there no program can be written that
>> is an halt decider! It took time for you to abandon your delusions!
>>
>
> *I didn't say that* There is a program H that can divide all of its
> inputs into halting and non-halting on the basis of the behavior of this
> input D correctly simulated by H.

But that is the WRONG answer, because it doesn't match the PROBLEM.

>
>    In the study of problem solving, any problem in which the
>    initial state or starting position, the allowable operations,
>    and the goal state are clearly specified, and a unique
>    solution can be shown to exist.

And the answer to the Halting Problem is the answer that no such machine
can be built.

>
> *a unique solution can be shown to exist* or the problem itself is
> ill-defined

And you don't understnad the nature of the Halting Problem.

It ISN'T asking for a "Unique" solution, it is asking if a correct
solution can possible exist.

The answer is NO.

The problem is well defined.

We have a mathematical function which when given a machine and an input,
determines if said machine will Halt in finite time or not.

THis is a WELL DEFINED function, as all machines given any input will
either Halt on that input or not.

The question is can this mathematical function be converted into a
computation, something computable by a finite algorithm.

The answer is NO, because no such machine can be built.

>
> https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947

Which is taking about a differnt type of problem, on more commonly
called a PUZZLE.

>
> When a simulating halt decider H is only required to report on the the
> behavior of D correctly simulated by H, then the problem has a solution.

So you ADMIT you aren't solving the ACTUAL halting problem.

FINE

The fact you claim it answers the original problem

NO, and just proves you are either a pathological liar or an idiot.

[Richard Damon]

You seem to have a problem with the concept of problem solving as used here.

Most problems have more than one solution, or might not have any solution.

yes, the term "Well Defined Problem" is used in a very techincal sense
in that definition, which more deals with what are more coloquially
defined as PUZZLES.

Not being "Well Defined" in that sense just means that it doesn't form a
good "Puzzle" because either there are multiple answer or no answer.

It doesn't mean that it isn't a good "Problem" in the more common
broader sense.

I guess this just shows that yet again, you have shown a fundamental
lack of understanding of the actual language you are using, just proving
the idea that "Natural Language" is a very bad tool when dealing with logic.

Fundamentally, you are using the wrong definition of "Problem" here.

>
> When a simulating halt decider H is only required to report on the the
> behavior of D correctly simulated by H, then this problem has a
> solution.
>
> An H so defined can correctly divide all of its inputs into halting and
> non-halting.
>

Which doesn't match the ACTUAL definition of Halting, so doesn't answer
the actual Halting Problem.

[Ben Bacarisse]

Python <pyt...@invalid.org> writes:

> Peter Olcott wrote:
> ...
>> No machine can possibly be defined that divides all pairs of finite
>> strings into those that represent machines would halt on their input
>> when directly executed and those that do not
>
> So at least you admit that there no program can be written that
> is an halt decider! It took time for you to abandon your delusions!

Not so fast! Remember that PO is often fractally wrong. Not only is he
usually wrong about the big picture he's usually wrong about all the
details too. In this case, he's having trouble expressing what he
means. This is actually just another iteration of his "it's an invalid
question" stance, badly phrased.

--
Ben.

[Richard Damon]

On 1/25/23 7:54 PM, olcott wrote:
> On 1/25/2023 6:48 PM, Python wrote:
>> Le 26/01/2023 à 01:40, olcott a écrit :
>>> On 1/25/2023 6:05 PM, Python wrote:
>>>> Peter Olcott wrote:
>>>> ...
>>>>> No machine can possibly be defined that divides all pairs of finite
>>>>> strings into those that represent machines would halt on their input
>>>>> when directly executed and those that do not
>>>>
>>>> So at least you admit that there no program can be written that
>>>> is an halt decider! It took time for you to abandon your delusions!
>>>>
>>>
>>> *I didn't say that*
>>
>> This is exactly what you wrote. For once it was a correct statement.
>>
>
> *This makes the current definition of the halting problem ill-defined*

Not by the definition of Conputation theory

>    In the study of problem solving, any problem in which the
>    initial state or starting position, the allowable operations,
>    and the goal state are clearly specified, and a unique
>    solution can be shown to exist.
>
> *a unique solution can be shown to exist* or the problem itself is
> ill-defined
>
> https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947

Which is from a different field with different definition.

They are talking about PUZZLES as "Problems".

You are just showing your ignorance of the topic, an ignorance you
imposed on yourself by refusing to actually trying to learn any of the
topic (or being unable due to mental definciencies)

>
> *This corrects the error with the definition of the halting problem*
> When a simulating halt decider H is only required to report on the
> behavior of D correctly simulated by H, then this problem has a
> solution.

But you aren't allowed to do that.

>
> *ZFC eliminated Russell's Paradox by redefining the problem*
>

Note, ZFC eliminated Russell's Paradox by creating a totally new field
of Set Theory. It didn't "redefine the problem", but put restrictions on
the field to keep the problem from being able to happen.

Yes, you can do the same thing with the Halting Problem, by restricting
the domain of the machines you can create, you can make a Turing Machine
that can correctly decide on them.

But, such a domain can't be asked the question that we want to be able
to ask, so doesn't help us.

This is just like incompleteness can be overcome by limiting the domain
of your logic theory, it is just that such a field can't handle all the
properties of the Natural Numbers. As I remember, it must only use First
Order Logic, and there may be some other limitations (and no such system
can prove in itself that it is consistent).

[Richard Damon]

So, by assuming an impossible machine exists, you can prove a false
statement.

Yep, that is your logic system. TOTALLY INCONSISTENT.

IT FAILS.

You just are proving your mental deficencies when it comes to
understanding mathematics.

[Python]

Le 26/01/2023 à 01:54, olcott a écrit :
> On 1/25/2023 6:48 PM, Python wrote:
>> Le 26/01/2023 à 01:40, olcott a écrit :
>>> On 1/25/2023 6:05 PM, Python wrote:
>>>> Peter Olcott wrote:
>>>> ...
>>>>> No machine can possibly be defined that divides all pairs of finite
>>>>> strings into those that represent machines would halt on their input
>>>>> when directly executed and those that do not
>>>>
>>>> So at least you admit that there no program can be written that
>>>> is an halt decider! It took time for you to abandon your delusions!
>>>>
>>>
>>> *I didn't say that*
>>
>> This is exactly what you wrote. For once it was a correct statement.
>>
>
> *This makes the current definition of the halting problem ill-defined*
>    In the study of problem solving, any problem in which the
>    initial state or starting position, the allowable operations,
>    and the goal state are clearly specified, and a unique
>    solution can be shown to exist.
>
> *a unique solution can be shown to exist* or the problem itself is
> ill-defined

Either a program stops or not. This is not ill-defined at all.

And you are right : no program can decide on that from its input.

You should be happy to have been right ONCE in your entire life.

[olcott]

On 1/25/2023 7:16 PM, Python wrote:

> So he is right, for once, by what he actually wrote expressed
> badly a faulty claim. As far as know him, he's definitely able to to
> that. Quite a paradox in a way, of his kind... :-)
>
> Taken word for word the sentence of him I quoted is actually quite
> right and expressed the actual opposite of all he claimed for years.

>

In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal

state are clearly specified, and a unique solution can be shown to
exist.

*a unique solution can be shown to exist* or the problem itself is
ill-defined

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947


Proving that the halting problem as conventionally understood is [well-
defined problem]

[Python]

This is asinine, Peter. An equation with no solution is not ill-defined,
it just has no solution.

[olcott]

On 1/25/2023 7:18 PM, Python wrote:
> Le 26/01/2023 à 01:54, olcott a écrit :
>> On 1/25/2023 6:48 PM, Python wrote:
>>> Le 26/01/2023 à 01:40, olcott a écrit :
>>>> On 1/25/2023 6:05 PM, Python wrote:
>>>>> Peter Olcott wrote:
>>>>> ...
>>>>>> No machine can possibly be defined that divides all pairs of finite
>>>>>> strings into those that represent machines would halt on their input
>>>>>> when directly executed and those that do not
>>>>>
>>>>> So at least you admit that there no program can be written that
>>>>> is an halt decider! It took time for you to abandon your delusions!
>>>>>
>>>>
>>>> *I didn't say that*
>>>
>>> This is exactly what you wrote. For once it was a correct statement.
>>>
>>
>> *This makes the current definition of the halting problem ill-defined*
>>     In the study of problem solving, any problem in which the
>>     initial state or starting position, the allowable operations,
>>     and the goal state are clearly specified, and a unique
>>     solution can be shown to exist.
>>
>> *a unique solution can be shown to exist* or the problem itself is
>> ill-defined
>
> Either a program stops or not. This is not ill-defined at all.

The problem of defining a machine that correctly determines whether or
not any arbitrary pair of finite strings represents a halting
computation or not can be solved by a simulating halt decider.

The problem of passing the correct answer through a liar that reverses
this answer cannot be solved.

[olcott]

On 1/25/2023 7:11 PM, Richard Damon wrote:
> On 1/25/23 7:48 PM, olcott wrote:
>> On 1/25/2023 6:33 PM, Richard Damon wrote:
>
>>> One simple comment that comes to mind that points out the error in
>>> your thinking:
>>>
>>> The number of possible computing machines is a countable infinite,
>>> because we can express every such machine as a finite string of a
>>> finite symbol set.
>>>
>>> The number of possible deciders that can be defined is an UNCOUNTABLE
>>> infinite.
>>>
>>
>> I had a very very long debate about this with a PhD computer scientist.
>> When we make one single universal halt decider that correctly determines
>> the halt status of any arbitrary input pair then the countability issue
>> ceases to exist.
>>
>
> So, by assuming an impossible machine exists, you can prove a false
> statement.
>

By hypothesizing a single halt decider for the infinite set of arbitrary
finite string pairs countability ceases to be an issue.

[Richard Damon]

His problem is he so misunderstands things that he found a defionition
of a "Well Defined Problem" that releates to the field of PUZZLES.

It specifically is talking about "Problems" like the "Tower of Hanoi"
where the problem is to transform a system from one defined state to
another with a defined set of moves.

Note, even the Tower of Hanoi is technically not "well defined" as the
answer isn't unique, as you can add arbitrary side tracks to the optimal
solution and still get there. By this defiition, the Tower of Hanoi is
only Well Defined if you include the requirement of doing so in a
minumum number of moves.

[Richard Damon]

But it isn't a problem of the type described.

The Halting Problem does NOT start for a specified initial state, and
end in another specified final state, and there is not a specifically
listed set of operations allowed (just that it must use a computation).

Thus, the problem isn't of the domain being described, which happens to
be what we commonly describe as PUZZLES.

[Python]

There is nothing of that kind here.

The problem is perfectly defined.

It cannot be solved by a machine (i.e. a program) as you wrote.

Why cannot you keep being right when you are (which happened almost
NEVER)?

[olcott]

They are merely saying what I have been saying all along yet applying it
simultaneously to all fields.

I have been saying the every undecidable decision problem is necessarily
erroneous, thus not any sort of legitimate problem at all.

My first key breakthrough on this was my
*logical law of polar questions*

When posed to a man whom has never been married,
the question: Have you stopped beating your wife?
Is an incorrect polar question because neither yes nor
no is a correct answer.

All polar questions (including incorrect polar questions)
have exactly one answer from the following:
1) No
2) Yes
3) Neither // Only applies to incorrect polar questions

Copyright 2015 PL Olcott
https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ

[Richard Damon]

On 1/25/23 8:35 PM, olcott wrote:
> On 1/25/2023 7:11 PM, Richard Damon wrote:
>> On 1/25/23 7:48 PM, olcott wrote:
>>> On 1/25/2023 6:33 PM, Richard Damon wrote:
>>
>>>> One simple comment that comes to mind that points out the error in
>>>> your thinking:
>>>>
>>>> The number of possible computing machines is a countable infinite,
>>>> because we can express every such machine as a finite string of a
>>>> finite symbol set.
>>>>
>>>> The number of possible deciders that can be defined is an
>>>> UNCOUNTABLE infinite.
>>>>
>>>
>>> I had a very very long debate about this with a PhD computer scientist.
>>> When we make one single universal halt decider that correctly determines
>>> the halt status of any arbitrary input pair then the countability issue
>>> ceases to exist.
>>>
>>
>> So, by assuming an impossible machine exists, you can prove a false
>> statement.
>>
>
> By hypothesizing a single halt decider for the infinite set of arbitrary
> finite string pairs countability ceases to be an issue.
>

So your answer to trying to do the impossible is to just assume you can
do something impossible.

There goes your idea that Truth is based on a connection to the
fundamental Truth Makers of the field you are in.

You have just defined that you logic system if fundamentally inconsistent.

I guess that just shows you are a *Hypocritical* Pathological Lying Idiot.

[olcott]

On 1/25/2023 7:32 PM, Richard Damon wrote:
> On 1/25/23 8:23 PM, olcott wrote:

>> *This time www.oxfordreference.com agrees*

>>
>>     In the study of problem solving, any problem in which the initial
>>     state or starting position, the allowable operations, and the goal
>>     state are clearly specified, and a unique solution can be shown to
>>     exist.
>>
>> *a unique solution can be shown to exist* or the problem itself is
>> ill-defined
>>
>> https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947
>>
>>
>

> But using the definitions of a DIFFERENT Field.

Their statement universally applies to all problems including decision
problems. I have known this all along, finally the rest of the world is
beginning to catch up.

[olcott]

Initial state or starting position: (start state of decider)

the allowable operations:
H simulates an input finite string pair (D,I) until the behavior of D
(a) Matches a non-halting behavior pattern (H aborts and rejects)
(b) Reaches its own final state (H accepts)

the goal state: (accept or reject state of decider)

[Richard Damon]

Nope, it is SPECIFICALLY talking about "Problems" defined as figuring
out what sequence of transformations from a defined list will take you
from the specified inital state to a specified final state.

That isn't the type of "Problem" that the Halting Problem is.

>
> I have been saying the every undecidable decision problem is necessarily
> erroneous, thus not any sort of legitimate problem at all.

Then you are wrong. PERIOD

>
> My first key breakthrough on this was my
> *logical law of polar questions*

But the Halting problem as specified isn't Polar.

So that isn't applicable.

>
> When posed to a man whom has never been married,
> the question: Have you stopped beating your wife?
> Is an incorrect polar question because neither yes nor
> no is a correct answer.
>
> All polar questions (including incorrect polar questions)
> have exactly one answer from the following:
> 1) No
> 2) Yes
> 3) Neither // Only applies to incorrect polar questions
>
> Copyright 2015 PL Olcott
> https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ
>
>
>

And the question "Does the Machine specified by the input Halt when
given the input specified by the input Halt?"

Always has a correct Yes or No answer, so, by your own definition, is
not "incorrect".

Only when you erronously change the question, do you get your incorrect
question, so YOU are the one with the bad question.

[Richard Damon]

How?

it specificially talks about problems based on starting at a specified
initial state and getting to a specified final state, using a sequence
of transfomation from a defined set.

That isn't "All Problems", and you claim it does shows you are either a
Pathological Liar or a total idiot, or both.

You are also showing that you are a Hypocrite, as you are not following
your own rule for truth which requires a conenction to the actual
accepted Truth Makers of the system, which you aren't doing.

You are just proving how stupid you are.

[olcott]

On 1/25/2023 7:42 PM, Richard Damon wrote:
> On 1/25/23 8:35 PM, olcott wrote:
>> On 1/25/2023 7:11 PM, Richard Damon wrote:
>>> On 1/25/23 7:48 PM, olcott wrote:
>>>> On 1/25/2023 6:33 PM, Richard Damon wrote:
>>>
>>>>> One simple comment that comes to mind that points out the error in
>>>>> your thinking:
>>>>>
>>>>> The number of possible computing machines is a countable infinite,
>>>>> because we can express every such machine as a finite string of a
>>>>> finite symbol set.
>>>>>
>>>>> The number of possible deciders that can be defined is an
>>>>> UNCOUNTABLE infinite.
>>>>>
>>>>
>>>> I had a very very long debate about this with a PhD computer scientist.
>>>> When we make one single universal halt decider that correctly
>>>> determines
>>>> the halt status of any arbitrary input pair then the countability issue
>>>> ceases to exist.
>>>>
>>>
>>> So, by assuming an impossible machine exists, you can prove a false
>>> statement.
>>>
>>
>> By hypothesizing a single halt decider for the infinite set of arbitrary
>> finite string pairs countability ceases to be an issue.
>>
>
> So your answer to trying to do the impossible is to just assume you can
> do something impossible.
>

*Not at all*
Under the conditions that I specified countability definitely does
become moot, thus conclusively proving that countability
is not always an issue.

[Richard Damon]

Which is? Note, every "problem" being posed within the Halting Problem

So, you are transforming the Halting Problem into an INFINTE number of
"Problems" one for each possible queztion to the Halt Decider.

>
> the allowable operations:
>   H simulates an input finite string pair (D,I) until the behavior of D
>   (a) Matches a non-halting behavior pattern (H aborts and rejects)
>   (b) Reaches its own final state (H accepts)

So, what is the actual list of transfomations of the state this performs?

Seems like you don't actually understand the problem

>
> the goal state: (accept or reject state of decider)
>

But which? Remember, the definition said a SPECIFIED final state, thus
which state is it supposed to go to accept or reject?

You can't do the problem you are propsing until you solve the actual
problem of the Haltig Problem.

yes, you could say there is a problem of the sort they are talking about
to design such a decider, and the fact that THAT second problem is
ill-defined just shows that the original halting problem is proved to be
uncomputable.


You are just showing that you haven't thought this through.

You are just proving your mistakes on the subject.

You don't actually know the meaning of what you are talking about.

[Richard Damon]

So in a land of fairy dust power magical mythical unicorns, you think
you can count them.

You are just showing how stupid you are.

I though YOU were the one saying you have to start from actual truths
and moved forward. How do you justify hypothesizing something that you
can't figure out how to do, and has been proven to be impossible.

You are admitting you don't believe your own definition of Truth, so
everything you say should be assuemd to be a lie.

[olcott]

Yes and you fail to see that this is exactly a decision problem?
https://en.wikipedia.org/wiki/Decision_problem

> That isn't the type of "Problem" that the Halting Problem is.
>

If you were correct (you are not correct) that would make the
halting problem ill-defined for more than one reason.

A halt decider begins at its own start state and transforms an arbitrary
finite string pair input into a Boolean value indicated by its final
accept or reject state on the basis of whether or not the first element
of this pair would ever reach its own final state.

[olcott]

That very obviously includes decision problems
https://en.wikipedia.org/wiki/Decision_problem

[Richard Damon]

Nope, the descion problem is to come up with an algrorithm that
transfers you from ANY initial input to the CORRECT answer for a question.

The "Puzzle" problem is to figgure out the steps to do to go from a
speciric input state to a specific output state.

Most decision problem don't care about the path the decider took being
'unique" just that the final state matches the right answer.

>
>> That isn't the type of "Problem" that the Halting Problem is.
>>
> If you were correct (you are not correct) that would make the
> halting problem ill-defined for more than one reason.

Maybe it is a ill-defined puzzle problem, but that isn't the type of
problem it claims to be

>
> A halt decider begins at its own start state and transforms an arbitrary
> finite string pair input into a Boolean value indicated by its final
> accept or reject state on the basis of whether or not the first element
> of this pair would ever reach its own final state.
>

Which isn't the sort of thing that the Puzzle Problem definition is
supposed to do.


You are just continuing to bury your reputation, proving that you don't
actually understand the words you are using.

[Richard Damon]

Nope, see other post.

In a very real sense they are OPPOSITE problems.

[olcott]

Anyone can count to one. Do you disagree?

One TM and an arbitrary finite string pair also applies to deriving the
sum of natural numbers as pairs of finite strings. We need not count
these strings we only need to compute the sum of any arbitrary pair.

[Richard Damon]

Nope, not the "sum" of an arbtrary pair. Yes, "Summing" is computable.

The number of possible functions to compute goes exponentially to the
number of input values.

8 inputs to decide, 256 functions
9 inputs to decide, 512 functions
10 inputs to decide, 1024 functions

since the input can be a countable infinite number of values, there are
2 to a countable infinite number of functions to make.

It turns out that no method to try to map that number of functions to a
countable number exists, as it grows too fast.

Please post YOUR mapping that shows it is countable.

Note, you can't assume an actual Halt Decider exists, as you haven't
actually shown it does. Only that the common proof doesn't work for your
"alternate" definition of a Halt Decider that doesn't actually map to
the Halting Function, but it still won't work, as other proofs will
still break it.

[olcott]

Yes of course everyone knows that we must have a separate TM to compute
the sum of each distinct input pair. It is utterly impossible to define
a single machine that could compute the sum of 3+4 and also compute the
sum of 2+1.

Even if by some magic this would be possible everyone knows that it is
utterly impossible to chain these calls together to derive the sum of
more elements than a pair.

sum(sum(2,3), sum(4,5)) is utterly unimaginable total nonsense.
Recursive calls are a form of psychosis.

Did you notice that was sarcasm?

[Richard Damon]

????? That is a standard first year exercise.

>
> Even if by some magic this would be possible everyone knows that it is
> utterly impossible to chain these calls together to derive the sum of
> more elements than a pair.

So, "Sum" is a computable function.

You falling into the proof by example problem agian.

>
> sum(sum(2,3), sum(4,5)) is utterly unimaginable total nonsense.
> Recursive calls are a form of psychosis.
>
> Did you notice that was sarcasm?
>
>

So, rather than try to actually come up with an answewr, you deflect
with garbage.

Guess that shows how much basis you have to work from.

You still don't seem to understand that there are an order of magnatude
more functions than machines, (order as in degree of infinity) so you
can't compute all the functions, there aren't enough machines to do it.

Your brain is just too small to understand that, because it doesn't even
seem to understand the actual concept of infinity. Infinity isn't just a
very big number.

[Ben Bacarisse]

Python <pyt...@invalid.org> writes:

> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>> One simple comment that comes to mind that points out the error in your
>> thinking:
>> The number of possible computing machines is a countable infinite,
>> because we can express every such machine as a finite string of a
>> finite symbol set.
>> The number of possible deciders that can be defined is an UNCOUNTABLE
>> infinite.

Ooh, I would not say that. For any reasonable meaning of "can be
defined" the set is countable, isn't it?

The set of subsets of N is uncountable, so most of these sets are not
decidable, but only a countable subset can be defined. That's how I'd
put anyway.

>> Thus, there are deciders that can not be computed, in
>> fact, MOST deciders can't be computed. (Admittedly a randomly chosen
>> decider likely isn't useful).

(I'd phrase it in terms of sets that can't be decided.)

>> I suspect you aren't going to understand this, as you can't seem to
>> handle the actual concept of infinity.
>
> Exactly. This is something Ben Bacarisse pointed out several times
> here. Then the fact there is no program being an Halt Decider is
> not much a surprise. It is only the first of this kind of problem that
> has been found not to be able to be solve by a program.

As RD says, the counting argument does not guarantee that we care about
any of the undecidable sets. This together with the fact that only
countable many can be finitely defined means that we are doubly lucky
(or unlucky, depending on how you see it) to have examples of
well-defined sets that are both undecidable and interesting. All the
undecidable ones /could/ have been boring or ones we can't finitely
define.

The halting deniers studiously ignore all the other well-defined
non-computable functions because they have no basis for rejecting them
as pathological. And they always ignore the busy beaver function
because it's non-computability has in independent proof.

--
Ben.

[olcott]

On 1/25/2023 9:35 PM, Ben Bacarisse wrote:
> Richard Damon <Ric...@Damon-Family.org> writes:

>
>> On 1/25/23 8:06 PM, Ben Bacarisse wrote:
>>> Python <pyt...@invalid.org> writes:
>>>

>>>> Peter Olcott wrote:
>>>> ...
>>>>> No machine can possibly be defined that divides all pairs of finite
>>>>> strings into those that represent machines would halt on their input
>>>>> when directly executed and those that do not
>>>>
>>>> So at least you admit that there no program can be written that
>>>> is an halt decider! It took time for you to abandon your delusions!
>>>

>>> Not so fast! Remember that PO is often fractally wrong. Not only is he
>>> usually wrong about the big picture he's usually wrong about all the
>>> details too. In this case, he's having trouble expressing what he
>>> means. This is actually just another iteration of his "it's an invalid
>>> question" stance, badly phrased.
>>

>> Meaning some times he just admits he is wrong because he fails to
>> fashion a good enough lie and slips up and tells the truth that he
>> doesn't beleive.
>
> Not quite. Python cut off the end of the sentence. The "...because"
> text is what shows it's the same old "some instances have no correct
> answer" in new clothing. PO almost certainly does not stand by what
> Python quoted without the because clause.
>

It is the case that ZFC did eliminate Russell's Paradox by eliminating
its basis of a set containing itself. Under the original definition of
the problem within naive set theory Russell's Paradox still exists.

The halting problem proof begins with the correct basis that arbitrary
pairs of finite strings either represent a computation that halts on its
input or not.

The proof that no machine can correctly determine this set is analogous
to the Liar Paradox in that the input is specifically defined to do the
opposite of whatever the halt decider determines. This transforms the
halting problem into an ill-formed problem.

In the study of problem solving, any problem in which the initial
state or starting position, the allowable operations, and the goal
state are clearly specified, and a unique solution can be shown to
exist.

*a unique solution can be shown to exist*
or the problem itself is ill-defined

https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947

*I have been saying this for decades*
Every undecidable decision problem is necessarily erroneous.

*Finally www.oxfordreference.com agrees*

When we redefine the problem from arbitrary pairs of finite strings to
arbitrary pairs of finite string inputs to a decider then the liar
paradox issue goes away. H(D,D) does correctly determine that its
correct simulation of its input would never stop running unless aborted.

[olcott]

I have proven that countability is not an issue.
That you fail to understand that is not my problem.

[Richard Damon]

WHERE? You have CLAIMED, not proven.

You claim is based on Fairy Dust, not reality,

You are just proving you are insane or stupid.


>

[Richard Damon]

Not by just defining that sets can't contain themselves, but by limiting
the kind of things that sets can contain.

>
> The halting problem proof begins with the correct basis that arbitrary
> pairs of finite strings either represent a computation that halts on its
> input or not.
>
> The proof that no machine can correctly determine this set is analogous
> to the Liar Paradox in that the input is specifically defined to do the
> opposite of whatever the halt decider determines. This transforms the
> halting problem into an ill-formed problem.

Nope. Since the input is part of the domain of machine/inputs, the
logical semntics of what that machine is doing is irrelevent. Basd on
the rules the prospective Halt Decider is using, it will either Halt or
be Non-Halting, the the Problem has a correct answer, so the Halting
Funciton exists as a well defined function, it just is a fact that the
decider can't give the right answer.

The the problem that is ill-defined, is the problem to try to create the
Halt Decider, because it doesn't exist.

You just can't seem to distinguish between the actual problem asked for,
and the problem of trying to create a working Halt Decider.

>
>    In the study of problem solving, any problem in which the initial
>    state or starting position, the allowable operations, and the goal
>    state are clearly specified, and a unique solution can be shown to
>    exist.
>

You keep repeating the Strawman, This proves you are STUPID

> *a unique solution can be shown to exist*
> or the problem itself is ill-defined
>
> https://www.oxfordreference.com/display/10.1093/oi/authority.20110803121717729;jsessionid=DAD4AA6FA046509B2E4564A52201A947

Which is about PUZZLE Problems.

>
> *I have been saying this for decades*
> Every undecidable decision problem is necessarily erroneous.

Nope, just uncomputable.

>
> *Finally www.oxfordreference.com agrees*
>
> When we redefine the problem from arbitrary pairs of finite strings to
> arbitrary pairs of finite string inputs to a decider then the liar
> paradox issue goes away. H(D,D) does correctly determine that its
> correct simulation of its input would never stop running unless aborted.
>

So, you are admitting that H doesn't answer the actual Halting problem,
but think it is ok to give a wrong answer because it is impossible for
it to give the right answer?

This just proves that you are totally ignorant.

[olcott]

The above is pure Cockamamie bullshit.
One TM has an arbitrary number of space delimited finite strings of
ASCII digits that it computes the sum of.

[Richard Damon]

So, you have no idea of what you are talking, and think all computations
are mearly sumations.

You are just proving you are too stupid to be worth arguing about this.

Show the bijection, or the pair of injections, or STFU.

[olcott]

On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
> Richard Damon <Ric...@Damon-Family.org> writes:
>

>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>> Python <pyt...@invalid.org> writes:
>>>
>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>> One simple comment that comes to mind that points out the error in your
>>>>> thinking:
>>>>> The number of possible computing machines is a countable infinite,
>>>>> because we can express every such machine as a finite string of a
>>>>> finite symbol set.
>>>>> The number of possible deciders that can be defined is an UNCOUNTABLE
>>>>> infinite.
>>> Ooh, I would not say that. For any reasonable meaning of "can be
>>> defined" the set is countable, isn't it?
>>

>> Right, I meant FUNCTIONS is an uncountable set.
>
> Yes, it can also be framed in terms of functions. For any countably
> infinite set X, the set X->{0,1} is uncountable, so most of those
> functions are not TM computable.
>

The sum of every element of the set of all finite subsets of finite
strings of of ASCII digits can be computed because we can define a TM
that takes an arbitrary number of space delimited finite strings.

Infinite input to a TM is uncomputable because the TM would never halt,
thus the set of subsets of finite strings of ASCII digits must exclude
infinite subsets.

The same thing would apply to a halt decider that takes arbitrary pairs
of finite strings. We know this because we know that a TM that computes
the sum of arbitrary pairs of finite strings of ASCII digits can be
defined: This is merely a simpler case of the above.

[olcott]

On 1/26/2023 5:47 AM, Richard Damon wrote:
> On 1/25/23 11:52 PM, olcott wrote:
>> On 1/25/2023 8:45 PM, Richard Damon wrote:
>>> On 1/25/23 9:26 PM, olcott wrote:
>
>>> Nope, not the "sum" of an arbtrary pair. Yes, "Summing" is computable.
>>>
>>> The number of possible functions to compute goes exponentially to the
>>> number of input values.
>>>
>>> 8 inputs to decide, 256 functions
>>> 9 inputs to decide, 512 functions
>>> 10 inputs to decide, 1024 functions
>>>
>>
>> The above is pure Cockamamie bullshit.
>> One TM has an arbitrary number of space delimited finite strings of
>> ASCII digits that it computes the sum of.
>>
>
> So, you have no idea of what you are talking, and think all computations
> are mearly sumations.
>

If a TM that computes the sum of a finite number of arbitrary finite
strings of ASCII digits is computable then a TM that computes anything
else on a finite number of arbitrary finite strings is not uncomputable
for any countability reason.

[olcott]

That a set cannot contain itself is what eliminates Russell's Paradox.

>>
>> The halting problem proof begins with the correct basis that arbitrary
>> pairs of finite strings either represent a computation that halts on its
>> input or not.
>>
>> The proof that no machine can correctly determine this set is analogous
>> to the Liar Paradox in that the input is specifically defined to do the
>> opposite of whatever the halt decider determines. This transforms the
>> halting problem into an ill-formed problem.
>
> Nope. Since the input is part of the domain of machine/inputs, the

When we define a machine that correctly determines whether or not pairs
of arbitrary finite sting inputs would reach the final state of the
first element of this input then halting is computable.

Because the pathological input actually has different behavior when it
is correctly simulated by its corresponding halt decider and the halt
decider must base its halt status decision on the actual behavior of
this input then the halt decider is necessarily correct to reject its
pathological input as non-halting.

You still have not provided any counter example that shows that my
definition of correct simulation is incorrect:

Try and provide a 100% specific counter-example where you show a line
of machine code such as [mov eax, 1] and the simulator simulates another
different line instead such as [push ebx] and the simulator is correct.

If no such counter-example exists then it is proven that the ultimate
measure of correct simulation is that the simulator simulates line-by-
line exactly what the machine code specifies.

ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE COUNTER-FACTUAL

(a) The simulation of the input to H(D,D) by H is correct.

(b) D correctly simulated by H would never stop running unless aborted.

(c) Therefore H is necessarily correct to abort its simulation of D and
reject D as non-halting.

https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

[André G. Isaak]

On 2023-01-26 08:43, olcott wrote:
> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>> Richard Damon <Ric...@Damon-Family.org> writes:
>>
>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>> Python <pyt...@invalid.org> writes:
>>>>
>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>> One simple comment that comes to mind that points out the error in
>>>>>> your
>>>>>> thinking:
>>>>>> The number of possible computing machines is a countable infinite,
>>>>>> because we can express every such machine as a finite string of a
>>>>>> finite symbol set.
>>>>>> The number of possible deciders that can be defined is an UNCOUNTABLE
>>>>>> infinite.
>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>> defined" the set is countable, isn't it?
>>>
>>> Right, I meant FUNCTIONS is an uncountable set.
>>
>> Yes, it can also be framed in terms of functions.  For any countably
>> infinite set X, the set X->{0,1} is uncountable, so most of those
>> functions are not TM computable.
>>
>
> The sum of every element of the set of all finite subsets of finite
> strings of of ASCII digits can be computed because we can define a TM
> that takes an arbitrary number of space delimited finite strings.

And how 'bout them Mets?

André

> Infinite input to a TM is uncomputable because the TM would never halt,
> thus the set of subsets of finite strings of ASCII digits must exclude
> infinite subsets.
>
> The same thing would apply to a halt decider that takes arbitrary pairs
> of finite strings. We know this because we know that a TM that computes
> the sum of arbitrary pairs of finite strings of ASCII digits can be
> defined: This is merely a simpler case of the above.
>


--

To email remove 'invalid' & replace 'gm' with well known Google mail
service.

[olcott]

In other words my statement is irrefutably correct.

>
>> Infinite input to a TM is uncomputable because the TM would never halt,
>> thus the set of subsets of finite strings of ASCII digits must exclude
>> infinite subsets.
>>
>> The same thing would apply to a halt decider that takes arbitrary pairs
>> of finite strings. We know this because we know that a TM that computes
>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>> defined: This is merely a simpler case of the above.
>>
>
>

--

[Richard Damon]

On 1/26/23 11:46 AM, olcott wrote:
> On 1/26/2023 5:47 AM, Richard Damon wrote:
>> On 1/25/23 11:52 PM, olcott wrote:
>>> On 1/25/2023 8:45 PM, Richard Damon wrote:
>>>> On 1/25/23 9:26 PM, olcott wrote:
>>
>>>> Nope, not the "sum" of an arbtrary pair. Yes, "Summing" is computable.
>>>>
>>>> The number of possible functions to compute goes exponentially to
>>>> the number of input values.
>>>>
>>>> 8 inputs to decide, 256 functions
>>>> 9 inputs to decide, 512 functions
>>>> 10 inputs to decide, 1024 functions
>>>>
>>>
>>> The above is pure Cockamamie bullshit.
>>> One TM has an arbitrary number of space delimited finite strings of
>>> ASCII digits that it computes the sum of.
>>>
>>
>> So, you have no idea of what you are talking, and think all
>> computations are mearly sumations.
>>
>
> If a TM that computes the sum of a finite number of arbitrary finite
> strings of ASCII digits is computable then a TM that computes anything
> else on a finite number of arbitrary finite strings is not uncomputable
> for any countability reason.
>

WHy? Summing is a very simple operation, that we can do that doesn't say
anthing about more complicated operations.

Please write a TM that computes the last prime.

How about one that computes the Busy Beaver number for a given input on
number of states.

You are just showing how STUPID you are.

[Richard Damon]

On 1/26/23 10:43 AM, olcott wrote:
> On 1/26/2023 6:22 AM, Ben Bacarisse wrote:
>> Richard Damon <Ric...@Damon-Family.org> writes:
>>
>>> On 1/25/23 10:54 PM, Ben Bacarisse wrote:
>>>> Python <pyt...@invalid.org> writes:
>>>>
>>>>> Le 26/01/2023 à 01:33, Richard Damon a écrit :
>>>>>> One simple comment that comes to mind that points out the error in
>>>>>> your
>>>>>> thinking:
>>>>>> The number of possible computing machines is a countable infinite,
>>>>>> because we can express every such machine as a finite string of a
>>>>>> finite symbol set.
>>>>>> The number of possible deciders that can be defined is an UNCOUNTABLE
>>>>>> infinite.
>>>> Ooh, I would not say that.  For any reasonable meaning of "can be
>>>> defined" the set is countable, isn't it?
>>>
>>> Right, I meant FUNCTIONS is an uncountable set.
>>
>> Yes, it can also be framed in terms of functions.  For any countably
>> infinite set X, the set X->{0,1} is uncountable, so most of those
>> functions are not TM computable.
>>
>
> The sum of every element of the set of all finite subsets of finite
> strings of of ASCII digits can be computed because we can define a TM
> that takes an arbitrary number of space delimited finite strings.

Red herring as we are not talking about functions that are just a "sum".

>
> Infinite input to a TM is uncomputable because the TM would never halt,
> thus the set of subsets of finite strings of ASCII digits must exclude
> infinite subsets.

We are not talking about any subset that has an infinte number of
members, but the number of finite subsets of the Natural Numbers.

The count of this is an uncountable infinity, an order of infinity
bigger than the count of the Natural Numbers.

>
> The same thing would apply to a halt decider that takes arbitrary pairs
> of finite strings. We know this because we know that a TM that computes
> the sum of arbitrary pairs of finite strings of ASCII digits can be
> defined: This is merely a simpler case of the above.
>

Wrong, and using a Red Herring and the fallacy of proof by examole,


You are just showing how IGNORANT you are of what you are talking about.

[Richard Damon]

But you need to show that you CAN do that. YOu haven't

H(P,P) says that P(P) will not halt when it does, so it fails.

> Because the pathological input actually has different behavior when it
> is correctly simulated by its corresponding halt decider and the halt
> decider must base its halt status decision on the actual behavior of
> this input then the halt decider is necessarily correct to reject its
> pathological input as non-halting.

No, it doesn't

You have been asked to point what point in the actual execution of
H(P,P) called by P(P) call by main differs from the execution of H(P,P)
calledd by main diverege.

You have failed to point that out, becaue it doesn't exist, because you
ar a LIAR and an IDOIT.

As stated before, your failure to even attempt to indicate this is taken
as your admission that your claim is a LIE, and you can not actually
prove your claim, also making you a damned hypocrite.

>
> You still have not provided any counter example that shows that my
> definition of correct simulation is incorrect:

LIE.

P(P) is the counter example.

>
> Try and provide a 100% specific counter-example where you show a line
> of machine code such as [mov eax, 1] and the simulator simulates another
> different line instead such as [push ebx] and the simulator is correct.

P(P), its call H will go through the exact same set of states when P(P)
call s as when main calls it, thus since H(P,P) returns 0 when called by
main, we know it does the same thing when called by P (or it just fails
to be the "pure function"/computation you have claimex it to be)

Since H simulats that call the H(P,P) as something that will never
returm, H has done an incorrect simulation.

Your inability to understand this just shows your STUPIDITY.

>
> If no such counter-example exists then it is proven that the ultimate
> measure of correct simulation is that the simulator simulates line-by-
> line exactly what the machine code specifies.
>
> ALL OF THE ARGUMENTS AGAINST MY POSITION HAVE PROVEN TO BE COUNTER-FACTUAL

Nope, YOUR statements, have been shown to be "counter-factual" and your
reasoning ab

>
> (a) The simulation of the input to H(D,D) by H is correct.

Nope, because it says H(P,P) will never return, when it doesn.

>
> (b) D correctly simulated by H would never stop running unless aborted.

Which is irrelvent and not a truth bearer, as H doen't do this, buyt
ALWAYS aborts its simulation.

H IN CORRECTLY presumes that the input is calling a DIFFERENT function
than it actually does, so gives the wrong asnwer.

>
> (c) Therefore H is necessarily correct to abort its simulation of D and
>     reject D as non-halting.

batting 0/3

YOU FAIL.

>
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>
>
>

Just shows you are a Hypocritical Pathological Lying Idiot.

[André G. Isaak]

Woooooosh!

André

>>
>>> Infinite input to a TM is uncomputable because the TM would never halt,
>>> thus the set of subsets of finite strings of ASCII digits must exclude
>>> infinite subsets.
>>>
>>> The same thing would apply to a halt decider that takes arbitrary pairs
>>> of finite strings. We know this because we know that a TM that computes
>>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>>> defined: This is merely a simpler case of the above.
>>>
>>
>>
>


--

[olcott]

It is not possible that the relevance of your irrelevant response was
over my head.

>>>
>>>> Infinite input to a TM is uncomputable because the TM would never halt,
>>>> thus the set of subsets of finite strings of ASCII digits must exclude
>>>> infinite subsets.
>>>>
>>>> The same thing would apply to a halt decider that takes arbitrary pairs
>>>> of finite strings. We know this because we know that a TM that computes
>>>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>>>> defined: This is merely a simpler case of the above.
>>>>
>>>
>>>
>>
>
>

--

[olcott]

On 1/26/2023 5:37 PM, Richard Damon wrote:
> On 1/26/23 11:46 AM, olcott wrote:
>> On 1/26/2023 5:47 AM, Richard Damon wrote:
>>> On 1/25/23 11:52 PM, olcott wrote:
>>>> On 1/25/2023 8:45 PM, Richard Damon wrote:
>>>>> On 1/25/23 9:26 PM, olcott wrote:
>>>
>>>>> Nope, not the "sum" of an arbtrary pair. Yes, "Summing" is computable.
>>>>>
>>>>> The number of possible functions to compute goes exponentially to
>>>>> the number of input values.
>>>>>
>>>>> 8 inputs to decide, 256 functions
>>>>> 9 inputs to decide, 512 functions
>>>>> 10 inputs to decide, 1024 functions
>>>>>
>>>>
>>>> The above is pure Cockamamie bullshit.
>>>> One TM has an arbitrary number of space delimited finite strings of
>>>> ASCII digits that it computes the sum of.
>>>>
>>>
>>> So, you have no idea of what you are talking, and think all
>>> computations are mearly sumations.
>>>
>>
>> If a TM that computes the sum of a finite number of arbitrary finite
>> strings of ASCII digits is computable then a TM that computes anything
>> else on a finite number of arbitrary finite strings is not uncomputable
>> for any countability reason.
>>
>
> WHy? Summing is a very simple operation, that we can do that doesn't say
> anthing about more complicated operations.
>

It does completely prove that countability is not an issue for the
halting problem thus all proofs to the contrary have been refuted.

[Richard Damon]

Woooooosh!

[Richard Damon]

No, saying one functions is computable does not prove that another is.


You are just showing you don't understand what you are talking about.

As I remember, you failed at even trying to write a machine to do the
summing you are talking about, you are just going on the fact that
others says it can be done.

You ar showing you don't even understand the very nature of a proof, or
what it means to be true. You may be able to spout off words, but you
show ZERO undrstanding of the actual meaning.

You are just proving to the whole world how stupid and ignorant you are.

[olcott]

On 1/26/2023 5:37 PM, Richard Damon wrote:

The set of all finite subsets of the natural numbers is countable
https://en.wikipedia.org/wiki/Countable_set

https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable

https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable

Thus the set of all finite subsets of finite strings is countable.

Thus the set all finite string pairs is countable because all of these
pairs are subsets having two elements thus finite length,

>>
>> The same thing would apply to a halt decider that takes arbitrary pairs
>> of finite strings. We know this because we know that a TM that computes
>> the sum of arbitrary pairs of finite strings of ASCII digits can be
>> defined: This is merely a simpler case of the above.
>>
>
> Wrong, and using a Red Herring and the fallacy of proof by examole,
>
>
> You are just showing how IGNORANT you are of what you are talking about.
>
>

[olcott]

Because your main tactic of rebuttal is the dishonest dodge I will stay
focused on the point until you meet the challenge.

[Richard Damon]

call H

in actuality, it goes into H which will eventually returns.

H "simulates" that as something that doesn't return, and doesn't
actually simulate into the function.

Remeber, "Correct Simulation" means fully determining the behavior of
the machine, and BY DEFINITION if the machine halts and the simulation
says it doesn't, the simulation is INCORRECT.

>
> If no such counter-example exists then it is proven that the ultimate
> measure of correct simulation is that the simulator simulates line-by-
> line exactly what the machine code specifies.
>
> Because your main tactic of rebuttal is the dishonest dodge I will stay
> focused on the point until you meet the challenge.
>

I have, multiple times, but you are too stup[id to undrstand.

You ADMIT that P(P) halts (at least most of the time) but somehow try to
justify that the correct answer for H, which is being asked if P(P)
Halts, is to say "No". You say H's simulation must be correct, as each
of the instructions it has simulated completed were done correctly, even
though it interprests what a call H instruction will end up doing
incorrectly as it "guesses" the behavior of H to not be what H actually
does (maybe because H doesn't actually do what you think it is "defined"
to do)

This is like saying you can determine how long a road is by following it
exactly till the first exit and then getting off, saying the road past
the exit look just like the road before, so the road must be infinitely
long.

[Richard Damon]

Side note, read on this page about total order:

> In both examples of well orders here, any subset has a least element; and in both examples of non-well orders, some subsets do not have a least element. This is the key definition that determines whether a total order is also a well order.
>

Note, the rationals "in usual order" are a non-well ordered set, and
thus some subsets (like the open interval) do not have a least member.
This is why the intervale (0, 1] doesn't have a "lowest" value.

>
> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>
> https://proofwiki.org/wiki/Set_of_Finite_Subsets_of_Countable_Set_is_Countable
>
> Thus the set of all finite subsets of finite strings is countable.
>
> Thus the set all finite string pairs is countable because all of these
> pairs are subsets having two elements thus finite length,

Note, MY claim was the number of FUNCTIONS was uncountable, not the
number of subsets, thus not all Functions F(N) -> N are computable, as
there are more functions than computations.

This also applies to the set of Functions F(N) -> {0,1}, which is the
set of all deciders

The subset problem is different. While the number of FINITE subsets is
countably infinite, the number of partitions of N into S and S' can
result in both S and S' being infinte, and thus none of those proofs
show that the number of partiosns to be countable, thus more than the
number of possible deciders which must be countable.

From what I remember, the set of Halting Machines/Input pairs is
countably infinte, and the number of Non-Halting pairs is Uncountable,
so a Halting RECOGNIZER is possible, that is a machine that WILL Halt in
finite time and say Halting for ALL Halting Machine/Inputs combinations,
but might not halt on all Non-Halting combinations, which isn't much
better than we could get by just running the machines (it might be able
to detect that SOME non-halting machines are non-halting)

[olcott]

There is a single TM can you not count to one?

A single TM can derive the sum of any arbitrary finite set
of finite strings of ASCII digits that are space delimited.

Proving that this cannot be done requires a specific
counter-example finite set of finite strings of ASCII digits
where the sum cannot be computed.

To be correct the TM need not calculate the sum of every finite
set of finite strings of ASCII digits, it merely has to always
compute this sum correctly for any arbitrary element of the
finite set of finite strings.

[olcott]

Show me a specific line of machine code such as [mov eax, 1] where the
simulator simulates some other entirely different specific line of
machine code instead such as [push ebx] *AND THE SIMULATOR IS CORRECT*

If this is impossible then my standard of correct simulation is proven
to be correct.

[Richard Damon]

????

Why are you asking me to show that the simulator was correct????

>
> If this is impossible then my standard of correct simulation is proven
> to be correct.
>

Your brain is just fucked.


The simulation id WRONG, not "correct"

[Richard Damon]

?????

Where do you get that claim?

>
> A single TM can derive the sum of any arbitrary finite set
> of finite strings of ASCII digits that are space delimited.
>

So?

> Proving that this cannot be done requires a specific
> counter-example finite set of finite strings of ASCII digits
> where the sum cannot be computed.
>

Neer said you couldn't compute SOME functions.

> To be correct the TM need not calculate the sum of every finite
> set of finite strings of ASCII digits, it merely has to always
> compute this sum correctly for any arbitrary element of the
> finite set of finite strings.
>

NBot talking about "Sums"


You are just showing you are totally lost about what I am talking about
becaue you are too stupid.

There exist more possibe problems to decide on then possible deciders
(by an order of infinity).

Thus, most decision problems are not computatble.

Maybe most of the uncomputable ones are not interesting, but it shows
that some are not computable.

This happens to include the halting function.

Your Red Herring Comments just show you have no idea what is being
talked about.

[olcott]

You have repeatedly claimed that the simulation of D by H is incorrect
yet cannot point our a single line of code that was simulated incorrectly.

[olcott]

I just proved that there are no countability issues with the
computability of halting on the basis that there are no countability
issues with the computation of sums.

[Richard Damon]

No, I have repeatedly TOLD you the error, H presumes the wrong behavior
for a call to H.

Also, a PARTIAL simulation is NOT a "Correct" simulation for the rule
that lets you replace its behavior for that of the origina.

Thus, your criteria itself is invalid, and your claim that I haven't
provided one is a LIE.

Either H HAS simulated the call to H and thus derived an INCORRECT
result, or it hasn't and doesn't have enough information to be able to
claim its answer,

Seeing the first mile of a road can't tell you how long it is

[Richard Damon]

Nope. Falllicy of proof byt example.

Not all computations are "sums"

You are just proving your stupidity.

What does the "Countability of Sums" have to do with the question of an
arbitrary machine halting on a given inputy?

You are just showing you are totally out of touch with what you are saying.

[olcott]

When D calls H this is D calling H.
If H did not abort its simulation of D then D would never stop running.

[olcott]

On 1/27/2023 9:19 PM, Richard Damon wrote:
> On 1/27/23 8:56 PM, olcott wrote:
>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>> On 1/26/23 10:46 PM, olcott wrote:
>>>> To be correct the TM need not calculate the sum of every finite
>>>> set of finite strings of ASCII digits, it merely has to always
>>>> compute this sum correctly for any arbitrary element of the
>>>> finite set of finite strings.
>>>>
>>>
>>> NBot talking about "Sums"
>>>
>>>
>>
>> I just proved that there are no countability issues with the
>> computability of halting on the basis that there are no countability
>> issues with the computation of sums.
>>
>
> Nope. Falllicy of proof byt example.
>

None-the-less if sum has no countability issue with any finite set of
finite strings then H cannot have any countability issue with any
finite pair of finite strings.

[Richard Damon]

But it DOES abort its simulation and returns 0 to D, because that is
what it does.

IF not, what is the first instruction in Main -> D(D) -> H(D,D) that
acts differently than the path main -> H(D,D) to allow it to return 0
from second call and not from the first.

You have been asked this before, and have DUCKED, because you don't have
an answer.

Until you answer this, your claim is just a LIE made up out of fairy dust.

PUT UP or STFU.

[Richard Damon]

On 1/27/23 10:34 PM, olcott wrote:
> On 1/27/2023 9:19 PM, Richard Damon wrote:
>> On 1/27/23 8:56 PM, olcott wrote:
>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>> To be correct the TM need not calculate the sum of every finite
>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>> compute this sum correctly for any arbitrary element of the
>>>>> finite set of finite strings.
>>>>>
>>>>
>>>> NBot talking about "Sums"
>>>>
>>>>
>>>
>>> I just proved that there are no countability issues with the
>>> computability of halting on the basis that there are no countability
>>> issues with the computation of sums.
>>>
>>
>> Nope. Falllicy of proof byt example.
>>
>
> None-the-less if sum has no countability issue with any finite set of
> finite strings then H cannot have any countability issue with any
> finite pair of finite strings.
>

How do you make a countable infinite number of machine make an
uncountable number of maps.

You non-sequitur about summing just shows you don't know what you are
talking about, and you dismissing of the fallacy says you don't
understand that basics of logic. "Summing" has NOTHING to do with the
problem, except as a trivial example that shows that the decider can get
a few answers right.

All you are proving is that anyone who trust your ideas has a blind man
as a guide, who will lead them into a pit.

[olcott]

On 1/27/2023 9:37 PM, Richard Damon wrote:
> On 1/27/23 10:32 PM, olcott wrote:
>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>
>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>> behavior for a call to H.
>>>
>>
>> When D calls H this is D calling H.
>> If H did not abort its simulation of D then D would never stop running.
>>
>
> But it DOES abort its simulation and returns 0 to D, because that is
> what it does.
>

*THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
Anytime that H correctly determines that its correct simulation of its
input D would never stop running unless aborted H is always correct to
abort this simulation and reject this input as non-halting.

void D(void (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{
Output("Input_Halts = ", H(D, D));

[olcott]

On 1/27/2023 9:47 PM, Richard Damon wrote:
> On 1/27/23 10:34 PM, olcott wrote:
>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>> On 1/27/23 8:56 PM, olcott wrote:
>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>> finite set of finite strings.
>>>>>>
>>>>>
>>>>> NBot talking about "Sums"
>>>>>
>>>>>
>>>>
>>>> I just proved that there are no countability issues with the
>>>> computability of halting on the basis that there are no countability
>>>> issues with the computation of sums.
>>>>
>>>
>>> Nope. Falllicy of proof byt example.
>>>
>>
>> None-the-less if sum has no countability issue with any finite set of
>> finite strings then H cannot have any countability issue with any
>> finite pair of finite strings.
>>
>
> How do you make a countable infinite number of machine make an
> uncountable number of maps.
>

I ask you again can you count to one?

There is only one machine that always has a finite number of inputs.
We don't need any maps we only need one set of inputs deriving a single
output for any arbitrary set of inputs. When we think of this as sums
then it is obvious that countability is not an issue.

Is there any finite set of finite strings of ASCII digits that cannot be
summed by a TM? No, therefore computability is proven.

[Richard Damon]

On 1/27/23 10:51 PM, olcott wrote:
> On 1/27/2023 9:37 PM, Richard Damon wrote:
>> On 1/27/23 10:32 PM, olcott wrote:
>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>
>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>> behavior for a call to H.
>>>>
>>>
>>> When D calls H this is D calling H.
>>> If H did not abort its simulation of D then D would never stop running.
>>>
>>
>> But it DOES abort its simulation and returns 0 to D, because that is
>> what it does.
>>
>
> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*

No, it is a LIE just like the LIARs paradox.

Your "Claim" that it is a Tautology is just a LIE, becaue it is based on
a false premise.

The fact that you haven't answered my question just proves that you are
admitting to being a Hypociritcal Pathological Lying Idiot.

> Anytime that H correctly determines that its correct simulation of its
> input D would never stop running unless aborted H is always correct to
> abort this simulation and reject this input as non-halting.

Except that the H you have provided never DOES a correct simulation so
it is illogical to make a decision based on it doing one. PERIOD.

You H LIES because it INCORRECTLY presumes that the H that D calls does
something that it doesn't do, because H doesn't meet its own requirements.

>
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
>

Thanks for proving and admitting that you are just a Hypocritical
Pathological Lying Idiot.

You Baseless lies are exosed.

[Richard Damon]

On 1/27/23 10:59 PM, olcott wrote:
> On 1/27/2023 9:47 PM, Richard Damon wrote:
>> On 1/27/23 10:34 PM, olcott wrote:
>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>> On 1/27/23 8:56 PM, olcott wrote:
>>>>> On 1/26/2023 10:16 PM, Richard Damon wrote:
>>>>>> On 1/26/23 10:46 PM, olcott wrote:
>>>>>>> To be correct the TM need not calculate the sum of every finite
>>>>>>> set of finite strings of ASCII digits, it merely has to always
>>>>>>> compute this sum correctly for any arbitrary element of the
>>>>>>> finite set of finite strings.
>>>>>>>
>>>>>>
>>>>>> NBot talking about "Sums"
>>>>>>
>>>>>>
>>>>>
>>>>> I just proved that there are no countability issues with the
>>>>> computability of halting on the basis that there are no countability
>>>>> issues with the computation of sums.
>>>>>
>>>>
>>>> Nope. Falllicy of proof byt example.
>>>>
>>>
>>> None-the-less if sum has no countability issue with any finite set of
>>> finite strings then H cannot have any countability issue with any
>>> finite pair of finite strings.
>>>
>>
>> How do you make a countable infinite number of machine make an
>> uncountable number of maps.
>>
>
> I ask you again can you count to one?

YTes, SO WHAT.

>
> There is only one machine that always has a finite number of inputs.
> We don't need any maps we only need one set of inputs deriving a single
> output for any arbitrary set of inputs. When we think of this as sums
> then it is obvious that countability is not an issue.

So you are saying that the machine that computes the prime factors of
its input it the same machine that computes its inputs factorial?

You DO understand that a Turing Machine can be treated as a computation
that computes a specific mapping of inputs to outputs?

Maybe not, as you are too stupid.

>
> Is there any finite set of finite strings of ASCII digits that cannot be
> summed by a TM? No, therefore computability is proven.
>

But summing isn't the only operation that a TM can do.

You are just proving you are totally ignorant of what you are talking about.

[olcott]

On 1/27/2023 10:02 PM, Richard Damon wrote:
> On 1/27/23 10:51 PM, olcott wrote:
>> On 1/27/2023 9:37 PM, Richard Damon wrote:
>>> On 1/27/23 10:32 PM, olcott wrote:
>>>> On 1/27/2023 9:19 PM, Richard Damon wrote:
>>>>>
>>>>> No, I have repeatedly TOLD you the error, H presumes the wrong
>>>>> behavior for a call to H.
>>>>>
>>>>
>>>> When D calls H this is D calling H.
>>>> If H did not abort its simulation of D then D would never stop running.
>>>>
>>>
>>> But it DOES abort its simulation and returns 0 to D, because that is
>>> what it does.
>>>
>>
>> *THIS IS A TAUTOLOGY DISAGREEMENT IS DISHONEST*
>
> No, it is a LIE just like the LIARs paradox.
>
> Your "Claim" that it is a Tautology is just a LIE, becaue it is based on
> a false premise.
>
> The fact that you haven't answered my question just proves that you are
> admitting to being a Hypociritcal Pathological Lying Idiot.
>
>> Anytime that H correctly determines that its correct simulation of its
>> input D would never stop running unless aborted H is always correct to
>> abort this simulation and reject this input as non-halting.
>
> Except that the H you have provided never DOES a correct simulation so
> it is illogical to make a decision based on it doing one. PERIOD.

H does a correct simulation of the first seven lines of D and upon
encountering the 8th line of D correctly determines that D would never
stop running unless aborted.

H: Begin Simulation Execution Trace Stored at:112ae5
Address_of_H:1383
[000019b3][00112ad1][00112ad5] 55 push ebp // begin D
[000019b4][00112ad1][00112ad5] 8bec mov ebp,esp
[000019b6][00112acd][00102aa1] 51 push ecx
[000019b7][00112acd][00102aa1] 8b4508 mov eax,[ebp+08]
[000019ba][00112ac9][000019b3] 50 push eax // push D
[000019bb][00112ac9][000019b3] 8b4d08 mov ecx,[ebp+08]
[000019be][00112ac5][000019b3] 51 push ecx // push D
[000019bf][00112ac1][000019c4] e8bff9ffff call 00001383 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

It is easier to see that the correct simulation of PP by HH would never
stop running unless aborted.

Begin Local Halt Decider Simulation Execution Trace Stored at:112aa9
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001993][00112a95][00112a99] 55 push ebp // begin PP
[00001994][00112a95][00112a99] 8bec mov ebp,esp
[00001996][00112a91][00102a65] 51 push ecx
[00001997][00112a91][00102a65] 8b4508 mov eax,[ebp+08]
[0000199a][00112a8d][00001993] 50 push eax // push PP
[0000199b][00112a8d][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][00112a89][00001993] 51 push ecx // push PP
[0000199f][00112a85][000019a4] e8fff7ffff call 000011a3 // call HH
New slave_stack at:14d4c9
[00001993][0015d4bd][0015d4c1] 55 push ebp // begin PP
[00001994][0015d4bd][0015d4c1] 8bec mov ebp,esp
[00001996][0015d4b9][0014d48d] 51 push ecx
[00001997][0015d4b9][0014d48d] 8b4508 mov eax,[ebp+08]
[0000199a][0015d4b5][00001993] 50 push eax // push PP
[0000199b][0015d4b5][00001993] 8b4d08 mov ecx,[ebp+08]
[0000199e][0015d4b1][00001993] 51 push ecx // push PP
[0000199f][0015d4ad][000019a4] e8fff7ffff call 000011a3 // call HH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

If H or HH were to wait for their nested simulations to abort their
simulation then the input would never be aborted because each H or HH
would wait for the next one ad infinitum.

[Richard Damon]

Nope, that is an INCORRECT conclusion, because the actual behavior of
that call to H by D(D) will be to abort ITS simulation (which is a
different instance, which is also an incorrect action) and return 0.

Thus H gets the wrong answer because it presumes that H will not get the
wrong answer when it does.

Until you provide the instruction in that direct execution of D(D) that
differs from the execution of H(D,D) when called by main, you are just
admitting that you are a Hypocritical Patholgical Lying Ignorant Idiot.

>
> H: Begin Simulation   Execution Trace Stored at:112ae5
> Address_of_H:1383
> [000019b3][00112ad1][00112ad5] 55         push ebp       // begin D
> [000019b4][00112ad1][00112ad5] 8bec       mov ebp,esp
> [000019b6][00112acd][00102aa1] 51         push ecx
> [000019b7][00112acd][00102aa1] 8b4508     mov eax,[ebp+08]
> [000019ba][00112ac9][000019b3] 50         push eax       // push D
> [000019bb][00112ac9][000019b3] 8b4d08     mov ecx,[ebp+08]
> [000019be][00112ac5][000019b3] 51         push ecx       // push D
> [000019bf][00112ac1][000019c4] e8bff9ffff call 00001383  // call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped

And H is wrong about ths.

>
> It is easier to see that the correct simulation of PP by HH would never
> stop running unless aborted.

So, H is seeing a call to H as a call to HH?

>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:112aa9
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001993][00112a95][00112a99] 55             push ebp       // begin PP
> [00001994][00112a95][00112a99] 8bec           mov ebp,esp
> [00001996][00112a91][00102a65] 51             push ecx
> [00001997][00112a91][00102a65] 8b4508         mov eax,[ebp+08]
> [0000199a][00112a8d][00001993] 50             push eax       // push PP
> [0000199b][00112a8d][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][00112a89][00001993] 51             push ecx       // push PP
> [0000199f][00112a85][000019a4] e8fff7ffff     call 000011a3  // call HH
> New slave_stack at:14d4c9

And this is the point the trace is incorrect as the CORRECT tracing of a
call to HH should be showing the code of HH executing,

> [00001993][0015d4bd][0015d4c1] 55             push ebp       // begin PP
> [00001994][0015d4bd][0015d4c1] 8bec           mov ebp,esp
> [00001996][0015d4b9][0014d48d] 51             push ecx
> [00001997][0015d4b9][0014d48d] 8b4508         mov eax,[ebp+08]
> [0000199a][0015d4b5][00001993] 50             push eax      // push PP
> [0000199b][0015d4b5][00001993] 8b4d08         mov ecx,[ebp+08]
> [0000199e][0015d4b1][00001993] 51             push ecx      // push PP
> [0000199f][0015d4ad][000019a4] e8fff7ffff     call 000011a3 // call HH
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> If H or HH were to wait for their nested simulations to abort their
> simulation then the input would never be aborted because each H or HH
> would wait for the next one ad infinitum.
>
>

Thank you again for confirming that you are just a Hypocirtical
Pathological Lying Ignorant Idiot.

This is an establish fact until you answer the question put to you of
wher the paths of D(D) -> H(D,D) and main -> H(D,D) differ, as that is
needed to show that H can be correct to simulate D(D)'s call to H(D,D)
as doing something different than H(D,D) does.