Re: My reviewers think that halt deciders must report on the behavior of their caller

On 7/8/25 11:17 AM, olcott wrote:

On 7/8/2025 6:18 AM, Richard Damon wrote:

On 7/7/25 10:52 PM, olcott wrote:

On 7/7/2025 9:24 PM, Richard Damon wrote:

On 7/7/25 7:47 PM, olcott wrote:>>

That Turing machines cannot take directly executing Turing
Machines as inputs entails that these directly executed
machines are outside of the domain of every Turing machine
based halt decider.

>
But they can take the finite-stringt encoding of those machines.
>

>
Yes.
>

I guess you idea of Turing Machine is so limited that you think they can't do arithmatic, as you can't actually put a "Number" as the input, only the finite-string encoding of a number, which puts it outside the domain of them.
>

>
No one here has any understanding of the philosophy of
computation. They can only memorize the rules and have
no idea about the reasoning behind these rules.
>

>
That you cannot understand that is a truism is only your
own lack of understanding.

>
But it isn't a truism, it is just a stupid lie that ignores that almost everything done with programs is via an "encoding" for the input.
>

>
Gross ignorance about the reasoning behind the rules
of computation would tell you that.
>

>
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
*Here is the Linz proof corrected to account for that*
>
*adapted from bottom of page 319*
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
     ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
     its simulated final halt state of ⟨Ĥ.qn⟩
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
     ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
     reach its simulated final halt state of ⟨Ĥ.qn⟩
>
>

>
Which is just an admission of your lying strawman, as the question is NOT about the (partial) simulation done by your H / embedded_H, but about the direct execution of the input H^ (H^) as that is what the input to H is encoding.
>

>
Because no Turing machine can take a directly executed
Turing machine as an input, directly executed Turing
machines have always been outside of the domain of every
Turing machine based decider.

>
Then evdrything in reality is outside the domain of Turing Machines.
>

>
"the direct execution of the input H^ (H^)" has always been
out-of-scope for every Turing machine based halt decider.
That no one bothered to notice this ever before
*DOES NOT MAKE ME WRONG*

>
But it hasn't been, and thus you are just wrong.
>

>
An actual rebuttal requires proving that Turing machines
can take directly executing Turing machines (that are not
finite string encodings) as inputs.

>
But the Turing Machine that is directly executed CAN be represented by a finite string,.
>

 In the case of pathological self-reference the
representation has different behavior than the
directly executed machine and halt deciders only
report on the actual behavior actually specified
by their inputs.

And where do you get that from?
It seems, just from your ASS.
Since the DEFINITION of the behavior of the input to a halt decider is the behavior of the direct execution of the program that input describes. you are just admitting that you are ignorant of what you are talking about, and are just a pathological liar that has no understanding of what truth means.

 

>
Alan had a hard time on this because a directly executed
machine never had to be divided from the simulation of
a finite string encoding before I created the idea of a
simulating halt decider.
>

>
Because that isn't a valid operation, just your insanity.
>

 Your lack of sufficient technical competence never
has been my mistake. You baselessly claim that I am
wrong yet never show the reasoning that shows that
I am wrong *BECAUSE YOU KNOW THAT I AM CORRECT*

No, I show the reasons you are wrong, but because you have brainwashed yourself to not see your own errors you don't understand them.

 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 Show how any step of DDD simulated by HHH
(according to the semantics of the x86 language)
ever reaches past its own machine address [0000219a].

The problem is your requirement is self-contradictory, and based on a LIE.
The problem is your input, as given above CAN'T be correctly simulated as the call HHH can not be simulated since the code at the target address is not provided in the input.
WHen you include the definition of HHH from Halt7.c as part of the input we see that HHH just fails to "correctly simulate" its input because it aborts, but that the correct simulation (as shown by you big trace) will halt (since main has the exact same code as DDD).

 

Since it CAN be represented as a finite string, it IS in the domain that they can handle,
>

 *It has provably different behavior*

And where is that proof?

 

To ignore the ability to represent means you ignore their ability to do anything useful.
>

 *It has provably different behavior*
 

And where is that proof?
Remember, proofs START with the listing of the known and accepted propositions that will be used (not your made up definitions) and then going step by step with accepted truth persevering operations, reach the conclusion.
Since it can be proven that a correct simulation of a representation of a program will ALWAYS exactly reproduce the direct execution of that program, you claim is just a lie.
And shows that you have absolutely no knowledge of the field you are talking about.

I will ask you try to do something useful without representations!!!
>
>
Note, Words are representations.
>
Letters and Digits are representations.
>
Messages sent over media are representations.
>
Saying you can't use representtions means you can basically do NOTHING, and the finite string they work with are just meaningless.
>
Just like your life, MEANINGLESS as you lost the key to reality, the understanding of real meaning.

 

Sorry, you are just proving that you are ignorant of everything you are talking about, and too stupid to see that fact.