On 1/31/24 9:52 AM, olcott wrote:
> On 1/31/2024 2:30 AM, Mikko wrote:
>> On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
>>
>>> Op 30.jan.2024 om 15:52 schreef olcott:
>>>> On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
>>>>> Op 30.jan.2024 om 06:05 schreef olcott:
>>>>>> On 1/29/2024 9:01 PM, Richard Damon wrote:
>>>>>>> On 1/29/24 9:30 PM, olcott wrote:
>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>> On 1/29/24 1:19 PM, olcott wrote:
>>>>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>>>> On 1/29/24 15:30, olcott wrote:
>>>>>>>>>>>> On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 28.jan.2024 om 16:28 schreef olcott:
>>>>>>>>>>>>>> On 1/28/2024 6:12 AM, immibis wrote:
>>>>>>>>>>>>>>> On 1/28/24 01:36, olcott wrote:
>>>>>>>>>>>>>>>> On 1/27/2024 6:33 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 1/28/24 01:32, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/27/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/27/2024 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem has been intentionally defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be unsatisfiable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is required to report on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that reports
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether the direct execution of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever an input calls its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive simulation then H is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on different behavior than the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it sees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H that must abort its simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any input D to prevent its own infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution is necessarily correct to reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to write a program that reports whether the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *It in incorrect for H to do this in some
>>>>>>>>>>>>>>>>>>>>>>>>>>>> cases*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Why would it be incorrect to answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>> question actually asked?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Does D specify halting behavior to H?
>>>>>>>>>>>>>>>>>>>>>>>>>> No it does not.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it specifies Halting Behavior to EVERYONE,
>>>>>>>>>>>>>>>>>>>>>>>>> as the actual property of Halting is
>>>>>>>>>>>>>>>>>>>>>>>>> independent of who you ask.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> D specifies infinite recursion to H.
>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> D specifies what ever recursion that H generates.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> D specifies recursive simulation to H forcing H to
>>>>>>>>>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> D only specifies as much recursive simulation to H
>>>>>>>>>>>>>>>>>>>>> as H actually does.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID OR
>>>>>>>>>>>>>>>>>>>> LIARS*
>>>>>>>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer H
>>>>>>>>>>>>>>>>>>>> must abort the
>>>>>>>>>>>>>>>>>>>> simulation of its input D to prevent its own
>>>>>>>>>>>>>>>>>>>> infinite execution
>>>>>>>>>>>>>>>>>>>> it is always necessarily correct for H to reject
>>>>>>>>>>>>>>>>>>>> this input as
>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And the decision to abort was encoded in the program
>>>>>>>>>>>>>>>>>>> of H, and thus into the program of D, so when you
>>>>>>>>>>>>>>>>>>> "alter" H to not abort to show this, D doesn't change
>>>>>>>>>>>>>>>>>>> and still refers to the H that did abort.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you are claiming that you just don't understand
>>>>>>>>>>>>>>>>>> that every H that
>>>>>>>>>>>>>>>>>> can possibly exist must abort its simulated D because
>>>>>>>>>>>>>>>>>> this is simply
>>>>>>>>>>>>>>>>>> over your head because you are not very smart?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Who's talking about every H that could possibly exist?
>>>>>>>>>>>>>>>>> You wrote just one H, not every one that could possibly
>>>>>>>>>>>>>>>>> exist.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Peter Linz proof uses a program template
>>>>>>>>>>>>>>>> simultaneously referring
>>>>>>>>>>>>>>>> every H that can possibly exist.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Peter Linz proof template tells you how to make a
>>>>>>>>>>>>>>> proof for the H that you have.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is why I apply my proof of H/D to the Linz proof
>>>>>>>>>>>>>> in my paper. Richard just doesn't seem to get the idea
>>>>>>>>>>>>>> of a program template. He does not understand that
>>>>>>>>>>>>>> analysis can be simultaneously applied to an infinite
>>>>>>>>>>>>>> set of programs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> One of the problems in this discussion is that different
>>>>>>>>>>>>> instantiations can be made of a template and olcott gives
>>>>>>>>>>>>> them all the same name.
>>>>>>>>>>>>> Just as he uses the same name for different halt deciders,
>>>>>>>>>>>>> some of which abort and others do not abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>> May I suggest a naming for the different candidate halt
>>>>>>>>>>>>> decoders?
>>>>>>>>>>>>> Here we limit ourselves to simulating halt deciders. We can
>>>>>>>>>>>>> imagine three candidates:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hss: A simple simulating halt decider, which does not
>>>>>>>>>>>>> abort. It is clear it can report only about programs which
>>>>>>>>>>>>> terminate normally.In this case it returns 'halting'. It
>>>>>>>>>>>>> cannot return 'non-halting' in a finite time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Han: A simulating halt decider that, when it recognizes
>>>>>>>>>>>>> that the program uses the same algorithm that is used in
>>>>>>>>>>>>> Han to do the opposite, it aborts and returns
>>>>>>>>>>>>> 'non-halting'. (For the sake of this discussion, we ignore
>>>>>>>>>>>>> that it very improbable that Han will be possible to
>>>>>>>>>>>>> recognize all variations of the algorithm, because we stick
>>>>>>>>>>>>> for the moment to the template mentioned above. Similarly
>>>>>>>>>>>>> it will not be easy to detect always that the program does
>>>>>>>>>>>>> the opposite.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is clear that Han is wrong if it assumes that Han will
>>>>>>>>>>>>> do an infinite recursion, because it is Hss that does an
>>>>>>>>>>>>> infinite recursion, not Han.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hah: A simulating halt decider, similar to Han, but when it
>>>>>>>>>>>>> recognizes that the same algorithm is used to do the
>>>>>>>>>>>>> opposite, it aborts and returns 'halting'.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is clear that Hah is wrong if it assumes that Hah will
>>>>>>>>>>>>> do an infinite recursion, because it is Hss that does an
>>>>>>>>>>>>> infinite recursion, not Hah.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Using these names it is no longer needed to use
>>>>>>>>>>>>> overcomplicated sentence fragments, such as 'keeps looping
>>>>>>>>>>>>> unless aborted'. Because, for Hss 'keeps looping' is
>>>>>>>>>>>>> sufficient, whereas for Han and Hah 'does not loop, because
>>>>>>>>>>>>> aborted' is more clear.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A halting decider needs a program to decide on. It cannot
>>>>>>>>>>>>> decide on a template, because different instantiations of a
>>>>>>>>>>>>> template can do different things. Therefore, from these
>>>>>>>>>>>>> three candidates the template can be used to create three
>>>>>>>>>>>>> programs:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Dss: based on Hss. It is clear that it does not halt,
>>>>>>>>>>>>> because Hss does not halt.
>>>>>>>>>>>>> Dan: based on Han. Han returns 'non-halting', so Dan halts.
>>>>>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does not
>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Again, we do no longer need overcomplicated sentences with
>>>>>>>>>>>>> 'unless', because it is clear that only Dss is involved in
>>>>>>>>>>>>> infinite recursion within the algorithm of Hss. Dan and Dah
>>>>>>>>>>>>> are not, because Han and Hah are not.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Three programs and three candidate halt deciders. That
>>>>>>>>>>>>> results in nine combinations:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hss(Dss,Dss): Hss does not halt and never returns a result.
>>>>>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han. Simulation
>>>>>>>>>>>>> ends normally and Hss reports 'Halting'.
>>>>>>>>>>>>> Hss(Dah,Dah): Hss simulates Dah, including Hah. The
>>>>>>>>>>>>> simulation of Hah returns to the simulation of Dah, which
>>>>>>>>>>>>> does not end. So Hss never returns a result.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Han(Dss,Dss): Han is different from Hss, so the simulation
>>>>>>>>>>>>> of Hss is not aborted. So, does Han recognize the infinite
>>>>>>>>>>>>> recursion? That depends on details not provided by olcott.
>>>>>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm, aborts and
>>>>>>>>>>>>> reports 'non-halting'.
>>>>>>>>>>>>> Han(Dah,Dah): Han is different from Hah, so the simulation
>>>>>>>>>>>>> of Hah is not aborted. The simulation of Hah returns with
>>>>>>>>>>>>> 'halting'. Does Han subsequently recognize that D starts an
>>>>>>>>>>>>> infinite loop? That depends on details not provides by olcott.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hah(Dss,Dss): Hah is different from Hss, so the simulation
>>>>>>>>>>>>> of Hss is not aborted. So, does Hah recognize the infinite
>>>>>>>>>>>>> recursion? That depends on details not provided by olcott.
>>>>>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the simulation
>>>>>>>>>>>>> of Han is not aborted. The simulation of Ha returns with
>>>>>>>>>>>>> 'non-halting'. The simulation of D will end normally and
>>>>>>>>>>>>> Hah will report 'halting'.
>>>>>>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts and
>>>>>>>>>>>>> reports 'halting'.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>  From these nine combinations we see that only a few are
>>>>>>>>>>>>> definitely able to report a correct status. we also see
>>>>>>>>>>>>> that the three most important ones Hss(Dss,Dss),
>>>>>>>>>>>>> Han(Dan,Dan) and Hah(Dah,Dah) do not return the correct
>>>>>>>>>>>>> status.
>>>>>>>>>>>>>
>>>>>>>>>>>>> May I suggest that we stick to these names, instead of
>>>>>>>>>>>>> using the same names D and H for different things? That
>>>>>>>>>>>>> would make the discussion more transparent. And maybe
>>>>>>>>>>>>> olcott can tell which case is in discussion, Hss(Dss,Dss),
>>>>>>>>>>>>> Han(Dan,Dan) or Hah(Dah,Dah), or one of the other
>>>>>>>>>>>>> combinations. Are we talking about an aborting, or a
>>>>>>>>>>>>> non-aborting decider? I ask this, because sentence
>>>>>>>>>>>>> fragments like 'keeps looping unless aborted', suggests
>>>>>>>>>>>>> that it is not always aborted, so it is not clear whether
>>>>>>>>>>>>> Hss, Han, or Han is meant.
>>>>>>>>>>>>
>>>>>>>>>>>> My whole purpose is to show the only possible way that H can be
>>>>>>>>>>>> correctly encoded is the current way that H is encoded.
>>>>>>>>>>>
>>>>>>>>>>> And which way is that? Is it Hss, Han, Hap or something else?
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Every H that correctly determines in N steps of correct
>>>>>>>>>>>> simulation of
>>>>>>>>>>>> input D that itself would never stop running unless it
>>>>>>>>>>>> aborts its
>>>>>>>>>>>> simulation of D is necessarily correct to report that *D
>>>>>>>>>>>> DOES NOT HALT*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You aren't listening.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am listening and I am overriding and superseding misconception.
>>>>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that you aren't ALLOWED to change definitions and stay
>>>>>>>>> in the same Theory. If you try, you have just thrusted your
>>>>>>>>> self into a DIFFERENT field of PO-Compuations and your POOP
>>>>>>>>> problem.
>>>>>>>>
>>>>>>>> Halt deciders have always been required to compute the mapping
>>>>>>>> from their finite strong input to their own accept or reject
>>>>>>>> state on the basis of *THE BEHAVIOR THAT THIS FINITE STRING
>>>>>>>> SPECIFIES*
>>>>>>>>
>>>>>>>
>>>>>>> Strings themselves do not have "Behavior"
>>>>>>
>>>>>> In computability theory, Rice's theorem states that all
>>>>>> non-trivial semantic properties of programs are undecidable. A
>>>>>> semantic property is one *about the program's behavior* (for
>>>>>> instance, does the program terminate for all inputs), unlike a
>>>>>> syntactic property (for instance, does the program contain an
>>>>>> if-then-else statement). A property is non-trivial if it is
>>>>>> neither true for every program, nor false for every program.
>>>>>> https://en.wikipedia.org/wiki/Rice%27s_theorem
>>>>>>>
>>>>>>> The the behavior specified by the input is NOT the Halting
>>>>>>> Behavior of the Compuation described by the input,
>>>>>>
>>>>>> The term "specified" is more precise than "described by". The
>>>>>> latter term allows indirect reference whereas the former one
>>>>>> does not.
>>>>>>
>>>>>> D simulated by H such that H executes the x86 machine code that
>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is
>>>>>> to incorrectly execute the x86 machine code that D specifies.
>>>>>>
>>>>>
>>>>> Which D?
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> Every correct H correctly aborts its corresponding D and correctly
>>>> rejects D as non-halting.
>>>>
>>>
>>> Olcott keeps hiding the details. Which H is shown here?
>>> If it is the aborting H, which we call Han, then there is no need to
>>> abort D, because Han aborts itself already. It cannot be at the same
>>> time Hss, which does not abort. Hss and Han are different deciders
>>> with different behaviour and therefore, Dss is different from Dan
>>>
>>> Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
>>
>> As Olcott uses in his proofs the inferene rule knonw as equivocation
>> he must restrict his naming conventions.
>>
>
> When one understands that simulating termination analyzer H
> is always correct to abort any simulation that cannot possibly
> stop running unless aborted
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> Then every simulating termination analyzer H specified by
> the above template is correct to abort its simulation of D
> and reject D as non-halting.
>

