Refutation of the Ben Bacarisse Rebuttal

[olcott]

The behavior of the directly executed P(P) is different than the
behavior of P(P) correctly simulated by H because in the first case H
has already aborted its simulation of its input and in the second case
this has not yet occurred.

I now refer to P(P) as D(D).

Can D correctly simulated by H terminate normally?
No it cannot see the details below.

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

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

D correctly simulated by H cannot possibly terminate normally by
reaching its own final state at line 09.

We can easily fix what Ben has misconstrued as a contradiction by
defining the return value of 0 from H as meaning:
(a) the input does not halt <or>
(b) the input is defined to have a pathological relationship to H.

Since it is true that D was defined to do the opposite of whatever
Boolean value that H returns H is correct to return 0.

*Termination Analyzer H is Not Fooled by Pathological Input D*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D



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

[Richard Damon]

On 6/19/23 4:43 PM, olcott wrote:
> The behavior of the directly executed P(P) is different than the
> behavior of P(P) correctly simulated by H because in the first case H
> has already aborted its simulation of its input and in the second case
> this has not yet occurred.

By what definition of "Correctly Simulated"?

The fact that H aborts its simulation has NO affect on the direct
execution of the machine, so all you are saying that H has shut its eyes
and said "I don't see it, so it didn't happen".

That is just FALSEHOOD.

>
> I now refer to P(P) as D(D).
>
> Can D correctly simulated by H terminate normally?
> No it cannot see the details below.

Which is not the question being asked. The fact that it is impossible to
design an H that can correctly simulate its input to a halting state
just proves that H can not correctly decider that its input is Halting.

This does NOT mean that the input can't be Halting, just that H can
never prove it.

IF H doesn't ever abort its simulation, then yes, the D built on that H
is non-halting, but that H never gives that answer, so it is still wrong.

Each H gets a DIFFERENT D, since they include the H that the
"pathological test" is to be performed on, so the behavior of one D
built on a different H doesn't apply, and for correct reasoning, you
really need to give each one a different name. Reusing the same name for
different machine, and then trying to confuse which one is which is just
a sign of being intentionally deceptive to try to tell a LIE.

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

But D is not SPECIFIED in a seperate context, but share code space with
H, which means it fails to be truely distinctly, like a Turing Machine
would be.

It is NOT a full "separate process context" as all the contexts share
code space.

>
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   D(D);
> 15 }
>
> D correctly simulated by H cannot possibly terminate normally by
> reaching its own final state at line 09.

But D correctly simulated by a correct simulator would, at least as long
as you are using an H that answer H(D,D) as 0, as you claim.

Thus, you H never DOES a correct simulation, so it answering based on a
false premise.

>
> We can easily fix what Ben has misconstrued as a contradiction by
> defining the return value of 0 from H as meaning:
> (a) the input does not halt <or>

ANd thus admit that you are lying about working on the Halting Problem,
since that doesn't have a (b) term, PERIOD.

> (b) the input is defined to have a pathological relationship to H.

Which you can't define in a way that you H actually handles.

>
> Since it is true that D was defined to do the opposite of whatever
> Boolean value that H returns H is correct to return 0.
>
> *Termination Analyzer H is Not Fooled by Pathological Input D*
> https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
>
>

FAIL.

[olcott]

H correctly simulates N steps of D until H correctly predicts through
the type of mathematical induction used by termination analyzers that D
correctly simulated by H cannot possibly terminate normally.

int factorial(int n)
{
if(n==0)
return(1);
return(n*factorial(n-1));
}

AProVE correctly determines that factorial(5) halts by
boiling the key behavior of entire function to this:
f(x) → f(x-1) :|: x > 0 && x <= 5

[Richard Damon]

But that is the wrong prediction. It needs to predict if the input when
run will halt, as THAT is the Halting Question.

Thus, you are just admitting to working on POOP instead of Halting, and
ALL your statements are just LIES.

>
> int factorial(int n)
> {
>   if(n==0)
>     return(1);
>   return(n*factorial(n-1));
> }
>
> AProVE correctly determines that factorial(5) halts by
> boiling the key behavior of entire function to this:
> f(x) → f(x-1) :|: x > 0 && x <= 5
>
>

Wrong Question leads to incorrect answer, and all your work goes down
the drain.

You are just proving you don't understand basic English.

YOU ARE JUST TOO STUPID for this.

[olcott]

That is just like Jack's question posed to Jack, self-contradictory.
ChatGPT could understand that I am correct.

