XPost: sci.logic

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation
reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Which you H doesn't meet, since the definition of "Correct Simulation"
here (as for most people) is a simulation that exactly reproduces the
behavior of the full program the input represents, which means a
simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of those
would do (since it would halt since you H returns 0) so you CAN'T
correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is correctly
answering your non-halt-deciding question. In other words, it is a
correct POOP decide.r

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not halted.  That much is a truism.

*Ben fails to understand this*
If HHH reported that it did not need to abort DDD
before it aborted DDD then HHH would be lying.

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

XPost: sci.logic

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation
reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Which you H doesn't meet, since the definition of "Correct Simulation"
here (as for most people) is a simulation that exactly reproduces the
behavior of the full program the input represents, which means a
simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of those
would do (since it would halt since you H returns 0) so you CAN'T
correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is correctly
answering your non-halt-deciding question.  In other words, it is a
correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

Ben disagrees with the second part because Ben fails to understand
that HHH cannot correctly report that DDD would stop running until
after HHH forces DDD to stop running.

No, HE understand that HHH to be a halt decider MUST correctly report
that DDD will stop running since HHH(DDD) returns.

YOU are the one that doesn't understand the problem.

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is not me.

Something you don't understand, maybe because you sold your free will
and got a deterministic program instead.

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

XPost: sci.logic

On 7/8/24 8:47 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are deterministic,
and their behavior is fully establish when they are written, and
running or simulating them is only a way to observe that behavior, >>>>>> and the only CORRECT observation of all the behavior, so letting
that operation reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>      If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that exactly
reproduces the behavior of the full program the input represents,
which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of
those would do (since it would halt since you H returns 0) so you
CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is correctly
answering your non-halt-deciding question.  In other words, it is a
correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

He literally agrees with MY meanings that the "if" has
been fulfilled.

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not halted.  That much is a truism.

Yes, Ben agrees that with your meaning that your statement, which isn't
about halting, is true. In other words, you have a decider H that
corrected determined that P doesn't POOP.

You HAVEN'T satisfied Professor Sipser statement, as that uses the
proper definition of correct simulation, and you don't meet that, so you
can't claim correct halt deciding.

That you are so dumb as to not understand that just shows how dumb you are.

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

XPost: sci.logic

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is
not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

You just don't understand causality.

Because DDD and HHH are deterministic programs, if HHH reports ANY
behavior for DDD, then DDD will halt.

HHH can't see that, but that doens't make it not true.

HHH just has to live with partial results to keep from getting stuck,
and then it needs to guess, and it seems you made it guess wrong.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

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

XPost: sci.logic

On 7/8/24 9:38 PM, olcott wrote:

On 7/8/2024 8:30 PM, Richard Damon wrote:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is
not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

The way that IT DOES report something while it is still
running. You love to disagree with verified facts.

Computation can not report answers while running.

YOu are just showing your stupidity.

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

XPost: sci.logic

On 7/8/24 9:23 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are deterministic,
and their behavior is fully establish when they are written, and
running or simulating them is only a way to observe that behavior, >>>>>> and the only CORRECT observation of all the behavior, so letting
that operation reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>      If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that exactly
reproduces the behavior of the full program the input represents,
which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of
those would do (since it would halt since you H returns 0) so you
CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is correctly
answering your non-halt-deciding question.  In other words, it is a
correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

Ben disagrees with the second part because Ben fails to understand
that HHH cannot correctly report that DDD would stop running until
after HHH forces DDD to stop running.

No, HE understand that HHH to be a halt decider MUST correctly report
that DDD will stop running since HHH(DDD) returns.

YOU are the one that doesn't understand the problem.

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is
not me.

Something you don't understand, maybe because you sold your free will
and got a deterministic program instead.

*Free will does not make lies into truth*

If HHH reports that it does not need to abort
DDD before it aborts DDD then HHH is a liar.

No, It COULD report that it has determined that it doesn't NEED to abort
its simulation, but does so anyway. Nothing says HHH MUST simulate to
the end if it can determine the right answwer sooner.

The problem is that HHH doesn't know that is true, as it doesn't know
what DDD will do after HHH returns to it, so all it can do is guess.

If you need groceries and report that you don't
need groceries before you get more groceries then
you are a liar.

