XPost: comp.theory, comp.lang.c++
From: 643-408-1753@kylheku.com
On 2025-11-24, olcott wrote:
> On 11/24/2025 4:22 PM, Kaz Kylheku wrote:
>> On 2025-11-24, olcott wrote:
>>> On 11/24/2025 1:27 PM, Kaz Kylheku wrote:
>>>> On 2025-11-24, Mike Terry
wrote:
>>>>> On 24/11/2025 16:32, Kaz Kylheku wrote:
>>>>>> On 2025-11-24, olcott wrote:
>>>>>>> On 11/22/2025 11:24 PM, Kaz Kylheku wrote:
>>>>>>>> That's just the thing! If this were correctly implemented then in fact
>>>>>>>> DD /wold be/ calling HHH1, using the name HHH.
>>>>>>>>
>>>>>>>
>>>>>>> You are trying to get away with this lie
>>>>>>> about the semantics of C?
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> HHH(DD);
>>>>>>> HHH1(DD);
>>>>>>> return 0;
>>>>>>> }
>>>>>>>
>>>>>>> _main()
>>>>>>> [000022c4] 55 push ebp
>>>>>>> [000022c5] 8bec mov ebp,esp
>>>>>>> [000022c7] 6834220000 push 00002234 ; push DD
>>>>>>> [000022cc] e833f3ffff call 00001604 ; call HHH
>>>>>>> [000022d1] 83c404 add esp,+04
>>>>>>> [000022d4] 6834220000 push 00002234 ; push DD
>>>>>>> [000022d9] e856f2ffff call 00001534 ; call HHH1
>>>>>>> [000022de] 83c404 add esp,+04
>>>>>>> [000022e1] 33c0 xor eax,eax
>>>>>>> [000022e3] 5d pop ebp
>>>>>>> [000022e4] c3 ret
>>>>>>> Size in bytes:(0033) [000022e4]
>>>>>>
>>>>>> That's right; even if HHH and HHH1 are separately realized and given
>>>>>> different adddresses, not recognized as identical by the compiler and
>>>>>> not folded into one copy, in a correct implementation of your software,
>>>>>> HHH(DD) and HHH1(DD) would behave as indistinguishable, mutually
>>>>>> interchangeable operations.
>>>>>
>>>>> Right - in terms of their results when called.
>>>>>
>>>>> But TM-descriptions can legitimately contain multiple distinct copies of
"the same algorithm", and
>>>>> there's no reason that an emulator emulating the TM is required to
identify such copies as being
>>>>> copies - an emulator just has to mimic what the TM would do and the TM
doesn't know that it has
>>>>> multiple copies of the same algorithm with different state labels...
Your point that the /results/
>>>>> of those copied algorithms must be the same is spot on though.
>>>>
>>>> Olcott's simulator contains abort criteria which rely on comparing
>>>> addresses pulled from the trace buffer.
>>>>
>>>> That logic concludes that when two addresses are not equal, they
>>>> represent two different functions. I.e. if CALL X and CALL Y occur in
>>>> the trace buffer, without any intervening conditionals in between but X
>>>> != Y, then it is not concluded that it is a loop.
>>>>
>>>
>>> DD is calling HHH(DD) in recursive simulation
>>> and DD is not calling HHH1(DD) in recursive
>>> simulation.
>>
>> Yes, clearly; yet HHH1 and HHH are the same. So how can that be?
>>
>>> I do not believe that you do not
>>> understand this.
>>
>> Indeed, I do, of course. I'm just saying that it's an incorrect
>> state of affairs.
>>
>
> That wold be a lie.
I would not say anything that would be interpreted as wrong; nobody who
finds it wrong would think that I'm lying, only that I am misinformed
and ignorant. The last thing I want is to be misinformed and ignorant,
misinforming others.
> It is like you are trying to get away with saying
> that identical twins are one and the same person.
No, it's like I'm saying that Peter and Olcott, in the context of
comp.theory, are one person and not identical twins.
Twins is not a great analogy, but within that analogy that's
how it is.
If HHH and HHH1 have the same definition, they are supposed
to be the same function and not just identical twins.
Two people who are exactly the same down to the atom (not just
identical twins) are still different individuals bedcause
they have a separate mental state. If you were cloned in a
Star-Trek-like matter replicator, there would be two individuals.
They would share the same memories of the past, but forge new
experiences.
Functions in computation theory must not have state. Thus,
they are not like people. (There are ways to model state, as such,
with functions, but an individual function doesn't have state,
by definition.)
Two identical definitions, or nearly identical definitions that
have different names only, are of one function, not "twins".
Yes, your HHH1 and HHH do have state, like separate static
execution trace pointers pointing to different buffers when those
are allocated. That is one thing that is wrong.
If that were fixed, you would still have to make sure that
HHH1 and HHH compare as equal.
(At that point, it would be best to just drop HHH1 since
an additional name for the same function just adds potential
for confusion. The reason you maintain HHH1 is that you believe
it serves some purpose in your understanding, but the underpinnings
are flawed due to the above issues.)
> The identity of indiscernibles is an ontological principle
> that states that there cannot be separate objects or entities
> that have all their properties in common.
>
> https://en.wikipedia.org/wiki/Identity_of_indiscernibles
All the properties of a recursive function in computation theory
are encoded in its definition.
If HHH and HHH1 share the same definition, and are properly
pure functions, then they are indiscernible.
There is another principle in that there cannot be separate objects,
in some context, which have all their /relevant properties/
in common.
A recursive function modeled in C in two ways can result in
two instances that do not share an /irrelevant/ property,
such as address.
You must not bring in irrelevant properties and make them significant,
because then inappropriate details are leaking from the
implementation into the abstract model.
>> The point is that there isn't /supposed/ to be a difference
>> between "DD is calls HHH" and "DD is calling HHH1".
>>
>
> You keep thinking in mathematical terms that abstract
> away (thus simply ignore) key differences.
No! I'm specifically pointing out differences in properties
that are not relevant and must not be allowed to make a difference.
Key differences must never be ignored, needless to say.
>
>> We (you, me, anyone else who runs the code) do see a difference.
>> There is no denying that.
>>
>>> HHH and HHH1 both see if the same function is
>>> called from the same machine address with the
>>> same arguments. This is true for HHH(DD) and
>>> not true for HHH1(DD).
>>
>> You believe that HHH1 is a different function from HHH because
>> DDD calls HHH and does not call HHH1.
>
> You really can't be stupid enough to not see the
> different execution trace.
[continued in next message]
--- SoupGate-Win32 v1.05
* Origin: you cannot sedate... all the things you hate (1:229/2)
|