> Thus, you are just admitting to working on POOP instead of Halting, and
> ALL your statements are just LIES.
>
>>
>> int factorial(int n)
>> {
>>    if(n==0)
>>      return(1);
>>    return(n*factorial(n-1));
>> }
>>
>> AProVE correctly determines that factorial(5) halts by
>> boiling the key behavior of entire function to this:
>> f(x) → f(x-1) :|: x > 0 && x <= 5
>>
>>
> > Wrong Question leads to incorrect answer, and all your work goes down
> the drain.
>

AProVE is the largest termination analysis project in the world.

> You are just proving you don't understand basic English.
>
> YOU ARE JUST TOO STUPID for this.

[Richard Damon]

Nope, and you just seem too stupid to understand.

>
>> Thus, you are just admitting to working on POOP instead of Halting,
>> and ALL your statements are just LIES.
>>
>>>
>>> int factorial(int n)
>>> {
>>>    if(n==0)
>>>      return(1);
>>>    return(n*factorial(n-1));
>>> }
>>>
>>> AProVE correctly determines that factorial(5) halts by
>>> boiling the key behavior of entire function to this:
>>> f(x) → f(x-1) :|: x > 0 && x <= 5
>>>
>>>
>>  > Wrong Question leads to incorrect answer, and all your work goes down
>> the drain.
>>
>
> AProVE is the largest termination analysis project in the world.

Yes, and it probably uses the RIGHT question, will the program halt when
actually run.

It will probably also tell you that D(D) will Halt since H(D,D) returns 0.

Thus, it likely shows you are wrong about everything.

[Ben Bacarisse]

Richard Damon <news.x.ri...@xoxy.net> writes:
...

If it's all the same to you, I'd much rather PO's stalking threads
(those where tries to get my attention) simply died a natural death.
He's become obsessed with me ever since I stopped talking to him, and I
don't want him encouraged.

If you must reply, at least change the subject so that it's accurate (as
above!).

--
Ben.

[olcott]

When we use the criteria:
Can D correctly simulated by H ever terminate normally?

After N steps of correct simulation the execution trace of D proves that
D cannot possibly reach its final instruction and terminate normally in
any finite number of steps.

This criteria matches non-halting input and it also matches the cases
where the input D has been intentionally defined to do the opposite of
whatever Boolean value that H returns.

When H returns 1 it means that its input halts and when H return 0
it means that either its input does not halt or D was intentionally
defined to do the opposite of whatever Boolean value that H returns.

To the best of my knowledge no one has ever made this much progress on
the halting problem's pathological input. To the best of my knowledge
everyone else was completely stumped by the halting problem's
pathological input.

>
>>
>>> You are just proving you don't understand basic English.
>>>
>>> YOU ARE JUST TOO STUPID for this.
>>
>

[olcott]

When we use the criteria:
Can D correctly simulated by H ever terminate normally?

After N steps of correct simulation the execution trace of D proves that
D cannot possibly reach its final instruction and terminate normally in
any finite number of steps.

This criteria matches non-halting input and it also matches the cases
where the input D has been intentionally defined to do the opposite of
whatever Boolean value that H returns.

When H returns 1 it means that its input halts and when H return 0
it means that either its input does not halt or D was intentionally
defined to do the opposite of whatever Boolean value that H returns.

To the best of my knowledge no one has ever made this much progress on
the halting problem's pathological input. To the best of my knowledge
everyone else was completely stumped by the halting problem's
pathological input.

[Richard Damon]

So you are ADMITTING to working on a different problem, and lying about
what you are doing. Thank you for being honest about that.

Ben is just pointing out the ERRORS in your logic

The fact you can't see that just shows your lack of understanding.

Just because you don't understand something doesn't make it
"inconsistent" or "invalid", the fact that only YOU don't understand it
shows that the problem is with you.

>
> After N steps of correct simulation the execution trace of D proves that
> D cannot possibly reach its final instruction and terminate normally in
> any finite number of steps.
>
> This criteria matches non-halting input and it also matches the cases
> where the input D has been intentionally defined to do the opposite of
> whatever Boolean value that H returns.
>
> When H returns 1 it means that its input halts and when H return 0
> it means that either its input does not halt or D was intentionally
> defined to do the opposite of whatever Boolean value that H returns.
>
> To the best of my knowledge no one has ever made this much progress on
> the halting problem's pathological input. To the best of my knowledge
> everyone else was completely stumped by the halting problem's
> pathological input.
>

