Because a halt decider is supposed to divide a set of finite string
pairs of:
(a) Turing Machine descriptions and
(b) Their finite string inputs
into those that halt on their input and those that do not and the
original H(D,D) does not do that I have revised my work.

H now returns three values:
0 == Input has the conventional HP proof pathological relationship to H
1 == Input halts on its input
2 == Input does not halt on its input

A pair of partial halt deciders (H and H1) correctly determines the halt
status of all of the conventional pathological inputs.

When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
correctly determines that the directly executed D(D) halts on its input.
Both H and H1 work this same way so one of the pair is always correct.

The key innovation of this that that both H and H1 correctly determine
all of the cases that they cannot correctly determine. This aspect seems
to refute Rice's theorem.

(a) If H says that D will halt D could do the opposite and loop.

(b) If H says that D will not halt D could do the opposite and halt.

(c) If H says that it cannot correctly return the halt status of the
directly executed D(D) then D cannot possibly thwart this return value.

If H determines that D is undecidable by H there is no possible way that
D can do the opposite and make itself decidable by H.

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

On 7/5/23 12:41 PM, olcott wrote:
> Because a halt decider is supposed to divide a set of finite string
> pairs of:
> (a) Turing Machine descriptions and
> (b) Their finite string inputs
> into those that halt on their input and those that do not and the
> original H(D,D) does not do that I have revised my work.
>
> H now returns three values:
> 0 == Input has the conventional HP proof pathological relationship to H
> 1 == Input halts on its input
> 2 == Input does not halt on its input

So you are admitting that it its a Halt Decider.

>
> A pair of partial halt deciders (H and H1) correctly determines the halt
> status of all of the conventional pathological inputs.

So you don't have a Halt Decider yet, you need your next step.
>
> When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
> correctly determines that the directly executed D(D) halts on its input.
> Both H and H1 work this same way so one of the pair is always correct.
>
> The key innovation of this that that both H and H1 correctly determine
> all of the cases that they cannot correctly determine. This aspect seems
> to refute Rice's theorem.
>
> (a) If H says that D will halt D could do the opposite and loop.
>
> (b) If H says that D will not halt D could do the opposite and halt.
>
> (c) If H says that it cannot correctly return the halt status of the
> directly executed D(D) then D cannot possibly thwart this return value.
>
> If H determines that D is undecidable by H there is no possible way that
> D can do the opposite and make itself decidable by H.
>
Except that now you Halt Deicder is really the computation that does
what you describe, which we can call HD and is describe below:

HD(P, m) first calls H(P, m) and if that gives an difinitive answer,
return it,

else it calls H1(P, m) and returns that answer.

So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
call HD(P,P) and do the opposite of what IT says (not just H, since that
isn't the Halt Decider that is claimed to be correct).

So D(D) calls HD(D,D) which calls H(D,D)

If H(D,D) says its input halts, HD(D,D) will say its input Halts and
D(D) will Loop forever, and HD is wrong.

If H(D,D) says its input never-halts, HD(D,D) will say its its input
never halts, and D(D) will then Halt, and HD is wrong/

If H(D,D) says it can't tell, HD(D,D) will call H1(D,D) and if H1(D,D)
says its input halts, then HD(D,D) will say its input Halts and D(D)
will loop forever, and HD is wrong.

If H1(D,D) says its input will never Halt, then HD(D,D) will say its
input will never halt and D(D) will halt, and HD is wrong.

You keep on forgetting that D isn't a "fixed" machine for all problems,
but needs to be built on the actual machine you claim to be correct.

Thus, even your revised system still fails for the input that is
ACTUALLY needs to get right.

On 7/5/2023 6:55 PM, Richard Damon wrote:
> On 7/5/23 12:41 PM, olcott wrote:
>> Because a halt decider is supposed to divide a set of finite string
>> pairs of:
>> (a) Turing Machine descriptions and
>> (b) Their finite string inputs
>> into those that halt on their input and those that do not and the
>> original H(D,D) does not do that I have revised my work.
>>
>> H now returns three values:
>> 0 == Input has the conventional HP proof pathological relationship to H
>> 1 == Input halts on its input
>> 2 == Input does not halt on its input
>
> So you are admitting that it its a Halt Decider.
>
>>
>> A pair of partial halt deciders (H and H1) correctly determines the halt
>> status of all of the conventional pathological inputs.
>
> So you don't have a Halt Decider yet, you need your next step.
>>
>> When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
>> correctly determines that the directly executed D(D) halts on its input.
>> Both H and H1 work this same way so one of the pair is always correct.
>>
>> The key innovation of this that that both H and H1 correctly determine
>> all of the cases that they cannot correctly determine. This aspect seems
>> to refute Rice's theorem.
>>
>> (a) If H says that D will halt D could do the opposite and loop.
>>
>> (b) If H says that D will not halt D could do the opposite and halt.
>>
>> (c) If H says that it cannot correctly return the halt status of the
>> directly executed D(D) then D cannot possibly thwart this return value.
>>
>> If H determines that D is undecidable by H there is no possible way that
>> D can do the opposite and make itself decidable by H.
>>
> Except that now you Halt Deicder is really the computation that does
> what you describe, which we can call HD and is describe below:
>
> HD(P, m) first calls H(P, m) and if that gives an difinitive answer,
> return it,
>
> else it calls H1(P, m) and returns that answer.
>
> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will

The key innovation is creating a termination analyzer that itself
knows when it cannot get an answer that is consistent with the direct
execution of D(D).

To the best of my knowledge every single source universally agrees that
this is impossible. *Try and find any source that says this is possible*

New_H is also able to correctly determine the halt status of any input
that has an embedded copy of New_H because this causes New_D(New_D) to
have a pathological relationship with itself instead of with New_H.

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

On 7/5/23 10:05 PM, olcott wrote:
> On 7/5/2023 6:55 PM, Richard Damon wrote:
>> On 7/5/23 12:41 PM, olcott wrote:
>>> Because a halt decider is supposed to divide a set of finite string
>>> pairs of:
>>> (a) Turing Machine descriptions and
>>> (b) Their finite string inputs
>>> into those that halt on their input and those that do not and the
>>> original H(D,D) does not do that I have revised my work.
>>>
>>> H now returns three values:
>>> 0 == Input has the conventional HP proof pathological relationship to H
>>> 1 == Input halts on its input
>>> 2 == Input does not halt on its input
>>
>> So you are admitting that it its a Halt Decider.
>>
>>>
>>> A pair of partial halt deciders (H and H1) correctly determines the halt
>>> status of all of the conventional pathological inputs.
>>
>> So you don't have a Halt Decider yet, you need your next step.
>>>
>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
>>> correctly determines that the directly executed D(D) halts on its input.
>>> Both H and H1 work this same way so one of the pair is always correct.
>>>
>>> The key innovation of this that that both H and H1 correctly determine
>>> all of the cases that they cannot correctly determine. This aspect seems
>>> to refute Rice's theorem.
>>>
>>> (a) If H says that D will halt D could do the opposite and loop.
>>>
>>> (b) If H says that D will not halt D could do the opposite and halt.
>>>
>>> (c) If H says that it cannot correctly return the halt status of the
>>> directly executed D(D) then D cannot possibly thwart this return value.
>>>
>>> If H determines that D is undecidable by H there is no possible way that
>>> D can do the opposite and make itself decidable by H.
>>>
>> Except that now you Halt Deicder is really the computation that does
>> what you describe, which we can call HD and is describe below:
>>
>> HD(P, m) first calls H(P, m) and if that gives an difinitive answer,
>> return it,
>>
>> else it calls H1(P, m) and returns that answer.
>>
>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
>
> The key innovation is creating a termination analyzer that itself
> knows when it cannot get an answer that is consistent with the direct
> execution of D(D).

Nope, because then it isn't the actual Halt Decider, but the algorithm
that selects the proper halt decider is.

Since you didn't point out where my logic was wrong, I guess you are
admitting that it was right and you are just blowing smoke

>
> To the best of my knowledge every single source universally agrees that
> this is impossible. *Try and find any source that says this is possible*
>

Since your machine doesn't talk in a Turing Complete set, it may well be
possible.

> New_H is also able to correctly determine the halt status of any input
> that has an embedded copy of New_H because this causes New_D(New_D) to
> have a pathological relationship with itself instead of with New_H.
>
>

So, where was my analysis of what happens incorrect?

New_D calls New_H, which either says it halts or it doesn't (it uses H
which says it can't decide, so it goes to H1)

If your mean new_H is the revised H that answers "Pathological", that
isn't the machine that is actually doing the decision, but the HD that I
talked about, and new_D is built on HD, so HD will get the answer wrong.

You are just showing that you brain can't think all the way through the
problem, and you just end up lyihg to yourself.

On 7/5/2023 10:07 PM, Richard Damon wrote:
> On 7/5/23 10:05 PM, olcott wrote:
>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>> On 7/5/23 12:41 PM, olcott wrote:
>>>> Because a halt decider is supposed to divide a set of finite string
>>>> pairs of:
>>>> (a) Turing Machine descriptions and
>>>> (b) Their finite string inputs
>>>> into those that halt on their input and those that do not and the
>>>> original H(D,D) does not do that I have revised my work.
>>>>
>>>> H now returns three values:
>>>> 0 == Input has the conventional HP proof pathological relationship to H
>>>> 1 == Input halts on its input
>>>> 2 == Input does not halt on its input
>>>
>>> So you are admitting that it its a Halt Decider.
>>>
>>>>
>>>> A pair of partial halt deciders (H and H1) correctly determines the
>>>> halt
>>>> status of all of the conventional pathological inputs.
>>>
>>> So you don't have a Halt Decider yet, you need your next step.
>>>>
>>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
>>>> correctly determines that the directly executed D(D) halts on its
>>>> input.
>>>> Both H and H1 work this same way so one of the pair is always correct.
>>>>
>>>> The key innovation of this that that both H and H1 correctly determine
>>>> all of the cases that they cannot correctly determine. This aspect
>>>> seems
>>>> to refute Rice's theorem.
>>>>
>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>
>>>> (b) If H says that D will not halt D could do the opposite and halt.
>>>>
>>>> (c) If H says that it cannot correctly return the halt status of the
>>>> directly executed D(D) then D cannot possibly thwart this return value.
>>>>
>>>> If H determines that D is undecidable by H there is no possible way
>>>> that
>>>> D can do the opposite and make itself decidable by H.
>>>>
>>> Except that now you Halt Deicder is really the computation that does
>>> what you describe, which we can call HD and is describe below:
>>>
>>> HD(P, m) first calls H(P, m) and if that gives an difinitive answer,
>>> return it,
>>>
>>> else it calls H1(P, m) and returns that answer.
>>>
>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
>>
>> The key innovation is creating a termination analyzer that itself
>> knows when it cannot get an answer that is consistent with the direct
>> execution of D(D).
>
> Nope, because then it isn't the actual Halt Decider, but the algorithm
> that selects the proper halt decider is.
>

It is a halting decidability decider that always gets the correct
answer on all of the counter-examples to the conventional halting
problem proofs.

It seems to me to refute Rice's theorem and the strongest argument that
you have presented against this is that you simply don;t believe it.

Because H does determine a non trivial semantic property this by itself
seems to refute Rice. You saying that you really don't think so is no
actual rebuttal at all.

It is a non-trivial semantic property and this seems to be both a
necessary and sufficient condition for refuting Rice.

A actual rebuttal must explain how non-trivial semantic property
is not necessary and sufficient condition for refuting Rice.

> Since you didn't point out where my logic was wrong, I guess you are
> admitting that it was right and you are just blowing smoke
>

H is a correct termination analyzer from a software engineering point
of view even if it does not divide all inputs pairs into halting and
non-halting on the basis of their direct execution.

H does reject pathological inputs as bad inputs in terms of a Denial of
Service attack detector. *No one have been able to detect these before*
Everyone assumed that Rice made this impossible.

Contradictory questions are incorrect questions thus placing the blame
for undecidability on the question and not the answerer.

>>
>> To the best of my knowledge every single source universally agrees that
>> this is impossible. *Try and find any source that says this is possible*
>>
>
> Since your machine doesn't talk in a Turing Complete set, it may well be
> possible.
>

You are using the wrong term. The correct term is Turing computable.
https://en.wikipedia.org/wiki/Computable_function#

>> New_H is also able to correctly determine the halt status of any input
>> that has an embedded copy of New_H because this causes New_D(New_D) to
>> have a pathological relationship with itself instead of with New_H.
>>
>>
>
>
> So, where was my analysis of what happens incorrect?

New_H correctly reports on the behavior of the direct execution of
New_D(New_D). It can do this because New_D has a pathological
relationship to itself thus preventing a pathological relationship to
New_H.

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

On 7/6/23 6:57 PM, olcott wrote:
> On 7/5/2023 10:07 PM, Richard Damon wrote:
>> On 7/5/23 10:05 PM, olcott wrote:
>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>> Because a halt decider is supposed to divide a set of finite string
>>>>> pairs of:
>>>>> (a) Turing Machine descriptions and
>>>>> (b) Their finite string inputs
>>>>> into those that halt on their input and those that do not and the
>>>>> original H(D,D) does not do that I have revised my work.
>>>>>
>>>>> H now returns three values:
>>>>> 0 == Input has the conventional HP proof pathological relationship
>>>>> to H
>>>>> 1 == Input halts on its input
>>>>> 2 == Input does not halt on its input
>>>>
>>>> So you are admitting that it its a Halt Decider.
>>>>
>>>>>
>>>>> A pair of partial halt deciders (H and H1) correctly determines the
>>>>> halt
>>>>> status of all of the conventional pathological inputs.
>>>>
>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>
>>>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D) which
>>>>> correctly determines that the directly executed D(D) halts on its
>>>>> input.
>>>>> Both H and H1 work this same way so one of the pair is always correct.
>>>>>
>>>>> The key innovation of this that that both H and H1 correctly determine
>>>>> all of the cases that they cannot correctly determine. This aspect
>>>>> seems
>>>>> to refute Rice's theorem.
>>>>>
>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>
>>>>> (b) If H says that D will not halt D could do the opposite and halt.
>>>>>
>>>>> (c) If H says that it cannot correctly return the halt status of the
>>>>> directly executed D(D) then D cannot possibly thwart this return
>>>>> value.
>>>>>
>>>>> If H determines that D is undecidable by H there is no possible way
>>>>> that
>>>>> D can do the opposite and make itself decidable by H.
>>>>>
>>>> Except that now you Halt Deicder is really the computation that does
>>>> what you describe, which we can call HD and is describe below:
>>>>
>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive answer,
>>>> return it,
>>>>
>>>> else it calls H1(P, m) and returns that answer.
>>>>
>>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
>>>
>>> The key innovation is creating a termination analyzer that itself
>>> knows when it cannot get an answer that is consistent with the direct
>>> execution of D(D).
>>
>> Nope, because then it isn't the actual Halt Decider, but the algorithm
>> that selects the proper halt decider is.
>>
>
> It is a halting decidability decider that always gets the correct
> answer on all of the counter-examples to the conventional halting
> problem proofs.

