On 6/20/23 10:59 PM, olcott wrote:
> On 6/20/2023 9:32 PM, Richard Damon wrote:
>> On 6/20/23 9:36 PM, olcott wrote:
>>> On 6/20/2023 7:41 PM, Richard Damon wrote:
>>>> On 6/20/23 6:59 PM, olcott wrote:
>>>>> On 6/20/2023 5:52 PM, Richard Damon wrote:
>>>>>> On 6/20/23 6:19 PM, olcott wrote:
>>>>>>> On 6/20/2023 4:56 PM, Richard Damon wrote:
>>>>>>>> On 6/20/23 5:27 PM, olcott wrote:
>>>>>>>>> On 6/20/2023 3:46 PM, Richard Damon wrote:
>>>>>>>>>> On 6/20/23 4:38 PM, olcott wrote:
>>>>>>>>>>> On 6/20/2023 3:32 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/20/23 2:33 PM, olcott wrote:
>>>>>>>>>>>>> On 6/20/2023 1:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/20/23 1:46 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/20/2023 10:48 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/20/23 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/20/2023 6:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/19/23 11:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/19/2023 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 6/19/23 9:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/19/23 4:43 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> The behavior of the directly executed P(P) is
>>>>>>>>>>>>>>>>>>>>>>> different than the
>>>>>>>>>>>>>>>>>>>>>>> behavior of P(P) correctly simulated by H because
>>>>>>>>>>>>>>>>>>>>>>> in the first case H
>>>>>>>>>>>>>>>>>>>>>>> has already aborted its simulation of its input
>>>>>>>>>>>>>>>>>>>>>>> and in the second case
>>>>>>>>>>>>>>>>>>>>>>> this has not yet occurred.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> By what definition of "Correctly Simulated"?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The fact that H aborts its simulation has NO
>>>>>>>>>>>>>>>>>>>>>> affect on the direct execution of the machine, so
>>>>>>>>>>>>>>>>>>>>>> all you are saying that H has shut its eyes and
>>>>>>>>>>>>>>>>>>>>>> said "I don't see it, so it didn't happen".
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That is just FALSEHOOD.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I now refer to P(P) as D(D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>> No it cannot see the details below.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which is not the question being asked. The fact
>>>>>>>>>>>>>>>>>>>>>> that it is impossible to design an H that can
>>>>>>>>>>>>>>>>>>>>>> correctly simulate its input to a halting state
>>>>>>>>>>>>>>>>>>>>>> just proves that H can not correctly decider that
>>>>>>>>>>>>>>>>>>>>>> its input is Halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This does NOT mean that the input can't be
>>>>>>>>>>>>>>>>>>>>>> Halting, just that H can never prove it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> IF H doesn't ever abort its simulation, then yes,
>>>>>>>>>>>>>>>>>>>>>> the D built on that H is non-halting, but that H
>>>>>>>>>>>>>>>>>>>>>> never gives that answer, so it is still wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Each H gets a DIFFERENT D, since they include the
>>>>>>>>>>>>>>>>>>>>>> H that the "pathological test" is to be performed
>>>>>>>>>>>>>>>>>>>>>> on, so the behavior of one D built on a different
>>>>>>>>>>>>>>>>>>>>>> H doesn't apply, and for correct reasoning, you
>>>>>>>>>>>>>>>>>>>>>> really need to give each one a different name.
>>>>>>>>>>>>>>>>>>>>>> Reusing the same name for different machine, and
>>>>>>>>>>>>>>>>>>>>>> then trying to confuse which one is which is just
>>>>>>>>>>>>>>>>>>>>>> a sign of being intentionally deceptive to try to
>>>>>>>>>>>>>>>>>>>>>> tell a LIE.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system based on an open
>>>>>>>>>>>>>>>>>>>>>>> source x86 emulator. This
>>>>>>>>>>>>>>>>>>>>>>> system enables one C function to execute another
>>>>>>>>>>>>>>>>>>>>>>> C function in debug
>>>>>>>>>>>>>>>>>>>>>>> step mode. When H simulates D it creates a
>>>>>>>>>>>>>>>>>>>>>>> separate process context for
>>>>>>>>>>>>>>>>>>>>>>> D with its own memory, stack and virtual
>>>>>>>>>>>>>>>>>>>>>>> registers. H is able to
>>>>>>>>>>>>>>>>>>>>>>> simulate D simulating itself, thus the only limit
>>>>>>>>>>>>>>>>>>>>>>> to recursive
>>>>>>>>>>>>>>>>>>>>>>> simulations is RAM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But D is not SPECIFIED in a seperate context, but
>>>>>>>>>>>>>>>>>>>>>> share code space with H, which means it fails to
>>>>>>>>>>>>>>>>>>>>>> be truely distinctly, like a Turing Machine would be.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is NOT a full "separate process context" as all
>>>>>>>>>>>>>>>>>>>>>> the contexts share code space.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> terminate normally by reaching its own final
>>>>>>>>>>>>>>>>>>>>>>> state at line 09.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But D correctly simulated by a correct simulator
>>>>>>>>>>>>>>>>>>>>>> would, at least as long as you are using an H that
>>>>>>>>>>>>>>>>>>>>>> answer H(D,D) as 0, as you claim.
>>>>>>>>>>>>>>>>>>>>> H correctly simulates N steps of D until H
>>>>>>>>>>>>>>>>>>>>> correctly predicts through
>>>>>>>>>>>>>>>>>>>>> the type of mathematical induction used by
>>>>>>>>>>>>>>>>>>>>> termination analyzers that D
>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot possibly terminate
>>>>>>>>>>>>>>>>>>>>> normally.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But that is the wrong prediction. It needs to
>>>>>>>>>>>>>>>>>>>> predict if the input when run will halt, as THAT is
>>>>>>>>>>>>>>>>>>>> the Halting Question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is just like Jack's question posed to Jack,
>>>>>>>>>>>>>>>>>>> self-contradictory.
>>>>>>>>>>>>>>>>>>> ChatGPT could understand that I am correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, and you just seem too stupid to understand.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, you are just admitting to working on POOP
>>>>>>>>>>>>>>>>>>>> instead of Halting, and ALL your statements are just
>>>>>>>>>>>>>>>>>>>> LIES.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int factorial(int n)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>    if(n==0)
>>>>>>>>>>>>>>>>>>>>>      return(1);
>>>>>>>>>>>>>>>>>>>>>    return(n*factorial(n-1));
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> AProVE correctly determines that factorial(5) halts by
>>>>>>>>>>>>>>>>>>>>> boiling the key behavior of entire function to this:
>>>>>>>>>>>>>>>>>>>>> f(x) → f(x-1) :|: x > 0 && x <= 5
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>  > Wrong Question leads to incorrect answer, and all
>>>>>>>>>>>>>>>>>>>> your work goes down
>>>>>>>>>>>>>>>>>>>> the drain.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> AProVE is the largest termination analysis project in
>>>>>>>>>>>>>>>>>>> the world.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, and it probably uses the RIGHT question, will the
>>>>>>>>>>>>>>>>>> program halt when actually run.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It will probably also tell you that D(D) will Halt
>>>>>>>>>>>>>>>>>> since H(D,D) returns 0.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, it likely shows you are wrong about everything.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When we use the criteria:
>>>>>>>>>>>>>>>>> Can D correctly simulated by H ever terminate normally?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you are ADMITTING to working on a different problem,
>>>>>>>>>>>>>>>> and lying about what you are doing. Thank you for being
>>>>>>>>>>>>>>>> honest about that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ben is just pointing out the ERRORS in your logic
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ben pointed out that H(P,P) reports that P(P) does
>>>>>>>>>>>>>>> not halt when
>>>>>>>>>>>>>>> P(P) does halt this seems to be a contradiction to people
>>>>>>>>>>>>>>> that lack a
>>>>>>>>>>>>>>> complete understanding.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> NO, it is a TRUE statement. H is NOT a correct HALT DECIDER.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It might be a valid POOP decider with your altered
>>>>>>>>>>>>>> criteria, but it isn't correct as a Halt Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't get to change the meaning of words, attempting
>>>>>>>>>>>>>> to just shows you are a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halting is a property of the original machine, not of the
>>>>>>>>>>>>>> partial simulation that H does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because of this I changed the semantic meaning of a
>>>>>>>>>>>>>>> return value of 0
>>>>>>>>>>>>>>> from H to mean either that P(P) does not halt or P(P)
>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>> targets H to do the opposite of whatever Boolean value
>>>>>>>>>>>>>>> that H returns.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which means you H need to return BOTH a 0 and 1 at the
>>>>>>>>>>>>>> same time,
>>>>>>>>>>>>> Not at all. Not the least little bit.
>>>>>>>>>>>>> A return value of 0 also indicates that input D
>>>>>>>>>>>>> intentionally targets
>>>>>>>>>>>>> H by doing the opposite of whatever Boolean value that H
>>>>>>>>>>>>> returns.
>>>>>>>>>>>>
>>>>>>>>>>>> But a return of 1 signals that it halts, which it does.
>>>>>>>>>>>>
>>>>>>>>>>>> You don't seem to understand English.
>>>>>>>>>>>>
>>>>>>>>>>>> The Halting Problem asks if the Machine Described by the
>>>>>>>>>>>> input Halts.
>>>>>>>>>>>>
>>>>>>>>>>>> It Does (for the H that you are cliaming to be correct)
>>>>>>>>>>>>
>>>>>>>>>>>> Therefore, the correct answer is YES / Halting, and you are
>>>>>>>>>>>> PROVED to be a LIAR.
>>>>>>>>>>> If I am the one that is a Liar then why did you already say
>>>>>>>>>>> that 1 is
>>>>>>>>>>> the wrong answer and are now saying that it is the right answer?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Where did I say that 1 is the wrong answer to THAT question.
>>>>>>>>>>
>>>>>>>>> What happens when H returns 1 to D?
>>>>>>>>>
>>>>>>>>
>>>>>>>> But it doesn't, so it doesn't matter.
>>>>>>> No H can possibly be defined that can be embedded within
>>>>>>> Linz Ĥ such that embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qy or Ĥ.qn
>>>>>>> consistently with the behavior of Ĥ applied to ⟨Ĥ⟩.
>>>>>>
>>>>>> Right, which is why it is impossible to make a correct Halt Decider.
>>>>>>
>>>>>>>
>>>>>>> The reason for this is that Ĥ does the opposite of both
>>>>>>> Ĥ.qy and Ĥ.qn. This makes the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
>>>>>>> self-contradictory for embedded_H.
>>>>>>
>>>>>> Not SELF contradicotory, but just contradictory.
>>>>>>
>>>>>
>>>>> OK that may make sense. One of our very rare agreements. The
>>>>> question does not contradict itself it contradicts every answer.
>>>>>
>>>>> Contradictory questions are also incorrect questions.
>>>>> Likewise Jack's question contradicts every answer.
>>>>>
>>>>
>>>> It doesn't contradict the answer to the actual question,
>>> If this is true then you can say which of yes/no are correct for Jack to
>>> reply and which of true/false that H can return.
>>>
>>
>> SO, you are just to dumb to understand
>
> That simply dodges my yes/no question.
>
> My IQ is probably higher than yours. Did you pass the Mensa test?
> In any case creative genius has its algorithm:
> https://www.scientificamerican.com/article/the-science-of-genius1/

On 6/21/2023 6:38 AM, Richard Damon wrote:
> On 6/20/23 10:59 PM, olcott wrote:
>> On 6/20/2023 9:32 PM, Richard Damon wrote:
>>> On 6/20/23 9:36 PM, olcott wrote:
>>>> On 6/20/2023 7:41 PM, Richard Damon wrote:
>>>>> On 6/20/23 6:59 PM, olcott wrote:
>>>>>> On 6/20/2023 5:52 PM, Richard Damon wrote:
>>>>>>> On 6/20/23 6:19 PM, olcott wrote:
>>>>>>>> On 6/20/2023 4:56 PM, Richard Damon wrote:
>>>>>>>>> On 6/20/23 5:27 PM, olcott wrote:
>>>>>>>>>> On 6/20/2023 3:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/20/23 4:38 PM, olcott wrote:
>>>>>>>>>>>> On 6/20/2023 3:32 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/20/23 2:33 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/20/2023 1:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/20/23 1:46 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/20/2023 10:48 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/20/23 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/20/2023 6:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 6/19/23 11:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/19/2023 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/19/23 9:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/19/23 4:43 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the directly executed P(P) is
>>>>>>>>>>>>>>>>>>>>>>>> different than the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of P(P) correctly simulated by H
>>>>>>>>>>>>>>>>>>>>>>>> because in the first case H
>>>>>>>>>>>>>>>>>>>>>>>> has already aborted its simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>> and in the second case
>>>>>>>>>>>>>>>>>>>>>>>> this has not yet occurred.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> By what definition of "Correctly Simulated"?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fact that H aborts its simulation has NO
>>>>>>>>>>>>>>>>>>>>>>> affect on the direct execution of the machine, so
>>>>>>>>>>>>>>>>>>>>>>> all you are saying that H has shut its eyes and
>>>>>>>>>>>>>>>>>>>>>>> said "I don't see it, so it didn't happen".
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That is just FALSEHOOD.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I now refer to P(P) as D(D).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>> No it cannot see the details below.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which is not the question being asked. The fact
>>>>>>>>>>>>>>>>>>>>>>> that it is impossible to design an H that can
>>>>>>>>>>>>>>>>>>>>>>> correctly simulate its input to a halting state
>>>>>>>>>>>>>>>>>>>>>>> just proves that H can not correctly decider that
>>>>>>>>>>>>>>>>>>>>>>> its input is Halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This does NOT mean that the input can't be
>>>>>>>>>>>>>>>>>>>>>>> Halting, just that H can never prove it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> IF H doesn't ever abort its simulation, then yes,
>>>>>>>>>>>>>>>>>>>>>>> the D built on that H is non-halting, but that H
>>>>>>>>>>>>>>>>>>>>>>> never gives that answer, so it is still wrong.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Each H gets a DIFFERENT D, since they include the
>>>>>>>>>>>>>>>>>>>>>>> H that the "pathological test" is to be performed
>>>>>>>>>>>>>>>>>>>>>>> on, so the behavior of one D built on a different
>>>>>>>>>>>>>>>>>>>>>>> H doesn't apply, and for correct reasoning, you
>>>>>>>>>>>>>>>>>>>>>>> really need to give each one a different name.
>>>>>>>>>>>>>>>>>>>>>>> Reusing the same name for different machine, and
>>>>>>>>>>>>>>>>>>>>>>> then trying to confuse which one is which is just
>>>>>>>>>>>>>>>>>>>>>>> a sign of being intentionally deceptive to try to
>>>>>>>>>>>>>>>>>>>>>>> tell a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system based on an open
>>>>>>>>>>>>>>>>>>>>>>>> source x86 emulator. This
>>>>>>>>>>>>>>>>>>>>>>>> system enables one C function to execute another
>>>>>>>>>>>>>>>>>>>>>>>> C function in debug
>>>>>>>>>>>>>>>>>>>>>>>> step mode. When H simulates D it creates a
>>>>>>>>>>>>>>>>>>>>>>>> separate process context for
>>>>>>>>>>>>>>>>>>>>>>>> D with its own memory, stack and virtual
>>>>>>>>>>>>>>>>>>>>>>>> registers. H is able to
>>>>>>>>>>>>>>>>>>>>>>>> simulate D simulating itself, thus the only
>>>>>>>>>>>>>>>>>>>>>>>> limit to recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulations is RAM.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But D is not SPECIFIED in a seperate context, but
>>>>>>>>>>>>>>>>>>>>>>> share code space with H, which means it fails to
>>>>>>>>>>>>>>>>>>>>>>> be truely distinctly, like a Turing Machine would
>>>>>>>>>>>>>>>>>>>>>>> be.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is NOT a full "separate process context" as
>>>>>>>>>>>>>>>>>>>>>>> all the contexts share code space.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int function
>>>>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to
>>>>>>>>>>>>>>>>>>>>>>>> simulate its input
>>>>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>> terminate normally by reaching its own final
>>>>>>>>>>>>>>>>>>>>>>>> state at line 09.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But D correctly simulated by a correct simulator
>>>>>>>>>>>>>>>>>>>>>>> would, at least as long as you are using an H
>>>>>>>>>>>>>>>>>>>>>>> that answer H(D,D) as 0, as you claim.
>>>>>>>>>>>>>>>>>>>>>> H correctly simulates N steps of D until H
>>>>>>>>>>>>>>>>>>>>>> correctly predicts through
>>>>>>>>>>>>>>>>>>>>>> the type of mathematical induction used by
>>>>>>>>>>>>>>>>>>>>>> termination analyzers that D
>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot possibly terminate
>>>>>>>>>>>>>>>>>>>>>> normally.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But that is the wrong prediction. It needs to
>>>>>>>>>>>>>>>>>>>>> predict if the input when run will halt, as THAT is
>>>>>>>>>>>>>>>>>>>>> the Halting Question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is just like Jack's question posed to Jack,
>>>>>>>>>>>>>>>>>>>> self-contradictory.
>>>>>>>>>>>>>>>>>>>> ChatGPT could understand that I am correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, and you just seem too stupid to understand.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus, you are just admitting to working on POOP
>>>>>>>>>>>>>>>>>>>>> instead of Halting, and ALL your statements are
>>>>>>>>>>>>>>>>>>>>> just LIES.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int factorial(int n)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    if(n==0)
>>>>>>>>>>>>>>>>>>>>>>      return(1);
>>>>>>>>>>>>>>>>>>>>>>    return(n*factorial(n-1));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> AProVE correctly determines that factorial(5)
>>>>>>>>>>>>>>>>>>>>>> halts by
>>>>>>>>>>>>>>>>>>>>>> boiling the key behavior of entire function to this:
>>>>>>>>>>>>>>>>>>>>>> f(x) → f(x-1) :|: x > 0 && x <= 5
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>  > Wrong Question leads to incorrect answer, and
>>>>>>>>>>>>>>>>>>>>> all your work goes down
>>>>>>>>>>>>>>>>>>>>> the drain.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> AProVE is the largest termination analysis project
>>>>>>>>>>>>>>>>>>>> in the world.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, and it probably uses the RIGHT question, will
>>>>>>>>>>>>>>>>>>> the program halt when actually run.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It will probably also tell you that D(D) will Halt
>>>>>>>>>>>>>>>>>>> since H(D,D) returns 0.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, it likely shows you are wrong about everything.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When we use the criteria:
>>>>>>>>>>>>>>>>>> Can D correctly simulated by H ever terminate normally?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So you are ADMITTING to working on a different problem,
>>>>>>>>>>>>>>>>> and lying about what you are doing. Thank you for being
>>>>>>>>>>>>>>>>> honest about that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ben is just pointing out the ERRORS in your logic
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ben pointed out that H(P,P) reports that P(P) does
>>>>>>>>>>>>>>>> not halt when
>>>>>>>>>>>>>>>> P(P) does halt this seems to be a contradiction to
>>>>>>>>>>>>>>>> people that lack a
>>>>>>>>>>>>>>>> complete understanding.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> NO, it is a TRUE statement. H is NOT a correct HALT DECIDER.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It might be a valid POOP decider with your altered
>>>>>>>>>>>>>>> criteria, but it isn't correct as a Halt Decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You don't get to change the meaning of words, attempting
>>>>>>>>>>>>>>> to just shows you are a liar.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Halting is a property of the original machine, not of the
>>>>>>>>>>>>>>> partial simulation that H does.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because of this I changed the semantic meaning of a
>>>>>>>>>>>>>>>> return value of 0
>>>>>>>>>>>>>>>> from H to mean either that P(P) does not halt or P(P)
>>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>>> targets H to do the opposite of whatever Boolean value
>>>>>>>>>>>>>>>> that H returns.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which means you H need to return BOTH a 0 and 1 at the
>>>>>>>>>>>>>>> same time,
>>>>>>>>>>>>>> Not at all. Not the least little bit.
>>>>>>>>>>>>>> A return value of 0 also indicates that input D
>>>>>>>>>>>>>> intentionally targets
>>>>>>>>>>>>>> H by doing the opposite of whatever Boolean value that H
>>>>>>>>>>>>>> returns.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But a return of 1 signals that it halts, which it does.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You don't seem to understand English.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Halting Problem asks if the Machine Described by the
>>>>>>>>>>>>> input Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It Does (for the H that you are cliaming to be correct)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore, the correct answer is YES / Halting, and you are
>>>>>>>>>>>>> PROVED to be a LIAR.
>>>>>>>>>>>> If I am the one that is a Liar then why did you already say
>>>>>>>>>>>> that 1 is
>>>>>>>>>>>> the wrong answer and are now saying that it is the right
>>>>>>>>>>>> answer?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Where did I say that 1 is the wrong answer to THAT question.
>>>>>>>>>>>
>>>>>>>>>> What happens when H returns 1 to D?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But it doesn't, so it doesn't matter.
>>>>>>>> No H can possibly be defined that can be embedded within
>>>>>>>> Linz Ĥ such that embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qy or Ĥ.qn
>>>>>>>> consistently with the behavior of Ĥ applied to ⟨Ĥ⟩.
>>>>>>>
>>>>>>> Right, which is why it is impossible to make a correct Halt Decider.
>>>>>>>
>>>>>>>>
>>>>>>>> The reason for this is that Ĥ does the opposite of both
>>>>>>>> Ĥ.qy and Ĥ.qn. This makes the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
>>>>>>>> self-contradictory for embedded_H.
>>>>>>>
>>>>>>> Not SELF contradicotory, but just contradictory.
>>>>>>>
>>>>>>
>>>>>> OK that may make sense. One of our very rare agreements. The
>>>>>> question does not contradict itself it contradicts every answer.
>>>>>>
>>>>>> Contradictory questions are also incorrect questions.
>>>>>> Likewise Jack's question contradicts every answer.
>>>>>>
>>>>>
>>>>> It doesn't contradict the answer to the actual question,
>>>> If this is true then you can say which of yes/no are correct for
>>>> Jack to
>>>> reply and which of true/false that H can return.
>>>>
>>>
>>> SO, you are just to dumb to understand
>>
>> That simply dodges my yes/no question.
>>
>> My IQ is probably higher than yours. Did you pass the Mensa test?
>> In any case creative genius has its algorithm:
>> https://www.scientificamerican.com/article/the-science-of-genius1/
>
> I never took the Mensa test, as I saw no benefit to taking it.
>
>>
>> If this is true then you can say which of yes/no are correct for
>> Jack to reply and which of true/false that H can return.
>>
>
> How do you get that conclusion? You are working off BAD LOGIC.
>
In other words you are saying that when a question contradicts every
answer From X that the reason that X cannot correctly answer the
question has nothing to do with the fact that the question contradicts
every answer from X instead it must be the case that X is very stupid.

On 6/21/23 1:32 PM, olcott wrote:
> On 6/21/2023 6:38 AM, Richard Damon wrote:
>> On 6/20/23 10:59 PM, olcott wrote:
>>> On 6/20/2023 9:32 PM, Richard Damon wrote:
>>>> On 6/20/23 9:36 PM, olcott wrote:
>>>>> On 6/20/2023 7:41 PM, Richard Damon wrote:
>>>>>> On 6/20/23 6:59 PM, olcott wrote:
>>>>>>> On 6/20/2023 5:52 PM, Richard Damon wrote:
>>>>>>>> On 6/20/23 6:19 PM, olcott wrote:
>>>>>>>>> On 6/20/2023 4:56 PM, Richard Damon wrote:
>>>>>>>>>> On 6/20/23 5:27 PM, olcott wrote:
>>>>>>>>>>> On 6/20/2023 3:46 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/20/23 4:38 PM, olcott wrote:
>>>>>>>>>>>>> On 6/20/2023 3:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/20/23 2:33 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/20/2023 1:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/20/23 1:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/20/2023 10:48 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/20/23 11:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/20/2023 6:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 6/19/23 11:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/19/2023 8:13 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/19/23 9:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/23 4:43 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> The behavior of the directly executed P(P) is
>>>>>>>>>>>>>>>>>>>>>>>>> different than the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of P(P) correctly simulated by H
>>>>>>>>>>>>>>>>>>>>>>>>> because in the first case H
>>>>>>>>>>>>>>>>>>>>>>>>> has already aborted its simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>> and in the second case
>>>>>>>>>>>>>>>>>>>>>>>>> this has not yet occurred.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> By what definition of "Correctly Simulated"?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The fact that H aborts its simulation has NO
>>>>>>>>>>>>>>>>>>>>>>>> affect on the direct execution of the machine,
>>>>>>>>>>>>>>>>>>>>>>>> so all you are saying that H has shut its eyes
>>>>>>>>>>>>>>>>>>>>>>>> and said "I don't see it, so it didn't happen".
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That is just FALSEHOOD.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I now refer to P(P) as D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>>>>>>>>>>>>>>>>>> No it cannot see the details below.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which is not the question being asked. The fact
>>>>>>>>>>>>>>>>>>>>>>>> that it is impossible to design an H that can
>>>>>>>>>>>>>>>>>>>>>>>> correctly simulate its input to a halting state
>>>>>>>>>>>>>>>>>>>>>>>> just proves that H can not correctly decider
>>>>>>>>>>>>>>>>>>>>>>>> that its input is Halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This does NOT mean that the input can't be
>>>>>>>>>>>>>>>>>>>>>>>> Halting, just that H can never prove it.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> IF H doesn't ever abort its simulation, then
>>>>>>>>>>>>>>>>>>>>>>>> yes, the D built on that H is non-halting, but
>>>>>>>>>>>>>>>>>>>>>>>> that H never gives that answer, so it is still
>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Each H gets a DIFFERENT D, since they include
>>>>>>>>>>>>>>>>>>>>>>>> the H that the "pathological test" is to be
>>>>>>>>>>>>>>>>>>>>>>>> performed on, so the behavior of one D built on
>>>>>>>>>>>>>>>>>>>>>>>> a different H doesn't apply, and for correct
>>>>>>>>>>>>>>>>>>>>>>>> reasoning, you really need to give each one a
>>>>>>>>>>>>>>>>>>>>>>>> different name. Reusing the same name for
>>>>>>>>>>>>>>>>>>>>>>>> different machine, and then trying to confuse
>>>>>>>>>>>>>>>>>>>>>>>> which one is which is just a sign of being
>>>>>>>>>>>>>>>>>>>>>>>> intentionally deceptive to try to tell a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system based on an open
>>>>>>>>>>>>>>>>>>>>>>>>> source x86 emulator. This
>>>>>>>>>>>>>>>>>>>>>>>>> system enables one C function to execute
>>>>>>>>>>>>>>>>>>>>>>>>> another C function in debug
>>>>>>>>>>>>>>>>>>>>>>>>> step mode. When H simulates D it creates a
>>>>>>>>>>>>>>>>>>>>>>>>> separate process context for
>>>>>>>>>>>>>>>>>>>>>>>>> D with its own memory, stack and virtual
>>>>>>>>>>>>>>>>>>>>>>>>> registers. H is able to
>>>>>>>>>>>>>>>>>>>>>>>>> simulate D simulating itself, thus the only
>>>>>>>>>>>>>>>>>>>>>>>>> limit to recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulations is RAM.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But D is not SPECIFIED in a seperate context,
>>>>>>>>>>>>>>>>>>>>>>>> but share code space with H, which means it
>>>>>>>>>>>>>>>>>>>>>>>> fails to be truely distinctly, like a Turing
>>>>>>>>>>>>>>>>>>>>>>>> Machine would be.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is NOT a full "separate process context" as
>>>>>>>>>>>>>>>>>>>>>>>> all the contexts share code space.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> // The following is written in C
>>>>>>>>>>>>>>>>>>>>>>>>> //
>>>>>>>>>>>>>>>>>>>>>>>>> 01 typedef int (*ptr)(); // pointer to int
>>>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>>>>> 02 int H(ptr x, ptr y)   // uses x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>> to simulate its input
>>>>>>>>>>>>>>>>>>>>>>>>> 03
>>>>>>>>>>>>>>>>>>>>>>>>> 04 int D(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> 05 {
>>>>>>>>>>>>>>>>>>>>>>>>> 06   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> 07   if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> 08     HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> 09   return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> 10 }
>>>>>>>>>>>>>>>>>>>>>>>>> 11
>>>>>>>>>>>>>>>>>>>>>>>>> 12 void main()
>>>>>>>>>>>>>>>>>>>>>>>>> 13 {
>>>>>>>>>>>>>>>>>>>>>>>>> 14   D(D);
>>>>>>>>>>>>>>>>>>>>>>>>> 15 }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally by reaching its own final
>>>>>>>>>>>>>>>>>>>>>>>>> state at line 09.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But D correctly simulated by a correct simulator
>>>>>>>>>>>>>>>>>>>>>>>> would, at least as long as you are using an H
>>>>>>>>>>>>>>>>>>>>>>>> that answer H(D,D) as 0, as you claim.
>>>>>>>>>>>>>>>>>>>>>>> H correctly simulates N steps of D until H
>>>>>>>>>>>>>>>>>>>>>>> correctly predicts through
>>>>>>>>>>>>>>>>>>>>>>> the type of mathematical induction used by
>>>>>>>>>>>>>>>>>>>>>>> termination analyzers that D
>>>>>>>>>>>>>>>>>>>>>>> correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> terminate normally.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But that is the wrong prediction. It needs to
>>>>>>>>>>>>>>>>>>>>>> predict if the input when run will halt, as THAT
>>>>>>>>>>>>>>>>>>>>>> is the Halting Question.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is just like Jack's question posed to Jack,
>>>>>>>>>>>>>>>>>>>>> self-contradictory.
>>>>>>>>>>>>>>>>>>>>> ChatGPT could understand that I am correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, and you just seem too stupid to understand.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Thus, you are just admitting to working on POOP
>>>>>>>>>>>>>>>>>>>>>> instead of Halting, and ALL your statements are
>>>>>>>>>>>>>>>>>>>>>> just LIES.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int factorial(int n)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    if(n==0)
>>>>>>>>>>>>>>>>>>>>>>>      return(1);
>>>>>>>>>>>>>>>>>>>>>>>    return(n*factorial(n-1));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> AProVE correctly determines that factorial(5)
>>>>>>>>>>>>>>>>>>>>>>> halts by
>>>>>>>>>>>>>>>>>>>>>>> boiling the key behavior of entire function to this:
>>>>>>>>>>>>>>>>>>>>>>> f(x) → f(x-1) :|: x > 0 && x <= 5
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>  > Wrong Question leads to incorrect answer, and
>>>>>>>>>>>>>>>>>>>>>> all your work goes down
>>>>>>>>>>>>>>>>>>>>>> the drain.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> AProVE is the largest termination analysis project
>>>>>>>>>>>>>>>>>>>>> in the world.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, and it probably uses the RIGHT question, will
>>>>>>>>>>>>>>>>>>>> the program halt when actually run.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It will probably also tell you that D(D) will Halt
>>>>>>>>>>>>>>>>>>>> since H(D,D) returns 0.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, it likely shows you are wrong about everything.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When we use the criteria:
>>>>>>>>>>>>>>>>>>> Can D correctly simulated by H ever terminate normally?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you are ADMITTING to working on a different
>>>>>>>>>>>>>>>>>> problem, and lying about what you are doing. Thank you
>>>>>>>>>>>>>>>>>> for being honest about that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ben is just pointing out the ERRORS in your logic
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ben pointed out that H(P,P) reports that P(P) does
>>>>>>>>>>>>>>>>> not halt when
>>>>>>>>>>>>>>>>> P(P) does halt this seems to be a contradiction to
>>>>>>>>>>>>>>>>> people that lack a
>>>>>>>>>>>>>>>>> complete understanding.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> NO, it is a TRUE statement. H is NOT a correct HALT
>>>>>>>>>>>>>>>> DECIDER.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It might be a valid POOP decider with your altered
>>>>>>>>>>>>>>>> criteria, but it isn't correct as a Halt Decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You don't get to change the meaning of words, attempting
>>>>>>>>>>>>>>>> to just shows you are a liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Halting is a property of the original machine, not of
>>>>>>>>>>>>>>>> the partial simulation that H does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because of this I changed the semantic meaning of a
>>>>>>>>>>>>>>>>> return value of 0
>>>>>>>>>>>>>>>>> from H to mean either that P(P) does not halt or P(P)
>>>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>>>> targets H to do the opposite of whatever Boolean value
>>>>>>>>>>>>>>>>> that H returns.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Which means you H need to return BOTH a 0 and 1 at the
>>>>>>>>>>>>>>>> same time,
>>>>>>>>>>>>>>> Not at all. Not the least little bit.
>>>>>>>>>>>>>>> A return value of 0 also indicates that input D
>>>>>>>>>>>>>>> intentionally targets
>>>>>>>>>>>>>>> H by doing the opposite of whatever Boolean value that H
>>>>>>>>>>>>>>> returns.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But a return of 1 signals that it halts, which it does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You don't seem to understand English.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Halting Problem asks if the Machine Described by the
>>>>>>>>>>>>>> input Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It Does (for the H that you are cliaming to be correct)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Therefore, the correct answer is YES / Halting, and you
>>>>>>>>>>>>>> are PROVED to be a LIAR.
>>>>>>>>>>>>> If I am the one that is a Liar then why did you already say
>>>>>>>>>>>>> that 1 is
>>>>>>>>>>>>> the wrong answer and are now saying that it is the right
>>>>>>>>>>>>> answer?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Where did I say that 1 is the wrong answer to THAT question.
>>>>>>>>>>>>
>>>>>>>>>>> What happens when H returns 1 to D?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it doesn't, so it doesn't matter.
>>>>>>>>> No H can possibly be defined that can be embedded within
>>>>>>>>> Linz Ĥ such that embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ transitions to Ĥ.qy or Ĥ.qn
>>>>>>>>> consistently with the behavior of Ĥ applied to ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> Right, which is why it is impossible to make a correct Halt
>>>>>>>> Decider.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The reason for this is that Ĥ does the opposite of both
>>>>>>>>> Ĥ.qy and Ĥ.qn. This makes the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H
>>>>>>>>> self-contradictory for embedded_H.
>>>>>>>>
>>>>>>>> Not SELF contradicotory, but just contradictory.
>>>>>>>>
>>>>>>>
>>>>>>> OK that may make sense. One of our very rare agreements. The
>>>>>>> question does not contradict itself it contradicts every answer.
>>>>>>>
>>>>>>> Contradictory questions are also incorrect questions.
>>>>>>> Likewise Jack's question contradicts every answer.
>>>>>>>
>>>>>>
>>>>>> It doesn't contradict the answer to the actual question,
>>>>> If this is true then you can say which of yes/no are correct for
>>>>> Jack to
>>>>> reply and which of true/false that H can return.
>>>>>
>>>>
>>>> SO, you are just to dumb to understand
>>>
>>> That simply dodges my yes/no question.
>>>
>>> My IQ is probably higher than yours. Did you pass the Mensa test?
>>> In any case creative genius has its algorithm:
>>> https://www.scientificamerican.com/article/the-science-of-genius1/
>>
>> I never took the Mensa test, as I saw no benefit to taking it.
>>
>>>
>>> If this is true then you can say which of yes/no are correct for
>>> Jack to reply and which of true/false that H can return.
>>>
>>
>> How do you get that conclusion? You are working off BAD LOGIC.
>>
> In other words you are saying that when a question contradicts every
> answer From X that the reason that X cannot correctly answer the
> question has nothing to do with the fact that the question contradicts
> every answer from X instead it must be the case that X is very stupid.
>

On 6/20/2023 6:48 AM, Ben Bacarisse wrote:
> Richard Damon <news.x.richarddamon@xoxy.net> writes:
> ...
>
> If it's all the same to you, I'd much rather PO's stalking threads
> (those where tries to get my attention) simply died a natural death.

*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*

> He's become obsessed with me ever since I stopped talking to him, and I
> don't want him encouraged.
>

*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*

> If you must reply, at least change the subject so that it's accurate (as
> above!).
>

On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
> Just a reminder that you are arguing with someone who has
> declared that the wrong answer is the right one:
>
> Me: "do you still assert that [...] false is the "correct"
> answer even though P(P) halts?"
>
> PO: Yes that is the correct answer even though P(P) halts.

Because
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
*Ben Bacarisse targets my posts to discourage honest dialogue*
All of my posts will be entitled as a Rebuttal to Ben

It is an easily verified fact that P correctly simulated by H cannot
possibly reach its own last instruction and terminate normally thus from
the Professor Sipser agreed criteria the input to H(P,P) does not halt.

MIT Professor Michael Sipser has agreed that the following verbatim
words are correct (he has not agreed to anything else):
(a) 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
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

To address what looks like a contradiction to reviewers not having a
very deep understanding of the halting problem:

(1) A return value of 1 from H(D,D) means the input to H(D,D) has halted

(2) A return value of 0 from H(D,D) has been redefined to mean
(a) D does not halt
(b) D has been defined to do the opposite of whatever Boolean value
that H returns.

*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
*THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/22/23 2:00 PM, olcott wrote:
> On 6/20/2023 6:48 AM, Ben Bacarisse wrote:
>> Richard Damon <news.x.richarddamon@xoxy.net> writes:
>> ...
>>
>> If it's all the same to you, I'd much rather PO's stalking threads
>> (those where tries to get my attention) simply died a natural death.
>
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*

No, he points out the truth of what you have been saying.

You actually don't WANT "Honest Dialog", because the only Honest Dialog
that CAN occc

>
>> He's become obsessed with me ever since I stopped talking to him, and I
>> don't want him encouraged.
>>
>
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
>
>> If you must reply, at least change the subject so that it's accurate (as
>> above!).
>>
>
> On 6/19/2023 3:08 PM, Ben Bacarisse wrote:
>  > Just a reminder that you are arguing with someone who has
>  > declared that the wrong answer is the right one:
>  >
>  > Me: "do you still assert that [...] false is the "correct"
>  > answer even though P(P) halts?"
>  >
>  > PO: Yes that is the correct answer even though P(P) halts.
>
> Because
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> *Ben Bacarisse targets my posts to discourage honest dialogue*
> All of my posts will be entitled as a Rebuttal to Ben

