A single H can consistently correctly determine whether or not its input
is pathological relative to itself. When H(D,D) is invoked in
decidability decider mode determines that D is pathological relative to
itself this enables a batch file to invoke H1(D,D) to get the actual
behavior of the directly executed D(D). H1 is identical to H except for
the pathological relationship to H.

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

Child molester, Peter Olcott wrote:
> A single H can consistently correctly determine whether or not its input
> is pathological relative to itself. When H(D,D) is invoked in
> decidability decider mode determines that D is pathological relative to
> itself this enables a batch file to invoke H1(D,D) to get the actual
> behavior of the directly executed D(D). H1 is identical to H except for
> the pathological relationship to H.
>

No. It can't.

On 7/2/23 8:45 PM, olcott wrote:
> A single H can consistently correctly determine whether or not its input
> is pathological relative to itself. When H(D,D) is invoked in
> decidability decider mode determines that D is pathological relative to
> itself this enables a batch file to invoke H1(D,D) to get the actual
> behavior of the directly executed D(D). H1 is identical to H except for
> the pathological relationship to H.
>

Only if its input isn't a Turing Complete environment. TO be Turing
Complete, teh environment needs to allow the machine being decided on
have its own (private) copy of the Halt Decider, at which point your
algorith for H can't tell when the input has called that copy.

Note, the representation of the copy that it is using doesn't need to
match that of the decider deciding on it to be an equivalent copy, so H
can't just use a simple sub-string compare to detect it.

You have just shown yourself too ignorant of what you are actually
talking about to understand this, so I am expecting some stupid response.

On 7/2/23 8:45 PM, olcott wrote:
> A single H can consistently correctly determine whether or not its input
> is pathological relative to itself. When H(D,D) is invoked in
> decidability decider mode determines that D is pathological relative to
> itself this enables a batch file to invoke H1(D,D) to get the actual
> behavior of the directly executed D(D). H1 is identical to H except for
> the pathological relationship to H.
>

And does an input D that uses this FULL algorithm give your algorithm
problems?

Since H(D,D) will (apparently) determine that the input is pathological,
and thus defer to H1(D,D), then when we actually run D, appearently it
will get that same answer from H1 and do the opposite of it, and thus H1
will be wrong.

Remember, the "Pathological" program is built on a copy of the ACTUAL
program that you ask to decide on it, including ALL of its "tricks",
including things like this "batch processing".

You seem to be assuming that there is some "Operationg System" outside
the Decider - Input structure, but there isn't, at least not one that
can affect the answer of the problem.

On 7/2/2023 8:40 PM, Richard Damon wrote:
> On 7/2/23 8:45 PM, olcott wrote:
>> A single H can consistently correctly determine whether or not its input
>> is pathological relative to itself. When H(D,D) is invoked in
>> decidability decider mode determines that D is pathological relative to
>> itself this enables a batch file to invoke H1(D,D) to get the actual
>> behavior of the directly executed D(D). H1 is identical to H except for
>> the pathological relationship to H.
>>
>
>
> And does an input D that uses this FULL algorithm give your algorithm
> problems?
>
> Since H(D,D) will (apparently) determine that the input is pathological,
> and thus defer to H1(D,D), then when we actually run D, appearently it
> will get that same answer from H1 and do the opposite of it, and thus H1
> will be wrong.
>
> Remember, the "Pathological" program is built on a copy of the ACTUAL
> program that you ask to decide on it, including ALL of its "tricks",
> including things like this "batch processing".
>
> You seem to be assuming that there is some "Operationg System" outside
> the Decider - Input structure, but there isn't, at least not one that
> can affect the answer of the problem.

I spent 12 hours a day for the last 10 days getting the copy the input
working. When H(D,D) (in decidability decider mode) detects that its
input is in the well defined set of pathological inputs it returns 0
indicating that its input is undecidable. The batch file that invoked H
then knows to invoke H1(D,D) to correctly report that D(D) halts.

This solution does seem to work correctly on every conventional proof in
every textbook.

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

Fraudster Peter Olcott wrote:
> ...
> This solution does seem to work correctly on every conventional proof in
> every textbook.

not. at. all.

On 7/2/23 10:01 PM, olcott wrote:
> On 7/2/2023 8:40 PM, Richard Damon wrote:
>> On 7/2/23 8:45 PM, olcott wrote:
>>> A single H can consistently correctly determine whether or not its input
>>> is pathological relative to itself. When H(D,D) is invoked in
>>> decidability decider mode determines that D is pathological relative to
>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>> behavior of the directly executed D(D). H1 is identical to H except for
>>> the pathological relationship to H.
>>>
>>
>>
>> And does an input D that uses this FULL algorithm give your algorithm
>> problems?
>>
>> Since H(D,D) will (apparently) determine that the input is
>> pathological, and thus defer to H1(D,D), then when we actually run D,
>> appearently it will get that same answer from H1 and do the opposite
>> of it, and thus H1 will be wrong.
>>
>> Remember, the "Pathological" program is built on a copy of the ACTUAL
>> program that you ask to decide on it, including ALL of its "tricks",
>> including things like this "batch processing".
>>
>> You seem to be assuming that there is some "Operationg System" outside
>> the Decider - Input structure, but there isn't, at least not one that
>> can affect the answer of the problem.
>
> I spent 12 hours a day for the last 10 days getting the copy the input
> working. When H(D,D) (in decidability decider mode) detects that its
> input is in the well defined set of pathological inputs it returns 0
> indicating that its input is undecidable. The batch file that invoked H
> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>
> This solution does seem to work correctly on every conventional proof in
> every textbook.
>

So, what is the definition of that "Well Definde Set"? or is this just
another of your moronic oxymorons.

Note, H can't have "Modes" that are externally controlled, as it has no
input to control that, it is just a decider that is given an input to
decide on.

If you have some "fuller" algorithm you use to decide that uses the
sub-function H to do a step, then D needs to be built on that fuller
algorithm, as THAT is what you are actually claiming to be your halt
decider.

I guess you are just making it painfully obvious that you don't
understand the nature of the problem you claim to be working on.

So, since it seems that you have some sort of "batch file" that is your
actual decider, you need to show how you have a program invoke that and
do tha tin D. If you can't, you are just admitting that you are not
working on the actual problem defined, but are playing games in the
sub-Turing Complete versions of the problem, which has many known solutions.

It seems that you just wasted 120 hours of work and just proved that you
are totally ignorant of the problem and don't know what you are talking
aobut.

On 7/2/23 10:01 PM, olcott wrote:
> On 7/2/2023 8:40 PM, Richard Damon wrote:
>> On 7/2/23 8:45 PM, olcott wrote:
>>> A single H can consistently correctly determine whether or not its input
>>> is pathological relative to itself. When H(D,D) is invoked in
>>> decidability decider mode determines that D is pathological relative to
>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>> behavior of the directly executed D(D). H1 is identical to H except for
>>> the pathological relationship to H.
>>>
>>
>>
>> And does an input D that uses this FULL algorithm give your algorithm
>> problems?
>>
>> Since H(D,D) will (apparently) determine that the input is
>> pathological, and thus defer to H1(D,D), then when we actually run D,
>> appearently it will get that same answer from H1 and do the opposite
>> of it, and thus H1 will be wrong.
>>
>> Remember, the "Pathological" program is built on a copy of the ACTUAL
>> program that you ask to decide on it, including ALL of its "tricks",
>> including things like this "batch processing".
>>
>> You seem to be assuming that there is some "Operationg System" outside
>> the Decider - Input structure, but there isn't, at least not one that
>> can affect the answer of the problem.
>
> I spent 12 hours a day for the last 10 days getting the copy the input
> working. When H(D,D) (in decidability decider mode) detects that its
> input is in the well defined set of pathological inputs it returns 0
> indicating that its input is undecidable. The batch file that invoked H
> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>
> This solution does seem to work correctly on every conventional proof in
> every textbook.
>

