On 8/2/25 2:46 PM, olcott wrote:
On 8/2/2025 1:19 PM, joes wrote:
Am Sat, 02 Aug 2025 10:03:10 -0500 schrieb olcott:
On 8/2/2025 4:38 AM, Fred. Zwarts wrote:
Op 02.aug.2025 om 04:09 schreef olcott:
On 8/1/2025 8:01 PM, Mr Flibble wrote:
Olcott, give it a fucking rest: what you are banging on about has
nothing to do with the Halting Problem.
Damon, stop feeding Olcott: you are just talking over each other at >>>>>> this point.
I'll have to agree with you on this one.
Every attempt to refute me has been counter-factual.
The survival of life an Earth depends on a correct understanding of
truth.
You are literally deluded.
As usual incorrect claims without evidence.
I am not going to repeat all of the lines of my proof every single time.
Thank you.
A finite recursion is not a non-halting behaviour.
Finite recursion by itself is not non-halting behavior.
Finite recursion that correctly detects a pattern that would infinitely
repeat *IS NON-HALTING BEHAVIOR*
...if you change what the "HHH" that DDD calls refers to.
You are trying to get away with the idea that if you close your eyes
for the halting behaviour, it does not exists.
Not at all. I repeatedly challenge you to show how DDD emulated by HHH
halts and you change the subject.
Change it to what?
I say DDD correctly emulated by HHH does not halt
and Richard says no I am wrong the directly executed
DDD() does halt. He has done this hundreds of times.
But the problem is, if that WERE true, then HHH doesn't answer, as so
wasn't a correct halt decider either.
And it is a DIFFERENT DDD that the HHH that aborts sees, because DDD
needs to be a PROGRAM, and thus include the code of the HHH that you are claiming to get the right answer, or you are just lying that you are
following the pattern.
Once we do that, then you statement is a lie, as now "the" HHH doesn't
do that to "the" DDD.
All you are doing is showing that you think you are allowed to LIE when
you do logic, and thus that you LIE about your ultimate goal.
The simulating HHH aborts before it reaches the final halt state of the >>>> simulated HHH that has the same code to abort, so it does not see it
and pretends that it does not exist.
Each HHH aborts as soon as it has seen one recursive simulation.
Each? The simulating and the simulated HHH?
_DDD()
[0000219e] 55 push ebp
[0000219f] 8bec mov ebp,esp
[000021a1] 689e210000 push 0000219e
[000021a6] e843f4ffff call 000015ee
[000021ab] 83c404 add esp,+04
[000021ae] 5d pop ebp
[000021af] c3 ret
Size in bytes:(0018) [000021af]
Not a valid input until the code of HHH is added to it, which makes each
HHH get a different DDD.
Within the infinite set of HHH/DDD pairs such that
each HHH emulates one element of the sequence of natural
numbers instructions of DDD no DDD element each reaches
past its own machine address [000021a6].
Which doesn't matter, as the test is does the program the input
represent reach a final state, which it does (as long as the selected
HHH returns an answer).
All you are doing is showing that you think LYING is valid, as you try
to use a strawman of the partial simulation of DDD to be its behavior,
and to say that all the DDD are "the same" when they are different.
We could change this to each HHH aborts after it sees N recursive
simulations. In every case the outer HHH meets its criteria first.
If this HHH waited for the next, they would all wait for the next and no >>> abort would ever occur.
Sure, but those are different programs. DDD calls a simulator that aborts
after two levels, no matter what you simulate it with.
When we examine the infinite set of HHH/DDD pairs
and HHH is a simulating termination analyzer it
would be correct for HHH to abort its simulation
as soon as it sees that DDD calls itself HHH(DDD).
Nope. That is just your lie.
If HHH does that, then the "behavior" of the input, which is DEFINED to
be the behavior of the program it represents, will halt, as that DDD
calls a HHH(DDD) that returns 0 to it.
Again, all you are doing is proving you think LYING is valid logic as
you think you get to change the meaning of words, which is just one form
of lying.
I have HHH emulate DDD all over again because
people here can hardly pay any attention at all
so I have to make a point totally obvious before
they have any chance of understanding.
No, you do it as you have run out of ideas of how to lie about what you
are doing, so trying to make an obvious lie to hide your real lie,
Sorry, all you have done is prove that you are just a stupid liar that
doesn't know the meaning of the words he uses, but just makes up what he
wants, and tries to call it the truth, when it is just a lie.
I don't change the meaning of words. I [...]
correct the definitions of the meaning
of words when these definitions directly contradict other definitions.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)