XPost: comp.theory, sci.logic
From: polcott333@gmail.com
On 7/30/2025 7:07 PM, Richard Damon wrote:
> On 7/30/25 7:46 PM, olcott wrote:
>> On 7/30/2025 6:26 PM, Richard Damon wrote:
>>> On 7/30/25 10:12 AM, olcott wrote:
>>>> 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.
>>>
>>> But not that *ALL* of it was simulated correctly.
>>>
>>
>> void Infinite_Recursion()
>> {
>> Infinite_Recursion();
>> return;
>> }
>>
>> void Infinite_Loop()
>> {
>> HERE: goto HERE;
>> return;
>> }
>>
>> Neither was all of the instructions of the above
>> simulated correctly. When N instructions are simulated
>> correctly the repeating pattern emerges.
>
> So?
>
>
>
>>
>> void DDD()
>> {
>> HHH(DDD);
>> return;
>> }
>>
>> executed HHH simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>> that simulates DDD that calls HHH(DDD)
>
>
> Nope, the first HHH simulated will abort the simulation before we get
> here.
Not at all. My encoded HHH aborts as soon as it
sees the pattern repeat once. It could have been
encoded to wait until it sees this same pattern
repeat ten times. That you keep pretending to never
see the pattern is quite dishonest. This might
cost your own soul. I would never risk this.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- SoupGate-Win32 v1.05
* Origin: you cannot sedate... all the things you hate (1:229/2)
|
