#include <stdint.h>
#define ptr uintptr_t

int H(ptr p, ptr i)
{ // Determine infinitely nested x86 emulation
}

void P(ptr x)
{ H(x, x);
}

int main()
{ printf("H is called in infinitely nested emulation = ", H(P, P));
}

H would use an x86 emulator to emulate its input in debug step mode.

Since people are telling me that my solution is incorrect I am giving
them an opportunity to either correct my errors or failing that show
that their software engineering skills are insufficient to analyze the
problem as presented.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 2021-09-23 12:30, olcott wrote:
> #include <stdint.h>
> #define ptr uintptr_t
>
> int H(ptr p, ptr i)
> {
> // Determine infinitely nested x86 emulation
> }
>
> void P(ptr x)
> {
>   H(x, x);
> }
>
> int main()
> {
>   printf("H is called in infinitely nested emulation = ", H(P, P));
> }
>
> H would use an x86 emulator to emulate its input in debug step mode.

An emulator doesn't *need* to run in debug step mode since the emulator
can put whatever instructions it wants between the emulated instructions.

> Since people are telling me that my solution is incorrect I am giving
> them an opportunity to either correct my errors or failing that show
> that their software engineering skills are insufficient to analyze the
> problem as presented.

Right now your solution seems to consist of the line:

// Determine infinitely nested x86 emulation

That's not exactly something which can be critiqued in any detail.

André

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

On 9/23/2021 8:17 PM, André G. Isaak wrote:
> On 2021-09-23 12:30, olcott wrote:
>> #include <stdint.h>
>> #define ptr uintptr_t
>>
>> int H(ptr p, ptr i)
>> {
>> // Determine infinitely nested x86 emulation
>> }
>>
>> void P(ptr x)
>> {
>>    H(x, x);
>> }
>>
>> int main()
>> {
>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>> }
>>
>> H would use an x86 emulator to emulate its input in debug step mode.
>
> An emulator doesn't *need* to run in debug step mode since the emulator
> can put whatever instructions it wants between the emulated instructions.
>

A simulating halt decider does not know in advance the exact point in
the emulation of the input program where a non-halting behavior pattern
is matched. Because of this it tests to see if a non-halting behavior
pattern has been matched after emulating each instruction of the input.

>> Since people are telling me that my solution is incorrect I am giving
>> them an opportunity to either correct my errors or failing that show
>> that their software engineering skills are insufficient to analyze the
>> problem as presented.
>
> Right now your solution seems to consist of the line:
>
> // Determine infinitely nested x86 emulation
>
> That's not exactly something which can be critiqued in any detail.
>
> André
>

My question is can you prove that solving this specific problem is
impossible? It seems like everyone here acts as if solving the very
simple problem is necessarily totally impossible.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott <NoOne@NoWhere.com> writes:

> #include <stdint.h>
> #define ptr uintptr_t
>
> int H(ptr p, ptr i)
> {
> // Determine infinitely nested x86 emulation
> }
>
> void P(ptr x)
> {
> H(x, x);
> }
>
> int main()
> {
> printf("H is called in infinitely nested emulation = ", H(P, P));
> }
>
> H would use an x86 emulator to emulate its input in debug step mode.
>
> Since people are telling me that my solution is incorrect I am giving
> them an opportunity to either correct my errors or failing that show
> that their software engineering skills are insufficient to analyze the
> problem as presented.

All x86 programs (of the kind you appear to be talking about without
unbounded input) have a finite number of configurations. All
"interesting" properties of them are decidable. In fact, there are only
a finite number of them to start with. There is nothing of interest
here.

--
Ben.

On 2021-09-23 19:25, olcott wrote:
> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>> On 2021-09-23 12:30, olcott wrote:
>>> #include <stdint.h>
>>> #define ptr uintptr_t
>>>
>>> int H(ptr p, ptr i)
>>> {
>>> // Determine infinitely nested x86 emulation
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>> }
>>>
>>> int main()
>>> {
>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>> }
>>>
>>> H would use an x86 emulator to emulate its input in debug step mode.
>>
>> An emulator doesn't *need* to run in debug step mode since the
>> emulator can put whatever instructions it wants between the emulated
>> instructions.
>>
>
> A simulating halt decider does not know in advance the exact point in
> the emulation of the input program where a non-halting behavior pattern
> is matched. Because of this it tests to see if a non-halting behavior
> pattern has been matched after emulating each instruction of the input.

Yes, and an emulator can single-step through the code it is emulated
without debug step mode being involved. You do grasp that debug-step
mode is used for software which is being *directly* executed by the
processor and involves a hardware interrupt, right? An emulator doesn't
require this.

>>> Since people are telling me that my solution is incorrect I am giving
>>> them an opportunity to either correct my errors or failing that show
>>> that their software engineering skills are insufficient to analyze
>>> the problem as presented.
>>
>> Right now your solution seems to consist of the line:
>>
>> // Determine infinitely nested x86 emulation
>>
>> That's not exactly something which can be critiqued in any detail.
>>
>> André
>>
>
> My question is can you prove that solving this specific problem is
> impossible? It seems like everyone here acts as if solving the very
> simple problem is necessarily totally impossible.

Linz has already done so. You are the one to claim to have shown
otherwise, but all you give is a line of comment. It isn't incumbent on
us to prove you wrong. It is incumbent on you to prove that you actually
have a solution.

André

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

On 9/23/2021 8:42 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> #include <stdint.h>
>> #define ptr uintptr_t
>>
>> int H(ptr p, ptr i)
>> {
>> // Determine infinitely nested x86 emulation
>> }
>>
>> void P(ptr x)
>> {
>> H(x, x);
>> }
>>
>> int main()
>> {
>> printf("H is called in infinitely nested emulation = ", H(P, P));
>> }
>>
>> H would use an x86 emulator to emulate its input in debug step mode.
>>
>> Since people are telling me that my solution is incorrect I am giving
>> them an opportunity to either correct my errors or failing that show
>> that their software engineering skills are insufficient to analyze the
>> problem as presented.
>
> All x86 programs (of the kind you appear to be talking about without
> unbounded input) have a finite number of configurations. All
> "interesting" properties of them are decidable. In fact, there are only
> a finite number of them to start with. There is nothing of interest
> here.
>

That you don't know enough software engineering to appreciate that some
variation of this is equivalent to refuting the halting theorem is of no
consequence. I need actual honest critique not baseless naysayers. That
you don't provide a basis is because your understanding does not go deep
enough to provide a basis.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott <NoOne@NoWhere.com> writes:

> On 9/23/2021 8:42 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> #include <stdint.h>
>>> #define ptr uintptr_t
>>>
>>> int H(ptr p, ptr i)
>>> {
>>> // Determine infinitely nested x86 emulation
>>> }
>>>
>>> void P(ptr x)
>>> {
>>> H(x, x);
>>> }
>>>
>>> int main()
>>> {
>>> printf("H is called in infinitely nested emulation = ", H(P, P));
>>> }
>>>
>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>
>>> Since people are telling me that my solution is incorrect I am giving
>>> them an opportunity to either correct my errors or failing that show
>>> that their software engineering skills are insufficient to analyze the
>>> problem as presented.
>>
>> All x86 programs (of the kind you appear to be talking about without
>> unbounded input) have a finite number of configurations. All
>> "interesting" properties of them are decidable. In fact, there are only
>> a finite number of them to start with. There is nothing of interest
>> here.
>
> That you don't know enough software engineering to appreciate that
> some variation of this is equivalent to refuting the halting theorem
> is of no consequence. I need actual honest critique not baseless
> naysayers. That you don't provide a basis is because your
> understanding does not go deep enough to provide a basis.

Carry on wasting your time on a finite model. It's no skin off my nose.

--
Ben.

On 9/23/21 2:30 PM, olcott wrote:
> #include <stdint.h>
> #define ptr uintptr_t
>
> int H(ptr p, ptr i)
> {
> // Determine infinitely nested x86 emulation
> }
>
> void P(ptr x)
> {
>   H(x, x);
> }
>
> int main()
> {
>   printf("H is called in infinitely nested emulation = ", H(P, P));
> }
>
> H would use an x86 emulator to emulate its input in debug step mode.
>
> Since people are telling me that my solution is incorrect I am giving
> them an opportunity to either correct my errors or failing that show
> that their software engineering skills are insufficient to analyze the
> problem as presented.
>
>

It is quite possible in the realm of H to detect that it has been called
in 'recursion', i.e. that one instance of H has been invoked within
another instance of H with the same parameters. You code does this
successfully.