So, did you make your "conventional proof" template actually use a copy
of your ACTUAL decider (which seems to be your "batch file" not the C
funciton H), or are you just admitting that you wasted 120 hours looking
at the wrong thing because you have made yourself intentionally ignorant
of the subject so you don't understand what you are trying to do.

On 7/2/2023 9:41 PM, Richard Damon wrote:
> On 7/2/23 10:01 PM, olcott wrote:
>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>> On 7/2/23 8:45 PM, olcott wrote:
>>>> A single H can consistently correctly determine whether or not its
>>>> input
>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>> decidability decider mode determines that D is pathological relative to
>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>> behavior of the directly executed D(D). H1 is identical to H except for
>>>> the pathological relationship to H.
>>>>
>>>
>>>
>>> And does an input D that uses this FULL algorithm give your algorithm
>>> problems?
>>>
>>> Since H(D,D) will (apparently) determine that the input is
>>> pathological, and thus defer to H1(D,D), then when we actually run D,
>>> appearently it will get that same answer from H1 and do the opposite
>>> of it, and thus H1 will be wrong.
>>>
>>> Remember, the "Pathological" program is built on a copy of the ACTUAL
>>> program that you ask to decide on it, including ALL of its "tricks",
>>> including things like this "batch processing".
>>>
>>> You seem to be assuming that there is some "Operationg System"
>>> outside the Decider - Input structure, but there isn't, at least not
>>> one that can affect the answer of the problem.
>>
>> I spent 12 hours a day for the last 10 days getting the copy the input
>> working. When H(D,D) (in decidability decider mode) detects that its
>> input is in the well defined set of pathological inputs it returns 0
>> indicating that its input is undecidable. The batch file that invoked H
>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>
>> This solution does seem to work correctly on every conventional proof in
>> every textbook.
>>
>
> So, did you make your "conventional proof" template actually use a copy
> of your ACTUAL decider (which seems to be your "batch file" not the C
> funciton H), or are you just admitting that you wasted 120 hours looking
> at the wrong thing because you have made yourself intentionally ignorant
> of the subject so you don't understand what you are trying to do.

New_D copies its input and simulates its input with its input.
It never sees 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/2/2023 9:37 PM, Richard Damon wrote:
> On 7/2/23 10:01 PM, olcott wrote:
>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>> On 7/2/23 8:45 PM, olcott wrote:
>>>> A single H can consistently correctly determine whether or not its
>>>> input
>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>> decidability decider mode determines that D is pathological relative to
>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>> behavior of the directly executed D(D). H1 is identical to H except for
>>>> the pathological relationship to H.
>>>>
>>>
>>>
>>> And does an input D that uses this FULL algorithm give your algorithm
>>> problems?
>>>
>>> Since H(D,D) will (apparently) determine that the input is
>>> pathological, and thus defer to H1(D,D), then when we actually run D,
>>> appearently it will get that same answer from H1 and do the opposite
>>> of it, and thus H1 will be wrong.
>>>
>>> Remember, the "Pathological" program is built on a copy of the ACTUAL
>>> program that you ask to decide on it, including ALL of its "tricks",
>>> including things like this "batch processing".
>>>
>>> You seem to be assuming that there is some "Operationg System"
>>> outside the Decider - Input structure, but there isn't, at least not
>>> one that can affect the answer of the problem.
>>
>> I spent 12 hours a day for the last 10 days getting the copy the input
>> working. When H(D,D) (in decidability decider mode) detects that its
>> input is in the well defined set of pathological inputs it returns 0
>> indicating that its input is undecidable. The batch file that invoked H
>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>
>> This solution does seem to work correctly on every conventional proof in
>> every textbook.
>>
>
> So, what is the definition of that "Well Definde Set"? or is this just
> another of your moronic oxymorons.
>

A set is a well-defined collection of objects called elements or members
of the set. If x is a member of the set S, we write x ∈ S, and if x is a
not member of the set S, we write x ∈ S Here, well-defined means that
any given object must either be an element of the set, or not be an
element of the set.
https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf

My definition of well-defined set is that it includes and excludes a
body of finite string pairs such that the second element of this pair
that can be encoded in an infinite number of different ways that cannot
even be foreseen in advance, all of which have the property of a
pathological relationship to their decider.

Since my system requires that the behavior of the input must be
considered in making this assessment it is a semantic property.

> Note, H can't have "Modes" that are externally controlled, as it has no
> input to control that, it is just a decider that is given an input to
> decide on.
>

Technically you are correct on this when construed as computable
functions.

> If you have some "fuller" algorithm you use to decide that uses the
> sub-function H to do a step, then D needs to be built on that fuller
> algorithm, as THAT is what you are actually claiming to be your halt
> decider.
>

It is only a matter of returning 1 for non-halting and halting inputs
and returning 0 for pathological inputs, thus the actual computation is
identical except for a single bit of the return value.

We could also simply run the input where H(D,D) != H1(D,D) means
pathological input, thus accept the H1(D,D) value as correct.

> I guess you are just making it painfully obvious that you don't
> understand the nature of the problem you claim to be working on.
>

I foresaw this objection before you made it.

> So, since it seems that you have some sort of "batch file" that is your
> actual decider, you need to show how you have a program invoke that and
> do tha tin D. If you can't, you are just admitting that you are not
> working on the actual problem defined, but are playing games in the
> sub-Turing Complete versions of the problem, which has many known
> solutions.
>

Batch files and Bash scripts can take different paths depending on the
return value of their executable.

> It seems that you just wasted 120 hours of work and just proved that you
> are totally ignorant of the problem and don't know what you are talking
> aobut.

You will say that no matter how correct that I prove to be.

--
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/2/2023 10:10 PM, olcott wrote:
> On 7/2/2023 9:37 PM, Richard Damon wrote:
>> On 7/2/23 10:01 PM, olcott wrote:
>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>> A single H can consistently correctly determine whether or not its
>>>>> input
>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>> decidability decider mode determines that D is pathological
>>>>> relative to
>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>> behavior of the directly executed D(D). H1 is identical to H except
>>>>> for
>>>>> the pathological relationship to H.
>>>>>
>>>>
>>>>
>>>> And does an input D that uses this FULL algorithm give your
>>>> algorithm problems?
>>>>
>>>> Since H(D,D) will (apparently) determine that the input is
>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>> D, appearently it will get that same answer from H1 and do the
>>>> opposite of it, and thus H1 will be wrong.
>>>>
>>>> Remember, the "Pathological" program is built on a copy of the
>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>> "tricks", including things like this "batch processing".
>>>>
>>>> You seem to be assuming that there is some "Operationg System"
>>>> outside the Decider - Input structure, but there isn't, at least not
>>>> one that can affect the answer of the problem.
>>>
>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>> working. When H(D,D) (in decidability decider mode) detects that its
>>> input is in the well defined set of pathological inputs it returns 0
>>> indicating that its input is undecidable. The batch file that invoked H
>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>
>>> This solution does seem to work correctly on every conventional proof in
>>> every textbook.
>>>
>>
>> So, what is the definition of that "Well Definde Set"? or is this just
>> another of your moronic oxymorons.
>>
>
> A set is a well-defined collection of objects called elements or members
> of the set. If x is a member of the set S, we write x ∈ S, and if x is a
> not member of the set S, we write x ∈ S Here, well-defined means that
> any given object must either be an element of the set, or not be an
> element of the set.
> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>
> My definition of well-defined set is that it includes and excludes a
> body of finite string pairs such that the second element of this pair
> that can be encoded in an infinite number of different ways that cannot
> even be foreseen in advance, all of which have the property of a
> pathological relationship to their decider.
>
> Since my system requires that the behavior of the input must be
> considered in making this assessment it is a semantic property.
>
>> Note, H can't have "Modes" that are externally controlled, as it has
>> no input to control that, it is just a decider that is given an input
>> to decide on.
>>
>
> Technically you are correct on this when construed as computable
> functions.
>
>> If you have some "fuller" algorithm you use to decide that uses the
>> sub-function H to do a step, then D needs to be built on that fuller
>> algorithm, as THAT is what you are actually claiming to be your halt
>> decider.
>>
>
> It is only a matter of returning 1 for non-halting and halting inputs
> and returning 0 for pathological inputs, thus the actual computation is
> identical except for a single bit of the return value.
>
> We could also simply run the input where H(D,D) != H1(D,D) means
> pathological input, thus accept the H1(D,D) value as correct.
>