No, I can not NEED groceries, but still go to the store and get somee
things I WANT (but don't need). It might be a hot day and I want a fresh
flavor of Ice Cream for that day. I don't NEED it, as I have some other flavors, but I can still go.

You are just showing how bad your logic is, you can't even argue about
simple philosophy.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

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

XPost: sci.logic

On 7/8/24 10:00 PM, olcott wrote:

On 7/8/2024 8:53 PM, Richard Damon wrote:

On 7/8/24 9:38 PM, olcott wrote:

On 7/8/2024 8:30 PM, Richard Damon wrote:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program
is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

The way that IT DOES report something while it is still
running. You love to disagree with verified facts.

Computation can not report answers while running.

YOu are just showing your stupidity.

Thus printf() does not exist.

For Turing Machines and the like, no, not in that sense.

Think of it as the output is spooled to a buffer that isn't released
until the program ends.

Yes, modern computers can do some "things" that Turing Machines and Computations can not, but they can not "Compute" by the meaning of the
word in the field something that the Turing Machine can not do.

Tbhe key point is that the next program taking the output of the program
can not know if that is all of its input until the running program says
it is done, and Conputation Theory is about comptations do things that
can feed other computations, so no output is done and fully usable until
the program generating it stops.

If you define that the first thing that HHH "prnts" is its answer and it
is done after that, then when DDD "calls" HHH, it resumes as soon as HHH
sends that output, and it doesn't need to "wait" for HHH to stop
running, as it has, as far as the calling DDD is concerned when HHH
completes its answer.

Think of it as a cross process pipe instead of a call instruction, as
that is what you are starting to try to define with early output.

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

XPost: sci.logic

On 7/8/24 10:01 PM, olcott wrote:

On 7/8/2024 8:53 PM, Richard Damon wrote:

On 7/8/24 9:37 PM, olcott wrote:

On 7/8/2024 8:27 PM, Richard Damon wrote:

On 7/8/24 8:47 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that >>>>>>>>>>>> DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are
deterministic, and their behavior is fully establish when they >>>>>>>>>> are written, and running or simulating them is only a way to >>>>>>>>>> observe that behavior, and the only CORRECT observation of all >>>>>>>>>> the behavior, so letting that operation reach its final state. >>>>>>>>>>

<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>>>      until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that
exactly reproduces the behavior of the full program the input
represents, which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of >>>>>>>> those would do (since it would halt since you H returns 0) so
you CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is
correctly answering your non-halt-deciding question.  In other >>>>>>>> words, it is a correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

He literally agrees with MY meanings that the "if" has
been fulfilled.

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H (it's >>>>>  > trivial to do for this one case) that correctly determines that

P(P)

*would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not >>>>>  > halted.  That much is a truism.

Yes, Ben agrees that

*That the verbatim words of the If statement are fulfilled*

In other words, you think changing meaning of words in a statement is
valid logic, but it is actually one form of LIE.

Ben agrees:
*That the verbatim words of the If statement are fulfilled*

But with difffent meaning of the words, so you LIE.

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

XPost: sci.logic

On 7/8/24 10:06 PM, olcott wrote:

On 7/8/2024 9:01 PM, Richard Damon wrote:

On 7/8/24 9:23 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that >>>>>>>>>> DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are
deterministic, and their behavior is fully establish when they >>>>>>>> are written, and running or simulating them is only a way to
observe that behavior, and the only CORRECT observation of all >>>>>>>> the behavior, so letting that operation reach its final state. >>>>>>>>

<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>      until H correctly determines that its simulated D would never >>>>>>>      stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that exactly >>>>>> reproduces the behavior of the full program the input represents,
which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of
those would do (since it would halt since you H returns 0) so you
CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is
correctly answering your non-halt-deciding question.  In other
words, it is a correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

Ben disagrees with the second part because Ben fails to understand
that HHH cannot correctly report that DDD would stop running until
after HHH forces DDD to stop running.

No, HE understand that HHH to be a halt decider MUST correctly
report that DDD will stop running since HHH(DDD) returns.

YOU are the one that doesn't understand the problem.

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is
not me.

Something you don't understand, maybe because you sold your free
will and got a deterministic program instead.

*Free will does not make lies into truth*

If HHH reports that it does not need to abort
DDD before it aborts DDD then HHH is a liar.

No, It COULD report that it has determined that it doesn't NEED to
abort its simulation, but does so anyway.

Says someone that acts as if lies are true.
If HHH reports that it didn't need to abort then HHH lies.

Why do you say that, since it DOES abort, it doesn't need to.

You think HHH can be something it isn't because you just don't know what
a program is.

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

XPost: sci.logic

On 7/8/24 10:44 PM, olcott wrote:

On 7/8/2024 9:13 PM, Richard Damon wrote:

On 7/8/24 10:06 PM, olcott wrote:

On 7/8/2024 9:01 PM, Richard Damon wrote:

On 7/8/24 9:23 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that >>>>>>>>>>>> DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are
deterministic, and their behavior is fully establish when they >>>>>>>>>> are written, and running or simulating them is only a way to >>>>>>>>>> observe that behavior, and the only CORRECT observation of all >>>>>>>>>> the behavior, so letting that operation reach its final state. >>>>>>>>>>

<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>>>      until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that
exactly reproduces the behavior of the full program the input
represents, which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of >>>>>>>> those would do (since it would halt since you H returns 0) so
you CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is
correctly answering your non-halt-deciding question.  In other >>>>>>>> words, it is a correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

Ben disagrees with the second part because Ben fails to understand >>>>>>> that HHH cannot correctly report that DDD would stop running until >>>>>>> after HHH forces DDD to stop running.

No, HE understand that HHH to be a halt decider MUST correctly
report that DDD will stop running since HHH(DDD) returns.

YOU are the one that doesn't understand the problem.

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program
is not me.

Something you don't understand, maybe because you sold your free
will and got a deterministic program instead.

*Free will does not make lies into truth*

If HHH reports that it does not need to abort
DDD before it aborts DDD then HHH is a liar.

No, It COULD report that it has determined that it doesn't NEED to
abort its simulation, but does so anyway.

Says someone that acts as if lies are true.
If HHH reports that it didn't need to abort then HHH lies.

Why do you say that, since it DOES abort, it doesn't need to.

*HHH reports that it must abort DDD and then aborts DDD is true*
*HHH reports that it need not abort DDD is false*

If it reports that it aborted DDD, then that is a true statement, but unresposive, so not a correct answer.

HHH, if it is reporting on the behavior of DDD, and not just its partial simultion of DDD, doesn't know the answer, but we do, and since we can
see that since HHH will return to DDD that DDD wil return and thus to
be ight HHH needs to anwer yes for THIS DDD.

You are just stuck with the wrong queastion becaue you don't understand
the right one.

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

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

--
Mikko

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

On 2024-07-08 23:45:16 +0000, olcott said:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation
reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*Ben agrees that the "if" statement has been met*

How is that relevant? Even if he did, you can't prove that he was not
mistaken. If you could. you wouldn't need to mention him.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game. PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not
halted. That much is a truism.

*Ben fails to understand this*
If HHH reported that it did not need to abort DDD
before it aborted DDD then HHH would be lying.

If he fails to understand one thing you should not assume that
he does understand another thing.

But why should anybody care about his understanding?

--
Mikko

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

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is
not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we are
stupid if we forget that when he forgets to keep it in the description
because HE is allowed to be sloppy, but we can't take benefit from that.

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

XPost: sci.logic

On 7/9/24 12:01 AM, olcott wrote:

On 7/8/2024 9:13 PM, Richard Damon wrote:

On 7/8/24 10:06 PM, olcott wrote:

On 7/8/2024 9:01 PM, Richard Damon wrote:

On 7/8/24 9:23 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

On 7/8/2024 6:59 PM, Richard Damon wrote:

On 7/8/24 7:45 PM, olcott wrote:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves >>>>>>>>>>>>> that the call from DDD correctly emulated by HHH to HHH(DDD) >>>>>>>>>>>>> cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that >>>>>>>>>>>> DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that >>>>>>>>>>> DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't
understand that the x86 language says programs are
deterministic, and their behavior is fully establish when they >>>>>>>>>> are written, and running or simulating them is only a way to >>>>>>>>>> observe that behavior, and the only CORRECT observation of all >>>>>>>>>> the behavior, so letting that operation reach its final state. >>>>>>>>>>

<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
     If simulating halt decider H correctly simulates its input D >>>>>>>>>      until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D >>>>>>>>>      specifies a non-halting sequence of configurations. >>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

Which you H doesn't meet, since the definition of "Correct
Simulation" here (as for most people) is a simulation that
exactly reproduces the behavior of the full program the input
represents, which means a simulaiton that doesn't abort.

Since your H doesn't do that, or correctly determine what one of >>>>>>>> those would do (since it would halt since you H returns 0) so
you CAN'T correctly predict that which doesn't happen.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

No, he agress that your H, which is NOT a Halt Decider, is
correctly answering your non-halt-deciding question.  In other >>>>>>>> words, it is a correct POOP decide.r

It is literally true that Ben agrees that the "if" statement
has been met.

Same words, but different meanings.

SO, NO

Ben disagrees with the second part because Ben fails to understand >>>>>>> that HHH cannot correctly report that DDD would stop running until >>>>>>> after HHH forces DDD to stop running.

No, HE understand that HHH to be a halt decider MUST correctly
report that DDD will stop running since HHH(DDD) returns.

YOU are the one that doesn't understand the problem.

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program
is not me.

Something you don't understand, maybe because you sold your free
will and got a deterministic program instead.

*Free will does not make lies into truth*

If HHH reports that it does not need to abort
DDD before it aborts DDD then HHH is a liar.

No, It COULD report that it has determined that it doesn't NEED to
abort its simulation, but does so anyway.

Says someone that acts as if lies are true.
If HHH reports that it didn't need to abort then HHH lies.

Why do you say that, since it DOES abort, it doesn't need to.

It correctly determines that it needs to abort,
it aborts then it reports that it needed to abort.

But that is the question of POOP, not halting.

Halting asks if the input will halt.

Halting is objective, and a valid question.

POOPing is subjective and not a valid question.

You think HHH can be something it isn't because you just don't know
what a program is.

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

On 7/9/24 10:24 AM, olcott wrote:

On 7/9/2024 1:28 AM, Mikko wrote:

On 2024-07-08 23:45:16 +0000, olcott said:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation
reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*Ben agrees that the "if" statement has been met*

How is that relevant? Even if he did, you can't prove that he was not
mistaken. If you could. you wouldn't need to mention him.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P) >>>  > *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not
halted.  That much is a truism.

*Ben fails to understand this*
If HHH reported that it did not need to abort DDD
before it aborted DDD then HHH would be lying.

If he fails to understand one thing you should not assume that
he does understand another thing.

Ben proves that he agrees that the If part of the Professor
Sipser approved criteria has been met when he paraphrases
this into his own words:

Nope, he agreed that based on YOUR definiton of the words (and not the conventional one that Professor Sipser uses) that your H is a correct
POOP decider (since what it decides is NOT "Halting" but some strange
concept of "Needed to abort" based on things being able to be things
they are not).

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

But H determines (correctly) that D would not halt
if it were not halted.  That much is a truism.

*Here is the part that Ben fails to understand*
*I have never explained this issue to Ben this clearly before*
Ben seems to believe that HHH must report that it need not
abort its emulation of DDD because AFTER HHH has already
aborted this emulation DDD does not need to be aborted.

Right, To be a Halt Decider, HHH must report on the actual behavior of
the direct execution of the input, and if that halts, then H didn't
actually need to have done the abort it did. If you changed H to not
abort, and built D by the actual rules so it still had its copy of the
original H, you would see that the non-aborting H' would be able to
simulate the D calling the aborting H would have the aborting H return
to it and it halts.

Thus, H really didn't need to abort, but only because it did. You
created the paradox by not using the right computation model, as your H
and P are not actualy seperate computations as needed.

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

On 2024-07-09 14:24:52 +0000, olcott said:

On 7/9/2024 1:28 AM, Mikko wrote:

On 2024-07-08 23:45:16 +0000, olcott said:

On 7/8/2024 6:26 PM, Richard Damon wrote:

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation
reach its final state.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*Ben agrees that the "if" statement has been met*

How is that relevant? Even if he did, you can't prove that he was not
mistaken. If you could. you wouldn't need to mention him.

*Ben agrees that the "if" statement has been met*
*Ben agrees that the "if" statement has been met*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P) >>>  > *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it were not
halted.  That much is a truism.

*Ben fails to understand this*
If HHH reported that it did not need to abort DDD
before it aborted DDD then HHH would be lying.

If he fails to understand one thing you should not assume that
he does understand another thing.

Ben proves that he agrees that the If part of the Professor
Sipser approved criteria has been met when he paraphrases
this into his own words:

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

But H determines (correctly) that D would not halt
if it were not halted. That much is a truism.

That does not express any agreement about anything.

And anyway, an agreement by an untrusted person would not mean anything.

--
Mikko

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

On 2024-07-09 11:29:20 +0000, Richard Damon said:

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we are
stupid if we forget that when he forgets to keep it in the description because HE is allowed to be sloppy, but we can't take benefit from that.

In such situations I may point out that OP did not require pure function
(or whatever he forgot to require).

--
Mikko

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

On 7/10/24 3:42 AM, Mikko wrote:

On 2024-07-09 11:29:20 +0000, Richard Damon said:

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program
is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we are
stupid if we forget that when he forgets to keep it in the description
because HE is allowed to be sloppy, but we can't take benefit from that.

In such situations I may point out that OP did not require pure function
(or whatever he forgot to require).

Yes, he might make such a claim, but if you use the fact that did
specify pure function that time to show him wrong he will answer that of
course it must be a pure function, that has always been in the requirements.

IF it can report via non-pure methods, then it can short-cut the
recursion with the static and be able to run to completion.

Either way, it is wrong.

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

On 7/10/24 9:48 AM, olcott wrote:

On 7/10/2024 2:42 AM, Mikko wrote:

On 2024-07-09 11:29:20 +0000, Richard Damon said:

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program >>>>>>> is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we
are stupid if we forget that when he forgets to keep it in the
description because HE is allowed to be sloppy, but we can't take
benefit from that.

In such situations I may point out that OP did not require pure function
(or whatever he forgot to require).

If I don't say pure function then Richard tries to get away
with cheating. I stopped saying it so that people that do not
know what a pure function is wouldn't get confused.

And then you try to cheat by having you no longer declare pure function
do the non-pure action of trying to write to output.

Pure functions can not try to influence the world in any way but their
returned value. ALL output involves somewhere the affecting of state
that isn't part of the claimed pure function (unless it hold the output internally until it returns, but then it didn't "report" it until it ends).

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