Since this H is only a limited decider, since the program to be decided
is FORCED to be in the same address space as H, the trick of detecting
the address of H in the simulated machine, and that must be a 'copy' of
this H. (This also means that H isn't the requried decider of Linz, as
it can't accept ANY input machine, but only those that fit this limited
model.

The problem is that it can't call this an 'infinite recursion' as H will
KNOW that if it is programmed to indicate that the computation is
recursive, that so will the H that it simulated, and thus the recursion
here is strictly limited.

We can add the tracking of all calls that occur, with their parameters,
and thus detect if its input uses recursion. We can't tell if the
recursion is infinite, but we can tell that any recursion that goes
through H with the same parameters will NOT be infinite.

This unfortunately falls short of being a useful Halt Detector, as a
simple simulator will not be able to tell what happens after this
simulated copy of itself will do after it aborts as that abort will
always be later in the execution of the machine that it is simulating
than when the simulator will abort it.

The task you want to do is proven to be impossible. Impossible to solve
problems do exist.

The key here is that the actual Question being asked by the Halting
Problem DOES have an answer, for any given defined machine H, there IS
a defined machine H^ that can be built from it, and that machine has a
definite halting status when run on a representation of itself.

It is just demonstrable that it is impossible to design an H that gives
the right answer for the H^ built from it. That is NOT a contradiction,
that just shows that designed problem (which is NOT the Queston of the
Halting Problem) is impossible. This gives us the answer to the second
question of the Halting Problem, that it IS actually impossible to make
a Computation that gives the right answer for EVERY possibe
Machine/Input combinations, as we show how to build amachine that will
defeat any given machine.

On 9/23/21 9:25 PM, olcott wrote:
> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>> On 2021-09-23 12:30, olcott wrote:
>>> #include <stdint.h>
>>> #define ptr uintptr_t
>>>
>>> int H(ptr p, ptr i)
>>> {
>>> // Determine infinitely nested x86 emulation
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>> }
>>>
>>> int main()
>>> {
>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>> }
>>>
>>> H would use an x86 emulator to emulate its input in debug step mode.
>>
>> An emulator doesn't *need* to run in debug step mode since the
>> emulator can put whatever instructions it wants between the emulated
>> instructions.
>>
>
> A simulating halt decider does not know in advance the exact point in
> the emulation of the input program where a non-halting behavior pattern
> is matched. Because of this it tests to see if a non-halting behavior
> pattern has been matched after emulating each instruction of the input.

I think the comment is that your use of the name 'Debug Step' implies
the use of the debug trap for actually EXECUTION the input code as
opposed to having a 'Simulation Step' command.

From all your comments, it sounds like the input is actually being
executed and not just simulated, since it seems that the simulated
copies of H have access to the state of the simulator (which is
impossible for a real simulator).

>
>>> Since people are telling me that my solution is incorrect I am giving
>>> them an opportunity to either correct my errors or failing that show
>>> that their software engineering skills are insufficient to analyze
>>> the problem as presented.
>>
>> Right now your solution seems to consist of the line:
>>
>> // Determine infinitely nested x86 emulation
>>
>> That's not exactly something which can be critiqued in any detail.
>>
>> André
>>
>
> My question is can you prove that solving this specific problem is
> impossible? It seems like everyone here acts as if solving the very
> simple problem is necessarily totally impossible.
>

Linz. NO Halt decider (simulating or otherwise) can correctly decide the
H^ Machine derived from it.

On 9/23/2021 8:58 PM, André G. Isaak wrote:
> On 2021-09-23 19:25, olcott wrote:
>> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>>> On 2021-09-23 12:30, olcott wrote:
>>>> #include <stdint.h>
>>>> #define ptr uintptr_t
>>>>
>>>> int H(ptr p, ptr i)
>>>> {
>>>> // Determine infinitely nested x86 emulation
>>>> }
>>>>
>>>> void P(ptr x)
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>>> }
>>>>
>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>
>>> An emulator doesn't *need* to run in debug step mode since the
>>> emulator can put whatever instructions it wants between the emulated
>>> instructions.
>>>
>>
>> A simulating halt decider does not know in advance the exact point in
>> the emulation of the input program where a non-halting behavior
>> pattern is matched. Because of this it tests to see if a non-halting
>> behavior pattern has been matched after emulating each instruction of
>> the input.
>
> Yes, and an emulator can single-step through the code it is emulated
> without debug step mode being involved. You do grasp that debug-step
> mode is used for software which is being *directly* executed by the
> processor and involves a hardware interrupt, right? An emulator doesn't
> require this.
>

I used a common term to that there would be common understanding.
It is much more cocise to simply call this debug step mode. People know
what that means.

>>>> Since people are telling me that my solution is incorrect I am
>>>> giving them an opportunity to either correct my errors or failing
>>>> that show that their software engineering skills are insufficient to
>>>> analyze the problem as presented.
>>>
>>> Right now your solution seems to consist of the line:
>>>
>>> // Determine infinitely nested x86 emulation
>>>
>>> That's not exactly something which can be critiqued in any detail.
>>>
>>> André
>>>
>>
>> My question is can you prove that solving this specific problem is
>> impossible? It seems like everyone here acts as if solving the very
>> simple problem is necessarily totally impossible.
>
> Linz has already done so. You are the one to claim to have shown
> otherwise, but all you give is a line of comment. It isn't incumbent on
> us to prove you wrong. It is incumbent on you to prove that you actually
> have a solution.
>
> André
>

#include <stdint.h>
#define ptr uintptr_t

void P(ptr x)
{ H(x, x);
}

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

Linz has proved it is totally impossible to create a C function named H
that emulates P(P) with an x86 emulator to determine from the execution
trace of P that P never reaches its final state?

I think that most very well qualified software engineers that know C and
the x86 language very well would disagree.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 9/23/21 11:13 PM, olcott wrote:
> On 9/23/2021 8:58 PM, André G. Isaak wrote:
>> On 2021-09-23 19:25, olcott wrote:
>>> On 9/23/2021 8:17 PM, André G. Isaak wrote:
>>>> On 2021-09-23 12:30, olcott wrote:
>>>>> #include <stdint.h>
>>>>> #define ptr uintptr_t
>>>>>
>>>>> int H(ptr p, ptr i)
>>>>> {
>>>>> // Determine infinitely nested x86 emulation
>>>>> }
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>>>> }
>>>>>
>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>
>>>> An emulator doesn't *need* to run in debug step mode since the
>>>> emulator can put whatever instructions it wants between the emulated
>>>> instructions.
>>>>
>>>
>>> A simulating halt decider does not know in advance the exact point in
>>> the emulation of the input program where a non-halting behavior
>>> pattern is matched. Because of this it tests to see if a non-halting
>>> behavior pattern has been matched after emulating each instruction of
>>> the input.
>>
>> Yes, and an emulator can single-step through the code it is emulated
>> without debug step mode being involved. You do grasp that debug-step
>> mode is used for software which is being *directly* executed by the
>> processor and involves a hardware interrupt, right? An emulator
>> doesn't require this.
>>
>
> I used a common term to that there would be common understanding.
> It is much more cocise to simply call this debug step mode. People know
> what that means.

Which isn't simulation.

Also, rarely is a debugger able to use this mode on itself, as it
appears that you are doing.

