On 3/13/24 12:51 PM, olcott wrote:
> 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.
>

So, includes the non-pathological use of H?

On 13/03/24 20:46, 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.

E copies it. Did you even read the code? It's not very long. Only three
lines. One of them is the function declaration and one of them is just a
closing bracket.

On 13/03/24 20:48, olcott wrote:
> 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.

Naïve set theory says that every {x|P(x)} is a set. ZFC says it isn't.

Naïve Turing machine theory says that every ⟨Q, Γ, b, Σ, δ, q0, F⟩ where
[basic validity conditions omitted] is a Turing machine. Olcott theory
says it isn't. But what is a Turing machine according to Olcott theory?

On 13/03/24 21:12, olcott wrote:
> 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.
>>
>
> That you did not bother to look at it does not mean it is hidden.
> When every C function can access its own address then like Olcott
> machines this is always an input that it can use or ignore.
>

On 3/13/2024 3:46 PM, immibis wrote:
> On 13/03/24 21:12, olcott wrote:
>> 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.
>>>
>>
>> That you did not bother to look at it does not mean it is hidden.
>> When every C function can access its own address then like Olcott
>> machines this is always an input that it can use or ignore.
>>
>
> Actually, C functions can't access "my own address".

On 3/13/2024 3:42 PM, immibis wrote:
> On 13/03/24 20:48, olcott wrote:
>> 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.
>
> Naïve set theory says that every {x|P(x)} is a set. ZFC says it isn't.
>
> Naïve Turing machine theory says that every ⟨Q, Γ, b, Σ, δ, q0, F⟩ where
> [basic validity conditions omitted] is a Turing machine. Olcott theory
> says it isn't. But what is a Turing machine according to Olcott theory?

Not at all and because I have explained this to you so many
times you are being a Troll.

--
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:56 PM, olcott wrote:
> 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)

So, you think the internet is a good source of Truth?

> 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.
>
>

Nope. He shows that if a True precicate that ACTUALLY GIVES THE CORRECT
ANSWER FOR ALL INPUTS existed, it could be used to PROVE that the LIAR
was true, as it, BY DEFINITION A TRUTH BEARER for ALL, even for
statements that are not truth bearers.

Thus S defined in L as ~True(L, S) has no valid value for True(L,S),
but, BY DEFINITION of what a Truth Predicate should be, it must.

If you can indicate whether True or False is the correct value for that
expression, maybe you can solve the problem.

On 3/13/2024 3:41 PM, immibis wrote:
> On 13/03/24 20:46, 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.
>
> E copies it. Did you even read the code? It's not very long. Only three
> lines. One of them is the function declaration and one of them is just a
> closing bracket.

And nothing says it copies its input so yet again you are being a Troll.

--
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 3:27 PM, Richard Damon wrote:
> On 3/13/24 12:51 PM, olcott wrote:
>> 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.
>>
>
> So, includes the non-pathological use of H?

I don't know what you mean by that.
H(D,D) must abort the simulation of its input.
H(H,H) would not need to abort the simulation of its input.

--
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 3:58 PM, Richard Damon wrote:
> On 3/13/24 12:56 PM, olcott wrote:
>> 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)
>
> So, you think the internet is a good source of Truth?
>
It already has the truth it is on the internet looking for lies.

>> 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.
>>
>>
>
> Nope. He shows that if a True precicate that ACTUALLY GIVES THE CORRECT
> ANSWER FOR ALL INPUTS existed, it could be used to PROVE that the LIAR
> was true, as it, BY DEFINITION A TRUTH BEARER for ALL, even for
> statements that are not truth bearers.
>
A false assumption cannot be used in a sound proof.

> Thus S defined in L as ~True(L, S) has no valid value for True(L,S),
> but, BY DEFINITION of what a Truth Predicate should be, it must.
>
> If you can indicate whether True or False is the correct value for that
> expression, maybe you can solve the problem.

LP = "This sentence is not true."
True(L,x) returns TRUE when x is True otherwise returns FALSE.
Boolean True(English, LP) returns FALSE
Boolean True(English, ~LP) returns FALSE

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

