Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #27055 > unrolled thread
| Started by | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| First post | 2020-12-15 07:19 -0800 |
| Last post | 2020-12-16 00:15 +0000 |
| Articles | 20 — 8 participants |
Back to article view | Back to comp.theory
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
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-12-15 07:19 -0800 |
| Subject | HALT 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]
| From | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| Date | 2020-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2020-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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2020-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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]
| From | Graham Cooper <grahamcooper7@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2020-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]
| From | "dklei...@gmail.com" <dkleinecke@gmail.com> |
|---|---|
| Date | 2020-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2020-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