u32 H_DD = H(D,D);
u32 H1_DD = H1(D,D);
if (H_DD != H1_DD)
Output("H1(D,D) correct halt status is:", H1_DD);

H1(D,D) correct halt status is:1

>> I guess you are just making it painfully obvious that you don't
>> understand the nature of the problem you claim to be working on.
>>
>
> I foresaw this objection before you made it.
>
>> So, since it seems that you have some sort of "batch file" that is
>> your actual decider, you need to show how you have a program invoke
>> that and do tha tin D. If you can't, you are just admitting that you
>> are not working on the actual problem defined, but are playing games
>> in the sub-Turing Complete versions of the problem, which has many
>> known solutions.
>>
>
> Batch files and Bash scripts can take different paths depending on the
> return value of their executable.
>
>> It seems that you just wasted 120 hours of work and just proved that
>> you are totally ignorant of the problem and don't know what you are
>> talking aobut.
>
> You will say that no matter how correct that I prove to be.
>

--
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/2/23 11:10 PM, olcott wrote:
> On 7/2/2023 9:37 PM, Richard Damon wrote:
>> On 7/2/23 10:01 PM, olcott wrote:
>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>> A single H can consistently correctly determine whether or not its
>>>>> input
>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>> decidability decider mode determines that D is pathological
>>>>> relative to
>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>> behavior of the directly executed D(D). H1 is identical to H except
>>>>> for
>>>>> the pathological relationship to H.
>>>>>
>>>>
>>>>
>>>> And does an input D that uses this FULL algorithm give your
>>>> algorithm problems?
>>>>
>>>> Since H(D,D) will (apparently) determine that the input is
>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>> D, appearently it will get that same answer from H1 and do the
>>>> opposite of it, and thus H1 will be wrong.
>>>>
>>>> Remember, the "Pathological" program is built on a copy of the
>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>> "tricks", including things like this "batch processing".
>>>>
>>>> You seem to be assuming that there is some "Operationg System"
>>>> outside the Decider - Input structure, but there isn't, at least not
>>>> one that can affect the answer of the problem.
>>>
>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>> working. When H(D,D) (in decidability decider mode) detects that its
>>> input is in the well defined set of pathological inputs it returns 0
>>> indicating that its input is undecidable. The batch file that invoked H
>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>
>>> This solution does seem to work correctly on every conventional proof in
>>> every textbook.
>>>
>>
>> So, what is the definition of that "Well Definde Set"? or is this just
>> another of your moronic oxymorons.
>>
>
> A set is a well-defined collection of objects called elements or members
> of the set. If x is a member of the set S, we write x ∈ S, and if x is a
> not member of the set S, we write x ∈ S Here, well-defined means that
> any given object must either be an element of the set, or not be an
> element of the set.
> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>
> My definition of well-defined set is that it includes and excludes a
> body of finite string pairs such that the second element of this pair
> that can be encoded in an infinite number of different ways that cannot
> even be foreseen in advance, all of which have the property of a
> pathological relationship to their decider.

And how do you detect this? You just admitted that there are an infinite
number of them, so you can't just string compare to detect it.

>
> Since my system requires that the behavior of the input must be
> considered in making this assessment it is a semantic property.

But you still haven't described how you detect it.

>
>> Note, H can't have "Modes" that are externally controlled, as it has
>> no input to control that, it is just a decider that is given an input
>> to decide on.
>>
>
> Technically you are correct on this when construed as computable
> functions.
>

And computations are computable functions. If the function isn't
computable, by definition no program exists that computes it.

Deciders are, by definition, Computations, so again, by definition,
don't have "modes" (except as defined by an actual input).

All this shows is that you ar playing games with words, and have
deceived yourself.

If H has "Modes", it isn't the Decider, so showing that you can get the
correct answer for the D built on IT is meaningless, you need to show
you can get the correct answer for the D built on your actual decider,
not just a piece of it.

>> If you have some "fuller" algorithm you use to decide that uses the
>> sub-function H to do a step, then D needs to be built on that fuller
>> algorithm, as THAT is what you are actually claiming to be your halt
>> decider.
>>
>
> It is only a matter of returning 1 for non-halting and halting inputs
> and returning 0 for pathological inputs, thus the actual computation is
> identical except for a single bit of the return value.
>
> We could also simply run the input where H(D,D) != H1(D,D) means
> pathological input, thus accept the H1(D,D) value as correct.

You need to make clear what type of decider you are defining. If a Halt
Decider, then there is no allowed change of answer.

IF you are trying to refute Rice, then you need to clearly define the
property that you are going to use, which your above definition requires
a FIXED H/H1 to be defined, and that the property is actually Semantic.
The fact that it is defined by executing your deciders is NOT enough.

One important thing that you seem to be missing is that Rice's Theorem
is NOT about "Programs" and their behavior, but about Functions and
languages, and their ability to be recognized by a program.

You still need to show that your property is semantic, and the fact that
you can determine that value without needing to actually run the input
shows that it isn't.

>
>> I guess you are just making it painfully obvious that you don't
>> understand the nature of the problem you claim to be working on.
>>
>
> I foresaw this objection before you made it.

But didn't answer it.

>
>> So, since it seems that you have some sort of "batch file" that is
>> your actual decider, you need to show how you have a program invoke
>> that and do tha tin D. If you can't, you are just admitting that you
>> are not working on the actual problem defined, but are playing games
>> in the sub-Turing Complete versions of the problem, which has many
>> known solutions.
>>
>
> Batch files and Bash scripts can take different paths depending on the
> return value of their executable.

Right, but now the "Decider" is a "Batch Script" so the program D must
be able to do the equivalent of that batch script, or you system doesn't
acccept a Turing Complete set.

>
>> It seems that you just wasted 120 hours of work and just proved that
>> you are totally ignorant of the problem and don't know what you are
>> talking aobut.
>
> You will say that no matter how correct that I prove to be.
>

Only when I show you are wrong. Actually try to answer my objections

On 7/2/23 11:54 PM, olcott wrote:
> On 7/2/2023 10:10 PM, olcott wrote:
>> On 7/2/2023 9:37 PM, Richard Damon wrote:
>>> On 7/2/23 10:01 PM, olcott wrote:
>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>> A single H can consistently correctly determine whether or not its
>>>>>> input
>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>> decidability decider mode determines that D is pathological
>>>>>> relative to
>>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>> except for
>>>>>> the pathological relationship to H.
>>>>>>
>>>>>
>>>>>
>>>>> And does an input D that uses this FULL algorithm give your
>>>>> algorithm problems?
>>>>>
>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>>> D, appearently it will get that same answer from H1 and do the
>>>>> opposite of it, and thus H1 will be wrong.
>>>>>
>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>> "tricks", including things like this "batch processing".
>>>>>
>>>>> You seem to be assuming that there is some "Operationg System"
>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>> not one that can affect the answer of the problem.
>>>>
>>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>> input is in the well defined set of pathological inputs it returns 0
>>>> indicating that its input is undecidable. The batch file that invoked H
>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>
>>>> This solution does seem to work correctly on every conventional
>>>> proof in
>>>> every textbook.
>>>>
>>>
>>> So, what is the definition of that "Well Definde Set"? or is this
>>> just another of your moronic oxymorons.
>>>
>>
>> A set is a well-defined collection of objects called elements or
>> members of the set. If x is a member of the set S, we write x ∈ S, and
>> if x is a not member of the set S, we write x ∈ S Here, well-defined
>> means that any given object must either be an element of the set, or
>> not be an element of the set.
>> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>>
>> My definition of well-defined set is that it includes and excludes a
>> body of finite string pairs such that the second element of this pair
>> that can be encoded in an infinite number of different ways that cannot
>> even be foreseen in advance, all of which have the property of a
>> pathological relationship to their decider.
>>
>> Since my system requires that the behavior of the input must be
>> considered in making this assessment it is a semantic property.
>>
>>> Note, H can't have "Modes" that are externally controlled, as it has
>>> no input to control that, it is just a decider that is given an input
>>> to decide on.
>>>
>>
>> Technically you are correct on this when construed as computable
>> functions.
>>
>>> If you have some "fuller" algorithm you use to decide that uses the
>>> sub-function H to do a step, then D needs to be built on that fuller
>>> algorithm, as THAT is what you are actually claiming to be your halt
>>> decider.
>>>
>>
>> It is only a matter of returning 1 for non-halting and halting inputs
>> and returning 0 for pathological inputs, thus the actual computation is
>> identical except for a single bit of the return value.
>>
>> We could also simply run the input where H(D,D) != H1(D,D) means
>> pathological input, thus accept the H1(D,D) value as correct.
>>
>
>   u32 H_DD  = H(D,D);
>   u32 H1_DD = H1(D,D);
>   if (H_DD != H1_DD)
>     Output("H1(D,D) correct halt status is:", H1_DD);
>
> H1(D,D) correct halt status is:1

