Re: The philosophy of computation reformulates existing ideas on a new basis --- x86 code is a liar?

On 11/5/24 10:16 PM, olcott wrote:

On 11/5/2024 7:50 PM, Richard Damon wrote:

On 11/5/24 8:22 PM, olcott wrote:

On 11/5/2024 6:04 PM, Richard Damon wrote:

On 11/5/24 12:08 PM, olcott wrote:

On 11/5/2024 6:03 AM, Richard Damon wrote:

On 11/4/24 10:15 PM, olcott wrote:

On 11/4/2024 8:42 PM, Richard Damon wrote:

On 11/4/24 8:32 PM, olcott wrote:

On 11/4/2024 6:21 PM, Richard Damon wrote:

On 11/4/24 7:48 AM, olcott wrote:

On 11/4/2024 6:07 AM, Richard Damon wrote:

On 11/3/24 11:03 PM, olcott wrote:

On 11/3/2024 9:57 PM, Richard Damon wrote:

On 11/3/24 10:19 PM, olcott wrote:

On 11/3/2024 7:46 PM, Richard Damon wrote:

On 11/3/24 8:38 PM, olcott wrote:

On 11/3/2024 7:26 PM, Richard Damon wrote:

On 11/3/24 8:21 PM, olcott wrote:

>
What would an unbounded emulation do?
>

>
Keep on emulating for an unbounded number of steps.
>
Something you don't seem to understand as part of the requirements.
>
Non-Halting isn't just did reach a final state in some finite number of steps, but that it will NEVER reach a final state even if you process an unbounded number of steps.

>
Would an unbounded emulation of DDD by HHH halt?

>
Not a valid question, as your HHH does not do an unbounded emulation, but aborts after a defined time.
>

>
*Now you are contradicting yourself*
YOU JUST SAID THAT HHH NEED NOT DO AN UNBOUNDED
EMULATION TO PREDICT WHAT AN UNBOUNDED EMULATION WOULD DO.

>
Right. it doesn't NEED to do the operation, just report what an unbounded emulation would do.
>
You asked about an "unbounded emulation of DDD by HHH" but that isn't possible, as HHH doesn't do that.
>

>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > On 11/3/24 9:39 AM, olcott wrote:
 >>
 >> The finite string input to HHH specifies that HHH
 >> MUST EMULATE ITSELF emulating DDD.
 >
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do, even if its own programming
 > only lets it emulate a part of that.
 >
>
*You JUST said that HHH does not need to do an unbounded emulation*
*You JUST said that HHH does not need to do an unbounded emulation*
*You JUST said that HHH does not need to do an unbounded emulation*
*You JUST said that HHH does not need to do an unbounded emulation*
>

>
Right, it doesn't need to DO the unbounded emulatiohn just figure out what it would do.
>
Just like we can compute:
>
1 + 1/2 + 1/4 + 1/8 + ... + 1/2^n + ...
>
Ether by adding the infinite number of terms, or we can notice something about it to say it will sum, in the infinite limit, to 2.
>
>
In the same way, if HHH can see something in its simulation that tells it THIS this program can NEVER halt, it can report it.
>

>
Anyone with sufficient technical competence can see that
the unbounded emulation of DDD emulated by HHH can never halt.

>
No, because the HHH that is given doesn't do that, and that is the only one that matters.
>

>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > On 11/3/24 9:39 AM, olcott wrote:
 >>
 >> The finite string input to HHH specifies that HHH
 >> MUST EMULATE ITSELF emulating DDD.
 >
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do, even if its own programming
 > only lets it emulate a part of that.
 >
>
If you are going to keep contradicting yourself
I am going to stop looking at anything you say.

>
And where is the contradiction?
>
HHH doesn't need to do the unlimited emulation, just say what the unlimited emulation by the unlimited emulator (which WILL be a different program) will do.
>

>
That is what I have been saying all along.

>
So, you agree that HHH1's emulation to the completion shows that the complete emulation of the input to HHH does halt, and thus the correct answer for HHH to give for *THIS* input, which has implicitly included *THIS* HHH as part of it, is that it halts.
>

>
Nothing like this.
You continue to fail to understand that halting
requires reaching the "return" instruction final
halt state. DDD emulated by HHH never does this.

>
But the emulation by HHH isn't the correct measure of DDD reaching its return statement.
>

>
Well we did get somewhere on this so that is more progress.
Only reaching the final state is halting.

>
And only something that continues to the end shows that, an emulation that aborts doesn't show that the input is non-halting unless it can prove that the unaborted emulation of that EXACT PROGRAM would never halt.
>

 That statement is self-contradictory. The exact same
program that aborts is different than when it would
never abort.

How is my statement self-contradictory. THere can't be an "exact same program" that aborts and never abort.
That is YOUR contradiction, you try to claim that the HHH that does one is the "same" as the one that does the other, and that both are looking at the "same" DDD that is built on it.
DDD (the orignial, calling HHH that aborts) does reach its return when run or FULLY emulated (which HHH doesn't do), showing that your claim of non-halting is just false.
The HHH' (your modified version) when it emulated DDD' (the modified version of DDD that calls HHH') does get stuck in the infinite recursion, but it isn't looking at the "same program" as HHH did, as you try to claim, and admit to your error above.
Thus, HHH is WRONG about DDD, but would have been right about DDD' if that was what was given to it, but it wasn't.
Only by your LIE that DDD and DDD' are "the same program", that you just admitted is a lie can it try to claim to be correct.
Part of the problem is your whole argument is based on the lie of your strawman that the "behavior" of the input is based on the emulation of the decider, which is just a blantant lie that shows your total ignorance of the facts.
Partial emulation do not define the results of NEVER, only NOT YET

 

>

By the correct meaning of the statement, it is just false.
>

>
ChatGPT explains why and how it <is> the correct measure
in its own words and from a point of view that I not tell
it or even see for myself.
>
https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2

>
Base on your LIES, so doesn't mean anything,
>

 Not at all. It has acquired its own understanding
and cannot be convinced that this understanding is
incorrect.

No, Chat GPT doesn't HAVE "understanding", and when feed lies will give false results.
You are just proving that your concept of "logic" include that lies are ok, showing that you are nothing but a pathological liar that wants to destroy the world by allowing people to "validly" make false claims.

 

>

By your attempted meaning, it is just nonsense, and thus a lie to claim it to be true.
>

>
*It is actually your words that are nonsense*
>
(a) Finite string of x86 machine code DDD +

>
Which include the code of the HHH that DDD calls, which you have said is the HHH that aborts and returns the answer.
>

 HHH examines what would happen if it didn't abort just
like you already correctly said:

But it does so by assuming it is allowed to change the code of the program that it was given.
DDD calls the HHH that gives the answer, not the "assumed" HHH that doesn't.
Remember, DDD calls a specific set of code, not just whatever decider is looking at it at the momentn

 On 11/3/2024 12:20 PM, Richard Damon wrote:
 > On 11/3/24 9:39 AM, olcott wrote:
 >>
 >> The finite string input to HHH specifies that HHH
 >> MUST EMULATE ITSELF emulating DDD.
 >
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do, even if its own programming
 > only lets it emulate a part of that.
 >
 The unbounded emulation of DDD by HHH is the emulation of
DDD where HHH DOES NOT ABORT, that is what unbounded means.
 

No, it is the umbound emulation of the exact program given to it, which includes the code of the HHH that does abort.
You are just proving that you have been lying about what you are doing and that you don't understand what a PROGRAM is.
Sorry, you are just proving yourself to be an ignorant pathological lying idiot that doesn't understand what he is talking about.