Nope, just shows you are ignorant.

[olcott]

When Ben pointed out that H(P,P) reports that P(P) does not halt when
P(P) does halt this seems to be a contradiction to people that lack a
complete understanding.

Because of this I changed the semantic meaning of a return value of 0
from H to mean either that P(P) does not halt or P(P) specifically
targets H to do the opposite of whatever Boolean value that H returns.

When H(P,P) reports that P correctly simulated by H cannot possibly
reach its own last instruction this is an easily verified fact, thus
P(P) does not halt from the point of view of H.

When H returns 0 for input P means either that P does not halt or
P specifically targets H to do the opposite of whatever Boolean
value that H returns not even people with little understanding can
say that this is contradictory.

> The fact you can't see that just shows your lack of understanding.

ChatGPT understood that Jack’s question is a self contradictory
question when posed to Jack.

ChatGPT further understood that this makes Jack’s question posed
to Jack an incorrect question.

ChatGPT also understood that because D was intentionally defined
to do the opposite of whatever Boolean value that H returned,
that D is a self-contradictory input for H.

ChatGPT:
“Therefore, based on the understanding that self-contradictory
questions lack a correct answer and are deemed incorrect, one could
argue that the halting problem's pathological input D can be
categorized as an incorrect question when posed to the halting
decider H.”

https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
It did not leap to this conclusion it took a lot of convincing.

ChatGPT is not biased towards rebuttal against the truth.
My human reviewers are biased towards rebuttal against the truth.

[Richard Damon]

NO, it is a TRUE statement. H is NOT a correct HALT DECIDER.

It might be a valid POOP decider with your altered criteria, but it
isn't correct as a Halt Decider.

You don't get to change the meaning of words, attempting to just shows
you are a liar.

Halting is a property of the original machine, not of the partial
simulation that H does.

>
> Because of this I changed the semantic meaning of a return value of 0
> from H to mean either that P(P) does not halt or P(P) specifically
> targets H to do the opposite of whatever Boolean value that H returns.

Which means you H need to return BOTH a 0 and 1 at the same time, since
D(D) DOES Halt, and also matches you "do the opposite" clause. Since
this is impossible, your criteria is invalid.

IT also means H is no longer a Halt Decider, since it fails to meet the
API definition of one.

You don't get to change the definition of a Halt Decider, trying to do
so just make yo a LIAR.

>
> When H(P,P) reports that P correctly simulated by H cannot possibly
> reach its own last instruction this is an easily verified fact, thus
> P(P) does not halt from the point of view of H.

Which isn't the criteria of a Halt Decider, and thus Ben is CORRECT to
say your H isn't a correct Halt Decider. It might be a correct POOP
decider, using your new criteria, but that isn't halting, and you saying
it is just makes you a LIAR.

> When H returns 0 for input P means either that P does not halt or
> P specifically targets H to do the opposite of whatever Boolean
> value that H returns not even people with little understanding can
> say that this is contradictory.

Which mean you admit that H isn't a Halt Decider, then LIE when you
claim it is.

>
>> The fact you can't see that just shows your lack of understanding.
> ChatGPT understood that Jack’s question is a self contradictory
> question when posed to Jack.

So? The Halting Question isn't the same question as we ask a Halt Decider:

Does the Machine represented by this input Halt when run?

That Question has a definite answer, as the machine needs to be fully
defined to ask it, and thus H has definite behavior, which will just
always be to give a wrong answer.

>
> ChatGPT further understood that this makes Jack’s question posed
> to Jack an incorrect question.

So?

>
> ChatGPT also understood that because D was intentionally defined
> to do the opposite of whatever Boolean value that H returned,
> that D is a self-contradictory input for H.

Only because it doesn't understand that H is fixed by the time you ask it.

>
> ChatGPT:
>    “Therefore, based on the understanding that self-contradictory
>    questions lack a correct answer and are deemed incorrect, one could
>    argue that the halting problem's pathological input D can be
>    categorized as an incorrect question when posed to the halting
>    decider H.”
>
> https://chat.openai.com/c/2aae46ef-e7be-444d-a046-b76c1f971c5a
> It did not leap to this conclusion it took a lot of convincing.
>
> ChatGPT is not biased towards rebuttal against the truth.
> My human reviewers are biased towards rebuttal against the truth.
>

So, you seem to beleive in artificial intelligence as being correct,
maybe that is because you don't have any real intelligence of your own.