So, what returns the actual results of the Halt decision?

Remember, THAT is what D will call, not H or H1, since neither, by
themselves, is a halt decider.

That seems to mean that your ACTUAL Halt Decider HD(P, m) would be
something like:

HD(P, m) {
u32 H_DD = H(P, m);
u32 H1_DD = H1(P, m);
return (H_DD == H1_DD) ? H_DD : H1_DD;
}

and

D is defined something like:
D(P) {
if(HD(P,P)) {
while(1) ;
}
}

Which still gives the wrong answer.

You seem to be forgetting what a Halt Decider needs to be.

On 7/2/23 10:48 PM, olcott wrote:
> On 7/2/2023 9:41 PM, Richard Damon wrote:
>> On 7/2/23 10:01 PM, olcott wrote:
>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>> A single H can consistently correctly determine whether or not its
>>>>> input
>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>> decidability decider mode determines that D is pathological
>>>>> relative to
>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>> behavior of the directly executed D(D). H1 is identical to H except
>>>>> for
>>>>> the pathological relationship to H.
>>>>>
>>>>
>>>>
>>>> And does an input D that uses this FULL algorithm give your
>>>> algorithm problems?
>>>>
>>>> Since H(D,D) will (apparently) determine that the input is
>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>> D, appearently it will get that same answer from H1 and do the
>>>> opposite of it, and thus H1 will be wrong.
>>>>
>>>> Remember, the "Pathological" program is built on a copy of the
>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>> "tricks", including things like this "batch processing".
>>>>
>>>> You seem to be assuming that there is some "Operationg System"
>>>> outside the Decider - Input structure, but there isn't, at least not
>>>> one that can affect the answer of the problem.
>>>
>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>> working. When H(D,D) (in decidability decider mode) detects that its
>>> input is in the well defined set of pathological inputs it returns 0
>>> indicating that its input is undecidable. The batch file that invoked H
>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>
>>> This solution does seem to work correctly on every conventional proof in
>>> every textbook.
>>>
>>
>> So, did you make your "conventional proof" template actually use a
>> copy of your ACTUAL decider (which seems to be your "batch file" not
>> the C funciton H), or are you just admitting that you wasted 120 hours
>> looking at the wrong thing because you have made yourself
>> intentionally ignorant of the subject so you don't understand what you
>> are trying to do.
>
> New_D copies its input and simulates its input with its input.
> It never sees New_H.
>

Why not? Since New_H is the thing that is considered the "Correct Halt
Decider", New_D needs to be built on it.

You keep on forgetting that the proof says we create a specific input
for the given halt decider claimed to be correct, and the only halt
decider that input is claimed to not be decidable with is that one.

SHowing that New_H can answer for the input designed on H means nothing,
you need to show that it can handle the input designed for itself.

THAT is where the actual self-reference occurs, that there exists within
the set of "any program" a program built on the decider in this manner.

On 7/3/2023 8:14 AM, Richard Damon wrote:
> On 7/2/23 10:48 PM, olcott wrote:
>> On 7/2/2023 9:41 PM, Richard Damon wrote:
>>> On 7/2/23 10:01 PM, olcott wrote:
>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>> A single H can consistently correctly determine whether or not its
>>>>>> input
>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>> decidability decider mode determines that D is pathological
>>>>>> relative to
>>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>> except for
>>>>>> the pathological relationship to H.
>>>>>>
>>>>>
>>>>>
>>>>> And does an input D that uses this FULL algorithm give your
>>>>> algorithm problems?
>>>>>
>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>>> D, appearently it will get that same answer from H1 and do the
>>>>> opposite of it, and thus H1 will be wrong.
>>>>>
>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>> "tricks", including things like this "batch processing".
>>>>>
>>>>> You seem to be assuming that there is some "Operationg System"
>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>> not one that can affect the answer of the problem.
>>>>
>>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>> input is in the well defined set of pathological inputs it returns 0
>>>> indicating that its input is undecidable. The batch file that invoked H
>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>
>>>> This solution does seem to work correctly on every conventional
>>>> proof in
>>>> every textbook.
>>>>
>>>
>>> So, did you make your "conventional proof" template actually use a
>>> copy of your ACTUAL decider (which seems to be your "batch file" not
>>> the C funciton H), or are you just admitting that you wasted 120
>>> hours looking at the wrong thing because you have made yourself
>>> intentionally ignorant of the subject so you don't understand what
>>> you are trying to do.
>>
>> New_D copies its input and simulates its input with its input.
>> It never sees New_H.
>>
>
> Why not? Since New_H is the thing that is considered the "Correct Halt
> Decider", New_D needs to be built on it.
>

New_H is embedded within New_D (as its middle states) just the
way it is supposed to be. The question is: Does New_H(New_H) halt?

The only difference at the source code level is:
(a) New_H copies its input, thus takes one param.
(b) New_H has an infinite loop at its accept state.

> You keep on forgetting that the proof says we create a specific input
> for the given halt decider claimed to be correct, and the only halt
> decider that input is claimed to not be decidable with is that one.
>
> SHowing that New_H can answer for the input designed on H means nothing,
> you need to show that it can handle the input designed for itself.
>
> THAT is where the actual self-reference occurs, that there exists within
> the set of "any program" a program built on the decider in this manner.

--
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/3/23 9:47 AM, olcott wrote:
> On 7/3/2023 8:14 AM, Richard Damon wrote:
>> On 7/2/23 10:48 PM, olcott wrote:
>>> On 7/2/2023 9:41 PM, Richard Damon wrote:
>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>> its input
>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>> decidability decider mode determines that D is pathological
>>>>>>> relative to
>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>> except for
>>>>>>> the pathological relationship to H.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>> algorithm problems?
>>>>>>
>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>>>> D, appearently it will get that same answer from H1 and do the
>>>>>> opposite of it, and thus H1 will be wrong.
>>>>>>
>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>>> "tricks", including things like this "batch processing".
>>>>>>
>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>> not one that can affect the answer of the problem.
>>>>>
>>>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>> indicating that its input is undecidable. The batch file that
>>>>> invoked H
>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>
>>>>> This solution does seem to work correctly on every conventional
>>>>> proof in
>>>>> every textbook.
>>>>>
>>>>
>>>> So, did you make your "conventional proof" template actually use a
>>>> copy of your ACTUAL decider (which seems to be your "batch file" not
>>>> the C funciton H), or are you just admitting that you wasted 120
>>>> hours looking at the wrong thing because you have made yourself
>>>> intentionally ignorant of the subject so you don't understand what
>>>> you are trying to do.
>>>
>>> New_D copies its input and simulates its input with its input.
>>> It never sees New_H.
>>>
>>
>> Why not? Since New_H is the thing that is considered the "Correct Halt
>> Decider", New_D needs to be built on it.
>>
>
> New_H is embedded within New_D (as its middle states) just the
> way it is supposed to be. The question is: Does New_H(New_H) halt?
>
> The only difference at the source code level is:
> (a) New_H copies its input, thus takes one param.
> (b) New_H has an infinite loop at its accept state.

