Infinite recursion detection criteria (Please correct me if I am

[olcott]

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the
execution trace shows no conditional branch instructions in Y() or
function call returns in X() then the function call from Y() to X() is
infinitely recursive unless X() stops it.

The referenced excution trace is on x86 machine language, disassembled
for human consumption.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

[MrSpo...@rw5_r42g0rzmn7wwf3izpl4.biz]

On Sat, 17 Apr 2021 09:15:14 -0500
olcott <No...@nospicedham.NoWhere.com> wrote:
>Copyright 2021 Pete Olcott

Pretentious twat.

[olcott]

ad hominem the favorite reply of ignoramuses.

[MrSpook...@4t98owsqx2nlg6yp.com]

On Sat, 17 Apr 2021 10:22:47 -0500
olcott <No...@NoWhere.com> wrote:
>On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>> On Sat, 17 Apr 2021 09:15:14 -0500
>> olcott <No...@nospicedham.NoWhere.com> wrote:
>>> Copyright 2021 Pete Olcott
>>
>> Pretentious twat.
>>
>
>ad hominem the favorite reply of ignoramuses.
>

>Copyright 2021 Pete Olcott
>
>"Great spirits have always encountered violent opposition from mediocre
>minds." Einstein

Self aggrandisement, the favourite approach of Dunning-Kruger types.

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:
> On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>> On Sat, 17 Apr 2021 09:15:14 -0500
>> olcott <No...@nospicedham.NoWhere.com> wrote:
>>> Copyright 2021 Pete Olcott
>>
>> Pretentious twat.
>
> ad hominem the favorite reply of ignoramuses.

I see you have not yet read the exellent article:

https://laurencetennant.com/bonds/adhominem.html

[olcott]

On 4/17/2021 9:15 AM, olcott wrote:
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the
> execution trace shows no conditional branch instructions in Y() or
> function call returns in X() then the function call from Y() to X() is
> infinitely recursive unless X() stops it.
>

> The referenced execution trace is on x86 machine language, disassembled
> for human consumption.
>

When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is
invoking X() in infinite recursion. On this basis it can stop simulating
Y() and report that Y() would not halt unless its execution was aborted
by Halts().

void Y(u32 P)
Halts(P, P);
}


int main()
{
Halts((u32)Y, (u32)Y);
}


_Y()
[000009ac](01) 55 push ebp
[000009ad](02) 8bec mov ebp,esp
[000009af](03) 8b4508 mov eax,[ebp+08]
[000009b2](01) 50 push eax
[000009b3](03) 8b4d08 mov ecx,[ebp+08]
[000009b6](01) 51 push ecx
[000009b7](05) e840feffff call 000007fc
[000009bc](03) 83c408 add esp,+08
[000009bf](01) 5d pop ebp
[000009c0](01) c3 ret
Size in bytes:(0021) [000009c0]

_main()
[000009cc](01) 55 push ebp
[000009cd](02) 8bec mov ebp,esp
[000009cf](05) 68ac090000 push 000009ac
[000009d4](05) 68ac090000 push 000009ac
[000009d9](05) e81efeffff call 000007fc
[000009de](03) 83c408 add esp,+08
[000009e1](02) 33c0 xor eax,eax
[000009e3](01) 5d pop ebp
[000009e4](01) c3 ret
Size in bytes:(0025) [000009e4]