ChatGPT is a known liar, and has a tendency to say whatever it thinks
the person communicating with it wants to hear. Thus, it is not a good
source for finding Truth.

People have gotten into serious problem because the just blindly
believed what ChatGPT said to them. I guess we need to include you in
its victims.

[olcott]

Not at all. Not the least little bit.
A return value of 0 also indicates that input D intentionally targets
H by doing the opposite of whatever Boolean value that H returns.

Because this is a verified fact that D does do this H is necessarily
correct and there is no contradiction.

[Richard Damon]

But a return of 1 signals that it halts, which it does.

You don't seem to understand English.

The Halting Problem asks if the Machine Described by the input Halts.

It Does (for the H that you are cliaming to be correct)

Therefore, the correct answer is YES / Halting, and you are PROVED to be
a LIAR.

>
> Because this is a verified fact that D does do this H is necessarily
> correct and there is no contradiction.
>

It may be a correct POOP decider, but it isn't a Halt Decider, because
you don't get to change the criteria for an actual Halt Decider.

You are just showing yourself to be a pathological liar, as you state
things that you should know to be incorrect.

If you don't understand that definition are what they are, they you are
just too stupid to be relied on for anything.

[olcott]

If I am the one that is a Liar then why did you already say that 1 is
the wrong answer and are now saying that it is the right answer?

[Richard Damon]

Where did I say that 1 is the wrong answer to THAT question.

Yes, H can not simulate the input to a final state, but that isn't what
the quesiton is asking, it is asking if the Input Halts, and the input
is a description of the actual machine, tha halts.

YOU ARE JUST A PATHETIC LIAR

Note, THIS H doesn't simulate its input forever to never halt, it aborts
its simulation, so "Halting" isn't actually defined for this input by
the simulation definition, as it neither Halts or Never Halts, but just
hasn't halted yet.

[olcott]

What happens when H returns 1 to D?

[Richard Damon]

But it doesn't, so it doesn't matter.

To be CORRECT H would need to do that, but it doesn't, and if you change
H you change its input so it is no longer correct.

You just don't seem to understand that fact. In Reality, H is a single
defined program, and that program generates a single defined D, and
whatever this realities H gives as an answer, it will be wrong.

You can't then change H to be right, as then H isn't H anymore.

You are just showing that you are totally out of touch with what
actually is reality, because you seem to have gone insane at some point.

[olcott]

No H can possibly be defined that can be embedded within
Linz Ĥ such that embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qy or Ĥ.qn
consistently with the behavior of Ĥ applied to ⟨Ĥ⟩.

The reason for this is that Ĥ does the opposite of both
Ĥ.qy and Ĥ.qn. This makes the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
self-contradictory for embedded_H.

You will not be able to explain why embedded_H cannot do
this for any reason other than the fact that the input
⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is self-contradictory for embedded_H.

(a) Because it just can't dodges the question.
(b) Because the input is undecidable for H is equivalent to (a)

[Richard Damon]

Right, which is why it is impossible to make a correct Halt Decider.

>
> The reason for this is that Ĥ does the opposite of both
> Ĥ.qy and Ĥ.qn. This makes the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
> self-contradictory for embedded_H.

Not SELF contradicotory, but just contradictory.

>
> You will not be able to explain why embedded_H cannot do
> this for any reason other than the fact that the input
> ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H is self-contradictory for embedded_H.

No, embedded H just doesn't have code to give the right answer.

>
> (a) Because it just can't dodges the question.
> (b) Because the input is undecidable for H is equivalent to (a)
>

"Just Can't" is a totally correct answer, when you look at an exhaustive
list of options that it can do, and none of them work.

You just can't right an algorithm that always WINS at Tic-Tac-Toe

Note, "Undecidable" isn't defined for a particular machine, but for a
PROBLEM.

That answer of D(D) is very decidable (as long as H gives an answer or
is provable to not halt) so the answer for this machine is decidable.

It just is a fact that for ANY decider you chose, you can build a machie
by the ^ template that it will fail on.

[olcott]

OK that may make sense. One of our very rare agreements. The
question does not contradict itself it contradicts every answer.

Contradictory questions are also incorrect questions.
Likewise Jack's question contradicts every answer.

[Richard Damon]

It doesn't contradict the answer to the actual question, D just works
contrary to the answer of H, which is fully valid behavior, since the
DEFINITION is tha H needs to answer about EVERY machine. One of the
things that makes the halting problem impossible is the ability to
create such a machine to every decider.