On 1/31/24 9:43 AM, olcott wrote:
> On 1/31/2024 2:24 AM, Mikko wrote:
>> On 2024-01-30 15:03:10 +0000, olcott said:
>>
>>> On 1/30/2024 5:37 AM, Mikko wrote:
>>>> On 2024-01-29 22:18:11 +0000, olcott said:
>>>>
>>>>> On 1/29/2024 4:11 PM, immibis wrote:
>>>>>> On 1/29/24 19:19, olcott wrote:
>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>
>>>>>>>> You aren't listening.
>>>>>>>>
>>>>>>>
>>>>>>> I am listening and I am overriding and superseding misconception.
>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>
>>>>>>
>>>>>> You have now ignored my formulation of the halting problem four
>>>>>> (4) times.
>>>>>
>>>>> There is only one single relevant detail and changing the subject away
>>>>> from this is off topic thus must be ignored.
>>>>
>>>> Be specific: the relevant detail is that H is a halt decider
>>>> only if H(D,D) <-> D(D) halts.
>>>
>>> It is a verified fact that the x86 machine code of D specifies
>>> recursive simulation to H.
>>
>>  From the meanings of the words follow (so you may call it self-evident)
>> that if H(D,D) specifes an infinite recursion for any D then
>> H is not a halt decider (nor any other decider, either).
>>
>
> It is a verified fact that input D specifies recursive
> simulation to every simulating termination analyzer H.
>

FINITE to any H that aborts its simulation of D(D), and thus can specify
Halting behavior.

On 1/31/24 10:54 AM, olcott wrote:
> On 1/31/2024 7:04 AM, immibis wrote:
>> On 1/31/24 01:56, olcott wrote:
>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>> On 1/31/24 01:31, olcott wrote:
>>>>> I have already been completely through your idea with hundreds of
>>>>> posts on another forum with someone else before I determined that
>>>>> it is nonsense using set theory.
>>>>
>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>
>>>> The halting problem is to decide whether the execution sequence of a
>>>> Turing machine/input pair is finite or infinite.
>>>>
>>>
>>> Close but no cigar. No TM can take another TM as input, it
>>> can only take finite strings as input.
>>>
>>> The halting problem is whether or not a finite string pair
>>> (TM description and its input)
>>>
>>> *specifies a finite sequence of configurations*
>>> *specifies a finite sequence of configurations*
>>> *specifies a finite sequence of configurations*
>>>
>>
>> The halting problem is whether or not you get a finite sequence of
>> configurations when you execute the finite string pair according to
>> Turing Machine rules and no other rules.
>
> *No that is a common misconception*
> The halting problem is actually about computing the mapping
> from an input finite string pair such the the first element of
> this pair species behavior. It is the behavior that this finite
> string specifies that must be reported on.

Right, and that behavior specified is the state sequence generated by
running the turing Machine and input descirbed, which since that Turing
Machine when run, halts, means H must accept this input.

>
> When D does call H in recursive simulation such that D cannot
> possibly stop running unless aborted the H is necessarily correct
> to abort D and reject D as non-halting.

But that D DOES stop running, and it CAN'T have been aborted, as actual
Turing Machines are not "simulation" but free running machies,

>
> D correctly simulated by H cannot possibly reach the point in
> its own execution trace where it does the opposite of whatever
> value that H returns.
>
>
The problem is not "D", but the fact that your H doesn't "Correctly
Simulate" its input.

We don't talk about "any H" or "any D" but THIS D and THIS H.

If THIS H aborts and return non-halting, (and thus doesn't do a correct
simulation) then THIS D will halt, as will a correct simulation of it.

If you CHANGE PROBLEM to a different H, which isn't the one you are
claiming gets the right answer (because you know it doen't answer) and
actually does a correct simulation, then you are right THIS OTHER D
(which is different from above) is non-halting, but so is H, so it isn't
a decider.

The first H can't claim its input is the other D, because then you are
lying that D was built by the required formula, that of using the
decider that is claimed to be correct.

Op 31.jan.2024 om 23:04 schreef olcott:
> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 18:16 schreef olcott:
>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>> hundreds of
>>>>>>>>>>> posts on another forum with someone else before I determined
>>>>>>>>>>> that
>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>
>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>
>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>> can only take finite strings as input.
>>>>>>>>>
>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>> (TM description and its input)
>>>>>>>>>
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>
>>>>>>>>
>>>>>>>> The halting problem is whether or not you get a finite sequence
>>>>>>>> of configurations when you execute the finite string pair
>>>>>>>> according to Turing Machine rules and no other rules.
>>>>>>>
>>>>>>> *No that is a common misconception*
>>>>>>> The halting problem is actually about computing the mapping
>>>>>>> from an input finite string pair such the the first element of
>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>> string specifies that must be reported on.
>>>>>>>
>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>> to abort D and reject D as non-halting >
>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>> value that H returns.
>>>>>>>
>>>>>>
>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>
>>>>> *PREMISE*
>>>>> *When one understands that simulating termination analyzer H*
>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>> *stop running unless aborted
>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>> running), does stop and it is incorrect to abort it. So, the premise
>>>> causes a contradiction, therefore the premise is false. So, such a H
>>>> does not exist.
>>>>
>>>> Now we get the non-existing D derived from this non-existing H.
>>>>
>>>>>
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>
>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>
>>>> The premise which is shown to be false. Which makes the following
>>>> sentences vacuous.
>>>>
>>>
>>> All halt deciders must report on what the behavior of their
>>> input would be. None are required to infinitely simulate
>>> their input to correctly determine that their input would
>>> never halt.
>>
>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts
>
> I have spent far too many weeks on this convoluted bullshit Dennis Bush
> mostly on another forum.
>
> There is one infinite set of H/D pairs where every H correctly
> determines the halt status of its corresponding D every other
> freaking thing else is a dishonest dodge away from the point.
>
> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
> before I stopped tolerating them from anyone.
>

Strange. Most people will understand that olcotts claim is false within
a few days, but olcott does not even understand it after a dozen years.
I am afraid he will need an infinite time to understand it. Probably a
bug in the AI.

On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
> Op 31.jan.2024 om 23:04 schreef olcott:
>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>> hundreds of
>>>>>>>>>>>> posts on another forum with someone else before I determined
>>>>>>>>>>>> that
>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>
>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>> (TM description and its input)
>>>>>>>>>>
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The halting problem is whether or not you get a finite sequence
>>>>>>>>> of configurations when you execute the finite string pair
>>>>>>>>> according to Turing Machine rules and no other rules.
>>>>>>>>
>>>>>>>> *No that is a common misconception*
>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>> string specifies that must be reported on.
>>>>>>>>
>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>> value that H returns.
>>>>>>>>
>>>>>>>
>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>
>>>>>> *PREMISE*
>>>>>> *When one understands that simulating termination analyzer H*
>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>> *stop running unless aborted
>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>> premise causes a contradiction, therefore the premise is false. So,
>>>>> such a H does not exist.
>>>>>
>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>
>>>>>>
>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>
>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>
>>>>> The premise which is shown to be false. Which makes the following
>>>>> sentences vacuous.
>>>>>
>>>>
>>>> All halt deciders must report on what the behavior of their
>>>> input would be. None are required to infinitely simulate
>>>> their input to correctly determine that their input would
>>>> never halt.
>>>
>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which aborts
>>
>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>> mostly on another forum.
>>
>> There is one infinite set of H/D pairs where every H correctly
>> determines the halt status of its corresponding D every other
>> freaking thing else is a dishonest dodge away from the point.
>>
>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>> before I stopped tolerating them from anyone.
>>
>
> Strange. Most people will understand that olcotts claim is false within
> a few days, but olcott does not even understand it after a dozen years.
> I am afraid he will need an infinite time to understand it. Probably a
> bug in the AI.
>

Three PhD computer science professors agree.

Does the halting problem place an actual limit on computation?
https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation

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

