Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #27055 > unrolled thread

HALT has to solve NON_HALTING TMs but has to HALT itself!

Started byGraham Cooper <grahamcooper7@gmail.com>
First post2020-12-15 07:19 -0800
Last post2020-12-16 00:15 +0000
Articles 20 — 8 participants

Back to article view | Back to comp.theory


Contents

  HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-15 07:19 -0800
    Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2020-12-15 20:15 +0000
    Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-15 20:44 +0000
      Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-15 14:56 -0800
        Re: HALT has to solve NON_HALTING TMs but has to HALT itself! "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-16 17:04 -0800
          Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-17 01:40 -0800
            Re: HALT has to solve NON_HALTING TMs but has to HALT itself! "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-17 12:02 -0800
              Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-17 19:58 -0800
                Re: HALT has to solve NON_HALTING TMs but has to HALT itself! "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-17 21:39 -0800
                  Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-17 22:18 -0800
                    Re: HALT has to solve NON_HALTING TMs but has to HALT itself! "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2020-12-17 23:23 -0800
                      Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-17 23:30 -0800
    Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Jeff Barnett <jbb@notatt.com> - 2020-12-15 15:00 -0700
      Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Kaz Kylheku <563-365-8930@kylheku.com> - 2020-12-15 22:13 +0000
        Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-15 23:12 +0000
          Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Graham Cooper <grahamcooper7@gmail.com> - 2020-12-15 15:23 -0800
            Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-16 00:39 +0000
          Re: HALT has to solve NON_HALTING TMs but has to HALT itself! olcott <NoOne@NoWhere.com> - 2020-12-15 17:26 -0600
            Re: HALT has to solve NON_HALTING TMs but has to HALT itself! "dklei...@gmail.com" <dkleinecke@gmail.com> - 2020-12-15 16:01 -0800
            Re: HALT has to solve NON_HALTING TMs but has to HALT itself! Ben Bacarisse <ben.usenet@bsb.me.uk> - 2020-12-16 00:15 +0000

#27055 — HALT has to solve NON_HALTING TMs but has to HALT itself!

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-15 07:19 -0800
SubjectHALT has to solve NON_HALTING TMs but has to HALT itself!
Message-ID<9d72637f-0382-4596-bbb4-36fbde2f2355n@googlegroups.com>
Basically, given a SMALLER CLASS OF COMPUTATION

can it solve a LARGER CLASS of computation ??



By the halting proof the answer is NO

but what if HALT() didnt have to halt itself?


Then it belongs to the SAME CLASS OF COMPUTATION
as programs it has to DECIDE

and the HALTING PROBLEM IS SOLVED!



BUT BUT ...  it doesnt always give an answer!!

Doesn't matter, if halt hangs on a spurious program test
then that program hangs too so we KNOW its halt value
with incremental processing time!

So the WHOLE WORLD GOT IT WRONG!
CHAITANS OMEGA is incrementally computable!

HALT( P I ) --> VALUE
HALT( P I ) --> 0 FALSE
HALT( P I ) --> DOESNT HALT

IS A LARGER CLASS OF COMPUTATION

WHICH SOLVES THE HALTING PROBLEM!

[toc] | [next] | [standalone]


#27068

FromMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
Date2020-12-15 20:15 +0000
Message-ID<_P8CH.131628$9J69.126007@fx21.ams4>
In reply to#27055
On 15/12/2020 15:19, Graham Cooper wrote:
> Basically, given a SMALLER CLASS OF COMPUTATION
> 
> can it solve a LARGER CLASS of computation ??
> 
> 
> 
> By the halting proof the answer is NO
> 
> but what if HALT() didnt have to halt itself?
> 
> 
> Then it belongs to the SAME CLASS OF COMPUTATION
> as programs it has to DECIDE
> 
> and the HALTING PROBLEM IS SOLVED!
> 
> 
> 
> BUT BUT ...  it doesnt always give an answer!!
> 
> Doesn't matter, if halt hangs on a spurious program test
> then that program hangs too so we KNOW its halt value
> with incremental processing time!

Define "spurious" and "hangs".

We are more interested in programs that are given *any* input (including "valid" input) and that infinitely loop and/or recurse (with branching logic) without actually "hanging".

> 
> So the WHOLE WORLD GOT IT WRONG!
> CHAITANS OMEGA is incrementally computable!
> 
> HALT( P I ) --> VALUE
> HALT( P I ) --> 0 FALSE
> HALT( P I ) --> DOESNT HALT
> 
> IS A LARGER CLASS OF COMPUTATION
> 
> WHICH SOLVES THE HALTING PROBLEM!

Nonsense.

/Flibble

-- 
😎

[toc] | [prev] | [next] | [standalone]


#27069

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-15 20:44 +0000
Message-ID<20201215123748.481@kylheku.com>
In reply to#27055
On 2020-12-15, Graham Cooper <grahamcooper7@gmail.com> wrote:
> Doesn't matter, if halt hangs on a spurious program test
> then that program hangs too so we KNOW its halt value
> with incremental processing time!

You can't externally tell the difference between a machine that truly
hangs forever, and a machine that terminates, but has not yet done so:
it just requires more time and steps.

Only using internal reasoning---by observing some internal behavior, or
deducing it from analyzing the code---can you tell that something hangs
forever. Like, "aha, here is a trivial endless loop, which is provably
reached from the starting point in no more than 300 steps".

This is the same as the halting problem.  The halting theorem says that
there can be no universal algorithm for deciding, in a finite number
of steps, whether a given machine will halt.

Thus when you say "if halt hangs ... that program hals too ... so we
KNOW its halt value", you are necessarily taking the perspective that we
have a magic oracle that allows us to know.

We do not have an algorithm (Turing computation) to be able to KNOW;
not for any arbitary machine.

[toc] | [prev] | [next] | [standalone]


#27076

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-15 14:56 -0800
Message-ID<f7ac3ca5-ec4b-4171-aabb-b94eff068d3fn@googlegroups.com>
In reply to#27069
On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote:
> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote: 
> > Doesn't matter, if halt hangs on a spurious program test 
> > then that program hangs too so we KNOW its halt value 
> > with incremental processing time!
> You can't externally tell the difference between a machine that truly 
> hangs forever, and a machine that terminates, but has not yet done so: 
> it just requires more time and steps. 
> 
> Only using internal reasoning---by observing some internal behavior, or 
> deducing it from analyzing the code---can you tell that something hangs 
> forever. Like, "aha, here is a trivial endless loop, which is provably 
> reached from the starting point in no more than 300 steps". 
> 
> This is the same as the halting problem. The halting theorem says that 
> there can be no universal algorithm for deciding, in a finite number 
> of steps, whether a given machine will halt. 

Which is just : GIVEN A SMALLER CLASS OF COMPUTATION

CAN YOU DECIDE A LARGER CLASS OF COMPUTATION

A self inconsistent paradox of specification