===============================
....[000009cc][00011278][00000000](01) 55 push ebp
....[000009cd][00011278][00000000](02) 8bec mov ebp,esp
....[000009cf][00011274][000009ac](05) 68ac090000 push 000009ac
....[000009d4][00011270][000009ac](05) 68ac090000 push 000009ac
....[000009d9][0001126c][000009de](05) e81efeffff call 000007fc
Begin Local Halt Decider Simulation at Machine Address:9ac
....[000009ac][00031318][0003131c](01) 55 push ebp
....[000009ad][00031318][0003131c](02) 8bec mov ebp,esp
....[000009af][00031318][0003131c](03) 8b4508 mov
eax,[ebp+08]
....[000009b2][00031314][000009ac](01) 50 push eax
....[000009b3][00031314][000009ac](03) 8b4d08 mov
ecx,[ebp+08]
....[000009b6][00031310][000009ac](01) 51 push ecx
....[000009b7][0003130c][000009bc](05) e840feffff call 000007fc
....[000009ac][0007bd40][0007bd44](01) 55 push ebp
....[000009ad][0007bd40][0007bd44](02) 8bec mov ebp,esp
....[000009af][0007bd40][0007bd44](03) 8b4508 mov
eax,[ebp+08]
....[000009b2][0007bd3c][000009ac](01) 50 push eax
....[000009b3][0007bd3c][000009ac](03) 8b4d08 mov
ecx,[ebp+08]
....[000009b6][0007bd38][000009ac](01) 51 push ecx
....[000009b7][0007bd34][000009bc](05) e840feffff call 000007fc
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
....[000009de][00011278][00000000](03) 83c408 add esp,+08
....[000009e1][00011278][00000000](02) 33c0 xor eax,eax
....[000009e3][0001127c][00010000](01) 5d pop ebp
....[000009e4][00011280][00000058](01) c3 ret
Number_of_User_Instructions(23)
Number of Instructions Executed(16920)
sizeof(Decoded_Line_Of_Code)(24)

[olcott]

directed against a person’s character rather than their argument
https://www.oxfordlearnersdictionaries.com/us/definition/english/ad-hominem

[olcott]

On 4/17/2021 10:41 AM, Kaz Kylheku wrote:

(of a criticism, etc.) directed against a person, rather than against
what that person says:
https://dictionary.cambridge.org/us/dictionary/english/ad-hominem

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:
> On 4/17/2021 10:41 AM, Kaz Kylheku wrote:
>> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>> On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>>>> On Sat, 17 Apr 2021 09:15:14 -0500
>>>> olcott <No...@nospicedham.NoWhere.com> wrote:
>>>>> Copyright 2021 Pete Olcott
>>>>
>>>> Pretentious twat.
>>>
>>> ad hominem the favorite reply of ignoramuses.
>>
>> I see you have not yet read the exellent article:
>>
>> https://laurencetennant.com/bonds/adhominem.html
>>
>
> (of a criticism, etc.) directed against a person, rather than against
> what that person says:
> https://dictionary.cambridge.org/us/dictionary/english/ad-hominem

What the dictionary says isn't incorrect, but it doesn't give the full
treatment of the /ad hominem/ fallacy.

I see you have not yet read the exellent article:

https://laurencetennant.com/bonds/adhominem.html

"ad hominem" is not simply a Latin phrase that means "personal attack".

It is the logical fallacy of refuting (or accepting) an argument based
on who is saying it, or that person's characteristics, rather than the
argument's content.

"Pretentious twat" is not inherently ad hominem, though it's a personal
attack.

"Your argument is incorrect because only a pretentius twat would think
such a thing" is almost certainly ad hominem.

"Your argument is incorrect because [... excellent logical reasons],
and you're only making such mistakes because you're a pretentious twat"
is not ad hominem. The argument is addressed techncially, with
an additional hypothesis about why the argument is wrong,
with an embedded personal attack.

Just read the article; there are lot of good points and subtleties.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

[olcott]

On 4/17/2021 12:25 PM, Kaz Kylheku wrote:
> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>> On 4/17/2021 10:41 AM, Kaz Kylheku wrote:
>>> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>>> On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>>>>> On Sat, 17 Apr 2021 09:15:14 -0500
>>>>> olcott <No...@nospicedham.NoWhere.com> wrote:
>>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> Pretentious twat.
>>>>
>>>> ad hominem the favorite reply of ignoramuses.
>>>
>>> I see you have not yet read the exellent article:
>>>
>>> https://laurencetennant.com/bonds/adhominem.html
>>>
>>
>> (of a criticism, etc.) directed against a person, rather than against
>> what that person says:
>> https://dictionary.cambridge.org/us/dictionary/english/ad-hominem
>
> What the dictionary says isn't incorrect, but it doesn't give the full
> treatment of the /ad hominem/ fallacy.
>
> I see you have not yet read the exellent article:
>