So, how is New_H a halt decider then?

Or are you just being deceptive about what problem you are solving again.

If New_H is about your 'Rice' problem machine, I showed why your
property wasn't semantic, so doesn't disprove the Rice proofs.

Remember, the definition based on "executing" are based on executing the
machine described on the input, NOT on executing the decider.

After all, of course a property based on the execution decider is decidable.

You seem to be just building a great big argument out of strawmen, and
Red Herring, and forgetting the actual problem you claim to be working on.

>
>> You keep on forgetting that the proof says we create a specific input
>> for the given halt decider claimed to be correct, and the only halt
>> decider that input is claimed to not be decidable with is that one.
>>
>> SHowing that New_H can answer for the input designed on H means
>> nothing, you need to show that it can handle the input designed for
>> itself.
>>
>> THAT is where the actual self-reference occurs, that there exists
>> within the set of "any program" a program built on the decider in this
>> manner.
>

On 7/3/2023 8:13 AM, Richard Damon wrote:
> On 7/2/23 11:10 PM, olcott wrote:
>> On 7/2/2023 9:37 PM, Richard Damon wrote:
>>> On 7/2/23 10:01 PM, olcott wrote:
>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>> A single H can consistently correctly determine whether or not its
>>>>>> input
>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>> decidability decider mode determines that D is pathological
>>>>>> relative to
>>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>> except for
>>>>>> the pathological relationship to H.
>>>>>>
>>>>>
>>>>>
>>>>> And does an input D that uses this FULL algorithm give your
>>>>> algorithm problems?
>>>>>
>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>>> D, appearently it will get that same answer from H1 and do the
>>>>> opposite of it, and thus H1 will be wrong.
>>>>>
>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>> "tricks", including things like this "batch processing".
>>>>>
>>>>> You seem to be assuming that there is some "Operationg System"
>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>> not one that can affect the answer of the problem.
>>>>
>>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>> input is in the well defined set of pathological inputs it returns 0
>>>> indicating that its input is undecidable. The batch file that invoked H
>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>
>>>> This solution does seem to work correctly on every conventional
>>>> proof in
>>>> every textbook.
>>>>
>>>
>>> So, what is the definition of that "Well Definde Set"? or is this
>>> just another of your moronic oxymorons.
>>>
>>
>> A set is a well-defined collection of objects called elements or
>> members of the set. If x is a member of the set S, we write x ∈ S, and
>> if x is a not member of the set S, we write x ∈ S Here, well-defined
>> means that any given object must either be an element of the set, or
>> not be an element of the set.
>> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>>
>> My definition of well-defined set is that it includes and excludes a
>> body of finite string pairs such that the second element of this pair
>> that can be encoded in an infinite number of different ways that cannot
>> even be foreseen in advance, all of which have the property of a
>> pathological relationship to their decider.
>
> And how do you detect this? You just admitted that there are an infinite
> number of them, so you can't just string compare to detect it.
>
>>
>> Since my system requires that the behavior of the input must be
>> considered in making this assessment it is a semantic property.
>
> But you still haven't described how you detect it.
>
>
>>
>>> Note, H can't have "Modes" that are externally controlled, as it has
>>> no input to control that, it is just a decider that is given an input
>>> to decide on.
>>>
>>
>> Technically you are correct on this when construed as computable
>> functions.
>>
>
> And computations are computable functions. If the function isn't
> computable, by definition no program exists that computes it.
>
> Deciders are, by definition, Computations, so again, by definition,
> don't have "modes" (except as defined by an actual input).
>
> All this shows is that you ar playing games with words, and have
> deceived yourself.
>
> If H has "Modes", it isn't the Decider, so showing that you can get the
> correct answer for the D built on IT is meaningless, you need to show
> you can get the correct answer for the D built on your actual decider,
> not just a piece of it.
>
>>> If you have some "fuller" algorithm you use to decide that uses the
>>> sub-function H to do a step, then D needs to be built on that fuller
>>> algorithm, as THAT is what you are actually claiming to be your halt
>>> decider.
>>>
>>
>> It is only a matter of returning 1 for non-halting and halting inputs
>> and returning 0 for pathological inputs, thus the actual computation is
>> identical except for a single bit of the return value.
>>
>> We could also simply run the input where H(D,D) != H1(D,D) means
>> pathological input, thus accept the H1(D,D) value as correct.
>
> You need to make clear what type of decider you are defining. If a Halt
> Decider, then there is no allowed change of answer.
>
> IF you are trying to refute Rice, then you need to clearly define the
> property that you are going to use, which your above definition requires
> a FIXED H/H1 to be defined, and that the property is actually Semantic.
> The fact that it is defined by executing your deciders is NOT enough.
>
> One important thing that you seem to be missing is that Rice's Theorem
> is NOT about "Programs" and their behavior, but about Functions and
> languages, and their ability to be recognized by a program.
>
> You still need to show that your property is semantic, and the fact that
> you can determine that value without needing to actually run the input
> shows that it isn't.
>
>>
>>> I guess you are just making it painfully obvious that you don't
>>> understand the nature of the problem you claim to be working on.
>>>
>>
>> I foresaw this objection before you made it.
>
> But didn't answer it.
>
>>
>>> So, since it seems that you have some sort of "batch file" that is
>>> your actual decider, you need to show how you have a program invoke
>>> that and do tha tin D. If you can't, you are just admitting that you
>>> are not working on the actual problem defined, but are playing games
>>> in the sub-Turing Complete versions of the problem, which has many
>>> known solutions.
>>>
>>
>> Batch files and Bash scripts can take different paths depending on the
>> return value of their executable.
>
> Right, but now the "Decider" is a "Batch Script" so the program D must
> be able to do the equivalent of that batch script, or you system doesn't
> acccept a Turing Complete set.
>
>>
>>> It seems that you just wasted 120 hours of work and just proved that
>>> you are totally ignorant of the problem and don't know what you are
>>> talking aobut.
>>
>> You will say that no matter how correct that I prove to be.
>>
>
> Only when I show you are wrong. Actually try to answer my objections

What about a three valued decider?
0=undecidable
1=halting
2=not halting

--
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/3/2023 9:24 AM, Richard Damon wrote:
> On 7/3/23 9:47 AM, olcott wrote:
>> On 7/3/2023 8:14 AM, Richard Damon wrote:
>>> On 7/2/23 10:48 PM, olcott wrote:
>>>> On 7/2/2023 9:41 PM, Richard Damon wrote:
>>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>>> its input
>>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>>> decidability decider mode determines that D is pathological
>>>>>>>> relative to
>>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the
>>>>>>>> actual
>>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>>> except for
>>>>>>>> the pathological relationship to H.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>>> algorithm problems?
>>>>>>>
>>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>>> pathological, and thus defer to H1(D,D), then when we actually
>>>>>>> run D, appearently it will get that same answer from H1 and do
>>>>>>> the opposite of it, and thus H1 will be wrong.
>>>>>>>
>>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>>>> "tricks", including things like this "batch processing".
>>>>>>>
>>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>>> not one that can affect the answer of the problem.
>>>>>>
>>>>>> I spent 12 hours a day for the last 10 days getting the copy the
>>>>>> input
>>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>>> indicating that its input is undecidable. The batch file that
>>>>>> invoked H
>>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>>
>>>>>> This solution does seem to work correctly on every conventional
>>>>>> proof in
>>>>>> every textbook.
>>>>>>
>>>>>
>>>>> So, did you make your "conventional proof" template actually use a
>>>>> copy of your ACTUAL decider (which seems to be your "batch file"
>>>>> not the C funciton H), or are you just admitting that you wasted
>>>>> 120 hours looking at the wrong thing because you have made yourself
>>>>> intentionally ignorant of the subject so you don't understand what
>>>>> you are trying to do.
>>>>
>>>> New_D copies its input and simulates its input with its input.
>>>> It never sees New_H.
>>>>
>>>
>>> Why not? Since New_H is the thing that is considered the "Correct
>>> Halt Decider", New_D needs to be built on it.
>>>
>>
>> New_H is embedded within New_D (as its middle states) just the
>> way it is supposed to be. The question is: Does New_H(New_H) halt?
>>
>> The only difference at the source code level is:
>> (a) New_H copies its input, thus takes one param.
>> (b) New_H has an infinite loop at its accept state.
>
> So, how is New_H a halt decider then?

