Simulating halt decider applied to a simpler input

[olcott]

void E(void (*x)())
{
H(x, x);
}

(Ignoring stack overflow) If H correctly simulates E would the simulated
E ever stop running without being aborted?

Because no E would ever stop running unless H aborts its simulation of E
this proves that the aborted E specifies a non-halting sequence of
configurations.

Simulating Halt Decider Applied to the Halting Theorem
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem

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

[Richard Damon]

On 11/11/22 10:28 AM, olcott wrote:
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> (Ignoring stack overflow) If H correctly simulates E would the simulated
> E ever stop running without being aborted?
>
> Because no E would ever stop running unless H aborts its simulation of E
> this proves that the aborted E specifies a non-halting sequence of
> configurations.
>
> Simulating Halt Decider Applied to the Halting Theorem
> https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
>

And No H that doesn't abort its simulation of an input that it thinks is
not halting can ever return a 0.

Thus, there is no E that calls a H that is a Halt Decider that doesn't Halt.

All you statement proves is that your H that returned 0 didn't actually
correctly decide on the input it was given, but a different one, because
it wasn't looking at all the code it needed to.

You don't seem to understand that you need to look at the input you were
actually given, to make the decision. You just seem to think that things
that aren't what actually are define what things are.

This is the proof of your ignorace.

It is a simple fact that you are not working on the Halting Problem
because you are actually using the requirements of the halting problem,
but you are just too stupid to know the differenc.

Sorry, you have wasted 18 years and destroyed your reputation because
you are made yourself too ignorant of the material and are too stupid to
understand the issue.

It doesn't matter that no H can correctly simulate this template to a
final state. That is just the error in your own mind.

THe question is what any specific instance does. Either E(E) will halt
because that H(E,E) for that E (incorrctly) aborts its simulation of
that E, and return 0, or we have a DIFFERENT class of H that doesn't
abort its simulation, and for THAT class of H, we do get a E(E) that
doesn't halt, but the H it was basd on doesn't give the answer, so is
still wrong.

[Mr Flibble]

It is my understanding that Olcott has blocked you and I would have
thought given your intelligence you would also understand that.

/Flibble

[Richard Damon]

On 11/11/22 1:36 PM, Mr Flibble wrote:

> It is my understanding that Olcott has blocked you and I would have
> thought given your intelligence you would also understand that.
>
> /Flibble
>

I don't think he has actually blocked me, just mostly ignores me.

I say this because at times he seems to respond to what I say, even if
not in a direct reply,

Also, when someone like you replies, even if he has blocked me, he will
still see me.

More importantly, If anyone naive wanders into the archives, I want
enough evidence to be around to point out his errors.

Note also, my longer replies shows what I know and provide reasoning
behind the claims, showing the Truth.

His short claims, and guff replies just show that he doesn't actually
know what he is talking about, and reveals his ignorance. If he tries to
put his explanation into explicit words, his errors become very
apparent, I think even to him, so he just refuses.

[olcott]

You always use the strawman deception as your only basis.
Naive readers will never notice this, yet naive readers are not in my
target audience.

[Richard Damon]

On 11/11/22 2:16 PM, olcott wrote:
> On 11/11/2022 12:43 PM, Richard Damon wrote:
>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>
>>> It is my understanding that Olcott has blocked you and I would have
>>> thought given your intelligence you would also understand that.
>>>
>>> /Flibble
>>>
>>
>> I don't think he has actually blocked me, just mostly ignores me.
>>
>> I say this because at times he seems to respond to what I say, even if
>> not in a direct reply,
>>
>> Also, when someone like you replies, even if he has blocked me, he
>> will still see me.
>>
>> More importantly, If anyone naive wanders into the archives, I want
>> enough evidence to be around to point out his errors.
>>
>> Note also, my longer replies shows what I know and provide reasoning
>> behind the claims, showing the Truth.
>>
>> His short claims, and guff replies just show that he doesn't actually
>> know what he is talking about, and reveals his ignorance. If he tries
>> to put his explanation into explicit words, his errors become very
>> apparent, I think even to him, so he just refuses.
>
> You always use the strawman deception as your only basis.
> Naive readers will never notice this, yet naive readers are not in my
> target audience.
>
>

No, because *I* use the actual definition of a Halting Decider.

YOU have the Strawman, unless you are admitting that your "SHD" isn't
actually a Halting Decider.

The fact you can't tell the difference shows your ignorance.

YOU are the Naive one.


Do you reject that the correct answer for a Halt Decider when given the
description of a program and its input is whether that program when run
with that input will halt or not.

After all, that is the DEFINITION of a Halt Decider. (Care to provide an
actual published reference from a reputable source that says otherwise?)

So either you Simulation Halt Deciders answer that question or your
criteria makes that not actually a Halt Decider.

Your refusal to face that reveals who you are.

FAIL.

[olcott]

On 11/11/2022 1:30 PM, Richard Damon wrote:
> On 11/11/22 2:16 PM, olcott wrote:
>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>
>>>> It is my understanding that Olcott has blocked you and I would have
>>>> thought given your intelligence you would also understand that.
>>>>
>>>> /Flibble
>>>>
>>>
>>> I don't think he has actually blocked me, just mostly ignores me.
>>>
>>> I say this because at times he seems to respond to what I say, even
>>> if not in a direct reply,
>>>
>>> Also, when someone like you replies, even if he has blocked me, he
>>> will still see me.
>>>
>>> More importantly, If anyone naive wanders into the archives, I want
>>> enough evidence to be around to point out his errors.
>>>
>>> Note also, my longer replies shows what I know and provide reasoning
>>> behind the claims, showing the Truth.
>>>
>>> His short claims, and guff replies just show that he doesn't actually
>>> know what he is talking about, and reveals his ignorance. If he tries
>>> to put his explanation into explicit words, his errors become very
>>> apparent, I think even to him, so he just refuses.
>>
>> You always use the strawman deception as your only basis.
>> Naive readers will never notice this, yet naive readers are not in my
>> target audience.
>>
>>
>
> No, because *I* use the actual definition of a Halting Decider.
>

Anyone that accepts the definition of a universal Turing machine (UTM)
knows that the behavior of D correctly simulated by H provides H with a
correct basis for its halt status decision.

[Jeff Barnett]

On 11/11/2022 11:43 AM, Richard Damon wrote:
> On 11/11/22 1:36 PM, Mr Flibble wrote:
>
>> It is my understanding that Olcott has blocked you and I would have
>> thought given your intelligence you would also understand that.
>>
>> /Flibble
>>
>
> I don't think he has actually blocked me, just mostly ignores me.
>
> I say this because at times he seems to respond to what I say, even if
> not in a direct reply,
>
> Also, when someone like you replies, even if he has blocked me, he will
> still see me.
>
> More importantly, If anyone naive wanders into the archives, I want
> enough evidence to be around to point out his errors.

How is that working? Do you really think that repeating yourself
literally 1000's of times makes good reading? Almost anyone who can look
deeply enough into the logic will notice you engaging in a supposed
dialogue with a stone wall (actually a stone brain). After your first
half dozen messages a few years ago, you have added nothing to the
conversation. Time to move on.

