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

On 11/6/24 10:09 PM, olcott wrote:

On 11/6/2024 6:45 PM, Richard Damon wrote:

On 11/6/24 8:16 AM, olcott wrote:

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

On 11/5/24 10:28 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.
>

>

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,
>

>

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.
>

(b) The semantics of the x86 language +

>
Which is the defintion of doing *EVERY* instruction, just as presented, and not stopping until you reach a conclusion, something HHH doesn't do, so HHH's emulation doesn't follow this.
>

(c) DDD is calling its own termination analyzer

>
Which is irrelevent as it has nothing to do with "x86 langugage semantics", and when taken into account mean that HHH *MUST* return to DDD, and thus DDD MUST halt.
>
Thus proving that HHH is wrong, and you are just a liar.
>

∴ HHH is correct to reject its input as non-halting

>
Nope, just proves that you fail to understand how to do logic, but believe that lying is an acceptable form of logic.
>

>
*THIS IS THE PART THAT YOU PRETEND TO NOT SEE*
We can only get to the behavior of the directly executed
DDD() by ignoring (b).

>
How is that? You seem unable to explain, only make false claims.
>
The sementics of the x86 language say that the input does what it does when executed. PERIOD.
>
So, your saying that the x86 semantics only show something when you ignore the x86 semantics is just an admission that you are lying.
>

>

You are just trapped in your equivocation, unable to resolve it without admitting your error, but because of it, you are just showing your stupidity.
>

>

And thus, HHH is just wrong.
>

>

No contradiciton in that, unlike your claim that HHH can do a partial emulation to predict what it itself would do when it does a complete emulation of the exact same input using the exact same code.
>

>
I have never said that.
*ChatGPT explains that HHH does meet your model*

>
Nope, it admitted that it doesn't.
>

>
*Simplified Analogy*
Think of HHH as a "watchdog" that steps in during real
execution to stop DDD() from running forever. But when
HHH simulates DDD(), it's analyzing an "idealized" version
of DDD() where nothing stops the recursion. In the simulation,
DDD() is seen as endlessly recursive, so HHH concludes that
it would not halt without external intervention.
>
https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
>
>
>

>
Except that your input is a LIE.
>

>
It is very stupid to say that a byte string of x86 code is a lie.
>

>
But it doesn't represent the program DDD.
>
THAT is the lie.
>

>
It is ridiculously stupid to call the ACTUAL x86
machine language of DDD that calls the x86 machine
language of HHH a lie.

>
It is when you OMIT some of it. Only the WHOLE TRUTH is the truth, a partial truth is just a lie.
>

>
How can the full finite string of x86 machine code
that calls the full finite string of HHH code lie?

>
>
Because the code that just calls some other code, isn't a complete program.
>
Thus, the code for the C function DDD, isn't the full code for the PROGRAM DDD, until it has had the full code for HHH (and everything it calls) included in it.
>
You don't seem to understand that "Programs" are complete and self- contained and don't "call" things outside of them, only use sub- routines that are part of them.
>

>

You clearly don't understand what a PROGRAM is, and that the PROGRAM DDD must include the code for the HHH that it calls.
>

>
*I have told you that it does dozens and dozens of times*
>
HHH emulates itself emulating DDD
HHH emulates itself emulating DDD
HHH emulates itself emulating DDD
HHH emulates itself emulating DDD
HHH emulates itself emulating DDD

>
But only partially.
>

>
I can keep repeating this thousands of times
if that is what it takes for you to see it once.

>
Maybe if you say it long enough you will remember to make the complete statement.
>

>

>

It isn't analyzing an "idealized" version of its input, it is analyzing the input it is actually given, where DDD calls the existing HHH, not the idealized version of it.
>
You should know this, and thus all you have done is show that your logic is just based on LIES.
>

>
The paragraph that you said that I keep quoting
is a breakthrough. that you keep contradicting
your own words seems quite dumb to me.

>
How am I contradicting myself?
>
HHH doesn't need to actualy emulate DDD completely, just determine, like HHH1 does, that it will reach the return instruction.
>

>
That is not what the machine code of DDD that calls
the machine code of HHH says. You are living in a fantasy land.

>
Right, so that is part of the input, or it can't be emulated.
>
The Machine code of HHH says that it will abort its emulation and return, so that is the only correct result per the x86 language.
>

>
Are you really so ignorant of these things that you
think that the fact that HHH returns to main() causes
its emulated DDD to reach its own final state?
>
>

>
But the PROGRAM DDD, that it is emulating does. Just its own PARTIAL emulation of it is aborted before it gets there.
>

>

>
Just repeating your errors, and not even trying to refute the errors pointed out, I guess that means you accept these as errors.
>

(a) Finite string of x86 machine code DDD +

>
Which doesn't contain all the code of DDD, and thus saying it is a representation of the PROGRAM DDD is just a lie.
>

(b) The semantics of the x86 language +

>
Which requires the code of *ALL* of the program, and the unbounded emulation (or until it reaches a final state) of that COMPLETE code.
>

(c) DDD is calling its own termination analyzer

>
Which isn't something that is part of the sematnics of the xx86 language, so irrelevent.
>
And, when you include it, since BY DEFINITION a termination analyser must return an answer, shows that HHH(DDD) WILL return to DDD, and thus DDD will halt.
>

>
DDD emulated by HHH will reach its own "return" instruction,
or are you trying to get away with equivocation?
>

 DDD, when completly emulated by the other emulator