So, you can't stand your own words being quoted back to you, with their
meaning explained?

Do you not agree that you said those things?

What is not "Honest" about what he said.

YOU seem to be the one that doesn't what "Honest Dialog" because you
freak out when someone disagrees with you.

>
> It is an easily verified fact that P correctly simulated by H cannot
> possibly reach its own last instruction and terminate normally thus from
> the Professor Sipser agreed criteria the input to H(P,P) does not halt.

Which is irrelevent, as pointed out many times.

You are apparently just to stupid to understand.

>
> MIT Professor Michael Sipser has agreed that the following verbatim
> words are correct (he has not agreed to anything else):
> (a) 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
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.

Yes, if H can show that an ACTUALLY CORRECT SIMULATION (which mean as
per a UTM, i.e. never aborted, of the ACTUAL INPUT) wouldn't halt, then
H can abort its simulation. SInce H does abort and return 0, that
condition isn't true. and you are just shown to be s stupid liar.

>
> To address what looks like a contradiction to reviewers not having a
> very deep understanding of the halting problem:
>
> (1) A return value of 1 from H(D,D) means the input to H(D,D) has halted
>
> (2) A return value of 0 from H(D,D) has been redefined to mean
>     (a) D does not halt
>     (b) D has been defined to do the opposite of whatever Boolean value
>         that H returns.

So, you are admitting to being a liar about working on the Halting
Problem, or a total idiot that doesn't understand a thing about what you
are talking.

>
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
> *THIS CHANGE UTTERLY REFUTES BEN'S REBUTTAL*
>
>

Nope, it says H is a correct POOP decider, not a Halt Decider, and you
are shown to be a Hypocritical Ignornat Pathalogical Lying Insane Idiot.