typo
The only difference at the source code level is:
(a) New_D copies its input, thus takes one param.
(b) New_D has an infinite loop at its accept state.
Other than that (at the source-code level) New_D is exactly 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/3/2023 8:14 AM, Richard Damon wrote:
> On 7/2/23 11:54 PM, olcott wrote:
>> On 7/2/2023 10:10 PM, olcott wrote:
>>> On 7/2/2023 9:37 PM, Richard Damon wrote:
>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>> its input
>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>> decidability decider mode determines that D is pathological
>>>>>>> relative to
>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the actual
>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>> except for
>>>>>>> the pathological relationship to H.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>> algorithm problems?
>>>>>>
>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>> pathological, and thus defer to H1(D,D), then when we actually run
>>>>>> D, appearently it will get that same answer from H1 and do the
>>>>>> opposite of it, and thus H1 will be wrong.
>>>>>>
>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>>> "tricks", including things like this "batch processing".
>>>>>>
>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>> not one that can affect the answer of the problem.
>>>>>
>>>>> I spent 12 hours a day for the last 10 days getting the copy the input
>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>> indicating that its input is undecidable. The batch file that
>>>>> invoked H
>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>
>>>>> This solution does seem to work correctly on every conventional
>>>>> proof in
>>>>> every textbook.
>>>>>
>>>>
>>>> So, what is the definition of that "Well Definde Set"? or is this
>>>> just another of your moronic oxymorons.
>>>>
>>>
>>> A set is a well-defined collection of objects called elements or
>>> members of the set. If x is a member of the set S, we write x ∈ S,
>>> and if x is a not member of the set S, we write x ∈ S Here,
>>> well-defined means that any given object must either be an element of
>>> the set, or not be an element of the set.
>>> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>>>
>>> My definition of well-defined set is that it includes and excludes a
>>> body of finite string pairs such that the second element of this pair
>>> that can be encoded in an infinite number of different ways that cannot
>>> even be foreseen in advance, all of which have the property of a
>>> pathological relationship to their decider.
>>>
>>> Since my system requires that the behavior of the input must be
>>> considered in making this assessment it is a semantic property.
>>>
>>>> Note, H can't have "Modes" that are externally controlled, as it has
>>>> no input to control that, it is just a decider that is given an
>>>> input to decide on.
>>>>
>>>
>>> Technically you are correct on this when construed as computable
>>> functions.
>>>
>>>> If you have some "fuller" algorithm you use to decide that uses the
>>>> sub-function H to do a step, then D needs to be built on that fuller
>>>> algorithm, as THAT is what you are actually claiming to be your halt
>>>> decider.
>>>>
>>>
>>> It is only a matter of returning 1 for non-halting and halting inputs
>>> and returning 0 for pathological inputs, thus the actual computation is
>>> identical except for a single bit of the return value.
>>>
>>> We could also simply run the input where H(D,D) != H1(D,D) means
>>> pathological input, thus accept the H1(D,D) value as correct.
>>>
>>
>>    u32 H_DD  = H(D,D);
>>    u32 H1_DD = H1(D,D);
>>    if (H_DD != H1_DD)
>>      Output("H1(D,D) correct halt status is:", H1_DD);
>>
>> H1(D,D) correct halt status is:1
>
> So, what returns the actual results of the Halt decision?
>
> Remember, THAT is what D will call, not H or H1, since neither, by
> themselves, is a halt decider.
>
> That seems to mean that your ACTUAL Halt Decider HD(P, m) would be
> something like:
>
> HD(P, m) {
>   u32 H_DD = H(P, m);
>   u32 H1_DD = H1(P, m);
>   return (H_DD == H1_DD) ? H_DD : H1_DD;
> }
>
> and
>
> D is defined something like:
> D(P) {
>   if(HD(P,P)) {
>     while(1) ;
>   }
> }
>
> Which still gives the wrong answer.
>
>
> You seem to be forgetting what a Halt Decider needs to be.

At the Turing machine level any D can make it impossible for a
particular H to be unable to correctly report on the behavior of the
directly executed D(D). Because D is a fixed constant finite string it
cannot dynamically reconfigure itself to fool a different 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/3/23 11:10 AM, olcott wrote:
> On 7/3/2023 8:14 AM, Richard Damon wrote:
>> On 7/2/23 11:54 PM, olcott wrote:
>>> On 7/2/2023 10:10 PM, olcott wrote:
>>>> On 7/2/2023 9:37 PM, Richard Damon wrote:
>>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>>> its input
>>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>>> decidability decider mode determines that D is pathological
>>>>>>>> relative to
>>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the
>>>>>>>> actual
>>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>>> except for
>>>>>>>> the pathological relationship to H.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>>> algorithm problems?
>>>>>>>
>>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>>> pathological, and thus defer to H1(D,D), then when we actually
>>>>>>> run D, appearently it will get that same answer from H1 and do
>>>>>>> the opposite of it, and thus H1 will be wrong.
>>>>>>>
>>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>>> ACTUAL program that you ask to decide on it, including ALL of its
>>>>>>> "tricks", including things like this "batch processing".
>>>>>>>
>>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>>> not one that can affect the answer of the problem.
>>>>>>
>>>>>> I spent 12 hours a day for the last 10 days getting the copy the
>>>>>> input
>>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>>> indicating that its input is undecidable. The batch file that
>>>>>> invoked H
>>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>>
>>>>>> This solution does seem to work correctly on every conventional
>>>>>> proof in
>>>>>> every textbook.
>>>>>>
>>>>>
>>>>> So, what is the definition of that "Well Definde Set"? or is this
>>>>> just another of your moronic oxymorons.
>>>>>
>>>>
>>>> A set is a well-defined collection of objects called elements or
>>>> members of the set. If x is a member of the set S, we write x ∈ S,
>>>> and if x is a not member of the set S, we write x ∈ S Here,
>>>> well-defined means that any given object must either be an element
>>>> of the set, or not be an element of the set.
>>>> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>>>>
>>>> My definition of well-defined set is that it includes and excludes a
>>>> body of finite string pairs such that the second element of this pair
>>>> that can be encoded in an infinite number of different ways that cannot
>>>> even be foreseen in advance, all of which have the property of a
>>>> pathological relationship to their decider.
>>>>
>>>> Since my system requires that the behavior of the input must be
>>>> considered in making this assessment it is a semantic property.
>>>>
>>>>> Note, H can't have "Modes" that are externally controlled, as it
>>>>> has no input to control that, it is just a decider that is given an
>>>>> input to decide on.
>>>>>
>>>>
>>>> Technically you are correct on this when construed as computable
>>>> functions.
>>>>
>>>>> If you have some "fuller" algorithm you use to decide that uses the
>>>>> sub-function H to do a step, then D needs to be built on that
>>>>> fuller algorithm, as THAT is what you are actually claiming to be
>>>>> your halt decider.
>>>>>
>>>>
>>>> It is only a matter of returning 1 for non-halting and halting inputs
>>>> and returning 0 for pathological inputs, thus the actual computation is
>>>> identical except for a single bit of the return value.
>>>>
>>>> We could also simply run the input where H(D,D) != H1(D,D) means
>>>> pathological input, thus accept the H1(D,D) value as correct.
>>>>
>>>
>>>    u32 H_DD  = H(D,D);
>>>    u32 H1_DD = H1(D,D);
>>>    if (H_DD != H1_DD)
>>>      Output("H1(D,D) correct halt status is:", H1_DD);
>>>
>>> H1(D,D) correct halt status is:1
>>
>> So, what returns the actual results of the Halt decision?
>>
>> Remember, THAT is what D will call, not H or H1, since neither, by
>> themselves, is a halt decider.
>>
>> That seems to mean that your ACTUAL Halt Decider HD(P, m) would be
>> something like:
>>
>> HD(P, m) {
>>    u32 H_DD = H(P, m);
>>    u32 H1_DD = H1(P, m);
>>    return (H_DD == H1_DD) ? H_DD : H1_DD;
>> }
>>
>> and
>>
>> D is defined something like:
>> D(P) {
>>    if(HD(P,P)) {
>>      while(1) ;
>>    }
>> }
>>
>> Which still gives the wrong answer.
>>
>>
>> You seem to be forgetting what a Halt Decider needs to be.
>
> At the Turing machine level any D can make it impossible for a
> particular H to be unable to correctly report on the behavior of the
> directly executed D(D). Because D is a fixed constant finite string it
> cannot dynamically reconfigure itself to fool a different H.
>
>