Yes is one trusts articles by Joe Blow then one can become convinced
that Trump got ten times more than all the votes and the covid-19 virus
is faked by the CIA beaming fake thoughts into our brains.

> https://laurencetennant.com/bonds/adhominem.html
>
> "ad hominem" is not simply a Latin phrase that means "personal attack".
>

ad hominem
c. 1600, Latin, literally "to a man," from ad "to" (see ad-) + hominem,
accusative of homo "man" (see homunculus). Hence, "to the interests and
passions of the person." Originally an argument or appeal to the known
preferences or principles of the person addressed, rather than to
abstract truth or logic.
https://www.etymonline.com/word/ad%20hominem

> It is the logical fallacy of refuting (or accepting) an argument based
> on who is saying it, or that person's characteristics, rather than the
> argument's content.
>
> "Pretentious twat" is not inherently ad hominem, though it's a personal
> attack.
>

It was a direct reply to my request for critique thus making it ad hominem.

[olcott]

It is at the bottom of the most fallacious instances argumentation.

https://en.wikipedia.org/wiki/Ad_hominem#Fallacious_types_of_ad_hominem_arguments

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:
> On 4/17/2021 12:25 PM, Kaz Kylheku wrote:
>> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>> On 4/17/2021 10:41 AM, Kaz Kylheku wrote:
>>>> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>>>> On 4/17/2021 10:16 AM, MrSpook__k@rw5_r42g0rzmn7wwf3izpl4.biz wrote:
>>>>>> On Sat, 17 Apr 2021 09:15:14 -0500
>>>>>> olcott <No...@nospicedham.NoWhere.com> wrote:
>>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> Pretentious twat.
>>>>>
>>>>> ad hominem the favorite reply of ignoramuses.
>>>>
>>>> I see you have not yet read the exellent article:
>>>>
>>>> https://laurencetennant.com/bonds/adhominem.html
>>>>
>>>
>>> (of a criticism, etc.) directed against a person, rather than against
>>> what that person says:
>>> https://dictionary.cambridge.org/us/dictionary/english/ad-hominem
>>
>> What the dictionary says isn't incorrect, but it doesn't give the full
>> treatment of the /ad hominem/ fallacy.
>>
>> I see you have not yet read the exellent article:
>>
>
> Yes is one trusts articles by Joe Blow then one can become convinced
> that Trump got ten times more than all the votes and the covid-19 virus
> is faked by the CIA beaming fake thoughts into our brains.

Aha, that's an ad hominem argument.

>
>> https://laurencetennant.com/bonds/adhominem.html
>>
>> "ad hominem" is not simply a Latin phrase that means "personal attack".
>>
>
> ad hominem
> c. 1600, Latin, literally "to a man," from ad "to" (see ad-) + hominem,

Thank you for the Latin lesson, Cicero.

Today when we say /ad hominem/ we are referring specifically to the ad
hominem fallacy, and not to just any personal attack.

https://en.wikipedia.org/wiki/Ad_hominem

You're not using the term right.

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>
>> "Pretentious twat" is not inherently ad hominem, though it's a personal
>> attack.
>
> It is at the bottom of the most fallacious instances argumentation.
>
> https://en.wikipedia.org/wiki/Ad_hominem#Fallacious_types_of_ad_hominem_arguments

I don't know what you're looking at, but I see in that section of the
page a very clear pyramid diagram.

In that diagram, the bottom layer is "name calling".
"Ad hominem" is immediately above it, second from bottom.

I.e. ad hominem is distinct from name calling.

(Do you have any other URL you are confused about that you'd like me
or anyone else to explain, in the Wikipedia or elsewhere?)

[olcott]

On 4/17/2021 1:37 PM, Kaz Kylheku wrote:
> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>>
>>> "Pretentious twat" is not inherently ad hominem, though it's a personal
>>> attack.
>>
>> It is at the bottom of the most fallacious instances argumentation.
>>
>> https://en.wikipedia.org/wiki/Ad_hominem#Fallacious_types_of_ad_hominem_arguments
>
> I don't know what you're looking at, but I see in that section of the
> page a very clear pyramid diagram.
>
> In that diagram, the bottom layer is "name calling".
> "Ad hominem" is immediately above it, second from bottom.
>
> I.e. ad hominem is distinct from name calling.
>
> (Do you have any other URL you are confused about that you'd like me
> or anyone else to explain, in the Wikipedia or elsewhere?)
>

On the validity versus fallaciousness hierarchy name calling is more
fallacious than ad hominem. When name calling is the reply to a request
for critique this makes name calling also a form of ad hominem.

[olcott]

On 4/17/2021 10:41 AM, Kaz Kylheku wrote:

In any case back to the actual point the following <is> confirmed to be
correct halt deciding criteria in the case of infinite recursion.

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the

execution trace shows no conditional branch instructions in Y() or a
function call returns from X() then the function call from Y() to X() is

infinitely recursive unless X() stops it.

The referenced execution trace is on x86 machine language, disassembled
for human consumption.

When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is
invoking X() in infinite recursion.

On this basis Halts() can stop simulating Y() and report that Y() would

not halt unless its execution was aborted by Halts().

void Y(u32 P)
{
Halts(P, P);
}


int main()
{
Halts((u32)Y, (u32)Y);
}

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:
> On 4/17/2021 1:37 PM, Kaz Kylheku wrote:
>> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>>>>
>>>> "Pretentious twat" is not inherently ad hominem, though it's a personal
>>>> attack.
>>>
>>> It is at the bottom of the most fallacious instances argumentation.
>>>
>>> https://en.wikipedia.org/wiki/Ad_hominem#Fallacious_types_of_ad_hominem_arguments
>>
>> I don't know what you're looking at, but I see in that section of the
>> page a very clear pyramid diagram.
>>
>> In that diagram, the bottom layer is "name calling".
>> "Ad hominem" is immediately above it, second from bottom.
>>
>> I.e. ad hominem is distinct from name calling.
>>
>> (Do you have any other URL you are confused about that you'd like me
>> or anyone else to explain, in the Wikipedia or elsewhere?)
>>
>
> On the validity versus fallaciousness hierarchy name calling is more

This is a term you made up.

What we are actually looking at is "Paul Graham's hierarchy of
disagreement", not "validity versus fallaciousness hierarchy".

> fallacious than ad hominem.

There is no such thing as "more fallacious". Any argument that is false
due to any error of inference is exactly as false (and thus fallacious)
as any other.

Name calling isn't an argument; therefore we might say that it's "not
even fallacious".

However, name calling can actually be true. It's not true to the
argument, but it can be separately true on its won.

For instance, there is considerable evidence that you are a pretentious
twat, and the supply of this evidence grows by the hour thanks to your
dogged effort to climb to the top of the heap of pretentious twats.

Calling you a pretentious twat is definitely name calling, but at the
same time isn't fallacious in any way.

Though the name calling isn't fallacious, it would be /ad hominem/ to
say that a statement of yours is incorrect because you're a
pretentious twat. (Nobody did that, though).

Moreover, it is not /ad hominem/ due to "pretentious twat" being name
calling. Ad hominem does not require name calling. If you try to attack
a speaker's argument by saying it is wrong due to any attribute of
theirs rather than the argument's content, that is argumentio ad
hominem. That attribute may have nothing to do with name calling.
Ad hominem can be civil. For instance, "I respectfully disagree with
your idea because you don't have a university degree in the subject
matter" is ad hominem. The speaker didn't consider the idea at all,
only the background of the idea's proponent. Moreover, that part
of it may even be true; the proponent really doesn't have that
background.