On 13/03/24 21:54, olcott wrote:
> On 3/13/2024 3:46 PM, immibis wrote:
>> Actually, C functions can't access "my own address".
>
> *Denying verified facts is far too untruthful*
> *Denying verified facts is far too untruthful*
> *Denying verified facts is far too untruthful*
>
> u32 H(ptr P, ptr I)
> {
>   u32 End_Of_Code               = get_code_end((u32)H);
>   u32 Address_of_H              = (u32)H;
>
>> They can only access addresses of named functions. You can write &H
>> but you can't write &myself (unless the function is called myself).
>>
>> H contains &H but H1 contains &H1. They are different functions so any
>> rebuttal based on the fact they are the same function is rejected as
>> invalid.
>

do you see this code:
(u32)H
do you know what it means

On 13/03/24 21:58, olcott wrote:
> On 3/13/2024 3:41 PM, immibis wrote:
>> On 13/03/24 20:46, 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.
>>
>> E copies it. Did you even read the code? It's not very long. Only
>> three lines. One of them is the function declaration and one of them
>> is just a closing bracket.
>
> And nothing says it copies its input so yet again you are being a Troll.
>
H(argument, argument); <- this line specifies to copy the argument twice

On 3/13/2024 4:14 PM, immibis wrote:
> On 13/03/24 21:54, olcott wrote:
>> On 3/13/2024 3:46 PM, immibis wrote:
>>> Actually, C functions can't access "my own address".
>>
>> *Denying verified facts is far too untruthful*
>> *Denying verified facts is far too untruthful*
>> *Denying verified facts is far too untruthful*
>>
>> u32 H(ptr P, ptr I)
>> {
>>    u32 End_Of_Code               = get_code_end((u32)H);
>>    u32 Address_of_H              = (u32)H;
>>
>>> They can only access addresses of named functions. You can write &H
>>> but you can't write &myself (unless the function is called myself).
>>>
>>> H contains &H but H1 contains &H1. They are different functions so
>>> any rebuttal based on the fact they are the same function is rejected
>>> as invalid.
>>
>
> do you see this code:
> (u32)H
> do you know what it means

I am going to quit responding to any of your Trollish messages.

--
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 4:15 PM, immibis wrote:
> On 13/03/24 21:58, olcott wrote:
>> On 3/13/2024 3:41 PM, immibis wrote:
>>> On 13/03/24 20:46, 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.
>>>
>>> E copies it. Did you even read the code? It's not very long. Only
>>> three lines. One of them is the function declaration and one of them
>>> is just a closing bracket.
>>
>> And nothing says it copies its input so yet again you are being a Troll.
>>
> H(argument, argument); <- this line specifies to copy the argument twice

Not when finite_string is char* or
H takes C++ reference parameters.

--
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 1:12 PM, olcott wrote:
> On 3/13/2024 3:07 PM, Richard Damon wrote:
\ >> And if it isn't a DECLARED input, it is a HIDDEN input, making the C
>> function NOT A COMPUTATION.
>>
>
> That you did not bother to look at it does not mean it is hidden.
> When every C function can access its own address then like Olcott
> machines this is always an input that it can use or ignore.
>

Which just proves you are a stupid liar, because you refuese to learn
the technical meaning of a "Hidden Input".

If you have to go look for it, it was hidden,

You are, effectively, saying that you new computation system can't have
an actual objective decider, as all mapping they can compute include the
decider as an input.

At best they are subjective mapping that don't actually depend on which
decider is being used, but until proven they are all apparently subjective.

On 3/13/24 1:08 PM, olcott wrote:
> 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.

And the original Halting problem is DEFINED for ANY input.

So, if you refuse to look at some inputs, you are admitting failure.

>
> 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.
>

On 3/13/24 1:58 PM, olcott wrote:
> On 3/13/2024 3:41 PM, immibis wrote:
>> On 13/03/24 20:46, 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.
>>
>> E copies it. Did you even read the code? It's not very long. Only
>> three lines. One of them is the function declaration and one of them
>> is just a closing bracket.
>
> And nothing says it copies its input so yet again you are being a Troll.
>

E(X) calls H(X,X)

Just like D does.

So, I guess you admit that you D doesn't work and You are the Troll.

On 3/13/24 2:32 PM, olcott wrote:
> On 3/13/2024 4:15 PM, immibis wrote:
>> On 13/03/24 21:58, olcott wrote:
>>> On 3/13/2024 3:41 PM, immibis wrote:
>>>> On 13/03/24 20:46, 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.
>>>>
>>>> E copies it. Did you even read the code? It's not very long. Only
>>>> three lines. One of them is the function declaration and one of them
>>>> is just a closing bracket.
>>>
>>> And nothing says it copies its input so yet again you are being a Troll.
>>>
>> H(argument, argument); <- this line specifies to copy the argument twice
>
> Not when finite_string is char* or
> H takes C++ reference parameters.
>

Sure it does.

Just like D does.

On 3/13/24 2:01 PM, olcott wrote:
> On 3/13/2024 3:27 PM, Richard Damon wrote:
>> On 3/13/24 12:51 PM, olcott wrote:
>>> 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.
>>>
>>
>> So, includes the non-pathological use of H?
>
> I don't know what you mean by that.
> H(D,D) must abort the simulation of its input.
> H(H,H) would not need to abort the simulation of its input.
>

Look at E(x) that just calls H(x,x) and then halts.

THat is NOT "Pathological", as there is clearly a correct answer for H
to return to be correct, Halting.

The fact that your mental algorithm can detect the case of the input
using the decider, but can't handle it non-pathological use of it shows
that H comes in below expectation.

The algorithm for handling this case (and similar non-pathological
variants) has been discussed here in the past, so you H should get low
marks for declairing this case "unsolvable"

On 3/13/24 2:08 PM, olcott wrote:
> On 3/13/2024 3:58 PM, Richard Damon wrote:
>> On 3/13/24 12:56 PM, olcott wrote:
>>> 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)
>>
>> So, you think the internet is a good source of Truth?
>>
> It already has the truth it is on the internet looking for lies.
>
>>> 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.
>>>
>>>
>>
>> Nope. He shows that if a True precicate that ACTUALLY GIVES THE
>> CORRECT ANSWER FOR ALL INPUTS existed, it could be used to PROVE that
>> the LIAR was true, as it, BY DEFINITION A TRUTH BEARER for ALL, even
>> for statements that are not truth bearers.
>>
> A false assumption cannot be used in a sound proof.

What false assumption.

I quoted the DEFINITION of a PREDICATE.

>
>> Thus S defined in L as ~True(L, S) has no valid value for True(L,S),
>> but, BY DEFINITION of what a Truth Predicate should be, it must.
>>
>> If you can indicate whether True or False is the correct value for
>> that expression, maybe you can solve the problem.
>
>
> LP = "This sentence is not true."
> True(L,x) returns TRUE when x is True otherwise returns FALSE.
> Boolean True(English, LP)  returns FALSE
> Boolean True(English, ~LP) returns FALSE
>
>

And what should:

S = Not True(L,S)

True(L,S)

return?

On 13/03/24 22:01, olcott wrote:
> On 3/13/2024 3:27 PM, Richard Damon wrote:
>> On 3/13/24 12:51 PM, olcott wrote:
>>> 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.
>>>
>>
>> So, includes the non-pathological use of H?
>
> I don't know what you mean by that.
> H(D,D) must abort the simulation of its input.
> H(H,H) would not need to abort the simulation of its input.
>

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

H(E,E) must ?????????????? <- fill in the blank please

On 13/03/24 22:32, olcott wrote:
> On 3/13/2024 4:15 PM, immibis wrote:
>> On 13/03/24 21:58, olcott wrote:
>>> On 3/13/2024 3:41 PM, immibis wrote:
>>>> On 13/03/24 20:46, 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.
>>>>
>>>> E copies it. Did you even read the code? It's not very long. Only
>>>> three lines. One of them is the function declaration and one of them
>>>> is just a closing bracket.
>>>
>>> And nothing says it copies its input so yet again you are being a Troll.
>>>
>> H(argument, argument); <- this line specifies to copy the argument twice
>
> Not when finite_string is char* or
> H takes C++ reference parameters.
>
The argument is still copied twice even if the argument is merely a pointer.

On 3/13/2024 5:32 PM, immibis wrote:
> On 13/03/24 22:32, olcott wrote:
>> On 3/13/2024 4:15 PM, immibis wrote:
>>> On 13/03/24 21:58, olcott wrote:
>>>> On 3/13/2024 3:41 PM, immibis wrote:
>>>>> On 13/03/24 20:46, 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.
>>>>>
>>>>> E copies it. Did you even read the code? It's not very long. Only
>>>>> three lines. One of them is the function declaration and one of
>>>>> them is just a closing bracket.
>>>>
>>>> And nothing says it copies its input so yet again you are being a
>>>> Troll.
>>>>
>>> H(argument, argument); <- this line specifies to copy the argument twice
>>
>> Not when finite_string is char* or
>> H takes C++ reference parameters.
>>
> The argument is still copied twice even if the argument is merely a
> pointer.

The same machine address is correctly used by my own H(D,D).

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

On 13/03/24 23:35, olcott wrote:
> On 3/13/2024 5:32 PM, immibis wrote:
>> On 13/03/24 22:32, olcott wrote:
>>> On 3/13/2024 4:15 PM, immibis wrote:
>>>> On 13/03/24 21:58, olcott wrote:
>>>>> On 3/13/2024 3:41 PM, immibis wrote:
>>>>>> On 13/03/24 20:46, 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.
>>>>>>
>>>>>> E copies it. Did you even read the code? It's not very long. Only
>>>>>> three lines. One of them is the function declaration and one of
>>>>>> them is just a closing bracket.
>>>>>
>>>>> And nothing says it copies its input so yet again you are being a
>>>>> Troll.
>>>>>
>>>> H(argument, argument); <- this line specifies to copy the argument
>>>> twice
>>>
>>> Not when finite_string is char* or
>>> H takes C++ reference parameters.
>>>
>> The argument is still copied twice even if the argument is merely a
>> pointer.
>
> The same machine address is correctly used by my own H(D,D).
>

So what does H(E,E) say?

On 2024-03-13 17:03:03 +0000, olcott said:

> 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.

E calls H correctly if put the required typedef or #define
for finite_string in front of it and call E correctly.

--
Mikko