So, you don't understand the problem.

D doesn't even exist as an input until you define the H that you want to
claim to be correct, then you make the H^/P/D that shows that THAT H
doesn't get all inputs right.

Thus 'D' is only a 'fixed constant finite string' in the context of a
given H, and while you can give that string to a different decider, it
doesn't actualy prove anything, except that the answer the H it was
designed for is wrong.

Thus, your whole arguement is based on a category error.

On 7/3/23 10:42 AM, olcott wrote:
> On 7/3/2023 8:13 AM, Richard Damon wrote:
>> On 7/2/23 11:10 PM, olcott wrote:
>
>> Only when I show you are wrong. Actually try to answer my objections
>
>
> What about a three valued decider?
> 0=undecidable
> 1=halting
> 2=not halting
>

Doesn't meet the definition of a Halt Decider.

After all, ALL inputs to H represent a computation that either Halts or
Not, so "Undecidable" isn't a correct answer for the behavior of that
machine.

So, all you are doing is showing that you don't understand that actual
problem you claim to be solving.

On 7/3/23 10:45 AM, olcott wrote:
> On 7/3/2023 9:24 AM, Richard Damon wrote:
>> On 7/3/23 9:47 AM, olcott wrote:
>>> On 7/3/2023 8:14 AM, Richard Damon wrote:
>>>> On 7/2/23 10:48 PM, olcott wrote:
>>>>> On 7/2/2023 9:41 PM, Richard Damon wrote:
>>>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>>>> its input
>>>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>>>> decidability decider mode determines that D is pathological
>>>>>>>>> relative to
>>>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the
>>>>>>>>> actual
>>>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>>>> except for
>>>>>>>>> the pathological relationship to H.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>>>> algorithm problems?
>>>>>>>>
>>>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>>>> pathological, and thus defer to H1(D,D), then when we actually
>>>>>>>> run D, appearently it will get that same answer from H1 and do
>>>>>>>> the opposite of it, and thus H1 will be wrong.
>>>>>>>>
>>>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>>>> ACTUAL program that you ask to decide on it, including ALL of
>>>>>>>> its "tricks", including things like this "batch processing".
>>>>>>>>
>>>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>>>> not one that can affect the answer of the problem.
>>>>>>>
>>>>>>> I spent 12 hours a day for the last 10 days getting the copy the
>>>>>>> input
>>>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>>>> indicating that its input is undecidable. The batch file that
>>>>>>> invoked H
>>>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>>>
>>>>>>> This solution does seem to work correctly on every conventional
>>>>>>> proof in
>>>>>>> every textbook.
>>>>>>>
>>>>>>
>>>>>> So, did you make your "conventional proof" template actually use a
>>>>>> copy of your ACTUAL decider (which seems to be your "batch file"
>>>>>> not the C funciton H), or are you just admitting that you wasted
>>>>>> 120 hours looking at the wrong thing because you have made
>>>>>> yourself intentionally ignorant of the subject so you don't
>>>>>> understand what you are trying to do.
>>>>>
>>>>> New_D copies its input and simulates its input with its input.
>>>>> It never sees New_H.
>>>>>
>>>>
>>>> Why not? Since New_H is the thing that is considered the "Correct
>>>> Halt Decider", New_D needs to be built on it.
>>>>
>>>
>>> New_H is embedded within New_D (as its middle states) just the
>>> way it is supposed to be. The question is: Does New_H(New_H) halt?
>>>
>>> The only difference at the source code level is:
>>> (a) New_H copies its input, thus takes one param.
>>> (b) New_H has an infinite loop at its accept state.
>>
>> So, how is New_H a halt decider then?
>
> typo
> The only difference at the source code level is:
> (a) New_D copies its input, thus takes one param.
> (b) New_D has an infinite loop at its accept state.
> Other than that (at the source-code level) New_D is exactly New_H
>
>

But New_D needs to call New_H, and so at the source code level, which
includes ALL the source code of the program, it is different.

If New_D doesn't call New_H, then it is no longer a proof program for
New_H, so New_H hasn't refuted the "pathological program proof".

You just are showing you don't understand the nature of the problem you
are claiming to solve.

On 7/3/2023 10:35 AM, Richard Damon wrote:
> On 7/3/23 11:10 AM, olcott wrote:
>> On 7/3/2023 8:14 AM, Richard Damon wrote:
>>> On 7/2/23 11:54 PM, olcott wrote:
>>>> On 7/2/2023 10:10 PM, olcott wrote:
>>>>> On 7/2/2023 9:37 PM, Richard Damon wrote:
>>>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>>>> its input
>>>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>>>> decidability decider mode determines that D is pathological
>>>>>>>>> relative to
>>>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the
>>>>>>>>> actual
>>>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>>>> except for
>>>>>>>>> the pathological relationship to H.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>>>> algorithm problems?
>>>>>>>>
>>>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>>>> pathological, and thus defer to H1(D,D), then when we actually
>>>>>>>> run D, appearently it will get that same answer from H1 and do
>>>>>>>> the opposite of it, and thus H1 will be wrong.
>>>>>>>>
>>>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>>>> ACTUAL program that you ask to decide on it, including ALL of
>>>>>>>> its "tricks", including things like this "batch processing".
>>>>>>>>
>>>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>>>> outside the Decider - Input structure, but there isn't, at least
>>>>>>>> not one that can affect the answer of the problem.
>>>>>>>
>>>>>>> I spent 12 hours a day for the last 10 days getting the copy the
>>>>>>> input
>>>>>>> working. When H(D,D) (in decidability decider mode) detects that its
>>>>>>> input is in the well defined set of pathological inputs it returns 0
>>>>>>> indicating that its input is undecidable. The batch file that
>>>>>>> invoked H
>>>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>>>
>>>>>>> This solution does seem to work correctly on every conventional
>>>>>>> proof in
>>>>>>> every textbook.
>>>>>>>
>>>>>>
>>>>>> So, what is the definition of that "Well Definde Set"? or is this
>>>>>> just another of your moronic oxymorons.
>>>>>>
>>>>>
>>>>> A set is a well-defined collection of objects called elements or
>>>>> members of the set. If x is a member of the set S, we write x ∈ S,
>>>>> and if x is a not member of the set S, we write x ∈ S Here,
>>>>> well-defined means that any given object must either be an element
>>>>> of the set, or not be an element of the set.
>>>>> https://www.math.uvic.ca/faculty/gmacgill/guide/sets.pdf
>>>>>
>>>>> My definition of well-defined set is that it includes and excludes a
>>>>> body of finite string pairs such that the second element of this pair
>>>>> that can be encoded in an infinite number of different ways that
>>>>> cannot
>>>>> even be foreseen in advance, all of which have the property of a
>>>>> pathological relationship to their decider.
>>>>>
>>>>> Since my system requires that the behavior of the input must be
>>>>> considered in making this assessment it is a semantic property.
>>>>>
>>>>>> Note, H can't have "Modes" that are externally controlled, as it
>>>>>> has no input to control that, it is just a decider that is given
>>>>>> an input to decide on.
>>>>>>
>>>>>
>>>>> Technically you are correct on this when construed as computable
>>>>> functions.
>>>>>
>>>>>> If you have some "fuller" algorithm you use to decide that uses
>>>>>> the sub-function H to do a step, then D needs to be built on that
>>>>>> fuller algorithm, as THAT is what you are actually claiming to be
>>>>>> your halt decider.
>>>>>>
>>>>>
>>>>> It is only a matter of returning 1 for non-halting and halting inputs
>>>>> and returning 0 for pathological inputs, thus the actual
>>>>> computation is
>>>>> identical except for a single bit of the return value.
>>>>>
>>>>> We could also simply run the input where H(D,D) != H1(D,D) means
>>>>> pathological input, thus accept the H1(D,D) value as correct.
>>>>>
>>>>
>>>>    u32 H_DD  = H(D,D);
>>>>    u32 H1_DD = H1(D,D);
>>>>    if (H_DD != H1_DD)
>>>>      Output("H1(D,D) correct halt status is:", H1_DD);
>>>>
>>>> H1(D,D) correct halt status is:1
>>>
>>> So, what returns the actual results of the Halt decision?
>>>
>>> Remember, THAT is what D will call, not H or H1, since neither, by
>>> themselves, is a halt decider.
>>>
>>> That seems to mean that your ACTUAL Halt Decider HD(P, m) would be
>>> something like:
>>>
>>> HD(P, m) {
>>>    u32 H_DD = H(P, m);
>>>    u32 H1_DD = H1(P, m);
>>>    return (H_DD == H1_DD) ? H_DD : H1_DD;
>>> }
>>>
>>> and
>>>
>>> D is defined something like:
>>> D(P) {
>>>    if(HD(P,P)) {
>>>      while(1) ;
>>>    }
>>> }
>>>
>>> Which still gives the wrong answer.
>>>
>>>
>>> You seem to be forgetting what a Halt Decider needs to be.
>>
>> At the Turing machine level any D can make it impossible for a
>> particular H to be unable to correctly report on the behavior of the
>> directly executed D(D). Because D is a fixed constant finite string it
>> cannot dynamically reconfigure itself to fool a different H.
>>
>>
>
> So, you don't understand the problem.
>
> D doesn't even exist as an input until you define the H