> Note also, my longer replies shows what I know and provide reasoning
> behind the claims, showing the Truth.

It's a trivial truth and few will be fooled. Further, the real truth
tellers and teachers do not hang out in these groups or archives. Too
many truth tellers too few acolytes shrewd enough to know who has the
inside track on god's word. Did you know that PO, in his less lucid
moments, thinks he's a truth teller too? Truth tellers only pass the
word when they preach to the choir.

> His short claims, and guff replies just show that he doesn't actually
> know what he is talking about, and reveals his ignorance. If he tries to
> put his explanation into explicit words, his errors become very
> apparent, I think even to him, so he just refuses.

So what? Rather than save the world from a babbling idiot, why not
rescue homeless puppies at risk? You would be doing a better thing and
would be more admired. A mathematical social worker is not needed.

I think, instead, you don't know what to do with your time and have
select this task to fill the gaps. Anyone studying the archives will
notice that PO is the clear victor in all these threads. His head is too
thick to be bothered by facts or sort-of facts; he's too ignorant and
proud to be bothered by anyone else's facts or religion; and some of
your presentations (articles) are not worded in the best way or are
slightly misleading to someone who doesn't already know most of what you
meant to say. (That's a problem with most of us writing articles without
a few hours reflection before posting.) You will not win this way.

Since I think you seek recognition for your efforts as a white knight
and it's not working, I suggest you go black hat! Beat PO at his own
game: Initiate threads five to twenty times a week; Have response chains
where you respond significant numbers of times to your own articles; Be
outrageous!

This will only work if you devote enough time to take all of the PO
USENET distinctions away from him. You must, every month, win the honors
for (1) most threads started, (2) most number of responses to threads
you have started, (3) most posts by an individual, (4) threads with
largest number of indentations, (5) the highest number of almost
repetitious posts - slight variations required, (6) highest percentage
of silly capitalization, and (7) most times breaking USENET rules on
text postings.

When you follow the above seven point program (and you are well on your
way in many of the points) you will eclipse PO and he will go POOF into
a heap of dust. You will have won! At last. and history and the titles
will be yours. You will be known to future USENET generations, for as
long as the archives are maintained, as a winner.

However, and this is an important however, you will have approximately
the same impact on the truth as you do now. Why not have fun instead?
--
Jeff Barnett

[olcott]

Gullible fools will be quite convinced by your empty rhetoric.

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

None-the-less

Anyone that accepts the definition of a universal Turing machine (UTM)
knows that the behavior of D correctly simulated by H provides H with a
correct basis for its halt status decision.

[Richard Damon]

But only if H DOES correctly simulate its input.

It is true that the correct simulation of the input will show the
answer, but that is because the correct simulaiton of the input BY
DEFINITION matches the direct execution of it.

You still haven't shown how H can correct simulate an input and show it
to be non-halting when the direct exectution of that exact input halts.

D(D) will ALWAYS Halt if H(D,D) returns 0, so that can NOT be the
correct answer, and no "correct simulation" of that input can say that
it is non-halting.

You just don't seem to understand what it means to correctly simulate
something,

Note, you STILL haven't pointed out the x86 instruction where the
correct simulation by H of the x86 code of D differs from the direct
exectuion of it, even though you need to claim it does, which shows the
problem with your claims.

The problem is you can't, because the difference in your explaination
occurs where H desn't actually simulate its input but applies its
INCORRCT reasoning about the behavior of H to its simulation.

This just shows your ignorance and stupidity of the field.

[olcott]

void E(void (*x)())
{
H(x, x);
}

Any H that does abort its simulation to prevent the infinite execution
of E is correct to report non-halting. No shell game can correctly deny
this.

[Richard Damon]

Any H that does aborts its simulation is INCORRECT because the CORRECT
simulation, as will the diret exectuion, will halt. Note, such an H
doesn't do a correct simulation, so any arguement based on it doing so
it just WRONG.

You just are too stupid to understand that H does what it does, so if it
aborts, the correct answer to a machine based on it is based on the fact
that it does abort.

Yes, if H doesn't abort its simulation, then this E(E) will be
non-halting, but that H fails to be correct as it never gives an answer.

You are just PROVING your stupidity because you seem to think that it is
possible for H to both of these programs at once.

You are just showing that you don't understand the requirements of the
problem.

H must decide on the input given to it, and that input is, for this
problem, using the H that you are claiming to get the right answer,
which you fail to do, because you just don't understand what truth is.

You are just proving that you don't understand basic terms like CORRECT,
or PROOF.

YOU H IS WRONG, the fact that you think it is right just makes you STUPID>

It is wrong, because you say it is a Halt Decider, but a Halt Decider,
by definition, needs to answer "Halting" if the direct running of its
input (or simulation by an ACTUAL UTM) will reach a final state. In this
case E it DOES, as you have even admitted. Thus H is wrong.

Your instance otherwise just shows you are a LIAR.

My guess is you must live in Oz, as you seem to like to use your
strawmen, where you replace the PROPER definition of a Halt Decider
deciding on the basis of Direct Exectution, or the equivalent by the
actual simulation by a UTM, with your STRAWMAN of the simulation done by
H, which you claim to be correct, but isn't because it doesn't match the
needed behavior.

YOU FAIL.

[Mr Flibble]

The need to abort the simulation is due to the self reference category
error present in the proof; what Olcott is getting wrong is the mapping
of the need to abort the simulation to a halt decision of non-halting;
it needs to instead be mapped to INVALID INPUT.

/Flibble

[olcott]

If no H ever aborts its simulation of E then no E ever stops running
this conclusively proves that H is correct to abort its simulation and
report non-halting.

[olcott]

I believed that for a decade.

[Richard Damon]

if THE H doesn't abort, it doesn't answer.

if THE H does abor, the E returns, and H just doesn't do a "correct
simulation" that shows that E is non-halting, because it aborted.

You can't look at the behavior of a different H than the one in the problem.

You computer seems to have faulty memory.

FAIL.

[Richard Damon]

Nope, no self reference.

E just has a copy of the H that claim to be deciding it, not a
"reference" to it. Turing Machines do not have the power to directly
express a reference.

H just gets the wrong answer.

The only "self reference" logic that occurs is in trying to do a
NON-COMUTATION to try to deduce the correct answer.

That means there does not exist a design for an H that gives the correct
answer, and any "algorithm" that says for H to just give the right
answer is itself a category error.


The other possible category error is saying that it is the correct
simulation *BY H* that defines the answer, since no H that gives the
answer did a correct/complete simulaiton, thus it is an error to limit
the simulation to only that done by H.

The Correct Simulation of the input WILL give the right answer. If H
returns 0, then the Correct simulation will Halt.

If H doesn't abort, if just fails to give an answer at all, so is wrong.

[olcott]

H only need to correctly predict that its input would never reach its
own final state and terminate normally in 1 to ∞ of correct simulation.

> if THE H does abor, the E returns, and H just doesn't do a "correct
> simulation" that shows that E is non-halting, because it aborted.
>
> You can't look at the behavior of a different H than the one in the
> problem.
>
> You computer seems to have faulty memory.
>
> FAIL.

