Re: What is a computation? (honest dialogue ?)

[olcott]

On 4/29/2021 5:24 PM, Ben Bacarisse wrote:
> olcott <No...@NoWhere.com> writes:
>
>> I want to stay sharply focused on one point until it is totally
>> resolved to mutual understanding.
>
> No you don't. You run away when it gets problematic for you. A day or
> so ago you clearly stated that some halting computations -- these that
> halt only for particular reasons -- are non-halting computations. This
> is false. I stated that every computation that halts, for whatever
> reason, is a halting computation. Surely this is a matter that needs to
> be totally resolved? If not this, what? Nothing could be more
> important. But you refused to address this fundamental point. I asked:
>
> "First, do you really disagree with my simple statement that a
> computation that halts, for whatever reason, is a halting computation?

Yes you and I both disagree with this:
Yes you and I both disagree with this:
Yes you and I both disagree with this:
Yes you and I both disagree with this:

On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
> A computation that would not halt if its simulation were not
> halted is indeed a non-halting computation. But a computation that
> would not halt and one that is halted are different computations.


void Infinite_Loop()
{
HERE: goto HERE;
}

The first sentence corresponds to a halt decider that simulates its
input and examines the execution trace to determine that a finite string
specifies infinite execution such as the above infinite loop. After the
halt decider determines that a finite string does specify infinite
execution the halt decider stops simulating this input and reports not
halting.

The second sentence is false because it would decide that the above
infinite loop is a halting computation on the basis that the halt
decider stopped simulating it.


--
Copyright 2021 Pete Olcott "Great spirits have always encountered
violent opposition from mediocre minds." Einstein

[olcott]

On 4/30/2021 8:10 AM, Ben Bacarisse wrote:
> olcott <No...@NoWhere.com> writes:
>

>> On 4/29/2021 7:50 PM, Ben Bacarisse wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>

>>>> On 4/29/2021 7:17 PM, Ben Bacarisse wrote:

>>>>> olcott <polc...@gmail.com> writes:
>>>>>
>>>>>> On 4/29/2021 5:24 PM, Ben Bacarisse wrote:
>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>
>>>>>>>> I want to stay sharply focused on one point until it is totally
>>>>>>>> resolved to mutual understanding.
>>>>>>>
>>>>>>> No you don't. You run away when it gets problematic for you. A day or
>>>>>>> so ago you clearly stated that some halting computations -- these that
>>>>>>> halt only for particular reasons -- are non-halting computations. This
>>>>>>> is false. I stated that every computation that halts, for whatever
>>>>>>> reason, is a halting computation. Surely this is a matter that needs to
>>>>>>> be totally resolved? If not this, what? Nothing could be more
>>>>>>> important. But you refused to address this fundamental point. I asked:
>>>>>>>
>>>>>>> "First, do you really disagree with my simple statement that a
>>>>>>> computation that halts, for whatever reason, is a halting computation?
>>>>>>
>>>>>> Yes
>>>>>

>>>>> Well that's clear. You are prepared to deny that all halting
>>>>> computations are halting computations. There's really nothing more to
>>>>> say.
>>>>
>>>> YOU ALSO HAVE DISAGREED WITH THIS STATEMENT
>>>
>>> No. I'm not sure what you gain by pretending this because even if you
>>> genuinely misunderstood, there can't be any misunderstanding now. You
>>> know for certain that I think that denying that all halting computation
>>> are halting computation is loony.

>>>
>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>>> A computation that would not halt if its simulation were not
>>>>> halted is indeed a non-halting computation. But a computation that
>>>>> would not halt and one that is halted are different computations.
>>>

>>> If you've like to know what this means, you just have to ask. That
>>> would be what someone wanting an honest debate would do.
>>
>> I created those words, yours are merely a paraphrase of my words.
>
> Well that's good news. So you now agree with me that the computation
> that "would not halt" and the one that "is halted" are different?

I notice my error after I posted.
These are the words that are only a paraphrase of my own words:

>>>> On 11/27/2020 9:02 PM, Ben Bacarisse wrote:
>>>>> A computation that would not halt if its simulation were not
>>>>> halted is indeed a non-halting computation.

< You
> rejected that for ages. I suppose that's a tiny bit of progress. Your
> trick has always been to return the result of one computation (the one
> that would not halt) as the answer for the one that is halted. But if
> you know they are different computations, you must surely reject your
> own trick.

Every computation that never stops unless its simulator stops simulating
it <is> a non halting computation.

void Infinite_Loop()
{
HERE: goto HERE;
}

void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}

void H_Hat2(u32 P)
{
u32 Input_Would_Halt = Simulate(P, P);
}

void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);
}

int main()
{
u32 Input_Would_Halt = Halts((u32)Infinite_Loop, (u32)Infinite_Loop);
u32 Input_Would_Halt = Halts((u32)Infinite_Recursion, 1);
u32 Input_Would_Halt = Halts((u32)H_Hat2, (u32)H_Hat2);
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
}

All of the above functions are computations that never stop unless their
simulator stops simulating them and you know it.



> Unfortunately, even if you've seen the light on that point, your have
> gone off the rails elsewhere. Unless you can agree that every
> computation that halts is halting computation, discussion of the halting
> problem is utterly pointless.

It depends on how you are defining your terms and the scope of what is
considered the computation.

When we have an infinite loop that halts because its simulator stopped
simulating it then we have an infinite loop that did halt yet its finite
string retains the property of infinite execution.

This counter-example correctly refutes your claim:
On 4/30/2021 8:10 AM, Ben Bacarisse wrote:
> every computation that halts is halting computation

> I suppose we should add it to your other Great Equivocation. You need
> to accept, once and for all, that
>
> (A) Every instance of the halting problem has a correct yes/no answer.

I would not word it that way. Every complete Turing machine description
either halts on its input or fails to halt on its input when simulated
by a UTM.

> (B) Every computation that halts, for whatever reason, is a halting
> computation.

The equivocation on this statement is the last refuge for people that
have disagreement and rebuttal as a much higher priority than the mutual
understanding that can be achieved through an honest dialogue.

We can say that an infinite loop that was forced to halt by its
simulator on the basis that this simulator discerned that its input
finite string has the property of infinite execution is a halting
computation because it was forced to halt.

If we look at it this way then building a universal halt decider is
trivial we simply say that all inputs halt. It does not matter that they
halt on their own or are forced to halt because their simulation was
stopped, every input falls into one of these two categories.

// Proving that your reasoning is incorrect
bool Universal_Halt_Decider(u32 P, u32 I)
{
return true;
}

>
> Nothing can be as important as a clear affirmation that you accept these
> unassailable facts.

[wij]

Let X(), Y() be the functions we had discussed before. (X the halt decider, Y the input program)
Y() is written AFTER X(). Such a Y() can do anything opposing what X() expect.
Otherwise, X() is probably not a deterministic function.

X() implies "P=NP", at least a one million dollar answer, maybe more.
Anyone has the answer you expect will win the prize, NOT YOU and no need to tell you.

[olcott]

void H_Hat(u32 P)
{
u32 Input_Halts = Halts(P, P);

if (Input_Halts)
HERE: goto HERE;
}

int main()
{
u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
Output("Input_Would_Halt = ", Input_Would_Halt);
}

Although the "P=NP" stuff is totally out of the scope of my
investigation I have discovered that all of the conventional halting
problem undecidability proof counter-examples can be decided as not
halting on the basis that the specify infinite recursion to any halt
decider that bases its halting deciding decision on examining the
execution trace of its input.

I have the above fully operational in the x86utm operating system that I
wrote that is based on an x86 emulator.

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf