On 1/22/2024 10:10 PM, wij wrote:
> On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
>> On 1/22/2024 9:59 PM, wij wrote:
>>> On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
>>>> On 1/22/2024 8:59 PM, wij wrote:
>>>>> On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
>>>>>> On 1/22/2024 8:27 PM, wij wrote:
>>>>>>> On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
>>>>>>>> On 1/22/2024 8:13 PM, wij wrote:
>>>>>>>>> On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
>>>>>>>>>> On 1/22/2024 7:44 PM, wij wrote:
>>>>>>>>>>> On Mon, 2024-01-22 at 19:19 -0600, olcott wrote:
>>>>>>>>>>>> On 1/22/2024 6:57 PM, wij wrote:
>>>>>>>>>>>>> On Mon, 2024-01-22 at 18:39 -0600, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 1/22/2024 6:09 PM, wij wrote:
>>>>>>>>>>>>>>> On Mon, 2024-01-22 at 10:28 +0200, Mikko
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 2024-01-21 19:22:22 +0000, wij said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I just found an article about the
>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>> Problem.
>>>>>>>>>>>>>>>>> https://arxiv.org/pdf/1906.05340.pdf
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In the conclusion section:
>>>>>>>>>>>>>>>>> The idea of a universal halting test
>>>>>>>>>>>>>>>>> seems
>>>>>>>>>>>>>>>>> reasonable,
>>>>>>>>>>>>>>>>> but
>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>> for-
>>>>>>>>>>>>>>>>> malised as a consistent specification.
>>>>>>>>>>>>>>>>> It
>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>> model
>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>> exist as
>>>>>>>>>>>>>>>>> a conceptual object. Assuming its
>>>>>>>>>>>>>>>>> conceptual
>>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>>> leads to
>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>> paradox.
>>>>>>>>>>>>>>>>> The halting problem is universally used
>>>>>>>>>>>>>>>>> in
>>>>>>>>>>>>>>>>> university
>>>>>>>>>>>>>>>>> courses
>>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>>> Computer
>>>>>>>>>>>>>>>>> Science to illustrate the limits of
>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>> Hehner
>>>>>>>>>>>>>>>>> claims
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>> problem is misconceived......
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It looks like what olcott now is
>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>> Am I
>>>>>>>>>>>>>>>>> missing
>>>>>>>>>>>>>>>>> something?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The error in the article is the claim
>>>>>>>>>>>>>>>> that an
>>>>>>>>>>>>>>>> "inconsistent"
>>>>>>>>>>>>>>>> specification
>>>>>>>>>>>>>>>> is somehow invalid. But it is not.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A problem is a request to find at least
>>>>>>>>>>>>>>>> one
>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> requirements of the problem or to prove
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>> such
>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>>>> found.
>>>>>>>>>>>>>>>> The problem is well posed if for every
>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>> check
>>>>>>>>>>>>>>>> whether it satisfies all requirements.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The halting problem is solved: a proof
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>> the requirements is known (and nothing
>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that it must be a Turing machine).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is a matter of opinion whether the
>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>> presentation
>>>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> halting theorem is the best one. If one
>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>> like
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>> statement one may instead use:
>>>>>>>>>>>>>>>>          For every universal Turing
>>>>>>>>>>>>>>>> machine U
>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>> H
>>>>>>>>>>>>>>>>          there is an input string S so
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>          either T(S) halts but H(S) does
>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>>          or T(S) does not halt but H(S)
>>>>>>>>>>>>>>>> accepts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This formulation has the disadvantage
>>>>>>>>>>>>>>>> that it
>>>>>>>>>>>>>>>> uses
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> concept of
>>>>>>>>>>>>>>>> "univesal Turing machine", and therefore
>>>>>>>>>>>>>>>> depends
>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>> of one.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Mikko
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thanks for the explanation.
>>>>>>>>>>>>>>> It looked to me it is the statement of
>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>> neither
>>>>>>>>>>>>>>> T nor F bugged these people (including
>>>>>>>>>>>>>>> olcott).
>>>>>>>>>>>>>>> There is also a status of proposition
>>>>>>>>>>>>>>> called
>>>>>>>>>>>>>>> contingency,
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Contingency_(philosophy)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ultimately all these things boil down to the
>>>>>>>>>>>>>> fact
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> self-contradictory questions must be rejected
>>>>>>>>>>>>>> as
>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>> questions. Hehner's paper explains this the
>>>>>>>>>>>>>> best:
>>>>>>>>>>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The key part that non-technical people can
>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>> is
>>>>>>>>>>>>>> Carol's question:
>>>>>>>>>>>>>> Can Carol correctly answer “no” to this
>>>>>>>>>>>>>> [yes/no]
>>>>>>>>>>>>>> question?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That question is self-contradictory when
>>>>>>>>>>>>>> posed to
>>>>>>>>>>>>>> Carol
>>>>>>>>>>>>>> and has the correct answer of "no" when posed
>>>>>>>>>>>>>> to
>>>>>>>>>>>>>> anyone
>>>>>>>>>>>>>> else.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Carol's question actually originates from my
>>>>>>>>>>>>>> own
>>>>>>>>>>>>>> conversation:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/25/2004 6:30 PM, Daryl McCullough wrote:
>>>>>>>>>>>>>> (USENET
>>>>>>>>>>>>>> sci.logic)
>>>>>>>>>>>>>>        > You ask someone (we'll call him
>>>>>>>>>>>>>> "Jack")
>>>>>>>>>>>>>> to
>>>>>>>>>>>>>> give a
>>>>>>>>>>>>>> truthful
>>>>>>>>>>>>>>        > yes/no answer to the following
>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>        >
>>>>>>>>>>>>>>        >  Will Jack's answer to this question
>>>>>>>>>>>>>> be
>>>>>>>>>>>>>> no?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> was addressed to me in 2004.
>>>>>>>>>>>>>> Hehner had no way of knowing this I repeated
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> same question as Bill's question hundreds of
>>>>>>>>>>>>>> times
>>>>>>>>>>>>>> until I tracked down the original author.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The HP is asking (equivalent) for A PROGRAM
>>>>>>>>>>>>> that
>>>>>>>>>>>>> takes
>>>>>>>>>>>>> another
>>>>>>>>>>>>> program
>>>>>>>>>>>>> as its argument and decides whether or not that
>>>>>>>>>>>>> given
>>>>>>>>>>>>> program
>>>>>>>>>>>>> will terminate.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The HP is not asking the evaluation of "HP
>>>>>>>>>>>>> Theorem"
>>>>>>>>>>>>> (the
>>>>>>>>>>>>> conclusion)
>>>>>>>>>>>>> to be true or false!!!
>>>>>>>>>>>
>>>>>>>>>>>> The HP uses a counter-example D that does the
>>>>>>>>>>>> opposite
>>>>>>>>>>>> of whatever value that H returns, thus making the
>>>>>>>>>>>> question
>>>>>>>>>>>> Does D halt? a self-contradictory question for H.
>>>>>>>>>>>
>>>>>>>>>>> It seems you took it as:
>>>>>>>>>>> Proposition P="A program that decides whether
>>>>>>>>>>> another
>>>>>>>>>>> program
>>>>>>>>>>> halts
>>>>>>>>>>> or
>>>>>>>>>>> not is undecidable".
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have gone over these details many many thousands of
>>>>>>>>>> times
>>>>>>>>>> since
>>>>>>>>>> 2004.
>>>>>>>>>> That actual question for H is this:
>>>>>>>>>>
>>>>>>>>>> "What correct Boolean value does H return when D is
>>>>>>>>>> defined
>>>>>>>>>> to do
>>>>>>>>>> the
>>>>>>>>>>       opposite of whatever value that H returns?"
>>>>>>>>>
>>>>>>>>> As you already have seen: The H would be stock in an
>>>>>>>>> infinite
>>>>>>>>> recursive
>>>>>>>>> call. I.e. H is not implementable.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You mean "stuck" not "stock".
>>>>>>>>
>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>> I spent 1.5 years making sure that H does not get stuck
>>>>>>>> it
>>>>>>>> has
>>>>>>>> been
>>>>>>>> fully operational code for several years now.
>>>>>>>>
>>>>>>>>> The result as know it that you deliberately fabricate D
>>>>>>>>> in
>>>>>>>>> way
>>>>>>>>> to
>>>>>>>>> say
>>>>>>>>> whatever you want to say, this is invalid.
>>>>>>>>>
>>>>>>>>
>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>> int D(int (*x)())
>>>>>>>> {
>>>>>>>>       int Halt_Status = H(x, x);
>>>>>>>>       if (Halt_Status)
>>>>>>>>         HERE: goto HERE;
>>>>>>>>       return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> is on lines 935-941 of FULLY OPERATIONAL CODE
>>>>>>>>
>>>>>>>
>>>>>>> You have been through this for a long time. I would suggest
>>>>>>> reading something about quantum computing, then, you will
>>>>>>> become expert soon (because you are a genius), not many
>>>>>>> people
>>>>>>> reading by rote can disagree with you with those age old
>>>>>>> theories.
>>>>>>
>>>>>> Thanks for the great compliment.
>>>>>> My very limited understanding of quantum computing would seem
>>>>>> to
>>>>>> indicate that it still performs computations that are
>>>>>> isomorphic
>>>>>> to Turing machines yet performs these computations at
>>>>>> theoretical
>>>>>> maximum speeds. I am most certain of the TM equivalence part
>>>>>> and
>>>>>> least certain of the theoretical maximum speed part.
>>>>>
>>>>> There are already books teaching quantum programming (an
>>>>> several
>>>>> books
>>>>> I saw are cheap), it would not be difficult for you because you
>>>>> had been good in dealing with symbols. You don't have to be
>>>>> certain about the real quantum things, no one is certain about
>>>>> quantum stuff.
>>>>> Anyway, at least, you will have additional arsenal to support
>>>>> what
>>>>> you claimed.
>>>>>
>>>>>
>>>>
>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>> 02 {
>>>> 03   int Halt_Status = H(x, x);
>>>> 04   if (Halt_Status)
>>>> 05     HERE: goto HERE;
>>>> 06   return Halt_Status;
>>>> 07 }
>>>> 08
>>>> 09 void main()
>>>> 10 {
>>>> 11   H(D,D);
>>>> 12 }
>>>>
>>>> *Execution Trace*
>>>> Line 11: main() invokes H(D,D);
>>>>
>>>> *keeps repeating* (unless aborted)
>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>> D(D)
>>>>
>>>> *Simulation invariant*
>>>> D correctly simulated by H cannot possibly reach past its own
>>>> line
>>>> 03.
>>>>
>>>> D correctly simulated by H cannot possibly reach its simulated
>>>> final
>>>> state in 1 to ∞ steps of correct simulation.
>>>>
>>>> I translated it into C so that it would be as simple as
>>>> possible to see every single detail of exactly what is
>>>> really going on. *People insist on denying reality anyway*
>>>
>>> This is right. But why you insist on something people can't see it?
>>
>> It does seem to solve the halting problem correctly.
>> People don't see it only because they care about disagreement
>> much more than they care about truth.
>
> Exactly, that is the same as why my claim "repeating decimals
> are irrational number" was not accepted. People's reality is
> actually those imposed from the system (school, government,..,
> society), not really the 'real' thing you discovered.

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
>.....
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

I would say people do it because it is/was rewarded, and, if not, they
are punished in someway. That is their 'real' thing. They are
not really 'free-will'.

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>
I would say people do it because it is/was rewarded, and, if not, they
are punished in someway. That is their 'real' thing. They are not
really 'free-will'.

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>
I would say people do it because it is/was rewarded, and, if not, they
are punished in someway. That is their 'real' thing. They are not
really 'free-will'.

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > On 1/22/2024 9:59 PM, wij wrote:
> > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > wrote:
> > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > >           For every universal Turing
> > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > >           there is an input string S
> > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > >           either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > >           or T(S) does not halt but
> > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > >         > You ask someone (we'll call him
> > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > >         > yes/no answer to the following
> > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > >         >
> > > > > > > > > > > > > > >         >  Will Jack's answer to this
> > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > another
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > that
> > > > > > > > > > > > > > given
> > > > > > > > > > > > > > program
> > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > >
> > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > opposite
> > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > the
> > > > > > > > > > > > > question
> > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > for H.
> > > > > > > > > > > >
> > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > another
> > > > > > > > > > > > program
> > > > > > > > > > > > halts
> > > > > > > > > > > > or
> > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > thousands of
> > > > > > > > > > > times
> > > > > > > > > > > since
> > > > > > > > > > > 2004.
> > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > >
> > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > is
> > > > > > > > > > > defined
> > > > > > > > > > > to do
> > > > > > > > > > > the
> > > > > > > > > > >        opposite of whatever value that H
> > > > > > > > > > > returns?"
> > > > > > > > > >
> > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > an
> > > > > > > > > > infinite
> > > > > > > > > > recursive
> > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > stuck
> > > > > > > > > it
> > > > > > > > > has
> > > > > > > > > been
> > > > > > > > > fully operational code for several years now.
> > > > > > > > >
> > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > fabricate D
> > > > > > > > > > in
> > > > > > > > > > way
> > > > > > > > > > to
> > > > > > > > > > say
> > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > int D(int (*x)())
> > > > > > > > > {
> > > > > > > > >        int Halt_Status = H(x, x);
> > > > > > > > >        if (Halt_Status)
> > > > > > > > >          HERE: goto HERE;
> > > > > > > > >        return Halt_Status;
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > >
> > > > > > > >
> > > > > > > > You have been through this for a long time. I would
> > > > > > > > suggest
> > > > > > > > reading something about quantum computing, then, you
> > > > > > > > will
> > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > people
> > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > old
> > > > > > > > theories.
> > > > > > >
> > > > > > > Thanks for the great compliment.
> > > > > > > My very limited understanding of quantum computing would
> > > > > > > seem
> > > > > > > to
> > > > > > > indicate that it still performs computations that are
> > > > > > > isomorphic
> > > > > > > to Turing machines yet performs these computations at
> > > > > > > theoretical
> > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > part
> > > > > > > and
> > > > > > > least certain of the theoretical maximum speed part.
> > > > > >
> > > > > > There are already books teaching quantum programming (an
> > > > > > several
> > > > > > books
> > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > you
> > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > certain about the real quantum things, no one is certain
> > > > > > about
> > > > > > quantum stuff.
> > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > support
> > > > > > what
> > > > > > you claimed.
> > > > > >
> > > > > >
> > > > >
> > > > > 01 int D(ptr x)  // ptr is pointer to int function
> > > > > 02 {
> > > > > 03   int Halt_Status = H(x, x);
> > > > > 04   if (Halt_Status)
> > > > > 05     HERE: goto HERE;
> > > > > 06   return Halt_Status;
> > > > > 07 }
> > > > > 08
> > > > > 09 void main()
> > > > > 10 {
> > > > > 11   H(D,D);
> > > > > 12 }
> > > > >
> > > > > *Execution Trace*
> > > > > Line 11: main() invokes H(D,D);
> > > > >
> > > > > *keeps repeating* (unless aborted)
> > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > simulates
> > > > > D(D)
> > > > >
> > > > > *Simulation invariant*
> > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > line
> > > > > 03.
> > > > >
> > > > > D correctly simulated by H cannot possibly reach its
> > > > > simulated
> > > > > final
> > > > > state in 1 to ∞ steps of correct simulation.
> > > > >
> > > > > I translated it into C so that it would be as simple as
> > > > > possible to see every single detail of exactly what is
> > > > > really going on. *People insist on denying reality anyway*
> > > >
> > > > This is right. But why you insist on something people can't see
> > > > it?
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
>....
> > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > >
> > > It does seem to solve the halting problem correctly.
> > > People don't see it only because they care about disagreement
> > > much more than they care about truth.
> >
> > Exactly, that is the same as why my claim "repeating decimals
> > are irrational number" was not accepted. People's reality is
> > actually those imposed from the system (school, government,..,
> > society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>
> Once we understand that the Tarski undefinability theorem
> is totally refuted by
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> then we have the basis for fully automated fact checkers that
> can blast holes in any and all propaganda every which way before
> it ever even gets started.
>

Because it is/was rewarded, and, if not doing so, they are punished
in someway. That is their miserable 'real' thing. They are not
really 'free-will'.

On Monday, January 22, 2024 at 8:49:49 PM UTC-8, wij wrote:
> On Mon, 2024-01-22 at 22:27 -0600, olcott wrote:
> > On 1/22/2024 10:10 PM, wij wrote:
> > > On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
> > > > On 1/22/2024 9:59 PM, wij wrote:
> > > > > On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
> > > > > > On 1/22/2024 8:59 PM, wij wrote:
> > > > > > > On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
> > > > > > > > On 1/22/2024 8:27 PM, wij wrote:
> > > > > > > > > On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
> > > > > > > > > > On 1/22/2024 8:13 PM, wij wrote:
> > > > > > > > > > > On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
> > > > > > > > > > > > On 1/22/2024 7:44 PM, wij wrote:
> > > > > > > > > > > > > On Mon, 2024-01-22 at 19:19 -0600, olcott
> > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > On 1/22/2024 6:57 PM, wij wrote:
> > > > > > > > > > > > > > > On Mon, 2024-01-22 at 18:39 -0600, olcott
> > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > On 1/22/2024 6:09 PM, wij wrote:
> > > > > > > > > > > > > > > > > On Mon, 2024-01-22 at 10:28 +0200,
> > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > > > On 2024-01-21 19:22:22 +0000, wij
> > > > > > > > > > > > > > > > > > said:
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > > I just found an article about the
> > > > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > > > Problem.
> > > > > > > > > > > > > > > > > > > https://arxiv.org/pdf/1906.05340.pdf
> > > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > > In the conclusion section:
> > > > > > > > > > > > > > > > > > > The idea of a universal halting
> > > > > > > > > > > > > > > > > > > test
> > > > > > > > > > > > > > > > > > > seems
> > > > > > > > > > > > > > > > > > > reasonable,
> > > > > > > > > > > > > > > > > > > but
> > > > > > > > > > > > > > > > > > > cannot
> > > > > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > > > > for-
> > > > > > > > > > > > > > > > > > > malised as a consistent
> > > > > > > > > > > > > > > > > > > specification.
> > > > > > > > > > > > > > > > > > > It
> > > > > > > > > > > > > > > > > > > has
> > > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > > model
> > > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > > exist as
> > > > > > > > > > > > > > > > > > > a conceptual object. Assuming its
> > > > > > > > > > > > > > > > > > > conceptual
> > > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > > leads to
> > > > > > > > > > > > > > > > > > > a
> > > > > > > > > > > > > > > > > > > paradox.
> > > > > > > > > > > > > > > > > > > The halting problem is universally
> > > > > > > > > > > > > > > > > > > used
> > > > > > > > > > > > > > > > > > > in
> > > > > > > > > > > > > > > > > > > university
> > > > > > > > > > > > > > > > > > > courses
> > > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > > Computer
> > > > > > > > > > > > > > > > > > > Science to illustrate the limits of
> > > > > > > > > > > > > > > > > > > computation.
> > > > > > > > > > > > > > > > > > > Hehner
> > > > > > > > > > > > > > > > > > > claims
> > > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > > halting
> > > > > > > > > > > > > > > > > > > problem is misconceived......
> > > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > > It looks like what olcott now is
> > > > > > > > > > > > > > > > > > > claiming.
> > > > > > > > > > > > > > > > > > > Am I
> > > > > > > > > > > > > > > > > > > missing
> > > > > > > > > > > > > > > > > > > something?
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > The error in the article is the claim
> > > > > > > > > > > > > > > > > > that an
> > > > > > > > > > > > > > > > > > "inconsistent"
> > > > > > > > > > > > > > > > > > specification
> > > > > > > > > > > > > > > > > > is somehow invalid. But it is not.
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > A problem is a request to find at
> > > > > > > > > > > > > > > > > > least
> > > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > requirements of the problem or to
> > > > > > > > > > > > > > > > > > prove
> > > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > such
> > > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > > can be
> > > > > > > > > > > > > > > > > > found.
> > > > > > > > > > > > > > > > > > The problem is well posed if for
> > > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > > thing
> > > > > > > > > > > > > > > > > > it
> > > > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > > > possible
> > > > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > > > check
> > > > > > > > > > > > > > > > > > whether it satisfies all
> > > > > > > > > > > > > > > > > > requirements.
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > The halting problem is solved: a
> > > > > > > > > > > > > > > > > > proof
> > > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > > no
> > > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > > the requirements is known (and
> > > > > > > > > > > > > > > > > > nothing
> > > > > > > > > > > > > > > > > > else
> > > > > > > > > > > > > > > > > > satisfies
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > requirement
> > > > > > > > > > > > > > > > > > that it must be a Turing machine).
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > It is a matter of opinion whether the
> > > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > > presentation
> > > > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > halting theorem is the best one. If
> > > > > > > > > > > > > > > > > > one
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > like
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > usual
> > > > > > > > > > > > > > > > > > statement one may instead use:
> > > > > > > > > > > > > > > > > > For every universal Turing
> > > > > > > > > > > > > > > > > > machine U
> > > > > > > > > > > > > > > > > > and
> > > > > > > > > > > > > > > > > > every
> > > > > > > > > > > > > > > > > > Turing
> > > > > > > > > > > > > > > > > > machine
> > > > > > > > > > > > > > > > > > H
> > > > > > > > > > > > > > > > > > there is an input string S
> > > > > > > > > > > > > > > > > > so
> > > > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > > > either T(S) halts but H(S)
> > > > > > > > > > > > > > > > > > does
> > > > > > > > > > > > > > > > > > not
> > > > > > > > > > > > > > > > > > accept
> > > > > > > > > > > > > > > > > > or T(S) does not halt but
> > > > > > > > > > > > > > > > > > H(S)
> > > > > > > > > > > > > > > > > > accepts.
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > This formulation has the disadvantage
> > > > > > > > > > > > > > > > > > that it
> > > > > > > > > > > > > > > > > > uses
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > concept of
> > > > > > > > > > > > > > > > > > "univesal Turing machine", and
> > > > > > > > > > > > > > > > > > therefore
> > > > > > > > > > > > > > > > > > depends
> > > > > > > > > > > > > > > > > > on
> > > > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > > > existence
> > > > > > > > > > > > > > > > > > of one.
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > > Mikko
> > > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Thanks for the explanation.
> > > > > > > > > > > > > > > > > It looked to me it is the statement of
> > > > > > > > > > > > > > > > > Halting
> > > > > > > > > > > > > > > > > Problem
> > > > > > > > > > > > > > > > > proved
> > > > > > > > > > > > > > > > > neither
> > > > > > > > > > > > > > > > > T nor F bugged these people (including
> > > > > > > > > > > > > > > > > olcott).
> > > > > > > > > > > > > > > > > There is also a status of proposition
> > > > > > > > > > > > > > > > > called
> > > > > > > > > > > > > > > > > contingency,
> > > > > > > > > > > > > > > > > https://en.wikipedia.org/wiki/Contingency_(philosophy)
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Ultimately all these things boil down to
> > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > fact
> > > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > > self-contradictory questions must be
> > > > > > > > > > > > > > > > rejected
> > > > > > > > > > > > > > > > as
> > > > > > > > > > > > > > > > incorrect
> > > > > > > > > > > > > > > > questions. Hehner's paper explains this
> > > > > > > > > > > > > > > > the
> > > > > > > > > > > > > > > > best:
> > > > > > > > > > > > > > > > https://www.cs.toronto.edu/~hehner/OSS.pdf
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > The key part that non-technical people
> > > > > > > > > > > > > > > > can
> > > > > > > > > > > > > > > > understand
> > > > > > > > > > > > > > > > is
> > > > > > > > > > > > > > > > Carol's question:
> > > > > > > > > > > > > > > > Can Carol correctly answer “no” to this
> > > > > > > > > > > > > > > > [yes/no]
> > > > > > > > > > > > > > > > question?
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > That question is self-contradictory when
> > > > > > > > > > > > > > > > posed to
> > > > > > > > > > > > > > > > Carol
> > > > > > > > > > > > > > > > and has the correct answer of "no" when
> > > > > > > > > > > > > > > > posed
> > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > anyone
> > > > > > > > > > > > > > > > else.
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > Carol's question actually originates from
> > > > > > > > > > > > > > > > my
> > > > > > > > > > > > > > > > own
> > > > > > > > > > > > > > > > conversation:
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > On 6/25/2004 6:30 PM, Daryl McCullough
> > > > > > > > > > > > > > > > wrote:
> > > > > > > > > > > > > > > > (USENET
> > > > > > > > > > > > > > > > sci.logic)
> > > > > > > > > > > > > > > > > You ask someone (we'll call him
> > > > > > > > > > > > > > > > "Jack")
> > > > > > > > > > > > > > > > to
> > > > > > > > > > > > > > > > give a
> > > > > > > > > > > > > > > > truthful
> > > > > > > > > > > > > > > > > yes/no answer to the following
> > > > > > > > > > > > > > > > question:
> > > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > > Will Jack's answer to this
> > > > > > > > > > > > > > > > question
> > > > > > > > > > > > > > > > be
> > > > > > > > > > > > > > > > no?
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > > was addressed to me in 2004.
> > > > > > > > > > > > > > > > Hehner had no way of knowing this I
> > > > > > > > > > > > > > > > repeated
> > > > > > > > > > > > > > > > this
> > > > > > > > > > > > > > > > same question as Bill's question hundreds
> > > > > > > > > > > > > > > > of
> > > > > > > > > > > > > > > > times
> > > > > > > > > > > > > > > > until I tracked down the original author.
> > > > > > > > > > > > > > > >
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The HP is asking (equivalent) for A PROGRAM
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > takes
> > > > > > > > > > > > > > > another
> > > > > > > > > > > > > > > program
> > > > > > > > > > > > > > > as its argument and decides whether or not
> > > > > > > > > > > > > > > that
> > > > > > > > > > > > > > > given
> > > > > > > > > > > > > > > program
> > > > > > > > > > > > > > > will terminate.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > The HP is not asking the evaluation of "HP
> > > > > > > > > > > > > > > Theorem"
> > > > > > > > > > > > > > > (the
> > > > > > > > > > > > > > > conclusion)
> > > > > > > > > > > > > > > to be true or false!!!
> > > > > > > > > > > > >
> > > > > > > > > > > > > > The HP uses a counter-example D that does the
> > > > > > > > > > > > > > opposite
> > > > > > > > > > > > > > of whatever value that H returns, thus making
> > > > > > > > > > > > > > the
> > > > > > > > > > > > > > question
> > > > > > > > > > > > > > Does D halt? a self-contradictory question
> > > > > > > > > > > > > > for H.
> > > > > > > > > > > > >
> > > > > > > > > > > > > It seems you took it as:
> > > > > > > > > > > > > Proposition P="A program that decides whether
> > > > > > > > > > > > > another
> > > > > > > > > > > > > program
> > > > > > > > > > > > > halts
> > > > > > > > > > > > > or
> > > > > > > > > > > > > not is undecidable".
> > > > > > > > > > > > >
> > > > > > > > > > > >
> > > > > > > > > > > > I have gone over these details many many
> > > > > > > > > > > > thousands of
> > > > > > > > > > > > times
> > > > > > > > > > > > since
> > > > > > > > > > > > 2004.
> > > > > > > > > > > > That actual question for H is this:
> > > > > > > > > > > >
> > > > > > > > > > > > "What correct Boolean value does H return when D
> > > > > > > > > > > > is
> > > > > > > > > > > > defined
> > > > > > > > > > > > to do
> > > > > > > > > > > > the
> > > > > > > > > > > > opposite of whatever value that H
> > > > > > > > > > > > returns?"
> > > > > > > > > > >
> > > > > > > > > > > As you already have seen: The H would be stock in
> > > > > > > > > > > an
> > > > > > > > > > > infinite
> > > > > > > > > > > recursive
> > > > > > > > > > > call. I.e. H is not implementable.
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > You mean "stuck" not "stock".
> > > > > > > > > >
> > > > > > > > > > https://github.com/plolcott/x86utm
> > > > > > > > > > I spent 1.5 years making sure that H does not get
> > > > > > > > > > stuck
> > > > > > > > > > it
> > > > > > > > > > has
> > > > > > > > > > been
> > > > > > > > > > fully operational code for several years now.
> > > > > > > > > >
> > > > > > > > > > > The result as know it that you deliberately
> > > > > > > > > > > fabricate D
> > > > > > > > > > > in
> > > > > > > > > > > way
> > > > > > > > > > > to
> > > > > > > > > > > say
> > > > > > > > > > > whatever you want to say, this is invalid.
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > https://github.com/plolcott/x86utm/blob/master/Halt7.c
> > > > > > > > > > int D(int (*x)())
> > > > > > > > > > {
> > > > > > > > > > int Halt_Status = H(x, x);
> > > > > > > > > > if (Halt_Status)
> > > > > > > > > > HERE: goto HERE;
> > > > > > > > > > return Halt_Status;
> > > > > > > > > > }
> > > > > > > > > >
> > > > > > > > > > is on lines 935-941 of FULLY OPERATIONAL CODE
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > > You have been through this for a long time. I would
> > > > > > > > > suggest
> > > > > > > > > reading something about quantum computing, then, you
> > > > > > > > > will
> > > > > > > > > become expert soon (because you are a genius), not many
> > > > > > > > > people
> > > > > > > > > reading by rote can disagree with you with those age
> > > > > > > > > old
> > > > > > > > > theories.
> > > > > > > >
> > > > > > > > Thanks for the great compliment.
> > > > > > > > My very limited understanding of quantum computing would
> > > > > > > > seem
> > > > > > > > to
> > > > > > > > indicate that it still performs computations that are
> > > > > > > > isomorphic
> > > > > > > > to Turing machines yet performs these computations at
> > > > > > > > theoretical
> > > > > > > > maximum speeds. I am most certain of the TM equivalence
> > > > > > > > part
> > > > > > > > and
> > > > > > > > least certain of the theoretical maximum speed part.
> > > > > > >
> > > > > > > There are already books teaching quantum programming (an
> > > > > > > several
> > > > > > > books
> > > > > > > I saw are cheap), it would not be difficult for you because
> > > > > > > you
> > > > > > > had been good in dealing with symbols. You don't have to be
> > > > > > > certain about the real quantum things, no one is certain
> > > > > > > about
> > > > > > > quantum stuff.
> > > > > > > Anyway, at least, you will have additional arsenal to
> > > > > > > support
> > > > > > > what
> > > > > > > you claimed.
> > > > > > >
> > > > > > >
> > > > > >
> > > > > > 01 int D(ptr x) // ptr is pointer to int function
> > > > > > 02 {
> > > > > > 03 int Halt_Status = H(x, x);
> > > > > > 04 if (Halt_Status)
> > > > > > 05 HERE: goto HERE;
> > > > > > 06 return Halt_Status;
> > > > > > 07 }
> > > > > > 08
> > > > > > 09 void main()
> > > > > > 10 {
> > > > > > 11 H(D,D);
> > > > > > 12 }
> > > > > >
> > > > > > *Execution Trace*
> > > > > > Line 11: main() invokes H(D,D);
> > > > > >
> > > > > > *keeps repeating* (unless aborted)
> > > > > > Line 03: simulated D(D) invokes simulated H(D,D) that
> > > > > > simulates
> > > > > > D(D)
> > > > > >
> > > > > > *Simulation invariant*
> > > > > > D correctly simulated by H cannot possibly reach past its own
> > > > > > line
> > > > > > 03.
> > > > > >
> > > > > > D correctly simulated by H cannot possibly reach its
> > > > > > simulated
> > > > > > final
> > > > > > state in 1 to ∞ steps of correct simulation.
> > > > > >
> > > > > > I translated it into C so that it would be as simple as
> > > > > > possible to see every single detail of exactly what is
> > > > > > really going on. *People insist on denying reality anyway*
> > > > >
> > > > > This is right. But why you insist on something people can't see
> > > > > it?
> > > >
> > > > It does seem to solve the halting problem correctly.
> > > > People don't see it only because they care about disagreement
> > > > much more than they care about truth.
> > >
> > > Exactly, that is the same as why my claim "repeating decimals
> > > are irrational number" was not accepted. People's reality is
> > > actually those imposed from the system (school, government,..,
> > > society), not really the 'real' thing you discovered.
> >
> > I think it is more along the lines that they have more fun playing
> > trollish heads games than helping make key advances in human
> > understanding of correct reasoning.
> >
> > Once we understand that the Tarski undefinability theorem
> > is totally refuted by
> > True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
> >
> > then we have the basis for fully automated fact checkers that
> > can blast holes in any and all propaganda every which way before
> > it ever even gets started.
> >
> Because it is/was rewarded, and, if not doing so, they are punished
> in someway. That is their miserable 'real' thing. They are not
> really 'free-will'.

On 1/22/24 11:27 PM, olcott wrote:
> On 1/22/2024 10:10 PM, wij wrote:
>> On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
>>> On 1/22/2024 9:59 PM, wij wrote:
>>>> On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
>>>>> On 1/22/2024 8:59 PM, wij wrote:
>>>>>> On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
>>>>>>> On 1/22/2024 8:27 PM, wij wrote:
>>>>>>>> On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
>>>>>>>>> On 1/22/2024 8:13 PM, wij wrote:
>>>>>>>>>> On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
>>>>>>>>>>> On 1/22/2024 7:44 PM, wij wrote:
>>>>>>>>>>>> On Mon, 2024-01-22 at 19:19 -0600, olcott wrote:
>>>>>>>>>>>>> On 1/22/2024 6:57 PM, wij wrote:
>>>>>>>>>>>>>> On Mon, 2024-01-22 at 18:39 -0600, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 1/22/2024 6:09 PM, wij wrote:
>>>>>>>>>>>>>>>> On Mon, 2024-01-22 at 10:28 +0200, Mikko
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 2024-01-21 19:22:22 +0000, wij said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I just found an article about the
>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>> Problem.
>>>>>>>>>>>>>>>>>> https://arxiv.org/pdf/1906.05340.pdf
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In the conclusion section:
>>>>>>>>>>>>>>>>>> The idea of a universal halting test
>>>>>>>>>>>>>>>>>> seems
>>>>>>>>>>>>>>>>>> reasonable,
>>>>>>>>>>>>>>>>>> but
>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>> for-
>>>>>>>>>>>>>>>>>> malised as a consistent specification.
>>>>>>>>>>>>>>>>>> It
>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>>> model
>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>> exist as
>>>>>>>>>>>>>>>>>> a conceptual object. Assuming its
>>>>>>>>>>>>>>>>>> conceptual
>>>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>>>> leads to
>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>> paradox.
>>>>>>>>>>>>>>>>>> The halting problem is universally used
>>>>>>>>>>>>>>>>>> in
>>>>>>>>>>>>>>>>>> university
>>>>>>>>>>>>>>>>>> courses
>>>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>>>> Computer
>>>>>>>>>>>>>>>>>> Science to illustrate the limits of
>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>> Hehner
>>>>>>>>>>>>>>>>>> claims
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>> problem is misconceived......
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It looks like what olcott now is
>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>> Am I
>>>>>>>>>>>>>>>>>> missing
>>>>>>>>>>>>>>>>>> something?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The error in the article is the claim
>>>>>>>>>>>>>>>>> that an
>>>>>>>>>>>>>>>>> "inconsistent"
>>>>>>>>>>>>>>>>> specification
>>>>>>>>>>>>>>>>> is somehow invalid. But it is not.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A problem is a request to find at least
>>>>>>>>>>>>>>>>> one
>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> requirements of the problem or to prove
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>> such
>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>>>>> found.
>>>>>>>>>>>>>>>>> The problem is well posed if for every
>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>> check
>>>>>>>>>>>>>>>>> whether it satisfies all requirements.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The halting problem is solved: a proof
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>> the requirements is known (and nothing
>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that it must be a Turing machine).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is a matter of opinion whether the
>>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>>> presentation
>>>>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> halting theorem is the best one. If one
>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>> like
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>>> statement one may instead use:
>>>>>>>>>>>>>>>>>           For every universal Turing
>>>>>>>>>>>>>>>>> machine U
>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>> H
>>>>>>>>>>>>>>>>>           there is an input string S so
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>           either T(S) halts but H(S) does
>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>>>           or T(S) does not halt but H(S)
>>>>>>>>>>>>>>>>> accepts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This formulation has the disadvantage
>>>>>>>>>>>>>>>>> that it
>>>>>>>>>>>>>>>>> uses
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> concept of
>>>>>>>>>>>>>>>>> "univesal Turing machine", and therefore
>>>>>>>>>>>>>>>>> depends
>>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>>> of one.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Mikko
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thanks for the explanation.
>>>>>>>>>>>>>>>> It looked to me it is the statement of
>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>> neither
>>>>>>>>>>>>>>>> T nor F bugged these people (including
>>>>>>>>>>>>>>>> olcott).
>>>>>>>>>>>>>>>> There is also a status of proposition
>>>>>>>>>>>>>>>> called
>>>>>>>>>>>>>>>> contingency,
>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Contingency_(philosophy)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ultimately all these things boil down to the
>>>>>>>>>>>>>>> fact
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> self-contradictory questions must be rejected
>>>>>>>>>>>>>>> as
>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>> questions. Hehner's paper explains this the
>>>>>>>>>>>>>>> best:
>>>>>>>>>>>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key part that non-technical people can
>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>> Carol's question:
>>>>>>>>>>>>>>> Can Carol correctly answer “no” to this
>>>>>>>>>>>>>>> [yes/no]
>>>>>>>>>>>>>>> question?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That question is self-contradictory when
>>>>>>>>>>>>>>> posed to
>>>>>>>>>>>>>>> Carol
>>>>>>>>>>>>>>> and has the correct answer of "no" when posed
>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>> anyone
>>>>>>>>>>>>>>> else.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Carol's question actually originates from my
>>>>>>>>>>>>>>> own
>>>>>>>>>>>>>>> conversation:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 6/25/2004 6:30 PM, Daryl McCullough wrote:
>>>>>>>>>>>>>>> (USENET
>>>>>>>>>>>>>>> sci.logic)
>>>>>>>>>>>>>>>         > You ask someone (we'll call him
>>>>>>>>>>>>>>> "Jack")
>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>> give a
>>>>>>>>>>>>>>> truthful
>>>>>>>>>>>>>>>         > yes/no answer to the following
>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>         >
>>>>>>>>>>>>>>>         >  Will Jack's answer to this question
>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>> no?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> was addressed to me in 2004.
>>>>>>>>>>>>>>> Hehner had no way of knowing this I repeated
>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>> same question as Bill's question hundreds of
>>>>>>>>>>>>>>> times
>>>>>>>>>>>>>>> until I tracked down the original author.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The HP is asking (equivalent) for A PROGRAM
>>>>>>>>>>>>>> that
>>>>>>>>>>>>>> takes
>>>>>>>>>>>>>> another
>>>>>>>>>>>>>> program
>>>>>>>>>>>>>> as its argument and decides whether or not that
>>>>>>>>>>>>>> given
>>>>>>>>>>>>>> program
>>>>>>>>>>>>>> will terminate.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The HP is not asking the evaluation of "HP
>>>>>>>>>>>>>> Theorem"
>>>>>>>>>>>>>> (the
>>>>>>>>>>>>>> conclusion)
>>>>>>>>>>>>>> to be true or false!!!
>>>>>>>>>>>>
>>>>>>>>>>>>> The HP uses a counter-example D that does the
>>>>>>>>>>>>> opposite
>>>>>>>>>>>>> of whatever value that H returns, thus making the
>>>>>>>>>>>>> question
>>>>>>>>>>>>> Does D halt? a self-contradictory question for H.
>>>>>>>>>>>>
>>>>>>>>>>>> It seems you took it as:
>>>>>>>>>>>> Proposition P="A program that decides whether
>>>>>>>>>>>> another
>>>>>>>>>>>> program
>>>>>>>>>>>> halts
>>>>>>>>>>>> or
>>>>>>>>>>>> not is undecidable".
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have gone over these details many many thousands of
>>>>>>>>>>> times
>>>>>>>>>>> since
>>>>>>>>>>> 2004.
>>>>>>>>>>> That actual question for H is this:
>>>>>>>>>>>
>>>>>>>>>>> "What correct Boolean value does H return when D is
>>>>>>>>>>> defined
>>>>>>>>>>> to do
>>>>>>>>>>> the
>>>>>>>>>>>        opposite of whatever value that H returns?"
>>>>>>>>>>
>>>>>>>>>> As you already have seen: The H would be stock in an
>>>>>>>>>> infinite
>>>>>>>>>> recursive
>>>>>>>>>> call. I.e. H is not implementable.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You mean "stuck" not "stock".
>>>>>>>>>
>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>> I spent 1.5 years making sure that H does not get stuck
>>>>>>>>> it
>>>>>>>>> has
>>>>>>>>> been
>>>>>>>>> fully operational code for several years now.
>>>>>>>>>
>>>>>>>>>> The result as know it that you deliberately fabricate D
>>>>>>>>>> in
>>>>>>>>>> way
>>>>>>>>>> to
>>>>>>>>>> say
>>>>>>>>>> whatever you want to say, this is invalid.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>> int D(int (*x)())
>>>>>>>>> {
>>>>>>>>>        int Halt_Status = H(x, x);
>>>>>>>>>        if (Halt_Status)
>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>        return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> is on lines 935-941 of FULLY OPERATIONAL CODE
>>>>>>>>>
>>>>>>>>
>>>>>>>> You have been through this for a long time. I would suggest
>>>>>>>> reading something about quantum computing, then, you will
>>>>>>>> become expert soon (because you are a genius), not many
>>>>>>>> people
>>>>>>>> reading by rote can disagree with you with those age old
>>>>>>>> theories.
>>>>>>>
>>>>>>> Thanks for the great compliment.
>>>>>>> My very limited understanding of quantum computing would seem
>>>>>>> to
>>>>>>> indicate that it still performs computations that are
>>>>>>> isomorphic
>>>>>>> to Turing machines yet performs these computations at
>>>>>>> theoretical
>>>>>>> maximum speeds. I am most certain of the TM equivalence part
>>>>>>> and
>>>>>>> least certain of the theoretical maximum speed part.
>>>>>>
>>>>>> There are already books teaching quantum programming (an
>>>>>> several
>>>>>> books
>>>>>> I saw are cheap), it would not be difficult for you because you
>>>>>> had been good in dealing with symbols. You don't have to be
>>>>>> certain about the real quantum things, no one is certain about
>>>>>> quantum stuff.
>>>>>> Anyway, at least, you will have additional arsenal to support
>>>>>> what
>>>>>> you claimed.
>>>>>>
>>>>>>
>>>>>
>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>> 02 {
>>>>> 03   int Halt_Status = H(x, x);
>>>>> 04   if (Halt_Status)
>>>>> 05     HERE: goto HERE;
>>>>> 06   return Halt_Status;
>>>>> 07 }
>>>>> 08
>>>>> 09 void main()
>>>>> 10 {
>>>>> 11   H(D,D);
>>>>> 12 }
>>>>>
>>>>> *Execution Trace*
>>>>> Line 11: main() invokes H(D,D);
>>>>>
>>>>> *keeps repeating* (unless aborted)
>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>> D(D)
>>>>>
>>>>> *Simulation invariant*
>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>> line
>>>>> 03.
>>>>>
>>>>> D correctly simulated by H cannot possibly reach its simulated
>>>>> final
>>>>> state in 1 to ∞ steps of correct simulation.
>>>>>
>>>>> I translated it into C so that it would be as simple as
>>>>> possible to see every single detail of exactly what is
>>>>> really going on. *People insist on denying reality anyway*
>>>>
>>>> This is right. But why you insist on something people can't see it?
>>>
>>> It does seem to solve the halting problem correctly.
>>> People don't see it only because they care about disagreement
>>> much more than they care about truth.
>>
>> Exactly, that is the same as why my claim "repeating decimals
>> are irrational number" was not accepted. People's reality is
>> actually those imposed from the system (school, government,..,
>> society), not really the 'real' thing you discovered.
>
> I think it is more along the lines that they have more fun playing
> trollish heads games than helping make key advances in human
> understanding of correct reasoning.
>

On 1/23/2024 6:49 AM, Richard Damon wrote:
> On 1/22/24 11:27 PM, olcott wrote:
>> On 1/22/2024 10:10 PM, wij wrote:
>>> On Mon, 2024-01-22 at 22:01 -0600, olcott wrote:
>>>> On 1/22/2024 9:59 PM, wij wrote:
>>>>> On Mon, 2024-01-22 at 21:29 -0600, olcott wrote:
>>>>>> On 1/22/2024 8:59 PM, wij wrote:
>>>>>>> On Mon, 2024-01-22 at 20:40 -0600, olcott wrote:
>>>>>>>> On 1/22/2024 8:27 PM, wij wrote:
>>>>>>>>> On Mon, 2024-01-22 at 20:20 -0600, olcott wrote:
>>>>>>>>>> On 1/22/2024 8:13 PM, wij wrote:
>>>>>>>>>>> On Mon, 2024-01-22 at 20:05 -0600, olcott wrote:
>>>>>>>>>>>> On 1/22/2024 7:44 PM, wij wrote:
>>>>>>>>>>>>> On Mon, 2024-01-22 at 19:19 -0600, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2024 6:57 PM, wij wrote:
>>>>>>>>>>>>>>> On Mon, 2024-01-22 at 18:39 -0600, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 1/22/2024 6:09 PM, wij wrote:
>>>>>>>>>>>>>>>>> On Mon, 2024-01-22 at 10:28 +0200, Mikko
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 2024-01-21 19:22:22 +0000, wij said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I just found an article about the
>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>> Problem.
>>>>>>>>>>>>>>>>>>> https://arxiv.org/pdf/1906.05340.pdf
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In the conclusion section:
>>>>>>>>>>>>>>>>>>> The idea of a universal halting test
>>>>>>>>>>>>>>>>>>> seems
>>>>>>>>>>>>>>>>>>> reasonable,
>>>>>>>>>>>>>>>>>>> but
>>>>>>>>>>>>>>>>>>> cannot
>>>>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>>>>> for-
>>>>>>>>>>>>>>>>>>> malised as a consistent specification.
>>>>>>>>>>>>>>>>>>> It
>>>>>>>>>>>>>>>>>>> has
>>>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>>>> model
>>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>>> exist as
>>>>>>>>>>>>>>>>>>> a conceptual object. Assuming its
>>>>>>>>>>>>>>>>>>> conceptual
>>>>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>>>>> leads to
>>>>>>>>>>>>>>>>>>> a
>>>>>>>>>>>>>>>>>>> paradox.
>>>>>>>>>>>>>>>>>>> The halting problem is universally used
>>>>>>>>>>>>>>>>>>> in
>>>>>>>>>>>>>>>>>>> university
>>>>>>>>>>>>>>>>>>> courses
>>>>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>>>>> Computer
>>>>>>>>>>>>>>>>>>> Science to illustrate the limits of
>>>>>>>>>>>>>>>>>>> computation.
>>>>>>>>>>>>>>>>>>> Hehner
>>>>>>>>>>>>>>>>>>> claims
>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>>>>> problem is misconceived......
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It looks like what olcott now is
>>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>>> Am I
>>>>>>>>>>>>>>>>>>> missing
>>>>>>>>>>>>>>>>>>> something?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The error in the article is the claim
>>>>>>>>>>>>>>>>>> that an
>>>>>>>>>>>>>>>>>> "inconsistent"
>>>>>>>>>>>>>>>>>> specification
>>>>>>>>>>>>>>>>>> is somehow invalid. But it is not.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A problem is a request to find at least
>>>>>>>>>>>>>>>>>> one
>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> requirements of the problem or to prove
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>>> such
>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>>>>>> found.
>>>>>>>>>>>>>>>>>> The problem is well posed if for every
>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>>>> possible
>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>> check
>>>>>>>>>>>>>>>>>> whether it satisfies all requirements.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The halting problem is solved: a proof
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> no
>>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>>> the requirements is known (and nothing
>>>>>>>>>>>>>>>>>> else
>>>>>>>>>>>>>>>>>> satisfies
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>> that it must be a Turing machine).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is a matter of opinion whether the
>>>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>>>> presentation
>>>>>>>>>>>>>>>>>> of
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> halting theorem is the best one. If one
>>>>>>>>>>>>>>>>>> does
>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>> like
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> usual
>>>>>>>>>>>>>>>>>> statement one may instead use:
>>>>>>>>>>>>>>>>>>           For every universal Turing
>>>>>>>>>>>>>>>>>> machine U
>>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>> every
>>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>> H
>>>>>>>>>>>>>>>>>>           there is an input string S so
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>           either T(S) halts but H(S) does
>>>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>>>>           or T(S) does not halt but H(S)
>>>>>>>>>>>>>>>>>> accepts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This formulation has the disadvantage
>>>>>>>>>>>>>>>>>> that it
>>>>>>>>>>>>>>>>>> uses
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> concept of
>>>>>>>>>>>>>>>>>> "univesal Turing machine", and therefore
>>>>>>>>>>>>>>>>>> depends
>>>>>>>>>>>>>>>>>> on
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> existence
>>>>>>>>>>>>>>>>>> of one.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Mikko
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thanks for the explanation.
>>>>>>>>>>>>>>>>> It looked to me it is the statement of
>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>> proved
>>>>>>>>>>>>>>>>> neither
>>>>>>>>>>>>>>>>> T nor F bugged these people (including
>>>>>>>>>>>>>>>>> olcott).
>>>>>>>>>>>>>>>>> There is also a status of proposition
>>>>>>>>>>>>>>>>> called
>>>>>>>>>>>>>>>>> contingency,
>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Contingency_(philosophy)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ultimately all these things boil down to the
>>>>>>>>>>>>>>>> fact
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> self-contradictory questions must be rejected
>>>>>>>>>>>>>>>> as
>>>>>>>>>>>>>>>> incorrect
>>>>>>>>>>>>>>>> questions. Hehner's paper explains this the
>>>>>>>>>>>>>>>> best:
>>>>>>>>>>>>>>>> https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The key part that non-technical people can
>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>> is
>>>>>>>>>>>>>>>> Carol's question:
>>>>>>>>>>>>>>>> Can Carol correctly answer “no” to this
>>>>>>>>>>>>>>>> [yes/no]
>>>>>>>>>>>>>>>> question?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That question is self-contradictory when
>>>>>>>>>>>>>>>> posed to
>>>>>>>>>>>>>>>> Carol
>>>>>>>>>>>>>>>> and has the correct answer of "no" when posed
>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>> anyone
>>>>>>>>>>>>>>>> else.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Carol's question actually originates from my
>>>>>>>>>>>>>>>> own
>>>>>>>>>>>>>>>> conversation:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/25/2004 6:30 PM, Daryl McCullough wrote:
>>>>>>>>>>>>>>>> (USENET
>>>>>>>>>>>>>>>> sci.logic)
>>>>>>>>>>>>>>>>         > You ask someone (we'll call him
>>>>>>>>>>>>>>>> "Jack")
>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>> give a
>>>>>>>>>>>>>>>> truthful
>>>>>>>>>>>>>>>>         > yes/no answer to the following
>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>         >
>>>>>>>>>>>>>>>>         >  Will Jack's answer to this question
>>>>>>>>>>>>>>>> be
>>>>>>>>>>>>>>>> no?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> was addressed to me in 2004.
>>>>>>>>>>>>>>>> Hehner had no way of knowing this I repeated
>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>> same question as Bill's question hundreds of
>>>>>>>>>>>>>>>> times
>>>>>>>>>>>>>>>> until I tracked down the original author.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The HP is asking (equivalent) for A PROGRAM
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> takes
>>>>>>>>>>>>>>> another
>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>> as its argument and decides whether or not that
>>>>>>>>>>>>>>> given
>>>>>>>>>>>>>>> program
>>>>>>>>>>>>>>> will terminate.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The HP is not asking the evaluation of "HP
>>>>>>>>>>>>>>> Theorem"
>>>>>>>>>>>>>>> (the
>>>>>>>>>>>>>>> conclusion)
>>>>>>>>>>>>>>> to be true or false!!!
>>>>>>>>>>>>>
>>>>>>>>>>>>>> The HP uses a counter-example D that does the
>>>>>>>>>>>>>> opposite
>>>>>>>>>>>>>> of whatever value that H returns, thus making the
>>>>>>>>>>>>>> question
>>>>>>>>>>>>>> Does D halt? a self-contradictory question for H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It seems you took it as:
>>>>>>>>>>>>> Proposition P="A program that decides whether
>>>>>>>>>>>>> another
>>>>>>>>>>>>> program
>>>>>>>>>>>>> halts
>>>>>>>>>>>>> or
>>>>>>>>>>>>> not is undecidable".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have gone over these details many many thousands of
>>>>>>>>>>>> times
>>>>>>>>>>>> since
>>>>>>>>>>>> 2004.
>>>>>>>>>>>> That actual question for H is this:
>>>>>>>>>>>>
>>>>>>>>>>>> "What correct Boolean value does H return when D is
>>>>>>>>>>>> defined
>>>>>>>>>>>> to do
>>>>>>>>>>>> the
>>>>>>>>>>>>        opposite of whatever value that H returns?"
>>>>>>>>>>>
>>>>>>>>>>> As you already have seen: The H would be stock in an
>>>>>>>>>>> infinite
>>>>>>>>>>> recursive
>>>>>>>>>>> call. I.e. H is not implementable.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You mean "stuck" not "stock".
>>>>>>>>>>
>>>>>>>>>> https://github.com/plolcott/x86utm
>>>>>>>>>> I spent 1.5 years making sure that H does not get stuck
>>>>>>>>>> it
>>>>>>>>>> has
>>>>>>>>>> been
>>>>>>>>>> fully operational code for several years now.
>>>>>>>>>>
>>>>>>>>>>> The result as know it that you deliberately fabricate D
>>>>>>>>>>> in
>>>>>>>>>>> way
>>>>>>>>>>> to
>>>>>>>>>>> say
>>>>>>>>>>> whatever you want to say, this is invalid.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>>>>>>>>>> int D(int (*x)())
>>>>>>>>>> {
>>>>>>>>>>        int Halt_Status = H(x, x);
>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>        return Halt_Status;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> is on lines 935-941 of FULLY OPERATIONAL CODE
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You have been through this for a long time. I would suggest
>>>>>>>>> reading something about quantum computing, then, you will
>>>>>>>>> become expert soon (because you are a genius), not many
>>>>>>>>> people
>>>>>>>>> reading by rote can disagree with you with those age old
>>>>>>>>> theories.
>>>>>>>>
>>>>>>>> Thanks for the great compliment.
>>>>>>>> My very limited understanding of quantum computing would seem
>>>>>>>> to
>>>>>>>> indicate that it still performs computations that are
>>>>>>>> isomorphic
>>>>>>>> to Turing machines yet performs these computations at
>>>>>>>> theoretical
>>>>>>>> maximum speeds. I am most certain of the TM equivalence part
>>>>>>>> and
>>>>>>>> least certain of the theoretical maximum speed part.
>>>>>>>
>>>>>>> There are already books teaching quantum programming (an
>>>>>>> several
>>>>>>> books
>>>>>>> I saw are cheap), it would not be difficult for you because you
>>>>>>> had been good in dealing with symbols. You don't have to be
>>>>>>> certain about the real quantum things, no one is certain about
>>>>>>> quantum stuff.
>>>>>>> Anyway, at least, you will have additional arsenal to support
>>>>>>> what
>>>>>>> you claimed.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> 01 int D(ptr x)  // ptr is pointer to int function
>>>>>> 02 {
>>>>>> 03   int Halt_Status = H(x, x);
>>>>>> 04   if (Halt_Status)
>>>>>> 05     HERE: goto HERE;
>>>>>> 06   return Halt_Status;
>>>>>> 07 }
>>>>>> 08
>>>>>> 09 void main()
>>>>>> 10 {
>>>>>> 11   H(D,D);
>>>>>> 12 }
>>>>>>
>>>>>> *Execution Trace*
>>>>>> Line 11: main() invokes H(D,D);
>>>>>>
>>>>>> *keeps repeating* (unless aborted)
>>>>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates
>>>>>> D(D)
>>>>>>
>>>>>> *Simulation invariant*
>>>>>> D correctly simulated by H cannot possibly reach past its own
>>>>>> line
>>>>>> 03.
>>>>>>
>>>>>> D correctly simulated by H cannot possibly reach its simulated
>>>>>> final
>>>>>> state in 1 to ∞ steps of correct simulation.
>>>>>>
>>>>>> I translated it into C so that it would be as simple as
>>>>>> possible to see every single detail of exactly what is
>>>>>> really going on. *People insist on denying reality anyway*
>>>>>
>>>>> This is right. But why you insist on something people can't see it?
>>>>
>>>> It does seem to solve the halting problem correctly.
>>>> People don't see it only because they care about disagreement
>>>> much more than they care about truth.
>>>
>>> Exactly, that is the same as why my claim "repeating decimals
>>> are irrational number" was not accepted. People's reality is
>>> actually those imposed from the system (school, government,..,
>>> society), not really the 'real' thing you discovered.
>>
>> I think it is more along the lines that they have more fun playing
>> trollish heads games than helping make key advances in human
>> understanding of correct reasoning.
>>
>
> What "Correct Reasoning" are you talking about? The PO-Correct Reasoning
> that says it is correct to ask a Halting Decider, defined to have ACTUAL
> PROGRAMS given as an input, and input that isn't actually a compete
> program?
>
>
>> Once we understand that the Tarski undefinability theorem
>> is totally refuted by
>> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>
> Except (L ⊢ x)  isn't a valid definition as it isn't a finite procedure
> that can be used to determine if x is, in fact true.

On 1/23/24 11:30 AM, olcott wrote:
> On 1/23/2024 6:49 AM, Richard Damon wrote:
>> On 1/22/24 11:27 PM, olcott wrote:

>>> Once we understand that the Tarski undefinability theorem
>>> is totally refuted by
>>> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
>>
>> Except (L ⊢ x)  isn't a valid definition as it isn't a finite
>> procedure that can be used to determine if x is, in fact true.
>
> If you know what a directed graph cycle is then you can understand this
>
> Prolog detects and rejects inputs that specify cycles
> ?- unify_with_occurs_check(LP, not(true(LP))).
> false.

But that still doesn't show how you can tell if (L ⊢ x) is true for a
given L in a reasonably complicated system.

Remember, Prolog is limited to Prepositional logic, not even full first
order, and only for system with a finite domain.

I don't think you understand how limited that is, probably because you
don't really understand that much, and surely don't understand the
Higher orders of logic.

>
>>>
>>> then we have the basis for fully automated fact checkers that
>>> can blast holes in any and all propaganda every which way before
>>> it ever even gets started.
>>>
>>
>> You seem to have missed Tarski's definition of a "Definition of Truth".
>
> Mine works correctly and he "proved" that his does not work.
> True(L, x) ≡ (L ⊢ x) with its corresponding False(L, x) ≡ (L ⊢ ~x)
> (~True(L, LP) & ~False(L, LP)) ⊢ Invalid(L, LP)
>

Except (L ⊢ x) isn't computable, so can't be his "Defintion of Proof"

On 1/25/2024 3:56 AM, Mikko wrote:
> On 2024-01-24 16:22:53 +0000, olcott said:
>
>> On 1/24/2024 5:39 AM, Mikko wrote:
>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>
>>>> Remember, Prolog is limited to Prepositional logic, not even full
>>>> first order, and only for system with a finite domain.
>>>
>>> The basic logical system of Prolog is Horn clauses. However, it also
>>> has library predicates (like assert and not and unify_with_occurs_check)
>>> that can break the logic system if used in a wrong place.
>>>
>>> Mikko
>>>
>>
>> unify_with_occurs_check detects cycles in the evaluation of
>> expressions such as LP := ~True(LP)
>> because it can see that this specifies
>> ~True(~True(~True(~True(~True(...)))))
>
> Prolog rules also permit but do no require that every unification
> do the same. The consequence is that true conclusions about liar's
> paradox or Quine's atom are impossible to infer.
>
> Mikko
>

Not at all.

The problem is that it is conventional to encode
self-reference incorrectly.
ψ ↔ ϕ⟨ψ⟩ … The sentence ψ is of course not self-referential
in a strict sense, but mathematically it behaves like one.”
https://plato.stanford.edu/entries/self-reference/

*Because of this I created Minimal Type Theory that*
(a) Encodes self-reference correctly with :=
(b) Has a fully integrated provability operator ⊢

https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF

*Thus finally making the error of the Liar Paradox easy to see*
It is dead obvious that LP := ~True(LP) specifies
~True(~True(~True(~True(~True(...)))))
Thus proving that the Liar Paradox is not a truth bearer.

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

On 2024-01-25 16:24:09 +0000, olcott said:

> On 1/25/2024 3:56 AM, Mikko wrote:
>> On 2024-01-24 16:22:53 +0000, olcott said:
>>
>>> On 1/24/2024 5:39 AM, Mikko wrote:
>>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>>
>>>>> Remember, Prolog is limited to Prepositional logic, not even full first
>>>>> order, and only for system with a finite domain.
>>>>
>>>> The basic logical system of Prolog is Horn clauses. However, it also
>>>> has library predicates (like assert and not and unify_with_occurs_check)
>>>> that can break the logic system if used in a wrong place.
>>>>
>>>> Mikko
>>>>
>>>
>>> unify_with_occurs_check detects cycles in the evaluation of
>>> expressions such as LP := ~True(LP)
>>> because it can see that this specifies
>>> ~True(~True(~True(~True(~True(...)))))
>>
>> Prolog rules also permit but do no require that every unification
>> do the same. The consequence is that true conclusions about liar's
>> paradox or Quine's atom are impossible to infer.
>>
>> Mikko
>>
>
> Not at all.
>
> The problem is that it is conventional to encode
> self-reference incorrectly.

No, it isn't. A Prolog implementation does not need to support
a self-reference. If a self reference needs be encoded then it
must be encoded so that a Prolog imiplementation does not see
it as a self-reference. The programmer must also ensure that any
processing of a self-reference does not produce an infinite
recursion.

An encoding is not incorrect if it serves its intended purpose.

Mikko

On 1/26/2024 3:47 AM, Mikko wrote:
> On 2024-01-25 16:24:09 +0000, olcott said:
>
>> On 1/25/2024 3:56 AM, Mikko wrote:
>>> On 2024-01-24 16:22:53 +0000, olcott said:
>>>
>>>> On 1/24/2024 5:39 AM, Mikko wrote:
>>>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>>>
>>>>>> Remember, Prolog is limited to Prepositional logic, not even full
>>>>>> first order, and only for system with a finite domain.
>>>>>
>>>>> The basic logical system of Prolog is Horn clauses. However, it also
>>>>> has library predicates (like assert and not and
>>>>> unify_with_occurs_check)
>>>>> that can break the logic system if used in a wrong place.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> unify_with_occurs_check detects cycles in the evaluation of
>>>> expressions such as LP := ~True(LP)
>>>> because it can see that this specifies
>>>> ~True(~True(~True(~True(~True(...)))))
>>>
>>> Prolog rules also permit but do no require that every unification
>>> do the same. The consequence is that true conclusions about liar's
>>> paradox or Quine's atom are impossible to infer.
>>>
>>> Mikko
>>>
>>
>> Not at all.
>>
>> The problem is that it is conventional to encode
>> self-reference incorrectly.
>
> No, it isn't. A Prolog implementation does not need to support
> a self-reference. If a self reference needs be encoded then it
> must be encoded so that a Prolog imiplementation does not see
> it as a self-reference.

Not at all.
unify_with_occurs_check() was intentionally defined
to detect and reject

?- LP = not(true(LP)).
LP = not(true(LP)).

?- unify_with_occurs_check(LP, not(true(LP))).
false.

BEGIN:(Clocksin & Mellish 2003:254)
Finally, a note about how Prolog matching sometimes differs from the
unification used in Resolution. Most Prolog systems will allow you to
satisfy goals like:

equal(X, X).
?- equal(foo(Y), Y).

that is, they will allow you to match a term against an uninstantiated
subterm of itself. In this example, foo(Y) is matched against Y,
which appears within it. As a result, Y will stand for foo(Y), which is
foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
and so on. So Y ends up standing for some kind of infinite structure.
END:(Clocksin & Mellish 2003:254)

> The programmer must also ensure that any
> processing of a self-reference does not produce an infinite
> recursion.
>
> An encoding is not incorrect if it serves its intended purpose.
>
> Mikko
>

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

On 1/26/24 18:24, olcott wrote:
> On 1/26/2024 3:47 AM, Mikko wrote:
>> On 2024-01-25 16:24:09 +0000, olcott said:
>>
>>> On 1/25/2024 3:56 AM, Mikko wrote:
>>>> On 2024-01-24 16:22:53 +0000, olcott said:
>>>>
>>>>> On 1/24/2024 5:39 AM, Mikko wrote:
>>>>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>>>>
>>>>>>> Remember, Prolog is limited to Prepositional logic, not even full
>>>>>>> first order, and only for system with a finite domain.
>>>>>>
>>>>>> The basic logical system of Prolog is Horn clauses. However, it also
>>>>>> has library predicates (like assert and not and
>>>>>> unify_with_occurs_check)
>>>>>> that can break the logic system if used in a wrong place.
>>>>>>
>>>>>> Mikko
>>>>>>
>>>>>
>>>>> unify_with_occurs_check detects cycles in the evaluation of
>>>>> expressions such as LP := ~True(LP)
>>>>> because it can see that this specifies
>>>>> ~True(~True(~True(~True(~True(...)))))
>>>>
>>>> Prolog rules also permit but do no require that every unification
>>>> do the same. The consequence is that true conclusions about liar's
>>>> paradox or Quine's atom are impossible to infer.
>>>>
>>>> Mikko
>>>>
>>>
>>> Not at all.
>>>
>>> The problem is that it is conventional to encode
>>> self-reference incorrectly.
>>
>> No, it isn't. A Prolog implementation does not need to support
>> a self-reference. If a self reference needs be encoded then it
>> must be encoded so that a Prolog imiplementation does not see
>> it as a self-reference.
>
> Not at all.
> unify_with_occurs_check() was intentionally defined
> to detect and reject
>
> ?- LP = not(true(LP)).
> LP = not(true(LP)).
>
> ?- unify_with_occurs_check(LP, not(true(LP))).
> false.
>
> BEGIN:(Clocksin & Mellish 2003:254)
> Finally, a note about how Prolog matching sometimes differs from the
> unification used in Resolution. Most Prolog systems will allow you to
> satisfy goals like:
>
> equal(X, X).
> ?- equal(foo(Y), Y).
>
> that is, they will allow you to match a term against an uninstantiated
> subterm of itself. In this example, foo(Y) is matched against Y,
> which appears within it. As a result, Y will stand for foo(Y), which is
> foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
> and so on. So Y ends up standing for some kind of infinite structure.
> END:(Clocksin & Mellish 2003:254)
>
>> The programmer must also ensure that any
>> processing of a self-reference does not produce an infinite
>> recursion.
>>
>> An encoding is not incorrect if it serves its intended purpose.
>>
>> Mikko
>>
>

P ←→ ¬True(P)
is not self reference
any more than
x = 2-x
is self-reference

On 1/26/2024 2:27 PM, immibis wrote:
> On 1/26/24 18:24, olcott wrote:
>> On 1/26/2024 3:47 AM, Mikko wrote:
>>> On 2024-01-25 16:24:09 +0000, olcott said:
>>>
>>>> On 1/25/2024 3:56 AM, Mikko wrote:
>>>>> On 2024-01-24 16:22:53 +0000, olcott said:
>>>>>
>>>>>> On 1/24/2024 5:39 AM, Mikko wrote:
>>>>>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>>>>>
>>>>>>>> Remember, Prolog is limited to Prepositional logic, not even
>>>>>>>> full first order, and only for system with a finite domain.
>>>>>>>
>>>>>>> The basic logical system of Prolog is Horn clauses. However, it also
>>>>>>> has library predicates (like assert and not and
>>>>>>> unify_with_occurs_check)
>>>>>>> that can break the logic system if used in a wrong place.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> unify_with_occurs_check detects cycles in the evaluation of
>>>>>> expressions such as LP := ~True(LP)
>>>>>> because it can see that this specifies
>>>>>> ~True(~True(~True(~True(~True(...)))))
>>>>>
>>>>> Prolog rules also permit but do no require that every unification
>>>>> do the same. The consequence is that true conclusions about liar's
>>>>> paradox or Quine's atom are impossible to infer.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> Not at all.
>>>>
>>>> The problem is that it is conventional to encode
>>>> self-reference incorrectly.
>>>
>>> No, it isn't. A Prolog implementation does not need to support
>>> a self-reference. If a self reference needs be encoded then it
>>> must be encoded so that a Prolog imiplementation does not see
>>> it as a self-reference.
>>
>> Not at all.
>> unify_with_occurs_check() was intentionally defined
>> to detect and reject
>>
>> ?- LP = not(true(LP)).
>> LP = not(true(LP)).
>>
>> ?- unify_with_occurs_check(LP, not(true(LP))).
>> false.
>>
>> BEGIN:(Clocksin & Mellish 2003:254)
>> Finally, a note about how Prolog matching sometimes differs from the
>> unification used in Resolution. Most Prolog systems will allow you to
>> satisfy goals like:
>>
>> equal(X, X).
>> ?- equal(foo(Y), Y).
>>
>> that is, they will allow you to match a term against an uninstantiated
>> subterm of itself. In this example, foo(Y) is matched against Y,
>> which appears within it. As a result, Y will stand for foo(Y), which is
>> foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
>> and so on. So Y ends up standing for some kind of infinite structure.
>> END:(Clocksin & Mellish 2003:254)
>>
>>> The programmer must also ensure that any
>>> processing of a self-reference does not produce an infinite
>>> recursion.
>>>
>>> An encoding is not incorrect if it serves its intended purpose.
>>>
>>> Mikko
>>>
>>
>
> P ←→ ¬True(P)
> is not self reference
> any more than
> x = 2-x
> is self-reference

I have mentioned that it is been a long standing
convention to encode self-reference incorrectly
dozens of times now...

ψ ↔ ϕ⟨ψ⟩ … The sentence ψ is of course not self-referential
in a strict sense, but mathematically it behaves like one.”
https://plato.stanford.edu/entries/self-reference/

P ←→ ¬True(P) is the way that self-reference is encoded
incorrectly as shown above.

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

On 1/27/2024 4:30 AM, Mikko wrote:
> On 2024-01-26 17:24:34 +0000, olcott said:
>
>> On 1/26/2024 3:47 AM, Mikko wrote:
>>> On 2024-01-25 16:24:09 +0000, olcott said:
>>>
>>>> On 1/25/2024 3:56 AM, Mikko wrote:
>>>>> On 2024-01-24 16:22:53 +0000, olcott said:
>>>>>
>>>>>> On 1/24/2024 5:39 AM, Mikko wrote:
>>>>>>> On 2024-01-24 03:51:39 +0000, Richard Damon said:
>>>>>>>
>>>>>>>> Remember, Prolog is limited to Prepositional logic, not even
>>>>>>>> full first order, and only for system with a finite domain.
>>>>>>>
>>>>>>> The basic logical system of Prolog is Horn clauses. However, it also
>>>>>>> has library predicates (like assert and not and
>>>>>>> unify_with_occurs_check)
>>>>>>> that can break the logic system if used in a wrong place.
>>>>>>>
>>>>>>> Mikko
>>>>>>>
>>>>>>
>>>>>> unify_with_occurs_check detects cycles in the evaluation of
>>>>>> expressions such as LP := ~True(LP)
>>>>>> because it can see that this specifies
>>>>>> ~True(~True(~True(~True(~True(...)))))
>>>>>
>>>>> Prolog rules also permit but do no require that every unification
>>>>> do the same. The consequence is that true conclusions about liar's
>>>>> paradox or Quine's atom are impossible to infer.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> Not at all.
>>>>
>>>> The problem is that it is conventional to encode
>>>> self-reference incorrectly.
>>>
>>> No, it isn't. A Prolog implementation does not need to support
>>> a self-reference. If a self reference needs be encoded then it
>>> must be encoded so that a Prolog imiplementation does not see
>>> it as a self-reference.
>>
>> Not at all.
>> unify_with_occurs_check() was intentionally defined
>> to detect and reject
>>
>> ?- LP = not(true(LP)).
>> LP = not(true(LP)).
>
> And also X = a(X) and X = [X] as well as more complicated
> examples of the same. But the plain = is allowed to detect
> and reject them, too. There is no promice that such structures
> can be created and used for any purpose although in some
> conforming implementations that may be possible.
>
>> ?- unify_with_occurs_check(LP, not(true(LP))).
>> false.
>>
>> BEGIN:(Clocksin & Mellish 2003:254)
>> Finally, a note about how Prolog matching sometimes differs from the
>> unification used in Resolution. Most Prolog systems will allow you to
>> satisfy goals like:
>>
>> equal(X, X).
>> ?- equal(foo(Y), Y).
>
> According to Prolog rules, Both "yes" or "no" are permitted answers.
>
> Mikko
>

BEGIN:(Clocksin & Mellish 2003:254)
Finally, a note about how Prolog matching sometimes differs from the
unification used in Resolution. Most Prolog systems will allow you to
satisfy goals like:

equal(X, X).
?- equal(foo(Y), Y).

that is, they will allow you to match a term against an uninstantiated
subterm of itself. In this example, foo(Y) is matched against Y,
which appears within it. As a result, Y will stand for foo(Y), which is
foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))),
and so on. So Y ends up standing for some kind of infinite structure.
END:(Clocksin & Mellish 2003:254)

*Not for infinite terms, they abnormally terminate*

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