>
>>>>> Since people are telling me that my solution is incorrect I am
>>>>> giving them an opportunity to either correct my errors or failing
>>>>> that show that their software engineering skills are insufficient
>>>>> to analyze the problem as presented.
>>>>
>>>> Right now your solution seems to consist of the line:
>>>>
>>>> // Determine infinitely nested x86 emulation
>>>>
>>>> That's not exactly something which can be critiqued in any detail.
>>>>
>>>> André
>>>>
>>>
>>> My question is can you prove that solving this specific problem is
>>> impossible? It seems like everyone here acts as if solving the very
>>> simple problem is necessarily totally impossible.
>>
>> Linz has already done so. You are the one to claim to have shown
>> otherwise, but all you give is a line of comment. It isn't incumbent
>> on us to prove you wrong. It is incumbent on you to prove that you
>> actually have a solution.
>>
>> André
>>
>
> #include <stdint.h>
> #define ptr uintptr_t
>
> void P(ptr x)
> {
>   H(x, x);
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
> Linz has proved it is totally impossible to create a C function named H
> that emulates P(P) with an x86 emulator to determine from the execution
> trace of P that P never reaches its final state?
>
> I think that most very well qualified software engineers that know C and
> the x86 language very well would disagree.
>

Since when we use that same P and call it from main, it DOES reach its
final state, it shows the claim that the actual execution of the REAL
program P(P) is non-halting is incorrect, as P(P) is clearly seen, and
admitted by you, to be Halting.

If we look at the execution trace of this P(P) we see that it begins
exactly like the trace that H recorded and claimed is proof that it is
non-halting showing the claim to be invalid.

The 'logic' used to make this claim has also been demonstrated to be
unsound.

On 9/23/2021 9:09 PM, Richard Damon wrote:
>
> On 9/23/21 2:30 PM, olcott wrote:
>> #include <stdint.h>
>> #define ptr uintptr_t
>>
>> int H(ptr p, ptr i)
>> {
>> // Determine infinitely nested x86 emulation
>> }
>>
>> void P(ptr x)
>> {
>>   H(x, x);
>> }
>>
>> int main()
>> {
>>   printf("H is called in infinitely nested emulation = ", H(P, P));
>> }
>>
>> H would use an x86 emulator to emulate its input in debug step mode.
>>
>> Since people are telling me that my solution is incorrect I am giving
>> them an opportunity to either correct my errors or failing that show
>> that their software engineering skills are insufficient to analyze the
>> problem as presented.
>>
>>
>
> It is quite possible in the realm of H to detect that it has been called
> in 'recursion', i.e. that one instance of H has been invoked within
> another instance of H with the same parameters. You code does this
> successfully.
>
> Since this H is only a limited decider, since the program to be decided
> is FORCED to be in the same address space as H, the trick of detecting
> the address of H in the simulated machine, and that must be a 'copy' of
> this H. (This also means that H isn't the requried decider of Linz, as
> it can't accept ANY input machine, but only those that fit this limited
> model.
>

It is sufficiently the same thing in that it implements the essence of
the liar paradox pattern.

> The problem is that it can't call this an 'infinite recursion' as H will
> KNOW that if it is programmed to indicate that the computation is
> recursive, that so will the H that it simulated, and thus the recursion
> here is strictly limited.
>

H knows that is must abort the simulation of its input because its input
never reaches its final state whether or not it aborts this input.

> We can add the tracking of all calls that occur, with their parameters,
> and thus detect if its input uses recursion. We can't tell if the
> recursion is infinite, but we can tell that any recursion that goes
> through H with the same parameters will NOT be infinite.
>
> This unfortunately falls short of being a useful Halt Detector, as a
> simple simulator will not be able to tell what happens after this
> simulated copy of itself will do after it aborts as that abort will
> always be later in the execution of the machine that it is simulating
> than when the simulator will abort it.
>
> The task you want to do is proven to be impossible. Impossible to solve
> problems do exist.
>
> The key here is that the actual Question being asked by the Halting
> Problem DOES have an answer, for any given defined machine H, there IS
> a defined machine H^ that can be built from it, and that machine has a
> definite halting status when run on a representation of itself.
>
> It is just demonstrable that it is impossible to design an H that gives
> the right answer for the H^ built from it. That is NOT a contradiction,
> that just shows that designed problem (which is NOT the Queston of the
> Halting Problem) is impossible. This gives us the answer to the second
> question of the Halting Problem, that it IS actually impossible to make
> a Computation that gives the right answer for EVERY possibe
> Machine/Input combinations, as we show how to build amachine that will
> defeat any given machine.
>

All of the inputs that were defined with the liar paradox pattern
require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
and toss out the one that loses the three-way vote.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 2021-09-23 21:13, olcott wrote:
> On 9/23/2021 8:58 PM, André G. Isaak wrote:

>> Yes, and an emulator can single-step through the code it is emulated
>> without debug step mode being involved. You do grasp that debug-step
>> mode is used for software which is being *directly* executed by the
>> processor and involves a hardware interrupt, right? An emulator
>> doesn't require this.
>>
>
> I used a common term to that there would be common understanding.

You used a common term to mean something other than what that common
term actually means. That's not how you achieve common understanding.

> It is much more cocise to simply call this debug step mode. People know
> what that means.

Yes, people other than you do know what it means. It means directly
executing a program on the hardware (not simulating it) with the
processor in a specific mode which causes the CPU to generates an INT1
interrupt following the execution of every instruction which transfers
control to the debugger. If that's not what you're doing, then don't
call it that.

André

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

On 9/23/21 11:27 PM, olcott wrote:
> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>
>> On 9/23/21 2:30 PM, olcott wrote:
>>> #include <stdint.h>
>>> #define ptr uintptr_t
>>>
>>> int H(ptr p, ptr i)
>>> {
>>> // Determine infinitely nested x86 emulation
>>> }
>>>
>>> void P(ptr x)
>>> {
>>>    H(x, x);
>>> }
>>>
>>> int main()
>>> {
>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>> }
>>>
>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>
>>> Since people are telling me that my solution is incorrect I am giving
>>> them an opportunity to either correct my errors or failing that show
>>> that their software engineering skills are insufficient to analyze the
>>> problem as presented.
>>>
>>>
>>
>> It is quite possible in the realm of H to detect that it has been called
>> in 'recursion', i.e. that one instance of H has been invoked within
>> another instance of H with the same parameters. You code does this
>> successfully.
>>
>> Since this H is only a limited decider, since the program to be decided
>> is FORCED to be in the same address space as H, the trick of detecting
>> the address of H in the simulated machine, and that must be a 'copy' of
>> this H. (This also means that H isn't the requried decider of Linz, as
>> it can't accept ANY input machine, but only those that fit this limited
>> model.
>>
>
> It is sufficiently the same thing in that it implements the essence of
> the liar paradox pattern.

I thought you were working on that Halting Problem. It needs to
sufficienty recreate the Linz H/H^ pattern and decide that. This
requires H to be a real computation, and H^ built sufficiently like Linz
does.

>
>> The problem is that it can't call this an 'infinite recursion' as H will
>> KNOW that if it is programmed to indicate that the computation is
>> recursive, that so will the H that it simulated, and thus the recursion
>> here is strictly limited.
>>
>
> H knows that is must abort the simulation of its input because its input
> never reaches its final state whether or not it aborts this input.

It may 'know' that, but it is wrong. Since H does abort its simulation
and answer Non-Halting, the machine represented by the input will reach
its Halting State.

>
>> We can add the tracking of all calls that occur, with their parameters,
>> and thus detect if its input uses recursion. We can't tell if the
>> recursion is infinite, but we can tell that any recursion that goes
>> through H with the same parameters will NOT be infinite.
>>
>> This unfortunately falls short of being a useful Halt Detector, as a
>> simple simulator will not be able to tell what happens after this
>> simulated copy of itself will do after it aborts as that abort will
>> always be later in the execution of the machine that it is simulating
>> than when the simulator will abort it.
>>
>> The task you want to do is proven to be impossible. Impossible to solve
>> problems do exist.
>>
>> The key here is that the actual Question being asked by the Halting
>> Problem DOES have an answer, for any given defined machine H, there IS
>> a defined machine H^ that can be built from it, and that machine has a
>> definite halting status when run on a representation of itself.
>>
>> It is just demonstrable that it is impossible to design an H that gives
>> the right answer for the H^ built from it. That is NOT a contradiction,
>> that just shows that designed problem (which is NOT the Queston of the
>> Halting Problem) is impossible. This gives us the answer to the second
>> question of the Halting Problem, that it IS actually impossible to make
>> a Computation that gives the right answer for EVERY possibe
>> Machine/Input combinations, as we show how to build amachine that will
>> defeat any given machine.
>>
>
> All of the inputs that were defined with the liar paradox pattern
> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
> and toss out the one that loses the three-way vote.
>
>

Nope.

FAIL.

If you define a decider based on 3 copies of H, and call this lets say
H3, then you just need to make the H^ pattern based on H3, call it H3^,
and your H3 voting pattern will get this wrong.

I think all three will detect the infinite recursion and thus the
consesus will be non-halting, at which point it will halt, showing them
ALL to be wrong, even the majority vote.

Depending on how you do the voting, it might be possible for only 2 of
the three to get it wrong, if H3 never checks the third machine if the
first two agree.

On 9/23/2021 10:39 PM, Richard Damon wrote:
>
> On 9/23/21 11:27 PM, olcott wrote:
>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>
>>> On 9/23/21 2:30 PM, olcott wrote:
>>>> #include <stdint.h>
>>>> #define ptr uintptr_t
>>>>
>>>> int H(ptr p, ptr i)
>>>> {
>>>> // Determine infinitely nested x86 emulation
>>>> }
>>>>
>>>> void P(ptr x)
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    printf("H is called in infinitely nested emulation = ", H(P, P));
>>>> }
>>>>
>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>
>>>> Since people are telling me that my solution is incorrect I am giving
>>>> them an opportunity to either correct my errors or failing that show
>>>> that their software engineering skills are insufficient to analyze the
>>>> problem as presented.
>>>>
>>>>
>>>
>>> It is quite possible in the realm of H to detect that it has been called
>>> in 'recursion', i.e. that one instance of H has been invoked within
>>> another instance of H with the same parameters. You code does this
>>> successfully.
>>>
>>> Since this H is only a limited decider, since the program to be decided
>>> is FORCED to be in the same address space as H, the trick of detecting
>>> the address of H in the simulated machine, and that must be a 'copy' of
>>> this H. (This also means that H isn't the requried decider of Linz, as
>>> it can't accept ANY input machine, but only those that fit this limited
>>> model.
>>>
>>
>> It is sufficiently the same thing in that it implements the essence of
>> the liar paradox pattern.
>
> I thought you were working on that Halting Problem. It needs to
> sufficienty recreate the Linz H/H^ pattern and decide that. This
> requires H to be a real computation, and H^ built sufficiently like Linz
> does.
>

I hypothesize that you are either a liar or incompetent about what is
and what is not an actual computation. The term of the art for this is
"computable function", therefore if you are not a liar or incompetent
you would be able to cite sources that conform your assessments.

>>
>>> The problem is that it can't call this an 'infinite recursion' as H will
>>> KNOW that if it is programmed to indicate that the computation is
>>> recursive, that so will the H that it simulated, and thus the recursion
>>> here is strictly limited.
>>>
>>
>> H knows that is must abort the simulation of its input because its input
>> never reaches its final state whether or not it aborts this input.
>
> It may 'know' that, but it is wrong. Since H does abort its simulation
> and answer Non-Halting, the machine represented by the input will reach
> its Halting State.
>
>>
>>> We can add the tracking of all calls that occur, with their parameters,
>>> and thus detect if its input uses recursion. We can't tell if the
>>> recursion is infinite, but we can tell that any recursion that goes
>>> through H with the same parameters will NOT be infinite.
>>>
>>> This unfortunately falls short of being a useful Halt Detector, as a
>>> simple simulator will not be able to tell what happens after this
>>> simulated copy of itself will do after it aborts as that abort will
>>> always be later in the execution of the machine that it is simulating
>>> than when the simulator will abort it.
>>>
>>> The task you want to do is proven to be impossible. Impossible to solve
>>> problems do exist.
>>>
>>> The key here is that the actual Question being asked by the Halting
>>> Problem DOES have an answer, for any given defined machine H, there IS
>>> a defined machine H^ that can be built from it, and that machine has a
>>> definite halting status when run on a representation of itself.
>>>
>>> It is just demonstrable that it is impossible to design an H that gives
>>> the right answer for the H^ built from it. That is NOT a contradiction,
>>> that just shows that designed problem (which is NOT the Queston of the
>>> Halting Problem) is impossible. This gives us the answer to the second
>>> question of the Halting Problem, that it IS actually impossible to make
>>> a Computation that gives the right answer for EVERY possibe
>>> Machine/Input combinations, as we show how to build amachine that will
>>> defeat any given machine.
>>>
>>
>> All of the inputs that were defined with the liar paradox pattern
>> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
>> and toss out the one that loses the three-way vote.
>>
>>
>
> Nope.
>
> FAIL.
>
> If you define a decider based on 3 copies of H, and call this lets say
> H3, then you just need to make the H^ pattern based on H3, call it H3^,
> and your H3 voting pattern will get this wrong.
>
> I think all three will detect the infinite recursion and thus the
> consesus will be non-halting, at which point it will halt, showing them
> ALL to be wrong, even the majority vote.
>
> Depending on how you do the voting, it might be possible for only 2 of
> the three to get it wrong, if H3 never checks the third machine if the
> first two agree.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt

It has already been empirically validated that although the equivalent
of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
⟨Ĥ⟩ derives a halt status value that is consistent with the behavior of Ĥ.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 9/24/21 10:49 AM, olcott wrote:
> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>
>> On 9/23/21 11:27 PM, olcott wrote:
>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>
>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>> #include <stdint.h>
>>>>> #define ptr uintptr_t
>>>>>
>>>>> int H(ptr p, ptr i)
>>>>> {
>>>>> // Determine infinitely nested x86 emulation
>>>>> }
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>>     H(x, x);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     printf("H is called in infinitely nested emulation = ", H(P, P));
>>>>> }
>>>>>
>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>>
>>>>> Since people are telling me that my solution is incorrect I am giving
>>>>> them an opportunity to either correct my errors or failing that show
>>>>> that their software engineering skills are insufficient to analyze the
>>>>> problem as presented.
>>>>>
>>>>>
>>>>
>>>> It is quite possible in the realm of H to detect that it has been
>>>> called
>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>> another instance of H with the same parameters. You code does this
>>>> successfully.
>>>>
>>>> Since this H is only a limited decider, since the program to be decided
>>>> is FORCED to be in the same address space as H, the trick of detecting
>>>> the address of H in the simulated machine, and that must be a 'copy' of
>>>> this H. (This also means that H isn't the requried decider of Linz, as
>>>> it can't accept ANY input machine, but only those that fit this limited
>>>> model.
>>>>
>>>
>>> It is sufficiently the same thing in that it implements the essence of
>>> the liar paradox pattern.
>>
>> I thought you were working on that Halting Problem. It needs to
>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>> requires H to be a real computation, and H^ built sufficiently like Linz
>> does.
>>
>
> I hypothesize that you are either a liar or incompetent about what is
> and what is not an actual computation. The term of the art for this is
> "computable function", therefore if you are not a liar or incompetent
> you would be able to cite sources that conform your assessments.

There is a difference between a Computable Function and a Computation,
but it might be too subtle for you.

A Computible Function is the actual Mapping, that happens to be
computable, i.e. there exists an algorithm that is able to generate that
mapping.

A Computation is the running of such an algorithm on an input.

The Turing Machine is an embodiment of an algorithm.

Add an input tape, and you get a Computaton.

The sum set of all input tapes to their results, is a Computable Function.

>
>>>
>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>> will
>>>> KNOW that if it is programmed to indicate that the computation is
>>>> recursive, that so will the H that it simulated, and thus the recursion
>>>> here is strictly limited.
>>>>
>>>
>>> H knows that is must abort the simulation of its input because its input
>>> never reaches its final state whether or not it aborts this input.
>>
>> It may 'know' that, but it is wrong. Since H does abort its simulation
>> and answer Non-Halting, the machine represented by the input will reach
>> its Halting State.
>>
>>>
>>>> We can add the tracking of all calls that occur, with their parameters,
>>>> and thus detect if its input uses recursion. We can't tell if the
>>>> recursion is infinite, but we can tell that any recursion that goes
>>>> through H with the same parameters will NOT be infinite.
>>>>
>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>> simple simulator will not be able to tell what happens after this
>>>> simulated copy of itself will do after it aborts as that abort will
>>>> always be later in the execution of the machine that it is simulating
>>>> than when the simulator will abort it.
>>>>
>>>> The task you want to do is proven to be impossible. Impossible to solve
>>>> problems do exist.
>>>>
>>>> The key here is that the actual Question being asked by the Halting
>>>> Problem DOES have an answer, for any given defined machine H, there IS
>>>> a defined machine H^ that can be built from it, and that machine has a
>>>> definite halting status when run on a representation of itself.
>>>>
>>>> It is just demonstrable that it is impossible to design an H that gives
>>>> the right answer for the H^ built from it. That is NOT a contradiction,
>>>> that just shows that designed problem (which is NOT the Queston of the
>>>> Halting Problem) is impossible. This gives us the answer to the second
>>>> question of the Halting Problem, that it IS actually impossible to make
>>>> a Computation that gives the right answer for EVERY possibe
>>>> Machine/Input combinations, as we show how to build amachine that will
>>>> defeat any given machine.
>>>>
>>>
>>> All of the inputs that were defined with the liar paradox pattern
>>> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
>>> and toss out the one that loses the three-way vote.
>>>
>>>
>>
>> Nope.
>>
>> FAIL.
>>
>> If you define a decider based on 3 copies of H, and call this lets say
>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>> and your H3 voting pattern will get this wrong.
>>
>> I think all three will detect the infinite recursion and thus the
>> consesus will be non-halting, at which point it will halt, showing them
>> ALL to be wrong, even the majority vote.
>>
>> Depending on how you do the voting, it might be possible for only 2 of
>> the three to get it wrong, if H3 never checks the third machine if the
>> first two agree.
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>
> It has already been empirically validated that although the equivalent
> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior of Ĥ.
>

Nope. You have unsound logic.

The 'H' that gets the right answer is NOT the same 'H' that H^ was built
on, if it was, it would get the exact same answer.

This basically proves that your whole logic is flawed. Most likely
because your C/x86 things that you claim to map to the Turing Machine
are actually the right sort of Computation, so there actually isn't a
Turing Machine for them to the equivalent of.

On 9/24/2021 7:09 PM, Richard Damon wrote:
> On 9/24/21 10:49 AM, olcott wrote:
>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>
>>> On 9/23/21 11:27 PM, olcott wrote:
>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>> #include <stdint.h>
>>>>>> #define ptr uintptr_t
>>>>>>
>>>>>> int H(ptr p, ptr i)
>>>>>> {
>>>>>> // Determine infinitely nested x86 emulation
>>>>>> }
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>>     H(x, x);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     printf("H is called in infinitely nested emulation = ", H(P, P));
>>>>>> }
>>>>>>
>>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>>>
>>>>>> Since people are telling me that my solution is incorrect I am giving
>>>>>> them an opportunity to either correct my errors or failing that show
>>>>>> that their software engineering skills are insufficient to analyze the
>>>>>> problem as presented.
>>>>>>
>>>>>>
>>>>>
>>>>> It is quite possible in the realm of H to detect that it has been
>>>>> called
>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>> another instance of H with the same parameters. You code does this
>>>>> successfully.
>>>>>
>>>>> Since this H is only a limited decider, since the program to be decided
>>>>> is FORCED to be in the same address space as H, the trick of detecting
>>>>> the address of H in the simulated machine, and that must be a 'copy' of
>>>>> this H. (This also means that H isn't the requried decider of Linz, as
>>>>> it can't accept ANY input machine, but only those that fit this limited
>>>>> model.
>>>>>
>>>>
>>>> It is sufficiently the same thing in that it implements the essence of
>>>> the liar paradox pattern.
>>>
>>> I thought you were working on that Halting Problem. It needs to
>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>> requires H to be a real computation, and H^ built sufficiently like Linz
>>> does.
>>>
>>
>> I hypothesize that you are either a liar or incompetent about what is
>> and what is not an actual computation. The term of the art for this is
>> "computable function", therefore if you are not a liar or incompetent
>> you would be able to cite sources that conform your assessments.
>
> There is a difference between a Computable Function and a Computation,
> but it might be too subtle for you.
>
> A Computible Function is the actual Mapping, that happens to be
> computable, i.e. there exists an algorithm that is able to generate that
> mapping.
>

I derive a unique mapping from an input finite string to a Boolean
value. I currently need static local data to do this, none-the-less a
unique mapping is derived. I can't understand how this is computable in
C and not computable in a TM.

> A Computation is the running of such an algorithm on an input.
>
> The Turing Machine is an embodiment of an algorithm.
>
> Add an input tape, and you get a Computaton.
>
> The sum set of all input tapes to their results, is a Computable Function.
>
>>
>>>>
>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>> will
>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>> recursive, that so will the H that it simulated, and thus the recursion
>>>>> here is strictly limited.
>>>>>
>>>>
>>>> H knows that is must abort the simulation of its input because its input
>>>> never reaches its final state whether or not it aborts this input.
>>>
>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>> and answer Non-Halting, the machine represented by the input will reach
>>> its Halting State.
>>>
>>>>
>>>>> We can add the tracking of all calls that occur, with their parameters,
>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>> through H with the same parameters will NOT be infinite.
>>>>>
>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>> simple simulator will not be able to tell what happens after this
>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>> always be later in the execution of the machine that it is simulating
>>>>> than when the simulator will abort it.
>>>>>
>>>>> The task you want to do is proven to be impossible. Impossible to solve
>>>>> problems do exist.
>>>>>
>>>>> The key here is that the actual Question being asked by the Halting
>>>>> Problem DOES have an answer, for any given defined machine H, there IS
>>>>> a defined machine H^ that can be built from it, and that machine has a
>>>>> definite halting status when run on a representation of itself.
>>>>>
>>>>> It is just demonstrable that it is impossible to design an H that gives
>>>>> the right answer for the H^ built from it. That is NOT a contradiction,
>>>>> that just shows that designed problem (which is NOT the Queston of the
>>>>> Halting Problem) is impossible. This gives us the answer to the second
>>>>> question of the Halting Problem, that it IS actually impossible to make
>>>>> a Computation that gives the right answer for EVERY possibe
>>>>> Machine/Input combinations, as we show how to build amachine that will
>>>>> defeat any given machine.
>>>>>
>>>>
>>>> All of the inputs that were defined with the liar paradox pattern
>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox pattern
>>>> and toss out the one that loses the three-way vote.
>>>>
>>>>
>>>
>>> Nope.
>>>
>>> FAIL.
>>>
>>> If you define a decider based on 3 copies of H, and call this lets say
>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>> and your H3 voting pattern will get this wrong.
>>>
>>> I think all three will detect the infinite recursion and thus the
>>> consesus will be non-halting, at which point it will halt, showing them
>>> ALL to be wrong, even the majority vote.
>>>
>>> Depending on how you do the voting, it might be possible for only 2 of
>>> the three to get it wrong, if H3 never checks the third machine if the
>>> first two agree.
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>
>> It has already been empirically validated that although the equivalent
>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior of Ĥ.
>>
>
> Nope. You have unsound logic.
>
> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
> on, if it was, it would get the exact same answer.
>

One machine has an input that calls the same halt decider that is
evaluating it and the other machine does not this makea them distinctly
different computations even though their code it the same.

> This basically proves that your whole logic is flawed. Most likely
> because your C/x86 things that you claim to map to the Turing Machine
> are actually the right sort of Computation, so there actually isn't a
> Turing Machine for them to the equivalent of.
>

On 9/24/21 8:48 PM, olcott wrote:
> On 9/24/2021 7:09 PM, Richard Damon wrote:
>> On 9/24/21 10:49 AM, olcott wrote:
>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>
>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>> #include <stdint.h>
>>>>>>> #define ptr uintptr_t
>>>>>>>
>>>>>>> int H(ptr p, ptr i)
>>>>>>> {
>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>> }
>>>>>>>
>>>>>>> void P(ptr x)
>>>>>>> {
>>>>>>>      H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>      printf("H is called in infinitely nested emulation = ", H(P,
>>>>>>> P));
>>>>>>> }
>>>>>>>
>>>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>>>>
>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>> giving
>>>>>>> them an opportunity to either correct my errors or failing that show
>>>>>>> that their software engineering skills are insufficient to
>>>>>>> analyze the
>>>>>>> problem as presented.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>> called
>>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>>> another instance of H with the same parameters. You code does this
>>>>>> successfully.
>>>>>>
>>>>>> Since this H is only a limited decider, since the program to be
>>>>>> decided
>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>> detecting
>>>>>> the address of H in the simulated machine, and that must be a
>>>>>> 'copy' of
>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>> Linz, as
>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>> limited
>>>>>> model.
>>>>>>
>>>>>
>>>>> It is sufficiently the same thing in that it implements the essence of
>>>>> the liar paradox pattern.
>>>>
>>>> I thought you were working on that Halting Problem. It needs to
>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>> requires H to be a real computation, and H^ built sufficiently like
>>>> Linz
>>>> does.
>>>>
>>>
>>> I hypothesize that you are either a liar or incompetent about what is
>>> and what is not an actual computation. The term of the art for this is
>>> "computable function", therefore if you are not a liar or incompetent
>>> you would be able to cite sources that conform your assessments.
>>
>> There is a difference between a Computable Function and a Computation,
>> but it might be too subtle for you.
>>
>> A Computible Function is the actual Mapping, that happens to be
>> computable, i.e. there exists an algorithm that is able to generate that
>> mapping.
>>
>
> I derive a unique mapping from an input finite string to a Boolean
> value. I currently need static local data to do this, none-the-less a
> unique mapping is derived. I can't understand how this is computable in
> C and not computable in a TM.
>

The problem is that to be a Computatable Function ALL refereces to that
Function need to generate that same mapping.

That means that the P that call this 'Computable Function' H must get
the exact same answer as H give when just asked.

This actually isn't a problem so far, because H(P,P) is non-Halting and
the H(P,P) also gives non-halting, so that can easily be a Computable
Function.

It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
non-halting answer, P(P) then halts.

When you then claim that H1 is the SAME Computable Function and its
answer is correct, then you have a problem.

Or, when you claim that H's non halting answer while it might not be
correct for the indpendently run P(P) is correct of the P(P) is is
simulating, then that implies that P is not a computable function, as
two instances of it give diffent answers for the same input, but the
structure of P is such that the only way that P isn't computable is if H
itself isn't. The simulated P(P) can only be non halting if the
simulated H(P,P) doesn't answer non-halting which means that H isn't
actually a Computatable Function.

If you allow H to be wrong, then it could be a Turing Machine, but it
just is wrong.

If you don't allow H to be wrong, then it must not actually a Computable
Function, and thus doesn't map to a Turing Machine.

>> A Computation is the running of such an algorithm on an input.
>>
>> The Turing Machine is an embodiment of an algorithm.
>>
>> Add an input tape, and you get a Computaton.
>>
>> The sum set of all input tapes to their results, is a Computable
>> Function.
>>
>>>
>>>>>
>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>> will
>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>> recursion
>>>>>> here is strictly limited.
>>>>>>
>>>>>
>>>>> H knows that is must abort the simulation of its input because its
>>>>> input
>>>>> never reaches its final state whether or not it aborts this input.
>>>>
>>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>>> and answer Non-Halting, the machine represented by the input will reach
>>>> its Halting State.
>>>>
>>>>>
>>>>>> We can add the tracking of all calls that occur, with their
>>>>>> parameters,
>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>
>>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>>> simple simulator will not be able to tell what happens after this
>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>> always be later in the execution of the machine that it is simulating
>>>>>> than when the simulator will abort it.
>>>>>>
>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>> solve
>>>>>> problems do exist.
>>>>>>
>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>> there IS
>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>> has a
>>>>>> definite halting status when run on a representation of itself.
>>>>>>
>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>> gives
>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>> contradiction,
>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>> the
>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>> second
>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>> make
>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>> will
>>>>>> defeat any given machine.
>>>>>>
>>>>>
>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>> pattern
>>>>> and toss out the one that loses the three-way vote.
>>>>>
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> FAIL.
>>>>
>>>> If you define a decider based on 3 copies of H, and call this lets say
>>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>>> and your H3 voting pattern will get this wrong.
>>>>
>>>> I think all three will detect the infinite recursion and thus the
>>>> consesus will be non-halting, at which point it will halt, showing them
>>>> ALL to be wrong, even the majority vote.
>>>>
>>>> Depending on how you do the voting, it might be possible for only 2 of
>>>> the three to get it wrong, if H3 never checks the third machine if the
>>>> first two agree.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>
>>> It has already been empirically validated that although the equivalent
>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>> of Ĥ.
>>>
>>
>> Nope. You have unsound logic.
>>
>> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
>> on, if it was, it would get the exact same answer.
>>
>
> One machine has an input that calls the same halt decider that is
> evaluating it and the other machine does not this makea them distinctly
> different computations even though their code it the same.

On 9/24/2021 8:27 PM, Richard Damon wrote:
> On 9/24/21 8:48 PM, olcott wrote:
>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>> On 9/24/21 10:49 AM, olcott wrote:
>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>> #include <stdint.h>
>>>>>>>> #define ptr uintptr_t
>>>>>>>>
>>>>>>>> int H(ptr p, ptr i)
>>>>>>>> {
>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>> }
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>>      H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>      printf("H is called in infinitely nested emulation = ", H(P,
>>>>>>>> P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> H would use an x86 emulator to emulate its input in debug step mode.
>>>>>>>>
>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>> giving
>>>>>>>> them an opportunity to either correct my errors or failing that show
>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>> analyze the
>>>>>>>> problem as presented.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>> called
>>>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>>>> another instance of H with the same parameters. You code does this
>>>>>>> successfully.
>>>>>>>
>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>> decided
>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>> detecting
>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>> 'copy' of
>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>> Linz, as
>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>> limited
>>>>>>> model.
>>>>>>>
>>>>>>
>>>>>> It is sufficiently the same thing in that it implements the essence of
>>>>>> the liar paradox pattern.
>>>>>
>>>>> I thought you were working on that Halting Problem. It needs to
>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>> Linz
>>>>> does.
>>>>>
>>>>
>>>> I hypothesize that you are either a liar or incompetent about what is
>>>> and what is not an actual computation. The term of the art for this is
>>>> "computable function", therefore if you are not a liar or incompetent
>>>> you would be able to cite sources that conform your assessments.
>>>
>>> There is a difference between a Computable Function and a Computation,
>>> but it might be too subtle for you.
>>>
>>> A Computible Function is the actual Mapping, that happens to be
>>> computable, i.e. there exists an algorithm that is able to generate that
>>> mapping.
>>>
>>
>> I derive a unique mapping from an input finite string to a Boolean
>> value. I currently need static local data to do this, none-the-less a
>> unique mapping is derived. I can't understand how this is computable in
>> C and not computable in a TM.
>>
>
> The problem is that to be a Computatable Function ALL refereces to that
> Function need to generate that same mapping.
>
> That means that the P that call this 'Computable Function' H must get
> the exact same answer as H give when just asked.

So we are back to a function called in infinite recursion must return to
its caller even though everyone know this is impossible.

Maybe all black cats are really white dogs?

> This actually isn't a problem so far, because H(P,P) is non-Halting and
> the H(P,P) also gives non-halting, so that can easily be a Computable
> Function.
>

H(P,P) is only non-halting until at least one element of this otherwise
infinite chain breaks the chain. It makes sense that the element that is
not called in infinite recursion would be the one that does this.

> It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
> non-halting answer, P(P) then halts.
>

They are very similar looking distinctly different comutations that are
proven to be different by their different execution trace.

H1(P,P) is a similar computation to P(P).

> When you then claim that H1 is the SAME Computable Function and its
> answer is correct, then you have a problem.
>

Whenever a halt decider must decide halting on an input that calls this
same halt decider this is an entirely different computation than when an
exact copy of this code must decide halting on the exact same input that
does not call this copied halt decider.

You maintain your false assumptions even when presented with easily
verified facts to the contrary.

> Or, when you claim that H's non halting answer while it might not be
> correct for the indpendently run P(P) is correct of the P(P) is is
> simulating, then that implies that P is not a computable function, as
> two instances of it give diffent answers for the same input, but the
> structure of P is such that the only way that P isn't computable is if H
> itself isn't. The simulated P(P) can only be non halting if the
> simulated H(P,P) doesn't answer non-halting which means that H isn't
> actually a Computatable Function.
>
> If you allow H to be wrong, then it could be a Turing Machine, but it
> just is wrong.
>
> If you don't allow H to be wrong, then it must not actually a Computable
> Function, and thus doesn't map to a Turing Machine.
>
>>> A Computation is the running of such an algorithm on an input.
>>>
>>> The Turing Machine is an embodiment of an algorithm.
>>>
>>> Add an input tape, and you get a Computaton.
>>>
>>> The sum set of all input tapes to their results, is a Computable
>>> Function.
>>>
>>>>
>>>>>>
>>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>>> will
>>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>>> recursion
>>>>>>> here is strictly limited.
>>>>>>>
>>>>>>
>>>>>> H knows that is must abort the simulation of its input because its
>>>>>> input
>>>>>> never reaches its final state whether or not it aborts this input.
>>>>>
>>>>> It may 'know' that, but it is wrong. Since H does abort its simulation
>>>>> and answer Non-Halting, the machine represented by the input will reach
>>>>> its Halting State.
>>>>>
>>>>>>
>>>>>>> We can add the tracking of all calls that occur, with their
>>>>>>> parameters,
>>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>>
>>>>>>> This unfortunately falls short of being a useful Halt Detector, as a
>>>>>>> simple simulator will not be able to tell what happens after this
>>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>>> always be later in the execution of the machine that it is simulating
>>>>>>> than when the simulator will abort it.
>>>>>>>
>>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>>> solve
>>>>>>> problems do exist.
>>>>>>>
>>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>>> there IS
>>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>>> has a
>>>>>>> definite halting status when run on a representation of itself.
>>>>>>>
>>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>>> gives
>>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>>> contradiction,
>>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>>> the
>>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>>> second
>>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>>> make
>>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>>> will
>>>>>>> defeat any given machine.
>>>>>>>
>>>>>>
>>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>>> pattern
>>>>>> and toss out the one that loses the three-way vote.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> FAIL.
>>>>>
>>>>> If you define a decider based on 3 copies of H, and call this lets say
>>>>> H3, then you just need to make the H^ pattern based on H3, call it H3^,
>>>>> and your H3 voting pattern will get this wrong.
>>>>>
>>>>> I think all three will detect the infinite recursion and thus the
>>>>> consesus will be non-halting, at which point it will halt, showing them
>>>>> ALL to be wrong, even the majority vote.
>>>>>
>>>>> Depending on how you do the voting, it might be possible for only 2 of
>>>>> the three to get it wrong, if H3 never checks the third machine if the
>>>>> first two agree.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> It has already been empirically validated that although the equivalent
>>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>>> of Ĥ.
>>>>
>>>
>>> Nope. You have unsound logic.
>>>
>>> The 'H' that gets the right answer is NOT the same 'H' that H^ was built
>>> on, if it was, it would get the exact same answer.
>>>
>>
>> One machine has an input that calls the same halt decider that is
>> evaluating it and the other machine does not this makea them distinctly
>> different computations even though their code it the same.
>
> If they give different answers, they can't be the same Computable
> Function. PERIOD.
>
> IF H/H1 can distinguish that P calls H but not H1, then they are not the
> same Computable Function. PERIOD.
>
> You can't claim that they actually have the exact same algorithm, but
> give different result from the exact same input.
>

On 9/24/21 9:52 PM, olcott wrote:
> On 9/24/2021 8:27 PM, Richard Damon wrote:
>> On 9/24/21 8:48 PM, olcott wrote:
>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>> #include <stdint.h>
>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>
>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>> {
>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void P(ptr x)
>>>>>>>>> {
>>>>>>>>>       H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>       printf("H is called in infinitely nested emulation = ", H(P,
>>>>>>>>> P));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>> mode.
>>>>>>>>>
>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>> giving
>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>> show
>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>> analyze the
>>>>>>>>> problem as presented.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>> called
>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>>>>> another instance of H with the same parameters. You code does this
>>>>>>>> successfully.
>>>>>>>>
>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>> decided
>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>> detecting
>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>> 'copy' of
>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>> Linz, as
>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>> limited
>>>>>>>> model.
>>>>>>>>
>>>>>>>
>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>> essence of
>>>>>>> the liar paradox pattern.
>>>>>>
>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>> Linz
>>>>>> does.
>>>>>>
>>>>>
>>>>> I hypothesize that you are either a liar or incompetent about what is
>>>>> and what is not an actual computation. The term of the art for this is
>>>>> "computable function", therefore if you are not a liar or incompetent
>>>>> you would be able to cite sources that conform your assessments.
>>>>
>>>> There is a difference between a Computable Function and a Computation,
>>>> but it might be too subtle for you.
>>>>
>>>> A Computible Function is the actual Mapping, that happens to be
>>>> computable, i.e. there exists an algorithm that is able to generate
>>>> that
>>>> mapping.
>>>>
>>>
>>> I derive a unique mapping from an input finite string to a Boolean
>>> value. I currently need static local data to do this, none-the-less a
>>> unique mapping is derived. I can't understand how this is computable in
>>> C and not computable in a TM.
>>>
>>
>> The problem is that to be a Computatable Function ALL refereces to that
>> Function need to generate that same mapping.
>>
>> That means that the P that call this 'Computable Function' H must get
>> the exact same answer as H give when just asked.
>
> So we are back to a function called in infinite recursion must return to
> its caller even though everyone know this is impossible.

Except that it ISN'T infinite recursion, since EVERY H will abort its
simulation and return after finite time.

Do you not understand that fact?

Replace the outermost H with a real simulator to see what the input
does, It goes Simulator -> P -> H -> P -> H -> P -> H, at which point
the first H in the series stops the sequence, and returns.

Finite Recursion.

Thus when we put back the first P, it sees:

P -> H -> P -> H -> P and decides that this must be infinte, but there
actual is just one more cycle left before the next H WILL abort its
simulation.

>
> Maybe all black cats are really white dogs?

Only by your logic.

>
>> This actually isn't a problem so far, because H(P,P) is non-Halting and
>> the H(P,P) also gives non-halting, so that can easily be a Computable
>> Function.
>>
>
> H(P,P) is only non-halting until at least one element of this otherwise
> infinite chain breaks the chain. It makes sense that the element that is
> not called in infinite recursion would be the one that does this.

But the algorithm of H, which is also part of the algorithm of P WILL
break the chain, so it isn't

You logic is based on presuming the existance of something that isn't
there. That doesn't count. H IS what it is, you can't evaluate P based
on some other H that built a different P.

>
>> It just isn't a correct Halt Deciding, since when H(P,P) give P(P) that
>> non-halting answer, P(P) then halts.
>>
>
> They are very similar looking distinctly different comutations that are
> proven to be different by their different execution trace.

If the P(P) that is run independent is a different P(P) that H is
simulating, your setup is incorrect.

PERIOD.

YOU FAIL.

>
> H1(P,P) is a similar computation to P(P).

But H1 isn't a compuation that matters. Since H1 ISN'T H, it doesn't matter.

FAIL.

>
>> When you then claim that H1 is the SAME Computable Function and its
>> answer is correct, then you have a problem.
>>
>
> Whenever a halt decider must decide halting on an input that calls this
> same halt decider this is an entirely different computation than when an
> exact copy of this code must decide halting on the exact same input that
> does not call this copied halt decider.
>

NO. Just means your decider isn't a computation and thus not a Decider.

FAIL.

> You maintain your false assumptions even when presented with easily
> verified facts to the contrary.

WHAT FACTS.

Can you actually PROVE them. As in present an ACTUAL formal proof proof
starting from standardly accepted Theorms, Axioms and Definitions?

I don't think so, all you can say is 'by the meaning or the words'
without even givening the meaning of the words.

>
>> Or, when you claim that H's non halting answer while it might not be
>> correct for the indpendently run P(P) is correct of the P(P) is is
>> simulating, then that implies that P is not a computable function, as
>> two instances of it give diffent answers for the same input, but the
>> structure of P is such that the only way that P isn't computable is if H
>> itself isn't. The simulated P(P) can only be non halting if the
>> simulated H(P,P) doesn't answer non-halting which means that H isn't
>> actually a Computatable Function.
>>
>> If you allow H to be wrong, then it could be a Turing Machine, but it
>> just is wrong.
>>
>> If you don't allow H to be wrong, then it must not actually a Computable
>> Function, and thus doesn't map to a Turing Machine.
>>
>>>> A Computation is the running of such an algorithm on an input.
>>>>
>>>> The Turing Machine is an embodiment of an algorithm.
>>>>
>>>> Add an input tape, and you get a Computaton.
>>>>
>>>> The sum set of all input tapes to their results, is a Computable
>>>> Function.
>>>>
>>>>>
>>>>>>>
>>>>>>>> The problem is that it can't call this an 'infinite recursion' as H
>>>>>>>> will
>>>>>>>> KNOW that if it is programmed to indicate that the computation is
>>>>>>>> recursive, that so will the H that it simulated, and thus the
>>>>>>>> recursion
>>>>>>>> here is strictly limited.
>>>>>>>>
>>>>>>>
>>>>>>> H knows that is must abort the simulation of its input because its
>>>>>>> input
>>>>>>> never reaches its final state whether or not it aborts this input.
>>>>>>
>>>>>> It may 'know' that, but it is wrong. Since H does abort its
>>>>>> simulation
>>>>>> and answer Non-Halting, the machine represented by the input will
>>>>>> reach
>>>>>> its Halting State.
>>>>>>
>>>>>>>
>>>>>>>> We can add the tracking of all calls that occur, with their
>>>>>>>> parameters,
>>>>>>>> and thus detect if its input uses recursion. We can't tell if the
>>>>>>>> recursion is infinite, but we can tell that any recursion that goes
>>>>>>>> through H with the same parameters will NOT be infinite.
>>>>>>>>
>>>>>>>> This unfortunately falls short of being a useful Halt Detector,
>>>>>>>> as a
>>>>>>>> simple simulator will not be able to tell what happens after this
>>>>>>>> simulated copy of itself will do after it aborts as that abort will
>>>>>>>> always be later in the execution of the machine that it is
>>>>>>>> simulating
>>>>>>>> than when the simulator will abort it.
>>>>>>>>
>>>>>>>> The task you want to do is proven to be impossible. Impossible to
>>>>>>>> solve
>>>>>>>> problems do exist.
>>>>>>>>
>>>>>>>> The key here is that the actual Question being asked by the Halting
>>>>>>>> Problem DOES have an answer, for any given defined machine H,
>>>>>>>> there IS
>>>>>>>> a defined machine H^ that can be built from it, and that machine
>>>>>>>> has a
>>>>>>>> definite halting status when run on a representation of itself.
>>>>>>>>
>>>>>>>> It is just demonstrable that it is impossible to design an H that
>>>>>>>> gives
>>>>>>>> the right answer for the H^ built from it. That is NOT a
>>>>>>>> contradiction,
>>>>>>>> that just shows that designed problem (which is NOT the Queston of
>>>>>>>> the
>>>>>>>> Halting Problem) is impossible. This gives us the answer to the
>>>>>>>> second
>>>>>>>> question of the Halting Problem, that it IS actually impossible to
>>>>>>>> make
>>>>>>>> a Computation that gives the right answer for EVERY possibe
>>>>>>>> Machine/Input combinations, as we show how to build amachine that
>>>>>>>> will
>>>>>>>> defeat any given machine.
>>>>>>>>
>>>>>>>
>>>>>>> All of the inputs that were defined with the liar paradox pattern
>>>>>>> require three halt deciders H1/Hx/H to detect this Liar Paradox
>>>>>>> pattern
>>>>>>> and toss out the one that loses the three-way vote.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>> If you define a decider based on 3 copies of H, and call this lets
>>>>>> say
>>>>>> H3, then you just need to make the H^ pattern based on H3, call it
>>>>>> H3^,
>>>>>> and your H3 voting pattern will get this wrong.
>>>>>>
>>>>>> I think all three will detect the infinite recursion and thus the
>>>>>> consesus will be non-halting, at which point it will halt, showing
>>>>>> them
>>>>>> ALL to be wrong, even the majority vote.
>>>>>>
>>>>>> Depending on how you do the voting, it might be possible for only
>>>>>> 2 of
>>>>>> the three to get it wrong, if H3 never checks the third machine if
>>>>>> the
>>>>>> first two agree.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ halts, and
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> It has already been empirically validated that although the equivalent
>>>>> of the Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ does derive a halting status value that is
>>>>> inconsistent with the behavior of Ĥ, the equivalent of the Linz H ⟨Ĥ⟩
>>>>> ⟨Ĥ⟩ derives a halt status value that is consistent with the behavior
>>>>> of Ĥ.
>>>>>
>>>>
>>>> Nope. You have unsound logic.
>>>>
>>>> The 'H' that gets the right answer is NOT the same 'H' that H^ was
>>>> built
>>>> on, if it was, it would get the exact same answer.
>>>>
>>>
>>> One machine has an input that calls the same halt decider that is
>>> evaluating it and the other machine does not this makea them distinctly
>>> different computations even though their code it the same.
>>
>> If they give different answers, they can't be the same Computable
>> Function. PERIOD.
>>
>> IF H/H1 can distinguish that P calls H but not H1, then they are not the
>> same Computable Function. PERIOD.
>>
>> You can't claim that they actually have the exact same algorithm, but
>> give different result from the exact same input.
>>
>
> P calls H and P does not call H1 this makes a big difference.

On 9/24/2021 9:27 PM, Richard Damon wrote:
> On 9/24/21 9:52 PM, olcott wrote:
>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>> On 9/24/21 8:48 PM, olcott wrote:
>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>> #include <stdint.h>
>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>
>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>> {
>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>       H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>       printf("H is called in infinitely nested emulation = ", H(P,
>>>>>>>>>> P));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>> mode.
>>>>>>>>>>
>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>> giving
>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>> show
>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>> analyze the
>>>>>>>>>> problem as presented.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>>> called
>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked within
>>>>>>>>> another instance of H with the same parameters. You code does this
>>>>>>>>> successfully.
>>>>>>>>>
>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>> decided
>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>> detecting
>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>> 'copy' of
>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>> Linz, as
>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>> limited
>>>>>>>>> model.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>> essence of
>>>>>>>> the liar paradox pattern.
>>>>>>>
>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>>> Linz
>>>>>>> does.
>>>>>>>
>>>>>>
>>>>>> I hypothesize that you are either a liar or incompetent about what is
>>>>>> and what is not an actual computation. The term of the art for this is
>>>>>> "computable function", therefore if you are not a liar or incompetent
>>>>>> you would be able to cite sources that conform your assessments.
>>>>>
>>>>> There is a difference between a Computable Function and a Computation,
>>>>> but it might be too subtle for you.
>>>>>
>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>> that
>>>>> mapping.
>>>>>
>>>>
>>>> I derive a unique mapping from an input finite string to a Boolean
>>>> value. I currently need static local data to do this, none-the-less a
>>>> unique mapping is derived. I can't understand how this is computable in
>>>> C and not computable in a TM.
>>>>
>>>
>>> The problem is that to be a Computatable Function ALL refereces to that
>>> Function need to generate that same mapping.
>>>
>>> That means that the P that call this 'Computable Function' H must get
>>> the exact same answer as H give when just asked.
>>
>> So we are back to a function called in infinite recursion must return to
>> its caller even though everyone know this is impossible.
>
> Except that it ISN'T infinite recursion, since EVERY H will abort its
> simulation and return after finite time.
>
> Do you not understand that fact?
>

If the question was:
Does P on its input stop running?
Then H provides the wrong answer.

THIS IS NOT THE QUESTION
THIS IS NOT THE QUESTION
THIS IS NOT THE QUESTION
THIS IS NOT THE QUESTION

I have told you this many hundreds of times so I estimate that you may
have an actual neurological disorder.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 9/24/2021 10:36 PM, olcott wrote:
> On 9/24/2021 9:27 PM, Richard Damon wrote:
>> On 9/24/21 9:52 PM, olcott wrote:
>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>
>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>> {
>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>        H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>        printf("H is called in infinitely nested emulation =
>>>>>>>>>>> ", H(P,
>>>>>>>>>>> P));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>> mode.
>>>>>>>>>>>
>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>> giving
>>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>>> show
>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>> analyze the
>>>>>>>>>>> problem as presented.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>>>> called
>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>> within
>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>> this
>>>>>>>>>> successfully.
>>>>>>>>>>
>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>> decided
>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>> detecting
>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>> 'copy' of
>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>> Linz, as
>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>> limited
>>>>>>>>>> model.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>> essence of
>>>>>>>>> the liar paradox pattern.
>>>>>>>>
>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>>>> Linz
>>>>>>>> does.
>>>>>>>>
>>>>>>>
>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>> what is
>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>> this is
>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>> incompetent
>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>
>>>>>> There is a difference between a Computable Function and a
>>>>>> Computation,
>>>>>> but it might be too subtle for you.
>>>>>>
>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>> that
>>>>>> mapping.
>>>>>>
>>>>>
>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>> value. I currently need static local data to do this, none-the-less a
>>>>> unique mapping is derived. I can't understand how this is
>>>>> computable in
>>>>> C and not computable in a TM.
>>>>>
>>>>
>>>> The problem is that to be a Computatable Function ALL refereces to that
>>>> Function need to generate that same mapping.
>>>>
>>>> That means that the P that call this 'Computable Function' H must get
>>>> the exact same answer as H give when just asked.
>>>
>>> So we are back to a function called in infinite recursion must return to
>>> its caller even though everyone know this is impossible.
>>
>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>> simulation and return after finite time.
>>
>> Do you not understand that fact?
>>
>
> If the question was:
> Does P on its input stop running?
> Then H provides the wrong answer.
>
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
>
> I have told you this many hundreds of times so I estimate that you may
> have an actual neurological disorder.

I must correct my mistakes when I become aware of them. In this case you
made no mistake and were only going by the title of the post. I
apologize for my mistake.

H detects that its input never reaches its final state.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 9/24/21 11:36 PM, olcott wrote:
> On 9/24/2021 9:27 PM, Richard Damon wrote:
>> On 9/24/21 9:52 PM, olcott wrote:
>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>
>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>> {
>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>        H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>        printf("H is called in infinitely nested emulation =
>>>>>>>>>>> ", H(P,
>>>>>>>>>>> P));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>> mode.
>>>>>>>>>>>
>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>> giving
>>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>>> show
>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>> analyze the
>>>>>>>>>>> problem as presented.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>>>> called
>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>> within
>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>> this
>>>>>>>>>> successfully.
>>>>>>>>>>
>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>> decided
>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>> detecting
>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>> 'copy' of
>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>> Linz, as
>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>> limited
>>>>>>>>>> model.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>> essence of
>>>>>>>>> the liar paradox pattern.
>>>>>>>>
>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>>>> Linz
>>>>>>>> does.
>>>>>>>>
>>>>>>>
>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>> what is
>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>> this is
>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>> incompetent
>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>
>>>>>> There is a difference between a Computable Function and a
>>>>>> Computation,
>>>>>> but it might be too subtle for you.
>>>>>>
>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>> that
>>>>>> mapping.
>>>>>>
>>>>>
>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>> value. I currently need static local data to do this, none-the-less a
>>>>> unique mapping is derived. I can't understand how this is
>>>>> computable in
>>>>> C and not computable in a TM.
>>>>>
>>>>
>>>> The problem is that to be a Computatable Function ALL refereces to that
>>>> Function need to generate that same mapping.
>>>>
>>>> That means that the P that call this 'Computable Function' H must get
>>>> the exact same answer as H give when just asked.
>>>
>>> So we are back to a function called in infinite recursion must return to
>>> its caller even though everyone know this is impossible.
>>
>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>> simulation and return after finite time.
>>
>> Do you not understand that fact?
>>
>
> If the question was:
> Does P on its input stop running?
> Then H provides the wrong answer.
>
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
> THIS IS NOT THE QUESTION
>
> I have told you this many hundreds of times so I estimate that you may
> have an actual neurological disorder.
>

But it IS the question that the Halt Decider is SUPPOSED to be answering.

If you have decided you need to answer some different question, fine,
you just aren't working on the Halting Problem.

PERIOD. DEFINITION.

You don't get to make up your own rules if you want to play the real game.

I guess this is your admission that you have NEVER been talking about
the actual halting problem but just about POOP.

On 9/25/21 12:31 AM, olcott wrote:
> On 9/24/2021 10:36 PM, olcott wrote:
>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>> On 9/24/21 9:52 PM, olcott wrote:
>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>> {
>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>        printf("H is called in infinitely nested emulation =
>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>> P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>>> mode.
>>>>>>>>>>>>
>>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>>> giving
>>>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>>>> show
>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>> analyze the
>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is quite possible in the realm of H to detect that it has
>>>>>>>>>>> been
>>>>>>>>>>> called
>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>> within
>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>> this
>>>>>>>>>>> successfully.
>>>>>>>>>>>
>>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>>> decided
>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>> detecting
>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>> 'copy' of
>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>> Linz, as
>>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>>> limited
>>>>>>>>>>> model.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>> essence of
>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>
>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>>> requires H to be a real computation, and H^ built sufficiently
>>>>>>>>> like
>>>>>>>>> Linz
>>>>>>>>> does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>> what is
>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>> this is
>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>> incompetent
>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>
>>>>>>> There is a difference between a Computable Function and a
>>>>>>> Computation,
>>>>>>> but it might be too subtle for you.
>>>>>>>
>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>>> that
>>>>>>> mapping.
>>>>>>>
>>>>>>
>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>> value. I currently need static local data to do this, none-the-less a
>>>>>> unique mapping is derived. I can't understand how this is
>>>>>> computable in
>>>>>> C and not computable in a TM.
>>>>>>
>>>>>
>>>>> The problem is that to be a Computatable Function ALL refereces to
>>>>> that
>>>>> Function need to generate that same mapping.
>>>>>
>>>>> That means that the P that call this 'Computable Function' H must get
>>>>> the exact same answer as H give when just asked.
>>>>
>>>> So we are back to a function called in infinite recursion must
>>>> return to
>>>> its caller even though everyone know this is impossible.
>>>
>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>> simulation and return after finite time.
>>>
>>> Do you not understand that fact?
>>>
>>
>> If the question was:
>> Does P on its input stop running?
>> Then H provides the wrong answer.
>>
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>>
>> I have told you this many hundreds of times so I estimate that you may
>> have an actual neurological disorder.
>
> I must correct my mistakes when I become aware of them. In this case you
> made no mistake and were only going by the title of the post. I
> apologize for my mistake.
>
> H detects that its input never reaches its final state.
>

Again, you use that bad terminology.

Inputs don't actually DO anything.

The program P (P) that is the machine the input to H represents, does
reach its final state, and thus is a Halting Computation.

Yes, H doesn't see that state in its simulation, because it stoppeed
simulating too soon and returned the wrong answer.

PERIOD.

On 9/25/2021 5:03 AM, Richard Damon wrote:
> On 9/24/21 11:36 PM, olcott wrote:
>> On 9/24/2021 9:27 PM, Richard Damon wrote:
>>> On 9/24/21 9:52 PM, olcott wrote:
>>>> On 9/24/2021 8:27 PM, Richard Damon wrote:
>>>>> On 9/24/21 8:48 PM, olcott wrote:
>>>>>> On 9/24/2021 7:09 PM, Richard Damon wrote:
>>>>>>> On 9/24/21 10:49 AM, olcott wrote:
>>>>>>>> On 9/23/2021 10:39 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/23/21 11:27 PM, olcott wrote:
>>>>>>>>>> On 9/23/2021 9:09 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/23/21 2:30 PM, olcott wrote:
>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>> #define ptr uintptr_t
>>>>>>>>>>>>
>>>>>>>>>>>> int H(ptr p, ptr i)
>>>>>>>>>>>> {
>>>>>>>>>>>> // Determine infinitely nested x86 emulation
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>        printf("H is called in infinitely nested emulation =
>>>>>>>>>>>> ", H(P,
>>>>>>>>>>>> P));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> H would use an x86 emulator to emulate its input in debug step
>>>>>>>>>>>> mode.
>>>>>>>>>>>>
>>>>>>>>>>>> Since people are telling me that my solution is incorrect I am
>>>>>>>>>>>> giving
>>>>>>>>>>>> them an opportunity to either correct my errors or failing that
>>>>>>>>>>>> show
>>>>>>>>>>>> that their software engineering skills are insufficient to
>>>>>>>>>>>> analyze the
>>>>>>>>>>>> problem as presented.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is quite possible in the realm of H to detect that it has been
>>>>>>>>>>> called
>>>>>>>>>>> in 'recursion', i.e. that one instance of H has been invoked
>>>>>>>>>>> within
>>>>>>>>>>> another instance of H with the same parameters. You code does
>>>>>>>>>>> this
>>>>>>>>>>> successfully.
>>>>>>>>>>>
>>>>>>>>>>> Since this H is only a limited decider, since the program to be
>>>>>>>>>>> decided
>>>>>>>>>>> is FORCED to be in the same address space as H, the trick of
>>>>>>>>>>> detecting
>>>>>>>>>>> the address of H in the simulated machine, and that must be a
>>>>>>>>>>> 'copy' of
>>>>>>>>>>> this H. (This also means that H isn't the requried decider of
>>>>>>>>>>> Linz, as
>>>>>>>>>>> it can't accept ANY input machine, but only those that fit this
>>>>>>>>>>> limited
>>>>>>>>>>> model.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is sufficiently the same thing in that it implements the
>>>>>>>>>> essence of
>>>>>>>>>> the liar paradox pattern.
>>>>>>>>>
>>>>>>>>> I thought you were working on that Halting Problem. It needs to
>>>>>>>>> sufficienty recreate the Linz H/H^ pattern and decide that. This
>>>>>>>>> requires H to be a real computation, and H^ built sufficiently like
>>>>>>>>> Linz
>>>>>>>>> does.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I hypothesize that you are either a liar or incompetent about
>>>>>>>> what is
>>>>>>>> and what is not an actual computation. The term of the art for
>>>>>>>> this is
>>>>>>>> "computable function", therefore if you are not a liar or
>>>>>>>> incompetent
>>>>>>>> you would be able to cite sources that conform your assessments.
>>>>>>>
>>>>>>> There is a difference between a Computable Function and a
>>>>>>> Computation,
>>>>>>> but it might be too subtle for you.
>>>>>>>
>>>>>>> A Computible Function is the actual Mapping, that happens to be
>>>>>>> computable, i.e. there exists an algorithm that is able to generate
>>>>>>> that
>>>>>>> mapping.
>>>>>>>
>>>>>>
>>>>>> I derive a unique mapping from an input finite string to a Boolean
>>>>>> value. I currently need static local data to do this, none-the-less a
>>>>>> unique mapping is derived. I can't understand how this is
>>>>>> computable in
>>>>>> C and not computable in a TM.
>>>>>>
>>>>>
>>>>> The problem is that to be a Computatable Function ALL refereces to that
>>>>> Function need to generate that same mapping.
>>>>>
>>>>> That means that the P that call this 'Computable Function' H must get
>>>>> the exact same answer as H give when just asked.
>>>>
>>>> So we are back to a function called in infinite recursion must return to
>>>> its caller even though everyone know this is impossible.
>>>
>>> Except that it ISN'T infinite recursion, since EVERY H will abort its
>>> simulation and return after finite time.
>>>
>>> Do you not understand that fact?
>>>
>>
>> If the question was:
>> Does P on its input stop running?
>> Then H provides the wrong answer.
>>
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>> THIS IS NOT THE QUESTION
>>
>> I have told you this many hundreds of times so I estimate that you may
>> have an actual neurological disorder.
>>
>
> But it IS the question that the Halt Decider is SUPPOSED to be answering.
>
> If you have decided you need to answer some different question, fine,
> you just aren't working on the Halting Problem.
>
> PERIOD. DEFINITION.
>

Whether or not the input P ever reaches its final state is an equivalent
question.

> You don't get to make up your own rules if you want to play the real game.
>
>
> I guess this is your admission that you have NEVER been talking about
> the actual halting problem but just about POOP.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein