XPost: comp.theory, sci.logic
From: polcott333@gmail.com
On 7/31/2025 6:41 PM, Richard Damon wrote:
> On 7/31/25 12:15 PM, olcott wrote:
>> On 7/30/2025 9:18 PM, Richard Damon wrote:
>>> On 7/30/25 9:00 PM, olcott wrote:
>>>> 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.
>>>>
>>>
>>> Right, so you LIED about what happens.
>>
>> I had to emphasize the repeating pattern enough
>> so that you could see it. When I only show you
>> a little bit of it you pretend that it does not exist.
>
> In other words, you are just admitting that you think LYING is
> appropriate when making an arguement.
>
Of every HHH that can possibly exist one of them does
[continued in next message]
--- SoupGate-Win32 v1.05
* Origin: you cannot sedate... all the things you hate (1:229/2)
|