[Richard Damon]

Right, and it does when CORRECTLY (and completely) simulated or directly
executed.

H just aborts its simulation too soon.

Note, you are not allowed to change the code in the H the E calls when
you try to prove the never stops, which your incorrectly do in your proof.

Since H is defined to be a definite program, it can't be changed without
changing the behavior of E, and it will ALWAYS behave the way it does.

To test "unless", you can change the code of the deciding H, WITHOUT
changing the code of the H called by E, when you do that, you see that
the CORRECT simulation will halt.

You are just too stupid to understand this logic and make your proof
using the WRONG input to your altered simulator that doesn't abort.

Note, E is defined to call the ORIGINAL H, not whatever H you are using
under "otherwise" to test its answer.

FAIL.

[Mr Flibble]

On Fri, 11 Nov 2022 18:25:58 -0500

Nope, if it isn't a self reference then it is infinite copies all the
way down so is the same category error manifesting in a different
way.

/Flibble

[olcott]

You are exactly correct and the Peter Linz proof proves it.

[olcott]

*This is the part where you are either incompetent or a liar*

Any expert in C knows that the correctly simulated E never reaches its
own final state even if an infinite number of steps are correctly
simulated. Thus H is correct to predict that its input never halts.

void E(void (*x)())
{
H(x, x);
}

int main() { H(E,E); }

[Richard Damon]

Only if the "decider" makes that happen, in which case it isn't actually
a decider.

If we assume a prospective decider exists, then the "Impossible" program
is simple to make from it, and is given one copy of the description of
itself, which is also simple to make.

When run it makes a second copy of its description, and then calls the
decider.

After that, it is the deciders job to make the decision in finite time,
by whatever method it wants. If it gets stuck in your infinite loop, the
decider is just wrong.

The proof shows that what ever answer the decider does give (if it gives
one) will be wrong, and thus the decider doesn't meet the requirements.

No "Self Reference" in sight there only a program being given a copy of
something that just happens to be its own description.

The only place we get any form of "Reference", is when we try to ANALYSE
or DESIGN the H to try to meet the challenge. There the effect of the
Self-Reference just lets us see that the task turns out be be
impossible, so no such program exists.

[Richard Damon]

Nope, in fact you have PROVED the opposite. (Or do you forget that)

It just can't be done by H.

Note, the problem doesn't say "by H", that is your strawman, the problem
just references the behavior of the program, which can be seen by direct
execution or correct simulation.

A correct simulation or direct execution will see the H simulating for a
while, then aborting its simulation and returning 0 and E halting. (or
you H never gave what you claim to be the correct answer).

It just is a fact that an H that answer does abort its simulation before
it gets far enough to get the right answer, as is shown by an actual
correct simulation.

You are just too stupid to understand what you are doing.

[olcott]

It is easy to see that the correctly simulated input to embedded_H
cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When we remove extraneous complexity then
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

It is easy to see that the correctly simulated input to embedded_H
cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.

> If we assume a prospective decider exists, then the "Impossible" program
> is simple to make from it, and is given one copy of the description of
> itself, which is also simple to make.
>
> When run it makes a second copy of its description, and then calls the
> decider.
>
> After that, it is the deciders job to make the decision in finite time,
> by whatever method it wants. If it gets stuck in your infinite loop, the
> decider is just wrong.
>
> The proof shows that what ever answer the decider does give (if it gives
> one) will be wrong, and thus the decider doesn't meet the requirements.
>
> No "Self Reference" in sight there only a program being given a copy of
> something that just happens to be its own description.
>
> The only place we get any form of "Reference", is when we try to ANALYSE
> or DESIGN the H to try to meet the challenge. There the effect of the
> Self-Reference just lets us see that the task turns out be be
> impossible, so no such program exists.

[olcott]

If H waits for an inner H to abort its simulation then
this H waits for an inner H to abort its simulation then
this H waits for an inner H to abort its simulation then ...
no H ever aborts its simulation.

You aren't stupid or incompetent for not seeing this, you seem to be
dishonest not remembering all the times that I have already told you this.

[Jeff Barnett]

PS How are we supposed to distinguish between one of you who claims "I
am god" and another ".. If anyone naive wanders into the archives, I
want enough evidence to be around to point out his errors."? Gee, god
vs. defender of naive virtue?

Give it up. Follow Ben's plan.
--
Jeff Barnett

[Richard Damon]

Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that it
its input doesn't stop? So a correct simulation of that input will do
that too.

Note, there is no "embedded_H" in your statement. In your arguement,
embedded_H is just a copy of H, and thus behaves EXACTLY like H. Since
H ⟨Ĥ⟩ ⟨Ĥ⟩ goes to H.qn, the embeded copy of it will.

Why doesn't that happen when Ĥ reaches that exact same code?

Mote, it doesn't matter that embedded_H won't actually correctly
simulate its input, and in fact, it CAN'T since H doesn't, and
embedded_H is just a copy of H. (or you are just a liar).

Remember
H ⟨Ĥ⟩ ⟨Ĥ⟩ is required to go to H.qy if Ĥ ⟨Ĥ⟩ will Halt and
H ⟨Ĥ⟩ ⟨Ĥ⟩ is required to go to H.qn if Ĥ ⟨Ĥ⟩ will never Halt