> 
> Thus when you say "if halt hangs ... that program hals too ... so we 
> KNOW its halt value", you are necessarily taking the perspective that we 
> have a magic oracle that allows us to know. 


WRONG!   you dont need an ORACLE

There is a difference between

10 steps - halt(  spuriousProgram ) = HANG
100 steps - halt(  spuriousProgram ) = HANG
1000 steps - halt(  spuriousProgram ) = HANG
10000 steps - halt(  spuriousProgram ) = HANG

10 steps - halt(  longProgram ) = HANG
100 steps - halt(  longProgram ) = HANG
1000 steps - halt(  longProgram ) = HANG
10000 steps - halt(  longProgram ) = OUTPUTS VALUE


Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER!



> 
> We do not have an algorithm (Turing computation) to be able to KNOW; 
> not for any arbitary machine.

...for a finite number of steps.

But its just a POORLY SPECIFIED SPECIFICATION

You can go AROUND AND AROUND in semantic discussion
OR you can use a RUBRIC for the halting problem.

Is CHAITANS OMEGA UNCOMPUTABLE


10 processing steps - CO = 0.???1????01????...
100 processing steps - CO = 0.???11??0001????...
1000 processing steps - CO = 0.?1111?00001????...
10000 processing steps - CO = 0.11111?0000111??...


LOOKS COMPUTABLE TO ME!

At the Infinite processing time LIMIT - CO is fully computable

Any remaining ? can be determined to be 0's

[toc] | [prev] | [next] | [standalone]


#27121

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2020-12-16 17:04 -0800
Message-ID<rrear4$4qt$2@gioia.aioe.org>
In reply to#27076
On 12/15/2020 2:56 PM, Graham Cooper wrote:
> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote:
>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote:
>>> Doesn't matter, if halt hangs on a spurious program test
>>> then that program hangs too so we KNOW its halt value
>>> with incremental processing time!
>> You can't externally tell the difference between a machine that truly
>> hangs forever, and a machine that terminates, but has not yet done so:
>> it just requires more time and steps.
>>
>> Only using internal reasoning---by observing some internal behavior, or
>> deducing it from analyzing the code---can you tell that something hangs
>> forever. Like, "aha, here is a trivial endless loop, which is provably
>> reached from the starting point in no more than 300 steps".
>>
>> This is the same as the halting problem. The halting theorem says that
>> there can be no universal algorithm for deciding, in a finite number
>> of steps, whether a given machine will halt.
> 
> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION
> 
> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION
> 
> A self inconsistent paradox of specification
> 
>>
>> Thus when you say "if halt hangs ... that program hals too ... so we
>> KNOW its halt value", you are necessarily taking the perspective that we
>> have a magic oracle that allows us to know.
> 
> 
> WRONG!   you dont need an ORACLE
> 
> There is a difference between
> 
> 10 steps - halt(  spuriousProgram ) = HANG
> 100 steps - halt(  spuriousProgram ) = HANG
> 1000 steps - halt(  spuriousProgram ) = HANG
> 10000 steps - halt(  spuriousProgram ) = HANG
> 
> 10 steps - halt(  longProgram ) = HANG
> 100 steps - halt(  longProgram ) = HANG
> 1000 steps - halt(  longProgram ) = HANG
> 10000 steps - halt(  longProgram ) = OUTPUTS VALUE
> 
> 
> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER!
> 
> 
> 
>>
>> We do not have an algorithm (Turing computation) to be able to KNOW;
>> not for any arbitary machine.
> 
> ...for a finite number of steps.
> 
> But its just a POORLY SPECIFIED SPECIFICATION
> 
> You can go AROUND AND AROUND in semantic discussion
> OR you can use a RUBRIC for the halting problem.
> 
> Is CHAITANS OMEGA UNCOMPUTABLE
> 
> 
> 10 processing steps - CO = 0.???1????01????...
> 100 processing steps - CO = 0.???11??0001????...
> 1000 processing steps - CO = 0.?1111?00001????...
> 10000 processing steps - CO = 0.11111?0000111??...
> 
> 
> LOOKS COMPUTABLE TO ME!
> 
> At the Infinite processing time LIMIT - CO is fully computable
> 
> Any remaining ? can be determined to be 0's
> 

What is an infinite processing time limit?

[toc] | [prev] | [next] | [standalone]


#27141

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-17 01:40 -0800
Message-ID<4b36145f-6b69-450c-b43b-30245f18c119n@googlegroups.com>
In reply to#27121
On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote:
> On 12/15/2020 2:56 PM, Graham Cooper wrote: 
> > On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote: 
> >> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote: 
> >>> Doesn't matter, if halt hangs on a spurious program test 
> >>> then that program hangs too so we KNOW its halt value 
> >>> with incremental processing time! 
> >> You can't externally tell the difference between a machine that truly 
> >> hangs forever, and a machine that terminates, but has not yet done so: 
> >> it just requires more time and steps. 
> >> 
> >> Only using internal reasoning---by observing some internal behavior, or 
> >> deducing it from analyzing the code---can you tell that something hangs 
> >> forever. Like, "aha, here is a trivial endless loop, which is provably 
> >> reached from the starting point in no more than 300 steps". 
> >> 
> >> This is the same as the halting problem. The halting theorem says that 
> >> there can be no universal algorithm for deciding, in a finite number 
> >> of steps, whether a given machine will halt. 
> > 
> > Which is just : GIVEN A SMALLER CLASS OF COMPUTATION 
> > 
> > CAN YOU DECIDE A LARGER CLASS OF COMPUTATION 
> > 
> > A self inconsistent paradox of specification 
> > 
> >> 
> >> Thus when you say "if halt hangs ... that program hals too ... so we 
> >> KNOW its halt value", you are necessarily taking the perspective that we 
> >> have a magic oracle that allows us to know. 
> > 
> > 
> > WRONG! you dont need an ORACLE 
> > 
> > There is a difference between 
> > 
> > 10 steps - halt( spuriousProgram ) = HANG 
> > 100 steps - halt( spuriousProgram ) = HANG 
> > 1000 steps - halt( spuriousProgram ) = HANG 
> > 10000 steps - halt( spuriousProgram ) = HANG 
> > 
> > 10 steps - halt( longProgram ) = HANG 
> > 100 steps - halt( longProgram ) = HANG 
> > 1000 steps - halt( longProgram ) = HANG 
> > 10000 steps - halt( longProgram ) = OUTPUTS VALUE 
> > 
> > 
> > Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER! 
> > 
> > 
> > 
> >> 
> >> We do not have an algorithm (Turing computation) to be able to KNOW; 
> >> not for any arbitary machine. 
> > 
> > ...for a finite number of steps. 
> > 
> > But its just a POORLY SPECIFIED SPECIFICATION 
> > 
> > You can go AROUND AND AROUND in semantic discussion 
> > OR you can use a RUBRIC for the halting problem. 
> > 
> > Is CHAITANS OMEGA UNCOMPUTABLE 
> > 
> > 
> > 10 processing steps - CO = 0.???1????01????... 
> > 100 processing steps - CO = 0.???11??0001????... 
> > 1000 processing steps - CO = 0.?1111?00001????... 
> > 10000 processing steps - CO = 0.11111?0000111??... 
> > 
> > 
> > LOOKS COMPUTABLE TO ME! 
> > 
> > At the Infinite processing time LIMIT - CO is fully computable 
> > 
> > Any remaining ? can be determined to be 0's 
> >
> What is an infinite processing time limit?


Its just a hypothetical limit like 1/n as n-->o = INFINITY

there are 2 forms of COMPUTABLE, halting and incremental

its silly to say Chaitans Omega is uncomputable when all the digits are tractable


 10 processing steps - CO = 0.???1????01????... 
 100 processing steps - CO = 0.???11??0001????... 
 1000 processing steps - CO = 0.?1111?00001????... 
 10000 processing steps - CO = 0.11111?0000111??... 

Obviously CO is not IMPOSSIBLE to compute all the digits hypothetically

[toc] | [prev] | [next] | [standalone]


#27181

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2020-12-17 12:02 -0800
Message-ID<rrgdgo$33k$3@gioia.aioe.org>
In reply to#27141
On 12/17/2020 1:40 AM, Graham Cooper wrote:
> On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote:
>> On 12/15/2020 2:56 PM, Graham Cooper wrote:
>>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote:
>>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote:
>>>>> Doesn't matter, if halt hangs on a spurious program test
>>>>> then that program hangs too so we KNOW its halt value
>>>>> with incremental processing time!
>>>> You can't externally tell the difference between a machine that truly
>>>> hangs forever, and a machine that terminates, but has not yet done so:
>>>> it just requires more time and steps.
>>>>
>>>> Only using internal reasoning---by observing some internal behavior, or
>>>> deducing it from analyzing the code---can you tell that something hangs
>>>> forever. Like, "aha, here is a trivial endless loop, which is provably
>>>> reached from the starting point in no more than 300 steps".
>>>>
>>>> This is the same as the halting problem. The halting theorem says that
>>>> there can be no universal algorithm for deciding, in a finite number
>>>> of steps, whether a given machine will halt.
>>>
>>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION
>>>
>>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION
>>>
>>> A self inconsistent paradox of specification
>>>
>>>>
>>>> Thus when you say "if halt hangs ... that program hals too ... so we
>>>> KNOW its halt value", you are necessarily taking the perspective that we
>>>> have a magic oracle that allows us to know.
>>>
>>>
>>> WRONG! you dont need an ORACLE
>>>
>>> There is a difference between
>>>
>>> 10 steps - halt( spuriousProgram ) = HANG
>>> 100 steps - halt( spuriousProgram ) = HANG
>>> 1000 steps - halt( spuriousProgram ) = HANG
>>> 10000 steps - halt( spuriousProgram ) = HANG
>>>
>>> 10 steps - halt( longProgram ) = HANG
>>> 100 steps - halt( longProgram ) = HANG
>>> 1000 steps - halt( longProgram ) = HANG
>>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE
>>>
>>>
>>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER!
>>>
>>>
>>>
>>>>
>>>> We do not have an algorithm (Turing computation) to be able to KNOW;
>>>> not for any arbitary machine.
>>>
>>> ...for a finite number of steps.
>>>
>>> But its just a POORLY SPECIFIED SPECIFICATION
>>>
>>> You can go AROUND AND AROUND in semantic discussion
>>> OR you can use a RUBRIC for the halting problem.
>>>
>>> Is CHAITANS OMEGA UNCOMPUTABLE
>>>
>>>
>>> 10 processing steps - CO = 0.???1????01????...
>>> 100 processing steps - CO = 0.???11??0001????...
>>> 1000 processing steps - CO = 0.?1111?00001????...
>>> 10000 processing steps - CO = 0.11111?0000111??...
>>>
>>>
>>> LOOKS COMPUTABLE TO ME!
>>>
>>> At the Infinite processing time LIMIT - CO is fully computable
>>>
>>> Any remaining ? can be determined to be 0's
>>>
>> What is an infinite processing time limit?
> 
> 
> Its just a hypothetical limit like 1/n as n-->o = INFINITY

I am wondering if you tried to see if a server work loop, think 
threadpool, would halt... Say its been running for several years and 
going strong.


> 
> there are 2 forms of COMPUTABLE, halting and incremental
> 
> its silly to say Chaitans Omega is uncomputable when all the digits are tractable
> 
> 
>   10 processing steps - CO = 0.???1????01????...
>   100 processing steps - CO = 0.???11??0001????...
>   1000 processing steps - CO = 0.?1111?00001????...
>   10000 processing steps - CO = 0.11111?0000111??...
> 
> Obviously CO is not IMPOSSIBLE to compute all the digits hypothetically
> 
> 

[toc] | [prev] | [next] | [standalone]


#27217

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-17 19:58 -0800
Message-ID<846b42c8-7d24-4aec-8b3e-9ede17d15de1n@googlegroups.com>
In reply to#27181
On Friday, December 18, 2020 at 7:02:37 AM UTC+11, Chris M. Thomasson wrote:
> On 12/17/2020 1:40 AM, Graham Cooper wrote: 
> > On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote: 
> >> On 12/15/2020 2:56 PM, Graham Cooper wrote: 
> >>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote: 
> >>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote: 
> >>>>> Doesn't matter, if halt hangs on a spurious program test 
> >>>>> then that program hangs too so we KNOW its halt value 
> >>>>> with incremental processing time! 
> >>>> You can't externally tell the difference between a machine that truly 
> >>>> hangs forever, and a machine that terminates, but has not yet done so: 
> >>>> it just requires more time and steps. 
> >>>> 
> >>>> Only using internal reasoning---by observing some internal behavior, or 
> >>>> deducing it from analyzing the code---can you tell that something hangs 
> >>>> forever. Like, "aha, here is a trivial endless loop, which is provably 
> >>>> reached from the starting point in no more than 300 steps". 
> >>>> 
> >>>> This is the same as the halting problem. The halting theorem says that 
> >>>> there can be no universal algorithm for deciding, in a finite number 
> >>>> of steps, whether a given machine will halt. 
> >>> 
> >>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION 
> >>> 
> >>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION 
> >>> 
> >>> A self inconsistent paradox of specification 
> >>> 
> >>>> 
> >>>> Thus when you say "if halt hangs ... that program hals too ... so we 
> >>>> KNOW its halt value", you are necessarily taking the perspective that we 
> >>>> have a magic oracle that allows us to know. 
> >>> 
> >>> 
> >>> WRONG! you dont need an ORACLE 
> >>> 
> >>> There is a difference between 
> >>> 
> >>> 10 steps - halt( spuriousProgram ) = HANG 
> >>> 100 steps - halt( spuriousProgram ) = HANG 
> >>> 1000 steps - halt( spuriousProgram ) = HANG 
> >>> 10000 steps - halt( spuriousProgram ) = HANG 
> >>> 
> >>> 10 steps - halt( longProgram ) = HANG 
> >>> 100 steps - halt( longProgram ) = HANG 
> >>> 1000 steps - halt( longProgram ) = HANG 
> >>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE 
> >>> 
> >>> 
> >>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER! 
> >>> 
> >>> 
> >>> 
> >>>> 
> >>>> We do not have an algorithm (Turing computation) to be able to KNOW; 
> >>>> not for any arbitary machine. 
> >>> 
> >>> ...for a finite number of steps. 
> >>> 
> >>> But its just a POORLY SPECIFIED SPECIFICATION 
> >>> 
> >>> You can go AROUND AND AROUND in semantic discussion 
> >>> OR you can use a RUBRIC for the halting problem. 
> >>> 
> >>> Is CHAITANS OMEGA UNCOMPUTABLE 
> >>> 
> >>> 
> >>> 10 processing steps - CO = 0.???1????01????... 
> >>> 100 processing steps - CO = 0.???11??0001????... 
> >>> 1000 processing steps - CO = 0.?1111?00001????... 
> >>> 10000 processing steps - CO = 0.11111?0000111??... 
> >>> 
> >>> 
> >>> LOOKS COMPUTABLE TO ME! 
> >>> 
> >>> At the Infinite processing time LIMIT - CO is fully computable 
> >>> 
> >>> Any remaining ? can be determined to be 0's 
> >>> 
> >> What is an infinite processing time limit? 
> > 
> > 
> > Its just a hypothetical limit like 1/n as n-->o = INFINITY
> I am wondering if you tried to see if a server work loop, think 
> threadpool, would halt... Say its been running for several years and 
> going strong

As long as the programs on the server DONT include an INF LOOP CHECKER
then there's nothing stopping that.




[toc] | [prev] | [next] | [standalone]


#27219

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2020-12-17 21:39 -0800
Message-ID<rrhfbf$1nlm$1@gioia.aioe.org>
In reply to#27217
On 12/17/2020 7:58 PM, Graham Cooper wrote:
> On Friday, December 18, 2020 at 7:02:37 AM UTC+11, Chris M. Thomasson wrote:
>> On 12/17/2020 1:40 AM, Graham Cooper wrote:
>>> On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote:
>>>> On 12/15/2020 2:56 PM, Graham Cooper wrote:
>>>>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote:
>>>>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote:
>>>>>>> Doesn't matter, if halt hangs on a spurious program test
>>>>>>> then that program hangs too so we KNOW its halt value
>>>>>>> with incremental processing time!
>>>>>> You can't externally tell the difference between a machine that truly
>>>>>> hangs forever, and a machine that terminates, but has not yet done so:
>>>>>> it just requires more time and steps.
>>>>>>
>>>>>> Only using internal reasoning---by observing some internal behavior, or
>>>>>> deducing it from analyzing the code---can you tell that something hangs
>>>>>> forever. Like, "aha, here is a trivial endless loop, which is provably
>>>>>> reached from the starting point in no more than 300 steps".
>>>>>>
>>>>>> This is the same as the halting problem. The halting theorem says that
>>>>>> there can be no universal algorithm for deciding, in a finite number
>>>>>> of steps, whether a given machine will halt.
>>>>>
>>>>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION
>>>>>
>>>>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION
>>>>>
>>>>> A self inconsistent paradox of specification
>>>>>
>>>>>>
>>>>>> Thus when you say "if halt hangs ... that program hals too ... so we
>>>>>> KNOW its halt value", you are necessarily taking the perspective that we
>>>>>> have a magic oracle that allows us to know.
>>>>>
>>>>>
>>>>> WRONG! you dont need an ORACLE
>>>>>
>>>>> There is a difference between
>>>>>
>>>>> 10 steps - halt( spuriousProgram ) = HANG
>>>>> 100 steps - halt( spuriousProgram ) = HANG
>>>>> 1000 steps - halt( spuriousProgram ) = HANG
>>>>> 10000 steps - halt( spuriousProgram ) = HANG
>>>>>
>>>>> 10 steps - halt( longProgram ) = HANG
>>>>> 100 steps - halt( longProgram ) = HANG
>>>>> 1000 steps - halt( longProgram ) = HANG
>>>>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE
>>>>>
>>>>>
>>>>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER!
>>>>>
>>>>>
>>>>>
>>>>>>
>>>>>> We do not have an algorithm (Turing computation) to be able to KNOW;
>>>>>> not for any arbitary machine.
>>>>>
>>>>> ...for a finite number of steps.
>>>>>
>>>>> But its just a POORLY SPECIFIED SPECIFICATION
>>>>>
>>>>> You can go AROUND AND AROUND in semantic discussion
>>>>> OR you can use a RUBRIC for the halting problem.
>>>>>
>>>>> Is CHAITANS OMEGA UNCOMPUTABLE
>>>>>
>>>>>
>>>>> 10 processing steps - CO = 0.???1????01????...
>>>>> 100 processing steps - CO = 0.???11??0001????...
>>>>> 1000 processing steps - CO = 0.?1111?00001????...
>>>>> 10000 processing steps - CO = 0.11111?0000111??...
>>>>>
>>>>>
>>>>> LOOKS COMPUTABLE TO ME!
>>>>>
>>>>> At the Infinite processing time LIMIT - CO is fully computable
>>>>>
>>>>> Any remaining ? can be determined to be 0's
>>>>>
>>>> What is an infinite processing time limit?
>>>
>>>
>>> Its just a hypothetical limit like 1/n as n-->o = INFINITY
>> I am wondering if you tried to see if a server work loop, think
>> threadpool, would halt... Say its been running for several years and
>> going strong
> 
> As long as the programs on the server DONT include an INF LOOP CHECKER
> then there's nothing stopping that.

The main server loop never dies, unless artificially directed to do so.

[toc] | [prev] | [next] | [standalone]


#27220

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-17 22:18 -0800
Message-ID<77a5ae0c-7ecf-4375-9cb5-908ac1eb7fa6n@googlegroups.com>
In reply to#27219
On Friday, December 18, 2020 at 4:40:04 PM UTC+11, Chris M. Thomasson wrote:
> On 12/17/2020 7:58 PM, Graham Cooper wrote: 
> > On Friday, December 18, 2020 at 7:02:37 AM UTC+11, Chris M. Thomasson wrote: 
> >> On 12/17/2020 1:40 AM, Graham Cooper wrote: 
> >>> On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote: 
> >>>> On 12/15/2020 2:56 PM, Graham Cooper wrote: 
> >>>>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote: 
> >>>>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote: 
> >>>>>>> Doesn't matter, if halt hangs on a spurious program test 
> >>>>>>> then that program hangs too so we KNOW its halt value 
> >>>>>>> with incremental processing time! 
> >>>>>> You can't externally tell the difference between a machine that truly 
> >>>>>> hangs forever, and a machine that terminates, but has not yet done so: 
> >>>>>> it just requires more time and steps. 
> >>>>>> 
> >>>>>> Only using internal reasoning---by observing some internal behavior, or 
> >>>>>> deducing it from analyzing the code---can you tell that something hangs 
> >>>>>> forever. Like, "aha, here is a trivial endless loop, which is provably 
> >>>>>> reached from the starting point in no more than 300 steps". 
> >>>>>> 
> >>>>>> This is the same as the halting problem. The halting theorem says that 
> >>>>>> there can be no universal algorithm for deciding, in a finite number 
> >>>>>> of steps, whether a given machine will halt. 
> >>>>> 
> >>>>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION 
> >>>>> 
> >>>>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION 
> >>>>> 
> >>>>> A self inconsistent paradox of specification 
> >>>>> 
> >>>>>> 
> >>>>>> Thus when you say "if halt hangs ... that program hals too ... so we 
> >>>>>> KNOW its halt value", you are necessarily taking the perspective that we 
> >>>>>> have a magic oracle that allows us to know. 
> >>>>> 
> >>>>> 
> >>>>> WRONG! you dont need an ORACLE 
> >>>>> 
> >>>>> There is a difference between 
> >>>>> 
> >>>>> 10 steps - halt( spuriousProgram ) = HANG 
> >>>>> 100 steps - halt( spuriousProgram ) = HANG 
> >>>>> 1000 steps - halt( spuriousProgram ) = HANG 
> >>>>> 10000 steps - halt( spuriousProgram ) = HANG 
> >>>>> 
> >>>>> 10 steps - halt( longProgram ) = HANG 
> >>>>> 100 steps - halt( longProgram ) = HANG 
> >>>>> 1000 steps - halt( longProgram ) = HANG 
> >>>>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE 
> >>>>> 
> >>>>> 
> >>>>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER! 
> >>>>> 
> >>>>> 
> >>>>> 
> >>>>>> 
> >>>>>> We do not have an algorithm (Turing computation) to be able to KNOW; 
> >>>>>> not for any arbitary machine. 
> >>>>> 
> >>>>> ...for a finite number of steps. 
> >>>>> 
> >>>>> But its just a POORLY SPECIFIED SPECIFICATION 
> >>>>> 
> >>>>> You can go AROUND AND AROUND in semantic discussion 
> >>>>> OR you can use a RUBRIC for the halting problem. 
> >>>>> 
> >>>>> Is CHAITANS OMEGA UNCOMPUTABLE 
> >>>>> 
> >>>>> 
> >>>>> 10 processing steps - CO = 0.???1????01????... 
> >>>>> 100 processing steps - CO = 0.???11??0001????... 
> >>>>> 1000 processing steps - CO = 0.?1111?00001????... 
> >>>>> 10000 processing steps - CO = 0.11111?0000111??... 
> >>>>> 
> >>>>> 
> >>>>> LOOKS COMPUTABLE TO ME! 
> >>>>> 
> >>>>> At the Infinite processing time LIMIT - CO is fully computable 
> >>>>> 
> >>>>> Any remaining ? can be determined to be 0's 
> >>>>> 
> >>>> What is an infinite processing time limit? 
> >>> 
> >>> 
> >>> Its just a hypothetical limit like 1/n as n-->o = INFINITY 
> >> I am wondering if you tried to see if a server work loop, think 
> >> threadpool, would halt... Say its been running for several years and 
> >> going strong 
> > 
> > As long as the programs on the server DONT include an INF LOOP CHECKER 
> > then there's nothing stopping that.
> The main server loop never dies, unless artificially directed to do so.

Right!  Technically it doesnt compute anything.

Computable is merely defined that way, a program processes an input, writes an output and halts.

It ties in with FUNCTION theory that way.

a series of outputs is not a pure function.

To tie function theory and non-terminating code (input streams) together you require some extra functions 

INPUT = <ABCD...>

F' = f(A)
F'= f(AB)
F'' = f(ABC)
...


so what you get is  

mapfun( f ,  < <A> <AB> <ABC> <ABCD> ... > )

to process an infinite stream in pure functions




[toc] | [prev] | [next] | [standalone]


#27221

From"Chris M. Thomasson" <chris.m.thomasson.1@gmail.com>
Date2020-12-17 23:23 -0800
Message-ID<rrhlde$1g3o$1@gioia.aioe.org>
In reply to#27220
On 12/17/2020 10:18 PM, Graham Cooper wrote:
> On Friday, December 18, 2020 at 4:40:04 PM UTC+11, Chris M. Thomasson wrote:
>> On 12/17/2020 7:58 PM, Graham Cooper wrote:
>>> On Friday, December 18, 2020 at 7:02:37 AM UTC+11, Chris M. Thomasson wrote:
>>>> On 12/17/2020 1:40 AM, Graham Cooper wrote:
>>>>> On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote:
>>>>>> On 12/15/2020 2:56 PM, Graham Cooper wrote:
>>>>>>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote:
>>>>>>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote:
>>>>>>>>> Doesn't matter, if halt hangs on a spurious program test
>>>>>>>>> then that program hangs too so we KNOW its halt value
>>>>>>>>> with incremental processing time!
>>>>>>>> You can't externally tell the difference between a machine that truly
>>>>>>>> hangs forever, and a machine that terminates, but has not yet done so:
>>>>>>>> it just requires more time and steps.
>>>>>>>>
>>>>>>>> Only using internal reasoning---by observing some internal behavior, or
>>>>>>>> deducing it from analyzing the code---can you tell that something hangs
>>>>>>>> forever. Like, "aha, here is a trivial endless loop, which is provably
>>>>>>>> reached from the starting point in no more than 300 steps".
>>>>>>>>
>>>>>>>> This is the same as the halting problem. The halting theorem says that
>>>>>>>> there can be no universal algorithm for deciding, in a finite number
>>>>>>>> of steps, whether a given machine will halt.
>>>>>>>
>>>>>>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION
>>>>>>>
>>>>>>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION
>>>>>>>
>>>>>>> A self inconsistent paradox of specification
>>>>>>>
>>>>>>>>
>>>>>>>> Thus when you say "if halt hangs ... that program hals too ... so we
>>>>>>>> KNOW its halt value", you are necessarily taking the perspective that we
>>>>>>>> have a magic oracle that allows us to know.
>>>>>>>
>>>>>>>
>>>>>>> WRONG! you dont need an ORACLE
>>>>>>>
>>>>>>> There is a difference between
>>>>>>>
>>>>>>> 10 steps - halt( spuriousProgram ) = HANG
>>>>>>> 100 steps - halt( spuriousProgram ) = HANG
>>>>>>> 1000 steps - halt( spuriousProgram ) = HANG
>>>>>>> 10000 steps - halt( spuriousProgram ) = HANG
>>>>>>>
>>>>>>> 10 steps - halt( longProgram ) = HANG
>>>>>>> 100 steps - halt( longProgram ) = HANG
>>>>>>> 1000 steps - halt( longProgram ) = HANG
>>>>>>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE
>>>>>>>
>>>>>>>
>>>>>>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER!
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> We do not have an algorithm (Turing computation) to be able to KNOW;
>>>>>>>> not for any arbitary machine.
>>>>>>>
>>>>>>> ...for a finite number of steps.
>>>>>>>
>>>>>>> But its just a POORLY SPECIFIED SPECIFICATION
>>>>>>>
>>>>>>> You can go AROUND AND AROUND in semantic discussion
>>>>>>> OR you can use a RUBRIC for the halting problem.
>>>>>>>
>>>>>>> Is CHAITANS OMEGA UNCOMPUTABLE
>>>>>>>
>>>>>>>
>>>>>>> 10 processing steps - CO = 0.???1????01????...
>>>>>>> 100 processing steps - CO = 0.???11??0001????...
>>>>>>> 1000 processing steps - CO = 0.?1111?00001????...
>>>>>>> 10000 processing steps - CO = 0.11111?0000111??...
>>>>>>>
>>>>>>>
>>>>>>> LOOKS COMPUTABLE TO ME!
>>>>>>>
>>>>>>> At the Infinite processing time LIMIT - CO is fully computable
>>>>>>>
>>>>>>> Any remaining ? can be determined to be 0's
>>>>>>>
>>>>>> What is an infinite processing time limit?
>>>>>
>>>>>
>>>>> Its just a hypothetical limit like 1/n as n-->o = INFINITY
>>>> I am wondering if you tried to see if a server work loop, think
>>>> threadpool, would halt... Say its been running for several years and
>>>> going strong
>>>
>>> As long as the programs on the server DONT include an INF LOOP CHECKER
>>> then there's nothing stopping that.
>> The main server loop never dies, unless artificially directed to do so.
> 
> Right!  Technically it doesnt compute anything.