So what answer does it give the HD that I described?

>
> It seems to me to refute Rice's theorem and the strongest argument that
> you have presented against this is that you simply don;t believe it.

Nope. You may think so, but it doesn/t

>
> Because H does determine a non trivial semantic property this by itself
> seems to refute Rice. You saying that you really don't think so is no
> actual rebuttal at all.

But Rice isn't about determining a property of YOURSELF, but of an
arbirtray input / memebership of an input in a language.

>
> It is a non-trivial semantic property and this seems to be both a
> necessary and sufficient condition for refuting Rice.

First, it doesn't get it right, you have only attempted a SINGLE input,
you need to show it gets it right for ALL inputs.

You are just proving your lack of understanding.

>
> A actual rebuttal must explain how non-trivial semantic property
> is not necessary and sufficient condition for refuting Rice.

Like that fact that you have only showed it attempting to answer for a
single input?

That isn't what Rice is about.

>
>> Since you didn't point out where my logic was wrong, I guess you are
>> admitting that it was right and you are just blowing smoke
>>
>
> H is a correct termination analyzer from a software engineering point
> of view even if it does not divide all inputs pairs into halting and
> non-halting on the basis of their direct execution.

So you are admitting it isn't a Halting Decider from a Computation
Theory point of view, and thus your whole arguement is a Red Herring and
a LIE.

>
> H does reject pathological inputs as bad inputs in terms of a Denial of
> Service attack detector. *No one have been able to detect these before*
> Everyone assumed that Rice made this impossible.

So, you admit that your Halt Decider can't answer the ACTUAL Halting
Question, and that you don't understand what Rice is about.

>
> Contradictory questions are incorrect questions thus placing the blame
> for undecidability on the question and not the answerer.

But the actual question of the Halting Problem isn't "Contradictory", so
you are just proving yourself a Liar.

>
>>>
>>> To the best of my knowledge every single source universally agrees that
>>> this is impossible. *Try and find any source that says this is possible*
>>>
>>
>> Since your machine doesn't talk in a Turing Complete set, it may well
>> be possible.
>>
>
> You are using the wrong term. The correct term is Turing computable.
> https://en.wikipedia.org/wiki/Computable_function#
>

No, you are.

Turing Computable, means that you can create a Turing Machine (or a
computation in a Turing Complete equivalent) to compute the answer for
any input. Like Halting Isn't

Turing Complete means the system can compute anything that a Turing
Machine can. Your system FAILS, since you say H is an equivalent of a
Turing Machine, but we also can't create the equivalent machine to give
as an input that gives the exact same answer for every input that can be
imbedded into another machine.

ERGO, your system fails to meet the requirements of the Halting Problem.

>>> New_H is also able to correctly determine the halt status of any input
>>> that has an embedded copy of New_H because this causes New_D(New_D) to
>>> have a pathological relationship with itself instead of with New_H.
>>>
>>>
>>
>>
>> So, where was my analysis of what happens incorrect?
>
> New_H correctly reports on the behavior of the direct execution of
> New_D(New_D). It can do this because New_D has a pathological
> relationship to itself thus preventing a pathological relationship to
> New_H.
>
>
???

You are just spouting non-sense. BY DEFINITION, what every halt decider
you are trying to claim is correct is the machine that "D" needs to be
built on to use in the "pathological" relationship.

I guess you are just admitting you are doing it wrong and admitting you
don't know what you are doing.

YOU FAIL.

On 7/6/2023 9:40 PM, Richard Damon wrote:
> On 7/6/23 6:57 PM, olcott wrote:
>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>> On 7/5/23 10:05 PM, olcott wrote:
>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>> Because a halt decider is supposed to divide a set of finite string
>>>>>> pairs of:
>>>>>> (a) Turing Machine descriptions and
>>>>>> (b) Their finite string inputs
>>>>>> into those that halt on their input and those that do not and the
>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>
>>>>>> H now returns three values:
>>>>>> 0 == Input has the conventional HP proof pathological relationship
>>>>>> to H
>>>>>> 1 == Input halts on its input
>>>>>> 2 == Input does not halt on its input
>>>>>
>>>>> So you are admitting that it its a Halt Decider.
>>>>>
>>>>>>
>>>>>> A pair of partial halt deciders (H and H1) correctly determines
>>>>>> the halt
>>>>>> status of all of the conventional pathological inputs.
>>>>>
>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>
>>>>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D)
>>>>>> which
>>>>>> correctly determines that the directly executed D(D) halts on its
>>>>>> input.
>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>> correct.
>>>>>>
>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>> determine
>>>>>> all of the cases that they cannot correctly determine. This aspect
>>>>>> seems
>>>>>> to refute Rice's theorem.
>>>>>>
>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>
>>>>>> (b) If H says that D will not halt D could do the opposite and halt.
>>>>>>
>>>>>> (c) If H says that it cannot correctly return the halt status of the
>>>>>> directly executed D(D) then D cannot possibly thwart this return
>>>>>> value.
>>>>>>
>>>>>> If H determines that D is undecidable by H there is no possible
>>>>>> way that
>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>
>>>>> Except that now you Halt Deicder is really the computation that
>>>>> does what you describe, which we can call HD and is describe below:
>>>>>
>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>> answer, return it,
>>>>>
>>>>> else it calls H1(P, m) and returns that answer.
>>>>>
>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
>>>>
>>>> The key innovation is creating a termination analyzer that itself
>>>> knows when it cannot get an answer that is consistent with the direct
>>>> execution of D(D).
>>>
>>> Nope, because then it isn't the actual Halt Decider, but the
>>> algorithm that selects the proper halt decider is.
>>>
>>
>> It is a halting decidability decider that always gets the correct
>> answer on all of the counter-examples to the conventional halting
>> problem proofs.
>
> So what answer does it give the HD that I described?
>
>>
>> It seems to me to refute Rice's theorem and the strongest argument that
>> you have presented against this is that you simply don;t believe it.
>
> Nope. You may think so, but it doesn/t
>
>>
>> Because H does determine a non trivial semantic property this by itself
>> seems to refute Rice. You saying that you really don't think so is no
>> actual rebuttal at all.
>
> But Rice isn't about determining a property of YOURSELF, but of an
> arbirtray input / memebership of an input in a language.
>
>>
>> It is a non-trivial semantic property and this seems to be both a
>> necessary and sufficient condition for refuting Rice.
>
> First, it doesn't get it right, you have only attempted a SINGLE input,
> you need to show it gets it right for ALL inputs.
>

It does correctly determine the presence or absence of the semantic
property of the conventional halting problem pathological relationship
for every instance of this conventional halting problem pathological
relationship.

D can be changed in an infinite number of ways and H still recognizes
this semantic property.

> You are just proving your lack of understanding.
>
>>
>> A actual rebuttal must explain how non-trivial semantic property
>> is not necessary and sufficient condition for refuting Rice.
>
> Like that fact that you have only showed it attempting to answer for a
> single input?
>

I understand my algorithm much better than you so I can see that it
can handle infinite variations of the same basic theme.

> That isn't what Rice is about.
>

Yes that isn't what Rice is about.

>>
>>> Since you didn't point out where my logic was wrong, I guess you are
>>> admitting that it was right and you are just blowing smoke
>>>
>>
>> H is a correct termination analyzer from a software engineering point
>> of view even if it does not divide all inputs pairs into halting and
>> non-halting on the basis of their direct execution.
>
> So you are admitting it isn't a Halting Decider from a Computation
> Theory point of view, and thus your whole arguement is a Red Herring and
> a LIE.
>

Not at all. Five 12 hours days of talking this over with a PhD computer
scientist (the recent portion of our dialog takes 470 pages of text)
provided a precise definition of what H does not do.

I am not quite sure of this, but, it also seemed to be agreed that the
halting problem instances are really nothing more that the inability to
answer an incorrect question.

If H defeats Rice that would be bigger than solving the halting problem.

>>
>> H does reject pathological inputs as bad inputs in terms of a Denial of
>> Service attack detector. *No one have been able to detect these before*
>> Everyone assumed that Rice made this impossible.
>
> So, you admit that your Halt Decider can't answer the ACTUAL Halting
> Question, and that you don't understand what Rice is about.
>

No one and nothing can correctly answer a contradictory question.
No computer scientist every noticed this crucial {formal semantics
of natural language} aspect of the halting problem or they would
have never continued to construed it as any limitation of computer
science.

If a baker cannot bake a perfect angel food cake using only ordinary
red house bricks as the only ingredient this is zero limitation
what-so-ever of their baking skills.

>>
>> Contradictory questions are incorrect questions thus placing the blame
>> for undecidability on the question and not the answerer.
>
> But the actual question of the Halting Problem isn't "Contradictory", so
> you are just proving yourself a Liar.
>

Anyone knowing the formal semantics of natural language knows that
ignored the full context (such as who is asked) derived incorrect
semantics. I have spoken with the people on sci.lang about this
for many years. They vehemently disagree with Frege's principle of
compositionality because they believe that it ignore context.
https://en.wikipedia.org/wiki/Principle_of_compositionality

>>
>>>>
>>>> To the best of my knowledge every single source universally agrees that
>>>> this is impossible. *Try and find any source that says this is
>>>> possible*
>>>>
>>>
>>> Since your machine doesn't talk in a Turing Complete set, it may well
>>> be possible.
>>>
>>
>> You are using the wrong term. The correct term is Turing computable.
>> https://en.wikipedia.org/wiki/Computable_function#
>>
>
> No, you are.
>
> Turing Computable, means that you can create a Turing Machine (or a
> computation in a Turing Complete equivalent) to compute the answer for
> any input. Like Halting Isn't
>
> Turing Complete means the system can compute anything that a Turing
> Machine can.

On 7/6/23 11:18 PM, olcott wrote:
> On 7/6/2023 9:40 PM, Richard Damon wrote:
>> On 7/6/23 6:57 PM, olcott wrote:
>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>> Because a halt decider is supposed to divide a set of finite string
>>>>>>> pairs of:
>>>>>>> (a) Turing Machine descriptions and
>>>>>>> (b) Their finite string inputs
>>>>>>> into those that halt on their input and those that do not and the
>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>
>>>>>>> H now returns three values:
>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>> relationship to H
>>>>>>> 1 == Input halts on its input
>>>>>>> 2 == Input does not halt on its input
>>>>>>
>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>
>>>>>>>
>>>>>>> A pair of partial halt deciders (H and H1) correctly determines
>>>>>>> the halt
>>>>>>> status of all of the conventional pathological inputs.
>>>>>>
>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>
>>>>>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D)
>>>>>>> which
>>>>>>> correctly determines that the directly executed D(D) halts on its
>>>>>>> input.
>>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>>> correct.
>>>>>>>
>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>> determine
>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>> aspect seems
>>>>>>> to refute Rice's theorem.
>>>>>>>
>>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>>
>>>>>>> (b) If H says that D will not halt D could do the opposite and halt.
>>>>>>>
>>>>>>> (c) If H says that it cannot correctly return the halt status of the
>>>>>>> directly executed D(D) then D cannot possibly thwart this return
>>>>>>> value.
>>>>>>>
>>>>>>> If H determines that D is undecidable by H there is no possible
>>>>>>> way that
>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>
>>>>>> Except that now you Halt Deicder is really the computation that
>>>>>> does what you describe, which we can call HD and is describe below:
>>>>>>
>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>> answer, return it,
>>>>>>
>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>
>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P) will
>>>>>
>>>>> The key innovation is creating a termination analyzer that itself
>>>>> knows when it cannot get an answer that is consistent with the direct
>>>>> execution of D(D).
>>>>
>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>> algorithm that selects the proper halt decider is.
>>>>
>>>
>>> It is a halting decidability decider that always gets the correct
>>> answer on all of the counter-examples to the conventional halting
>>> problem proofs.
>>
>> So what answer does it give the HD that I described?
>>
>>>
>>> It seems to me to refute Rice's theorem and the strongest argument that
>>> you have presented against this is that you simply don;t believe it.
>>
>> Nope. You may think so, but it doesn/t
>>
>>>
>>> Because H does determine a non trivial semantic property this by itself
>>> seems to refute Rice. You saying that you really don't think so is no
>>> actual rebuttal at all.
>>
>> But Rice isn't about determining a property of YOURSELF, but of an
>> arbirtray input / memebership of an input in a language.
>>
>>>
>>> It is a non-trivial semantic property and this seems to be both a
>>> necessary and sufficient condition for refuting Rice.
>>
>> First, it doesn't get it right, you have only attempted a SINGLE
>> input, you need to show it gets it right for ALL inputs.
>>
>
> It does correctly determine the presence or absence of the semantic
> property of the conventional halting problem pathological relationship
> for every instance of this conventional halting problem pathological
> relationship.
>
> D can be changed in an infinite number of ways and H still recognizes
> this semantic property.

Ecept that you haven't actually DEFINED what the property means.

Do you REALLY mean that one machine is being both the "Halt Decider" and
also contary detctor?

If so, D calls H, and it returns 1 saying it is halting and
non-contrary, it doesn't halt, and thus WAS contrary (since it was
non-halting so contrary)

If H returns 0 saying it is non-halting and contrary, it can also be
non-halting, and thus wasn't contrary, so H fails to detect that the
input wasn't contrary.

If you mean two different machine, you need to define them.

>
>> You are just proving your lack of understanding.
>>
>>>
>>> A actual rebuttal must explain how non-trivial semantic property
>>> is not necessary and sufficient condition for refuting Rice.
>>
>> Like that fact that you have only showed it attempting to answer for a
>> single input?
>>
>
> I understand my algorithm much better than you so I can see that it
> can handle infinite variations of the same basic theme.

So? Doesn't mean you have to actually DEFINE to others what you mean and
show that you meet the requirement you claim.

This is typical pathological liar technique. Don't commit to anything so
nothing can actually be tested.

>
>> That isn't what Rice is about.
>>
>
> Yes that isn't what Rice is about.

So, you agree that you haven't done anything to disprove Rice, and are
lying when you said you did.

>
>>>
>>>> Since you didn't point out where my logic was wrong, I guess you are
>>>> admitting that it was right and you are just blowing smoke
>>>>
>>>
>>> H is a correct termination analyzer from a software engineering point
>>> of view even if it does not divide all inputs pairs into halting and
>>> non-halting on the basis of their direct execution.
>>
>> So you are admitting it isn't a Halting Decider from a Computation
>> Theory point of view, and thus your whole arguement is a Red Herring
>> and a LIE.
>>
>
> Not at all. Five 12 hours days of talking this over with a PhD computer
> scientist (the recent portion of our dialog takes 470 pages of text)
> provided a precise definition of what H does not do.
>
You don't need to define what H doesn't do, you need to define what H
actually does.

Since the question it is answering doesn't exactly match in values as
the actual Halting Problem, your machine is NOT a "Halt Decider". PERIOD.

This means you are just admitting to being a LIAR when you claimed it was.

> I am not quite sure of this, but, it also seemed to be agreed that the
> halting problem instances are really nothing more that the inability to
> answer an incorrect question.

But what is wrong with the ACTUAL question? Your problem is you keep
looking at a different quet.

>
> If H defeats Rice that would be bigger than solving the halting problem.

Yes, but you needd to show that it actuall does. And that means you need
to show that you can create a property that you can SHOW is ACTUALLY
"Semantic" (per the full definition, not the ones converted into layman
terms) and that your decider can answer correctly for EVERY possible input.

On 7/6/2023 11:15 PM, Richard Damon wrote:
> On 7/6/23 11:18 PM, olcott wrote:
>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>> On 7/6/23 6:57 PM, olcott wrote:
>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>> Because a halt decider is supposed to divide a set of finite string
>>>>>>>> pairs of:
>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>> (b) Their finite string inputs
>>>>>>>> into those that halt on their input and those that do not and the
>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>
>>>>>>>> H now returns three values:
>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>> relationship to H
>>>>>>>> 1 == Input halts on its input
>>>>>>>> 2 == Input does not halt on its input
>>>>>>>
>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>
>>>>>>>>
>>>>>>>> A pair of partial halt deciders (H and H1) correctly determines
>>>>>>>> the halt
>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>
>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>
>>>>>>>> When H(D,D) returns 0 the human user merely needs to run H1(D,D)
>>>>>>>> which
>>>>>>>> correctly determines that the directly executed D(D) halts on
>>>>>>>> its input.
>>>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>>>> correct.
>>>>>>>>
>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>> determine
>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>> aspect seems
>>>>>>>> to refute Rice's theorem.
>>>>>>>>
>>>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>>>
>>>>>>>> (b) If H says that D will not halt D could do the opposite and
>>>>>>>> halt.
>>>>>>>>
>>>>>>>> (c) If H says that it cannot correctly return the halt status of
>>>>>>>> the
>>>>>>>> directly executed D(D) then D cannot possibly thwart this return
>>>>>>>> value.
>>>>>>>>
>>>>>>>> If H determines that D is undecidable by H there is no possible
>>>>>>>> way that
>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>
>>>>>>> Except that now you Halt Deicder is really the computation that
>>>>>>> does what you describe, which we can call HD and is describe below:
>>>>>>>
>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>> answer, return it,
>>>>>>>
>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>
>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P)
>>>>>>> will
>>>>>>
>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>> knows when it cannot get an answer that is consistent with the direct
>>>>>> execution of D(D).
>>>>>
>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>> algorithm that selects the proper halt decider is.
>>>>>
>>>>
>>>> It is a halting decidability decider that always gets the correct
>>>> answer on all of the counter-examples to the conventional halting
>>>> problem proofs.
>>>
>>> So what answer does it give the HD that I described?
>>>
>>>>
>>>> It seems to me to refute Rice's theorem and the strongest argument that
>>>> you have presented against this is that you simply don;t believe it.
>>>
>>> Nope. You may think so, but it doesn/t
>>>
>>>>
>>>> Because H does determine a non trivial semantic property this by itself
>>>> seems to refute Rice. You saying that you really don't think so is no
>>>> actual rebuttal at all.
>>>
>>> But Rice isn't about determining a property of YOURSELF, but of an
>>> arbirtray input / memebership of an input in a language.
>>>
>>>>
>>>> It is a non-trivial semantic property and this seems to be both a
>>>> necessary and sufficient condition for refuting Rice.
>>>
>>> First, it doesn't get it right, you have only attempted a SINGLE
>>> input, you need to show it gets it right for ALL inputs.
>>>
>>
>> It does correctly determine the presence or absence of the semantic
>> property of the conventional halting problem pathological relationship
>> for every instance of this conventional halting problem pathological
>> relationship.
>>
>> D can be changed in an infinite number of ways and H still recognizes
>> this semantic property.
>
> Ecept that you haven't actually DEFINED what the property means.
>
> Do you REALLY mean that one machine is being both the "Halt Decider" and
> also contary detctor?
>

The best way to do this is for H to recognize the semantic property of
{BAD_INPUT} from a Denial of Service Attack Detector.
GOOD_INPUT halts.
BAD_INPUT either does not halt or has defined a pathological
relationship to H.

This is a sufficient basis to create a termination analyzer that
consistently catches all non-termination bugs.

Because inputs that specifically target the termination analyzer
are aptly construed as malevolent inputs such a termination analyzer
would not let any BAD_INPUT slip through undetected.

> If so, D calls H, and it returns 1 saying it is halting and
> non-contrary, it doesn't halt, and thus WAS contrary (since it was
> non-halting so contrary)
>
> If H returns 0 saying it is non-halting  and contrary, it can also be
> non-halting, and thus wasn't contrary, so H fails to detect that the
> input wasn't contrary.
>
> If you mean two different machine, you need to define them.
>
>>
>>> You are just proving your lack of understanding.
>>>
>>>>
>>>> A actual rebuttal must explain how non-trivial semantic property
>>>> is not necessary and sufficient condition for refuting Rice.
>>>
>>> Like that fact that you have only showed it attempting to answer for
>>> a single input?
>>>
>>
>> I understand my algorithm much better than you so I can see that it
>> can handle infinite variations of the same basic theme.
>
> So? Doesn't mean you have to actually DEFINE to others what you mean and
> show that you meet the requirement you claim.
>
> This is typical pathological liar technique. Don't commit to anything so
> nothing can actually be tested.
>
>>
>>> That isn't what Rice is about.
>>>
>>
>> Yes that isn't what Rice is about.
>
> So, you agree that you haven't done anything to disprove Rice, and are
> lying when you said you did.
>
>>
>>>>
>>>>> Since you didn't point out where my logic was wrong, I guess you
>>>>> are admitting that it was right and you are just blowing smoke
>>>>>
>>>>
>>>> H is a correct termination analyzer from a software engineering point
>>>> of view even if it does not divide all inputs pairs into halting and
>>>> non-halting on the basis of their direct execution.
>>>
>>> So you are admitting it isn't a Halting Decider from a Computation
>>> Theory point of view, and thus your whole arguement is a Red Herring
>>> and a LIE.
>>>
>>
>> Not at all. Five 12 hours days of talking this over with a PhD computer
>> scientist (the recent portion of our dialog takes 470 pages of text)
>> provided a precise definition of what H does not do.
>>
> You don't need to define what H doesn't do, you need to define what H
> actually does.
>
> Since the question it is answering doesn't exactly match in values as
> the actual Halting Problem, your machine is NOT a "Halt Decider". PERIOD.
>

On 7/7/23 1:47 PM, olcott wrote:
> On 7/6/2023 11:15 PM, Richard Damon wrote:
>> On 7/6/23 11:18 PM, olcott wrote:
>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>> Because a halt decider is supposed to divide a set of finite
>>>>>>>>> string
>>>>>>>>> pairs of:
>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>> (b) Their finite string inputs
>>>>>>>>> into those that halt on their input and those that do not and the
>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>
>>>>>>>>> H now returns three values:
>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>> relationship to H
>>>>>>>>> 1 == Input halts on its input
>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>
>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> A pair of partial halt deciders (H and H1) correctly determines
>>>>>>>>> the halt
>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>
>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>
>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>> H1(D,D) which
>>>>>>>>> correctly determines that the directly executed D(D) halts on
>>>>>>>>> its input.
>>>>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>>>>> correct.
>>>>>>>>>
>>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>>> determine
>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>> aspect seems
>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>
>>>>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>>>>
>>>>>>>>> (b) If H says that D will not halt D could do the opposite and
>>>>>>>>> halt.
>>>>>>>>>
>>>>>>>>> (c) If H says that it cannot correctly return the halt status
>>>>>>>>> of the
>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>> return value.
>>>>>>>>>
>>>>>>>>> If H determines that D is undecidable by H there is no possible
>>>>>>>>> way that
>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>
>>>>>>>> Except that now you Halt Deicder is really the computation that
>>>>>>>> does what you describe, which we can call HD and is describe below:
>>>>>>>>
>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>> answer, return it,
>>>>>>>>
>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>
>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD, D(P)
>>>>>>>> will
>>>>>>>
>>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>>> knows when it cannot get an answer that is consistent with the
>>>>>>> direct
>>>>>>> execution of D(D).
>>>>>>
>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>> algorithm that selects the proper halt decider is.
>>>>>>
>>>>>
>>>>> It is a halting decidability decider that always gets the correct
>>>>> answer on all of the counter-examples to the conventional halting
>>>>> problem proofs.
>>>>
>>>> So what answer does it give the HD that I described?
>>>>
>>>>>
>>>>> It seems to me to refute Rice's theorem and the strongest argument
>>>>> that
>>>>> you have presented against this is that you simply don;t believe it.
>>>>
>>>> Nope. You may think so, but it doesn/t
>>>>
>>>>>
>>>>> Because H does determine a non trivial semantic property this by
>>>>> itself
>>>>> seems to refute Rice. You saying that you really don't think so is no
>>>>> actual rebuttal at all.
>>>>
>>>> But Rice isn't about determining a property of YOURSELF, but of an
>>>> arbirtray input / memebership of an input in a language.
>>>>
>>>>>
>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>> necessary and sufficient condition for refuting Rice.
>>>>
>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>> input, you need to show it gets it right for ALL inputs.
>>>>
>>>
>>> It does correctly determine the presence or absence of the semantic
>>> property of the conventional halting problem pathological relationship
>>> for every instance of this conventional halting problem pathological
>>> relationship.
>>>
>>> D can be changed in an infinite number of ways and H still recognizes
>>> this semantic property.
>>
>> Ecept that you haven't actually DEFINED what the property means.
>>
>> Do you REALLY mean that one machine is being both the "Halt Decider"
>> and also contary detctor?
>>
>
> The best way to do this is for H to recognize the semantic property of
> {BAD_INPUT} from a Denial of Service Attack Detector.
> GOOD_INPUT halts.
> BAD_INPUT either does not halt or has defined a pathological
> relationship to H.
>

So D asks H if it is a "Bad Input" and if so, it just halts, thus it is
not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
Property, remember, a Semantic Property requires the execution of the
program decribed by its input, not the "Decider" trying to decide the input.

Thus, D isn't ACTUALLY a "Bad Input", since for that particular H, the H
aborts its simulation (as not actually a DOS) and doesn't run forever.

You seem to have the idea that the behavior of H isn't fixed for a given
input.

> This is a sufficient basis to create a termination analyzer that
> consistently catches all non-termination bugs.

So, is the "Termination analyzer" H, or some other machine.

If it is H, then the above shows how H is wrong.

If it is some other machine T, then we just need to build D on T, and if
T says that it will Halt, (which from your logic says H will say it
doesn't halt, then D loops forever, thus both T and H are wrong.

If T says that it will never halt, it just halts, showing that T was wrong.
>
> Because inputs that specifically target the termination analyzer
> are aptly construed as malevolent inputs such a termination analyzer
> would not let any BAD_INPUT slip through undetected.

But the "Bad Input" is a program that Halts, and thus NOT actually a
malevolent input. It is only malvolent for some other system, which
doesn't apply.

Unless you want to define what you actually mean by a "malevolent"
input, you are just shown to be wrong.

This seems to be your problem, that you like to use terms that you don't
have mean what they actually mean.

>
>
>> If so, D calls H, and it returns 1 saying it is halting and
>> non-contrary, it doesn't halt, and thus WAS contrary (since it was
>> non-halting so contrary)
>>
>> If H returns 0 saying it is non-halting  and contrary, it can also be
>> non-halting, and thus wasn't contrary, so H fails to detect that the
>> input wasn't contrary.
>>
>> If you mean two different machine, you need to define them.
>>
>>>
>>>> You are just proving your lack of understanding.
>>>>
>>>>>
>>>>> A actual rebuttal must explain how non-trivial semantic property
>>>>> is not necessary and sufficient condition for refuting Rice.
>>>>
>>>> Like that fact that you have only showed it attempting to answer for
>>>> a single input?
>>>>
>>>
>>> I understand my algorithm much better than you so I can see that it
>>> can handle infinite variations of the same basic theme.
>>
>> So? Doesn't mean you have to actually DEFINE to others what you mean
>> and show that you meet the requirement you claim.
>>
>> This is typical pathological liar technique. Don't commit to anything
>> so nothing can actually be tested.
>>
>>>
>>>> That isn't what Rice is about.
>>>>
>>>
>>> Yes that isn't what Rice is about.
>>
>> So, you agree that you haven't done anything to disprove Rice, and are
>> lying when you said you did.
>>
>>>
>>>>>
>>>>>> Since you didn't point out where my logic was wrong, I guess you
>>>>>> are admitting that it was right and you are just blowing smoke
>>>>>>
>>>>>
>>>>> H is a correct termination analyzer from a software engineering point
>>>>> of view even if it does not divide all inputs pairs into halting and
>>>>> non-halting on the basis of their direct execution.
>>>>
>>>> So you are admitting it isn't a Halting Decider from a Computation
>>>> Theory point of view, and thus your whole arguement is a Red Herring
>>>> and a LIE.
>>>>
>>>
>>> Not at all. Five 12 hours days of talking this over with a PhD computer
>>> scientist (the recent portion of our dialog takes 470 pages of text)
>>> provided a precise definition of what H does not do.
>>>
>> You don't need to define what H doesn't do, you need to define what H
>> actually does.
>>
>> Since the question it is answering doesn't exactly match in values as
>> the actual Halting Problem, your machine is NOT a "Halt Decider". PERIOD.
>>
>
> It is a BAD_INPUT decider.
>
>> This means you are just admitting to being a LIAR when you claimed it
>> was.
>>
>>
>>> I am not quite sure of this, but, it also seemed to be agreed that the
>>> halting problem instances are really nothing more that the inability to
>>> answer an incorrect question.
>>
>> But what is wrong with the ACTUAL question? Your problem is you keep
>> looking at a different quet.
>>
>>>
>>> If H defeats Rice that would be bigger than solving the halting problem.
>>
>> Yes, but you needd to show that it actuall does. And that means you
>> need to show that you can create a property that you can SHOW is
>> ACTUALLY "Semantic" (per the full definition, not the ones converted
>> into layman terms) and that your decider can answer correctly for
>> EVERY possible input.
>>
>
> I have done this. Anything decision based on behavior is semantic.
>
>>>
>>>>>
>>>>> H does reject pathological inputs as bad inputs in terms of a
>>>>> Denial of
>>>>> Service attack detector. *No one have been able to detect these
>>>>> before*
>>>>> Everyone assumed that Rice made this impossible.
>>>>
>>>> So, you admit that your Halt Decider can't answer the ACTUAL Halting
>>>> Question, and that you don't understand what Rice is about.
>>>>
>>>
>>> No one and nothing can correctly answer a contradictory question.
>>> No computer scientist every noticed this crucial {formal semantics
>>> of natural language} aspect of the halting problem or they would
>>> have never continued to construed it as any limitation of computer
>>> science.
>>
>> And what is the "Contradictory question" that is in the Halting
>> Question: "Does the Machine represeented by the Input Halt when run
>> with the given input?"
>>
>
> When the task of a halt decider is to divide finite string pairs into
> those that halt on their input when directly executed and those that do
> not then the question: "Does the input halt?" posed to H about D is a
> contradictory thus incorrect question when the full context of the
> question (including who its being asked) is included in the analysis.
>
> Simply ignoring this full context is nothing more than incorrect
> semantics. That most computer scientists don't have a clue about
> linguistic semantics does not mean that they can correctly ignore it.
>
>> Note, to ask that question, the machine being represented needs to
>> exist, which for H^/H/D means the machine you want to claim is correct
>> needs to be fully defined, thus there are no "if it did something
>> else" becauses a given machine can't do something other than what it
>> is defined to do.
>>
>>>
>>> If a baker cannot bake a perfect angel food cake using only ordinary
>>> red house bricks as the only ingredient this is zero limitation
>>> what-so-ever of their baking skills.
>>
>> So? The correct answer exists for the Halting Question for the H^/H/D
>> built from any actual machine claimed to be a correct Halting decider,
>> so the correct answer is possible. It just turns out that H never
>> gives the right answer, because it turns out that the mappign defined
>> by the question turns out not to computable.
>>
>
> The mapping turns out to derive a contradictory (thus incorrect)
> question for H even though it is not a contradictory question for H1.
>
>> Since it is well known that many mapping of input to output are not
>> computable, there is nothing particually unusual about the Halting
>> Function be non-computable. It just has massive implications on the
>> limits of Knowledge.
>>
>
> It is quite nutty to think that computations are in any way limited
> on the basis that a correct answer cannot be provided for incorrect
> questions.
>
>>>
>>>>>
>>>>> Contradictory questions are incorrect questions thus placing the blame
>>>>> for undecidability on the question and not the answerer.
>>>>
>>>> But the actual question of the Halting Problem isn't
>>>> "Contradictory", so you are just proving yourself a Liar.
>>>>
>>>
>>> Anyone knowing the formal semantics of natural language knows that
>>> ignored the full context (such as who is asked) derived incorrect
>>> semantics. I have spoken with the people on sci.lang about this
>>> for many years. They vehemently disagree with Frege's principle of
>>> compositionality because they believe that it ignore context.
>>> https://en.wikipedia.org/wiki/Principle_of_compositionality
>>
>> But many questions don't matter on who you ask. If the question
>> doesn't refer to the questioned person, it doesn't matter.
>>
>> The fact that it just happens to be about the one we ask doesn't
>> change that fact.
>>
>> Asking Jack if he has a quarter in his pocket, or asking John if Jack
>> has a quarter in his pocket both have the same answer.
>>
>
> Yes asking anyone:
> "Will your answer to this question be no?"
> Never has a correct answer from anyone that this question is posed to
> because it is a contradictory thus incorrect question for all these
> people.
>
>> A specific machine D doesn't change if we ask other Halt Deciders, so
>> the question doesn't have context on who we ask.
>>
>> Note, the question is more like does he have a quarter in his pocket
>> than will he say no to his next question, as the results that the
>> decider H will generate has a FIXED VALUE at the point of asking,
>> unlike asking about the future behavior of a volitional being.
>>
>>>
>>>>>
>>>>>>>
>>>>>>> To the best of my knowledge every single source universally
>>>>>>> agrees that
>>>>>>> this is impossible. *Try and find any source that says this is
>>>>>>> possible*
>>>>>>>
>>>>>>
>>>>>> Since your machine doesn't talk in a Turing Complete set, it may
>>>>>> well be possible.
>>>>>>
>>>>>
>>>>> You are using the wrong term. The correct term is Turing computable.
>>>>> https://en.wikipedia.org/wiki/Computable_function#
>>>>>
>>>>
>>>> No, you are.
>>>>
>>>> Turing Computable, means that you can create a Turing Machine (or a
>>>> computation in a Turing Complete equivalent) to compute the answer
>>>> for any input. Like Halting Isn't
>>>>
>>>> Turing Complete means the system can compute anything that a Turing
>>>> Machine can.
>>>
>>> Yes including counting all of the atoms in the universe and storing the
>>> full computation and all of the results.
>>> https://en.wikipedia.org/wiki/Turing_completeness
>>
>> Showing you don't understand the definition as practically applied.
>>
>
> In other words the fudge factor (that diverges for the literal truth)
> that is typically applied.
>
>>>
>>>> Your system FAILS, since you say H is an equivalent of a Turing
>>>> Machine, but we also can't create the equivalent machine to give as
>>>> an input that gives the exact same answer for every input that can
>>>> be imbedded into another machine.
>>>>
>>>> ERGO, your system fails to meet the requirements of the Halting
>>>> Problem.
>>>>
>>>>>>> New_H is also able to correctly determine the halt status of any
>>>>>>> input
>>>>>>> that has an embedded copy of New_H because this causes
>>>>>>> New_D(New_D) to
>>>>>>> have a pathological relationship with itself instead of with New_H.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>> So, where was my analysis of what happens incorrect?
>>>>>
>>>>> New_H correctly reports on the behavior of the direct execution of
>>>>> New_D(New_D). It can do this because New_D has a pathological
>>>>> relationship to itself thus preventing a pathological relationship to
>>>>> New_H.
>>>>>
>>>>>
>>>> ???
>>>>
>>>> You are just spouting non-sense. BY DEFINITION, what every halt
>>>> decider you are trying to claim is correct is the machine that "D"
>>>> needs to be built on to use in the "pathological" relationship.
>>>>
>>>
>>> When you actually fully encode such things then false assumption are
>>> easily shown to be false. That is why I am fully encoding it.
>>
>> How?
>>
>> H(D,D) return 0, saying D(D) does not Halt, but D(D) Halt, so H is wrong.
>
> H(D,D) returning 0 meaning:
> (a) The input does not halt.
> (b) The input has defined a pathological relationship to H.
> *Is correct*
>
>>>
>>> You have known that H(D,D) != H1(D,D) and have had full access to
>>> their code for a long time. You can continue to falsely claim
>>> that one of them simulates its input incorrectly yet the easily verified
>>> fact is that they both simulate exactly what their input specifies.
>>
>> And that proves that you system isn't "Turing Complete" as to be
>> complete one requirement is that we can create another copy of a given
>> machine.
>>
>
> The only textbook proof that I am aware of the specifies that the input
> is copied is the Linz proof. Sipser, Kozen and Hopcroft et al don't
> specify this.
>
>>>
>>> Its dead obvious to every very bright high school student that knows C
>>> very well that D correctly simulated by H cannot possibly reach line 07.
>>
>> And it is equally obvious that it doesn't matter,
>
> Ah great so you are implicitly telling the truth this time and not
> trying to get away with saying that the simulation is incorrect.
>
> It is also the case that H(D,D) != H1(D,D) and both simulations are
> correct. This is an easily verified that cannot be refuted.
>
> This allows any H to report on the actual behavior of any directly
> executed D(D) that has the functionality of H embedded within it.
>
> When D is defined to have a pathological relationship to itself this
> prevents D from defining a pathological relationship to anything else.
>
>> as the question isn't about the simulation done by H, especially when
>> it doesn't do a "Correct Simulation" per the definition that allows
>> using a simulation instead of the actual behavior.
>>
>
> (1) From a software engineering (termination analyzer) perspective H is
> definitely correct. In this case it does not matter at all that an input
> would stop running {in theory} when it does not stop running in
> practice. All BAD_INPUT return values are relevant in the real world.
>
> (2) The inability for a halt decider to provide a correct answer
> to a contradictory (thus incorrect) question is no actual limit
> to computation in the same way that the inability for a baker to
> bake a perfect angel food using only red house bricks for
> ingredients is no limitation of actual baking skill.
>
>> Thus, you are just showing that you are being duplicitous.
>>
>>>
>>> // The following is written in C
>>> //
>>> 01 typedef int (*ptr)(); // pointer to int function
>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>> 03
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>>
>>>> I guess you are just admitting you are doing it wrong and admitting
>>>> you don't know what you are doing.
>>>>
>>>> YOU FAIL.
>>>
>>
>