On 2/1/2024 3:54 AM, Mikko wrote:
> On 2024-01-31 17:18:32 +0000, olcott said:
>
>> On 1/31/2024 11:12 AM, Mikko wrote:
>>> On 2024-01-31 14:52:29 +0000, olcott said:
>>>
>>>> On 1/31/2024 2:30 AM, Mikko wrote:
>>>>> On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
>>>>>
>>>>>> Op 30.jan.2024 om 15:52 schreef olcott:
>>>>>>> On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
>>>>>>>> Op 30.jan.2024 om 06:05 schreef olcott:
>>>>>>>>> On 1/29/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>> On 1/29/24 9:30 PM, olcott wrote:
>>>>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/29/24 1:19 PM, olcott wrote:
>>>>>>>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>>>>>>> On 1/29/24 15:30, olcott wrote:
>>>>>>>>>>>>>>> On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 28.jan.2024 om 16:28 schreef olcott:
>>>>>>>>>>>>>>>>> On 1/28/2024 6:12 AM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 1/28/24 01:36, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:33 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:32, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science professors
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem has been intentionally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to be unsatisfiable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is required to report on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever an input calls its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive simulation then H is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on different behavior than the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it sees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H that must abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of any input D to prevent its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite execution is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject D as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that reports
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether the direct execution of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *It in incorrect for H to do this in some
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cases*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why would it be incorrect to answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question actually asked?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does D specify halting behavior to H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it does not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it specifies Halting Behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> EVERYONE, as the actual property of Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is independent of who you ask.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies infinite recursion to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies what ever recursion that H generates.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> D specifies recursive simulation to H forcing H
>>>>>>>>>>>>>>>>>>>>>>>>> to abort
>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> D only specifies as much recursive simulation to
>>>>>>>>>>>>>>>>>>>>>>>> H as H actually does.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID
>>>>>>>>>>>>>>>>>>>>>>> OR LIARS*
>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulating termination analyzer
>>>>>>>>>>>>>>>>>>>>>>> H must abort the
>>>>>>>>>>>>>>>>>>>>>>> simulation of its input D to prevent its own
>>>>>>>>>>>>>>>>>>>>>>> infinite execution
>>>>>>>>>>>>>>>>>>>>>>> it is always necessarily correct for H to reject
>>>>>>>>>>>>>>>>>>>>>>> this input as
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And the decision to abort was encoded in the
>>>>>>>>>>>>>>>>>>>>>> program of H, and thus into the program of D, so
>>>>>>>>>>>>>>>>>>>>>> when you "alter" H to not abort to show this, D
>>>>>>>>>>>>>>>>>>>>>> doesn't change and still refers to the H that did
>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So you are claiming that you just don't understand
>>>>>>>>>>>>>>>>>>>>> that every H that
>>>>>>>>>>>>>>>>>>>>> can possibly exist must abort its simulated D
>>>>>>>>>>>>>>>>>>>>> because this is simply
>>>>>>>>>>>>>>>>>>>>> over your head because you are not very smart?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Who's talking about every H that could possibly
>>>>>>>>>>>>>>>>>>>> exist? You wrote just one H, not every one that
>>>>>>>>>>>>>>>>>>>> could possibly exist.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The Peter Linz proof uses a program template
>>>>>>>>>>>>>>>>>>> simultaneously referring
>>>>>>>>>>>>>>>>>>> every H that can possibly exist.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The Peter Linz proof template tells you how to make a
>>>>>>>>>>>>>>>>>> proof for the H that you have.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is why I apply my proof of H/D to the Linz proof
>>>>>>>>>>>>>>>>> in my paper. Richard just doesn't seem to get the idea
>>>>>>>>>>>>>>>>> of a program template. He does not understand that
>>>>>>>>>>>>>>>>> analysis can be simultaneously applied to an infinite
>>>>>>>>>>>>>>>>> set of programs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> One of the problems in this discussion is that different
>>>>>>>>>>>>>>>> instantiations can be made of a template and olcott
>>>>>>>>>>>>>>>> gives them all the same name.
>>>>>>>>>>>>>>>> Just as he uses the same name for different halt
>>>>>>>>>>>>>>>> deciders, some of which abort and others do not abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> May I suggest a naming for the different candidate halt
>>>>>>>>>>>>>>>> decoders?
>>>>>>>>>>>>>>>> Here we limit ourselves to simulating halt deciders. We
>>>>>>>>>>>>>>>> can imagine three candidates:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hss: A simple simulating halt decider, which does not
>>>>>>>>>>>>>>>> abort. It is clear it can report only about programs
>>>>>>>>>>>>>>>> which terminate normally.In this case it returns
>>>>>>>>>>>>>>>> 'halting'. It cannot return 'non-halting' in a finite time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Han: A simulating halt decider that, when it recognizes
>>>>>>>>>>>>>>>> that the program uses the same algorithm that is used in
>>>>>>>>>>>>>>>> Han to do the opposite, it aborts and returns
>>>>>>>>>>>>>>>> 'non-halting'. (For the sake of this discussion, we
>>>>>>>>>>>>>>>> ignore that it very improbable that Han will be possible
>>>>>>>>>>>>>>>> to recognize all variations of the algorithm, because we
>>>>>>>>>>>>>>>> stick for the moment to the template mentioned above.
>>>>>>>>>>>>>>>> Similarly it will not be easy to detect always that the
>>>>>>>>>>>>>>>> program does the opposite.)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is clear that Han is wrong if it assumes that Han
>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>> does an infinite recursion, not Han.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hah: A simulating halt decider, similar to Han, but when
>>>>>>>>>>>>>>>> it recognizes that the same algorithm is used to do the
>>>>>>>>>>>>>>>> opposite, it aborts and returns 'halting'.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is clear that Hah is wrong if it assumes that Hah
>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>> does an infinite recursion, not Hah.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Using these names it is no longer needed to use
>>>>>>>>>>>>>>>> overcomplicated sentence fragments, such as 'keeps
>>>>>>>>>>>>>>>> looping unless aborted'. Because, for Hss 'keeps
>>>>>>>>>>>>>>>> looping' is sufficient, whereas for Han and Hah 'does
>>>>>>>>>>>>>>>> not loop, because aborted' is more clear.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A halting decider needs a program to decide on. It
>>>>>>>>>>>>>>>> cannot decide on a template, because different
>>>>>>>>>>>>>>>> instantiations of a template can do different things.
>>>>>>>>>>>>>>>> Therefore, from these three candidates the template can
>>>>>>>>>>>>>>>> be used to create three programs:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Dss: based on Hss. It is clear that it does not halt,
>>>>>>>>>>>>>>>> because Hss does not halt.
>>>>>>>>>>>>>>>> Dan: based on Han. Han returns 'non-halting', so Dan halts.
>>>>>>>>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does
>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, we do no longer need overcomplicated sentences
>>>>>>>>>>>>>>>> with 'unless', because it is clear that only Dss is
>>>>>>>>>>>>>>>> involved in infinite recursion within the algorithm of
>>>>>>>>>>>>>>>> Hss. Dan and Dah are not, because Han and Hah are not.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Three programs and three candidate halt deciders. That
>>>>>>>>>>>>>>>> results in nine combinations:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hss(Dss,Dss): Hss does not halt and never returns a result.
>>>>>>>>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han.
>>>>>>>>>>>>>>>> Simulation ends normally and Hss reports 'Halting'.
>>>>>>>>>>>>>>>> Hss(Dah,Dah): Hss simulates Dah, including Hah. The
>>>>>>>>>>>>>>>> simulation of Hah returns to the simulation of Dah,
>>>>>>>>>>>>>>>> which does not end. So Hss never returns a result.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Han(Dss,Dss): Han is different from Hss, so the
>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Han recognize
>>>>>>>>>>>>>>>> the infinite recursion? That depends on details not
>>>>>>>>>>>>>>>> provided by olcott.
>>>>>>>>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm, aborts
>>>>>>>>>>>>>>>> and reports 'non-halting'.
>>>>>>>>>>>>>>>> Han(Dah,Dah): Han is different from Hah, so the
>>>>>>>>>>>>>>>> simulation of Hah is not aborted. The simulation of Hah
>>>>>>>>>>>>>>>> returns with 'halting'. Does Han subsequently recognize
>>>>>>>>>>>>>>>> that D starts an infinite loop? That depends on details
>>>>>>>>>>>>>>>> not provides by olcott.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Hah(Dss,Dss): Hah is different from Hss, so the
>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Hah recognize
>>>>>>>>>>>>>>>> the infinite recursion? That depends on details not
>>>>>>>>>>>>>>>> provided by olcott.
>>>>>>>>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the
>>>>>>>>>>>>>>>> simulation of Han is not aborted. The simulation of Ha
>>>>>>>>>>>>>>>> returns with 'non-halting'. The simulation of D will end
>>>>>>>>>>>>>>>> normally and Hah will report 'halting'.
>>>>>>>>>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts
>>>>>>>>>>>>>>>> and reports 'halting'.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>  From these nine combinations we see that only a few are
>>>>>>>>>>>>>>>> definitely able to report a correct status. we also see
>>>>>>>>>>>>>>>> that the three most important ones Hss(Dss,Dss),
>>>>>>>>>>>>>>>> Han(Dan,Dan) and Hah(Dah,Dah) do not return the correct
>>>>>>>>>>>>>>>> status.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> May I suggest that we stick to these names, instead of
>>>>>>>>>>>>>>>> using the same names D and H for different things? That
>>>>>>>>>>>>>>>> would make the discussion more transparent. And maybe
>>>>>>>>>>>>>>>> olcott can tell which case is in discussion,
>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
>>>>>>>>>>>>>>>> the other combinations. Are we talking about an
>>>>>>>>>>>>>>>> aborting, or a non-aborting decider? I ask this, because
>>>>>>>>>>>>>>>> sentence fragments like 'keeps looping unless aborted',
>>>>>>>>>>>>>>>> suggests that it is not always aborted, so it is not
>>>>>>>>>>>>>>>> clear whether Hss, Han, or Han is meant.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My whole purpose is to show the only possible way that H
>>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>>> correctly encoded is the current way that H is encoded.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And which way is that? Is it Hss, Han, Hap or something else?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every H that correctly determines in N steps of correct
>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>> input D that itself would never stop running unless it
>>>>>>>>>>>>>>> aborts its
>>>>>>>>>>>>>>> simulation of D is necessarily correct to report that *D
>>>>>>>>>>>>>>> DOES NOT HALT*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You aren't listening.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am listening and I am overriding and superseding
>>>>>>>>>>>>> misconception.
>>>>>>>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Except that you aren't ALLOWED to change definitions and
>>>>>>>>>>>> stay in the same Theory. If you try, you have just thrusted
>>>>>>>>>>>> your self into a DIFFERENT field of PO-Compuations and your
>>>>>>>>>>>> POOP problem.
>>>>>>>>>>>
>>>>>>>>>>> Halt deciders have always been required to compute the mapping
>>>>>>>>>>> from their finite strong input to their own accept or reject
>>>>>>>>>>> state on the basis of *THE BEHAVIOR THAT THIS FINITE STRING
>>>>>>>>>>> SPECIFIES*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strings themselves do not have "Behavior"
>>>>>>>>>
>>>>>>>>> In computability theory, Rice's theorem states that all
>>>>>>>>> non-trivial semantic properties of programs are undecidable. A
>>>>>>>>> semantic property is one *about the program's behavior* (for
>>>>>>>>> instance, does the program terminate for all inputs), unlike a
>>>>>>>>> syntactic property (for instance, does the program contain an
>>>>>>>>> if-then-else statement). A property is non-trivial if it is
>>>>>>>>> neither true for every program, nor false for every program.
>>>>>>>>> https://en.wikipedia.org/wiki/Rice%27s_theorem
>>>>>>>>>>
>>>>>>>>>> The the behavior specified by the input is NOT the Halting
>>>>>>>>>> Behavior of the Compuation described by the input,
>>>>>>>>>
>>>>>>>>> The term "specified" is more precise than "described by". The
>>>>>>>>> latter term allows indirect reference whereas the former one
>>>>>>>>> does not.
>>>>>>>>>
>>>>>>>>> D simulated by H such that H executes the x86 machine code that
>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is
>>>>>>>>> to incorrectly execute the x86 machine code that D specifies.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which D?
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Every correct H correctly aborts its corresponding D and correctly
>>>>>>> rejects D as non-halting.
>>>>>>>
>>>>>>
>>>>>> Olcott keeps hiding the details. Which H is shown here?
>>>>>> If it is the aborting H, which we call Han, then there is no need
>>>>>> to abort D, because Han aborts itself already. It cannot be at the
>>>>>> same time Hss, which does not abort. Hss and Han are different
>>>>>> deciders with different behaviour and therefore, Dss is different
>>>>>> from Dan
>>>>>>
>>>>>> Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
>>>>>
>>>>> As Olcott uses in his proofs the inferene rule knonw as equivocation
>>>>> he must restrict his naming conventions.
>>>>>
>>>>
>>>> When one understands that simulating termination analyzer H
>>>> is always correct to abort any simulation that cannot possibly
>>>> stop running unless aborted
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> Then every simulating termination analyzer H specified by
>>>> the above template is correct to abort its simulation of D
>>>> and reject D as non-halting.
>>>
>>> Nice to see that you agree with my observation.
>>>
>>> HOwever, the above template does not specify a simulating rermination
>>> analyzer.
>>>
>>
>> Below I reference an infinite set of simulating termination
>> analyzers that each correctly aborts its simulation of D
>> and correctly rejects D as non-halting.
>>
>> *PREMISE*
>> When one understands that simulating termination analyzer H
>> is always correct to abort any simulation that cannot possibly
>> stop running unless aborted:
>>
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> *LOGICALLY ENTAILED BY PREMISE*
>> Then every simulating termination analyzer H specified by
>> the above template correctly aborts its simulation of D
>> and correctly rejects D as non-halting.
>>
>> Pages 661 to 696 of Halt7.c specify the H that does this
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
> The above template specifies no simulating termination analyzer.
>

On 2/1/2024 11:02 AM, Mikko wrote:
> On 2024-02-01 14:14:22 +0000, olcott said:
>
>> On 2/1/2024 3:54 AM, Mikko wrote:
>>> On 2024-01-31 17:18:32 +0000, olcott said:
>>>
>>>> On 1/31/2024 11:12 AM, Mikko wrote:
>>>>> On 2024-01-31 14:52:29 +0000, olcott said:
>>>>>
>>>>>> On 1/31/2024 2:30 AM, Mikko wrote:
>>>>>>> On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
>>>>>>>
>>>>>>>> Op 30.jan.2024 om 15:52 schreef olcott:
>>>>>>>>> On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 30.jan.2024 om 06:05 schreef olcott:
>>>>>>>>>>> On 1/29/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/29/24 9:30 PM, olcott wrote:
>>>>>>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/29/24 1:19 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>>>>>>>>> On 1/29/24 15:30, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 28.jan.2024 om 16:28 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 1/28/2024 6:12 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:33 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:32, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> professors agree that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem has been intentionally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to be unsatisfiable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is required to report on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever an input calls its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive simulation then H is not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on different behavior than the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it sees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H that must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of any input D to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own infinite execution is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *It in incorrect for H to do this in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some cases*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why would it be incorrect to answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question actually asked?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does D specify halting behavior to H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it does not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it specifies Halting Behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EVERYONE, as the actual property of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting is independent of who you ask.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies infinite recursion to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies what ever recursion that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> generates.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies recursive simulation to H forcing
>>>>>>>>>>>>>>>>>>>>>>>>>>> H to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> D only specifies as much recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> to H as H actually does.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *PEOPLE THAT DENY TAUTOLOGIES ARE EITHER STUPID
>>>>>>>>>>>>>>>>>>>>>>>>> OR LIARS*
>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulating termination
>>>>>>>>>>>>>>>>>>>>>>>>> analyzer H must abort the
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input D to prevent its own
>>>>>>>>>>>>>>>>>>>>>>>>> infinite execution
>>>>>>>>>>>>>>>>>>>>>>>>> it is always necessarily correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And the decision to abort was encoded in the
>>>>>>>>>>>>>>>>>>>>>>>> program of H, and thus into the program of D, so
>>>>>>>>>>>>>>>>>>>>>>>> when you "alter" H to not abort to show this, D
>>>>>>>>>>>>>>>>>>>>>>>> doesn't change and still refers to the H that
>>>>>>>>>>>>>>>>>>>>>>>> did abort.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that you just don't
>>>>>>>>>>>>>>>>>>>>>>> understand that every H that
>>>>>>>>>>>>>>>>>>>>>>> can possibly exist must abort its simulated D
>>>>>>>>>>>>>>>>>>>>>>> because this is simply
>>>>>>>>>>>>>>>>>>>>>>> over your head because you are not very smart?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Who's talking about every H that could possibly
>>>>>>>>>>>>>>>>>>>>>> exist? You wrote just one H, not every one that
>>>>>>>>>>>>>>>>>>>>>> could possibly exist.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The Peter Linz proof uses a program template
>>>>>>>>>>>>>>>>>>>>> simultaneously referring
>>>>>>>>>>>>>>>>>>>>> every H that can possibly exist.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The Peter Linz proof template tells you how to make
>>>>>>>>>>>>>>>>>>>> a proof for the H that you have.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is why I apply my proof of H/D to the Linz proof
>>>>>>>>>>>>>>>>>>> in my paper. Richard just doesn't seem to get the idea
>>>>>>>>>>>>>>>>>>> of a program template. He does not understand that
>>>>>>>>>>>>>>>>>>> analysis can be simultaneously applied to an infinite
>>>>>>>>>>>>>>>>>>> set of programs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> One of the problems in this discussion is that
>>>>>>>>>>>>>>>>>> different instantiations can be made of a template and
>>>>>>>>>>>>>>>>>> olcott gives them all the same name.
>>>>>>>>>>>>>>>>>> Just as he uses the same name for different halt
>>>>>>>>>>>>>>>>>> deciders, some of which abort and others do not abort.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> May I suggest a naming for the different candidate
>>>>>>>>>>>>>>>>>> halt decoders?
>>>>>>>>>>>>>>>>>> Here we limit ourselves to simulating halt deciders.
>>>>>>>>>>>>>>>>>> We can imagine three candidates:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Hss: A simple simulating halt decider, which does not
>>>>>>>>>>>>>>>>>> abort. It is clear it can report only about programs
>>>>>>>>>>>>>>>>>> which terminate normally.In this case it returns
>>>>>>>>>>>>>>>>>> 'halting'. It cannot return 'non-halting' in a finite
>>>>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Han: A simulating halt decider that, when it
>>>>>>>>>>>>>>>>>> recognizes that the program uses the same algorithm
>>>>>>>>>>>>>>>>>> that is used in Han to do the opposite, it aborts and
>>>>>>>>>>>>>>>>>> returns 'non-halting'. (For the sake of this
>>>>>>>>>>>>>>>>>> discussion, we ignore that it very improbable that Han
>>>>>>>>>>>>>>>>>> will be possible to recognize all variations of the
>>>>>>>>>>>>>>>>>> algorithm, because we stick for the moment to the
>>>>>>>>>>>>>>>>>> template mentioned above. Similarly it will not be
>>>>>>>>>>>>>>>>>> easy to detect always that the program does the
>>>>>>>>>>>>>>>>>> opposite.)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is clear that Han is wrong if it assumes that Han
>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>> does an infinite recursion, not Han.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Hah: A simulating halt decider, similar to Han, but
>>>>>>>>>>>>>>>>>> when it recognizes that the same algorithm is used to
>>>>>>>>>>>>>>>>>> do the opposite, it aborts and returns 'halting'.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is clear that Hah is wrong if it assumes that Hah
>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>> does an infinite recursion, not Hah.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Using these names it is no longer needed to use
>>>>>>>>>>>>>>>>>> overcomplicated sentence fragments, such as 'keeps
>>>>>>>>>>>>>>>>>> looping unless aborted'. Because, for Hss 'keeps
>>>>>>>>>>>>>>>>>> looping' is sufficient, whereas for Han and Hah 'does
>>>>>>>>>>>>>>>>>> not loop, because aborted' is more clear.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A halting decider needs a program to decide on. It
>>>>>>>>>>>>>>>>>> cannot decide on a template, because different
>>>>>>>>>>>>>>>>>> instantiations of a template can do different things.
>>>>>>>>>>>>>>>>>> Therefore, from these three candidates the template
>>>>>>>>>>>>>>>>>> can be used to create three programs:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Dss: based on Hss. It is clear that it does not halt,
>>>>>>>>>>>>>>>>>> because Hss does not halt.
>>>>>>>>>>>>>>>>>> Dan: based on Han. Han returns 'non-halting', so Dan
>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does
>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Again, we do no longer need overcomplicated sentences
>>>>>>>>>>>>>>>>>> with 'unless', because it is clear that only Dss is
>>>>>>>>>>>>>>>>>> involved in infinite recursion within the algorithm of
>>>>>>>>>>>>>>>>>> Hss. Dan and Dah are not, because Han and Hah are not.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Three programs and three candidate halt deciders. That
>>>>>>>>>>>>>>>>>> results in nine combinations:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Hss(Dss,Dss): Hss does not halt and never returns a
>>>>>>>>>>>>>>>>>> result.
>>>>>>>>>>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han.
>>>>>>>>>>>>>>>>>> Simulation ends normally and Hss reports 'Halting'.
>>>>>>>>>>>>>>>>>> Hss(Dah,Dah): Hss simulates Dah, including Hah. The
>>>>>>>>>>>>>>>>>> simulation of Hah returns to the simulation of Dah,
>>>>>>>>>>>>>>>>>> which does not end. So Hss never returns a result.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Han(Dss,Dss): Han is different from Hss, so the
>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Han
>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm, aborts
>>>>>>>>>>>>>>>>>> and reports 'non-halting'.
>>>>>>>>>>>>>>>>>> Han(Dah,Dah): Han is different from Hah, so the
>>>>>>>>>>>>>>>>>> simulation of Hah is not aborted. The simulation of
>>>>>>>>>>>>>>>>>> Hah returns with 'halting'. Does Han subsequently
>>>>>>>>>>>>>>>>>> recognize that D starts an infinite loop? That depends
>>>>>>>>>>>>>>>>>> on details not provides by olcott.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Hah(Dss,Dss): Hah is different from Hss, so the
>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Hah
>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the
>>>>>>>>>>>>>>>>>> simulation of Han is not aborted. The simulation of Ha
>>>>>>>>>>>>>>>>>> returns with 'non-halting'. The simulation of D will
>>>>>>>>>>>>>>>>>> end normally and Hah will report 'halting'.
>>>>>>>>>>>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts
>>>>>>>>>>>>>>>>>> and reports 'halting'.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>  From these nine combinations we see that only a few
>>>>>>>>>>>>>>>>>> are definitely able to report a correct status. we
>>>>>>>>>>>>>>>>>> also see that the three most important ones
>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
>>>>>>>>>>>>>>>>>> return the correct status.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> May I suggest that we stick to these names, instead of
>>>>>>>>>>>>>>>>>> using the same names D and H for different things?
>>>>>>>>>>>>>>>>>> That would make the discussion more transparent. And
>>>>>>>>>>>>>>>>>> maybe olcott can tell which case is in discussion,
>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
>>>>>>>>>>>>>>>>>> the other combinations. Are we talking about an
>>>>>>>>>>>>>>>>>> aborting, or a non-aborting decider? I ask this,
>>>>>>>>>>>>>>>>>> because sentence fragments like 'keeps looping unless
>>>>>>>>>>>>>>>>>> aborted', suggests that it is not always aborted, so
>>>>>>>>>>>>>>>>>> it is not clear whether Hss, Han, or Han is meant.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My whole purpose is to show the only possible way that
>>>>>>>>>>>>>>>>> H can be
>>>>>>>>>>>>>>>>> correctly encoded is the current way that H is encoded.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And which way is that? Is it Hss, Han, Hap or something
>>>>>>>>>>>>>>>> else?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every H that correctly determines in N steps of correct
>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>> input D that itself would never stop running unless it
>>>>>>>>>>>>>>>>> aborts its
>>>>>>>>>>>>>>>>> simulation of D is necessarily correct to report that
>>>>>>>>>>>>>>>>> *D DOES NOT HALT*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You aren't listening.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am listening and I am overriding and superseding
>>>>>>>>>>>>>>> misconception.
>>>>>>>>>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that you aren't ALLOWED to change definitions and
>>>>>>>>>>>>>> stay in the same Theory. If you try, you have just
>>>>>>>>>>>>>> thrusted your self into a DIFFERENT field of
>>>>>>>>>>>>>> PO-Compuations and your POOP problem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Halt deciders have always been required to compute the mapping
>>>>>>>>>>>>> from their finite strong input to their own accept or reject
>>>>>>>>>>>>> state on the basis of *THE BEHAVIOR THAT THIS FINITE STRING
>>>>>>>>>>>>> SPECIFIES*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Strings themselves do not have "Behavior"
>>>>>>>>>>>
>>>>>>>>>>> In computability theory, Rice's theorem states that all
>>>>>>>>>>> non-trivial semantic properties of programs are undecidable.
>>>>>>>>>>> A semantic property is one *about the program's behavior*
>>>>>>>>>>> (for instance, does the program terminate for all inputs),
>>>>>>>>>>> unlike a syntactic property (for instance, does the program
>>>>>>>>>>> contain an if-then-else statement). A property is non-trivial
>>>>>>>>>>> if it is neither true for every program, nor false for every
>>>>>>>>>>> program. https://en.wikipedia.org/wiki/Rice%27s_theorem
>>>>>>>>>>>>
>>>>>>>>>>>> The the behavior specified by the input is NOT the Halting
>>>>>>>>>>>> Behavior of the Compuation described by the input,
>>>>>>>>>>>
>>>>>>>>>>> The term "specified" is more precise than "described by". The
>>>>>>>>>>> latter term allows indirect reference whereas the former one
>>>>>>>>>>> does not.
>>>>>>>>>>>
>>>>>>>>>>> D simulated by H such that H executes the x86 machine code that
>>>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is
>>>>>>>>>>> to incorrectly execute the x86 machine code that D specifies.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which D?
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> Every correct H correctly aborts its corresponding D and correctly
>>>>>>>>> rejects D as non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott keeps hiding the details. Which H is shown here?
>>>>>>>> If it is the aborting H, which we call Han, then there is no
>>>>>>>> need to abort D, because Han aborts itself already. It cannot be
>>>>>>>> at the same time Hss, which does not abort. Hss and Han are
>>>>>>>> different deciders with different behaviour and therefore, Dss
>>>>>>>> is different from Dan
>>>>>>>>
>>>>>>>> Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
>>>>>>>
>>>>>>> As Olcott uses in his proofs the inferene rule knonw as equivocation
>>>>>>> he must restrict his naming conventions.
>>>>>>>
>>>>>>
>>>>>> When one understands that simulating termination analyzer H
>>>>>> is always correct to abort any simulation that cannot possibly
>>>>>> stop running unless aborted
>>>>>>
>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> Then every simulating termination analyzer H specified by
>>>>>> the above template is correct to abort its simulation of D
>>>>>> and reject D as non-halting.
>>>>>
>>>>> Nice to see that you agree with my observation.
>>>>>
>>>>> HOwever, the above template does not specify a simulating rermination
>>>>> analyzer.
>>>>>
>>>>
>>>> Below I reference an infinite set of simulating termination
>>>> analyzers that each correctly aborts its simulation of D
>>>> and correctly rejects D as non-halting.
>>>>
>>>> *PREMISE*
>>>> When one understands that simulating termination analyzer H
>>>> is always correct to abort any simulation that cannot possibly
>>>> stop running unless aborted:
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> *LOGICALLY ENTAILED BY PREMISE*
>>>> Then every simulating termination analyzer H specified by
>>>> the above template correctly aborts its simulation of D
>>>> and correctly rejects D as non-halting.
>>>>
>>>> Pages 661 to 696 of Halt7.c specify the H that does this
>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>
>>> The above template specifies no simulating termination analyzer.
>>>
>>
>> *That is factually incorrect*
>>
>> Both the template and the code do specify a simulating termination
>> analyzer.
>
> The template contains neither any of workds "simulating", "termination",
> "analyzer", or related words or synonyms nor anything that is or means
> any of these.
>
> Mikko
>

On 2/1/24 12:29 PM, olcott wrote:
> On 2/1/2024 11:02 AM, Mikko wrote:
>> On 2024-02-01 14:14:22 +0000, olcott said:
>>
>>> On 2/1/2024 3:54 AM, Mikko wrote:
>>>> On 2024-01-31 17:18:32 +0000, olcott said:
>>>>
>>>>> On 1/31/2024 11:12 AM, Mikko wrote:
>>>>>> On 2024-01-31 14:52:29 +0000, olcott said:
>>>>>>
>>>>>>> On 1/31/2024 2:30 AM, Mikko wrote:
>>>>>>>> On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
>>>>>>>>
>>>>>>>>> Op 30.jan.2024 om 15:52 schreef olcott:
>>>>>>>>>> On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 30.jan.2024 om 06:05 schreef olcott:
>>>>>>>>>>>> On 1/29/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/29/24 9:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/29/24 1:19 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>>>>>>>>>> On 1/29/24 15:30, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 28.jan.2024 om 16:28 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 1/28/2024 6:12 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:33 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:32, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> professors agree that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem has been intentionally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to be unsatisfiable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is required to report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever an input calls its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive simulation then H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not allowed to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on different behavior than the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it sees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H that must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of any input D to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own infinite execution is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *It in incorrect for H to do this in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some cases*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why would it be incorrect to answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question actually asked?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does D specify halting behavior to H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it does not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it specifies Halting Behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EVERYONE, as the actual property of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting is independent of who you ask.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies infinite recursion to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies what ever recursion that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generates.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies recursive simulation to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> forcing H to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D only specifies as much recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> to H as H actually does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *PEOPLE THAT DENY TAUTOLOGIES ARE EITHER
>>>>>>>>>>>>>>>>>>>>>>>>>> STUPID OR LIARS*
>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulating termination
>>>>>>>>>>>>>>>>>>>>>>>>>> analyzer H must abort the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input D to prevent its own
>>>>>>>>>>>>>>>>>>>>>>>>>> infinite execution
>>>>>>>>>>>>>>>>>>>>>>>>>> it is always necessarily correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And the decision to abort was encoded in the
>>>>>>>>>>>>>>>>>>>>>>>>> program of H, and thus into the program of D,
>>>>>>>>>>>>>>>>>>>>>>>>> so when you "alter" H to not abort to show
>>>>>>>>>>>>>>>>>>>>>>>>> this, D doesn't change and still refers to the
>>>>>>>>>>>>>>>>>>>>>>>>> H that did abort.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that you just don't
>>>>>>>>>>>>>>>>>>>>>>>> understand that every H that
>>>>>>>>>>>>>>>>>>>>>>>> can possibly exist must abort its simulated D
>>>>>>>>>>>>>>>>>>>>>>>> because this is simply
>>>>>>>>>>>>>>>>>>>>>>>> over your head because you are not very smart?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Who's talking about every H that could possibly
>>>>>>>>>>>>>>>>>>>>>>> exist? You wrote just one H, not every one that
>>>>>>>>>>>>>>>>>>>>>>> could possibly exist.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The Peter Linz proof uses a program template
>>>>>>>>>>>>>>>>>>>>>> simultaneously referring
>>>>>>>>>>>>>>>>>>>>>> every H that can possibly exist.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The Peter Linz proof template tells you how to make
>>>>>>>>>>>>>>>>>>>>> a proof for the H that you have.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is why I apply my proof of H/D to the Linz proof
>>>>>>>>>>>>>>>>>>>> in my paper. Richard just doesn't seem to get the idea
>>>>>>>>>>>>>>>>>>>> of a program template. He does not understand that
>>>>>>>>>>>>>>>>>>>> analysis can be simultaneously applied to an infinite
>>>>>>>>>>>>>>>>>>>> set of programs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> One of the problems in this discussion is that
>>>>>>>>>>>>>>>>>>> different instantiations can be made of a template
>>>>>>>>>>>>>>>>>>> and olcott gives them all the same name.
>>>>>>>>>>>>>>>>>>> Just as he uses the same name for different halt
>>>>>>>>>>>>>>>>>>> deciders, some of which abort and others do not abort.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> May I suggest a naming for the different candidate
>>>>>>>>>>>>>>>>>>> halt decoders?
>>>>>>>>>>>>>>>>>>> Here we limit ourselves to simulating halt deciders.
>>>>>>>>>>>>>>>>>>> We can imagine three candidates:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hss: A simple simulating halt decider, which does not
>>>>>>>>>>>>>>>>>>> abort. It is clear it can report only about programs
>>>>>>>>>>>>>>>>>>> which terminate normally.In this case it returns
>>>>>>>>>>>>>>>>>>> 'halting'. It cannot return 'non-halting' in a finite
>>>>>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Han: A simulating halt decider that, when it
>>>>>>>>>>>>>>>>>>> recognizes that the program uses the same algorithm
>>>>>>>>>>>>>>>>>>> that is used in Han to do the opposite, it aborts and
>>>>>>>>>>>>>>>>>>> returns 'non-halting'. (For the sake of this
>>>>>>>>>>>>>>>>>>> discussion, we ignore that it very improbable that
>>>>>>>>>>>>>>>>>>> Han will be possible to recognize all variations of
>>>>>>>>>>>>>>>>>>> the algorithm, because we stick for the moment to the
>>>>>>>>>>>>>>>>>>> template mentioned above. Similarly it will not be
>>>>>>>>>>>>>>>>>>> easy to detect always that the program does the
>>>>>>>>>>>>>>>>>>> opposite.)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is clear that Han is wrong if it assumes that Han
>>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>>> does an infinite recursion, not Han.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hah: A simulating halt decider, similar to Han, but
>>>>>>>>>>>>>>>>>>> when it recognizes that the same algorithm is used to
>>>>>>>>>>>>>>>>>>> do the opposite, it aborts and returns 'halting'.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is clear that Hah is wrong if it assumes that Hah
>>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>>> does an infinite recursion, not Hah.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Using these names it is no longer needed to use
>>>>>>>>>>>>>>>>>>> overcomplicated sentence fragments, such as 'keeps
>>>>>>>>>>>>>>>>>>> looping unless aborted'. Because, for Hss 'keeps
>>>>>>>>>>>>>>>>>>> looping' is sufficient, whereas for Han and Hah 'does
>>>>>>>>>>>>>>>>>>> not loop, because aborted' is more clear.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A halting decider needs a program to decide on. It
>>>>>>>>>>>>>>>>>>> cannot decide on a template, because different
>>>>>>>>>>>>>>>>>>> instantiations of a template can do different things.
>>>>>>>>>>>>>>>>>>> Therefore, from these three candidates the template
>>>>>>>>>>>>>>>>>>> can be used to create three programs:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Dss: based on Hss. It is clear that it does not halt,
>>>>>>>>>>>>>>>>>>> because Hss does not halt.
>>>>>>>>>>>>>>>>>>> Dan: based on Han. Han returns 'non-halting', so Dan
>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does
>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again, we do no longer need overcomplicated sentences
>>>>>>>>>>>>>>>>>>> with 'unless', because it is clear that only Dss is
>>>>>>>>>>>>>>>>>>> involved in infinite recursion within the algorithm
>>>>>>>>>>>>>>>>>>> of Hss. Dan and Dah are not, because Han and Hah are
>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Three programs and three candidate halt deciders.
>>>>>>>>>>>>>>>>>>> That results in nine combinations:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss): Hss does not halt and never returns a
>>>>>>>>>>>>>>>>>>> result.
>>>>>>>>>>>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han.
>>>>>>>>>>>>>>>>>>> Simulation ends normally and Hss reports 'Halting'.
>>>>>>>>>>>>>>>>>>> Hss(Dah,Dah): Hss simulates Dah, including Hah. The
>>>>>>>>>>>>>>>>>>> simulation of Hah returns to the simulation of Dah,
>>>>>>>>>>>>>>>>>>> which does not end. So Hss never returns a result.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Han(Dss,Dss): Han is different from Hss, so the
>>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Han
>>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm,
>>>>>>>>>>>>>>>>>>> aborts and reports 'non-halting'.
>>>>>>>>>>>>>>>>>>> Han(Dah,Dah): Han is different from Hah, so the
>>>>>>>>>>>>>>>>>>> simulation of Hah is not aborted. The simulation of
>>>>>>>>>>>>>>>>>>> Hah returns with 'halting'. Does Han subsequently
>>>>>>>>>>>>>>>>>>> recognize that D starts an infinite loop? That
>>>>>>>>>>>>>>>>>>> depends on details not provides by olcott.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hah(Dss,Dss): Hah is different from Hss, so the
>>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Hah
>>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the
>>>>>>>>>>>>>>>>>>> simulation of Han is not aborted. The simulation of
>>>>>>>>>>>>>>>>>>> Ha returns with 'non-halting'. The simulation of D
>>>>>>>>>>>>>>>>>>> will end normally and Hah will report 'halting'.
>>>>>>>>>>>>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts
>>>>>>>>>>>>>>>>>>> and reports 'halting'.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>  From these nine combinations we see that only a few
>>>>>>>>>>>>>>>>>>> are definitely able to report a correct status. we
>>>>>>>>>>>>>>>>>>> also see that the three most important ones
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
>>>>>>>>>>>>>>>>>>> return the correct status.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> May I suggest that we stick to these names, instead
>>>>>>>>>>>>>>>>>>> of using the same names D and H for different things?
>>>>>>>>>>>>>>>>>>> That would make the discussion more transparent. And
>>>>>>>>>>>>>>>>>>> maybe olcott can tell which case is in discussion,
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
>>>>>>>>>>>>>>>>>>> the other combinations. Are we talking about an
>>>>>>>>>>>>>>>>>>> aborting, or a non-aborting decider? I ask this,
>>>>>>>>>>>>>>>>>>> because sentence fragments like 'keeps looping unless
>>>>>>>>>>>>>>>>>>> aborted', suggests that it is not always aborted, so
>>>>>>>>>>>>>>>>>>> it is not clear whether Hss, Han, or Han is meant.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My whole purpose is to show the only possible way that
>>>>>>>>>>>>>>>>>> H can be
>>>>>>>>>>>>>>>>>> correctly encoded is the current way that H is encoded.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And which way is that? Is it Hss, Han, Hap or something
>>>>>>>>>>>>>>>>> else?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every H that correctly determines in N steps of
>>>>>>>>>>>>>>>>>> correct simulation of
>>>>>>>>>>>>>>>>>> input D that itself would never stop running unless it
>>>>>>>>>>>>>>>>>> aborts its
>>>>>>>>>>>>>>>>>> simulation of D is necessarily correct to report that
>>>>>>>>>>>>>>>>>> *D DOES NOT HALT*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You aren't listening.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am listening and I am overriding and superseding
>>>>>>>>>>>>>>>> misconception.
>>>>>>>>>>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that you aren't ALLOWED to change definitions and
>>>>>>>>>>>>>>> stay in the same Theory. If you try, you have just
>>>>>>>>>>>>>>> thrusted your self into a DIFFERENT field of
>>>>>>>>>>>>>>> PO-Compuations and your POOP problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halt deciders have always been required to compute the
>>>>>>>>>>>>>> mapping
>>>>>>>>>>>>>> from their finite strong input to their own accept or reject
>>>>>>>>>>>>>> state on the basis of *THE BEHAVIOR THAT THIS FINITE
>>>>>>>>>>>>>> STRING SPECIFIES*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Strings themselves do not have "Behavior"
>>>>>>>>>>>>
>>>>>>>>>>>> In computability theory, Rice's theorem states that all
>>>>>>>>>>>> non-trivial semantic properties of programs are undecidable.
>>>>>>>>>>>> A semantic property is one *about the program's behavior*
>>>>>>>>>>>> (for instance, does the program terminate for all inputs),
>>>>>>>>>>>> unlike a syntactic property (for instance, does the program
>>>>>>>>>>>> contain an if-then-else statement). A property is
>>>>>>>>>>>> non-trivial if it is neither true for every program, nor
>>>>>>>>>>>> false for every program.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Rice%27s_theorem
>>>>>>>>>>>>>
>>>>>>>>>>>>> The the behavior specified by the input is NOT the Halting
>>>>>>>>>>>>> Behavior of the Compuation described by the input,
>>>>>>>>>>>>
>>>>>>>>>>>> The term "specified" is more precise than "described by". The
>>>>>>>>>>>> latter term allows indirect reference whereas the former one
>>>>>>>>>>>> does not.
>>>>>>>>>>>>
>>>>>>>>>>>> D simulated by H such that H executes the x86 machine code that
>>>>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is
>>>>>>>>>>>> to incorrectly execute the x86 machine code that D specifies.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which D?
>>>>>>>>>>
>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> Every correct H correctly aborts its corresponding D and
>>>>>>>>>> correctly
>>>>>>>>>> rejects D as non-halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott keeps hiding the details. Which H is shown here?
>>>>>>>>> If it is the aborting H, which we call Han, then there is no
>>>>>>>>> need to abort D, because Han aborts itself already. It cannot
>>>>>>>>> be at the same time Hss, which does not abort. Hss and Han are
>>>>>>>>> different deciders with different behaviour and therefore, Dss
>>>>>>>>> is different from Dan
>>>>>>>>>
>>>>>>>>> Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
>>>>>>>>
>>>>>>>> As Olcott uses in his proofs the inferene rule knonw as
>>>>>>>> equivocation
>>>>>>>> he must restrict his naming conventions.
>>>>>>>>
>>>>>>>
>>>>>>> When one understands that simulating termination analyzer H
>>>>>>> is always correct to abort any simulation that cannot possibly
>>>>>>> stop running unless aborted
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Then every simulating termination analyzer H specified by
>>>>>>> the above template is correct to abort its simulation of D
>>>>>>> and reject D as non-halting.
>>>>>>
>>>>>> Nice to see that you agree with my observation.
>>>>>>
>>>>>> HOwever, the above template does not specify a simulating rermination
>>>>>> analyzer.
>>>>>>
>>>>>
>>>>> Below I reference an infinite set of simulating termination
>>>>> analyzers that each correctly aborts its simulation of D
>>>>> and correctly rejects D as non-halting.
>>>>>
>>>>> *PREMISE*
>>>>> When one understands that simulating termination analyzer H
>>>>> is always correct to abort any simulation that cannot possibly
>>>>> stop running unless aborted:
>>>>>
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> *LOGICALLY ENTAILED BY PREMISE*
>>>>> Then every simulating termination analyzer H specified by
>>>>> the above template correctly aborts its simulation of D
>>>>> and correctly rejects D as non-halting.
>>>>>
>>>>> Pages 661 to 696 of Halt7.c specify the H that does this
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>
>>>> The above template specifies no simulating termination analyzer.
>>>>
>>>
>>> *That is factually incorrect*
>>>
>>> Both the template and the code do specify a simulating termination
>>> analyzer.
>>
>> The template contains neither any of workds "simulating", "termination",
>> "analyzer", or related words or synonyms nor anything that is or means
>> any of these.
>>
>> Mikko
>>
>
> In other words you are expecting C to understand English or did you
> simply ignore this quoted from above?
>
> *PREMISE*
> When one understands that simulating termination analyzer H
> is always correct to abort any simulation that cannot possibly
> stop running unless aborted:
>
>

On 2/1/24 9:11 AM, olcott wrote:
> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 23:04 schreef olcott:
>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>> determined that
>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>
>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>
>>>>>>>>> *No that is a common misconception*
>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>
>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>> value that H returns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>>
>>>>>>> *PREMISE*
>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>> *stop running unless aborted
>>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>>> premise causes a contradiction, therefore the premise is false.
>>>>>> So, such a H does not exist.
>>>>>>
>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>
>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>
>>>>>> The premise which is shown to be false. Which makes the following
>>>>>> sentences vacuous.
>>>>>>
>>>>>
>>>>> All halt deciders must report on what the behavior of their
>>>>> input would be. None are required to infinitely simulate
>>>>> their input to correctly determine that their input would
>>>>> never halt.
>>>>
>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>> aborts
>>>
>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>> mostly on another forum.
>>>
>>> There is one infinite set of H/D pairs where every H correctly
>>> determines the halt status of its corresponding D every other
>>> freaking thing else is a dishonest dodge away from the point.
>>>
>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>> before I stopped tolerating them from anyone.
>>>
>>
>> Strange. Most people will understand that olcotts claim is false
>> within a few days, but olcott does not even understand it after a
>> dozen years. I am afraid he will need an infinite time to understand
>> it. Probably a bug in the AI.
>>
>
> Three PhD computer science professors agree.
>
> Does the halting problem place an actual limit on computation?
> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>

Fallacy of "proof" by authority.

You all are making the same mistake,

On 2/1/2024 9:39 PM, Richard Damon wrote:
> On 2/1/24 9:11 AM, olcott wrote:
>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>>
>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>
>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>> value that H returns.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation
>>>>>>>>> and
>>>>>>>>
>>>>>>>> *PREMISE*
>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>> *stop running unless aborted
>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>> not stop running), does stop and it is incorrect to abort it. So,
>>>>>>> the premise causes a contradiction, therefore the premise is
>>>>>>> false. So, such a H does not exist.
>>>>>>>
>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>
>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>
>>>>>>> The premise which is shown to be false. Which makes the following
>>>>>>> sentences vacuous.
>>>>>>>
>>>>>>
>>>>>> All halt deciders must report on what the behavior of their
>>>>>> input would be. None are required to infinitely simulate
>>>>>> their input to correctly determine that their input would
>>>>>> never halt.
>>>>>
>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>> aborts
>>>>
>>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>>> mostly on another forum.
>>>>
>>>> There is one infinite set of H/D pairs where every H correctly
>>>> determines the halt status of its corresponding D every other
>>>> freaking thing else is a dishonest dodge away from the point.
>>>>
>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>> before I stopped tolerating them from anyone.
>>>>
>>>
>>> Strange. Most people will understand that olcotts claim is false
>>> within a few days, but olcott does not even understand it after a
>>> dozen years. I am afraid he will need an infinite time to understand
>>> it. Probably a bug in the AI.
>>>
>>
>> Three PhD computer science professors agree.
>>
>> Does the halting problem place an actual limit on computation?
>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>
>
> Fallacy of "proof" by authority.
>
> You all are making the same mistake,

Qualified expert means an individual who has satisfactorily fulfilled
the training and experience requirements consistent with achieving a
level of competency sufficient to function effectively in the position
for which registration is sought.
https://www.lawinsider.com/dictionary/qualified-expert#

*Within inductive inference One is allowed to appeal*
*to the authority of a qualified expert*
https://philosophy.stackexchange.com/questions/73124/what-fallacy-or-appeal-occurs-when-one-feigns-to-be-more-educated-knowledgeable

Evidence as if submitted in court.

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

Op 01.feb.2024 om 15:11 schreef olcott:
> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 23:04 schreef olcott:
>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>> determined that
>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>
>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>
>>>>>>>>> *No that is a common misconception*
>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>
>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>> value that H returns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation and
>>>>>>>
>>>>>>> *PREMISE*
>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>> *stop running unless aborted
>>>>>> 'H is correct to abort' So it should be of the Han type. Thus Dan,
>>>>>> derived from this Han, correctly simulated (Han(Dan,Dan) should
>>>>>> simulate its input Dan, not its non-input Dss which does not stop
>>>>>> running), does stop and it is incorrect to abort it. So, the
>>>>>> premise causes a contradiction, therefore the premise is false.
>>>>>> So, such a H does not exist.
>>>>>>
>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>
>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>
>>>>>> The premise which is shown to be false. Which makes the following
>>>>>> sentences vacuous.
>>>>>>
>>>>>
>>>>> All halt deciders must report on what the behavior of their
>>>>> input would be. None are required to infinitely simulate
>>>>> their input to correctly determine that their input would
>>>>> never halt.
>>>>
>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>> aborts
>>>
>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>> mostly on another forum.
>>>
>>> There is one infinite set of H/D pairs where every H correctly
>>> determines the halt status of its corresponding D every other
>>> freaking thing else is a dishonest dodge away from the point.
>>>
>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>> before I stopped tolerating them from anyone.
>>>
>>
>> Strange. Most people will understand that olcotts claim is false
>> within a few days, but olcott does not even understand it after a
>> dozen years. I am afraid he will need an infinite time to understand
>> it. Probably a bug in the AI.
>>
>
> Three PhD computer science professors agree.

If true, I am very sorry for those professors.
My son, working for Google, told me that the Google search engine is so
strong, that for every false statement one can find a few professors
that seem to defend it.

On 2/2/24 2:16 AM, olcott wrote:
> On 2/1/2024 9:39 PM, Richard Damon wrote:
>> On 2/1/24 9:11 AM, olcott wrote:
>>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or
>>>>>>>>>>>>>> infinite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>>> sequence of configurations when you execute the finite
>>>>>>>>>>>> string pair according to Turing Machine rules and no other
>>>>>>>>>>>> rules.
>>>>>>>>>>>
>>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>>
>>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>>> possibly stop running unless aborted the H is necessarily
>>>>>>>>>>> correct
>>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>>> value that H returns.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott's H is of the Han type, because it aborts the
>>>>>>>>>> simulation and
>>>>>>>>>
>>>>>>>>> *PREMISE*
>>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>>> *stop running unless aborted
>>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>>> not stop running), does stop and it is incorrect to abort it.
>>>>>>>> So, the premise causes a contradiction, therefore the premise is
>>>>>>>> false. So, such a H does not exist.
>>>>>>>>
>>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>
>>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>>
>>>>>>>> The premise which is shown to be false. Which makes the
>>>>>>>> following sentences vacuous.
>>>>>>>>
>>>>>>>
>>>>>>> All halt deciders must report on what the behavior of their
>>>>>>> input would be. None are required to infinitely simulate
>>>>>>> their input to correctly determine that their input would
>>>>>>> never halt.
>>>>>>
>>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>>> aborts
>>>>>
>>>>> I have spent far too many weeks on this convoluted bullshit Dennis
>>>>> Bush
>>>>> mostly on another forum.
>>>>>
>>>>> There is one infinite set of H/D pairs where every H correctly
>>>>> determines the halt status of its corresponding D every other
>>>>> freaking thing else is a dishonest dodge away from the point.
>>>>>
>>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>>> before I stopped tolerating them from anyone.
>>>>>
>>>>
>>>> Strange. Most people will understand that olcotts claim is false
>>>> within a few days, but olcott does not even understand it after a
>>>> dozen years. I am afraid he will need an infinite time to understand
>>>> it. Probably a bug in the AI.
>>>>
>>>
>>> Three PhD computer science professors agree.
>>>
>>> Does the halting problem place an actual limit on computation?
>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>
>>
>> Fallacy of "proof" by authority.
>>
>> You all are making the same mistake,
>
> Qualified expert means an individual who has satisfactorily fulfilled
> the training and experience requirements consistent with achieving a
> level of competency sufficient to function effectively in the position
> for which registration is sought.
> https://www.lawinsider.com/dictionary/qualified-expert#

Still FALLACY OF APPEAL TO AUTHORITY.

Being a qualified expert may allow allow you to testify in court as an
expert, UNDER THE PENALTY OF PREJURY and thus overt liars end up in jail.

On 2/2/2024 5:16 AM, Fred. Zwarts wrote:
> Op 01.feb.2024 om 15:11 schreef olcott:
>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or infinite.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>> sequence of configurations when you execute the finite string
>>>>>>>>>>> pair according to Turing Machine rules and no other rules.
>>>>>>>>>>
>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>
>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>> possibly stop running unless aborted the H is necessarily correct
>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>> value that H returns.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott's H is of the Han type, because it aborts the simulation
>>>>>>>>> and
>>>>>>>>
>>>>>>>> *PREMISE*
>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>> *stop running unless aborted
>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>> not stop running), does stop and it is incorrect to abort it. So,
>>>>>>> the premise causes a contradiction, therefore the premise is
>>>>>>> false. So, such a H does not exist.
>>>>>>>
>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>
>>>>>>>>
>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>> 02 {
>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>> 04   if (Halt_Status)
>>>>>>>> 05     HERE: goto HERE;
>>>>>>>> 06   return Halt_Status;
>>>>>>>> 07 }
>>>>>>>> 08
>>>>>>>> 09 void main()
>>>>>>>> 10 {
>>>>>>>> 11   H(D,D);
>>>>>>>> 12 }
>>>>>>>>
>>>>>>>
>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>
>>>>>>> The premise which is shown to be false. Which makes the following
>>>>>>> sentences vacuous.
>>>>>>>
>>>>>>
>>>>>> All halt deciders must report on what the behavior of their
>>>>>> input would be. None are required to infinitely simulate
>>>>>> their input to correctly determine that their input would
>>>>>> never halt.
>>>>>
>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>> aborts
>>>>
>>>> I have spent far too many weeks on this convoluted bullshit Dennis Bush
>>>> mostly on another forum.
>>>>
>>>> There is one infinite set of H/D pairs where every H correctly
>>>> determines the halt status of its corresponding D every other
>>>> freaking thing else is a dishonest dodge away from the point.
>>>>
>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>> before I stopped tolerating them from anyone.
>>>>
>>>
>>> Strange. Most people will understand that olcotts claim is false
>>> within a few days, but olcott does not even understand it after a
>>> dozen years. I am afraid he will need an infinite time to understand
>>> it. Probably a bug in the AI.
>>>
>>
>> Three PhD computer science professors agree.
>
> If true, I am very sorry for those professors.
> My son, working for Google, told me that the Google search engine is so
> strong, that for every false statement one can find a few professors
> that seem to defend it.

Does the halting problem place an actual limit on computation?
https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation

Since I independently came up with this same reasoning back in 2004
(as referenced in my paper) I understand how and why they are correct.
Even "Carol's question" was directed at me as Jack's question in 2004.

So far not a single person could ever show any actual error in my
reasoning all they ever have is the dogma that they really really
believe that I am wrong. They try to get away with using rhetoric
instead of reasoning. This only works on gullible fools.

Any question intentionally defined to have no correct
answer <is> an incorrect question.

Any decision problem intentionally defined to be unsatisfiable
is isomorphic to an incorrect question.

The inability to answer an incorrect question places
no actual limit on anyone or anything.

Professor Hehner did a beautiful in showing that the context
of who is asked a question changed the meaning of this question.

You can comprehend this or fail to comprehend this. Because it
is a self-evident truth correct rebuttals are impossible.

On 2/2/24 10:48 AM, olcott wrote:
> On 2/2/2024 5:16 AM, Fred. Zwarts wrote:
>> Op 01.feb.2024 om 15:11 schreef olcott:
>>> On 2/1/2024 3:48 AM, Fred. Zwarts wrote:
>>>> Op 31.jan.2024 om 23:04 schreef olcott:
>>>>> On 1/31/2024 1:58 PM, Fred. Zwarts wrote:
>>>>>> Op 31.jan.2024 om 18:16 schreef olcott:
>>>>>>> On 1/31/2024 11:08 AM, Fred. Zwarts wrote:
>>>>>>>> Op 31.jan.2024 om 17:41 schreef olcott:
>>>>>>>>> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 31.jan.2024 om 16:54 schreef olcott:
>>>>>>>>>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>>>>>>>>>> On 1/31/24 01:56, olcott wrote:
>>>>>>>>>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>>>>>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>>>>>>>>>> I have already been completely through your idea with
>>>>>>>>>>>>>>> hundreds of
>>>>>>>>>>>>>>> posts on another forum with someone else before I
>>>>>>>>>>>>>>> determined that
>>>>>>>>>>>>>>> it is nonsense using set theory.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The halting problem is to decide whether the execution
>>>>>>>>>>>>>> sequence of a Turing machine/input pair is finite or
>>>>>>>>>>>>>> infinite.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>>>>>>>>>> can only take finite strings as input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem is whether or not a finite string pair
>>>>>>>>>>>>> (TM description and its input)
>>>>>>>>>>>>>
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>> *specifies a finite sequence of configurations*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The halting problem is whether or not you get a finite
>>>>>>>>>>>> sequence of configurations when you execute the finite
>>>>>>>>>>>> string pair according to Turing Machine rules and no other
>>>>>>>>>>>> rules.
>>>>>>>>>>>
>>>>>>>>>>> *No that is a common misconception*
>>>>>>>>>>> The halting problem is actually about computing the mapping
>>>>>>>>>>> from an input finite string pair such the the first element of
>>>>>>>>>>> this pair species behavior. It is the behavior that this finite
>>>>>>>>>>> string specifies that must be reported on.
>>>>>>>>>>>
>>>>>>>>>>> When D does call H in recursive simulation such that D cannot
>>>>>>>>>>> possibly stop running unless aborted the H is necessarily
>>>>>>>>>>> correct
>>>>>>>>>>> to abort D and reject D as non-halting >
>>>>>>>>>>> D correctly simulated by H cannot possibly reach the point in
>>>>>>>>>>> its own execution trace where it does the opposite of whatever
>>>>>>>>>>> value that H returns.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott's H is of the Han type, because it aborts the
>>>>>>>>>> simulation and
>>>>>>>>>
>>>>>>>>> *PREMISE*
>>>>>>>>> *When one understands that simulating termination analyzer H*
>>>>>>>>> *is always correct to abort any simulation that cannot possibly*
>>>>>>>>> *stop running unless aborted
>>>>>>>> 'H is correct to abort' So it should be of the Han type. Thus
>>>>>>>> Dan, derived from this Han, correctly simulated (Han(Dan,Dan)
>>>>>>>> should simulate its input Dan, not its non-input Dss which does
>>>>>>>> not stop running), does stop and it is incorrect to abort it.
>>>>>>>> So, the premise causes a contradiction, therefore the premise is
>>>>>>>> false. So, such a H does not exist.
>>>>>>>>
>>>>>>>> Now we get the non-existing D derived from this non-existing H.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 void main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>
>>>>>>>>> *IS LOGICALLY ENTAILED FROM PREMISE*
>>>>>>>>
>>>>>>>> The premise which is shown to be false. Which makes the
>>>>>>>> following sentences vacuous.
>>>>>>>>
>>>>>>>
>>>>>>> All halt deciders must report on what the behavior of their
>>>>>>> input would be. None are required to infinitely simulate
>>>>>>> their input to correctly determine that their input would
>>>>>>> never halt.
>>>>>>
>>>>>> Indeed. So Han(Dan,Dan) must report on Dan, which uses Han, which
>>>>>> aborts
>>>>>
>>>>> I have spent far too many weeks on this convoluted bullshit Dennis
>>>>> Bush
>>>>> mostly on another forum.
>>>>>
>>>>> There is one infinite set of H/D pairs where every H correctly
>>>>> determines the halt status of its corresponding D every other
>>>>> freaking thing else is a dishonest dodge away from the point.
>>>>>
>>>>> I spent a dozen years on the Dishonest dodges of Ben Bacarisse
>>>>> before I stopped tolerating them from anyone.
>>>>>
>>>>
>>>> Strange. Most people will understand that olcotts claim is false
>>>> within a few days, but olcott does not even understand it after a
>>>> dozen years. I am afraid he will need an infinite time to understand
>>>> it. Probably a bug in the AI.
>>>>
>>>
>>> Three PhD computer science professors agree.
>>
>> If true, I am very sorry for those professors.
>> My son, working for Google, told me that the Google search engine is
>> so strong, that for every false statement one can find a few
>> professors that seem to defend it.
>
> Does the halting problem place an actual limit on computation?

That is an interesting philosophical question. Does knowing you have the
limit actual cause the limit or not.

Without the "Halting Problem" and its proof, Computations still could
compute the things they couldn't compute (and a lot of the things they
can't compute are not directly Halting Problems).

So, the knowledge of the Halting Problem doesn't actually create a limit
on computations, it just shows some of the limits that actually exist.

On 31/01/24 18:11, olcott wrote:
> On 1/31/2024 11:07 AM, immibis wrote:
>> This is saying: If H doesn't abort its simulation then H is correct to
>> abort its simulation.
>
> All halt deciders must predict what the behavior of their
> input would be.

And yours predicts wrong.

On 1/02/24 18:29, olcott wrote:
> On 2/1/2024 11:02 AM, Mikko wrote:
>> On 2024-02-01 14:14:22 +0000, olcott said:
>>
>>> On 2/1/2024 3:54 AM, Mikko wrote:
>>>> On 2024-01-31 17:18:32 +0000, olcott said:
>>>>
>>>>> On 1/31/2024 11:12 AM, Mikko wrote:
>>>>>> On 2024-01-31 14:52:29 +0000, olcott said:
>>>>>>
>>>>>>> On 1/31/2024 2:30 AM, Mikko wrote:
>>>>>>>> On 2024-01-30 15:45:11 +0000, Fred. Zwarts said:
>>>>>>>>
>>>>>>>>> Op 30.jan.2024 om 15:52 schreef olcott:
>>>>>>>>>> On 1/30/2024 5:09 AM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 30.jan.2024 om 06:05 schreef olcott:
>>>>>>>>>>>> On 1/29/2024 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/29/24 9:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/29/2024 6:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/29/24 1:19 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/29/2024 8:47 AM, immibis wrote:
>>>>>>>>>>>>>>>>> On 1/29/24 15:30, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/29/2024 6:51 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>>> Op 28.jan.2024 om 16:28 schreef olcott:
>>>>>>>>>>>>>>>>>>>> On 1/28/2024 6:12 AM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:36, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:33 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/28/24 01:32, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 6:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 5:34 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 5:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 4:15 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 3:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 4:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 2:35 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:24, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/2024 1:21 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/27/24 20:05, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Three PhD computer science
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> professors agree that the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem has been intentionally
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to be unsatisfiable
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when H is required to report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution of D(D).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/374806722_Does_the_halting_problem_place_an_actual_limit_on_computation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever an input calls its own
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination analyzer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in recursive simulation then H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not allowed to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on different behavior than the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it sees.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every H that must abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of any input D to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own infinite execution is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject D as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you believe it's impossible or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possible to write a program that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports whether the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *It in incorrect for H to do this in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some cases*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would make H a liar*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why would it be incorrect to answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question actually asked?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does D specify halting behavior to H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it does not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, it specifies Halting Behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EVERYONE, as the actual property of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting is independent of who you ask.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies infinite recursion to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D does not specify infinite recursion to H1.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies what ever recursion that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> generates.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> D specifies recursive simulation to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> forcing H to abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of D so that H itself can halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> D only specifies as much recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> to H as H actually does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *PEOPLE THAT DENY TAUTOLOGIES ARE EITHER
>>>>>>>>>>>>>>>>>>>>>>>>>> STUPID OR LIARS*
>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever any simulating termination
>>>>>>>>>>>>>>>>>>>>>>>>>> analyzer H must abort the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input D to prevent its own
>>>>>>>>>>>>>>>>>>>>>>>>>> infinite execution
>>>>>>>>>>>>>>>>>>>>>>>>>> it is always necessarily correct for H to
>>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And the decision to abort was encoded in the
>>>>>>>>>>>>>>>>>>>>>>>>> program of H, and thus into the program of D,
>>>>>>>>>>>>>>>>>>>>>>>>> so when you "alter" H to not abort to show
>>>>>>>>>>>>>>>>>>>>>>>>> this, D doesn't change and still refers to the
>>>>>>>>>>>>>>>>>>>>>>>>> H that did abort.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that you just don't
>>>>>>>>>>>>>>>>>>>>>>>> understand that every H that
>>>>>>>>>>>>>>>>>>>>>>>> can possibly exist must abort its simulated D
>>>>>>>>>>>>>>>>>>>>>>>> because this is simply
>>>>>>>>>>>>>>>>>>>>>>>> over your head because you are not very smart?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Who's talking about every H that could possibly
>>>>>>>>>>>>>>>>>>>>>>> exist? You wrote just one H, not every one that
>>>>>>>>>>>>>>>>>>>>>>> could possibly exist.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The Peter Linz proof uses a program template
>>>>>>>>>>>>>>>>>>>>>> simultaneously referring
>>>>>>>>>>>>>>>>>>>>>> every H that can possibly exist.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The Peter Linz proof template tells you how to make
>>>>>>>>>>>>>>>>>>>>> a proof for the H that you have.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is why I apply my proof of H/D to the Linz proof
>>>>>>>>>>>>>>>>>>>> in my paper. Richard just doesn't seem to get the idea
>>>>>>>>>>>>>>>>>>>> of a program template. He does not understand that
>>>>>>>>>>>>>>>>>>>> analysis can be simultaneously applied to an infinite
>>>>>>>>>>>>>>>>>>>> set of programs.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> One of the problems in this discussion is that
>>>>>>>>>>>>>>>>>>> different instantiations can be made of a template
>>>>>>>>>>>>>>>>>>> and olcott gives them all the same name.
>>>>>>>>>>>>>>>>>>> Just as he uses the same name for different halt
>>>>>>>>>>>>>>>>>>> deciders, some of which abort and others do not abort.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> May I suggest a naming for the different candidate
>>>>>>>>>>>>>>>>>>> halt decoders?
>>>>>>>>>>>>>>>>>>> Here we limit ourselves to simulating halt deciders.
>>>>>>>>>>>>>>>>>>> We can imagine three candidates:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hss: A simple simulating halt decider, which does not
>>>>>>>>>>>>>>>>>>> abort. It is clear it can report only about programs
>>>>>>>>>>>>>>>>>>> which terminate normally.In this case it returns
>>>>>>>>>>>>>>>>>>> 'halting'. It cannot return 'non-halting' in a finite
>>>>>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Han: A simulating halt decider that, when it
>>>>>>>>>>>>>>>>>>> recognizes that the program uses the same algorithm
>>>>>>>>>>>>>>>>>>> that is used in Han to do the opposite, it aborts and
>>>>>>>>>>>>>>>>>>> returns 'non-halting'. (For the sake of this
>>>>>>>>>>>>>>>>>>> discussion, we ignore that it very improbable that
>>>>>>>>>>>>>>>>>>> Han will be possible to recognize all variations of
>>>>>>>>>>>>>>>>>>> the algorithm, because we stick for the moment to the
>>>>>>>>>>>>>>>>>>> template mentioned above. Similarly it will not be
>>>>>>>>>>>>>>>>>>> easy to detect always that the program does the
>>>>>>>>>>>>>>>>>>> opposite.)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is clear that Han is wrong if it assumes that Han
>>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>>> does an infinite recursion, not Han.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hah: A simulating halt decider, similar to Han, but
>>>>>>>>>>>>>>>>>>> when it recognizes that the same algorithm is used to
>>>>>>>>>>>>>>>>>>> do the opposite, it aborts and returns 'halting'.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is clear that Hah is wrong if it assumes that Hah
>>>>>>>>>>>>>>>>>>> will do an infinite recursion, because it is Hss that
>>>>>>>>>>>>>>>>>>> does an infinite recursion, not Hah.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Using these names it is no longer needed to use
>>>>>>>>>>>>>>>>>>> overcomplicated sentence fragments, such as 'keeps
>>>>>>>>>>>>>>>>>>> looping unless aborted'. Because, for Hss 'keeps
>>>>>>>>>>>>>>>>>>> looping' is sufficient, whereas for Han and Hah 'does
>>>>>>>>>>>>>>>>>>> not loop, because aborted' is more clear.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A halting decider needs a program to decide on. It
>>>>>>>>>>>>>>>>>>> cannot decide on a template, because different
>>>>>>>>>>>>>>>>>>> instantiations of a template can do different things.
>>>>>>>>>>>>>>>>>>> Therefore, from these three candidates the template
>>>>>>>>>>>>>>>>>>> can be used to create three programs:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Dss: based on Hss. It is clear that it does not halt,
>>>>>>>>>>>>>>>>>>> because Hss does not halt.
>>>>>>>>>>>>>>>>>>> Dan: based on Han. Han returns 'non-halting', so Dan
>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>> Dah: based on Hah. Han returns 'halting', so Dan does
>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again, we do no longer need overcomplicated sentences
>>>>>>>>>>>>>>>>>>> with 'unless', because it is clear that only Dss is
>>>>>>>>>>>>>>>>>>> involved in infinite recursion within the algorithm
>>>>>>>>>>>>>>>>>>> of Hss. Dan and Dah are not, because Han and Hah are
>>>>>>>>>>>>>>>>>>> not.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Three programs and three candidate halt deciders.
>>>>>>>>>>>>>>>>>>> That results in nine combinations:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss): Hss does not halt and never returns a
>>>>>>>>>>>>>>>>>>> result.
>>>>>>>>>>>>>>>>>>> Hss(Dan,Dan): Hss simulates Dan, including Han.
>>>>>>>>>>>>>>>>>>> Simulation ends normally and Hss reports 'Halting'.
>>>>>>>>>>>>>>>>>>> Hss(Dah,Dah): Hss simulates Dah, including Hah. The
>>>>>>>>>>>>>>>>>>> simulation of Hah returns to the simulation of Dah,
>>>>>>>>>>>>>>>>>>> which does not end. So Hss never returns a result.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Han(Dss,Dss): Han is different from Hss, so the
>>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Han
>>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>>> Han(Dan,Dan): Han recognizes its own algorithm,
>>>>>>>>>>>>>>>>>>> aborts and reports 'non-halting'.
>>>>>>>>>>>>>>>>>>> Han(Dah,Dah): Han is different from Hah, so the
>>>>>>>>>>>>>>>>>>> simulation of Hah is not aborted. The simulation of
>>>>>>>>>>>>>>>>>>> Hah returns with 'halting'. Does Han subsequently
>>>>>>>>>>>>>>>>>>> recognize that D starts an infinite loop? That
>>>>>>>>>>>>>>>>>>> depends on details not provides by olcott.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Hah(Dss,Dss): Hah is different from Hss, so the
>>>>>>>>>>>>>>>>>>> simulation of Hss is not aborted. So, does Hah
>>>>>>>>>>>>>>>>>>> recognize the infinite recursion? That depends on
>>>>>>>>>>>>>>>>>>> details not provided by olcott.
>>>>>>>>>>>>>>>>>>> Hah(Dan,Dan): Hah is different from Han, so the
>>>>>>>>>>>>>>>>>>> simulation of Han is not aborted. The simulation of
>>>>>>>>>>>>>>>>>>> Ha returns with 'non-halting'. The simulation of D
>>>>>>>>>>>>>>>>>>> will end normally and Hah will report 'halting'.
>>>>>>>>>>>>>>>>>>> Hah(Dah,Dah): Hah recognizes its own algorithm,aborts
>>>>>>>>>>>>>>>>>>> and reports 'halting'.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>  From these nine combinations we see that only a few
>>>>>>>>>>>>>>>>>>> are definitely able to report a correct status. we
>>>>>>>>>>>>>>>>>>> also see that the three most important ones
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) and Hah(Dah,Dah) do not
>>>>>>>>>>>>>>>>>>> return the correct status.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> May I suggest that we stick to these names, instead
>>>>>>>>>>>>>>>>>>> of using the same names D and H for different things?
>>>>>>>>>>>>>>>>>>> That would make the discussion more transparent. And
>>>>>>>>>>>>>>>>>>> maybe olcott can tell which case is in discussion,
>>>>>>>>>>>>>>>>>>> Hss(Dss,Dss), Han(Dan,Dan) or Hah(Dah,Dah), or one of
>>>>>>>>>>>>>>>>>>> the other combinations. Are we talking about an
>>>>>>>>>>>>>>>>>>> aborting, or a non-aborting decider? I ask this,
>>>>>>>>>>>>>>>>>>> because sentence fragments like 'keeps looping unless
>>>>>>>>>>>>>>>>>>> aborted', suggests that it is not always aborted, so
>>>>>>>>>>>>>>>>>>> it is not clear whether Hss, Han, or Han is meant.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My whole purpose is to show the only possible way that
>>>>>>>>>>>>>>>>>> H can be
>>>>>>>>>>>>>>>>>> correctly encoded is the current way that H is encoded.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And which way is that? Is it Hss, Han, Hap or something
>>>>>>>>>>>>>>>>> else?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every H that correctly determines in N steps of
>>>>>>>>>>>>>>>>>> correct simulation of
>>>>>>>>>>>>>>>>>> input D that itself would never stop running unless it
>>>>>>>>>>>>>>>>>> aborts its
>>>>>>>>>>>>>>>>>> simulation of D is necessarily correct to report that
>>>>>>>>>>>>>>>>>> *D DOES NOT HALT*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You aren't listening.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am listening and I am overriding and superseding
>>>>>>>>>>>>>>>> misconception.
>>>>>>>>>>>>>>>> One way is correct and all alternative ways are incorrect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except that you aren't ALLOWED to change definitions and
>>>>>>>>>>>>>>> stay in the same Theory. If you try, you have just
>>>>>>>>>>>>>>> thrusted your self into a DIFFERENT field of
>>>>>>>>>>>>>>> PO-Compuations and your POOP problem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Halt deciders have always been required to compute the
>>>>>>>>>>>>>> mapping
>>>>>>>>>>>>>> from their finite strong input to their own accept or reject
>>>>>>>>>>>>>> state on the basis of *THE BEHAVIOR THAT THIS FINITE
>>>>>>>>>>>>>> STRING SPECIFIES*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Strings themselves do not have "Behavior"
>>>>>>>>>>>>
>>>>>>>>>>>> In computability theory, Rice's theorem states that all
>>>>>>>>>>>> non-trivial semantic properties of programs are undecidable.
>>>>>>>>>>>> A semantic property is one *about the program's behavior*
>>>>>>>>>>>> (for instance, does the program terminate for all inputs),
>>>>>>>>>>>> unlike a syntactic property (for instance, does the program
>>>>>>>>>>>> contain an if-then-else statement). A property is
>>>>>>>>>>>> non-trivial if it is neither true for every program, nor
>>>>>>>>>>>> false for every program.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Rice%27s_theorem
>>>>>>>>>>>>>
>>>>>>>>>>>>> The the behavior specified by the input is NOT the Halting
>>>>>>>>>>>>> Behavior of the Compuation described by the input,
>>>>>>>>>>>>
>>>>>>>>>>>> The term "specified" is more precise than "described by". The
>>>>>>>>>>>> latter term allows indirect reference whereas the former one
>>>>>>>>>>>> does not.
>>>>>>>>>>>>
>>>>>>>>>>>> D simulated by H such that H executes the x86 machine code that
>>>>>>>>>>>> D specifies *IS RECURSIVE SIMULATION*. The only alternative is
>>>>>>>>>>>> to incorrectly execute the x86 machine code that D specifies.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which D?
>>>>>>>>>>
>>>>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>>>>> 02 {
>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>> 07 }
>>>>>>>>>> 08
>>>>>>>>>> 09 void main()
>>>>>>>>>> 10 {
>>>>>>>>>> 11   H(D,D);
>>>>>>>>>> 12 }
>>>>>>>>>>
>>>>>>>>>> Every correct H correctly aborts its corresponding D and
>>>>>>>>>> correctly
>>>>>>>>>> rejects D as non-halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Olcott keeps hiding the details. Which H is shown here?
>>>>>>>>> If it is the aborting H, which we call Han, then there is no
>>>>>>>>> need to abort D, because Han aborts itself already. It cannot
>>>>>>>>> be at the same time Hss, which does not abort. Hss and Han are
>>>>>>>>> different deciders with different behaviour and therefore, Dss
>>>>>>>>> is different from Dan
>>>>>>>>>
>>>>>>>>> Han(Dan,Dan) needs to judge its input Dan, not its non-input Dss.
>>>>>>>>
>>>>>>>> As Olcott uses in his proofs the inferene rule knonw as
>>>>>>>> equivocation
>>>>>>>> he must restrict his naming conventions.
>>>>>>>>
>>>>>>>
>>>>>>> When one understands that simulating termination analyzer H
>>>>>>> is always correct to abort any simulation that cannot possibly
>>>>>>> stop running unless aborted
>>>>>>>
>>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>>> 02 {
>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>> 04   if (Halt_Status)
>>>>>>> 05     HERE: goto HERE;
>>>>>>> 06   return Halt_Status;
>>>>>>> 07 }
>>>>>>> 08
>>>>>>> 09 void main()
>>>>>>> 10 {
>>>>>>> 11   H(D,D);
>>>>>>> 12 }
>>>>>>>
>>>>>>> Then every simulating termination analyzer H specified by
>>>>>>> the above template is correct to abort its simulation of D
>>>>>>> and reject D as non-halting.
>>>>>>
>>>>>> Nice to see that you agree with my observation.
>>>>>>
>>>>>> HOwever, the above template does not specify a simulating rermination
>>>>>> analyzer.
>>>>>>
>>>>>
>>>>> Below I reference an infinite set of simulating termination
>>>>> analyzers that each correctly aborts its simulation of D
>>>>> and correctly rejects D as non-halting.
>>>>>
>>>>> *PREMISE*
>>>>> When one understands that simulating termination analyzer H
>>>>> is always correct to abort any simulation that cannot possibly
>>>>> stop running unless aborted:
>>>>>
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> *LOGICALLY ENTAILED BY PREMISE*
>>>>> Then every simulating termination analyzer H specified by
>>>>> the above template correctly aborts its simulation of D
>>>>> and correctly rejects D as non-halting.
>>>>>
>>>>> Pages 661 to 696 of Halt7.c specify the H that does this
>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>
>>>> The above template specifies no simulating termination analyzer.
>>>>
>>>
>>> *That is factually incorrect*
>>>
>>> Both the template and the code do specify a simulating termination
>>> analyzer.
>>
>> The template contains neither any of workds "simulating", "termination",
>> "analyzer", or related words or synonyms nor anything that is or means
>> any of these.
>>
>> Mikko
>>
>
> In other words you are expecting C to understand English or did you
> simply ignore this quoted from above?
>
> *PREMISE*
> When one understands that simulating termination analyzer H
> is always correct to abort any simulation that cannot possibly
> stop running unless aborted:
>
>
Dan stops running unless aborted.

On 31/01/24 17:41, olcott wrote:
> On 1/31/2024 10:21 AM, Fred. Zwarts wrote:
>> Op 31.jan.2024 om 16:54 schreef olcott:
>>> On 1/31/2024 7:04 AM, immibis wrote:
>>>> On 1/31/24 01:56, olcott wrote:
>>>>> On 1/30/2024 6:46 PM, immibis wrote:
>>>>>> On 1/31/24 01:31, olcott wrote:
>>>>>>> I have already been completely through your idea with hundreds of
>>>>>>> posts on another forum with someone else before I determined that
>>>>>>> it is nonsense using set theory.
>>>>>>
>>>>>> Your idea is also nonsense. Maybe you two would be equals.
>>>>>>
>>>>>> The halting problem is to decide whether the execution sequence of
>>>>>> a Turing machine/input pair is finite or infinite.
>>>>>>
>>>>>
>>>>> Close but no cigar. No TM can take another TM as input, it
>>>>> can only take finite strings as input.
>>>>>
>>>>> The halting problem is whether or not a finite string pair
>>>>> (TM description and its input)
>>>>>
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>> *specifies a finite sequence of configurations*
>>>>>
>>>>
>>>> The halting problem is whether or not you get a finite sequence of
>>>> configurations when you execute the finite string pair according to
>>>> Turing Machine rules and no other rules.
>>>
>>> *No that is a common misconception*
>>> The halting problem is actually about computing the mapping
>>> from an input finite string pair such the the first element of
>>> this pair species behavior. It is the behavior that this finite
>>> string specifies that must be reported on.
>>>
>>> When D does call H in recursive simulation such that D cannot
>>> possibly stop running unless aborted the H is necessarily correct
>>> to abort D and reject D as non-halting >
>>> D correctly simulated by H cannot possibly reach the point in
>>> its own execution trace where it does the opposite of whatever
>>> value that H returns.
>>>
>>
>> Olcott's H is of the Han type, because it aborts the simulation and
>
> *PREMISE*
> *When one understands that simulating termination analyzer H*
> *is always correct to abort any simulation that cannot possibly*
> *stop running unless aborted*
>

Olcott has decided to turn his brain off, and instead of reading what I
said, he merely repeats the same magic incantation in the hopes that
magic is real.

On 1/02/24 10:48, Fred. Zwarts wrote:
>
> Strange. Most people will understand that olcotts claim is false within
> a few days, but olcott does not even understand it after a dozen years.
> I am afraid he will need an infinite time to understand it. Probably a
> bug in the AI.
>
The true Olcott Halting Problem is whether Olcott himself will halt
after a finite number of steps.

On 02/05/2024 01:00 PM, immibis wrote:
> On 31/01/24 18:11, olcott wrote:
>> On 1/31/2024 11:07 AM, immibis wrote:
>>> This is saying: If H doesn't abort its simulation then H is correct
>>> to abort its simulation.
>>
>> All halt deciders must predict what the behavior of their
>> input would be.
>
> And yours predicts wrong.

One thing you're getting into is "quantifier disambiguation".

That is, for a given decider, there are undecideable inputs,
but, there exists a different decider, for which the same input's
decideable.

I.e., "for-any for-any" and "for-any for-all" and "for-all for-any"
and "for-all for-all", are four different disambiguations reflecting
quantifier application to the transfer principle or to that "for-each is
for-all", about breaking the quantifier down to at least

for-any <- at least one?
for-each <- going through?
for-every <- gone through?
for-all <- all as one?

that these sort of reflect why the universal quantifier suffers usual
quantifier ambiguities or the impredicative what with regards to
Feferman and quantifier disambiguation helps provide greater concrete
framings for the halting or traveling or branching or Entsheidungs.

This doesn't necessarily so help PO "validate his decider" but it does
illustrate that there are various concrete framings of what's otherwise
let out about static analysis generally, that specifically, there are
always approaches for static analysis to proceed, then as with respect
to existence proofs vis-a-vis demonstrations, and of course the very
notion of "completions", in logic and mathematics, of the "incomplete",
at all.

So, for things like the Sorites or Heap, quantifier disambiguation
doesn't go without saying, for such notions of predicativity and
impredicativity and even just "framing it in the second order" or
"under the conditions where the tape admits an arithmetization,
algebraization, or geometrization".

For tautology and identity and sameness and intensionality and
extensionality and such things, it's a lot about what things are,
"equal", as when, "almost", or the infinite or continuum limit,
vis-a-vis usually ordering theory.

Then, the usual idea that "the world of deciders is too big to find the
right one for an arbitrary input", still has that static analysis finds
most of the easy grapes, and, that the world of deciders is big enough
to include the input's own very one.

Not that it's very general, ....

So, it is a common misconclusion that "there exists an inscrutable input
for this decider" means "there exists inputs inscrutable any decider",
it's a usual error after impredicativity of quantifier ambiguity, where
logic sort of just has "next-higher-order" for these kinds of things,
and all sorts usual forms of concrete static analysis.

--
https://www.youtube.com/@rossfinlayson <- a "podcasts" or "vlog"