But this just demonstrates some of the power of computing machines.
Halting is also undecidable for stronger reason, but they are too far
beyond your ability to comprehend, so I won't even try.

There is nothing "Incorrect" about the Halting Question, it is a
perfectly valid thing to want to ask, it just turns out the answer is
you can't make such a machine. That doesn't make the question improper.

Note, Jack's question, when asked to Jack, IS self-contradictory, as the
form of the question says either answer becomes wrong.

The difference is that Jack if volitional, so his answer isn't fixed. H
is deterministic, so once H was created, its answer was fixed, and turns
out wrong, but a correct answer to the actual question exists.

It is just your Strawman Question that must be asked before you actually
have an H that gets self-contradictory, which means you never get a
correct H to ask to get the contradiction. (It is the fact that if you
thought you had a correct H, that you get a contradiction, that shows
that no such H can exist)

[olcott]

If this is true then you can say which of yes/no are correct for Jack to
reply and which of true/false that H can return.

[Richard Damon]

SO, you are just to dumb to understand (and are trimming out the my
explainations, which says your stupidity is mallicous).

No, there is no correct answer that H can return, but there IS a correct
answer to the question that H is supposed to answer, thus the question
is correct, and that result is that we know the answer isn't computable.

Since the question itself is based on H, since it is asking about the
behavior of D which includes H in it, and H must be defined before we
can even ask the question (which is the difference with Jack's
question), so it is perfectly fine for the correct answer to depend on
H's behavior and thus perfectly fine for it to be contrary to the
behavior of H.

Note, the question is NOT what answer can H return to be correct, as, H,
being a defined program, will always return the answer the program
defines, so correctness isn't a factor, the question is what is the
behavior of the machine described by the input, and did H get it correct?

You insisting on the wrong question is why you have wasted your life on
lies and errors.

It seems a big part of your error is based on you holding to some
fundamentally wrong ideas and assumptions. You also have no grasp of
actual concepts of some fairly basic things that come up in these areas.
You can't even count your infinities, which limits your logic in what it
can handle.

You whole idea of there being a "first point" after zero just breaks all
the logic of your system whn you need to deal with infinites.

You are just too dumb to understand the truth.

[olcott]

That simply dodges my yes/no question.

My IQ is probably higher than yours. Did you pass the Mensa test?
In any case creative genius has its algorithm:
https://www.scientificamerican.com/article/the-science-of-genius1/

If this is true then you can say which of yes/no are correct for
Jack to reply and which of true/false that H can return.

The only reason that no one can do this is that in both of
these cases the correct reply from Jack and return value from H
are contradicted by his question and the input to H.

[Richard Damon]

I never took the Mensa test, as I saw no benefit to taking it.

>
> If this is true then you can say which of yes/no are correct for
> Jack to reply and which of true/false that H can return.
>

How do you get that conclusion? You are working off BAD LOGIC.

> The only reason that no one can do this is that in both of
> these cases the correct reply from Jack and return value from H
> are contradicted by his question and the input to H.
>

Jack's question has a contradiction, because Jack has volition, and his
next answer isn't determined until he says it. Thus it can be that
neither answer is correct, as the volitional process of answering it
changes what answer is correct.

The question to H is not a contradiction, as H's answer has been fixed
before we ask it by the code of H (and D). Thus, we can see that H was
just always wrong, no matter how we designed it.

The fact that you just can't actualy keep the actual question in mind,
and keep on switching to a false question shows your mental defect. You
can't seem to understand that you can't think about changing something
that is fixed without resetting the whole problem. You can't ask in the
same manner what H should return as we can Does D(D) Halt or
equivalenetly what is the correct answer that H SHOULD have returned to
be correct.

The issue with your question is you don't actually have an input to
decide on, as the input isn't fully created until you have fixed H. All
you have is an input recipe for this particular problem. The recipe
doesn't affect the definition of the Halting Problem, as the Halting
Problem is about actual machines so only about the products of the
recipe, and irrespective of how a given machine was made, but ALLOWS the
recipe, as the requirement is to handle ALL Machines.

And it is the ALL MACHINES part of the problem that makes it
interesting, having a decider that just handles "many" cases, but not
all isn't very useful if the case you want to handle is one of the
exceptions.

The fact that you can't understand these fundamental facts, but keep on
insisting that you can correctly decide a Halting Machine as Non-Halting
because the problem is too tough for H just shows how little you
understand what truth and logic is actually about.