On 7/7/2023 1:25 PM, Richard Damon wrote:
> On 7/7/23 1:47 PM, olcott wrote:
>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>> On 7/6/23 11:18 PM, olcott wrote:
>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>> Because a halt decider is supposed to divide a set of finite
>>>>>>>>>> string
>>>>>>>>>> pairs of:
>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>> into those that halt on their input and those that do not and the
>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>
>>>>>>>>>> H now returns three values:
>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>> relationship to H
>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>
>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>> determines the halt
>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>
>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>
>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>> H1(D,D) which
>>>>>>>>>> correctly determines that the directly executed D(D) halts on
>>>>>>>>>> its input.
>>>>>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>>>>>> correct.
>>>>>>>>>>
>>>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>>>> determine
>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>> aspect seems
>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>
>>>>>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>>>>>
>>>>>>>>>> (b) If H says that D will not halt D could do the opposite and
>>>>>>>>>> halt.
>>>>>>>>>>
>>>>>>>>>> (c) If H says that it cannot correctly return the halt status
>>>>>>>>>> of the
>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>> return value.
>>>>>>>>>>
>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>> possible way that
>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>
>>>>>>>>> Except that now you Halt Deicder is really the computation that
>>>>>>>>> does what you describe, which we can call HD and is describe
>>>>>>>>> below:
>>>>>>>>>
>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>> answer, return it,
>>>>>>>>>
>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>
>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>> D(P) will
>>>>>>>>
>>>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>>>> knows when it cannot get an answer that is consistent with the
>>>>>>>> direct
>>>>>>>> execution of D(D).
>>>>>>>
>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>
>>>>>>
>>>>>> It is a halting decidability decider that always gets the correct
>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>> problem proofs.
>>>>>
>>>>> So what answer does it give the HD that I described?
>>>>>
>>>>>>
>>>>>> It seems to me to refute Rice's theorem and the strongest argument
>>>>>> that
>>>>>> you have presented against this is that you simply don;t believe it.
>>>>>
>>>>> Nope. You may think so, but it doesn/t
>>>>>
>>>>>>
>>>>>> Because H does determine a non trivial semantic property this by
>>>>>> itself
>>>>>> seems to refute Rice. You saying that you really don't think so is no
>>>>>> actual rebuttal at all.
>>>>>
>>>>> But Rice isn't about determining a property of YOURSELF, but of an
>>>>> arbirtray input / memebership of an input in a language.
>>>>>
>>>>>>
>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>
>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>
>>>>
>>>> It does correctly determine the presence or absence of the semantic
>>>> property of the conventional halting problem pathological relationship
>>>> for every instance of this conventional halting problem pathological
>>>> relationship.
>>>>
>>>> D can be changed in an infinite number of ways and H still recognizes
>>>> this semantic property.
>>>
>>> Ecept that you haven't actually DEFINED what the property means.
>>>
>>> Do you REALLY mean that one machine is being both the "Halt Decider"
>>> and also contary detctor?
>>>
>>
>> The best way to do this is for H to recognize the semantic property of
>> {BAD_INPUT} from a Denial of Service Attack Detector.
>> GOOD_INPUT halts.
>> BAD_INPUT either does not halt or has defined a pathological
>> relationship to H.
>>
>
> So D asks H if it is a "Bad Input" and if so, it just halts, thus it is
> not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
> Property, remember, a Semantic Property requires the execution of the
> program decribed by its input, not the "Decider" trying to decide the
> input.
>
> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H, the H
> aborts its simulation (as not actually a DOS) and doesn't run forever.
>
> You seem to have the idea that the behavior of H isn't fixed for a given
> input.
>

H(D,D) correctly and consistently returns 0 on its input indicating
that this input either fails to halt or has defined a pathological
relationship to H based on the semantic property of the behavior of D
relative to H.

>> This is a sufficient basis to create a termination analyzer that
>> consistently catches all non-termination bugs.
>
> So, is the "Termination analyzer" H, or some other machine.
>
> If it is H, then the above shows how H is wrong.
>
> If it is some other machine T, then we just need to build D on T, and if
> T says that it will Halt, (which from your logic says H will say it
> doesn't halt, then D loops forever, thus both T and H are wrong.
>
> If T says that it will never halt, it just halts, showing that T was wrong.
>>
>> Because inputs that specifically target the termination analyzer
>> are aptly construed as malevolent inputs such a termination analyzer
>> would not let any BAD_INPUT slip through undetected.
>
> But the "Bad Input" is a program that Halts, and thus NOT actually a
> malevolent input. It is only malvolent for some other system, which
> doesn't apply.
>
> Unless you want to define what you actually mean by a "malevolent"
> input, you are just shown to be wrong.
>
> This seems to be your problem, that you like to use terms that you don't
> have mean what they actually mean.
>

On 7/8/23 12:59 PM, olcott wrote:
> On 7/7/2023 1:25 PM, Richard Damon wrote:
>> On 7/7/23 1:47 PM, olcott wrote:
>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>> Because a halt decider is supposed to divide a set of finite
>>>>>>>>>>> string
>>>>>>>>>>> pairs of:
>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>> into those that halt on their input and those that do not and
>>>>>>>>>>> the
>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>
>>>>>>>>>>> H now returns three values:
>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>> relationship to H
>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>
>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>> determines the halt
>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>
>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>
>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>> correctly determines that the directly executed D(D) halts on
>>>>>>>>>>> its input.
>>>>>>>>>>> Both H and H1 work this same way so one of the pair is always
>>>>>>>>>>> correct.
>>>>>>>>>>>
>>>>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>>>>> determine
>>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>>> aspect seems
>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>
>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and loop.
>>>>>>>>>>>
>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>> and halt.
>>>>>>>>>>>
>>>>>>>>>>> (c) If H says that it cannot correctly return the halt status
>>>>>>>>>>> of the
>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>> return value.
>>>>>>>>>>>
>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>> possible way that
>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>
>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>> describe below:
>>>>>>>>>>
>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>>> answer, return it,
>>>>>>>>>>
>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>
>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>> D(P) will
>>>>>>>>>
>>>>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>>>>> knows when it cannot get an answer that is consistent with the
>>>>>>>>> direct
>>>>>>>>> execution of D(D).
>>>>>>>>
>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>
>>>>>>>
>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>> problem proofs.
>>>>>>
>>>>>> So what answer does it give the HD that I described?
>>>>>>
>>>>>>>
>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>> argument that
>>>>>>> you have presented against this is that you simply don;t believe it.
>>>>>>
>>>>>> Nope. You may think so, but it doesn/t
>>>>>>
>>>>>>>
>>>>>>> Because H does determine a non trivial semantic property this by
>>>>>>> itself
>>>>>>> seems to refute Rice. You saying that you really don't think so
>>>>>>> is no
>>>>>>> actual rebuttal at all.
>>>>>>
>>>>>> But Rice isn't about determining a property of YOURSELF, but of an
>>>>>> arbirtray input / memebership of an input in a language.
>>>>>>
>>>>>>>
>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>
>>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>>
>>>>>
>>>>> It does correctly determine the presence or absence of the semantic
>>>>> property of the conventional halting problem pathological relationship
>>>>> for every instance of this conventional halting problem pathological
>>>>> relationship.
>>>>>
>>>>> D can be changed in an infinite number of ways and H still recognizes
>>>>> this semantic property.
>>>>
>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>
>>>> Do you REALLY mean that one machine is being both the "Halt Decider"
>>>> and also contary detctor?
>>>>
>>>
>>> The best way to do this is for H to recognize the semantic property of
>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>> GOOD_INPUT halts.
>>> BAD_INPUT either does not halt or has defined a pathological
>>> relationship to H.
>>>
>>
>> So D asks H if it is a "Bad Input" and if so, it just halts, thus it
>> is not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
>> Property, remember, a Semantic Property requires the execution of the
>> program decribed by its input, not the "Decider" trying to decide the
>> input.
>>
>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H, the
>> H aborts its simulation (as not actually a DOS) and doesn't run forever.
>>
>> You seem to have the idea that the behavior of H isn't fixed for a
>> given input.
>>
>
> H(D,D) correctly and consistently returns 0 on its input indicating
> that this input either fails to halt or has defined a pathological
> relationship to H based on the semantic property of the behavior of D
> relative to H.

On 7/8/2023 12:43 PM, Richard Damon wrote:
> On 7/8/23 12:59 PM, olcott wrote:
>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>> On 7/7/23 1:47 PM, olcott wrote:
>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>> Because a halt decider is supposed to divide a set of finite
>>>>>>>>>>>> string
>>>>>>>>>>>> pairs of:
>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>> and the
>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>
>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>> relationship to H
>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>
>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>> determines the halt
>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>
>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>
>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>> on its input.
>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>> always correct.
>>>>>>>>>>>>
>>>>>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>>>>>> determine
>>>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>>>> aspect seems
>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>> loop.
>>>>>>>>>>>>
>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>> and halt.
>>>>>>>>>>>>
>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>> status of the
>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>> return value.
>>>>>>>>>>>>
>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>> possible way that
>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>
>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>> describe below:
>>>>>>>>>>>
>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>>>> answer, return it,
>>>>>>>>>>>
>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>
>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>> D(P) will
>>>>>>>>>>
>>>>>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>>>>>> knows when it cannot get an answer that is consistent with the
>>>>>>>>>> direct
>>>>>>>>>> execution of D(D).
>>>>>>>>>
>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>> problem proofs.
>>>>>>>
>>>>>>> So what answer does it give the HD that I described?
>>>>>>>
>>>>>>>>
>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>> argument that
>>>>>>>> you have presented against this is that you simply don;t believe
>>>>>>>> it.
>>>>>>>
>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>
>>>>>>>>
>>>>>>>> Because H does determine a non trivial semantic property this by
>>>>>>>> itself
>>>>>>>> seems to refute Rice. You saying that you really don't think so
>>>>>>>> is no
>>>>>>>> actual rebuttal at all.
>>>>>>>
>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>
>>>>>>>>
>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>
>>>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>>>
>>>>>>
>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>> property of the conventional halting problem pathological
>>>>>> relationship
>>>>>> for every instance of this conventional halting problem pathological
>>>>>> relationship.
>>>>>>
>>>>>> D can be changed in an infinite number of ways and H still recognizes
>>>>>> this semantic property.
>>>>>
>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>
>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>> Decider" and also contary detctor?
>>>>>
>>>>
>>>> The best way to do this is for H to recognize the semantic property of
>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>> GOOD_INPUT halts.
>>>> BAD_INPUT either does not halt or has defined a pathological
>>>> relationship to H.
>>>>
>>>
>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus it
>>> is not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
>>> Property, remember, a Semantic Property requires the execution of the
>>> program decribed by its input, not the "Decider" trying to decide the
>>> input.
>>>
>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>> forever.
>>>
>>> You seem to have the idea that the behavior of H isn't fixed for a
>>> given input.
>>>
>>
>> H(D,D) correctly and consistently returns 0 on its input indicating
>> that this input either fails to halt or has defined a pathological
>> relationship to H based on the semantic property of the behavior of D
>> relative to H.
>
> But the D you are looking at isn't designed to fool your pathological
> property, so doesn't prove anything.
>

On 7/8/23 5:35 PM, olcott wrote:
> On 7/8/2023 12:43 PM, Richard Damon wrote:
>> On 7/8/23 12:59 PM, olcott wrote:
>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>> finite string
>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>> and the
>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>
>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>>> on its input.
>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>>>>> aspect seems
>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>>> loop.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>>> and halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>> status of the
>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>
>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>> describe below:
>>>>>>>>>>>>
>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>>>>> answer, return it,
>>>>>>>>>>>>
>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>
>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>>> D(P) will
>>>>>>>>>>>
>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>> itself
>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>> the direct
>>>>>>>>>>> execution of D(D).
>>>>>>>>>>
>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>>> problem proofs.
>>>>>>>>
>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>> argument that
>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>> believe it.
>>>>>>>>
>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>> by itself
>>>>>>>>> seems to refute Rice. You saying that you really don't think so
>>>>>>>>> is no
>>>>>>>>> actual rebuttal at all.
>>>>>>>>
>>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>
>>>>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>>>>
>>>>>>>
>>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>>> property of the conventional halting problem pathological
>>>>>>> relationship
>>>>>>> for every instance of this conventional halting problem pathological
>>>>>>> relationship.
>>>>>>>
>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>> recognizes
>>>>>>> this semantic property.
>>>>>>
>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>
>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>> Decider" and also contary detctor?
>>>>>>
>>>>>
>>>>> The best way to do this is for H to recognize the semantic property of
>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>> GOOD_INPUT halts.
>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>> relationship to H.
>>>>>
>>>>
>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus it
>>>> is not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
>>>> Property, remember, a Semantic Property requires the execution of
>>>> the program decribed by its input, not the "Decider" trying to
>>>> decide the input.
>>>>
>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>>> forever.
>>>>
>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>> given input.
>>>>
>>>
>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>> that this input either fails to halt or has defined a pathological
>>> relationship to H based on the semantic property of the behavior of D
>>> relative to H.
>>
>> But the D you are looking at isn't designed to fool your pathological
>> property, so doesn't prove anything.
>>
>
> *That makes as much sense as proclaiming that all cows are birds*

On 7/8/2023 12:43 PM, Richard Damon wrote:
> On 7/8/23 12:59 PM, olcott wrote:
>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>> On 7/7/23 1:47 PM, olcott wrote:
>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>> Because a halt decider is supposed to divide a set of finite
>>>>>>>>>>>> string
>>>>>>>>>>>> pairs of:
>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>> and the
>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>
>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>> relationship to H
>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>
>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>> determines the halt
>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>
>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>
>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>> on its input.
>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>> always correct.
>>>>>>>>>>>>
>>>>>>>>>>>> The key innovation of this that that both H and H1 correctly
>>>>>>>>>>>> determine
>>>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>>>> aspect seems
>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>> loop.
>>>>>>>>>>>>
>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>> and halt.
>>>>>>>>>>>>
>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>> status of the
>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>> return value.
>>>>>>>>>>>>
>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>> possible way that
>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>
>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>> describe below:
>>>>>>>>>>>
>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>>>> answer, return it,
>>>>>>>>>>>
>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>
>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>> D(P) will
>>>>>>>>>>
>>>>>>>>>> The key innovation is creating a termination analyzer that itself
>>>>>>>>>> knows when it cannot get an answer that is consistent with the
>>>>>>>>>> direct
>>>>>>>>>> execution of D(D).
>>>>>>>>>
>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>> problem proofs.
>>>>>>>
>>>>>>> So what answer does it give the HD that I described?
>>>>>>>
>>>>>>>>
>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>> argument that
>>>>>>>> you have presented against this is that you simply don;t believe
>>>>>>>> it.
>>>>>>>
>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>
>>>>>>>>
>>>>>>>> Because H does determine a non trivial semantic property this by
>>>>>>>> itself
>>>>>>>> seems to refute Rice. You saying that you really don't think so
>>>>>>>> is no
>>>>>>>> actual rebuttal at all.
>>>>>>>
>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>
>>>>>>>>
>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>
>>>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>>>
>>>>>>
>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>> property of the conventional halting problem pathological
>>>>>> relationship
>>>>>> for every instance of this conventional halting problem pathological
>>>>>> relationship.
>>>>>>
>>>>>> D can be changed in an infinite number of ways and H still recognizes
>>>>>> this semantic property.
>>>>>
>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>
>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>> Decider" and also contary detctor?
>>>>>
>>>>
>>>> The best way to do this is for H to recognize the semantic property of
>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>> GOOD_INPUT halts.
>>>> BAD_INPUT either does not halt or has defined a pathological
>>>> relationship to H.
>>>>
>>>
>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus it
>>> is not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
>>> Property, remember, a Semantic Property requires the execution of the
>>> program decribed by its input, not the "Decider" trying to decide the
>>> input.
>>>
>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>> forever.
>>>
>>> You seem to have the idea that the behavior of H isn't fixed for a
>>> given input.
>>>
>>
>> H(D,D) correctly and consistently returns 0 on its input indicating
>> that this input either fails to halt or has defined a pathological
>> relationship to H based on the semantic property of the behavior of D
>> relative to H.
>
> But the D you are looking at isn't designed to fool your pathological
> property, so doesn't prove anything.
>
> I guess you are admitting that you have failed to create a Halt Decider,
> so now going for a theorem you understand even less.
>

On 7/8/23 6:09 PM, olcott wrote:
> On 7/8/2023 12:43 PM, Richard Damon wrote:
>> On 7/8/23 12:59 PM, olcott wrote:
>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>> finite string
>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>> and the
>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>
>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>>> on its input.
>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>> all of the cases that they cannot correctly determine. This
>>>>>>>>>>>>> aspect seems
>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>>> loop.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>>> and halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>> status of the
>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>
>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>> describe below:
>>>>>>>>>>>>
>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an difinitive
>>>>>>>>>>>> answer, return it,
>>>>>>>>>>>>
>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>
>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>>> D(P) will
>>>>>>>>>>>
>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>> itself
>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>> the direct
>>>>>>>>>>> execution of D(D).
>>>>>>>>>>
>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>>> problem proofs.
>>>>>>>>
>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>> argument that
>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>> believe it.
>>>>>>>>
>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>> by itself
>>>>>>>>> seems to refute Rice. You saying that you really don't think so
>>>>>>>>> is no
>>>>>>>>> actual rebuttal at all.
>>>>>>>>
>>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>
>>>>>>>> First, it doesn't get it right, you have only attempted a SINGLE
>>>>>>>> input, you need to show it gets it right for ALL inputs.
>>>>>>>>
>>>>>>>
>>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>>> property of the conventional halting problem pathological
>>>>>>> relationship
>>>>>>> for every instance of this conventional halting problem pathological
>>>>>>> relationship.
>>>>>>>
>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>> recognizes
>>>>>>> this semantic property.
>>>>>>
>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>
>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>> Decider" and also contary detctor?
>>>>>>
>>>>>
>>>>> The best way to do this is for H to recognize the semantic property of
>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>> GOOD_INPUT halts.
>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>> relationship to H.
>>>>>
>>>>
>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus it
>>>> is not a "Bad Input" (or your "Bad Inpt" isn't actually a Semantic
>>>> Property, remember, a Semantic Property requires the execution of
>>>> the program decribed by its input, not the "Decider" trying to
>>>> decide the input.
>>>>
>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>>> forever.
>>>>
>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>> given input.
>>>>
>>>
>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>> that this input either fails to halt or has defined a pathological
>>> relationship to H based on the semantic property of the behavior of D
>>> relative to H.
>>
>> But the D you are looking at isn't designed to fool your pathological
>> property, so doesn't prove anything.
>>
>> I guess you are admitting that you have failed to create a Halt
>> Decider, so now going for a theorem you understand even less.
>>
>
> When we define a halt decider as computing the mapping from its input
> finite string to an accept or reject state on the basis of:
>
> (a) The actual behavior actually specified by this finite string as
> measured by the correct simulation of D by H then H is a correct halt
> decider.

On 7/8/2023 5:04 PM, Richard Damon wrote:
> On 7/8/23 5:35 PM, olcott wrote:
>> On 7/8/2023 12:43 PM, Richard Damon wrote:
>>> On 7/8/23 12:59 PM, olcott wrote:
>>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>>> finite string
>>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>>> and the
>>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>>>> on its input.
>>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>>> all of the cases that they cannot correctly determine.
>>>>>>>>>>>>>> This aspect seems
>>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>>>> loop.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>>>> and halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>>> status of the
>>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>>> describe below:
>>>>>>>>>>>>>
>>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an
>>>>>>>>>>>>> difinitive answer, return it,
>>>>>>>>>>>>>
>>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>>>> D(P) will
>>>>>>>>>>>>
>>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>>> itself
>>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>>> the direct
>>>>>>>>>>>> execution of D(D).
>>>>>>>>>>>
>>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>>>> problem proofs.
>>>>>>>>>
>>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>>> argument that
>>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>>> believe it.
>>>>>>>>>
>>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>>> by itself
>>>>>>>>>> seems to refute Rice. You saying that you really don't think
>>>>>>>>>> so is no
>>>>>>>>>> actual rebuttal at all.
>>>>>>>>>
>>>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>>
>>>>>>>>> First, it doesn't get it right, you have only attempted a
>>>>>>>>> SINGLE input, you need to show it gets it right for ALL inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>>>> property of the conventional halting problem pathological
>>>>>>>> relationship
>>>>>>>> for every instance of this conventional halting problem
>>>>>>>> pathological
>>>>>>>> relationship.
>>>>>>>>
>>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>>> recognizes
>>>>>>>> this semantic property.
>>>>>>>
>>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>>
>>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>>> Decider" and also contary detctor?
>>>>>>>
>>>>>>
>>>>>> The best way to do this is for H to recognize the semantic
>>>>>> property of
>>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>>> GOOD_INPUT halts.
>>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>>> relationship to H.
>>>>>>
>>>>>
>>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus
>>>>> it is not a "Bad Input" (or your "Bad Inpt" isn't actually a
>>>>> Semantic Property, remember, a Semantic Property requires the
>>>>> execution of the program decribed by its input, not the "Decider"
>>>>> trying to decide the input.
>>>>>
>>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>>>> forever.
>>>>>
>>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>>> given input.
>>>>>
>>>>
>>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>>> that this input either fails to halt or has defined a pathological
>>>> relationship to H based on the semantic property of the behavior of D
>>>> relative to H.
>>>
>>> But the D you are looking at isn't designed to fool your pathological
>>> property, so doesn't prove anything.
>>>
>>
>> *That makes as much sense as proclaiming that all cows are birds*
>
> Shows the level of your intelect.
>
> Why would a machine designed to fool a "Halt Decider" fool a
> "Pathological Detector" (that you still need to formally define what you
> mean).
>
>>
>> // The following is written in C
>> //
>> 01 typedef int (*ptr)(); // pointer to int function
>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>> 03
>> 04 int D(ptr x)
>> 05 {
>> 06   int Halt_Status = H(x, x);
>> 07   if (Halt_Status)
>> 08     HERE: goto HERE;
>> 09   return Halt_Status;
>> 10 }
>> 11
>> 12 void main()
>> 13 {
>> 14   H(D,D);
>> 15 }
>>
>>> I guess you are admitting that you have failed to create a Halt
>>> Decider, so now going for a theorem you understand even less.
>>>
>>
>> I have defined a halt decider such that Linz:H correctly determines
>> that Linz:Ĥ applied to its own machine description would terminate.
>> This equally applies to every input that has a copy of its own
>> simulating halt decider embedded within it.
>
> But, if Linz:H says Linz:Ĥ will terminate, then Linz:Ĥ will not
> terminate, so you LIE, and your Linz:Ĥ was not built right.
>

On 7/8/23 6:36 PM, olcott wrote:
> On 7/8/2023 5:04 PM, Richard Damon wrote:
>> On 7/8/23 5:35 PM, olcott wrote:
>>> On 7/8/2023 12:43 PM, Richard Damon wrote:
>>>> On 7/8/23 12:59 PM, olcott wrote:
>>>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>>>> finite string
>>>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>>>> and the
>>>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next
>>>>>>>>>>>>>> step.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>>>> correctly determines that the directly executed D(D)
>>>>>>>>>>>>>>> halts on its input.
>>>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>>>> all of the cases that they cannot correctly determine.
>>>>>>>>>>>>>>> This aspect seems
>>>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite
>>>>>>>>>>>>>>> and loop.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (b) If H says that D will not halt D could do the
>>>>>>>>>>>>>>> opposite and halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>>>> status of the
>>>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>>>> describe below:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an
>>>>>>>>>>>>>> difinitive answer, return it,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider
>>>>>>>>>>>>>> HD, D(P) will
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>>>> itself
>>>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>>>> the direct
>>>>>>>>>>>>> execution of D(D).
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a halting decidability decider that always gets the
>>>>>>>>>>> correct
>>>>>>>>>>> answer on all of the counter-examples to the conventional
>>>>>>>>>>> halting
>>>>>>>>>>> problem proofs.
>>>>>>>>>>
>>>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>>>> argument that
>>>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>>>> believe it.
>>>>>>>>>>
>>>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>>>> by itself
>>>>>>>>>>> seems to refute Rice. You saying that you really don't think
>>>>>>>>>>> so is no
>>>>>>>>>>> actual rebuttal at all.
>>>>>>>>>>
>>>>>>>>>> But Rice isn't about determining a property of YOURSELF, but
>>>>>>>>>> of an arbirtray input / memebership of an input in a language.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a non-trivial semantic property and this seems to be
>>>>>>>>>>> both a
>>>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>>>
>>>>>>>>>> First, it doesn't get it right, you have only attempted a
>>>>>>>>>> SINGLE input, you need to show it gets it right for ALL inputs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It does correctly determine the presence or absence of the
>>>>>>>>> semantic
>>>>>>>>> property of the conventional halting problem pathological
>>>>>>>>> relationship
>>>>>>>>> for every instance of this conventional halting problem
>>>>>>>>> pathological
>>>>>>>>> relationship.
>>>>>>>>>
>>>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>>>> recognizes
>>>>>>>>> this semantic property.
>>>>>>>>
>>>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>>>
>>>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>>>> Decider" and also contary detctor?
>>>>>>>>
>>>>>>>
>>>>>>> The best way to do this is for H to recognize the semantic
>>>>>>> property of
>>>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>>>> GOOD_INPUT halts.
>>>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>>>> relationship to H.
>>>>>>>
>>>>>>
>>>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus
>>>>>> it is not a "Bad Input" (or your "Bad Inpt" isn't actually a
>>>>>> Semantic Property, remember, a Semantic Property requires the
>>>>>> execution of the program decribed by its input, not the "Decider"
>>>>>> trying to decide the input.
>>>>>>
>>>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>>>> the H aborts its simulation (as not actually a DOS) and doesn't
>>>>>> run forever.
>>>>>>
>>>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>>>> given input.
>>>>>>
>>>>>
>>>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>>>> that this input either fails to halt or has defined a pathological
>>>>> relationship to H based on the semantic property of the behavior of D
>>>>> relative to H.
>>>>
>>>> But the D you are looking at isn't designed to fool your
>>>> pathological property, so doesn't prove anything.
>>>>
>>>
>>> *That makes as much sense as proclaiming that all cows are birds*
>>
>> Shows the level of your intelect.
>>
>> Why would a machine designed to fool a "Halt Decider" fool a
>> "Pathological Detector" (that you still need to formally define what
>> you mean).
>>
>>>
>>> // The following is written in C
>>> //
>>> 01 typedef int (*ptr)(); // pointer to int function
>>> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
>>> 03
>>> 04 int D(ptr x)
>>> 05 {
>>> 06   int Halt_Status = H(x, x);
>>> 07   if (Halt_Status)
>>> 08     HERE: goto HERE;
>>> 09   return Halt_Status;
>>> 10 }
>>> 11
>>> 12 void main()
>>> 13 {
>>> 14   H(D,D);
>>> 15 }
>>>
>>>> I guess you are admitting that you have failed to create a Halt
>>>> Decider, so now going for a theorem you understand even less.
>>>>
>>>
>>> I have defined a halt decider such that Linz:H correctly determines
>>> that Linz:Ĥ applied to its own machine description would terminate.
>>> This equally applies to every input that has a copy of its own
>>> simulating halt decider embedded within it.
>>
>> But, if Linz:H says Linz:Ĥ will terminate, then Linz:Ĥ will not
>> terminate, so you LIE, and your Linz:Ĥ was not built right.
>>
>
> Because Linz:Ĥ is defined to have a pathological relationship to itself
> it cannot possibly define a pathological relationship to an external
> Linz:H.
>
>>>
>>>> Maybe if you understood what sort of properties that Rice was
>>>> talking about, and tried to define your "Semantic Property" in the
>>>> proper terms (and not just based on what the "common press"
>>>> describes it as) you would understand why you are wrong.
>>>>
>>>> You are just parading your ignorance of the topic.
>>>>
>>>
>>> If you understood it any better than I do then you could point out a
>>> specific mistake and thus not need to rely on ad hominem as your only
>>> basis.
>>
>> Since you refuse to actually DEFINE what you mean by "Pathological
>> Behvior", I might be able to.
>>
>
> Everyone slightly familiar with the HP knows exactly what this is
> that you pretend to not know is really lame.
>
>> Note, the input needs to be able to be a "Turing Complete" set of
>> programs, and that means that it can use a seperate copy of your
>> decider, so your "address match" trick doesn't work.
>>
>>>
>>>>>
>>>>>>> This is a sufficient basis to create a termination analyzer that
>>>>>>> consistently catches all non-termination bugs.
>>>>>>
>>>>>> So, is the "Termination analyzer" H, or some other machine.
>>>>>>
>>>>>> If it is H, then the above shows how H is wrong.
>>>>>>
>>>>>> If it is some other machine T, then we just need to build D on T,
>>>>>> and if T says that it will Halt, (which from your logic says H
>>>>>> will say it doesn't halt, then D loops forever, thus both T and H
>>>>>> are wrong.
>>>>>>
>>>>>> If T says that it will never halt, it just halts, showing that T
>>>>>> was wrong.
>>>>>>>
>>>>>>> Because inputs that specifically target the termination analyzer
>>>>>>> are aptly construed as malevolent inputs such a termination analyzer
>>>>>>> would not let any BAD_INPUT slip through undetected.
>>>>>>
>>>>>> But the "Bad Input" is a program that Halts, and thus NOT actually
>>>>>> a malevolent input. It is only malvolent for some other system,
>>>>>> which doesn't apply.
>>>>>>
>>>>>> Unless you want to define what you actually mean by a "malevolent"
>>>>>> input, you are just shown to be wrong.
>>>>>>
>>>>>> This seems to be your problem, that you like to use terms that you
>>>>>> don't have mean what they actually mean.
>>>>>>
>>>>>
>>>>>  From a Denial of Service Attack (DoSA) detector's perspective an
>>>>> input that either fails to halt or tries to circumvent this DoSA
>>>>> detector is a malevolent input that must be rejected.
>>>>>
>>>>
>>>> So, you are admitting that you DoSA attack definition isn't actually
>>>> a Halt Decider, so you are just plain lying when you claim your H
>>>> which might meet your DoSA requirement is an actual Halt Decider per
>>>> Computation Theory,
>>>>
>>>
>>> Better than solving halting it refutes Rice and you can't show otherwise
>>> because you don't know Rice well enough to find any specific mistake in
>>> what I am saying. Your entire basis is simply the presumption that I
>>> must be wrong.
>>>
>>
>> Since you can't define your property, you haven't done that. I don't
>> need to refute what you don't say,
>>
>> Note, to Refute Rice, you need to show that your decider can handle
>> ALL inputs, not just one that wasn't even designed to defeat your
>> decider for the property it is now deciding.
>>
>
> To refute Rice it only needs to divide inputs into two sets:
> Those having the conventional pathological relationship and
> those that do not.
>
> My current code recognizes and reports all encodings of this
> relationship. This makes L a recursively enumerable language.
>

On 7/8/2023 5:25 PM, Richard Damon wrote:
> On 7/8/23 6:09 PM, olcott wrote:
>> On 7/8/2023 12:43 PM, Richard Damon wrote:
>>> On 7/8/23 12:59 PM, olcott wrote:
>>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>>> finite string
>>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>>> and the
>>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next step.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>>> correctly determines that the directly executed D(D) halts
>>>>>>>>>>>>>> on its input.
>>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>>> all of the cases that they cannot correctly determine.
>>>>>>>>>>>>>> This aspect seems
>>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite and
>>>>>>>>>>>>>> loop.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (b) If H says that D will not halt D could do the opposite
>>>>>>>>>>>>>> and halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>>> status of the
>>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>>> describe below:
>>>>>>>>>>>>>
>>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an
>>>>>>>>>>>>> difinitive answer, return it,
>>>>>>>>>>>>>
>>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider HD,
>>>>>>>>>>>>> D(P) will
>>>>>>>>>>>>
>>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>>> itself
>>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>>> the direct
>>>>>>>>>>>> execution of D(D).
>>>>>>>>>>>
>>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a halting decidability decider that always gets the correct
>>>>>>>>>> answer on all of the counter-examples to the conventional halting
>>>>>>>>>> problem proofs.
>>>>>>>>>
>>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>>> argument that
>>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>>> believe it.
>>>>>>>>>
>>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>>> by itself
>>>>>>>>>> seems to refute Rice. You saying that you really don't think
>>>>>>>>>> so is no
>>>>>>>>>> actual rebuttal at all.
>>>>>>>>>
>>>>>>>>> But Rice isn't about determining a property of YOURSELF, but of
>>>>>>>>> an arbirtray input / memebership of an input in a language.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a non-trivial semantic property and this seems to be both a
>>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>>
>>>>>>>>> First, it doesn't get it right, you have only attempted a
>>>>>>>>> SINGLE input, you need to show it gets it right for ALL inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It does correctly determine the presence or absence of the semantic
>>>>>>>> property of the conventional halting problem pathological
>>>>>>>> relationship
>>>>>>>> for every instance of this conventional halting problem
>>>>>>>> pathological
>>>>>>>> relationship.
>>>>>>>>
>>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>>> recognizes
>>>>>>>> this semantic property.
>>>>>>>
>>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>>
>>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>>> Decider" and also contary detctor?
>>>>>>>
>>>>>>
>>>>>> The best way to do this is for H to recognize the semantic
>>>>>> property of
>>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>>> GOOD_INPUT halts.
>>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>>> relationship to H.
>>>>>>
>>>>>
>>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus
>>>>> it is not a "Bad Input" (or your "Bad Inpt" isn't actually a
>>>>> Semantic Property, remember, a Semantic Property requires the
>>>>> execution of the program decribed by its input, not the "Decider"
>>>>> trying to decide the input.
>>>>>
>>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>>> the H aborts its simulation (as not actually a DOS) and doesn't run
>>>>> forever.
>>>>>
>>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>>> given input.
>>>>>
>>>>
>>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>>> that this input either fails to halt or has defined a pathological
>>>> relationship to H based on the semantic property of the behavior of D
>>>> relative to H.
>>>
>>> But the D you are looking at isn't designed to fool your pathological
>>> property, so doesn't prove anything.
>>>
>>> I guess you are admitting that you have failed to create a Halt
>>> Decider, so now going for a theorem you understand even less.
>>>
>>
>> When we define a halt decider as computing the mapping from its input
>> finite string to an accept or reject state on the basis of:
>>
>> (a) The actual behavior actually specified by this finite string as
>> measured by the correct simulation of D by H then H is a correct halt
>> decider.
>
> Since H doesn't actually DO a correct simulation, this is an invalid
> criteria.
>

On 7/10/23 9:40 AM, olcott wrote:
> On 7/8/2023 5:25 PM, Richard Damon wrote:
>> On 7/8/23 6:09 PM, olcott wrote:
>>> On 7/8/2023 12:43 PM, Richard Damon wrote:
>>>> On 7/8/23 12:59 PM, olcott wrote:
>>>>> On 7/7/2023 1:25 PM, Richard Damon wrote:
>>>>>> On 7/7/23 1:47 PM, olcott wrote:
>>>>>>> On 7/6/2023 11:15 PM, Richard Damon wrote:
>>>>>>>> On 7/6/23 11:18 PM, olcott wrote:
>>>>>>>>> On 7/6/2023 9:40 PM, Richard Damon wrote:
>>>>>>>>>> On 7/6/23 6:57 PM, olcott wrote:
>>>>>>>>>>> On 7/5/2023 10:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 7/5/23 10:05 PM, olcott wrote:
>>>>>>>>>>>>> On 7/5/2023 6:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 7/5/23 12:41 PM, olcott wrote:
>>>>>>>>>>>>>>> Because a halt decider is supposed to divide a set of
>>>>>>>>>>>>>>> finite string
>>>>>>>>>>>>>>> pairs of:
>>>>>>>>>>>>>>> (a) Turing Machine descriptions and
>>>>>>>>>>>>>>> (b) Their finite string inputs
>>>>>>>>>>>>>>> into those that halt on their input and those that do not
>>>>>>>>>>>>>>> and the
>>>>>>>>>>>>>>> original H(D,D) does not do that I have revised my work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H now returns three values:
>>>>>>>>>>>>>>> 0 == Input has the conventional HP proof pathological
>>>>>>>>>>>>>>> relationship to H
>>>>>>>>>>>>>>> 1 == Input halts on its input
>>>>>>>>>>>>>>> 2 == Input does not halt on its input
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you are admitting that it its a Halt Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A pair of partial halt deciders (H and H1) correctly
>>>>>>>>>>>>>>> determines the halt
>>>>>>>>>>>>>>> status of all of the conventional pathological inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you don't have a Halt Decider yet, you need your next
>>>>>>>>>>>>>> step.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When H(D,D) returns 0 the human user merely needs to run
>>>>>>>>>>>>>>> H1(D,D) which
>>>>>>>>>>>>>>> correctly determines that the directly executed D(D)
>>>>>>>>>>>>>>> halts on its input.
>>>>>>>>>>>>>>> Both H and H1 work this same way so one of the pair is
>>>>>>>>>>>>>>> always correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key innovation of this that that both H and H1
>>>>>>>>>>>>>>> correctly determine
>>>>>>>>>>>>>>> all of the cases that they cannot correctly determine.
>>>>>>>>>>>>>>> This aspect seems
>>>>>>>>>>>>>>> to refute Rice's theorem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) If H says that D will halt D could do the opposite
>>>>>>>>>>>>>>> and loop.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (b) If H says that D will not halt D could do the
>>>>>>>>>>>>>>> opposite and halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (c) If H says that it cannot correctly return the halt
>>>>>>>>>>>>>>> status of the
>>>>>>>>>>>>>>> directly executed D(D) then D cannot possibly thwart this
>>>>>>>>>>>>>>> return value.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H determines that D is undecidable by H there is no
>>>>>>>>>>>>>>> possible way that
>>>>>>>>>>>>>>> D can do the opposite and make itself decidable by H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except that now you Halt Deicder is really the computation
>>>>>>>>>>>>>> that does what you describe, which we can call HD and is
>>>>>>>>>>>>>> describe below:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> HD(P, m) first calls H(P, m) and if that gives an
>>>>>>>>>>>>>> difinitive answer, return it,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> else it calls H1(P, m) and returns that answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, now D needs to be built on your ACTUAL Halt Decider
>>>>>>>>>>>>>> HD, D(P) will
>>>>>>>>>>>>>
>>>>>>>>>>>>> The key innovation is creating a termination analyzer that
>>>>>>>>>>>>> itself
>>>>>>>>>>>>> knows when it cannot get an answer that is consistent with
>>>>>>>>>>>>> the direct
>>>>>>>>>>>>> execution of D(D).
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, because then it isn't the actual Halt Decider, but the
>>>>>>>>>>>> algorithm that selects the proper halt decider is.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a halting decidability decider that always gets the
>>>>>>>>>>> correct
>>>>>>>>>>> answer on all of the counter-examples to the conventional
>>>>>>>>>>> halting
>>>>>>>>>>> problem proofs.
>>>>>>>>>>
>>>>>>>>>> So what answer does it give the HD that I described?
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It seems to me to refute Rice's theorem and the strongest
>>>>>>>>>>> argument that
>>>>>>>>>>> you have presented against this is that you simply don;t
>>>>>>>>>>> believe it.
>>>>>>>>>>
>>>>>>>>>> Nope. You may think so, but it doesn/t
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because H does determine a non trivial semantic property this
>>>>>>>>>>> by itself
>>>>>>>>>>> seems to refute Rice. You saying that you really don't think
>>>>>>>>>>> so is no
>>>>>>>>>>> actual rebuttal at all.
>>>>>>>>>>
>>>>>>>>>> But Rice isn't about determining a property of YOURSELF, but
>>>>>>>>>> of an arbirtray input / memebership of an input in a language.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is a non-trivial semantic property and this seems to be
>>>>>>>>>>> both a
>>>>>>>>>>> necessary and sufficient condition for refuting Rice.
>>>>>>>>>>
>>>>>>>>>> First, it doesn't get it right, you have only attempted a
>>>>>>>>>> SINGLE input, you need to show it gets it right for ALL inputs.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It does correctly determine the presence or absence of the
>>>>>>>>> semantic
>>>>>>>>> property of the conventional halting problem pathological
>>>>>>>>> relationship
>>>>>>>>> for every instance of this conventional halting problem
>>>>>>>>> pathological
>>>>>>>>> relationship.
>>>>>>>>>
>>>>>>>>> D can be changed in an infinite number of ways and H still
>>>>>>>>> recognizes
>>>>>>>>> this semantic property.
>>>>>>>>
>>>>>>>> Ecept that you haven't actually DEFINED what the property means.
>>>>>>>>
>>>>>>>> Do you REALLY mean that one machine is being both the "Halt
>>>>>>>> Decider" and also contary detctor?
>>>>>>>>
>>>>>>>
>>>>>>> The best way to do this is for H to recognize the semantic
>>>>>>> property of
>>>>>>> {BAD_INPUT} from a Denial of Service Attack Detector.
>>>>>>> GOOD_INPUT halts.
>>>>>>> BAD_INPUT either does not halt or has defined a pathological
>>>>>>> relationship to H.
>>>>>>>
>>>>>>
>>>>>> So D asks H if it is a "Bad Input" and if so, it just halts, thus
>>>>>> it is not a "Bad Input" (or your "Bad Inpt" isn't actually a
>>>>>> Semantic Property, remember, a Semantic Property requires the
>>>>>> execution of the program decribed by its input, not the "Decider"
>>>>>> trying to decide the input.
>>>>>>
>>>>>> Thus, D isn't ACTUALLY a "Bad Input", since for that particular H,
>>>>>> the H aborts its simulation (as not actually a DOS) and doesn't
>>>>>> run forever.
>>>>>>
>>>>>> You seem to have the idea that the behavior of H isn't fixed for a
>>>>>> given input.
>>>>>>
>>>>>
>>>>> H(D,D) correctly and consistently returns 0 on its input indicating
>>>>> that this input either fails to halt or has defined a pathological
>>>>> relationship to H based on the semantic property of the behavior of D
>>>>> relative to H.
>>>>
>>>> But the D you are looking at isn't designed to fool your
>>>> pathological property, so doesn't prove anything.
>>>>
>>>> I guess you are admitting that you have failed to create a Halt
>>>> Decider, so now going for a theorem you understand even less.
>>>>
>>>
>>> When we define a halt decider as computing the mapping from its input
>>> finite string to an accept or reject state on the basis of:
>>>
>>> (a) The actual behavior actually specified by this finite string as
>>> measured by the correct simulation of D by H then H is a correct halt
>>> decider.
>>
>> Since H doesn't actually DO a correct simulation, this is an invalid
>> criteria.
>>
>
> Since H does correctly simulate the machine language that it was
> presented with and it is an easily verified fact that statement that H
> does not do a correct simulation is counter-factual.