On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:

On 2025-08-14, olcott <polcott333@gmail.com> wrote:

On 8/14/2025 12:26 PM, Kaz Kylheku wrote:

We all agree that there is a recursive non-halting behavior
pattern.

*By "we all" you are only actually including yourself and myself*
Everyone else here has consistently denied or dodged that point for
the last three years. That is why I needed to pull in some experts
in C.

Are you sure? I mean if HHH uses a simulator to execute DD, which
calls HHH(DD), of course there is runaway recursion and non-halting.

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting Problem
is undecidable.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Thu, 14 Aug 2025 17:11:48 -0500, olcott wrote:

On 8/14/2025 5:08 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:
> On 2025-08-14, olcott <polcott333@gmail.com> wrote:
>> On 8/14/2025 12:26 PM, Kaz Kylheku wrote:
>>> We all agree that there is a recursive non-halting behavior
>>> pattern.
>>>
>>>
>> *By "we all" you are only actually including yourself and myself*
>> Everyone else here has consistently denied or dodged that point
>> for the last three years. That is why I needed to pull in some
>> experts in C.
>
> Are you sure? I mean if HHH uses a simulator to execute DD, which
> calls HHH(DD), of course there is runaway recursion and
> non-halting.
>
>

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the
Halting Problem is undecidable.

/Flibble

I will not speak to you ever again until after you acknowledge the truth
of the above.

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting Problem
is undecidable.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Thu, 14 Aug 2025 17:46:59 -0500, olcott wrote:

On 8/14/2025 5:37 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 17:11:48 -0500, olcott wrote:

On 8/14/2025 5:08 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:
> On 2025-08-14, olcott <polcott333@gmail.com> wrote:
>> On 8/14/2025 12:26 PM, Kaz Kylheku wrote:
>>> We all agree that there is a recursive non-halting behavior
>>> pattern.
>>>
>>>
>> *By "we all" you are only actually including yourself and
>> myself*
>> Everyone else here has consistently denied or dodged that
>> point for the last three years. That is why I needed to pull
>> in some experts in C.
>
> Are you sure? I mean if HHH uses a simulator to execute DD,
> which calls HHH(DD), of course there is runaway recursion and
> non-halting.
>
>

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the
Halting Problem is undecidable.

/Flibble

I will not speak to you ever again until after you acknowledge the
truth of the above.

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the
Halting Problem is undecidable.

/Flibble

I will address no other points until you accept that DD correctly
simulated by HHH matches the *recursive non-halting behavior pattern*

Now that I finally have good evidence that I was gaslighted I will no
longer tolerate it.

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting Problem
is undecidable.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/25 5:46 PM, olcott wrote:

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:

On 2025-08-14, olcott <polcott333@gmail.com> wrote:

On 8/14/2025 12:26 PM, Kaz Kylheku wrote:

We all agree that there is a recursive non-halting behavior pattern.

*By "we all" you are only actually including yourself and myself*
Everyone else here has consistently denied or dodged that point
for the last three years. That is why I needed to pull in some
experts in C.

Are you sure? I mean if HHH uses a simulator to execute
DD, which calls HHH(DD), of course there is runaway recursion
and non-halting.

So, you don't understand the meaning of that?

If HHH actually uses a "correct simulator" then it loses control of
itself and doesn't halt.

It is HHH that becomes non-hatling.

HHH needs to use a CONDITIONAL simulator, and if doing meta-logic on the
call to HHH, realize that it also is doing a CONDITIONAL simulation, and
thus there is no runaway recursion, as HHH will keep it finite.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/25 6:11 PM, olcott wrote:

On 8/14/2025 5:08 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:
  > On 2025-08-14, olcott <polcott333@gmail.com> wrote:
  >> On 8/14/2025 12:26 PM, Kaz Kylheku wrote:
  >>> We all agree that there is a recursive non-halting behavior
  >>> pattern.
  >>>
  >>>
  >> *By "we all" you are only actually including yourself and myself*
  >> Everyone else here has consistently denied or dodged that point for >>>   >> the last three years. That is why I needed to pull in some experts >>>   >> in C.
  >
  > Are you sure? I mean if HHH uses a simulator to execute DD, which
  > calls HHH(DD), of course there is runaway recursion and non-halting. >>>   >

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting
Problem
is undecidable.

/Flibble

I will not speak to you ever again until after
you acknowledge the truth of the above.

Since this is a public group, every thing to say to anyone is said to
everyone.

So, I guess you just promised to just shut your lying mouth shut.

Note, ignoring people just means that you are not even trying to refute
what they say, whicn means any claim you make about no one refuting you
becomes just a lie.

IT doesn't matter if you think they are wrong, when they point out an
error, if you don't respond with new, more basic arguemnts, or quotes to
the accepted sources of truth, you are just accepting the refutations as
having been properly made.

Sorry, your failure to even try to refute so many errors just shows that
you really have nothing to base you claims on other than your own
unprincipled beleifs, and thus are totally baseless lies.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/25 6:46 PM, olcott wrote:

On 8/14/2025 5:37 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 17:11:48 -0500, olcott wrote:

On 8/14/2025 5:08 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
     int Halt_Status = HHH(DD);
     if (Halt_Status)
       HERE: goto HERE;
     return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:
   > On 2025-08-14, olcott <polcott333@gmail.com> wrote:
   >> On 8/14/2025 12:26 PM, Kaz Kylheku wrote:
   >>> We all agree that there is a recursive non-halting behavior >>>>>    >>> pattern.
   >>>
   >>>
   >> *By "we all" you are only actually including yourself and
myself*
   >> Everyone else here has consistently denied or dodged that point >>>>>    >> for the last three years. That is why I needed to pull in some >>>>>    >> experts in C.
   >
   > Are you sure? I mean if HHH uses a simulator to execute DD, which >>>>>    > calls HHH(DD), of course there is runaway recursion and
   > non-halting.
   >
   >

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the
Halting Problem is undecidable.

/Flibble

I will not speak to you ever again until after you acknowledge the truth >>> of the above.

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting
Problem
is undecidable.

/Flibble

I will address no other points until you accept
that DD correctly simulated by HHH matches the
*recursive non-halting behavior pattern*

Now that I finally have good evidence that I was
gaslighted I will no longer tolerate it.

And we will only accept that whem you acknoledge that this eans that
*IS* the HHH you are talking about, and thus your HHH fails to answer.

Change HHH to abort, and you change the input, and that behavior no
longer holds, and you claim becomes a lie.

You either have ONE HHH, and ONE DD, and it has the behavior specified
(which makes it a non-decider)

or you accept that you are talking about a set of different HHH, each
one looking at one member of a set of different DDs, each with its own behavior, and thus you can't assume the behavior of one pair from the
behavior of a different one.

This makes your statement irrelevent, as the HHH that answers has a
different DD as its input then the DD you proved to be non-halting.

To have a set of HHH, but a single DD just says you have a category
error in your logic, and thus it is just a damning lie.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/14/25 6:53 PM, olcott wrote:

On 8/14/2025 5:51 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 17:46:59 -0500, olcott wrote:

On 8/14/2025 5:37 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 17:11:48 -0500, olcott wrote:

On 8/14/2025 5:08 PM, Mr Flibble wrote:

On Thu, 14 Aug 2025 16:46:52 -0500, olcott wrote:

int DD()
{
      int Halt_Status = HHH(DD);
      if (Halt_Status)
        HERE: goto HERE;
      return Halt_Status;
}

On 8/14/2025 1:38 PM, Kaz Kylheku wrote:
    > On 2025-08-14, olcott <polcott333@gmail.com> wrote:
    >> On 8/14/2025 12:26 PM, Kaz Kylheku wrote:
    >>> We all agree that there is a recursive non-halting behavior >>>>>>>     >>> pattern.
    >>>
    >>>
    >> *By "we all" you are only actually including yourself and >>>>>>>     >> myself*
    >> Everyone else here has consistently denied or dodged that >>>>>>>     >> point for the last three years. That is why I needed to pull >>>>>>>     >> in some experts in C.
    >
    > Are you sure? I mean if HHH uses a simulator to execute DD, >>>>>>>     > which calls HHH(DD), of course there is runaway recursion and >>>>>>>     > non-halting.
    >
    >

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the >>>>>> Halting Problem is undecidable.

/Flibble

I will not speak to you ever again until after you acknowledge the
truth of the above.

If the decision of HHH(DD) is non-halting then DD() will do the
opposite thus proving that HHH is incorrect and confirming that the
Halting Problem is undecidable.

/Flibble

I will address no other points until you accept that DD correctly
simulated by HHH matches the *recursive non-halting behavior pattern*

Now that I finally have good evidence that I was gaslighted I will no
longer tolerate it.

If the decision of HHH(DD) is non-halting then DD() will do the opposite
thus proving that HHH is incorrect and confirming that the Halting
Problem
is undecidable.

/Flibble

That is incorrect yet you will not be able to understand
that it is incorrect until after you first understand
this post.

No, YOU are incorrect, and won't be able to understand what you are
talking about until you accept that you need to learn the actual meaning
of the words you use as defined by the system, and not just presume you
are "God" with the power to change the unchangable.

If you want to be "God" of your system, you need to begin by actually
doing the work to create it, and then see if anyone cares to come to you garbage heap, as it seems it will be from how many contradictions you
try to put into your system.

Sorry, you can't alter what wasn't yours to begin with.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)