On 5/24/2022 5:54 AM, Richard Damon wrote:
>
> On 5/24/22 12:31 AM, olcott wrote:
>> On 5/23/2022 11:22 PM, Richard Damon wrote:
>>>
>>> On 5/23/22 11:47 PM, olcott wrote:
>>>> On 5/23/2022 10:16 PM, Dennis Bush wrote:
>>>>> On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
>>>>>> On 5/23/2022 10:05 PM, Dennis Bush wrote:
>>>>>>> On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
>>>>>>>> On 5/23/2022 9:57 PM, Dennis Bush wrote:
>>>>>>>>> On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/23/2022 9:40 PM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 5/23/22 9:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/23/2022 8:29 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 7:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 6:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/22 3:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All things being equal which is more likely:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Olcott is correct and everybody else is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Olcott is incorrect and everybody else
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Believability has the word [lie] embedded
>>>>>>>>>>>>>>>>>>>>>>>>>>>> directly within
>>>>>>>>>>>>>>>>>>>>>>>>>>>> itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Instead of the fake measure of credibility
>>>>>>>>>>>>>>>>>>>>>>>>>>>> one must employ
>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>> validation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actual validation conclusively proves that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct. This means that everyone that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagrees is either
>>>>>>>>>>>>>>>>>>>>>>>>>>>> insufficiently technically competent or a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You consider that H(P,P) == 0 is correct when
>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) halts,
>>>>>>>>>>>>>>>>>>>>>>>>>>> when that is
>>>>>>>>>>>>>>>>>>>>>>>>>>> the DEFINITION of what H(P,P) is supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>> be answering?
>>>>>>>>>>>>>>>>>>>>>>>>>> The C function H correctly determines that
>>>>>>>>>>>>>>>>>>>>>>>>>> there are no number
>>>>>>>>>>>>>>>>>>>>>>>>>> of steps
>>>>>>>>>>>>>>>>>>>>>>>>>> (0 to infinity) of its correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>> its input: a pair of
>>>>>>>>>>>>>>>>>>>>>>>>>> pointers to finite strings of x86 machine
>>>>>>>>>>>>>>>>>>>>>>>>>> language that would
>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>> the last instruction of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But since H has a fixed algorithm, it can't
>>>>>>>>>>>>>>>>>>>>>>>>> simulate for an
>>>>>>>>>>>>>>>>>>>>>>>>> infinite number of steps. It can only simulate
>>>>>>>>>>>>>>>>>>>>>>>>> P for some n
>>>>>>>>>>>>>>>>>>>>>>>>> number of steps.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> None-the-less on the basis of matching known
>>>>>>>>>>>>>>>>>>>>>>>> behavior patterns H
>>>>>>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>>>>>>> determine what the behavior of the input would
>>>>>>>>>>>>>>>>>>>>>>>> be if it did
>>>>>>>>>>>>>>>>>>>>>>>> simulate an
>>>>>>>>>>>>>>>>>>>>>>>> infinite number of steps.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So because Pn(Pn) does not halt then Ha(Pa,Pa)==0
>>>>>>>>>>>>>>>>>>>>>>> is correct?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No jackass, infinite loop does not halt because
>>>>>>>>>>>>>>>>>>>>>> infinite loop is an
>>>>>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>> [000012c2](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>> [000012c3](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>> [000012c5](02) ebfe jmp 000012c5
>>>>>>>>>>>>>>>>>>>>>> [000012c7](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>> [000012c8](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [000012
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Irrelevant, because this isn't part of any P.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It not irrelevant jackass it proves that H can
>>>>>>>>>>>>>>>>>>>> detect that an infinite
>>>>>>>>>>>>>>>>>>>> simulation would never halt without performing an
>>>>>>>>>>>>>>>>>>>> infinite simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> An infinite loop and the infinite simulation in
>>>>>>>>>>>>>>>>>>> Pn(Pn) are different,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It sure is _Infinite_Loop() is on topic and H(P,P) is
>>>>>>>>>>>>>>>>>> on topic
>>>>>>>>>>>>>>>>>> and Pn(Pn) is a strawman error intentionally designed
>>>>>>>>>>>>>>>>>> to deceive.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If _Infinite_Loop, which isn't at all related to P is
>>>>>>>>>>>>>>>>> on topic, then Pn,
>>>>>>>>>>>>>>>>> which is one of the P's you talk about must be.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I get to decide what is on topic and what is off topic,
>>>>>>>>>>>>>>>> I own the topic.
>>>>>>>>>>>>>>>>> Remember, you confusingly talk about a CLASS of H's
>>>>>>>>>>>>>>>>> since the H you keep
>>>>>>>>>>>>>>>>> on mentioning doesn't have a distinct rule (since if
>>>>>>>>>>>>>>>>> changes how much is
>>>>>>>>>>>>>>>>> simulates to be every possible length of simulation),
>>>>>>>>>>>>>>>>> thus giving them
>>>>>>>>>>>>>>>>> distinct names is a reasonable thing to do.
>>>>>>>>>>>>>>>> I am referring to one machine language immutable literal
>>>>>>>>>>>>>>>> string named H
>>>>>>>>>>>>>>>> and another immutable machine language literal string
>>>>>>>>>>>>>>>> named P.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then we'll refer to H as Ha and refer to P as Pa.
>>>>>>>>>>>>>> No we will not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> We all know exactly why not. Because by being clear about
>>>>>>>>>>>>> which H and which P we're talking about, it exposes the
>>>>>>>>>>>>> holes in your argument and makes it clear exactly where the
>>>>>>>>>>>>> problem is. So as Ben has said, clarity is your enemy.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So explain exactly what is wrong with the below statement.
>>>>>>>>>>>>> Failure to explain in detail why it is wrong in your next
>>>>>>>>>>>>> post will be taken as not being able to explain why it is
>>>>>>>>>>>>> wrong and an acceptance that it is correct. Stating
>>>>>>>>>>>>> "strawman" without an explanation will be taken as a
>>>>>>>>>>>>> failure to explain.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simulating the input to Ha(Pa,Pa) up to an infinite number
>>>>>>>>>>>>> of steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0
>>>>>>>>>>>>> is wrong. And Hb(Pa,Pa)==1 which also shows that
>>>>>>>>>>>>> Ha(Pa,Pa)==0 is wrong. And yes the input to Ha(Pa,Pa) is
>>>>>>>>>>>>> the same as the input to Hb(Pa,Pa), and you have no basis
>>>>>>>>>>>>> to claim otherwise.
>>>>>>>>>>>>>
>>>>>>>>>>>> It is just like you are saying that because the dog named
>>>>>>>>>>>> Spot is black
>>>>>>>>>>>> and the cat named Fluffy is white therefore the dog named
>>>>>>>>>>>> Rover cannot
>>>>>>>>>>>> be brown.
>>>>>>>>>>>>
>>>>>>>>>>>> Ha(Pa,Pa)
>>>>>>>>>>>> Hb(Pa,Pa)
>>>>>
>>>>>>>>>>>> Simulate(Pa,Pa)
>>>>>>>>>>>>
>>>>>>>>>>>> are computationally distinct at the x86 machine language level
>>>>>>>>>>>> and you have always known this therefore you are a damned liar.
>>>>>>>>>>>
>>>>>>>>>>> I know that you *claim* they are distinct, but you have
>>>>>>>>>>> nothing to back that up. Both Ha and Hb are halt deciders and
>>>>>>>>>>> both are given the same exact input.
>>>>>>>>>>>
>>>>>>>>>> P does not call anything besides H
>>>>>>>>>
>>>>>>>>> And because the fixed algorithm of H aborts, then H is the same
>>>>>>>>> as Ha and P is therefore the same as Pa.
>>>>>>>> How dishonest can you get?
>>>>>>>> It is the same as if you claimed that 5 == 6
>>>>>>>>
>>>>>>>> Because they have entirely different execution traces
>>>>>>>
>>>>>>> They're identical up to the point that Ha aborts,
>>>>>> They are not identical therefore it is either ridiculously stupid to
>>>>>> claim that they should have the same behavior or in your case
>>>>>> (because
>>>>>> we know that you are not stupid) it would be dishonest.
>>>>>
>>>>> If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim
>>>>> the traces differ, then that would also mean that
>>>>
>>>> Since you always knew this: that you are a liar when
>>>> you claimed that they are equivalent.
>>>>
>>>>  >>>>>>> I know that you *claim* they are distinct, but you have
>>>> nothing to back that up.
>>>>
>>>> I don't think that we are getting anywhere.
>>>>
>>>> All of the recent discussions are simply disagreement with an easily
>>>> verifiable fact. Any smart software engineer with a sufficient
>>>> technical background can easily confirm that H(P,P)==0 is correct:
>>>
>>> No, they can confirm that it MUST be INCORECT by the requirement of H.
>>>
>>> P(P) will Halt if H(P,P) returns 0.
>>>
>>> H(P,P) is REQUIRED to return 1 if P(P) halts, that is the DEFINITION
>>> of a Halting Decider, thus H is wrong.
>>>
>>> You are NOT allowed to change the Definition of the problem and still
>>> claim to be working on the problem.
>>>
>>> That is like you saying it is ok to say "I have no dogs in my house"
>>> when someone asks "Howmany Cats are in your houst?"
>>>
>>>>
>>>> Where H is a C function that correctly emulates its input pair of
>>>> finite strings of the x86 machine code of function P and criterion
>>>> for returning 0 is that the simulated P would never reach its "ret"
>>>> instruction.
>>>
>>> Except that it DOESN'T correctly emulates its input if it aborts it.
>>>
>>> And your finite string that you claim is P doesn't define the program
>>> P as it refers to code outside the string. (PROGRAMS are complete,
>>> and Halting is defined on COMPLETE PROGRAMS).
>>>
>>>>
>>>> The only other remaining objection is whether or not a halt decider
>>>> must compute the mapping of its input finite strings to an accept or
>>>> reject state on the basis of the actual behavior actually specified
>>>> by its input OR SOME OTHER MEASURE.
>>>
>>>
>>> Right, and the BEHAVIOR OF THE INPUT for H(P,P) IS *DEFINED* to be
>>> whether P(P) Halts or not. Any other defintion and you are not
>>> working on the Halting Problem.
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V5)
>>>>
>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>
>>>>
>>>
>>> Just a bunch of garbage that shows you don't know what you are
>>> talking about. Detail reviews given previously.
>>>
>>>
>>>>
>>>>
>>>>
>>>> That is all that any of you have and good software engineering
>>>> refutes the first and good computer science refutes the second.
>>>
>>> Nope, GOOD computer science shows that you are not good at computer
>>> science and fail to comprehend even the basics of it.
>>
>> (1) Good software engineering proves that H(P,P)==0 is correct.
>
> Nope, already explained.

A software engineer with sufficient technical competence would disagree.

>
>>
>> (2) Good computer science shows that a halt decider must
>> compute the mapping from its input finite strings to an accept or
>> reject state on the basis of the actual behavior actually specified by
>> its input.
>>
>
> Right, is CAN only compute an answer from a finite algorithm from its
> input, but such an answer doesn't match the definition of the problem,
> so a machine that computes the Halting Function can't exist.
>

A computer scientist with sufficient technical competence would disagree.

> Your H may be a successfuly be "A Decider", but it fails to be "A Halt
> Decider" since H(P,P) doesn't match the halting behavior of P(P).

--
Copyright 2022 Pete Olcott

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