I must be missing something, well... The server loop can compute, or 
process, if you will, say... Client requests?

> 
> Computable is merely defined that way, a program processes an input, writes an output and halts.
> 
> It ties in with FUNCTION theory that way.
> 
> a series of outputs is not a pure function.
> 
> To tie function theory and non-terminating code (input streams) together you require some extra functions
> 
> INPUT = <ABCD...>
> 
> F' = f(A)
> F'= f(AB)
> F'' = f(ABC)
> ...
> 
> 
> so what you get is
> 
> mapfun( f ,  < <A> <AB> <ABC> <ABCD> ... > )
> 
> to process an infinite stream in pure functions
> 
> 
> 
> 
> 

[toc] | [prev] | [next] | [standalone]


#27222

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-17 23:30 -0800
Message-ID<5247f846-75ad-4f95-a3ce-73550570ba43n@googlegroups.com>
In reply to#27221
On Friday, December 18, 2020 at 6:23:30 PM UTC+11, Chris M. Thomasson wrote:
> On 12/17/2020 10:18 PM, Graham Cooper wrote: 
> > On Friday, December 18, 2020 at 4:40:04 PM UTC+11, Chris M. Thomasson wrote: 
> >> On 12/17/2020 7:58 PM, Graham Cooper wrote: 
> >>> On Friday, December 18, 2020 at 7:02:37 AM UTC+11, Chris M. Thomasson wrote: 
> >>>> On 12/17/2020 1:40 AM, Graham Cooper wrote: 
> >>>>> On Thursday, December 17, 2020 at 12:04:41 PM UTC+11, Chris M. Thomasson wrote: 
> >>>>>> On 12/15/2020 2:56 PM, Graham Cooper wrote: 
> >>>>>>> On Wednesday, December 16, 2020 at 7:44:08 AM UTC+11, Kaz Kylheku wrote: 
> >>>>>>>> On 2020-12-15, Graham Cooper <graham...@gmail.com> wrote: 
> >>>>>>>>> Doesn't matter, if halt hangs on a spurious program test 
> >>>>>>>>> then that program hangs too so we KNOW its halt value 
> >>>>>>>>> with incremental processing time! 
> >>>>>>>> You can't externally tell the difference between a machine that truly 
> >>>>>>>> hangs forever, and a machine that terminates, but has not yet done so: 
> >>>>>>>> it just requires more time and steps. 
> >>>>>>>> 
> >>>>>>>> Only using internal reasoning---by observing some internal behavior, or 
> >>>>>>>> deducing it from analyzing the code---can you tell that something hangs 
> >>>>>>>> forever. Like, "aha, here is a trivial endless loop, which is provably 
> >>>>>>>> reached from the starting point in no more than 300 steps". 
> >>>>>>>> 
> >>>>>>>> This is the same as the halting problem. The halting theorem says that 
> >>>>>>>> there can be no universal algorithm for deciding, in a finite number 
> >>>>>>>> of steps, whether a given machine will halt. 
> >>>>>>> 
> >>>>>>> Which is just : GIVEN A SMALLER CLASS OF COMPUTATION 
> >>>>>>> 
> >>>>>>> CAN YOU DECIDE A LARGER CLASS OF COMPUTATION 
> >>>>>>> 
> >>>>>>> A self inconsistent paradox of specification 
> >>>>>>> 
> >>>>>>>> 
> >>>>>>>> Thus when you say "if halt hangs ... that program hals too ... so we 
> >>>>>>>> KNOW its halt value", you are necessarily taking the perspective that we 
> >>>>>>>> have a magic oracle that allows us to know. 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> WRONG! you dont need an ORACLE 
> >>>>>>> 
> >>>>>>> There is a difference between 
> >>>>>>> 
> >>>>>>> 10 steps - halt( spuriousProgram ) = HANG 
> >>>>>>> 100 steps - halt( spuriousProgram ) = HANG 
> >>>>>>> 1000 steps - halt( spuriousProgram ) = HANG 
> >>>>>>> 10000 steps - halt( spuriousProgram ) = HANG 
> >>>>>>> 
> >>>>>>> 10 steps - halt( longProgram ) = HANG 
> >>>>>>> 100 steps - halt( longProgram ) = HANG 
> >>>>>>> 1000 steps - halt( longProgram ) = HANG 
> >>>>>>> 10000 steps - halt( longProgram ) = OUTPUTS VALUE 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> Consider INFINITE PROCESSING STEPS and you can SEE the ANSWER! 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> 
> >>>>>>>> 
> >>>>>>>> We do not have an algorithm (Turing computation) to be able to KNOW; 
> >>>>>>>> not for any arbitary machine. 
> >>>>>>> 
> >>>>>>> ...for a finite number of steps. 
> >>>>>>> 
> >>>>>>> But its just a POORLY SPECIFIED SPECIFICATION 
> >>>>>>> 
> >>>>>>> You can go AROUND AND AROUND in semantic discussion 
> >>>>>>> OR you can use a RUBRIC for the halting problem. 
> >>>>>>> 
> >>>>>>> Is CHAITANS OMEGA UNCOMPUTABLE 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> 10 processing steps - CO = 0.???1????01????... 
> >>>>>>> 100 processing steps - CO = 0.???11??0001????... 
> >>>>>>> 1000 processing steps - CO = 0.?1111?00001????... 
> >>>>>>> 10000 processing steps - CO = 0.11111?0000111??... 
> >>>>>>> 
> >>>>>>> 
> >>>>>>> LOOKS COMPUTABLE TO ME! 
> >>>>>>> 
> >>>>>>> At the Infinite processing time LIMIT - CO is fully computable 
> >>>>>>> 
> >>>>>>> Any remaining ? can be determined to be 0's 
> >>>>>>> 
> >>>>>> What is an infinite processing time limit? 
> >>>>> 
> >>>>> 
> >>>>> Its just a hypothetical limit like 1/n as n-->o = INFINITY 
> >>>> I am wondering if you tried to see if a server work loop, think 
> >>>> threadpool, would halt... Say its been running for several years and 
> >>>> going strong 
> >>> 
> >>> As long as the programs on the server DONT include an INF LOOP CHECKER 
> >>> then there's nothing stopping that. 
> >> The main server loop never dies, unless artificially directed to do so. 
> > 
> > Right! Technically it doesnt compute anything.
> I must be missing something, well... The server loop can compute, or 
> process, if you will, say... Client requests?


Theoretically they are just working memory.

A turing machine inputs 1 value, processes it and outputs 1 value and halts

That is the defn of computation, same as function.

If the server hasnt finished processing what is the result ?

a pure function can convert an infinite stream of data using LAZY EVALUATION

and construct an increasing sequence towards the output.

But technically we are just peeking at the internal memory of a non halted function.





[toc] | [prev] | [next] | [standalone]


#27072

FromJeff Barnett <jbb@notatt.com>
Date2020-12-15 15:00 -0700
Message-ID<rrbbln$si6$1@dont-email.me>
In reply to#27055
On 12/15/2020 8:19 AM, Graham Cooper wrote:
> Basically, given a SMALLER CLASS OF COMPUTATION
> 
> can it solve a LARGER CLASS of computation ??
> 
> 
> 
> By the halting proof the answer is NO
> 
> but what if HALT() didnt have to halt itself?
> 
> 
> Then it belongs to the SAME CLASS OF COMPUTATION
> as programs it has to DECIDE
> 
> and the HALTING PROBLEM IS SOLVED!
> 
> 
> 
> BUT BUT ...  it doesnt always give an answer!!
> 
> Doesn't matter, if halt hangs on a spurious program test
> then that program hangs too so we KNOW its halt value
> with incremental processing time!
> 
> So the WHOLE WORLD GOT IT WRONG!
> CHAITANS OMEGA is incrementally computable!
> 
> HALT( P I ) --> VALUE
> HALT( P I ) --> 0 FALSE
> HALT( P I ) --> DOESNT HALT
> 
> IS A LARGER CLASS OF COMPUTATION
> 
> WHICH SOLVES THE HALTING PROBLEM!

It's so good to see that PO has such a supporter as you. We all treat 
him like crap and deservedly so. But we do know that your presence will 
help cure his wounded soul and perhaps salvage another human being. More 
or less. Keep up the good work, it is appreciated here. But I caution 
you to exercise discretion; PO is the only one who thinks you are as 
nuts as him. If you don't include subtle signals, other people might 
feel that you swallowed the same stupid potion. AS I said above, we all 
are glad to see the digital Red Cross in action.
-- 
Jeff Barnett

[toc] | [prev] | [next] | [standalone]


#27074

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2020-12-15 22:13 +0000
Message-ID<20201215140849.66@kylheku.com>
In reply to#27072
On 2020-12-15, Jeff Barnett <jbb@notatt.com> wrote:
>> WHICH SOLVES THE HALTING PROBLEM!
>
> It's so good to see that PO has such a supporter as you. We all treat 
> him like crap and deservedly so. But we do know that your presence will 
> help cure his wounded soul and perhaps salvage another human being. More 
> or less. Keep up the good work, it is appreciated here. But I caution 
> you to exercise discretion; PO is the only one who thinks you are as 
> nuts as him. If you don't include subtle signals, other people might 
> feel that you swallowed the same stupid potion. AS I said above, we all 
> are glad to see the digital Red Cross in action.

I think PO has a good idea with that simulator, but is abusing it for
ill purposes that will go nowhere.

A better idea would be to pour all energy into making it the best
detector of non-halting decider it could be.

He should port the effort to Qemu, which is apractical emulator that is
in widespread practical use, and supports multiple architecures.

Alernatively, it could be ported to Valgrind. Imagine valgrind equipped
with one more debugging tool: a detector of various situations when the
program has become provably hung, which terminates the program and
reports some details about what pieces of code are involved, and why.

-- 
TXR Programming Language: http://nongnu.org/txr

[toc] | [prev] | [next] | [standalone]


#27077

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-12-15 23:12 +0000
Message-ID<87bleu64ur.fsf@bsb.me.uk>
In reply to#27074
Kaz Kylheku <563-365-8930@kylheku.com> writes:
<cut>
> A better idea would be to pour all energy into making it the best
> detector of non-halting decider it could be.
>
> He should port the effort to Qemu, which is apractical emulator that is
> in widespread practical use, and supports multiple architecures.
>
> Alernatively, it could be ported to Valgrind. Imagine valgrind equipped
> with one more debugging tool: a detector of various situations when the
> program has become provably hung, which terminates the program and
> reports some details about what pieces of code are involved, and why.

The trouble is that is a rather obvious and ordinary thing to do.  It
might well be very useful, but that's beside the point.  PO wants
nothing less than that everyone else be wrong.  The conventional halting
theorem proof is wrong, the undecidability of halting is wrong, Rice's
theorem is wrong, Gödel's first incompleteness theorem is wrong,
Tarski's theorem on truth predicates is wrong...

Would you expect anything else from some who claims to be God (including
in a court of law, no less)?

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#27078