You didn't read the fine article I recommended. I promise you
that it is entertaining!

https://laurencetennant.com/bonds/adhominem.html

[olcott]

Can we get back to the actual point or are you afraid to do this because
when a point is correct there is no basis for rebuttal?

The halt deciding principle

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the
execution trace shows no conditional branch instructions in Y() or

function call returns from X() then the function call from Y() to X() is

infinitely recursive unless X() stops it.

[Real Troll]

On 17/04/2021 20:23, olcott wrote:
>
>
> The halt deciding principle
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the
> execution trace shows no conditional branch instructions in Y() or
> function call returns from X() then the function call from Y() to X()
> is infinitely recursive unless X() stops it.
>

Does this not depend on what the functions are doing? If the function
gets a value and uses it for something else then as far as I can see
that's it. If you call the same function second time then it will do
the same [again]. Either use the value or simply ignores it and stops. 
I am not sure what has this got to do with recursion? Have you got a
concrete example to try it?

Cross posting to comp.theory removed as it has nothing to do on my machine!!

[olcott]

I am trying to make a halt decider that can correctly detect infinite
recursion. Here are some more key details:

When Halts() uses an x86 emulator to simulate its input and maintains an
execution trace of this emulation then it can examine this execution
trace according to the above criteria and correctly decide that Y() is

invoking X() in infinite recursion. On this basis it can stop simulating

Y() and report that Y() would not halt unless its execution was aborted
by Halts().


void Y(u32 P)
{
Halts(P, P);
}


int main()
{
Halts((u32)Y, (u32)Y);
}

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf

[Malcolm McLean]

On Saturday, 17 April 2021 at 20:14:18 UTC+1, Kaz Kylheku wrote:
> On 2021-04-17, olcott <No...@NoWhere.com> wrote:
>
> >
> > On the validity versus fallaciousness hierarchy name calling is more
> This is a term you made up.
>
> What we are actually looking at is "Paul Graham's hierarchy of
> disagreement", not "validity versus fallaciousness hierarchy".
>
> > fallacious than ad hominem.
>
> There is no such thing as "more fallacious". Any argument that is false
> due to any error of inference is exactly as false (and thus fallacious)
> as any other.
>

Firstly, you have to adopt most of the famous logical fallacies as
a mode for everyday life. If a well-respected scientist fails to replicate
a published result, the paper is seriously under question. If a high school
student fails to do the same, that carries little or no weight. Otherwise
scientists would be constantly chasing their tails following false leads
from beginners.

Then dismissing a startling claim from a person with a history of making
similar claims with poor evidence isn't the same as dismissing a fairly
modest claim from someone with a reputation in the field, but maybe whom
you don't like. It's the same underlying fallacy, but the second is a higher dose
and far more likely to lead to a false conclusion.

[olcott]

It seems to me that everyone dodges this point because I am correct

The halt deciding principle for infinite recursion

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the

execution trace shows no conditional branch instructions in Y() or a

function call returns from X() then the function call from Y() to X() is

infinitely recursive unless X() stops it.

http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf

[Malcolm McLean]

You're talking about mutually recursive X() and Y()? Y calls X, calls Y,
calls X again and so on? Obviously eventually either X or Y must
return without making the call, or it will go on forever.

But in fact in your system, one function emulates another. Which means that
behaviour can be slightly different. We can stop the emulation when certain
criteria are met.

[olcott]

The question is whether or not the above criteria would be correct halt
deciding criteria for X() to decide not halting on Y().

[Kaz Kylheku]

On 2021-04-17, olcott <No...@nospicedham.NoWhere.com> wrote:
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the
> execution trace shows no conditional branch instructions in Y() or