The smart man knows what he does not know. You don't, you seem to THINK
you know a lot about these things, but what you "know" is actually
falsehood and your own deception, so you have the opposite of
"Knowledge", you have true Ignorance.

You have destroyed your life, and your reputation. In some ways I feel
pity for you.

[olcott]

In other words you are saying that when a question contradicts every
answer From X that the reason that X cannot correctly answer the
question has nothing to do with the fact that the question contradicts
every answer from X instead it must be the case that X is very stupid.

[Richard Damon]

You have bad logic because you have the wrong question, asked at the
wrong time.

This just proves how stupid you are.

[olcott]

On 6/20/2023 6:48 AM, Ben Bacarisse wrote:

> Richard Damon <news.x.ri...@xoxy.net> writes:
> ...
>
> If it's all the same to you, I'd much rather PO's stalking threads
> (those where tries to get my attention) simply died a natural death.

*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*

> He's become obsessed with me ever since I stopped talking to him, and I
> don't want him encouraged.
>

*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*

> If you must reply, at least change the subject so that it's accurate (as
> above!).
>

On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
> Just a reminder that you are arguing with someone who has
> declared that the wrong answer is the right one:
>
> Me: "do you still assert that [...] false is the "correct"
> answer even though P(P) halts?"
>
> PO: Yes that is the correct answer even though P(P) halts.

Because
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
All of my posts will be entitled as a Rebuttal to Ben

It is an easily verified fact that P correctly simulated by H cannot
possibly reach its own last instruction and terminate normally thus from
the Professor Sipser agreed criteria the input to H(P,P) does not halt.

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

To address what looks like a contradiction to reviewers not having a
very deep understanding of the halting problem:

(1) A return value of 1 from H(D,D) means the input to H(D,D) has halted

(2) A return value of 0 from H(D,D) has been redefined to mean
(a) D does not halt
(b) D has been defined to do the opposite of whatever Boolean value
that H returns.

*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*

[Richard Damon]

On 6/22/23 2:00 PM, olcott wrote:
> On 6/20/2023 6:48 AM, Ben Bacarisse wrote:
>> Richard Damon <news.x.ri...@xoxy.net> writes:
>> ...
>>
>> If it's all the same to you, I'd much rather PO's stalking threads
>> (those where tries to get my attention) simply died a natural death.
>
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*

No, he points out the truth of what you have been saying.

You actually don't WANT "Honest Dialog", because the only Honest Dialog
that CAN occc

>
>> He's become obsessed with me ever since I stopped talking to him, and I
>> don't want him encouraged.
>>
>
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
>
>> If you must reply, at least change the subject so that it's accurate (as
>> above!).
>>
>
> On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
>  > Just a reminder that you are arguing with someone who has
>  > declared that the wrong answer is the right one:
>  >
>  > Me: "do you still assert that [...] false is the "correct"
>  > answer even though P(P) halts?"
>  >
>  > PO: Yes that is the correct answer even though P(P) halts.
>
> Because
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> All of my posts will be entitled as a Rebuttal to Ben

So, you can't stand your own words being quoted back to you, with their
meaning explained?

Do you not agree that you said those things?

What is not "Honest" about what he said.

YOU seem to be the one that doesn't what "Honest Dialog" because you
freak out when someone disagrees with you.

>
> It is an easily verified fact that P correctly simulated by H cannot
> possibly reach its own last instruction and terminate normally thus from
> the Professor Sipser agreed criteria the input to H(P,P) does not halt.

Which is irrelevent, as pointed out many times.

You are apparently just to stupid to understand.

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

Yes, if H can show that an ACTUALLY CORRECT SIMULATION (which mean as
per a UTM, i.e. never aborted, of the ACTUAL INPUT) wouldn't halt, then
H can abort its simulation. SInce H does abort and return 0, that
condition isn't true. and you are just shown to be s stupid liar.

>
> To address what looks like a contradiction to reviewers not having a
> very deep understanding of the halting problem:
>
> (1) A return value of 1 from H(D,D) means the input to H(D,D) has halted
>
> (2) A return value of 0 from H(D,D) has been redefined to mean
>     (a) D does not halt
>     (b) D has been defined to do the opposite of whatever Boolean value
>         that H returns.

So, you are admitting to being a liar about working on the Halting
Problem, or a total idiot that doesn't understand a thing about what you
are talking.

>
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
>
>

Nope, it says H is a correct POOP decider, not a Halt Decider, and you
are shown to be a Hypocritical Ignornat Pathalogical Lying Insane Idiot.