FromGraham Cooper <grahamcooper7@gmail.com>
Date2020-12-15 15:23 -0800
Message-ID<6cd3fd9e-c44d-43b7-b8f1-913962579f1en@googlegroups.com>
In reply to#27077
On Wednesday, December 16, 2020 at 10:12:47 AM UTC+11, Ben Bacarisse wrote:
> Kaz Kylheku <563-36...@kylheku.com> writes: 
> <cut>
> > A better idea would be to pour all energy into making it the best 
> > detector of non-halting decider it could be. 
> > 
> > He should port the effort to Qemu, which is apractical emulator that is 
> > in widespread practical use, and supports multiple architecures. 
> > 
> > Alernatively, it could be ported to Valgrind. Imagine valgrind equipped 
> > with one more debugging tool: a detector of various situations when the 
> > program has become provably hung, which terminates the program and 
> > reports some details about what pieces of code are involved, and why.
> The trouble is that is a rather obvious and ordinary thing to do. It 
> might well be very useful, 


No its a PARADOXICAL SPECIFICATION.

CONSIDER 

function X()
  if infiniteLoops(X) BREAK
  else X()

this is all the halting proof is!   WHAT A JOKE you ARE all wrong and PO *IS* right!

You cant allow programs that USE the INFINITE LOOP DETECTOR
AND expect the ILD to always halt
AND program ways around it
AND spout on for a CENTURY that its impossible
AND conclude REAL NUMBERS ARE UNCOMPUTABLE

all because of program X()!   You are all got WOOL OVER YOUR EYES!

[toc] | [prev] | [next] | [standalone]


#27085

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-12-16 00:39 +0000
Message-ID<87o8iu4m98.fsf@bsb.me.uk>
In reply to#27078
Graham Cooper <grahamcooper7@gmail.com> writes:

> On Wednesday, December 16, 2020 at 10:12:47 AM UTC+11, Ben Bacarisse wrote:
>> Kaz Kylheku <563-36...@kylheku.com> writes: 
>> <cut>
>> > A better idea would be to pour all energy into making it the best 
>> > detector of non-halting decider it could be. 
>> > 
>> > He should port the effort to Qemu, which is apractical emulator that is 
>> > in widespread practical use, and supports multiple architecures. 
>> > 
>> > Alernatively, it could be ported to Valgrind. Imagine valgrind equipped 
>> > with one more debugging tool: a detector of various situations when the 
>> > program has become provably hung, which terminates the program and 
>> > reports some details about what pieces of code are involved, and why.
>> The trouble is that is a rather obvious and ordinary thing to do. It 
>> might well be very useful, 
>
> No its a PARADOXICAL SPECIFICATION.

I think Kaz meant "the best detector of non-halting he could write".
You are correct that there is no best detector of non-halting.  Any such
detector can be improved.

> CONSIDER 
>
> function X()
>   if infiniteLoops(X) BREAK
>   else X()
>
> this is all the halting proof is!

You did notice that Kaz was not talking about the halting theorem?

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#27079

Fromolcott <NoOne@NoWhere.com>
Date2020-12-15 17:26 -0600
Message-ID<4_qdndIytu-420TCnZ2dnUU7-a_NnZ2d@giganews.com>
In reply to#27077
On 12/15/2020 5:12 PM, Ben Bacarisse wrote:
> Kaz Kylheku <563-365-8930@kylheku.com> writes:
> <cut>
>> A better idea would be to pour all energy into making it the best
>> detector of non-halting decider it could be.
>>
>> He should port the effort to Qemu, which is apractical emulator that is
>> in widespread practical use, and supports multiple architecures.
>>
>> Alernatively, it could be ported to Valgrind. Imagine valgrind equipped
>> with one more debugging tool: a detector of various situations when the
>> program has become provably hung, which terminates the program and
>> reports some details about what pieces of code are involved, and why.
> 
> The trouble is that is a rather obvious and ordinary thing to do.  It
> might well be very useful, but that's beside the point.  PO wants
> nothing less than that everyone else be wrong.  The conventional halting
> theorem proof is wrong, the undecidability of halting is wrong, Rice's
> theorem is wrong, Gödel's first incompleteness theorem is wrong,
> Tarski's theorem on truth predicates is wrong...
> 
> Would you expect anything else from some who claims to be God (including
> in a court of law, no less)?
> 

I will give you a straight up computer science question
(I already know the answer):

Is this correct?
If the halting theorem proof is wrong then Rice's theorem is also wrong.

-- 
Copyright 2020 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#27081

From"dklei...@gmail.com" <dkleinecke@gmail.com>
Date2020-12-15 16:01 -0800
Message-ID<e11b2320-d03d-46bc-bb87-93b33e0d67d1n@googlegroups.com>
In reply to#27079
On Tuesday, December 15, 2020 at 3:26:36 PM UTC-8, olcott wrote:
> On 12/15/2020 5:12 PM, Ben Bacarisse wrote: 
> > Kaz Kylheku <563-36...@kylheku.com> writes: 
> > <cut> 
> >> A better idea would be to pour all energy into making it the best 
> >> detector of non-halting decider it could be. 
> >> 
> >> He should port the effort to Qemu, which is apractical emulator that is 
> >> in widespread practical use, and supports multiple architecures. 
> >> 
> >> Alernatively, it could be ported to Valgrind. Imagine valgrind equipped 
> >> with one more debugging tool: a detector of various situations when the 
> >> program has become provably hung, which terminates the program and 
> >> reports some details about what pieces of code are involved, and why. 
> > 
> > The trouble is that is a rather obvious and ordinary thing to do. It 
> > might well be very useful, but that's beside the point. PO wants 
> > nothing less than that everyone else be wrong. The conventional halting 
> > theorem proof is wrong, the undecidability of halting is wrong, Rice's 
> > theorem is wrong, Gödel's first incompleteness theorem is wrong, 
> > Tarski's theorem on truth predicates is wrong... 
> > 
> > Would you expect anything else from some who claims to be God (including 
> > in a court of law, no less)? 
> >
> I will give you a straight up computer science question 
> (I already know the answer): 
> 
> Is this correct? 
> If the halting theorem proof is wrong then Rice's theorem is also wrong. 

Of course it is correct.

Anything follows from a false premise.

[toc] | [prev] | [next] | [standalone]


#27083

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2020-12-16 00:15 +0000
Message-ID<87tusm4ndn.fsf@bsb.me.uk>
In reply to#27079
olcott <NoOne@NoWhere.com> writes:

> I will give you a straight up computer science question

Good plan, since this is comp.theory.

> (I already know the answer):

(unlikely)

> Is this correct?
> If the halting theorem proof is wrong then Rice's theorem is also
> wrong.

Which proof?  Lots of published proofs are wrong.  Linz contains two
proofs of the result being discussed.  One (the one you've never looked
at) is correct and the other has an error in it (at least if you rely on
the symbols and discount the explanatory text).  Neither is a proper
formal proof.

Just to be clear, your statement is neither correct nor incorrect.  It
has no proper meaning because the phase "the halting theorem proof" is
bogus.

-- 
Ben.

[toc] | [prev] | [standalone]


Back to top | Article view | comp.theory


csiph-web