XPost: comp.theory, sci.logic

On 11/5/2021 3:37 PM, André G. Isaak wrote:

On 2021-11-05 13:32, olcott wrote:

On 11/5/2021 2:16 PM, André G. Isaak wrote:

On 2021-11-04 19:51, olcott wrote:

We have to stay focused on the one single point that I perfectly and
totally proved that H did act as a pure simulator of the 14 steps of
P before we can move on to any other point.

As far as I can tell you are more interested in *avoiding* critical
points. The crucial points are:

(1) P(P) halts when run as an independent computation.
(2) Your H(P, P) claims that P(P) does *not* halt.

What you are saying is that if the correct pure simulation of the
input to H(P,P) never halts it still halts anyway. AKA a black cat is
sometimes not a cat at all.

I'm not talking about what happens inside your simulation. I'm talking
about the *actual* computation P(P) which you yourself have acknowledged halts.

Ah so you fundamentally disagree with the concept of a UTM.

That's the computation H(P, P) is supposed to be answering about.

Go back and reread the definition of Halt Decider. A halt decider takes
a description of a computation, but the answer it gives describes the *actual* computation described, not the 'behaviour of the input" (which
is meaningless gibberish) or what goes on inside some simulating halt decider.

P(P) halts. Ergo a halt decider must decide that it halts.

P(P) halts and the pure simulation of the input to H1(P,P) halts
and the pure simulation of the input to H(P,P) never halts conclusively
proving that it is not computationally equivalent to the above two.

It is a verified fact that the correct pure simulation of the input to
H(P,P) never halts therefore nothing in the universe can possibly
contradict this.

It is *not* a verified fact. It is simply an assertion on your part.

That the 14 lines shown below conclusively prove that H does perform a
pure simulation of its input in H(P,P) is no more a mere assertion than
the assertion that the decimal integer 5 is numerically greater than the decimal integer 3 AND YOU KNOW IT !!!

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

Begin Local Halt Decider Simulation at Machine Address:c36

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00000c36][002117ca][002117ce] 55 push ebp [00000c37][002117ca][002117ce] 8bec mov ebp,esp [00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08] [00000c3c][002117c6][00000c36] 50 push eax // push P [00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][002117c2][00000c36] 51 push ecx // push P [00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp [00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp [00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08] [00000c3c][0025c1ee][00000c36] 50 push eax // push P [00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08] [00000c40][0025c1ea][00000c36] 51 push ecx // push P [00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)

The
fact that P(P) halts and your simulation allegedly does not demonstrates
that your simulation is not a pure, faithful simulation.

Note that a trace merely shows *what* some program did. It does not
provide evidence for the correctness of that program. So you're never
going to convince anyone that your H is giving the correct answer simply
by providing traces. Its a waste of electrons.

The way to show that a program gives the correct answer is to compare
the answer it gives to the ACTUAL answer as defined by the problem which
the program is supposed to be solving.

André

--
Copyright 2021 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, sci.math

On 11/5/2021 4:15 PM, André G. Isaak wrote:

On 2021-11-05 14:51, olcott wrote:

On 11/5/2021 3:37 PM, André G. Isaak wrote:

On 2021-11-05 13:32, olcott wrote:

On 11/5/2021 2:16 PM, André G. Isaak wrote:

On 2021-11-04 19:51, olcott wrote:

We have to stay focused on the one single point that I perfectly
and totally proved that H did act as a pure simulator of the 14
steps of P before we can move on to any other point.

As far as I can tell you are more interested in *avoiding* critical
points. The crucial points are:

(1) P(P) halts when run as an independent computation.
(2) Your H(P, P) claims that P(P) does *not* halt.

What you are saying is that if the correct pure simulation of the
input to H(P,P) never halts it still halts anyway. AKA a black cat
is sometimes not a cat at all.

I'm not talking about what happens inside your simulation. I'm
talking about the *actual* computation P(P) which you yourself have
acknowledged halts.

Ah so you fundamentally disagree with the concept of a UTM.

You don't *have* a UTM. You have a C program.

And even if you were working with actual Turing Machines, you wouldn't
have a UTM, you'd have a 'simulating halt decider'.

That's the computation H(P, P) is supposed to be answering about.

Go back and reread the definition of Halt Decider. A halt decider
takes a description of a computation, but the answer it gives
describes the *actual* computation described, not the 'behaviour of
the input" (which is meaningless gibberish) or what goes on inside
some simulating halt decider.

P(P) halts. Ergo a halt decider must decide that it halts.

P(P) halts and the pure simulation of the input to H1(P,P) halts

Which takes us back to the question which you keep ignoring. You claimed
that "an infinite number of different simulating halt deciders must have exactly the same behavior while they are doing a pure simulation of
their input. "

Yes in the same way that an infinite number of int Add(int, X, int Y)
must derive the same sum of X + Y.

So why do H and H1 have *different* behaviours? They can't both be pure simulations and have different behaviours.

You can simply ignore that the pathological relationship between an
input and its halt decider has no effect what-so-ever on the halt
status decision none-the-less it has been conclusively proven beyond
all possible doubt that this pathological relationship DOES FREAKING
CHANGE THE RESULT.

and the pure simulation of the input to H(P,P) never halts
conclusively proving that it is not computationally equivalent to the
above two.

What is not computationally equivalent to what?

H1(P,P) != H(P,P) and their execution trace conclusively proves
that they are both correct.


The one thing that has most infuriated me my whole life is
that people stick with their false opinions directly against
the verified facts.

The opinion that climate change is not caused by humans will
make humans extinct.

https://www.researchgate.net/publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts

The opinion that the 2020 election had massive voter fraud will likely
cause Fascism to end Democracy by killing everyone that gets in their way.

The opinion that H does not correctly perform a pure simulation of
the first 14 steps of P will prevent me from getting enough credibility
to fix these other two things.

Any halt decider which takes a description of P(P) as its input is
answering about P(P). Ergo the behaviour of P(P) is all that matters in determining whether a given halting decision is correct.

If your 'pure simulation' is not "computationally equivalent" to this
then you are not answering about the right computation (and your
simulator isn't a pure simulator).

It is a verified fact that the correct pure simulation of the input
to H(P,P) never halts therefore nothing in the universe can possibly
contradict this.

It is *not* a verified fact. It is simply an assertion on your part.

That the 14 lines shown below conclusively prove that H does perform a
pure simulation of its input in H(P,P) is no more a mere assertion
than the assertion that the decimal integer 5 is numerically greater
than the decimal integer 3 AND YOU KNOW IT !!!

As I said before, traces DO NOT PROVE ANYTHING. Have you ever actually
looked at a proof of correctness for a computer program? They don't
involve traces. Traces are used for debugging, not for proofs. And on
the rare occasions when people actually do look at traces they do so in
a debugging environment where one can inspect the contents of variables
and memory locations. A printout of a trace is WORTHLESS.

André

--
Copyright 2021 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)