(Or don't you understand the part of the description you like to omit?)

Please note that none of this refers to ANY simulation to determine the
correct answer. Yes, you can replace the behavior of the machine with
the behavior of a UTM processing the input, but H isn't a UTM either,
since it abort. Also, such a UTM simulaiton isn't a piece of the
execution of H, but a specification for H, and in fact, H CAN'T just use
a UTM, as then it can't ever give a non-halting answer in finite time.

Maybe the problem is that you don't understand what you are saying.

It seems that you build the Halt Decider you describe, you need someone
to give you a Halt Decider to determine when the UTM will run forever,
and if you try to use your machine for that, it needs another halt
decider to tell it when to stop and so on. In other words, your design
fails to be finite.

[olcott]

I made the basis of my proof much easier to understand so that anyone
that is an expert in the C programming language would be able to
understand a simulating halt decider.

void E(void (*x)())
{
H(x, x);
}

When H(D,D) returns 0 it correctly predicts that D correctly simulated
by H would never reach its own final state and terminate normally after

1 to ∞ of correct simulation.

I predict that no one will be able to find any actual error with that.

[Richard Damon]

Right, if your H is designed THAT way, it never aborts and thus fails to
answer.

That doesn't make it right to abort without actually having proved you
know the answer.

You are just shwoing that you are a Hypocrite, as you say it is
illogical to use non-truth perseving operations, but you then use that
sort of logic to try to make your claims.

Remember, H needs to answer about the E made form IT, not some other
version of it that behaves "slightly" differently based on a general
category of pperation but a different exact process.

You need to FIRST define what EXACTLY your H is going to do. Remeber,
"Get the Right Answer" is NOT an algorithm, you need to define the
actual "mechanical" steps it will perform to get the answer.

Then you define your H^/P/D/E from that H, and compare the answer of
H(E,E) to the behavior of E(E) to see it it was right.

Based on what you have defined, either H(E,E) is going to never return
an answer, and thus this H just fails, or H(E,E) will return 0, and then
the running or correct simulation of E(E) will call that H(E,E), get
back the return of 0 and halt.

The fact that the simulation that H did was stopped gefore there doesn't
mean anything, as the correct simulation by an independent simulator shows.

You insistance otherwise just shows that you are too stupid to
understand how the logic works.

You just don't know what a correct simulation means.

[olcott]

⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩

[olcott]

I made the basis of my proof much easier to understand so that anyone
that is an expert in the C programming language would be able to
understand a simulating halt decider.

void E(void (*x)())
{
H(x, x);
}

When H(D,D) returns 0 it correctly predicts that D correctly simulated
by H would never reach its own final state and terminate normally after

1 to ∞ of correct simulation.

[Richard Damon]

If embedded_H does "Correctly Simulate" this input, then it is the case
that H never aborts its simulation, and thus H will never return an answer.

Since H DOES abort its simulation, since you claim it "correctly"
returns 0, embedded_H can't do a correct simulation, and thus your
statememt is meaningless.

Which way are you wrong?

You are just proving that you don't understand what you are talking
about or you are just intentionally lying about everything.

It is clear that you just don't understand how programs work.

You will be know FOREVER as someone who just tried to spread falsehoods
because they wanted to show something that wasn't actually true.

Maybe you will get some cover from Trump, as your lies aren't attempting
to do somethihng as big, but they are no better than what he has been
doiong.

[olcott]

Yes and when embedded_H can predict this in a finite number of steps
then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.

[Richard Damon]

Except that it didn't correctly predict that, as it can't correctly
predict that as the actual correct simulation of the input by a real
correct simulator, which will agree with the direct exectuion of the
input, shows that it does reach the final state, after the point that H
gives up.

You keep on using the ILOGICAL statement of D correctly simulated by H
never halting, The problem is that H doesn't actually DO a correct
simulation, and your design of H CAN'T do a correct simulation and still
be the H in question.

You logic is based on a FALSE PREMISE, and just is just UNSOUND.

It is built on a Strawman argument of changing the criteria to decide
Halting.

It is just showing you are a lying idiot.

Lying because you SHOULD know better, and an idiot because you think
reasonable people with actually belive you even after the check things out.

You might be able to bamboozle some people for a bit with confusing
words, but they WILL see through it.

You are just condeming your repurtation.

[Richard Damon]

Except that it can't do that since it is shown that H^ <H^> Will halt in
this case, so it is impossible to correctly predict that a correct
simulation of the input <H^> <H^> will not halt.

You just make brash claims without proof.

You are just showing that you are too mentally deficient to understand
the full meaning of your logic.

You even have admitted that H^ <H^> will Halt, but somehow think that a
correct simulation of it doesn't need to act like the machine itself,
which is a simple violation of the defintion.

In other words, you don't know the basic meaning of the words, because
you are to ignorant and stupid.

[olcott]

You and I can both see that
the correct and complete simulation of D by H never reaches its final
state in 1 to ∞ steps of correct simulation

thus when H returns 0 indicating that
the correct and complete simulation of D by H never reaches its final
state in 1 to ∞ steps of correct simulation

it is correct in the same way that 1==1 is true.

[olcott]

> Give it up. Follow Ben's plan.

Ben's plan is entirely based on the fact Professor Sipser decimated
Ben's only rebuttal of my work. Ben wants to actively suppress review of
my work because he can now see the clear path to my success.

[Richard Damon]

The H in question never does and can't do a correct and complete
simulation of this input, so if you mean something that never happens
will never complete, the yes, but not doing something doesn't actually
show that it won't complete.

It IS a fact that the correct and complete simulation of this input WILL
Halt, as has been show. Thus, if we somehow imagined that H could do
this, it would need to get the same result.

The problem is you don't have the mental agility to see that question
correctly. I think part of it is you don't really understand what
"unless" actually implies.

>
> thus when H returns 0 indicating that
> the correct and complete simulation of D by H never reaches its final
> state in 1 to ∞ steps of correct simulation

But it lies in doing that, as there can never be a correct and complete
simulation *by H*, and it is a fact that the ACTUAL correct and complete
simulation of THIS input will reach the end.

>
> it is correct in the same way that 1==1 is true.
>
>

Nope, it is correct in the same way that 1 + 1 == 4 is true.

The key is you are comparing the behavor of a DIFFERENT H looking at a
DIFFERENT input to make you claims. THIS H never does and never can do a
correect and compete simulation of this input.

By looking at a DIFFERENT H (let's call it Hn) that has been changed to
not abort and a different input E (let's call it En) that is based on
this different Hn, you are looking at a different problem.

You have been given 1 + 1, but have decideed that you actually don't
like 1, but will use 2 instead, so you answer 1 + 1 = 4.

Note, Hn(En,En) would be correct to return non-halting, since En(En) is
non-halting, but Hn doesn't return an answer.

Thus H(En,En) would be correct to return 0, but we aren't looking at
H(En,En) but H(E,E), and your H just can't tell the difference between E
and En, and just assumes it is En, so gets the wrong answer.

The other point is that having built this Hn, it is actually possible to
run Hn(E,E) and it will not abort it simulation and let us see the
actual behavior of this input, and in THIS case, it gets the correct
answer that Hn(E,E) will return 1 as it will simulate it to the final state.

Of course one problem you will have is that do to the fatal flaw in the
design of your system, is that since you insist on calling both H, you
can't actually perform these cross version checks. It appears that you
have done this to maximize your ability to be deceptive about what you
are talking about.

Also, you have shown yourself to be to ignorant of what you are actually
supposed to be doing to understand any of this.

[olcott]

H correctly predicts that D correctly simulated by H would never reach
the final state of D in 1 to ∞ steps of correct simulation.

void Infinite_Loop()
{
HERE: goto HERE;
}

H correctly predicts that Infinite_Loop() correctly simulated by H would
never reach the final state of Infinite_Loop() in 1 to ∞ steps of
correct simulation.

[olcott]

A simulating halt decider must correctly predict (in a finite number of
steps whether or not its simulated input would ever stop running if it
never aborted its simulation of its input.

[olcott]

When simulating halt decider embedded_H transitions to its reject state
⟨Ĥ.qn⟩ it is correctly predicting that ⟨Ĥ⟩ simulated by embedded_H would
never reach its own final state in 1 to ∞ steps of correct simulation.

[olcott]

On 11/11/2022 8:31 PM, Sergi o wrote:

> if it doesn't bust the compiler, run it through a code checker, lots of
> free ones out there
>
> https://www.onlinegdb.com/online_c_compiler


The last remaining issue is the acceptance of the notion of a simulating
halt decider.

[Richard Damon]

Right, it must, but it can't. Again, your Egish is lacking because you
are too stupid.

If you claim it can, what pattern did it use to detect this, that ALWAYS
shows the program is non-halting?

I will note that E(E) calling H(E,E) is NOT such a pattern, as E(E) will
halt if H(E,E) is defined to abort that simulation and return 0.

Note, the "if it never aborted" is a fantasy claim, as H DOES abort its
simulation. In this context, your phrase means to look at the alternate
reality when THIS EXECTUTION of H has been changed, but not any others.

Because of your erroneous structure of H and E (E is supposed to be an
INDEPENDENT PROGRAM, not a piece of the program H), you can't actualy
write that hypothetical case, as it requires two different version of H
to exist together.

[Richard Damon]

How it that a correct prediction of a correct simulation if the input
wil halt when run?

You just don't understand the meaning of correct, or program.

Remember, embedded_H is an exact copy of the version of H that is
claimed to be correct, as is the copy in the representation given to it.

This version DOES abort its simulation and go to qn, so the "correct
determination" is to be made of the input that does that, not the
version that is created in the hypothetical of H/embedded_H not aborting,

You are just too stupid to understand this. Sorry you wasted the last 18
years and ruined your reputation because of that.

[Mr Flibble]

On Fri, 11 Nov 2022 19:24:53 -0500

You are fractally wrong on all fronts: in the traditional halting
problem proofs based on [Strachey 1965] the program is impossible not
due to self reference or infinite copies but because the input tries to
do the opposite of what the decider decides; the category error that I
have identified is different: it is an error of self reference and/or
infinite copies; it is an error related to the fact that the input
references a decider rather than being related to what the input does
with the decision result of a decider.

/Flibble

[Richard Damon]

So, thats just the logical falacy of proof by example. Note I didn't say
that H can NEVER make such a prediction, just not for the input of the
"impossible program:.

You are just showing you don't understand the meaning of another word,
"this".

You are just to stupid for this problem, causd by your self-imposed
ignorance of it.

FAIL.

[Richard Damon]

Why, It is actually a well know concept, as a PARTIAL solution of the
problem.

I remember it being shown as why you CAN'T just solve the problem with one.

Your ignorance of the history of this topic has doomed you to repeat all
the errors that others have made in the past.

[Mr Flibble]

A simulating halt decider is Olcott's idea.

/Flibble

[Richard Damon]

But the infinite copies is a error in the Decider, not in Strachey's
program. The decider is SUPPOSED to be able to handle ANY input and
answer in finite time, If an input causes it to make infinite copies,
then the decided just doesn't meet its requirements.

Turing Machine can ALWAYS be legally built based on another Turing
Machine as a base. The only reason it wouldn't be allowed is if H isn't
actually a Turing Machine, so it CAN'T be a category error if H is
actualy a Turing Machine.

All your declaration of a "Category Error" here is doing is admitting
that your H can't actually be a Turing Machine, but must be of a HIGHER
order logic system, which means H fails the requirement to be the needed
decider.

[olcott]

Thanks. I was thinking about filing a trademark on it.

[Mr Flibble]

On Sat, 12 Nov 2022 09:32:23 -0500

In which case we get infinite turning machines all the way down: yet
another manifestation of the category error I have identified.

/Flibble

[olcott]

On 11/12/2022 8:02 AM, Richard Damon wrote:
> On 11/11/22 11:00 PM, olcott wrote:
>> On 11/11/2022 8:56 PM, Richard Damon wrote:
>>> On 11/11/22 9:48 PM, olcott wrote:
>>>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>>>> On 11/11/22 9:35 PM, olcott wrote:
>>>
>>>> Yes and when embedded_H can predict this in a finite number of steps
>>>> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>
>>> Except that it can't do that since it is shown that H^ <H^> Will halt
>>> in this case, so it is impossible to correctly predict that a correct
>>> simulation of the input <H^> <H^> will not halt.
>> A simulating halt decider must correctly predict (in a finite number
>> of steps whether or not its simulated input would ever stop running if
>> it never aborted its simulation of its input.
>>
>>
>
> Right, it must, but it can't. Again, your Egish is lacking because you
> are too stupid.
>
> If you claim it can, what pattern did it use to detect this, that ALWAYS
> shows the program is non-halting?
>
> I will note that E(E) calling H(E,E) is NOT such a pattern, as E(E) will
> halt if H(E,E) is defined to abort that simulation and return 0.

void Infinite_Loop()
{
HERE: goto HERE;
}

It is an easily verified fact that Infinite_Loop correctly simulated by
H would never reach its own last instruction and terminate normally
after 1 to ∞ steps of correct simulation.

void E(void (*x)())
{
H(x, x);
}

It is an easily verified fact that E correctly simulated by H would
never reach its own last instruction and terminate normally after 1 to ∞
steps of correct simulation.

[Mr Flibble]

On Sat, 12 Nov 2022 09:32:23 -0500

In which case we get infinite Turing Machines all the way down: yet

another manifestation of the category error I have identified.

We can play these games all day but I will always win because the
category error I have identified is real and refutes the Halting
Problem proofs.

Olcott's SHD confirms the presence of the category error I have
identified but I still disagree with his mapping of its manifestation
to a decision of non-halting; it should be a mapping of INVALID INPUT
instead; but all you learn-by-wrote types refuse to accept such a thing
as you refuse to extend the definition of a halting decider to include
such a mapping: you are trying to play the game with weighted dice.

/Flibble

[Richard Damon]

Where are infinite machines? There is ONE machine being run, either H or
D, and it SIMULATING others, and if we get an infinite sequence of
simulations we have just shown that H was defective because it failed to
answer in finite time.

This isn't a category error, but a design error in H.

Note, when we start H, there is exactly two machines present in
representation on the tape, and two is much smaller than infinity.

[olcott]

Neither the directly executed E nor correctly simulated E ever stops
running unless the simulated E is aborted. This conclusively proves that
the simulated E specifies a non-halting sequence of configurations.

[Richard Damon]

Go ahead and waste your money.

I remember the discussion of trying to determine halting by simulation
back in my school days, so not a new concept. Normally showing the
simple reasons about why it doesn't work.

Note, this is pre-internet, so your Google searches not bringing it up
is understandable.

Likely didn't reach "published papers" as it was a well known dead end
so no need to write the paper.

[Richard Damon]

No, the directly executed or correctly simulated E DO stop running
because the copy of H they use will abort the simulation of THEIR inputs.

Since this is the behavior of the H in question, that is what they are
supposed to do.

How can a directly executed or correctly simulated machine even BE
"aborted" by something that isn't in control of them.

You clearly don't understand what you are talking about.

You seem to not understand the difference of different invocations of a
program.

You are just proving your stupidity.

[Mr Flibble]

On Sat, 12 Nov 2022 09:52:12 -0500

Nope, if,

a) H is a copy, and
b) H is a Turing Machine, and
c) D is an input into H, and
d) D references H, and
e) H references D,

then (d) and (e) repeat ad infinitum so we get infinite Turing Machines
all the way down: a manifestation of the category error I have
identified.

/Flibble

[Richard Damon]

Then verify it. Hard to do since E(E) does halt since H(E,E) returns 0.

You seem to think that a correct simulation can act differently then
then the thing it is simulating, which is just definitionally incorrect.

The fact that it can get a simple case right is not proof that it can
get the more complicated correctly, but a classic fallacy that you
apparently don't understand due to your lack of knowledge,

You are just confirming your stupidity by your stupid claims.

[Mr Flibble]

On Sat, 12 Nov 2022 10:06:48 -0500
Richard Damon <Ric...@Damon-Family.org> wrote:
> You are just confirming your stupidity by your stupid claims.

Try arguing using facts and logic rather than ad hominem attacks.

/Flibble

[Mr Flibble]

On Sat, 12 Nov 2022 09:58:47 -0500

So you have no evidence to backup that claim. So no prior art leaving
Olcott free to trademark or file a patent.

/Flibble

[Richard Damon]

H doesn't reference D, in fact it CAN'T because D doesn't exist when H
is created. You can't actually reference something that doesn't exist.

H is GIVEN a copy of D as its input, that is NOT a "reference".

As I have pointed out before, Turing Machines do not support the direct
concept of a "Reference", but can only support it as something encoded
into the language of the representation of their inputs, and thus can
only reference other things in their input.

If H blindly processes its input and starts another round of simulation
unconditionally, then H is just defective, and not a decider.

All you are showing is that a "Simulating Halting Decider" that is based
on unconditional simulation is a failed method of decision.

[olcott]

What you are remembering is that a halt decider cannot correctly
determine the halt status of an input by only simulating this input
because some inputs never terminate.

A simulating halt decider simulates its input in debug step mode and
examines the execution trace of this input for non-halting behavior
patterns.

> Note, this is pre-internet, so your Google searches not bringing it up
> is understandable.
>
> Likely didn't reach "published papers" as it was a well known dead end
> so no need to write the paper.

[Mr Flibble]

The corollary being that a simulating halting decider proves that what
I am saying is correct; the onus is on you to prove that a SHD is not a
valid halt decider type.

/Flibble

[Richard Damon]

He can't file a patent, as he has publicly disclosed the idea too long
ago. Public disclosure precludes later patent. If he filed a preliminary
patent BEFORE disclosure, he is given a limited amount of time to
finalize it, but I think too much time has passed now for that to be an
option.

There is also the problem tha that you need to demonstrate that it works.

I suspect the attempt to trademark "Simulating Halt Decider" would be
denied as it is just a "Generic/Descritive Term or Phrase" and NOT a
"Brand Identification".

He might be able to Trademark (SHD) in a restricted scope of that
abbreviation isn't used in something similar.


If it was really worth my time, I might be able to find something from
that era with that mention, but it isn't worth my time.

Since the phrase isn't actually something he could register, it doesn't
really matter. Him claiming the "invention" of the idea, just proves to
those that know something of the field how ignorant he is,

He is just proving the adage from Winston Churchill that "Those that
fail to learn from history are doomed to repeat it", as Olcott has
repeatedly repeated errors that where worked out decades, to even a
century before.

[Richard Damon]

And it has been well known that non-halting does not have a finite set
of cases that always detect it.

That concept is probably above your mental ability to understand, as you
have shown definite limittations in dealing with non-finite sets.

[olcott]

The point is
that D correctly simulated by H would never reach its own last
instruction and terminate normally after 1 to ∞ steps of correct simulation.

When H returns 0 to main() it is indicating

that D correctly simulated by H would never reach its own last
instruction and terminate normally after 1 to ∞ steps of correct simulation.

[olcott]

The point is
that E correctly simulated by H would never reach its own last

instruction and terminate normally after 1 to ∞ steps of correct simulation.

When H returns 0 to main() it is indicating

that E correctly simulated by H would never reach its own last

[Mr Flibble]

On Sat, 12 Nov 2022 10:41:58 -0500

You are obviously unaware of the USPTO which allows patent trolls to
file vague nebulous patents all the time that are certainly not
"demonstrated to work". Patent trolls don't make money by creating
patented product, they make money through litigation if they think
their vague patents can be asserted in a congenial legal district.

/Flibble

[Richard Damon]

Please re-read what you snipped.

Ad-hominem would be saying he is wrong because he is stupid, using
claimed characteristics of the "hominem" to try to "prove" a statement.

Note, I am using the fact that he is wrong, as previously proven, to
show his "hominem" has a characteristic. That is NOT "ad-hominem", but
this detail is probably something too subtle for you.


Note, this is different than how Olcott uses it, where he doesn't
actually show ANY evidence his opponent is wrong, but just says they
must be too stupid as anyone smart enough would see he is right, which
just compounds that fallacies.

[Richard Damon]

Nope, the onus is on you to prove your claim, which you haven't done.

Note, I am not saying that you can't build a PARTIAL Halt Decider based
on simulation, just that they can't be a COMPLETE Halt Decider that is
able to decide on ALL inputs, since there can't exist a Halt Decider, of
ANY type, that can do that.

Note, the proof that it doesn't can be the simple Linz proof, as
presuming you are claiming that a Simulating Halt Decider IS actually
also a Halt Decider, then its definition of correct is the behavior of
the actual input, and H^ <H^> is shown to halt if H <H^ <H^ -> qn, so
that answer is NOT correct, BY DEFINITION.

If you aren't claiming that a Simulating Halt Decider is actually a Halt
Decider but something else, then they aren't applicable to the Halting
Problem, as that only deals with Halting Deciders.

[olcott]

void Infinite_Loop()
{
HERE: goto HERE;
}

void E(void (*x)())
{
H(x, x);
}

It is an easily verified fact that Infinite_Loop and E are correctly
recognized as specifying non-halting behavior to H.

[olcott]

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

So if I smash a Boston cream pie in your face you will say blub, blub
blub (speaking through pie dripping from your face) there is no pie.

[Richard Damon]

And you are not aware that such patents can be declared invalid, and the
trolls required to pay the legal fees of the chalenger if said patent is
determined to have been fraudulently field.

Yes, some trolls do get away with invalid patents because it isn't worth
the effort.

Note also, "work" doesn't need to be commercially viable, so can be a
low standard in some fields.

A patent must include a sample implementation of the invention it
claims, and claims about what that implementation can do. "Lying" about
that ability invalidates the patent.

[Richard Damon]

How is E verified? Remember, I have previously shown the error in your
claim that E(E) calling H(E,E) is sufficient, since you have said that
H(E,E) returns 0 when directly called.

What you have shown is that:

void En(void (*x)())
{
Hn(x,x);
}

is correctly decided by H to be non-halting, but that isn't the input
that H is given.

You logic presumes behavor of the H that E calls that isn't actually the
behavior of H.

You do this because you just don't understand what you are talking about.

The problem is your description of what H does that you use in your
logic doesn't actually match what H does, because it isn't an actual
computable algortihm, but based on unsound logic.

[olcott]

Since you know this is true I don't see why you continue to lie about it.

When H(E,E) returns 0 it is correctly rejecting its input on the basis

that E correctly simulated by H would never reach its own last
instruction and terminate normally after 1 to ∞ steps of correct simulation.

The definition of a UTM specifies that the correct simulation of a
machine description provides the actual behavior specified by this
machine description thus H is correct to base its halt status decision
on E correctly simulated by H.

[Richard Damon]

So, you admit that you don't understand what you are saying as you
respond with an irrelevant comment.

Juar shows the utter weakness of your position.

I guess this adds another word to your list of things you don't
understand, "Reference".

Sorry, you are just too stupid to be doing this.

If you want to prove otherwise, actually try to SHOW what you are saying
is true.

The liar resorts to just trying to put down his opponent, since he can't
deal with their words. I show your errors, you just rant that I must be
wrong since you don't understand how to even actually attempt to prove
your statement.

Maybe the issue is you know you can't do it, so you think you are being
deviously deceptive by pointing out irrelevant details, but it actually
just shows your stupidity, as most people are smarter than you think
they are (at least those you are trying to persuade).

[Richard Damon]

Except D is NOT correctly simulated by H, so that is a incorrect
statement. When it is correctly simulated by something other than H, it
will come to a final state, showing your statement is wrong.

Unless you admit that H isn't a Halt Decider, and just a POOP decider,
thn you statment is just FALSE.

You lie by trying to make H be multiple different programs at the same
time, which shows your ignorance of the rules of the system.

D (or E) is DEFINED to be calling the H that is claimed to be correctly
deciding it, which is the one with the abort in it,

Looking at a D that uses a different H is just showing you are a
deceptive liar who doesn't understand the rules of the game he claimes
to be playing.

You are just showing you utter lack of knowledge of the basic rules of
logic.

You are obviously too stupid to understand what you are talking about.

[Mr Flibble]

On Sat, 12 Nov 2022 11:09:56 -0500

Filing a patent and ruling a filed patent is invalid in court are two
different things, dear.

/Flibble

[Richard Damon]

Which is a STRAWMAN, or is H not a Halt Decider,

A Halt Decider needs to decide on the direct exectution of the input, or
the input simulated by a UTM, which, by definition, never aborts its
simulation, so H isn't a UTM.

FAIL.

>
> would never reach its own last instruction and terminate normally after
> 1 to ∞ steps of correct simulation.
>
> Since you know this is true I don't see why you continue to lie about it.

No, you THINK that Strawman statement is a usable basis, but it isn't.

You are just proving your stupidity by repeating it.

>
> When H(E,E) returns 0 it is correctly rejecting its input on the basis
> that E correctly simulated by H would never reach its own last
> instruction and terminate normally after 1 to ∞ steps of correct
> simulation.
>
> The definition of a UTM specifies that the correct simulation of a
> machine description provides the actual behavior specified by this
> machine description thus H is correct to base its halt status decision
> on E correctly simulated by H.
>
>

Except H isn't a UTM. H can base its answer on what a UTM would do when
simulating the input, but since H isn't a UTM, it can't use itself.

UTM(E,E) will see E call H(E,E), then H simulating E(E) until it sees it
call H(E,E) again, and then abort its simulation and return 0 to E and
then E halt.

Ths the correct answer is HALTING.

You are just showing you just fundamentally don't understand even the
basics of the field you are talking about, showing your stupidity. This
incompetence is of such a high magnatude, it seems that you are likely a
pathological liar to not be able to see the errors in your logic,
totally unable to tell the difference between truth and error.

[olcott]

In order for the simulation to actually be incorrect the execution trace
of the simulated E must diverge from the behavior that the line-by-line
x86 source-code of E specifies.

The first seven lines of the execution trace of the simulated E exactly
match the behavior specified by the first seven lines of the x86 source
code of E. This conclusively proves beyond all possible doubt that these
first seven lines have been simulated correctly.

*H correctly determines that E never halts*

void E(void (*x)())
{
H(x, x);
}

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

_E()
[000019d2] 55 push ebp
[000019d3] 8bec mov ebp,esp
[000019d5] 8b4508 mov eax,[ebp+08]
[000019d8] 50 push eax
[000019d9] 8b4d08 mov ecx,[ebp+08]
[000019dc] 51 push ecx
[000019dd] e8b0f9ffff call 00001392
[000019e2] 83c408 add esp,+08
[000019e5] 5d pop ebp
[000019e6] c3 ret
Size in bytes:(0021) [000019e6]

_main()
[000019f2] 55 push ebp
[000019f3] 8bec mov ebp,esp
[000019f5] 68d2190000 push 000019d2
[000019fa] 68d2190000 push 000019d2
[000019ff] e88ef9ffff call 00001392
[00001a04] 83c408 add esp,+08
[00001a07] 50 push eax
[00001a08] 6893060000 push 00000693
[00001a0d] e8a0ecffff call 000006b2
[00001a12] 83c408 add esp,+08
[00001a15] 33c0 xor eax,eax
[00001a17] 5d pop ebp
[00001a18] c3 ret
Size in bytes:(0039) [00001a18]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000019f2][00102a7c][00000000] 55 push ebp
[000019f3][00102a7c][00000000] 8bec mov ebp,esp
[000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
[000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
[000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H

H: Begin Simulation Execution Trace Stored at:112b28
Address_of_H:1392
[000019d2][00112b14][00112b18] 55 push ebp
[000019d3][00112b14][00112b18] 8bec mov ebp,esp
[000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
[000019d8][00112b10][000019d2] 50 push eax // push E
[000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
[000019dc][00112b0c][000019d2] 51 push ecx // push E
[000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

H correctly reports that E correctly simulated by H cannot possibly
reach its own final state at machine address [000019e6] and terminate
normally in 1 to ∞ steps of correct simulation.

[olcott]

Richard is correct that an invention can be prior art against itself
after one year of public disclosure. I didn't publish the actual halt
deciding criteria until very recently.

[Richard Damon]

And filing for a patent that will get overturned is mostly just a waste
of money.

It actually takes a reasonable amount of work to file a patent, and a
lot of work to write a "troll" patent that has a chance to get by the
examiners to even give you a chance to try to use the legal hammer.

You also need to be careful to attack the right caliber of defendants,
they need to have enough money to get a return on your investment, but
not so much that they might go to invalidate your troll patent.

Many of them actually work with "bought" patents, as that gives them
plausible deniability that the patent in invalid, limiting their
economic exposure.

[Richard Damon]

Right, and since you simulation does NOT continue past the call to H, it
is "incorrect" in the sense that the actual code does continue past that
point, so it does not actually match the behavior of that machine.

>
> The first seven lines of the execution trace of the simulated E exactly
> match the behavior specified by the first seven lines of the x86 source
> code of E. This conclusively proves beyond all possible doubt that these
> first seven lines have been simulated correctly.

Right, so H has correctly done a PARTIAL simulation of its input, which
does NOT prove the input is non-halting.

So you are just admitting you don't understand the Halting Criteria.

The fact that H stops its simulation before it gets to the end does NOT
prove that the machine being simulated, or a correct and complete
simultion of the input would be non-halting.

Or, do you claim that you have correctly climbed Mount Everest since
ever step of you climb of it were correct?

You are just proving you lack of understanding of the meaning of a
correct simulation.

[olcott]

We must handle only one point at a time because you are easily
overwhelmed. You usually cannot even handle one point at a time until
this point is repeated 20 or more times.

The fact that the line-by-line execution trace of the first seven
instructions E simulated by H exactly match the behavior specified by
the first seven instructions of the x86 source-code of E conclusively
proves that these first seven instructions are simulated correctly.

[Mr Flibble]

On Sat, 12 Nov 2022 12:59:18 -0500

Olcott is correct and you are incorrect: you don't seem to understand
what an (infinitely) recursive function actually entails.

/Flibble

[Richard Damon]

No, that says that H did a correct PARTIAL simulation of the input. You
seem to be INTENTIONALLY using deceptive terminology to spread you lies.

So, I suppose you can correctly say that the input doesn't stop within
its first 7 instructions, but that doesn't mean anything.

Since you make a claim about a COMPLETE simulation (the it will never
end) you need to establish THAT fact (and you can't change the input to
do it, which includes the H the E calls).

YOU FAIL

You show that you don't understand what you are talking about and seem
to actually think that you are proving something by using wrong defintions.

You are just showing how stupid you are.

[Richard Damon]

So you think that a function that returns in finite time can be
infinitely recursive, or that a given computational function, given the
same input, can give different results?

Since this H(E,E) returns 0 when called, it returns 0 to E(E) when it
calls it that way, and thus does NOT create an infinite recursion,

H is just wrong about its reasoning about itself, perhaps because it
doesn't actually met the specification given to it that it uses to
analyze itself.

[Mr Flibble]

On Sat, 12 Nov 2022 13:24:00 -0500

Again with the ad hominem attacks: "liar", "stupid" etc. You are not
very good at his are you, Mr Damon.

/Flibble

[olcott]

Yes that is correct now we can move on to the next point.

void E(void (*x)())
{
H(x, x);
}

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

H: Begin Simulation Execution Trace Stored at:112b28
Address_of_H:1392
[000019d2][00112b14][00112b18] 55 push ebp
[000019d3][00112b14][00112b18] 8bec mov ebp,esp
[000019d5][00112b14][00112b18] 8b4508 mov eax,[ebp+08]
[000019d8][00112b10][000019d2] 50 push eax // push E
[000019d9][00112b10][000019d2] 8b4d08 mov ecx,[ebp+08]
[000019dc][00112b0c][000019d2] 51 push ecx // push E
[000019dd][00112b08][000019e2] e8b0f9ffff call 00001392 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

We can see that the seventh instruction of E correctly simulated by H
would call H to simulate itself again.

We can also see that there are no instructions from the beginning of E
to its call to H that would prevent this process from repeating an
unlimited number of times.

These two things taken together conclusively prove that H would be
correct when it reports that D correctly simulated by H would never
reach its own final state at machine address [00001a18] and terminate
normally.

[Richard Damon]

No, E calls H which will HALT DECIDER (by simulation) its input. This H
will simulate its input ONLY to the point when it THINKS it is
non-halting, which will happen at the point when the simulation reaches
the call to H instuction, thus we don't get "infinite" simulation loop,
but just 1 level inside E.

Unless you are claiming that H is just a pure simulator that never
aborts its simulation, you statement is just a lie. But then, H(E,E)
doesn't return an answer, so you also are caught in a lie. The only
other opition is that you have lied that the H that main calls and the H
the E calls are the same function. In other words, you have just been
proven to have LIED.

The problem is that you are LYING that H will correct simulate its
input, which it doesn't.

>
> We can also see that there are no instructions from the beginning of E
> to its call to H that would prevent this process from repeating an
> unlimited number of times.

Which isn't a requirement. An instruction inside the H that it calls
that terminates the loop is sufficient.

You clearly don't understand the meaning of what you are talking about.

>
> These two things taken together conclusively prove that H would be
> correct when it reports that D correctly simulated by H would never
> reach its own final state at machine address [00001a18] and terminate
> normally.
>
>

Nope, two errors do not make a right statement.

You are just showing your ignorance.

[Richard Damon]

So, you don't understand the meaning of ad hominem. The fallacy of
ad-hominem is to say the person must be wrong because they are a "X".
That is not what my statement is, but that he is wrong for a specified
logical reason. I then point out that BECAUSE he is stating these
incorrect statements, he is a liar and stupid. That is a valid logical
deduction.

YOU are showing you lack of understanding.

[olcott]

Try again this time don't use a noun as a verb gibberish.

[Richard Damon]

So you can't understand that the call to H is supposed to Halt Decide
its input?

Minor typo, not gibberish like what you post that might follow correct
syntax but has a lack of semantics.

Do you agree that H(E,E) does return 0 when called?

[Mr Flibble]

On Sat, 12 Nov 2022 14:00:21 -0500

I fully understand what constitutes an ad hominem; YOU are using a
DISGUISED ad hominem by using insults after the fact in an attempt to
strengthen your argument. A DISGUISED ad hominem is still an ad
hominem if you use it as part of your argument, which you are.

To be clear, if you called Olcott "big nose" rather than "stupid" then
that would just be an insult however calling someone "stupid" implies
you think they have a low IQ which is a characteristic that directly
relates to their ability to argue/debate (unlike "big nose") and so is
a logical fallacy, albeit a disguised one.

/Flibble

[olcott]

Again you leap ahead past the point at hand. Doing this makes sure that
the point at hand is never addressed and you false assumptions continue.

It is agreed that H does correctly simulate the first seven instructions
of E.

The first seven instructions of E correctly simulated by H show that E
would call H to simulate itself again and that no instructions from the
beginning of E to its call to H can possibly prevent this from repeating

an unlimited number of times.

[olcott]

Good job you nailed that much better than I could have.

[Richard Damon]

I will point out that Peter Olcott BEGAN the insults, and continues them.

Why dont you issue the complaints to HIM?

As to thinking he has a low IQ, I DO. He has shows incredible lack of
reasoning capability. I do wonder if he has a bonafide mental condition.

He has shown an inability to put together a reasoned arguement.

He has shown a decided tendency to maintain conflicting idea and assume
they work together.

He has shown fundmental issues with the understand of basic English and
how it interacts with technical discussion.

He has ADMITTED that he doesn't have training in the basics of the
system he claims to talk about it, and brags about it as if that was a
good thing.

In other words, by the definition of the word, he has admitted to being
IGNORANT of the field.

[Richard Damon]

No, you characterize H incorrectly.

I have explained this, and you snipped it, showing that you are
INTENTIONALLY ignoring it, showing your illogic.

it doesn't matter that the instruction that stops the loop is in H
instead of E, it it there.

Please provide some reference to anything that supports your claims.

You are just continuing to display your deceptive attempt to describe
the behavior of H.

E will call H which will simulate a new copy of E, abort the simulation
and return to E which will Halt.

YOU LIE in you description that this is an infinite simulation loop.

YOU are just showing that you just don't care about what is actually
true, or maybe you just don't understand what is true.

You seem to be unable to understand what people tell you, but are just
tuck in your own mental roadblock.

This shows your mental inability. You are just not thinking straight.

Until you actually even try to reply to my correction to your
description, you are just continuing to be guilty of being deceptive.