On 3/13/2024 10:30 AM, Richard Damon wrote:
> On 3/13/24 8:09 AM, olcott wrote:
>> On 3/13/2024 10:02 AM, Richard Damon wrote:
>>> On 3/12/24 11:07 PM, olcott wrote:
>>>> On 3/13/2024 1:05 AM, Richard Damon wrote:
>>>>> On 3/12/24 11:02 PM, olcott wrote:
>>>> \
>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>
>>>>>
>>>>> Again, how do you define that?
>>>>
>>>> It rejects halting problem counter-example inputs like D.
>>>>
>>>
>>> And how do you detect that, with a Turing Machine?
>>>
>>> Remember, detection that something contains a copy of yourself is
>>> uncomputable.
>>>
>>> Your x86 system only did it by cheating and forcing D to call that
>>> same H, to allow it to compare addresses, and H had that "hidden"
>>> input of its address.
>>
>> It is not true that the address was hidden, it was always in
>> plain sight. If you can see some way to thwart H(D,D) feel
>> free to elaborate it.
>
> Where is it in H(D,D)?
>

u32 H(ptr P, ptr I)
{ u32 End_Of_Code = get_code_end((u32)H);
u32 Address_of_H = (u32)H;

> It isn't a declared input to H.
>
> If it was H(D,D, &H) then it becomes clear that H can not be a Halt
> Decider, as the inputs for a Halt Decider are just the description of
> the computation to be decide.
>
It is a termination analyzer in the x86 model of computation
that is a computable function of its inputs when we construe
it own address as one of these inputs. RASP machines might
need to be augmented to do this.

>>
>> That I have acknowledged my mistakes is sufficient reason
>> to conclude that these mistakes were never known falsehoods
>> with the intent to deceive.
>
> No, you still claim them.
>
Point out specific cases of assertions that I continue to
make that have been proven to me to be false.

Most of the "rebuttals" were always mere assertions lacking
complete supporting reasoning.

>>
>> The current focus is this:
>> Can H(D,D) always detect when its input is calling itself with
>> its same parameters such that the correctly simulated D(D) would
>> never stop running unless aborted?
>
> Which is a MEANING less criteria, as if this H does abort them, then you
> can't talk about what it would have done if it didn't, in a way that
> changes what the copy of H in the input does.
>
When H(D,D) is at a decision point there are two possible
decisions one of them results in its own termination and
the other one does not.

When we leave the abort criteria in and comment out the actual
abort we have proof that H(D,D) does make the correct choice.
Arguing against this is arguing against the verified facts.

> The "Pathological" input is pathological to a SPECIFIC ALGORITHM, that
> will always do what it does, thus, if the final H will end up aborting
> and returning 0, then the copy of H will still do that, and make H^
> Halting, even if H is trying to contemplate what happens if I don't
> abort my simulation.
>
> So, at best, H can determine that if it aborts the input will halt, and
> if it doesn't the input will loop.
>
Not quite. If it doesn't abort the simulation of its input
it will remain in recursive simulation until stack overflow.

> But if H now says, i will return Pathological, H^ can see that, and then
> act non-pathologically.
>

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is hard-coded to act pathologically.
H ⟨Ĥ⟩ ⟨Ĥ⟩ computes the mapping to H.qy, H.qn, and H.qe for error
then the current Ĥ ⟨Ĥ⟩ would seem to simply halt.

>>
>> *Hypothesis*
>> I say that if it is detectable then a machine can detect it
>> and it cannot be undetectable.
>>
>> If the above is true then this gives us two things:
>> (a) An alternative decidable criteria for the halting problem
>> (b) A way for every machine to correctly decide its own
>> undecidability on the original halting problem criteria.
>>
>>
>
>

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

On 3/13/24 9:26 AM, olcott wrote:
> On 3/13/2024 10:30 AM, Richard Damon wrote:
>> On 3/13/24 8:09 AM, olcott wrote:
>>> On 3/13/2024 10:02 AM, Richard Damon wrote:
>>>> On 3/12/24 11:07 PM, olcott wrote:
>>>>> On 3/13/2024 1:05 AM, Richard Damon wrote:
>>>>>> On 3/12/24 11:02 PM, olcott wrote:
>>>>> \
>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>
>>>>>>
>>>>>> Again, how do you define that?
>>>>>
>>>>> It rejects halting problem counter-example inputs like D.
>>>>>
>>>>
>>>> And how do you detect that, with a Turing Machine?
>>>>
>>>> Remember, detection that something contains a copy of yourself is
>>>> uncomputable.
>>>>
>>>> Your x86 system only did it by cheating and forcing D to call that
>>>> same H, to allow it to compare addresses, and H had that "hidden"
>>>> input of its address.
>>>
>>> It is not true that the address was hidden, it was always in
>>> plain sight. If you can see some way to thwart H(D,D) feel
>>> free to elaborate it.
>>
>> Where is it in H(D,D)?
>>
>
> u32 H(ptr P, ptr I)
> {
>   u32 End_Of_Code    = get_code_end((u32)H);
>   u32 Address_of_H   = (u32)H;

So, it is "HIDDEN" as in not obvious at the call site.

You just don't know the technical meaning of the terms.

Likely because you are using a zeroth principles analysis of the system.

>
>> It isn't a declared input to H.
>>
>> If it was H(D,D, &H) then it becomes clear that H can not be a Halt
>> Decider, as the inputs for a Halt Decider are just the description of
>> the computation to be decide.
>>
> It is a termination analyzer in the x86 model of computation
> that is a computable function of its inputs when we construe
> it own address as one of these inputs. RASP machines might
> need to be augmented to do this.

And thus, a LIE to call it a Halt Decider, or say it says ANYTHING about
Halt Deciders or their proofs.

>
>>>
>>> That I have acknowledged my mistakes is sufficient reason
>>> to conclude that these mistakes were never known falsehoods
>>> with the intent to deceive.
>>
>> No, you still claim them.
>>
> Point out specific cases of assertions that I continue to
> make that have been proven to me to be false.

That you are working on the Halting Theorem, when you keep on trying to
change the fundamental definition of the term.

>
> Most of the "rebuttals" were always mere assertions lacking
> complete supporting reasoning.\

Nope.

>
>>>
>>> The current focus is this:
>>> Can H(D,D) always detect when its input is calling itself with
>>> its same parameters such that the correctly simulated D(D) would
>>> never stop running unless aborted?
>>
>> Which is a MEANING less criteria, as if this H does abort them, then
>> you can't talk about what it would have done if it didn't, in a way
>> that changes what the copy of H in the input does.
>>
> When H(D,D) is at a decision point there are two possible
> decisions one of them results in its own termination and
> the other one does not.
>
> When we leave the abort criteria in and comment out the actual
> abort we have proof that H(D,D) does make the correct choice.
> Arguing against this is arguing against the verified facts.

And thus, you CHANGE H to something different.

Remember, the input to the problem you have claimed to be working on is
built on a SPECIFIC Program, the H that you finally decide has given the
right answer.

>
>> The "Pathological" input is pathological to a SPECIFIC ALGORITHM, that
>> will always do what it does, thus, if the final H will end up aborting
>> and returning 0, then the copy of H will still do that, and make H^
>> Halting, even if H is trying to contemplate what happens if I don't
>> abort my simulation.
>>
>> So, at best, H can determine that if it aborts the input will halt,
>> and if it doesn't the input will loop.
>>
> Not quite. If it doesn't abort the simulation of its input
> it will remain in recursive simulation until stack overflow.

Which point to the limited model you are using.

>
>> But if H now says, i will return Pathological, H^ can see that, and
>> then act non-pathologically.
>>
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is hard-coded to act pathologically.
> H ⟨Ĥ⟩ ⟨Ĥ⟩ computes the mapping to H.qy, H.qn, and H.qe for error
> then the current Ĥ ⟨Ĥ⟩ would seem to simply halt.

But it SHOULD be hard-coded to confound a specific H.

Behavior of H^ if H (H^) (H^) goes to H.qe will need to be figured out
for maximal antagonism.

You can't just assume what it should be based on the original problem.

>
>>>
>>> *Hypothesis*
>>> I say that if it is detectable then a machine can detect it
>>> and it cannot be undetectable.
>>>
>>> If the above is true then this gives us two things:
>>> (a) An alternative decidable criteria for the halting problem
>>> (b) A way for every machine to correctly decide its own
>>> undecidability on the original halting problem criteria.
>>>
>>>
>>
>>
>

On 13/03/24 05:14, olcott wrote:
> On 3/12/2024 11:00 PM, immibis wrote:
>>
>> Halting semi-deciders that sometimes output "I can't tell" can still
>> be very useful practical tools, however, they do not disprove the
>> halting theorem.
>>
>
> They might be building blocks that can be used to solve the
> halting problem if they cannot be circumvented.

In other words: A halting solver that sometimes outputs "I can't tell"
might solve the halting problem if it never outputs "I can't tell".

And if your mother had two wheels and handlebars, she'd be a bicycle.

On 13/03/24 05:15, olcott wrote:
> On 3/12/2024 11:00 PM, immibis wrote:
>> On 13/03/24 04:38, olcott wrote:
>>> On 3/12/2024 10:31 PM, Richard Damon wrote:
>>>> On 3/12/24 4:59 PM, olcott wrote:
>>>>> On 3/12/2024 6:38 PM, immibis wrote:
>>>>>> On 13/03/24 00:32, olcott wrote:
>>>>>>> *You keep changing the subject away from Russell's Paradox*
>>>>>>
>>>>>> Russell's paradox has nothing to do with the halting problem
>>>>>> because it is about set theory.
>>>>>
>>>>> None-the-less it was what Ross Finlayson agreed to when
>>>>> he agreed that ZFC rejected an incorrect question.
>>>>>
>>>>> On 3/12/2024 3:32 PM, olcott wrote:
>>>>>  > Ross Finlayson seems to agree that ZFC does toss out these
>>>>> incorrect
>>>>>  > questions.
>>>>>  >
>>>>>
>>>>
>>>> It only throws out "incorect questions" in Set Theory, when the
>>>> construction definition for a set is invalid.
>>>>
>>> Sure. The same idea can be expanded to more scope.
>>
>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't real Turing
>> machines, right? Just like Russell said that some {x|P(x)} aren't real
>> sets?
>>
> Nothing like that. Start with abnormal termination
> for invalid inputs.
>
Which part of ⟨Q, Γ, b, Σ, δ, q0, F⟩ specifies abnormal termination?

On 13/03/24 06:24, olcott wrote:
> If H(D,D) can always abnormally terminate on pathological
> input then it becomes a consistent undecidability decider.

void E(finite_string argument) {
H(argument, argument);
}

this input is incorrectly detected as pathological.

On 3/13/2024 10:35 AM, Richard Damon wrote:
> On 3/13/24 8:15 AM, olcott wrote:
>> On 3/13/2024 10:05 AM, Richard Damon wrote:
>>> On 3/13/24 7:14 AM, olcott wrote:
>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox
>>>>>>>>>>>>>>>>>>> set, and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't
>>>>>>>>>>>>>>> real Turing machines, right? Just like Russell said that
>>>>>>>>>>>>>>> some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that isn't
>>>>>>>>>>>>> an option for them.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make
>>>>>>>>>>>>> itself wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This might be a reasonable extension for a decider, Accept,
>>>>>>>>>>>>> Reject, and an "I can't tell". The key is to somehow limit
>>>>>>>>>>>>> where "I can't tell" can be used, or it makes the decider
>>>>>>>>>>>>> useless.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>>
>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>
>>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>>> stops the machine it is embedded in, then the operation isn't
>>>>>>>>> part of a computation, and become a "non-answer" result, and
>>>>>>>>> thus make the claim decider fail.
>>>>>>>>>
>>>>>>>> Then it returns 0,1,2
>>>>>>>
>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>
>>>>>>>>
>>>>>>>>> That is how the definitions work. If another machine can't get
>>>>>>>>> the answer by embedding you, it isn't an answer, and you are
>>>>>>>>> not a computation.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Like I say, it might be an intersting alternate problem, but
>>>>>>>>>>> it doesn't change the verdict on Halt Deciders, as it doesn't
>>>>>>>>>>> meet the requirements (which you can't change a be working on
>>>>>>>>>>> that problem)
>>>>>>>>>>
>>>>>>>>>> It might change this verdict, lets first see if it always works.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>
>>>>>>>>> That is proven.
>>>>>>>>
>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>
>>>>>>>
>>>>>>> Try to define that.
>>>>>>>
>>>>>>
>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>
>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not the
>>>>>>> specific input.
>>>>>>
>>>>>
>>>>> If you can't actually define it, you can't say you have
>>>>> successfully detected it
>>>> Whenever an input calls its decider.
>>>>
>>>
>>> But in the real system it doesn't call "it's decider", it calls a
>>> copy of the decider that it was designed to confound.
>>>
>> In a Turing machine system. If an x86 machine can do this
>> as a computable function and a TM cannot then that merely
>> refutes Church/Turing.
>
> And the key here is "as a computable function".
>
> That means NO special inputs, or hidden inputs.
>

// The input has never been hidden
u32 H(ptr P, ptr I)
{ u32 End_Of_Code = get_code_end((u32)H);
u32 Address_of_H = (u32)H;

> It also means that H needs to take in as its input, a FULL INDPENDENT
> PROGRAM, not a subprogram in its same memory space.
>

This seems to not make a difference.
The copy simply returns ERROR and halts.

> D does direcly call H, it call a copy of H that is all its own,
>
Then D.H still sees that it is calling itself with its same parameters.

On 3/13/2024 11:48 AM, immibis wrote:
> On 13/03/24 06:24, olcott wrote:
>> If H(D,D) can always abnormally terminate on pathological
>> input then it becomes a consistent undecidability decider.
>
> void E(finite_string argument) {
>     H(argument, argument);
> }
>
> this input is incorrectly detected as pathological.
>

I don't think so. H only takes the address of C functions.

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

On 3/13/24 9:57 AM, olcott wrote:
> On 3/13/2024 10:35 AM, Richard Damon wrote:
>> On 3/13/24 8:15 AM, olcott wrote:
>>> On 3/13/2024 10:05 AM, Richard Damon wrote:
>>>> On 3/13/24 7:14 AM, olcott wrote:
>>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox
>>>>>>>>>>>>>>>>>>>> set, and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set
>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't
>>>>>>>>>>>>>>>> real Turing machines, right? Just like Russell said that
>>>>>>>>>>>>>>>> some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that isn't
>>>>>>>>>>>>>> an option for them.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make
>>>>>>>>>>>>>> itself wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This might be a reasonable extension for a decider,
>>>>>>>>>>>>>> Accept, Reject, and an "I can't tell". The key is to
>>>>>>>>>>>>>> somehow limit where "I can't tell" can be used, or it
>>>>>>>>>>>>>> makes the decider useless.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>>
>>>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>>>> stops the machine it is embedded in, then the operation isn't
>>>>>>>>>> part of a computation, and become a "non-answer" result, and
>>>>>>>>>> thus make the claim decider fail.
>>>>>>>>>>
>>>>>>>>> Then it returns 0,1,2
>>>>>>>>
>>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> That is how the definitions work. If another machine can't get
>>>>>>>>>> the answer by embedding you, it isn't an answer, and you are
>>>>>>>>>> not a computation.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> Like I say, it might be an intersting alternate problem, but
>>>>>>>>>>>> it doesn't change the verdict on Halt Deciders, as it
>>>>>>>>>>>> doesn't meet the requirements (which you can't change a be
>>>>>>>>>>>> working on that problem)
>>>>>>>>>>>
>>>>>>>>>>> It might change this verdict, lets first see if it always works.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>>
>>>>>>>>>> That is proven.
>>>>>>>>>
>>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Try to define that.
>>>>>>>>
>>>>>>>
>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>
>>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not the
>>>>>>>> specific input.
>>>>>>>
>>>>>>
>>>>>> If you can't actually define it, you can't say you have
>>>>>> successfully detected it
>>>>> Whenever an input calls its decider.
>>>>>
>>>>
>>>> But in the real system it doesn't call "it's decider", it calls a
>>>> copy of the decider that it was designed to confound.
>>>>
>>> In a Turing machine system. If an x86 machine can do this
>>> as a computable function and a TM cannot then that merely
>>> refutes Church/Turing.
>>
>> And the key here is "as a computable function".
>>
>> That means NO special inputs, or hidden inputs.
>>
>
> // The input has never been hidden
> u32 H(ptr P, ptr I)
> {
>   u32 End_Of_Code   = get_code_end((u32)H);
>   u32 Address_of_H  = (u32)H;

On 2024-03-12 14:02:51 +0000, olcott said:

> On 3/12/2024 3:49 AM, Mikko wrote:
>> On 2024-03-11 15:34:04 +0000, olcott said:
>>
>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>
>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>
>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>>>
>>>>>>>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>
>>>>>>>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>
>>>>>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am working on the computability of the halting problem
>>>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>
>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>>>>> end of its own tape.
>>>>>>>>>>
>>>>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>>>>> simulate your machines.
>>>>>>>>>
>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>>>>> of its own tape.
>>>>>>>>
>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>>>>
>>>>>> That is not "ecept", that is containted in what the word "Truring machine"
>>>>>> means.
>>>>>>
>>>>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>>>>> everything your machine can, so your machine cannot compute anyting a
>>>>>> Turing machine cannot.
>>>>>>
>>>>>
>>>>> Turing Machines, Olcott Machines, RASP machines and my C functions
>>>>> can always correctly report on the behavior of their actual input
>>>>> When they report on this question:
>>>>> Will you halt if you never abort your simulation?
>>>>
>>>> If they only talk about themselves they are not useful.
>>>>
>>>
>>> When every simulating halt decider reports on the actual behavior
>>> that it actually sees, then the pathological input does not
>>> thwart it.
>>
>> If it is not useful then nobody cares whether some input can thwart it.
>>
>
> Best selling author of Theory of Computation textbooks:
> *Introduction To The Theory Of Computation 3RD, by sipser*
> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>
> Date 10/13/2022 11:29:23 AM
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (He has neither reviewed nor agreed to anything else in this paper)
> (a) If simulating halt decider H correctly simulates its input D until
> H correctly determines that its simulated D would never stop running
> unless aborted then
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> *When we apply this criteria* (elaborated above)
> Will you halt if you never abort your simulation?
> *Then the halting problem is solved*

No, it isn't. It is not possible to construct a halting decider
from an application of that criterion.

--
Mikko

On 2024-03-12 23:03:25 +0000, olcott said:

> On 3/12/2024 5:40 PM, Richard Damon wrote:
>> On 3/12/24 2:54 PM, olcott wrote:
>>> On 3/12/2024 4:34 PM, Richard Damon wrote:
>>>> On 3/12/24 2:17 PM, olcott wrote:
>>>>> On 3/12/2024 4:08 PM, Richard Damon wrote:
>>>>>> On 3/12/24 1:32 PM, olcott wrote:
>>>>>>> On 3/12/2024 3:23 PM, immibis wrote:
>>>>>>>> On 12/03/24 19:42, olcott wrote:
>>>>>>>>> On 3/12/2024 1:28 PM, immibis wrote:
>>>>>>>>>> On 12/03/24 17:55, olcott wrote:
>>>>>>>>>>> On 3/12/2024 11:50 AM, immibis wrote:
>>>>>>>>>>>> On 12/03/24 17:12, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> ∀ H ∈ Turing_Machine_Deciders
>>>>>>>>>>>>> ∃ TMD ∈ Turing_Machine_Descriptions  |
>>>>>>>>>>>>> Predicted_Behavior(H, TMD) != Actual_Behavior(TMD)
>>>>>>>>>>>>>
>>>>>>>>>>>>> In all of the H/TMD cases above where
>>>>>>>>>>>>> Predicted_Behavior(H, TMD) != Actual_Behavior(TMD)
>>>>>>>>>>>>> H is being asked a question where both YES and NO
>>>>>>>>>>>>> are the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> So when I ask this Turing machine:
>>>>>>>>>>>> states={qy,qn}
>>>>>>>>>>>> start_state={qn}
>>>>>>>>>>>>
>>>>>>>>>>>> whether it halts, the predicted behaviour is no but the actual
>>>>>>>>>>>> behaviour is yes, so that means both YES and NO are the wrong answer,
>>>>>>>>>>>> according to you?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I can't understand what you mean.
>>>>>>>>>>
>>>>>>>>>> The very simple Turing machine decider always halts in state qn (I
>>>>>>>>>> forgot to specify that states qy and qn are final states). So it
>>>>>>>>>> predicts NO to every input. You're saying that any time any decider
>>>>>>>>>> gets any input wrong, it was because YES and NO were both wrong
>>>>>>>>>> answers. My decider gets lots of inputs wrong. So they all have only
>>>>>>>>>> wrong answers?
>>>>>>>>>>
>>>>>>>>>>>>> It is not that H is gagged and cannot answer, it is
>>>>>>>>>>>>> that both YES and NO are the wrong answer.
>>>>>>>>>>>>
>>>>>>>>>>>> Once we understand that either YES or NO is the right answer, the whole
>>>>>>>>>>>> rebuttal is tossed out as invalid and incorrect.
>>>>>>>>>>>
>>>>>>>>>>> YES or NO is only the right answer to a different decider/input
>>>>>>>>>>> question, thus a rebuttal anchored in the strawman deception.
>>>>>>>>>>
>>>>>>>>>> Once we understand that either YES or NO is the right answer, the whole
>>>>>>>>>> rebuttal is tossed out as invalid and incorrect.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> ∀ H ∈ Turing_Machine_Deciders
>>>>>>>>> ∃ TMD ∈ Turing_Machine_Descriptions  |
>>>>>>>>> Predicted_Behavior(H, TMD) != Actual_Behavior(TMD)
>>>>>>>>>
>>>>>>>>> I am only referring to the decider/input pairs specified
>>>>>>>>> above. You persistently try to get away with referring
>>>>>>>>> to DIFFERENT decider/input pairs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It seems that you are trying to say you are only talking about the ones
>>>>>>>> that are gotten wrong.
>>>>>>>>
>>>>>>>> Once we understand that either YES or NO is the right answer, the whole
>>>>>>>> rebuttal is tossed out as invalid and incorrect.
>>>>>>>
>>>>>>> The above set only refers to the pathological decider/input pairs.
>>>>>>> every pathological decider/input pair <is> an instance of an incorrect
>>>>>>> question.
>>>>>>>
>>>>>>> Ross Finlayson seems to agree that ZFC does toss out these incorrect
>>>>>>> questions.
>>>>>>>
>>>>>>
>>>>>> And for EVERY input in that pair, there is a definite behavior, and
>>>>>> thus a correct answer,
>>>>>
>>>>>  From another different TM that is not in the above referenced set.
>>>>> *It seems that the strawman deception is all that you have on this*
>>>>> That no correct rebuttal exists proves that I am correct.
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> Your logic says that if I form a set of Decider / Input pairs for ANY
>>>> question, where all the deciders get the wrong answer, the quesiton is
>>>> invalid.
>>>>
>>> Every decider/input pair (referenced in the above set) has a
>>> corresponding decider/input pair that only differs by the return
>>> value of its decider.
>>
>> Nope, nothing says that two deciders are paired with the same input.
>>
>
> I keep forgetting the a decider is not a machine that makes
> at least one decision correctly the meaning that the whole
> rest of the world uses for everything else.

You keep forgetting meanigs of may words.

A decider is a Turing machine that for every input either
accepts or renects that input (one bit output). Whether the
decision is correct is not relevant.

--
Mikko

On 2024-03-13 04:12:47 +0000, olcott said:

> On 3/12/2024 10:58 PM, immibis wrote:
>> On 13/03/24 04:21, olcott wrote:
>>> On 3/12/2024 10:03 PM, immibis wrote:
>>>> On 13/03/24 03:40, olcott wrote:
>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>> You haven't actually shown that we have a paradox set, and in fact, ZFC
>>>>>>>>>> prevents it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>> semantically incorrect input we get the exact same results.
>>>>>>>>
>>>>>>>> That seems to be your habit, trying to just LIE and redefine terms and
>>>>>>>> then still try to be in the same logic system.
>>>>>>>>
>>>>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>>>>> My new foundation for computation (NFFC).
>>>>>>>
>>>>>>
>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't real Turing
>>>>>> machines, right? Just like Russell said that some {x|P(x)} aren't real
>>>>>> sets?
>>>>>>
>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>> zero exception when it detects pathological self-reference.
>>>>>
>>>> Because you wrote H(D,D) this means you are talking about x86utm. I am
>>>> talking about Turing machines.
>>>
>>> None-the-less do you see why this would not work?
>>> Is some machine can do it then it can be done.
>>>
>> The reason that Turing machines are used is that they are precise. For
>> example, Turing machines have no such thing as "abnormal termination",
>> so there is no need to argue about what a divide-by-zero termination
>> means.
>>
>> If x86utm machines are to be treated like Turing machines,
>> divide-by-zero is just another termination state. Since "divide-by-zero
>> exception" isn't a correct answer to "does this program halt?" it's an
>> incorrect answer and the machine doesn't solve the halting problem.
>>
> I just want to know if it can be circumvented or not.

It can.

> If it can be then the next steps become moot.

No, it doesn't if you only can but don't.

--
Mikko

On 2024-03-13 15:05:54 +0000, Richard Damon said:

> On 3/13/24 7:14 AM, olcott wrote:
>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>> On 3/12/24 11:05 PM, olcott wrote:
>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox set, and in fact, ZFC
>>>>>>>>>>>>>>>>> prevents it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same results.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and redefine terms and
>>>>>>>>>>>>>>> then still try to be in the same logic system.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't real Turing
>>>>>>>>>>>>> machines, right? Just like Russell said that some {x|P(x)} aren't real
>>>>>>>>>>>>> sets?
>>>>>>>>>>>>>
>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that isn't an option for them.
>>>>>>>>>>>
>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make itself wrong.
>>>>>>>>>>>
>>>>>>>>>>> This might be a reasonable extension for a decider, Accept, Reject, and
>>>>>>>>>>> an "I can't tell". The key is to somehow limit where "I can't tell" can
>>>>>>>>>>> be used, or it makes the decider useless.
>>>>>>>>>>>
>>>>>>>>>>> Could be a LOT better (but still not meet the original requrements)
>>>>>>>>>>> then lying by going to Accept or Reject incorrectly.
>>>>>>>>>>
>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>
>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>
>>>>>>> If your "abnormal Termination" is defined so that it always stops the
>>>>>>> machine it is embedded in, then the operation isn't part of a
>>>>>>> computation, and become a "non-answer" result, and thus make the claim
>>>>>>> decider fail.
>>>>>>>
>>>>>> Then it returns 0,1,2
>>>>>
>>>>> Thats fine. or -1, 0, 1
>>>>>
>>>>>>
>>>>>>> That is how the definitions work. If another machine can't get the
>>>>>>> answer by embedding you, it isn't an answer, and you are not a
>>>>>>> computation.
>>>>>>>
>>>>>>>>
>>>>>>>>> Like I say, it might be an intersting alternate problem, but it doesn't
>>>>>>>>> change the verdict on Halt Deciders, as it doesn't meet the
>>>>>>>>> requirements (which you can't change a be working on that problem)
>>>>>>>>
>>>>>>>> It might change this verdict, lets first see if it always works.
>>>>>>>>
>>>>>>>
>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>
>>>>>>> That is proven.
>>>>>>
>>>>>> Let's just see if it can always decide undecidability.
>>>>>>
>>>>>
>>>>> Try to define that.
>>>>>
>>>>
>>>> What-ever term you want to call it the idea remains unchanged.
>>>> H(D,D) correctly determines that its input is pathological.
>>>>
>>>>> Undecidability is a property of the QUESTION or MAPPING, not the
>>>>> specific input.
>>>>
>>>
>>> If you can't actually define it, you can't say you have successfully
>>> detected it
>> Whenever an input calls its decider.
>>
>
> But in the real system it doesn't call "it's decider", it calls a copy
> of the decider that it was designed to confound.

It needn't even be an exact copy. A camouflaged version would be as good.

--
Mikko

On 2024-03-13 03:52:05 +0000, olcott said:

> On 3/12/2024 10:09 PM, Richard Damon wrote:
>> On 3/12/24 6:52 PM, olcott wrote:
>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>
>>>>>> You haven't actually shown that we have a paradox set, and in fact, ZFC
>>>>>> prevents it.
>>>>>>
>>>>>
>>>>> Yes and by changing the notion of undecidability to mean
>>>>> semantically incorrect input we get the exact same results.
>>>>
>>>> That seems to be your habit, trying to just LIE and redefine terms and
>>>> then still try to be in the same logic system.
>>>>
>>> I am doing the same thing that ZFC did to Naive set theory.
>>> My new foundation for computation (NFFC).
>>
>> No, ZFC invented a TOTALLY NEW Set Theory, after it was shown that
>> Naive set theory was broken, they didn't "change" Naive Set Theory,
>> they replaced it from the ground up and totally defined a new system.
>>
> Sure.
>
>> You are welcome to do the same thing, Remember, TOTAL rewrite, you can
>> look at what you want to keep, but you need to explicitly state your
>> foundation rules and assumptionsk
>>
> I only need to fix what is actually broken.
>
>>>
>>> *It is pretty ridiculous that you keep mistaking new ideas for lies*
>>
>> WHen you claim your "new ideas" are applicable in a system that defines
>> things differently then your new idea require, it is a lie.
>>
> I was always talking about changing the way that things work as needed.
>
>> Talk about PO-Computing all you want, just do the work to actually
>> define it before making claims of what it can do.
>>
> We have H(D,D) terminate abnormally to indicate invalid input.
>
>> Also, don't claim it does anything to affect things inside the
>> classical Computation Theory,
>>
> Naive set theory has been made obsolete.
>
>> If you can prove something useful, only then might you persuade others
>> to try your system. Since most people don't see a problem with the
>> classical theory, it will be a harder sell.
>>
>> After all, Russell proved a big hole in Naive Set Theory with his
>> Paradox. The fact that we can't compute the Halting Function isn't
>> actually bothering many people, it is realized now that many things are
>> not computable, or provable in the more advanced systems.
>>
> The same reasoning prevents Boolean True(L,x) that could
> otherwise detect and report lies being told on the Social
> media and news platforms.

Only if you require it to detect and report all lies on
some set of platforms.

--
Mikko

On 2024-03-13 05:40:24 +0000, olcott said:

> On 3/12/2024 11:56 PM, Richard Damon wrote:

>> The problem with trying to "Terminate Abnormally" and stopping any
>> machine using you is you then become not Turing Complete.

> If any machine can do it, then it can be done. We can
> probably stick with the notion of a computation though:
> mapping inputs to outputs.

If you want to terminate "abnoramlly" you must define a criterion
that differentiates an "abnormal" termination from a "normal"
termination.

You can say "Xyzzy" but can you do it?

--
Mikko

On 2024-03-12 23:59:30 +0000, olcott said:

> On 3/12/2024 6:38 PM, immibis wrote:
>> On 13/03/24 00:32, olcott wrote:
>>> *You keep changing the subject away from Russell's Paradox*
>>
>> Russell's paradox has nothing to do with the halting problem because it
>> is about set theory.
>
> None-the-less it was what Ross Finlayson agreed to when
> he agreed that ZFC rejected an incorrect question.

ZFC coes not reject any question that can be asked in its
language.

--
Mikko

On 13/03/24 18:03, olcott wrote:
> On 3/13/2024 11:48 AM, immibis wrote:
>> On 13/03/24 06:24, olcott wrote:
>>> If H(D,D) can always abnormally terminate on pathological
>>> input then it becomes a consistent undecidability decider.
>>
>> void E(finite_string argument) {
>>      H(argument, argument);
>> }
>>
>> this input is incorrectly detected as pathological.
>>
>
> I don't think so. H only takes the address of C functions.
>

This input is incorrectly detected as pathological because recursive
call to H with the same parameters is detected in the execution trace.
H(E,E) returns 0 even though the correct answer is 1.

On 3/13/2024 12:16 PM, Richard Damon wrote:
> On 3/13/24 9:57 AM, olcott wrote:
>> On 3/13/2024 10:35 AM, Richard Damon wrote:
>>> On 3/13/24 8:15 AM, olcott wrote:
>>>> On 3/13/2024 10:05 AM, Richard Damon wrote:
>>>>> On 3/13/24 7:14 AM, olcott wrote:
>>>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox
>>>>>>>>>>>>>>>>>>>>> set, and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to
>>>>>>>>>>>>>>>>>>>> mean
>>>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set
>>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't
>>>>>>>>>>>>>>>>> real Turing machines, right? Just like Russell said
>>>>>>>>>>>>>>>>> that some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that
>>>>>>>>>>>>>>> isn't an option for them.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make
>>>>>>>>>>>>>>> itself wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This might be a reasonable extension for a decider,
>>>>>>>>>>>>>>> Accept, Reject, and an "I can't tell". The key is to
>>>>>>>>>>>>>>> somehow limit where "I can't tell" can be used, or it
>>>>>>>>>>>>>>> makes the decider useless.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>>>
>>>>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>>>>> stops the machine it is embedded in, then the operation isn't
>>>>>>>>>>> part of a computation, and become a "non-answer" result, and
>>>>>>>>>>> thus make the claim decider fail.
>>>>>>>>>>>
>>>>>>>>>> Then it returns 0,1,2
>>>>>>>>>
>>>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> That is how the definitions work. If another machine can't
>>>>>>>>>>> get the answer by embedding you, it isn't an answer, and you
>>>>>>>>>>> are not a computation.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Like I say, it might be an intersting alternate problem,
>>>>>>>>>>>>> but it doesn't change the verdict on Halt Deciders, as it
>>>>>>>>>>>>> doesn't meet the requirements (which you can't change a be
>>>>>>>>>>>>> working on that problem)
>>>>>>>>>>>>
>>>>>>>>>>>> It might change this verdict, lets first see if it always
>>>>>>>>>>>> works.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>>> That is proven.
>>>>>>>>>>
>>>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try to define that.
>>>>>>>>>
>>>>>>>>
>>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>>
>>>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not
>>>>>>>>> the specific input.
>>>>>>>>
>>>>>>>
>>>>>>> If you can't actually define it, you can't say you have
>>>>>>> successfully detected it
>>>>>> Whenever an input calls its decider.
>>>>>>
>>>>>
>>>>> But in the real system it doesn't call "it's decider", it calls a
>>>>> copy of the decider that it was designed to confound.
>>>>>
>>>> In a Turing machine system. If an x86 machine can do this
>>>> as a computable function and a TM cannot then that merely
>>>> refutes Church/Turing.
>>>
>>> And the key here is "as a computable function".
>>>
>>> That means NO special inputs, or hidden inputs.
>>>
>>
>> // The input has never been hidden
>> u32 H(ptr P, ptr I)
>> {
>>    u32 End_Of_Code   = get_code_end((u32)H);
>>    u32 Address_of_H  = (u32)H;
>
>
> It isn't in the prototype for the function.
>
> THEREFORE, IT IS HIDDEN.
>

On 3/13/2024 1:57 PM, immibis wrote:
> On 13/03/24 18:03, olcott wrote:
>> On 3/13/2024 11:48 AM, immibis wrote:
>>> On 13/03/24 06:24, olcott wrote:
>>>> If H(D,D) can always abnormally terminate on pathological
>>>> input then it becomes a consistent undecidability decider.
>>>
>>> void E(finite_string argument) {
>>>      H(argument, argument);
>>> }
>>>
>>> this input is incorrectly detected as pathological.
>>>
>>
>> I don't think so. H only takes the address of C functions.
>>
>
> This input is incorrectly detected as pathological because recursive
> call to H with the same parameters is detected in the execution trace.
> H(E,E) returns 0 even though the correct answer is 1.

*This seems to be the closest thing to what you are saying*
H ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
H ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt

H ⟨H⟩ ⟨H⟩ would halt because it never copies its own input thus
runs out of params.

I didn't yet figure out how H ⟨H⟩ ⟨H⟩ could see this.

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

On 3/13/2024 1:49 PM, Mikko wrote:
> On 2024-03-12 23:59:30 +0000, olcott said:
>
>> On 3/12/2024 6:38 PM, immibis wrote:
>>> On 13/03/24 00:32, olcott wrote:
>>>> *You keep changing the subject away from Russell's Paradox*
>>>
>>> Russell's paradox has nothing to do with the halting problem because
>>> it is about set theory.
>>
>> None-the-less it was what Ross Finlayson agreed to when
>> he agreed that ZFC rejected an incorrect question.
>
> ZFC coes not reject any question that can be asked in its
> language.
>

It does abolish the incorrect question that could be expressed in
Naive set theory.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/13/2024 1:46 PM, Mikko wrote:
> On 2024-03-13 05:40:24 +0000, olcott said:
>
>> On 3/12/2024 11:56 PM, Richard Damon wrote:
>
>>> The problem with trying to "Terminate Abnormally" and stopping any
>>> machine using you is you then become not Turing Complete.
>
>> If any machine can do it, then it can be done. We can
>> probably stick with the notion of a computation though:
>> mapping inputs to outputs.
>
> If you want to terminate "abnoramlly" you must define a criterion
> that differentiates an "abnormal" termination from a "normal"
> termination.
>
> You can say "Xyzzy" but can you do it?
>

*Abnormal termination criteria*
H(D,D) correctly determines that its input is calling itself
with its same params in such a way that its input would never
terminate unless aborted.

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

On 3/13/2024 1:38 PM, Mikko wrote:
> On 2024-03-13 03:52:05 +0000, olcott said:
>
>> On 3/12/2024 10:09 PM, Richard Damon wrote:
>>> On 3/12/24 6:52 PM, olcott wrote:
>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>
>>>>>>> You haven't actually shown that we have a paradox set, and in
>>>>>>> fact, ZFC prevents it.
>>>>>>>
>>>>>>
>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>> semantically incorrect input we get the exact same results.
>>>>>
>>>>> That seems to be your habit, trying to just LIE and redefine terms
>>>>> and then still try to be in the same logic system.
>>>>>
>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>> My new foundation for computation (NFFC).
>>>
>>> No, ZFC invented a TOTALLY NEW Set Theory, after it was shown that
>>> Naive set theory was broken, they didn't "change" Naive Set Theory,
>>> they replaced it from the ground up and totally defined a new system.
>>>
>> Sure.
>>
>>> You are welcome to do the same thing, Remember, TOTAL rewrite, you
>>> can look at what you want to keep, but you need to explicitly state
>>> your foundation rules and assumptionsk
>>>
>> I only need to fix what is actually broken.
>>
>>>>
>>>> *It is pretty ridiculous that you keep mistaking new ideas for lies*
>>>
>>> WHen you claim your "new ideas" are applicable in a system that
>>> defines things differently then your new idea require, it is a lie.
>>>
>> I was always talking about changing the way that things work as needed.
>>
>>> Talk about PO-Computing all you want, just do the work to actually
>>> define it before making claims of what it can do.
>>>
>> We have H(D,D) terminate abnormally to indicate invalid input.
>>
>>> Also, don't claim it does anything to affect things inside the
>>> classical Computation Theory,
>>>
>> Naive set theory has been made obsolete.
>>
>>> If you can prove something useful, only then might you persuade
>>> others to try your system. Since most people don't see a problem with
>>> the classical theory, it will be a harder sell.
>>>
>>> After all, Russell proved a big hole in Naive Set Theory with his
>>> Paradox. The fact that we can't compute the Halting Function isn't
>>> actually bothering many people, it is realized now that many things
>>> are not computable, or provable in the more advanced systems.
>>>
>> The same reasoning prevents Boolean True(L,x) that could
>> otherwise detect and report lies being told on the Social
>> media and news platforms.
>
> Only if you require it to detect and report all lies on
> some set of platforms.
>

It has access to the internet to use as input to its True(L,x)
function. It has its own internal model of the general knowledge
of the actual world. This enables it to compute whether or not
there is actual evidence of election fraud that could have changed
the result of the 2020 presidential election.

Tarski concluded that such a system would be defeated by the Liar
Paradox. With a pathological self-reference detector this is not
the case.

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

On 3/13/24 12:18 PM, olcott wrote:
> On 3/13/2024 12:16 PM, Richard Damon wrote:
>> On 3/13/24 9:57 AM, olcott wrote:
>>> On 3/13/2024 10:35 AM, Richard Damon wrote:
>>>> On 3/13/24 8:15 AM, olcott wrote:
>>>>> On 3/13/2024 10:05 AM, Richard Damon wrote:
>>>>>> On 3/13/24 7:14 AM, olcott wrote:
>>>>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox
>>>>>>>>>>>>>>>>>>>>>> set, and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to
>>>>>>>>>>>>>>>>>>>>> mean
>>>>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set
>>>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩
>>>>>>>>>>>>>>>>>> aren't real Turing machines, right? Just like Russell
>>>>>>>>>>>>>>>>>> said that some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>>>>> zero exception when it detects pathological
>>>>>>>>>>>>>>>>> self-reference.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that
>>>>>>>>>>>>>>>> isn't an option for them.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus
>>>>>>>>>>>>>>>> make itself wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This might be a reasonable extension for a decider,
>>>>>>>>>>>>>>>> Accept, Reject, and an "I can't tell". The key is to
>>>>>>>>>>>>>>>> somehow limit where "I can't tell" can be used, or it
>>>>>>>>>>>>>>>> makes the decider useless.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>>>>
>>>>>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>>>>>> stops the machine it is embedded in, then the operation
>>>>>>>>>>>> isn't part of a computation, and become a "non-answer"
>>>>>>>>>>>> result, and thus make the claim decider fail.
>>>>>>>>>>>>
>>>>>>>>>>> Then it returns 0,1,2
>>>>>>>>>>
>>>>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> That is how the definitions work. If another machine can't
>>>>>>>>>>>> get the answer by embedding you, it isn't an answer, and you
>>>>>>>>>>>> are not a computation.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Like I say, it might be an intersting alternate problem,
>>>>>>>>>>>>>> but it doesn't change the verdict on Halt Deciders, as it
>>>>>>>>>>>>>> doesn't meet the requirements (which you can't change a be
>>>>>>>>>>>>>> working on that problem)
>>>>>>>>>>>>>
>>>>>>>>>>>>> It might change this verdict, lets first see if it always
>>>>>>>>>>>>> works.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>>> That is proven.
>>>>>>>>>>>
>>>>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Try to define that.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>>>
>>>>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not
>>>>>>>>>> the specific input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you can't actually define it, you can't say you have
>>>>>>>> successfully detected it
>>>>>>> Whenever an input calls its decider.
>>>>>>>
>>>>>>
>>>>>> But in the real system it doesn't call "it's decider", it calls a
>>>>>> copy of the decider that it was designed to confound.
>>>>>>
>>>>> In a Turing machine system. If an x86 machine can do this
>>>>> as a computable function and a TM cannot then that merely
>>>>> refutes Church/Turing.
>>>>
>>>> And the key here is "as a computable function".
>>>>
>>>> That means NO special inputs, or hidden inputs.
>>>>
>>>
>>> // The input has never been hidden
>>> u32 H(ptr P, ptr I)
>>> {
>>>    u32 End_Of_Code   = get_code_end((u32)H);
>>>    u32 Address_of_H  = (u32)H;
>>
>>
>> It isn't in the prototype for the function.
>>
>> THEREFORE, IT IS HIDDEN.
>>
>
> Although it is not typically construed as an input at the
> C level does not mean that it cannot be used an aspect of
> the mapping to a return value.

On 3/13/2024 1:29 PM, Mikko wrote:
> On 2024-03-13 15:05:54 +0000, Richard Damon said:
>
>> On 3/13/24 7:14 AM, olcott wrote:
>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox set,
>>>>>>>>>>>>>>>>>> and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't
>>>>>>>>>>>>>> real Turing machines, right? Just like Russell said that
>>>>>>>>>>>>>> some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that isn't
>>>>>>>>>>>> an option for them.
>>>>>>>>>>>>
>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make
>>>>>>>>>>>> itself wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> This might be a reasonable extension for a decider, Accept,
>>>>>>>>>>>> Reject, and an "I can't tell". The key is to somehow limit
>>>>>>>>>>>> where "I can't tell" can be used, or it makes the decider
>>>>>>>>>>>> useless.
>>>>>>>>>>>>
>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>
>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>
>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>
>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>> stops the machine it is embedded in, then the operation isn't
>>>>>>>> part of a computation, and become a "non-answer" result, and
>>>>>>>> thus make the claim decider fail.
>>>>>>>>
>>>>>>> Then it returns 0,1,2
>>>>>>
>>>>>> Thats fine. or -1, 0, 1
>>>>>>
>>>>>>>
>>>>>>>> That is how the definitions work. If another machine can't get
>>>>>>>> the answer by embedding you, it isn't an answer, and you are not
>>>>>>>> a computation.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> Like I say, it might be an intersting alternate problem, but
>>>>>>>>>> it doesn't change the verdict on Halt Deciders, as it doesn't
>>>>>>>>>> meet the requirements (which you can't change a be working on
>>>>>>>>>> that problem)
>>>>>>>>>
>>>>>>>>> It might change this verdict, lets first see if it always works.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>
>>>>>>>> That is proven.
>>>>>>>
>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>
>>>>>>
>>>>>> Try to define that.
>>>>>>
>>>>>
>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>
>>>>>> Undecidability is a property of the QUESTION or MAPPING, not the
>>>>>> specific input.
>>>>>
>>>>
>>>> If you can't actually define it, you can't say you have successfully
>>>> detected it
>>> Whenever an input calls its decider.
>>>
>>
>> But in the real system it doesn't call "it's decider", it calls a copy
>> of the decider that it was designed to confound.
>
> It needn't even be an exact copy.
> A camouflaged version would be as good.
>
There are certainly no limit to increasingly difficult cases.
The cut-off on this is the original halting problem. Once that
one is fully dealt with the we may or may not move to the next
increment of complexity.

There are two scenarios under investigation.
(a) H and H.D recognize when they themselves are being called
in recursive simulation and correctly return 0 for a different
halting criteria. *Copies are not allowed to be changed*

(b) Same as above yet return ERROR to mean that they cannot
correctly report on the basis of the original criteria.

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

On 3/13/24 12:46 PM, olcott wrote:
> On 3/13/2024 1:57 PM, immibis wrote:
>> On 13/03/24 18:03, olcott wrote:
>>> On 3/13/2024 11:48 AM, immibis wrote:
>>>> On 13/03/24 06:24, olcott wrote:
>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>> input then it becomes a consistent undecidability decider.
>>>>
>>>> void E(finite_string argument) {
>>>>      H(argument, argument);
>>>> }
>>>>
>>>> this input is incorrectly detected as pathological.
>>>>
>>>
>>> I don't think so. H only takes the address of C functions.
>>>
>>
>> This input is incorrectly detected as pathological because recursive
>> call to H with the same parameters is detected in the execution trace.
>> H(E,E) returns 0 even though the correct answer is 1.
>
> *This seems to be the closest thing to what you are saying*
> H ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>
> H ⟨H⟩ ⟨H⟩ would halt because it never copies its own input thus
> runs out of params.
>
> I didn't yet figure out how H ⟨H⟩ ⟨H⟩ could see this.
>

No, H(E,E) sees that E(E) calls H(E,E) and decides it is pathological.

But E(E) ALWAYS Halts if H(E,E) returns ANY value, so E(E) should be
able to be correctly decides as HALTING and not PATHOLOGICAL.

It does NOT do the opposite, so isn't "Pathological"

This was one of the cases discussed a fer years ago.

On 3/13/2024 3:07 PM, Richard Damon wrote:
> On 3/13/24 12:18 PM, olcott wrote:
>> On 3/13/2024 12:16 PM, Richard Damon wrote:
>>> On 3/13/24 9:57 AM, olcott wrote:
>>>> On 3/13/2024 10:35 AM, Richard Damon wrote:
>>>>> On 3/13/24 8:15 AM, olcott wrote:
>>>>>> On 3/13/2024 10:05 AM, Richard Damon wrote:
>>>>>>> On 3/13/24 7:14 AM, olcott wrote:
>>>>>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox
>>>>>>>>>>>>>>>>>>>>>>> set, and in fact, ZFC prevents it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability
>>>>>>>>>>>>>>>>>>>>>> to mean
>>>>>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same
>>>>>>>>>>>>>>>>>>>>>> results.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and
>>>>>>>>>>>>>>>>>>>>> redefine terms and then still try to be in the same
>>>>>>>>>>>>>>>>>>>>> logic system.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set
>>>>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩
>>>>>>>>>>>>>>>>>>> aren't real Turing machines, right? Just like Russell
>>>>>>>>>>>>>>>>>>> said that some {x|P(x)} aren't real sets?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>>>>>> zero exception when it detects pathological
>>>>>>>>>>>>>>>>>> self-reference.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that
>>>>>>>>>>>>>>>>> isn't an option for them.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus
>>>>>>>>>>>>>>>>> make itself wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This might be a reasonable extension for a decider,
>>>>>>>>>>>>>>>>> Accept, Reject, and an "I can't tell". The key is to
>>>>>>>>>>>>>>>>> somehow limit where "I can't tell" can be used, or it
>>>>>>>>>>>>>>>>> makes the decider useless.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Could be a LOT better (but still not meet the original
>>>>>>>>>>>>>>>>> requrements) then lying by going to Accept or Reject
>>>>>>>>>>>>>>>>> incorrectly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If your "abnormal Termination" is defined so that it always
>>>>>>>>>>>>> stops the machine it is embedded in, then the operation
>>>>>>>>>>>>> isn't part of a computation, and become a "non-answer"
>>>>>>>>>>>>> result, and thus make the claim decider fail.
>>>>>>>>>>>>>
>>>>>>>>>>>> Then it returns 0,1,2
>>>>>>>>>>>
>>>>>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> That is how the definitions work. If another machine can't
>>>>>>>>>>>>> get the answer by embedding you, it isn't an answer, and
>>>>>>>>>>>>> you are not a computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Like I say, it might be an intersting alternate problem,
>>>>>>>>>>>>>>> but it doesn't change the verdict on Halt Deciders, as it
>>>>>>>>>>>>>>> doesn't meet the requirements (which you can't change a
>>>>>>>>>>>>>>> be working on that problem)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It might change this verdict, lets first see if it always
>>>>>>>>>>>>>> works.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is proven.
>>>>>>>>>>>>
>>>>>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Try to define that.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>>>>
>>>>>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not
>>>>>>>>>>> the specific input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If you can't actually define it, you can't say you have
>>>>>>>>> successfully detected it
>>>>>>>> Whenever an input calls its decider.
>>>>>>>>
>>>>>>>
>>>>>>> But in the real system it doesn't call "it's decider", it calls a
>>>>>>> copy of the decider that it was designed to confound.
>>>>>>>
>>>>>> In a Turing machine system. If an x86 machine can do this
>>>>>> as a computable function and a TM cannot then that merely
>>>>>> refutes Church/Turing.
>>>>>
>>>>> And the key here is "as a computable function".
>>>>>
>>>>> That means NO special inputs, or hidden inputs.
>>>>>
>>>>
>>>> // The input has never been hidden
>>>> u32 H(ptr P, ptr I)
>>>> {
>>>>    u32 End_Of_Code   = get_code_end((u32)H);
>>>>    u32 Address_of_H  = (u32)H;
>>>
>>>
>>> It isn't in the prototype for the function.
>>>
>>> THEREFORE, IT IS HIDDEN.
>>>
>>
>> Although it is not typically construed as an input at the
>> C level does not mean that it cannot be used an aspect of
>> the mapping to a return value.
>
> And if it isn't a DECLARED input, it is a HIDDEN input, making the C
> function NOT A COMPUTATION.
>