The problem is, the execution trace only shows no such instructions
because you have concealed them. You have declared that X is part
of the "operating system" and not part of the test case.
So in your trace there is an illegal discontinuity. There is a JSR Halts
instruction executed, but then the next instruction which is traced
is not inside Halts, but inside H_Hat. The address does not match.

> function call returns in X() then the function call from Y() to X() is
> infinitely recursive unless X() stops it.

Problem is, the above decision about the traces is being made by X
itself. It is accessing these global tracers, which make X not a
function, but an imperative procedure.

Below is a quote from the following idiotic document:

http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf

Note how after every "call 00000833", the next instruction being traced is
not 00000833, but 00000A63. A63 is _H_Hat.

The document does not reveal the disassembly of code at 833, so we have no
idea what instructions are there. However, those instructions have to do
with the decision that leads to "Infinite Recursion Detected", which is not
possible without conditionals.

(01)[00000a93][000114f7][00000000] (01) 55 push ebp
(02)[00000a94][000114f7][00000000] (02) 8bec mov ebp,esp
(03)[00000a96][000114f3][00000000] (01) 51 push ecx
(04)[00000a97][000114ef][00000a63] (05) 68630a0000 push 00000a63
(05)[00000a9c][000114eb][00000a63] (05) 68630a0000 push 00000a63
(06)[00000aa1][000114e7][00000aa6] (05) e8ddfdffff call 00000883
(07)[00000a63][00031577][0003157b] (01) 55 push ebp
(08)[00000a64][00031577][0003157b] (02) 8bec mov ebp,esp
(09)[00000a66][00031573][00021547] (01) 51 push ecx
(10)[00000a67][00031573][00021547] (03) 8b4508 mov eax,[ebp+08]
(11)[00000a6a][0003156f][00000a63] (01) 50 push eax
(12)[00000a6b][0003156f][00000a63] (03) 8b4d08 mov ecx,[ebp+08]
(13)[00000a6e][0003156b][00000a63] (01) 51 push ecx
(14)[00000a6f][00031567][00000a74] (05) e80ffeffff call 00000883
(15)[00000a63][0004271f][00042723] (01) 55 push ebp
(16)[00000a64][0004271f][00042723] (02) 8bec mov ebp,esp
(17)[00000a66][0004271b][000326ef] (01) 51 push ecx
(18)[00000a67][0004271b][000326ef] (03) 8b4508 mov eax,[ebp+08]
(19)[00000a6a][00042717][00000a63] (01) 50 push eax
(20)[00000a6b][00042717][00000a63] (03) 8b4d08 mov ecx,[ebp+08]
(21)[00000a6e][00042713][00000a63] (01) 51 push ecx
(22)[00000a6f][0004270f][00000a74] (05) e80ffeffff call 00000883

Infinite Recursion Detected Simulation Stopped

[Bonita Montero]

STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!
STOP POSTING IN comp.lang.c/c++ !!!

[olcott]

On 4/17/2021 10:01 AM, Kaz Kylheku wrote:
> On 2021-04-17, olcott <No...@nospicedham.NoWhere.com> wrote:
>> If a function X() is called by function Y() twice in sequence from the
>> same machine address of Y() with the same parameters to X() and the
>> execution trace shows no conditional branch instructions in Y() or
>
> The problem is, the execution trace only shows no such instructions
> because you have concealed them.

You are responding with boiler-plate that does not account for my
reconfiguration.

A halt deciding principle that detects infinite recursion

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the

execution trace shows no conditional branch instructions in Y() or a

function call returns from X() then the function call from Y() to X() is

infinitely recursive unless X() stops it.

The above specification need not look inside X() at all as long is we
have the assurance that the execution trace of X() does not include any
"ret" instructions. I modified my halt decider to makes sure that this
part works correctly.

[olcott]

On 4/17/2021 5:03 PM, Bonita Montero wrote:
> STOP POSTING IN comp.lang.c/c++ !!!

KNOW !!!

