XPost: comp.theory, sci.logic
From: F.Zwarts@HetNet.nl
Op 30.jul.2025 om 16:12 schreef olcott:
> On 7/30/2025 4:09 AM, Fred. Zwarts wrote:
>> Op 30.jul.2025 om 07:00 schreef olcott:
>>> On 7/29/2025 11:22 PM, Alan Mackenzie wrote:
>>>> [ Followup-To: set ]
>>>>
>>>> In comp.theory olcott wrote:
>>>>> On 7/29/2025 9:35 PM, Alan Mackenzie wrote:
>>>>>> olcott wrote:
>>>>>>> On 7/29/2025 5:49 PM, Alan Mackenzie wrote:
>>>>>>>> In comp.theory olcott wrote:
>>>>>>>>> On 7/29/2025 2:39 AM, Fred. Zwarts wrote:
>>>>
>>>>>>>> [ .... ]
>>>>
>>>>>>>>>> As usual incorrect claims without evidence.
>>>>>>>>>> Your dreams are no verified facts. HHH aborts before the
>>>>>>>>>> simulation
>>>>>>>>>> would reach the final halt state in a finite number of steps,
>>>>>>>>>> as proven
>>>>>>>>>> by world-class simulators using exactly the same input. The
>>>>>>>>>> infinity is
>>>>>>>>>> only in your dreams.
>>>>
>>>>
>>>>>>>>> HHH(DDD) must simulate itself simulating DDD because DDD calls
>>>>>>>>> HHH(DDD)
>>>>
>>>>>>>>> HHH1(DDD) must NOT simulate itself simulating DDD because DDD
>>>>>>>>> DOES NOT
>>>>>>>>> CALL HHH1(DDD)
>>>>
>>>>>>>>> At this point I think that you are a fucking liar.
>>>>
>>>>>>>> As has been established elsewhere in this thread, you are no
>>>>>>>> position to
>>>>>>>> call anybody else here a liar. Glass house inhabitants,
>>>>>>>> throwing stones,
>>>>>>>> and all that.
>>>>
>>>>>>>> And you used to distinguish yourself from other cranks by
>>>>>>>> sticking to
>>>>>>>> decorous language, and generally being courteous. Not any more.
>>>>>>>> That is
>>>>>>>> a most unwelcome change.
>>>>
>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> HHH(DDD);
>>>>>>> return;
>>>>>>> }
>>>>
>>>>>>> *That not one single person here*
>>>>>>> (besides those that I invited from the C groups)
>>>>>>> acknowledges that DDD simulated by HHH specifies
>>>>>>> recursive simulation
>>>>
>>>>>>> cannot be reasonably attributed to anything besides
>>>>>>> willful deception.
>>>>
>>>>>> Foul mouthed lying on your part. It can be attributed to your
>>>>>> lack of
>>>>>> self awareness and lack of technical ability. Everybody here but
>>>>>> you can
>>>>>> see that.
>>>>
>>>>
>>>>> It is not any lack of technical ability that determines
>>>>> whether or not DDD correctly simulated by HHH can or
>>>>> cannot reach its own "return" instruction final halt state.
>>>>
>>>> It is a lack of technical ability on your part which is unable to judge
>>>> whether such a correct simulation is possible. Everybody else sees
>>>> that
>>>> it is not, so further questions about it are non-sensical.
>>>>
>>>
>>> void DDD()
>>> {
>>> HHH(DDD);
>>> return;
>>> }
>>>
>>> _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]
>>>
>>> I have no idea why are are saying the something
>>> that is trivial is impossible.
>>>
>>> When HHH emulates: "push ebp" then HHH has correctly
>>> emulated the first instruction of DDD correctly.
>>
>> Simulating a few instructions does not make the whole simulation correct.
>
> Simulating N instructions correctly does mean that
> these N instructions were simulated correctly.
Nobody denies that, but it does not make te whole simulation correct.>
>> In contrast, the failure to simulate a single instruction correctly,
>> makes the whole simulation incorrect.
>> In this case it is the failure to simulate the call instruction.
>
> My code conclusively proves that HHH does simulate
> itself simulating DDD. That you do not understand
> this code well enough to understand that is less
> than no rebuttal at all.
Incorrect claims, as usual.
I do understand it and in fact better that you do. You do not understand
that the simulation is not correct when the simulation is not completed.
You also do not understand that a finite recursion does not imply
non-halting.
>
>> The simulation aborts at this point, where the semantics of the x86
>> language requires the execution of the next instruction.
>
> Simulating Termination Analyzer HHH correctly simulates its input until:
> (a) It detects a non-terminating behavior pattern then it aborts its
> simulation and returns 0,
Incorrect. It aborts when it sees a finite recursion. The programmer
forgot to cont the conditional branch instruction, so that it
incorrectly reports non-halting.
> (b) Its simulated input reaches its simulated "return" statement then it
> returns 1.
>
> My code conclusively proves that HHH does simulate itself
> simulating DDD until any sufficiently competent person can
> correctly determine a repeating pattern that cannot possibly
> reach its own "return" statement final halt state even with
> an infinite simulation.
Incorrect repeated claim, as usual. Any competent person knows that a
finite recursion, or a finite repeating pattern, does not mean
non-termination.
Better simulators also show that after the finite recursion, the final
halt state is reachable.
That HHH is unable to reach the final halt state, therefore, is a
failure of HHH.
>
> That you do not understand this code well enough to
> understand that is less than no rebuttal at all.
As usual, incorrect repeated claim, without any evidence.
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
The HHH that is called by DDD in the simulation, is the HHH that aborts
and returns. So, the input for the simulation specifies a halting program.
That HHH fails to see the whole specification, does not change the
specification.
Your huge mistake is that you think that what HHH does not see, does not
exist.
>
> When it does detect this pattern then it kills the
> whole DDD process so that there is no stack unwinding.
But there was no need to do so. Other simulators show that when the
simulation is not killed, the final halt state is reached.
> > This premature abort, based on the incorrect assumption that a finite
>> recursion specifies non-halting, makes the whole simulation incorrect
>> and, what is worse, the conclusion of non-halting behaviour fails.
>>
>
> HHH uses exactly same process on this function.
>
> void Infinite_Recursion()
> {
> Infinite_Recursion();
> return;
> }
>
> as it does this function.
Incorrect, it more like:
void Finite_Recursion (int N) {
[continued in next message]
--- SoupGate-Win32 v1.05
* Origin: you cannot sedate... all the things you hate (1:229/2)
|