On 2024-07-10 11:24:33 +0000, Richard Damon said:

On 7/10/24 3:42 AM, Mikko wrote:

On 2024-07-09 11:29:20 +0000, Richard Damon said:

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we are
stupid if we forget that when he forgets to keep it in the description
because HE is allowed to be sloppy, but we can't take benefit from that.

In such situations I may point out that OP did not require pure function
(or whatever he forgot to require).

Yes, he might make such a claim, but if you use the fact that did
specify pure function that time to show him wrong he will answer that
of course it must be a pure function, that has always been in the requirements.

He may say so but often he says something else instead.

--
Mikko

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

On 2024-07-10 13:48:53 +0000, olcott said:

On 7/10/2024 2:42 AM, Mikko wrote:

On 2024-07-09 11:29:20 +0000, Richard Damon said:

On 7/9/24 2:35 AM, Mikko wrote:

On 2024-07-09 01:30:01 +0000, Richard Damon said:

On 7/8/24 8:51 PM, olcott wrote:

On 7/8/2024 7:31 PM, Richard Damon wrote:

On 7/8/24 8:21 PM, olcott wrote:

When you need groceries you cannot say that you
don't need groceries until AFTER you get more groceries.

Which is just Red Herring, as I am not a program, and the program is not me.

Free will does not make lies into truth.
If HHH reports that DDD does not need to abort
DDD before HHH aborts DDD then HHH is a liar.

How can HHH "report" something while it is still running?

If HHH is not a pure function it can have side effects while still
running. A side effect can "report".

But he keeps on insting that HHH *IS* a pure function, and that we are
stupid if we forget that when he forgets to keep it in the description
because HE is allowed to be sloppy, but we can't take benefit from that.

In such situations I may point out that OP did not require pure function
(or whatever he forgot to require).

If I don't say pure function then Richard tries to get away
with cheating. I stopped saying it so that people that do not
know what a pure function is wouldn't get confused.

The important point is that you can't say "pure function" unless you
say "pure function".

--
Mikko

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