[olcott]

On 4/17/2021 10:01 AM, Kaz Kylheku wrote:

> On 2021-04-17, olcott <No...@nospicedham.NoWhere.com> wrote:
>> If a function X() is called by function Y() twice in sequence from the
>> same machine address of Y() with the same parameters to X() and the
>> execution trace shows no conditional branch instructions in Y() or
>
> The problem is, the execution trace only shows no such instructions
> because you have concealed them.

You are responding with boiler-plate that does not account for my
reconfiguration.

A halt deciding principle that detects infinite recursion

If a function X() is called by function Y() twice in sequence from the
same machine address of Y() with the same parameters to X() and the

execution trace shows no conditional branch instructions in Y() or a

function call returns from X() then the function call from Y() to X() is

infinitely recursive unless X() stops it.

The above specification need not look inside X() at all as long is we
have the assurance that the execution trace of X() does not include any
"ret" instructions. I modified my halt decider to makes sure that this
part works correctly.

[R Kym Horsell]

In comp.theory Moplessly Confused olcott <No...@nospicedham.nowhere.com> wrote:
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the

Dont forget "all the memory is the same". In the case of
a TM that's a bit of countable testing.

> execution trace shows no conditional branch instructions in Y() or

> function call returns in X() then the function call from Y() to X() is

> infinitely recursive unless X() stops it.

> The referenced excution trace is on x86 machine language, disassembled
> for human consumption.

Blary blaghdy blahdee.

[Kaz Kylheku]

No, I do not agree. If the execution trace shows no conditional branch
instructions, then the situation is runaway recursive, period.
Nothing will stop it but stack exhaustion.

X doesn't do anything such as making a decision to terminate. If it did,
that would contradict the assumption that there are no conditional
instructions being executed in the recursive loop.

In your implementation of this, there are gaps in the instruction trace.
Y (called _H_Hat) invokes X (_Halts) via a CALL 00000883 instruction.
But the next element in the trace is not the address 00000833 which was
called, but, unexpectedy, but the address of _H_Hat itself, 00000a63.

There is a "trace black out" starting with 00000833 until 00000a63.

Your document also does not not show the disassembly listing of the
procedure at 00000833.

(I suspect that CALL 0000833 isn't a function call at all; the simulator
is rigged to recognize this address. You've hinted at the fact that
_Halts is a built-in simulation primitive and not an actual function.)

What you must do is provide a complete diassembly listing of all code
that is invoked. That code must be executed in accordance with the x86
instruction set architecture from Intel without any sneaky extensions.
There must be no puzzing gaps in the execution traces. If there is a
CALL X, the next instruction to be traced must be X.

You must also trace the value of every register. I.e add columns to the
trace for EAX, EBX, ... to show nothing is messing with their contents.
Just like your current trace has a surprising discontinuity in the EIP
register, any other register could have a surprising change not
reflected in what the instructions are doing.

[Kaz Kylheku]

On 2021-04-17, olcott <No...@NoWhere.com> wrote:

> On 4/17/2021 10:01 AM, Kaz Kylheku wrote:
>> On 2021-04-17, olcott <No...@nospicedham.NoWhere.com> wrote:
>>> If a function X() is called by function Y() twice in sequence from the
>>> same machine address of Y() with the same parameters to X() and the
>>> execution trace shows no conditional branch instructions in Y() or
>>
>> The problem is, the execution trace only shows no such instructions
>> because you have concealed them.
> You are responding with boiler-plate that does not account for my
> reconfiguration.
>
> A halt deciding principle that detects infinite recursion
> If a function X() is called by function Y() twice in sequence from the
> same machine address of Y() with the same parameters to X() and the
> execution trace shows no conditional branch instructions in Y() or a
> function call returns from X() then the function call from Y() to X() is
> infinitely recursive unless X() stops it.

Correction: "execution trace shows no conditional branch instructions
anywhere; not in Y, not in X"

continue ...