Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #31240 > unrolled thread
| Started by | olcott <NoOne@nospicedham.NoWhere.com> |
|---|---|
| First post | 2021-04-17 09:15 -0500 |
| Last post | 2021-04-18 15:47 -0400 |
| Articles | 20 on this page of 145 — 12 participants |
Back to article view | Back to comp.theory
Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 09:15 -0500
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@nospicedham.NoWhere.com> - 2021-04-17 11:01 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:02 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 14:23 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:57 +0000
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:03 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 02:17 +0000
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:21 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-17 19:27 -0700
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-17 23:50 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-17 22:59 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 07:52 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 10:08 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 15:42 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 15:29 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-04-18 13:57 -0700
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 17:55 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) olcott <NoOne@NoWhere.com> - 2021-04-18 17:03 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 18:14 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong)(revised) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 00:35 +0100
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 18:42 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 01:13 +0100
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 19:47 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 02:25 +0100
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 20:40 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 03:00 +0100
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 21:11 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-19 23:44 +0100
Re: Infinite recursion detection criteria: X() simulates Y() olcott <polcott2@gmail.com> - 2021-04-19 21:02 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 03:53 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 21:57 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 04:21 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 22:35 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-04-19 22:09 -0700
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 00:13 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) "dklei...@gmail.com" <dkleinecke@gmail.com> - 2021-04-20 12:34 -0700
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 12:00 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 10:34 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 19:27 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 14:22 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-04-20 13:31 -0700
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 15:57 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-20 23:03 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 17:17 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 02:15 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 21:50 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 04:15 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-20 22:20 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 15:05 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 09:35 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 11:03 -0400
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-21 23:32 +0100
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 17:39 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 01:37 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-21 19:42 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 02:46 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-21 21:22 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-22 13:15 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 09:33 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 00:41 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 18:47 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 01:12 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 19:15 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:05 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:12 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:37 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:44 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 01:27 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 19:53 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:34 +0100
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 21:00 -0500
Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 22:24 -0400
Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:45 +0100
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 22:00 -0500
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-23 22:02 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 23:57 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 23:42 +0100
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-24 21:16 -0500
Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-25 14:06 +0100
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-25 09:15 -0500
Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-25 12:52 -0400
Re: Infinite recursion detection criteria: (formalized) olcott <NoOne@NoWhere.com> - 2021-04-25 13:12 -0500
Re: Infinite recursion detection criteria: (formalized) Richard Damon <Richard@Damon-Family.org> - 2021-04-25 19:53 -0400
Re: Infinite recursion detection criteria: (formalized) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-26 01:48 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:42 +0100
Re: Infinite recursion detection criteria: (Ben contradicts himself) olcott <NoOne@NoWhere.com> - 2021-04-23 20:20 -0500
Re: Infinite recursion detection criteria: (Ben contradicts himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:40 +0100
Re: Infinite recursion detection criteria: (Ben contradicts himself) olcott <NoOne@NoWhere.com> - 2021-04-23 22:11 -0500
Re: Infinite recursion detection criteria: (Ben contradicts himself) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-25 00:22 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 20:24 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-23 02:56 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 21:10 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-22 22:45 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 22:19 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 07:43 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 09:19 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 11:19 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 10:48 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 12:22 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 11:37 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 13:42 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-23 04:56 +0000
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <polcott2@gmail.com> - 2021-04-23 00:04 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-23 07:43 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 01:35 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 20:13 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 02:53 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 21:03 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 03:49 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-23 22:16 -0500
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-24 23:02 +0100
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) Richard Damon <Richard@Damon-Family.org> - 2021-04-22 22:14 -0400
Re: Infinite recursion detection criteria: (equivalent definitions)(easier?) olcott <NoOne@NoWhere.com> - 2021-04-22 21:44 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 07:59 -0400
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-21 09:11 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-21 11:16 -0400
Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-18 22:23 -0400
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-18 21:25 -0500
Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-19 07:26 -0400
Re: Infinite recursion detection criteria: X() simulates Y() olcott <NoOne@NoWhere.com> - 2021-04-19 10:16 -0500
Re: Infinite recursion detection criteria: (erroneous conflation) olcott <NoOne@NoWhere.com> - 2021-04-19 10:26 -0500
Re: Infinite recursion detection criteria: (erroneous conflation) Richard Damon <Richard@Damon-Family.org> - 2021-04-19 12:03 -0400
Re: Infinite recursion detection criteria: (erroneous conflation) Jeff Barnett <jbb@notatt.com> - 2021-04-19 14:38 -0600
Re: Infinite recursion detection criteria: X() simulates Y() Richard Damon <Richard@Damon-Family.org> - 2021-04-19 22:32 -0400
Re: Infinite recursion detection criteria: (equivalent definitions) olcott <NoOne@NoWhere.com> - 2021-04-19 21:53 -0500
Re: Infinite recursion detection criteria: (equivalent definitions) Richard Damon <Richard@Damon-Family.org> - 2021-04-20 08:03 -0400
Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@nospicedham.kylheku.com> - 2021-04-17 15:01 +0000
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 17:30 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Kaz Kylheku <563-365-8930@kylheku.com> - 2021-04-18 01:58 +0000
Re: Infinite recursion detection criteria (Please correct me if I am R Kym Horsell <kym@kymhorsell.com> - 2021-04-18 00:06 +0000
Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 02:16 +0100
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 20:30 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 02:33 +0100
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 20:42 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 21:58 +0100
Re: Infinite recursion detection criteria (Please correct me if I am Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-04-18 01:35 +0100
Re: Infinite recursion detection criteria (Please correct me if I am olcott <NoOne@NoWhere.com> - 2021-04-17 19:38 -0500
Re: Infinite recursion detection criteria (Please correct me if I am Richard Damon <Richard@Damon-Family.org> - 2021-04-17 22:46 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 21:54 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 00:00 -0400
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 23:02 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) olcott <NoOne@NoWhere.com> - 2021-04-17 23:08 -0500
Re: Infinite recursion detection criteria (Please correct me if I am wrong) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 07:55 -0400
Re: Infinite recursion detection criteria (universal halt decider) olcott <NoOne@NoWhere.com> - 2021-04-18 10:20 -0500
Re: Infinite recursion detection criteria (universal halt decider) Richard Damon <Richard@Damon-Family.org> - 2021-04-18 15:47 -0400
Page 2 of 8 — ← Prev page 1 [2] 3 4 5 6 7 8 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-18 18:42 -0500 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <8ZydnYj0669pXuH9nZ2dnUU7-I_NnZ2d@giganews.com> |
| In reply to | #31398 |
On 4/18/2021 6:35 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 4/18/21 6:03 PM, olcott wrote:
> <cut>
>>> No it invokes the "otherwise" portion of the statement.
>>> It is not that hard. You must have a short-cricuit in your brain.
>>
>> No. Y() Halts. Not otherwise..., it Halts.
>>
>> The definition of Halting has no 'otherwise' in it.
>
> Back in the "days of clarity" PO asserted that
>
> (a) Halts(Confound_Halts, Confound_Halts) returns
> (b) The input to Halts is finite.
>
> But in detail (b) was "The input to Halts is only finite because...".
> In other words, false was the right answer because the computation is
> finite for PO's Very Special Reason.
>
(1) Function X() is called twice in sequence from the same machine
address of Y().
(2) With the same parameters to X().
(3) With no conditional branch or indexed jump instructions in Y().
(4) With no function call returns from X().
void X(u32 P, i32 I)
{
Simulate(P, I);
}
void Y(u32 P)
{
X(P, P);
}
int main()
{
X((u32)Y, (u32)Y);
}
When X() simulates the machine language of Y() and examines resulting
execution trace after simulating each machine instruction of Y() then
X() can apply the criteria provided in the above to stop simulating Y()
on the basis that Y() would otherwise cause X() have infinite execution.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-19 01:13 +0100 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <87o8eb2kt8.fsf@bsb.me.uk> |
| In reply to | #31402 |
olcott <NoOne@NoWhere.com> writes: > On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >> Richard Damon <Richard@Damon-Family.org> writes: >> >>> On 4/18/21 6:03 PM, olcott wrote: >> <cut> >>>> No it invokes the "otherwise" portion of the statement. >>>> It is not that hard. You must have a short-cricuit in your brain. >>> >>> No. Y() Halts. Not otherwise..., it Halts. >>> >>> The definition of Halting has no 'otherwise' in it. >> >> Back in the "days of clarity" PO asserted that >> >> (a) Halts(Confound_Halts, Confound_Halts) returns >> (b) The input to Halts is finite. >> >> But in detail (b) was "The input to Halts is only finite because...". >> In other words, false was the right answer because the computation is >> finite for PO's Very Special Reason. > > (1) Function X() is called twice... So you don't deny any of the facts I posted? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-18 19:47 -0500 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <g7SdnX72nJ6aTuH9nZ2dnUU7-b3NnZ2d@giganews.com> |
| In reply to | #31406 |
On 4/18/2021 7:13 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >>> Richard Damon <Richard@Damon-Family.org> writes: >>> >>>> On 4/18/21 6:03 PM, olcott wrote: >>> <cut> >>>>> No it invokes the "otherwise" portion of the statement. >>>>> It is not that hard. You must have a short-cricuit in your brain. >>>> >>>> No. Y() Halts. Not otherwise..., it Halts. >>>> >>>> The definition of Halting has no 'otherwise' in it. >>> >>> Back in the "days of clarity" PO asserted that >>> >>> (a) Halts(Confound_Halts, Confound_Halts) returns >>> (b) The input to Halts is finite. >>> >>> But in detail (b) was "The input to Halts is only finite because...". >>> In other words, false was the right answer because the computation is >>> finite for PO's Very Special Reason. >> >> (1) Function X() is called twice... > > So you don't deny any of the facts I posted? > On 11/27/2020 9:02 PM, Ben Bacarisse wrote: > A computation that would not halt if its simulation were not > halted is indeed a non-halting computation. I thought that your words showed that you understood that a halt decider that determines its input is > A computation that would not halt if its simulation were not > halted is indeed a non-halting computation. even after the halt decider stops simulating this input. Because the only reason that the input did halt is that the simulator did stop simulating this remains true both before and after the halt decider stops simulating its input: > A computation that would not halt if its simulation were not > halted -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-19 02:25 +0100 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <87pmyr12vv.fsf@bsb.me.uk> |
| In reply to | #31410 |
olcott <NoOne@NoWhere.com> writes: > On 4/18/2021 7:13 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >>>> Richard Damon <Richard@Damon-Family.org> writes: >>>> >>>>> On 4/18/21 6:03 PM, olcott wrote: >>>> <cut> >>>>>> No it invokes the "otherwise" portion of the statement. >>>>>> It is not that hard. You must have a short-cricuit in your brain. >>>>> >>>>> No. Y() Halts. Not otherwise..., it Halts. >>>>> >>>>> The definition of Halting has no 'otherwise' in it. >>>> >>>> Back in the "days of clarity" PO asserted that >>>> >>>> (a) Halts(Confound_Halts, Confound_Halts) returns Annoying typo: "returns false". >>>> (b) The input to Halts is finite. >>>> >>>> But in detail (b) was "The input to Halts is only finite because...". >>>> In other words, false was the right answer because the computation is >>>> finite for PO's Very Special Reason. >>> >>> (1) Function X() is called twice... >> >> So you don't deny any of the facts I posted? > > On 11/27/2020 9:02 PM, Ben Bacarisse wrote: >> A computation that would not halt if its simulation were not >> halted is indeed a non-halting computation. > > I thought that your words showed that you understood that a halt decider > that determines its input is >> A computation that would not halt if its simulation were not >> halted is indeed a non-halting computation. || But a computation that || would not halt and one that is halted are different computations. (You don't finish the quote) > even after the halt decider stops simulating this input. False is the wrong answer for a finite computation. (a) Halts(Confound_Halts, Confound_Halts) returns false (b) The input to Halts is finite. You stand by these facts, do you not? > Because the only reason that the input did halt is that the simulator > did stop simulating this remains true both before and after the halt > decider stops simulating its input: That's not the same computation. The one that wouldn't halt and the one that is halted are different. You even had to change a line of code to get the two computations. I am sure you have hidden the trick better now, mainly by refusing to post the code, but the ruse is clear: have one computation that wouldn't halt, and one that would. Claim that the correct answer for one is correct for the other. It's about as silly a crank move as I've ever seen. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-18 20:40 -0500 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <o-KdnZGzQ83uQuH9nZ2dnUU7-K3NnZ2d@giganews.com> |
| In reply to | #31406 |
On 4/18/2021 7:13 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >>> Richard Damon <Richard@Damon-Family.org> writes: >>> >>>> On 4/18/21 6:03 PM, olcott wrote: >>> <cut> >>>>> No it invokes the "otherwise" portion of the statement. >>>>> It is not that hard. You must have a short-cricuit in your brain. >>>> >>>> No. Y() Halts. Not otherwise..., it Halts. >>>> >>>> The definition of Halting has no 'otherwise' in it. >>> >>> Back in the "days of clarity" PO asserted that >>> >>> (a) Halts(Confound_Halts, Confound_Halts) returns >>> (b) The input to Halts is finite. >>> >>> But in detail (b) was "The input to Halts is only finite because...". >>> In other words, false was the right answer because the computation is >>> finite for PO's Very Special Reason. >> >> (1) Function X() is called twice... > > So you don't deny any of the facts I posted? A stipulative definition is a type of definition in which a new or currently existing term is given a new specific meaning for the purposes of argument or discussion in a given context. https://en.wikipedia.org/wiki/Stipulative_definition If this is the stipulative definition of: "a non-halting computation." On 11/27/2020 9:02 PM, Ben Bacarisse wrote: > A computation that would not halt if its simulation were not > halted is indeed a non-halting computation. Then as long as this criteria is met "A computation that would not halt if its simulation were not halted" Then the stipulative definition entails: "is indeed a non-halting computation." I thought that you understood that the only dichotomy that a halt decider based on simulating it input can address is (a) Input forced to halt (b) Input halted on its own thus making it computationally equivalent to: (a) Input would not halt (b) Input would halt -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-19 03:00 +0100 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <87k0oz11b1.fsf@bsb.me.uk> |
| In reply to | #31420 |
olcott <NoOne@NoWhere.com> writes: > On 4/18/2021 7:13 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >>>> Richard Damon <Richard@Damon-Family.org> writes: >>>> >>>>> On 4/18/21 6:03 PM, olcott wrote: >>>> <cut> >>>>>> No it invokes the "otherwise" portion of the statement. >>>>>> It is not that hard. You must have a short-cricuit in your brain. >>>>> >>>>> No. Y() Halts. Not otherwise..., it Halts. >>>>> >>>>> The definition of Halting has no 'otherwise' in it. >>>> >>>> Back in the "days of clarity" PO asserted that >>>> >>>> (a) Halts(Confound_Halts, Confound_Halts) returns [false] >>>> (b) The input to Halts is finite. >>>> >>>> But in detail (b) was "The input to Halts is only finite because...". >>>> In other words, false was the right answer because the computation is >>>> finite for PO's Very Special Reason. >>> >>> (1) Function X() is called twice... >> >> So you don't deny any of the facts I posted? > > A stipulative definition is a type of definition in which a new or > currently existing term is given a new specific meaning for the > purposes of argument or discussion in a given context. > https://en.wikipedia.org/wiki/Stipulative_definition > > If this is the stipulative definition of: > "a non-halting computation." > > On 11/27/2020 9:02 PM, Ben Bacarisse wrote: >> A computation that would not halt if its simulation were not >> halted is indeed a non-halting computation. || But a computation that || would not halt and one that is halted are different computations. > Then as long as this criteria is met > "A computation that would not halt if its simulation were not halted" > > Then the stipulative definition entails: > "is indeed a non-halting computation." Yes (though I was not stipulating). False is the correct return for the computation that wouln't halt, but true is the correct return for the one that does. You remember the two computation ruse -- you showed us which line must be commented out to get the different computations? > I thought that you understood that the only dichotomy that a halt > decider based on simulating it input can address is > (a) Input forced to halt > (b) Input halted on its own Yes, I understand it much better than you do. It must stop simulating an infinite number computations that would halt anyway. Once you said: "The non-halting decider that I defined accepts any and all non-halting inputs and rejects any and all halting inputs." but you have never had any such thing. It's impossible. > thus making it computationally equivalent to: > (a) Input would not halt > (b) Input would halt Only if it is correct, and no halt decider can be correct. One based on simulation can only be PO-correct by reporting false for some computations that are finite (Confound_Halts(Confound_Halts) being one of these). I am not sure how long the furious agreement with me can continue. Can you go back to finding something you disagree with? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-18 21:11 -0500 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <_aGdnZUz64lbe-H9nZ2dnUU7-QHNnZ2d@giganews.com> |
| In reply to | #31421 |
On 4/18/2021 9:00 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/18/2021 7:13 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 4/18/2021 6:35 PM, Ben Bacarisse wrote: >>>>> Richard Damon <Richard@Damon-Family.org> writes: >>>>> >>>>>> On 4/18/21 6:03 PM, olcott wrote: >>>>> <cut> >>>>>>> No it invokes the "otherwise" portion of the statement. >>>>>>> It is not that hard. You must have a short-cricuit in your brain. >>>>>> >>>>>> No. Y() Halts. Not otherwise..., it Halts. >>>>>> >>>>>> The definition of Halting has no 'otherwise' in it. >>>>> >>>>> Back in the "days of clarity" PO asserted that >>>>> >>>>> (a) Halts(Confound_Halts, Confound_Halts) returns [false] >>>>> (b) The input to Halts is finite. >>>>> >>>>> But in detail (b) was "The input to Halts is only finite because...". >>>>> In other words, false was the right answer because the computation is >>>>> finite for PO's Very Special Reason. >>>> >>>> (1) Function X() is called twice... >>> >>> So you don't deny any of the facts I posted? >> >> A stipulative definition is a type of definition in which a new or >> currently existing term is given a new specific meaning for the >> purposes of argument or discussion in a given context. >> https://en.wikipedia.org/wiki/Stipulative_definition >> >> If this is the stipulative definition of: >> "a non-halting computation." >> >> On 11/27/2020 9:02 PM, Ben Bacarisse wrote: >>> A computation that would not halt if its simulation were not >>> halted is indeed a non-halting computation. > || But a computation that > || would not halt and one that is halted are different computations. > >> Then as long as this criteria is met >> "A computation that would not halt if its simulation were not halted" >> >> Then the stipulative definition entails: >> "is indeed a non-halting computation." > > Yes (though I was not stipulating). False is the correct return for the > computation that wouln't halt, but true is the correct return for the > one that does. You are conflating (a) and (b) (a) If not X then would not halt (b) Would not halt no matter what You stipulated (a) and disagree on the basis that (a) is not (b). (a) Input halted only because forced to halt by halt decider (b) Input halted without being because forced to halt by halt decider is computationally equivalent to: (a) Input would not halt (b) Input would halt -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-19 23:44 +0100 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <874kg1zygn.fsf@bsb.me.uk> |
| In reply to | #31422 |
olcott <NoOne@NoWhere.com> writes: I explained this fundamental mistake months ago. You accept the facts, you just pretend that the wrong answer is "PO-correct": You told me (in response to my "challenge" last year) that (a) Halts(Confound_Halts, Confound_Halts) returns false, and (b) the input to Halts is finite. (by which you meant the input represents a finite computation). I don't think there is any disagreement about this. The problem is just that you don't like it being drawn into the light. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2021-04-19 21:02 -0500 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <s5lcna$4t3$1@dont-email.me> |
| In reply to | #31510 |
On 4/19/2021 5:44 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > > I explained this fundamental mistake months ago. You accept the facts, > you just pretend that the wrong answer is "PO-correct": > > You told me (in response to my "challenge" last year) that > > (a) Halts(Confound_Halts, Confound_Halts) returns false, and > (b) the input to Halts is finite. > > (by which you meant the input represents a finite computation). > > I don't think there is any disagreement about this. The problem is just > that you don't like it being drawn into the light. > The machine language of the input to Halts does specify infinite recursion when this input to Halts and Halts are not conflated together as a single computation. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-20 03:53 +0100 |
| Subject | Re: Infinite recursion detection criteria: X() simulates Y() |
| Message-ID | <87zgxtwtt3.fsf@bsb.me.uk> |
| In reply to | #31515 |
olcott <polcott2@gmail.com> writes: > On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >> I explained this fundamental mistake months ago. You accept the facts, >> you just pretend that the wrong answer is "PO-correct": >> >> You told me (in response to my "challenge" last year) that >> >> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >> (b) the input to Halts is finite. >> >> (by which you meant the input represents a finite computation). >> >> I don't think there is any disagreement about this. The problem is just >> that you don't like it being drawn into the light. > > The machine language of the input to Halts does specify infinite > recursion when this input to Halts and Halts are not conflated > together as a single computation. But when Confound_Halts is correctly constructed, the input to Halts represents, as you told me, a finite computation. "Not conflated together" is the new way of saying line 15 is commented out. (Though I am sure you've now found a way to get your two computations without editing the source.) -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-19 21:57 -0500 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <cZWdnbiKbJS23uP9nZ2dnUU7-XvNnZ2d@giganews.com> |
| In reply to | #31532 |
On 4/19/2021 9:53 PM, Ben Bacarisse wrote: > olcott <polcott2@gmail.com> writes: > >> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>> I explained this fundamental mistake months ago. You accept the facts, >>> you just pretend that the wrong answer is "PO-correct": >>> >>> You told me (in response to my "challenge" last year) that >>> >>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>> (b) the input to Halts is finite. >>> >>> (by which you meant the input represents a finite computation). >>> >>> I don't think there is any disagreement about this. The problem is just >>> that you don't like it being drawn into the light. >> >> The machine language of the input to Halts does specify infinite >> recursion when this input to Halts and Halts are not conflated >> together as a single computation. > > But when Confound_Halts is correctly constructed, the input to Halts > represents, as you told me, a finite computation. I can transform one definition into another equivalent definition. Whether or not a simulated input must have its simulation aborted to prevent its infinite execution <is> equivalent to deciding that an input has infinite execution because (a) and (b) (a) Every input having infinite execution would have to have its simulation aborted to prevent its otherwise infinite execution. (b) Every input not having infinite execution need not have its simulation aborted to prevent infinite execution Thus the set of inputs that must be aborted to prevent their infinite execution is the exact same set of inputs that have infinite execution. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-20 04:21 +0100 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <87tuo1wsip.fsf@bsb.me.uk> |
| In reply to | #31534 |
olcott <NoOne@NoWhere.com> writes: > On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >> olcott <polcott2@gmail.com> writes: >> >>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>> I explained this fundamental mistake months ago. You accept the facts, >>>> you just pretend that the wrong answer is "PO-correct": >>>> >>>> You told me (in response to my "challenge" last year) that >>>> >>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>> (b) the input to Halts is finite. >>>> >>>> (by which you meant the input represents a finite computation). >>>> >>>> I don't think there is any disagreement about this. The problem is just >>>> that you don't like it being drawn into the light. >>> >>> The machine language of the input to Halts does specify infinite >>> recursion when this input to Halts and Halts are not conflated >>> together as a single computation. >> >> But when Confound_Halts is correctly constructed, the input to Halts >> represents, as you told me, a finite computation. > > I can transform one definition into another equivalent definition. > > Whether or not a simulated input must have its simulation aborted to > prevent its infinite execution <is> equivalent to deciding that an > input has infinite execution because (a) and (b) > > (a) Every input having infinite execution would have to have its > simulation aborted to prevent its otherwise infinite execution. > > (b) Every input not having infinite execution need not have its > simulation aborted to prevent infinite execution Confound_Halts(Confound_Halts) is a finite computation (according to you). It's in category (b). It does not need to have its simulation aborted to prevent infinite execution. It is a finite computation because, according to you, Halts(Confound_Halts, Confound_Halts) returns false and in that case Confound_Halts returns immediately. > Thus the set of inputs that must be aborted to prevent their infinite > execution is the exact same set of inputs that have infinite > execution. Confound_Halts(Confound_Halts) is not one of those. It is, according to you, a finite computation. That ties up with the fact that, according to you, Halts(Confound_Halts, Confound_Halts) returns false, because in that case Confound_Halts simply returns. The only problem is that false is the wrong answer for a finite computation. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-19 22:35 -0500 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <TOudnXcwjLF-1uP9nZ2dnUU7-KHNnZ2d@giganews.com> |
| In reply to | #31536 |
On 4/19/2021 10:21 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >>> olcott <polcott2@gmail.com> writes: >>> >>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>> I explained this fundamental mistake months ago. You accept the facts, >>>>> you just pretend that the wrong answer is "PO-correct": >>>>> >>>>> You told me (in response to my "challenge" last year) that >>>>> >>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>>> (b) the input to Halts is finite. >>>>> >>>>> (by which you meant the input represents a finite computation). >>>>> >>>>> I don't think there is any disagreement about this. The problem is just >>>>> that you don't like it being drawn into the light. >>>> >>>> The machine language of the input to Halts does specify infinite >>>> recursion when this input to Halts and Halts are not conflated >>>> together as a single computation. >>> >>> But when Confound_Halts is correctly constructed, the input to Halts >>> represents, as you told me, a finite computation. >> >> I can transform one definition into another equivalent definition. >> >> Whether or not a simulated input must have its simulation aborted to >> prevent its infinite execution <is> equivalent to deciding that an >> input has infinite execution because (a) and (b) >> >> (a) Every input having infinite execution would have to have its >> simulation aborted to prevent its otherwise infinite execution. >> >> (b) Every input not having infinite execution need not have its >> simulation aborted to prevent infinite execution > > Confound_Halts(Confound_Halts) is a finite computation (according to > you). It's in category (b). It does not need to have its simulation > aborted to prevent infinite execution. It is a finite computation > because, according to you, Halts(Confound_Halts, Confound_Halts) returns > false and in that case Confound_Halts returns immediately. > >> Thus the set of inputs that must be aborted to prevent their infinite >> execution is the exact same set of inputs that have infinite >> execution. > > Confound_Halts(Confound_Halts) is not one of those. It is, according to > you, a finite computation. That ties up with the fact that, according > to you, Halts(Confound_Halts, Confound_Halts) returns false, because in > that case Confound_Halts simply returns. > > The only problem is that false is the wrong answer for a finite > computation. > This must be over your head: When set Q has the same members as set R then we can know that the definition of set Q is equivalent to the definition of set R. -- Copyright 2021 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 | 2021-04-19 22:09 -0700 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <85d6e4ee-3244-4b01-aad0-a7c6e69e9a24n@googlegroups.com> |
| In reply to | #31539 |
On Monday, April 19, 2021 at 8:35:06 PM UTC-7, olcott wrote: > When set Q has the same members as set R then we can know that the > definition of set Q is equivalent to the definition of set R. When set Q has the same members as set R they are the same set. The "definition of a set X" is not a well-defined concept.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-20 00:13 -0500 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <J-idnV_3WNlt_-P9nZ2dnUU7-cWdnZ2d@giganews.com> |
| In reply to | #31554 |
On 4/20/2021 12:09 AM, dklei...@gmail.com wrote: > On Monday, April 19, 2021 at 8:35:06 PM UTC-7, olcott wrote: > >> When set Q has the same members as set R then we can know that the >> definition of set Q is equivalent to the definition of set R. > > When set Q has the same members as set R they are the same set. > > The "definition of a set X" is not a well-defined concept. > So when I say that X is the set of integers greater than three no one has any idea what I am referring to? -- Copyright 2021 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 | 2021-04-20 12:34 -0700 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <28949bd4-c04d-474b-8c44-77958add53b9n@googlegroups.com> |
| In reply to | #31555 |
On Monday, April 19, 2021 at 10:13:27 PM UTC-7, olcott wrote: > On 4/20/2021 12:09 AM, dklei...@gmail.com wrote: > > On Monday, April 19, 2021 at 8:35:06 PM UTC-7, olcott wrote: > > > >> When set Q has the same members as set R then we can know that the > >> definition of set Q is equivalent to the definition of set R. > > > > When set Q has the same members as set R they are the same set. > > > > The "definition of a set X" is not a well-defined concept. > > > So when I say that X is the set of integers greater than three no one > has any idea what I am referring to? Some sets have clear tests for membership. Some don't. Lots of constructions begin "X is a set of Y". Nothing is known about whether some Y belongs to X except that it is. There is nothing around to identify X. Another problem is the set of all sets and its cousin the set of all sets that don't belong to themselves. They have apparent definitions that don't work. If you were competent in logic I would ask you to define "definition of a set".
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-20 12:00 +0100 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <87im4hw78n.fsf@bsb.me.uk> |
| In reply to | #31539 |
olcott <NoOne@NoWhere.com> writes: > On 4/19/2021 10:21 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >>>> olcott <polcott2@gmail.com> writes: >>>> >>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>> I explained this fundamental mistake months ago. You accept the facts, >>>>>> you just pretend that the wrong answer is "PO-correct": >>>>>> >>>>>> You told me (in response to my "challenge" last year) that >>>>>> >>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>>>> (b) the input to Halts is finite. >>>>>> >>>>>> (by which you meant the input represents a finite computation). >>>>>> >>>>>> I don't think there is any disagreement about this. The problem is just >>>>>> that you don't like it being drawn into the light. >>>>> >>>>> The machine language of the input to Halts does specify infinite >>>>> recursion when this input to Halts and Halts are not conflated >>>>> together as a single computation. >>>> >>>> But when Confound_Halts is correctly constructed, the input to Halts >>>> represents, as you told me, a finite computation. >>> >>> I can transform one definition into another equivalent definition. >>> >>> Whether or not a simulated input must have its simulation aborted to >>> prevent its infinite execution <is> equivalent to deciding that an >>> input has infinite execution because (a) and (b) >>> >>> (a) Every input having infinite execution would have to have its >>> simulation aborted to prevent its otherwise infinite execution. >>> >>> (b) Every input not having infinite execution need not have its >>> simulation aborted to prevent infinite execution >> >> Confound_Halts(Confound_Halts) is a finite computation (according to >> you). It's in category (b). It does not need to have its simulation >> aborted to prevent infinite execution. It is a finite computation >> because, according to you, Halts(Confound_Halts, Confound_Halts) returns >> false and in that case Confound_Halts returns immediately. >> >>> Thus the set of inputs that must be aborted to prevent their infinite >>> execution is the exact same set of inputs that have infinite >>> execution. >> >> Confound_Halts(Confound_Halts) is not one of those. It is, according to >> you, a finite computation. That ties up with the fact that, according >> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in >> that case Confound_Halts simply returns. >> >> The only problem is that false is the wrong answer for a finite >> computation. > > This must be over your head: > When set Q has the same members as set R then we can know that the > definition of set Q is equivalent to the definition of set R. So you don't dispute any of the facts. Confound_Halts(Confound_Halts) is a finite computation. Its simulation does not need to be aborted. Halts(Confound_Halts, Confound_Halts) return false which is the wrong result, but is declared by you to be correct. This has been the position for months now. Agreeing with me about it is not the way to correct this error. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-20 10:34 -0500 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <f_ydneHkousUaeP9nZ2dnUU7-QOdnZ2d@giganews.com> |
| In reply to | #31558 |
On 4/20/2021 6:00 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/19/2021 10:21 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >>>>> olcott <polcott2@gmail.com> writes: >>>>> >>>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>> >>>>>>> I explained this fundamental mistake months ago. You accept the facts, >>>>>>> you just pretend that the wrong answer is "PO-correct": >>>>>>> >>>>>>> You told me (in response to my "challenge" last year) that >>>>>>> >>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>>>>> (b) the input to Halts is finite. >>>>>>> >>>>>>> (by which you meant the input represents a finite computation). >>>>>>> >>>>>>> I don't think there is any disagreement about this. The problem is just >>>>>>> that you don't like it being drawn into the light. >>>>>> >>>>>> The machine language of the input to Halts does specify infinite >>>>>> recursion when this input to Halts and Halts are not conflated >>>>>> together as a single computation. >>>>> >>>>> But when Confound_Halts is correctly constructed, the input to Halts >>>>> represents, as you told me, a finite computation. >>>> >>>> I can transform one definition into another equivalent definition. >>>> >>>> Whether or not a simulated input must have its simulation aborted to >>>> prevent its infinite execution <is> equivalent to deciding that an >>>> input has infinite execution because (a) and (b) >>>> >>>> (a) Every input having infinite execution would have to have its >>>> simulation aborted to prevent its otherwise infinite execution. >>>> >>>> (b) Every input not having infinite execution need not have its >>>> simulation aborted to prevent infinite execution >>> >>> Confound_Halts(Confound_Halts) is a finite computation (according to >>> you). It's in category (b). It does not need to have its simulation >>> aborted to prevent infinite execution. It is a finite computation >>> because, according to you, Halts(Confound_Halts, Confound_Halts) returns >>> false and in that case Confound_Halts returns immediately. >>> >>>> Thus the set of inputs that must be aborted to prevent their infinite >>>> execution is the exact same set of inputs that have infinite >>>> execution. >>> >>> Confound_Halts(Confound_Halts) is not one of those. It is, according to >>> you, a finite computation. That ties up with the fact that, according >>> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in >>> that case Confound_Halts simply returns. >>> >>> The only problem is that false is the wrong answer for a finite >>> computation. >> >> This must be over your head: >> When set Q has the same members as set R then we can know that the >> definition of set Q is equivalent to the definition of set R. > > So you don't dispute any of the facts. That fact has finally been made moot. I can transform one definition into another equivalent definition. Whether or not a simulated input must have its simulation aborted to prevent its infinite execution <is> equivalent to deciding that an input has infinite execution because (a) and (b) (a) Every input having infinite execution would have to have its simulation aborted to prevent its otherwise infinite execution. (b) Every input not having infinite execution need not have its simulation aborted to prevent infinite execution. Thus the set of inputs that must be aborted to prevent their infinite execution is the exact same set of inputs that have infinite execution. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-04-20 19:27 +0100 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <877dkwx13w.fsf@bsb.me.uk> |
| In reply to | #31577 |
olcott <NoOne@NoWhere.com> writes: > On 4/20/2021 6:00 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >>>>>> olcott <polcott2@gmail.com> writes: >>>>>> >>>>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>> >>>>>>>> I explained this fundamental mistake months ago. You accept the facts, >>>>>>>> you just pretend that the wrong answer is "PO-correct": >>>>>>>> >>>>>>>> You told me (in response to my "challenge" last year) that >>>>>>>> >>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>>>>>> (b) the input to Halts is finite. >>>>>>>> >>>>>>>> (by which you meant the input represents a finite computation). >>>>>>>> >>>>>>>> I don't think there is any disagreement about this. The problem is just >>>>>>>> that you don't like it being drawn into the light. >>>>>>> >>>>>>> The machine language of the input to Halts does specify infinite >>>>>>> recursion when this input to Halts and Halts are not conflated >>>>>>> together as a single computation. >>>>>> >>>>>> But when Confound_Halts is correctly constructed, the input to Halts >>>>>> represents, as you told me, a finite computation. >>>>> >>>>> I can transform one definition into another equivalent definition. >>>>> >>>>> Whether or not a simulated input must have its simulation aborted to >>>>> prevent its infinite execution <is> equivalent to deciding that an >>>>> input has infinite execution because (a) and (b) >>>>> >>>>> (a) Every input having infinite execution would have to have its >>>>> simulation aborted to prevent its otherwise infinite execution. >>>>> >>>>> (b) Every input not having infinite execution need not have its >>>>> simulation aborted to prevent infinite execution >>>> >>>> Confound_Halts(Confound_Halts) is a finite computation (according to >>>> you). It's in category (b). It does not need to have its simulation >>>> aborted to prevent infinite execution. It is a finite computation >>>> because, according to you, Halts(Confound_Halts, Confound_Halts) returns >>>> false and in that case Confound_Halts returns immediately. >>>> >>>>> Thus the set of inputs that must be aborted to prevent their infinite >>>>> execution is the exact same set of inputs that have infinite >>>>> execution. >>>> >>>> Confound_Halts(Confound_Halts) is not one of those. It is, according to >>>> you, a finite computation. That ties up with the fact that, according >>>> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in >>>> that case Confound_Halts simply returns. >>>> >>>> The only problem is that false is the wrong answer for a finite >>>> computation. >>> >>> This must be over your head: >>> When set Q has the same members as set R then we can know that the >>> definition of set Q is equivalent to the definition of set R. >> >> So you don't dispute any of the facts. > > That fact has finally been made moot. > > I can transform one definition into another equivalent definition. Well that simplifies things. If they are equivalent, it means you agree that false is the wrong result to return for a finite computation. How you plan to correct the record? One excellent way would be to go to one of the posts where you declare false to be the correct return and write a correction to it. <cut redundant equivalent definition> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-04-20 14:22 -0500 |
| Subject | Re: Infinite recursion detection criteria: (equivalent definitions) |
| Message-ID | <vtidnUgrGq2ft-L9nZ2dnUU7-adQAAAA@giganews.com> |
| In reply to | #31614 |
On 4/20/2021 1:27 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 4/20/2021 6:00 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 4/19/2021 10:21 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> On 4/19/2021 9:53 PM, Ben Bacarisse wrote: >>>>>>> olcott <polcott2@gmail.com> writes: >>>>>>> >>>>>>>> On 4/19/2021 5:44 PM, Ben Bacarisse wrote: >>>>>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>>>>> >>>>>>>>> I explained this fundamental mistake months ago. You accept the facts, >>>>>>>>> you just pretend that the wrong answer is "PO-correct": >>>>>>>>> >>>>>>>>> You told me (in response to my "challenge" last year) that >>>>>>>>> >>>>>>>>> (a) Halts(Confound_Halts, Confound_Halts) returns false, and >>>>>>>>> (b) the input to Halts is finite. >>>>>>>>> >>>>>>>>> (by which you meant the input represents a finite computation). >>>>>>>>> >>>>>>>>> I don't think there is any disagreement about this. The problem is just >>>>>>>>> that you don't like it being drawn into the light. >>>>>>>> >>>>>>>> The machine language of the input to Halts does specify infinite >>>>>>>> recursion when this input to Halts and Halts are not conflated >>>>>>>> together as a single computation. >>>>>>> >>>>>>> But when Confound_Halts is correctly constructed, the input to Halts >>>>>>> represents, as you told me, a finite computation. >>>>>> >>>>>> I can transform one definition into another equivalent definition. >>>>>> >>>>>> Whether or not a simulated input must have its simulation aborted to >>>>>> prevent its infinite execution <is> equivalent to deciding that an >>>>>> input has infinite execution because (a) and (b) >>>>>> >>>>>> (a) Every input having infinite execution would have to have its >>>>>> simulation aborted to prevent its otherwise infinite execution. >>>>>> >>>>>> (b) Every input not having infinite execution need not have its >>>>>> simulation aborted to prevent infinite execution >>>>> >>>>> Confound_Halts(Confound_Halts) is a finite computation (according to >>>>> you). It's in category (b). It does not need to have its simulation >>>>> aborted to prevent infinite execution. It is a finite computation >>>>> because, according to you, Halts(Confound_Halts, Confound_Halts) returns >>>>> false and in that case Confound_Halts returns immediately. >>>>> >>>>>> Thus the set of inputs that must be aborted to prevent their infinite >>>>>> execution is the exact same set of inputs that have infinite >>>>>> execution. >>>>> >>>>> Confound_Halts(Confound_Halts) is not one of those. It is, according to >>>>> you, a finite computation. That ties up with the fact that, according >>>>> to you, Halts(Confound_Halts, Confound_Halts) returns false, because in >>>>> that case Confound_Halts simply returns. >>>>> >>>>> The only problem is that false is the wrong answer for a finite >>>>> computation. >>>> >>>> This must be over your head: >>>> When set Q has the same members as set R then we can know that the >>>> definition of set Q is equivalent to the definition of set R. >>> >>> So you don't dispute any of the facts. >> >> That fact has finally been made moot. >> >> I can transform one definition into another equivalent definition. > > Well that simplifies things. When it is proven that set Q has the exactly same elements as set R then this proves that the definition of set Q is equivalent to the definition of set R. > If they are equivalent, it means you agree > that false is the wrong result to return for a finite computation. How > you plan to correct the record? One excellent way would be to go to one > of the posts where you declare false to be the correct return and write > a correction to it. > > <cut redundant equivalent definition> > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 2 of 8 — ← Prev page 1 [2] 3 4 5 6 7 8 Next page →
Back to top | Article view | comp.theory
csiph-web