Re: How Partial Simulations correctly determine non-halting ---Ben's 10/2022 analysis

On 6/8/24 8:52 AM, olcott wrote:

On 6/8/2024 1:36 AM, Mikko wrote:

On 2024-06-07 17:11:39 +0000, olcott said:
>

On 6/7/2024 11:56 AM, Mikko wrote:

On 2024-06-07 14:47:35 +0000, olcott said:
>

On 6/7/2024 1:30 AM, Mikko wrote:

On 2024-06-06 15:31:36 +0000, olcott said:
>

On 6/6/2024 10:14 AM, Mikko wrote:

On 2024-06-06 13:53:58 +0000, olcott said:
>

On 6/6/2024 5:15 AM, Mikko wrote:

On 2024-06-05 13:29:28 +0000, olcott said:
>

On 6/5/2024 2:37 AM, Mikko wrote:

On 2024-06-04 18:02:03 +0000, olcott said:
>

*HOW PARTIAL SIMULATIONS CORRECTLY DETERMINE NON-HALTING*
>
On 10/13/2022 11:29:23 AM
MIT Professor Michael Sipser agreed this verbatim paragraph is correct
(He has neither reviewed nor agreed to anything else in this paper)
>
<Professor Sipser agreed>
If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then
>
H can abort its simulation of D and correctly report that D specifies a
non-halting sequence of configurations.
</Professor Sipser agreed>

>
It is quite clear what Professor Sipser agreed.

>
Those were my verbatim words that he agreed to, no one
has ever correctly provided any alternative interpretation
that could possibly make my own HH(DD,DD)==0 incorrect.

>
One can agree with those words because they are both clear and true.
Whether they are sufficient to your purposes is another problem but
that is nor relevant to their acceptablility.
>

If you use those words
as the second last part of your proof then it sould be obvious that we
need to look at the other parts in order to find an error in the proof.

>
That is slightly more than zero supporting reasoning yet mere gibberish
when construed as any rebuttal to this:

>
Those who disagree with you about whether something is "gibberish" may
think that you are stupid. You probably don't want them to think so,
regardless whether thinking so would be right or wrong.
>

*This unequivocally proves the behavior of DD correctly simulated by HH*
https://liarparadox.org/DD_correctly_simulated_by_HH_is_Proven.pdf

>
Why would anyone construe my words as any rebuttal to that? That pdf
merely claims that a partucuar author (a C program) proves two particular
claims, the second of which is badly formed (because of the two
verbs it is hard to parse and consequently hard to be sure that the
apparent meaning or apparent lack of meaning is what is intended).
>

>
*I will dumb it down for you some more*

>
Did you knwo that "dumb it down" does not mean 'change the topic'?
>

Try any show how this DD can be correctly simulated by any HH
such that this DD reaches past its machine address [00001dbe]
>
_DD()
[00001e12] 55         push ebp
[00001e13] 8bec       mov  ebp,esp
[00001e15] 51         push ecx
[00001e16] 8b4508     mov  eax,[ebp+08]
[00001e19] 50         push eax      ; push DD
[00001e1a] 8b4d08     mov  ecx,[ebp+08]
[00001e1d] 51         push ecx      ; push DD
[00001e1e] e85ff5ffff call 00001382 ; call HH
>
*That meets this criteria*

>
It doesn't if you mean the criteria implied by the subject line.
>

>
Yes it does mean that when we ourselves detect the repeating
state of DD correctly simulated by HH does meet the first part
of the following criteria:

>
What does your "first part" mean? There is more than one way to
partition the criteria.
>

>
    If simulating halt decider HH correctly simulates its input DD
    until HH correctly determines that its simulated DD would never
    stop running unless aborted then

>
That is all of the criteria, so should not be called "first part".
Atually Sipser only agreed about H and D, not about HH and DD but
that does not make any difference for the above.

>
Professor Sipser knew full well that H and D are mere
placeholders for simulating halt decider H with arbitrary input D.

>
Yes, as nothing more is specified in the agreed text. But his expressed
agreement does not extend to any substition of those placeholders.
>

 It allows substitution of any simulating halt decider for H
and any finite string input for D. If you are going to lie
about this I am going to quit looking at what you say.
 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then
    H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

And you can only use that with the definiton Professor Sipser has for "Correct Simulation" which you don't do, that of one that goes to completion. And it is for an input that is FIXED and doesn't change as you imagine alternate H's.
Since your H doesn't do a correct simulation per the canonical definition, you can't directly use the first part to claim the second. You can't even imagine a hypothetical replace for THIS COPY of H that does such a simulation, because such a hypothetical doesn't change the input, which will still call the original H, and that simulation WILL HALT when you include in it the decision the H will abort its simulation and return 0, thus you never got the permission needed to be correct to do so, and thus you can be incorrect, which you are.

 

In order to prove that the criteria are met you need to prove that
(1) simulation halt decider HH correctly partially simulates its
input DD until some point,
(2) at that point HH can determine that it is possible to continue
the simulation forever, and > (3) the determination by H is correct.
So far you have not proven (3).

>
*I have proven it thousands of times in the last three years*
2,000 times would only be an average of less than two proofs
per day.

>
No, not even onece. You have often caimed to have proven but
you have not presented anything that would even look like a
proof.
>

 It will only look like gibberish to anyone not having the mandatory
prerequisites. That does not mean that it <is> gibberish.
 I incorporate by reference
(a) The x86 language
(b) The notion of an x86 emulator
 (c) I provide this complete function

So?

 void DDD(int (*x)())
{
   HH(x, x);
}
 _DDD()
[00001de2] 55         push ebp
[00001de3] 8bec       mov ebp,esp
[00001de5] 8b4508     mov eax,[ebp+08]
[00001de8] 50         push eax         ; push DD
[00001de9] 8b4d08     mov ecx,[ebp+08]
[00001dec] 51         push ecx         ; push DD
[00001ded] e890f5ffff call 00001382    ; call HH
[00001df2] 83c408     add esp,+08
[00001df5] 5d         pop ebp
[00001df6] c3         ret
Size in bytes:(0021) [00001df6]
 Then I state that No DDD correctly emulated by any
x86 emulator H can possibly reach its own [00001df6]
instruction.

Which isn't a proof, but just a claim. You need to show why that claim is actually true.
Note, claiming that NO thing meets a requirement is hard. Generally it is done by the proof type you don't understand, the proof by contradiction. Where you try to show that if one existed, it would by necessity be breaking some requirement.

 To anyone having this mandatory prerequisite knowledge
(perhaps not you) every x86 emulation of DDD by any
x86 emulator H continually repeats the first seven lines
of DDD until it crashes due to out-of-memory error.
 

Which means you just proved that NO HH that meets your requirements can ever give an answer for this question.
You Claim this not to be true, so that just shows that your system is self-contradictory.
And the apparent issue is that you are changing your definition of "Correct Simulation" between the two.
Apparently quite intentionally, so it can be considered an act of deception, commonly called a LIE.