So you want a TM to decide halting for an imaginary input?
That is not the way that computation actually works.

In computability theory and computational complexity theory, a decision
problem is a computational problem that can be posed as a yes–no
question of the input values.
https://en.wikipedia.org/wiki/Decision_problem

TM's do not take ideas held within the mind as their inputs, they only
take fixed constant finite strings as inputs.

--
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/3/2023 10:35 AM, Richard Damon wrote:
> On 7/3/23 10:42 AM, olcott wrote:
>> On 7/3/2023 8:13 AM, Richard Damon wrote:
>>> On 7/2/23 11:10 PM, olcott wrote:
>>
>>> Only when I show you are wrong. Actually try to answer my objections
>>
>>
>> What about a three valued decider?
>> 0=undecidable
>> 1=halting
>> 2=not halting
>>
>
> Doesn't meet the definition of a Halt Decider.
>

Because these are semantic properties based on the behavior of
the input it does refute Rice.

> After all, ALL inputs to H represent a computation that either Halts or
> Not, so "Undecidable" isn't a correct answer for the behavior of that
> machine.
>
> So, all you are doing is showing that you don't understand that actual
> problem you claim to be solving.

--
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/3/2023 10:35 AM, Richard Damon wrote:
> On 7/3/23 10:45 AM, olcott wrote:
>> On 7/3/2023 9:24 AM, Richard Damon wrote:
>>> On 7/3/23 9:47 AM, olcott wrote:
>>>> On 7/3/2023 8:14 AM, Richard Damon wrote:
>>>>> On 7/2/23 10:48 PM, olcott wrote:
>>>>>> On 7/2/2023 9:41 PM, Richard Damon wrote:
>>>>>>> On 7/2/23 10:01 PM, olcott wrote:
>>>>>>>> On 7/2/2023 8:40 PM, Richard Damon wrote:
>>>>>>>>> On 7/2/23 8:45 PM, olcott wrote:
>>>>>>>>>> A single H can consistently correctly determine whether or not
>>>>>>>>>> its input
>>>>>>>>>> is pathological relative to itself. When H(D,D) is invoked in
>>>>>>>>>> decidability decider mode determines that D is pathological
>>>>>>>>>> relative to
>>>>>>>>>> itself this enables a batch file to invoke H1(D,D) to get the
>>>>>>>>>> actual
>>>>>>>>>> behavior of the directly executed D(D). H1 is identical to H
>>>>>>>>>> except for
>>>>>>>>>> the pathological relationship to H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And does an input D that uses this FULL algorithm give your
>>>>>>>>> algorithm problems?
>>>>>>>>>
>>>>>>>>> Since H(D,D) will (apparently) determine that the input is
>>>>>>>>> pathological, and thus defer to H1(D,D), then when we actually
>>>>>>>>> run D, appearently it will get that same answer from H1 and do
>>>>>>>>> the opposite of it, and thus H1 will be wrong.
>>>>>>>>>
>>>>>>>>> Remember, the "Pathological" program is built on a copy of the
>>>>>>>>> ACTUAL program that you ask to decide on it, including ALL of
>>>>>>>>> its "tricks", including things like this "batch processing".
>>>>>>>>>
>>>>>>>>> You seem to be assuming that there is some "Operationg System"
>>>>>>>>> outside the Decider - Input structure, but there isn't, at
>>>>>>>>> least not one that can affect the answer of the problem.
>>>>>>>>
>>>>>>>> I spent 12 hours a day for the last 10 days getting the copy the
>>>>>>>> input
>>>>>>>> working. When H(D,D) (in decidability decider mode) detects that
>>>>>>>> its
>>>>>>>> input is in the well defined set of pathological inputs it
>>>>>>>> returns 0
>>>>>>>> indicating that its input is undecidable. The batch file that
>>>>>>>> invoked H
>>>>>>>> then knows to invoke H1(D,D) to correctly report that D(D) halts.
>>>>>>>>
>>>>>>>> This solution does seem to work correctly on every conventional
>>>>>>>> proof in
>>>>>>>> every textbook.
>>>>>>>>
>>>>>>>
>>>>>>> So, did you make your "conventional proof" template actually use
>>>>>>> a copy of your ACTUAL decider (which seems to be your "batch
>>>>>>> file" not the C funciton H), or are you just admitting that you
>>>>>>> wasted 120 hours looking at the wrong thing because you have made
>>>>>>> yourself intentionally ignorant of the subject so you don't
>>>>>>> understand what you are trying to do.
>>>>>>
>>>>>> New_D copies its input and simulates its input with its input.
>>>>>> It never sees New_H.
>>>>>>
>>>>>
>>>>> Why not? Since New_H is the thing that is considered the "Correct
>>>>> Halt Decider", New_D needs to be built on it.
>>>>>
>>>>
>>>> New_H is embedded within New_D (as its middle states) just the
>>>> way it is supposed to be. The question is: Does New_H(New_H) halt?
>>>>
>>>> The only difference at the source code level is:
>>>> (a) New_H copies its input, thus takes one param.
>>>> (b) New_H has an infinite loop at its accept state.
>>>
>>> So, how is New_H a halt decider then?
>>
>> typo
>> The only difference at the source code level is:
>> (a) New_D copies its input, thus takes one param.
>> (b) New_D has an infinite loop at its accept state.
>> Other than that (at the source-code level) New_D is exactly New_H
>>
>>
>
> But New_D needs to call New_H,

Not in the Peter Linz proof:
https://www.liarparadox.org/Linz_Proof.pdf

In the Linz proof a copy of H is directly embedded
within Ĥ at this state: Ĥq0 Wm Wm
The original H remains unchanged.

The halting problem is about undecidable inputs, it is not about
inserting bugs into a halt decider to make it cease to function.

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