Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #49506 > unrolled thread
| Started by | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| First post | 2022-05-02 16:47 +0100 |
| Last post | 2022-05-06 11:54 +0300 |
| Articles | 20 on this page of 215 — 14 participants |
Back to article view | Back to comp.theory
On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-02 16:47 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-02 11:18 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-02 17:39 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-02 15:28 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-03 00:10 +0100
Re: H(P,P) == false is correct olcott <polcott2@gmail.com> - 2022-05-03 21:07 -0500
Re: H(P,P) == false is correct Ben <ben.usenet@bsb.me.uk> - 2022-05-04 15:16 +0100
Re: H(P,P) == false is correct olcott <polcott2@gmail.com> - 2022-05-04 14:27 -0500
Re: H(P,P) == false is correct Ben <ben.usenet@bsb.me.uk> - 2022-05-05 01:59 +0100
Re: H(P,P) == false is correct olcott <polcott2@gmail.com> - 2022-05-04 20:19 -0500
Re: H(P,P) == false is correct Ben <ben.usenet@bsb.me.uk> - 2022-05-05 03:28 +0100
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 21:55 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 19:59 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:09 -0500
Re: H(P,P) == false is correct [ verified facts ] André G. Isaak <agisaak@gm.invalid> - 2022-05-04 21:17 -0600
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:35 -0500
Re: H(P,P) == false is correct [ verified facts ] André G. Isaak <agisaak@gm.invalid> - 2022-05-04 21:38 -0600
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:42 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 20:50 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:58 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 21:07 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 23:48 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 07:51 -0400
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 07:50 -0400
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 04:57 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 13:01 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 11:03 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 13:45 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 11:50 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 16:43 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 20:20 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:38 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 20:43 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 22:54 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-04 21:12 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-04 23:49 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 04:54 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 11:12 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 09:20 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 13:32 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 07:56 -0400
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 07:54 -0400
Re: H(P,P) == false is correct [ verified facts ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2022-05-05 05:27 -0700
Re: H(P,P) == false is correct [ verified facts ] Ben <ben.usenet@bsb.me.uk> - 2022-05-05 14:14 +0100
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 16:53 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 15:11 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 17:31 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 22:43 -0400
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 12:17 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 10:28 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 13:39 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 11:52 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 16:47 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 15:06 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 17:28 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 15:42 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 20:06 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 18:17 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 20:36 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 18:59 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 21:08 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 19:18 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 21:33 -0500
Re: H(P,P) == false is correct [ verified facts ] Dennis Bush <dbush.mobile@gmail.com> - 2022-05-05 19:50 -0700
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-06 01:35 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-06 07:52 -0400
Re: H(P,P) == false is correct [ verified facts ] André G. Isaak <agisaak@gm.invalid> - 2022-05-05 20:51 -0600
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-06 14:07 -0500
Re: H(P,P) == false is correct [ verified facts ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 13:14 -0600
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-06 14:29 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 07:46 -0400
Re: H(P,P) == false is correct [ verified facts ] Ben <ben.usenet@bsb.me.uk> - 2022-05-05 14:29 +0100
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 17:12 -0500
Re: H(P,P) == false is correct [ verified facts ] Python <python@example.invalid> - 2022-05-06 02:58 +0200
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 20:01 -0500
Re: H(P,P) == false is correct [ verified facts ] Python <python@example.invalid> - 2022-05-06 03:34 +0200
Re: H(P,P) == false is correct [ verified facts ] Ben <ben.usenet@bsb.me.uk> - 2022-05-06 03:35 +0100
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-05 21:57 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-05 22:29 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-06 12:36 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 11:33 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-07 02:57 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 21:22 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-08 00:01 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <NoOne@NoWhere.com> - 2022-05-07 18:45 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-08 00:59 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-07 12:31 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-05 23:48 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-05 23:01 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 00:12 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 07:36 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 10:32 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 09:43 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 11:45 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 11:01 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 13:03 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 12:18 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 13:50 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 13:05 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 14:19 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 13:23 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 14:34 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] André G. Isaak <agisaak@gm.invalid> - 2022-05-06 13:37 -0600
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 14:48 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-07 00:47 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 18:59 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] Ben <ben.usenet@bsb.me.uk> - 2022-05-07 03:04 +0100
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 21:26 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 23:03 -0500
Re: H(P,P) == false is correct [ Simple TM Interpreter ] olcott <polcott2@gmail.com> - 2022-05-06 00:55 -0500
Re: H(P,P) == false is correct [ verified facts ] Richard Damon <Richard@Damon-Family.org> - 2022-05-05 22:51 -0400
Re: H(P,P) == false is correct [ verified facts ] Mikko <mikko.levanto@iki.fi> - 2022-05-06 12:42 +0300
Re: H(P,P) == false is correct [ verified facts ] olcott <polcott2@gmail.com> - 2022-05-06 14:09 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-03 12:36 +0300
Re: On recursion and infinite recursion (reprise) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2022-05-03 04:08 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 09:33 -0500
Re: On recursion and infinite recursion (reprise) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2022-05-03 09:41 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 11:57 -0500
Re: On recursion and infinite recursion (reprise) Jeff Barnett <jbb@notatt.com> - 2022-05-03 12:53 -0600
Re: On recursion and infinite recursion (reprise) André G. Isaak <agisaak@gm.invalid> - 2022-05-03 13:02 -0600
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-03 19:59 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 14:05 -0500
Re: On recursion and infinite recursion (reprise) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2022-05-03 14:51 -0700
Re: On recursion and infinite recursion (reprise) Jeff Barnett <jbb@notatt.com> - 2022-05-03 16:06 -0600
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:15 -0500
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:11 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-04 12:04 +0100
Re: On recursion and infinite recursion (reprise) Andy Walker <anw@cuboid.co.uk> - 2022-05-04 14:04 +0100
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-04 14:48 +0100
Re: On recursion and infinite recursion (reprise) Python <python@example.invalid> - 2022-05-04 00:21 +0200
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:40 -0500
Re: On recursion and infinite recursion (reprise) Python <python@example.invalid> - 2022-05-04 00:46 +0200
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:49 -0500
Re: On recursion and infinite recursion (reprise) Python <python@example.invalid> - 2022-05-04 01:05 +0200
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 18:48 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-04 12:15 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-04 11:24 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-04 18:51 -0400
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 09:38 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-03 20:17 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 13:06 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-04 10:19 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-04 12:57 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-04 18:53 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-05 12:37 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-05 12:52 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-06 12:23 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-06 14:14 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-07 11:42 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-07 11:16 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-08 11:21 +0300
Re: On recursion and infinite recursion (reprise) olcott <NoOne@NoWhere.com> - 2022-05-09 10:41 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-09 19:45 +0300
Re: On recursion and infinite recursion (reprise) olcott <NoOne@NoWhere.com> - 2022-05-09 12:11 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-09 19:21 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-10 10:34 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 13:13 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-03 21:58 -0400
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-02 18:32 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-02 23:38 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-02 18:46 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-02 23:47 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-02 19:16 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-03 00:30 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-02 20:40 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-03 20:06 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 14:17 -0500
Re: On recursion and infinite recursion (reprise) Python <python@example.invalid> - 2022-05-04 00:23 +0200
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-04 12:24 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-03 21:54 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-04 17:40 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-04 12:46 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-04 19:23 -0400
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-02 19:35 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-02 20:48 -0400
Re: On recursion and infinite recursion (reprise) wij wij <wyniijj2@gmail.com> - 2022-05-03 05:12 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 09:31 -0500
Re: On recursion and infinite recursion (reprise) Dennis Bush <dbush.mobile@gmail.com> - 2022-05-03 07:47 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 10:19 -0500
Re: On recursion and infinite recursion (reprise) Dennis Bush <dbush.mobile@gmail.com> - 2022-05-03 08:36 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 11:39 -0500
Re: On recursion and infinite recursion (reprise) Dennis Bush <dbush.mobile@gmail.com> - 2022-05-03 14:49 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:08 -0500
Re: On recursion and infinite recursion (reprise) Dennis Bush <dbush.mobile@gmail.com> - 2022-05-03 15:21 -0700
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 17:32 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-03 21:47 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-03 12:31 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 09:42 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-03 20:27 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-03 13:13 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-03 21:38 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-09 19:58 +0300
Re: On recursion and infinite recursion (reprise) olcott <NoOne@NoWhere.com> - 2022-05-09 12:16 -0500
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-09 19:30 -0400
Re: On recursion and infinite recursion (reprise) wij <wyniijj2@gmail.com> - 2022-05-10 08:40 -0700
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-03 21:41 -0400
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-03 19:26 +0100
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-04 10:31 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-04 13:09 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-08 11:09 +0300
Re: On recursion and infinite recursion (reprise) olcott <NoOne@NoWhere.com> - 2022-05-09 10:39 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-09 19:48 +0300
Re: On recursion and infinite recursion (reprise) olcott <NoOne@NoWhere.com> - 2022-05-09 12:12 -0500
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-05 12:19 +0300
Re: On recursion and infinite recursion (reprise) Mr Flibble <flibble@reddwarf.jmc> - 2022-05-05 17:54 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-05 22:56 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-06 11:50 +0300
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-05 12:46 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-05 21:00 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-05 17:16 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-06 02:21 +0100
Re: On recursion and infinite recursion (reprise) olcott <polcott2@gmail.com> - 2022-05-05 20:37 -0500
Re: On recursion and infinite recursion (reprise) Ben <ben.usenet@bsb.me.uk> - 2022-05-06 03:46 +0100
Re: On recursion and infinite recursion (reprise) Richard Damon <Richard@Damon-Family.org> - 2022-05-05 18:41 -0400
Re: On recursion and infinite recursion (reprise) Mikko <mikko.levanto@iki.fi> - 2022-05-06 11:54 +0300
Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11 Next page →
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-03 13:06 -0500 |
| Message-ID | <t4rqv2$reg$1@dont-email.me> |
| In reply to | #49574 |
On 5/3/2022 12:17 PM, Mikko wrote: > On 2022-05-03 14:38:57 +0000, olcott said: > >> On 5/3/2022 4:36 AM, Mikko wrote: >>> On 2022-05-02 16:18:36 +0000, olcott said: >>> >>>> It seems to me that all infinitely recursive definitions are invalid >>>> and I am having an excellent dialogue with some Prolog folks about >>>> this in comp.lang.prolog. >>> >>> One of the rules that define Prolog language is >>> >>> arguments ::= argument | argument "," arguments >>> >>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>> of this and other infinitely recursive rules? >>> >>> Mikko >>> >> >> If would have to be invalid because it can never be resolved. > > What would be invalid? Prolog? Definition of Prolog? > Why "would be" and not "is"? > > Mikko > Expressions that cannot be resolved in Prolog that fail the unify_with_occurs_check test proves that these expressions are semantically incorrect. It is generally the case that every expression of any natural of formal language that cannot be derived by applying truth preserving operations (such as Prolog rules) to expressions known to be true (such as Prolog facts) cannot possibly be correctly construed as true. Dogs are animals (purely analytic) There is a small dog in my living room right now (Empirical). This is true for the entire body of analytic knowledge which only excludes expressions of language that rely on sense data from the sense organs to verify truth. The proof that this is correct is that no counter-examples exist. When G is considered true and unprovable there is some way the "true" is derived, it is not merely a wild guess. Just like Prolog databases True is limited to a specific formal system, one formal system is the entire body of analytic knowledge: EBAK. This is an entirely different formal system than PA. unprovable in PA and true in EBAC is not the same thing as true and unprovable. unprovable in PA means not true in PA, and true in EBAC means provable in EBAC. -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-04 10:19 +0300 |
| Message-ID | <t4t9ei$o7f$1@dont-email.me> |
| In reply to | #49578 |
On 2022-05-03 18:06:24 +0000, olcott said: > On 5/3/2022 12:17 PM, Mikko wrote: >> On 2022-05-03 14:38:57 +0000, olcott said: >> >>> On 5/3/2022 4:36 AM, Mikko wrote: >>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>> >>>>> It seems to me that all infinitely recursive definitions are invalid >>>>> and I am having an excellent dialogue with some Prolog folks about this >>>>> in comp.lang.prolog. >>>> >>>> One of the rules that define Prolog language is >>>> >>>> arguments ::= argument | argument "," arguments >>>> >>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>> of this and other infinitely recursive rules? >>>> >>>> Mikko >>>> >>> >>> If would have to be invalid because it can never be resolved. >> >> What would be invalid? Prolog? Definition of Prolog? >> Why "would be" and not "is"? >> >> Mikko >> > > Expressions that cannot be resolved in Prolog that fail the > unify_with_occurs_check test proves that these expressions are > semantically incorrect. No, it does not mean anything like that. It only means that no well founded data structure matches both arguments. For example, unify_with_occurs_check(1, 2) fails but there is nothing sematically incorrect in 1, 2. > It is generally the case that every expression of any natural of formal > language that cannot be derived by applying truth preserving operations > (such as Prolog rules) to expressions known to be true (such as Prolog > facts) cannot possibly be correctly construed as true. > > Dogs are animals (purely analytic) > There is a small dog in my living room right now (Empirical). > > This is true for the entire body of analytic knowledge which only > excludes expressions of language that rely on sense data from the sense > organs to verify truth. > > The proof that this is correct is that no counter-examples exist. > When G is considered true and unprovable there is some way the "true" > is derived, it is not merely a wild guess. > > Just like Prolog databases True is limited to a specific formal system, > one formal system is the entire body of analytic knowledge: EBAK. This > is an entirely different formal system than PA. > > unprovable in PA and true in EBAC is not the same thing as true and > unprovable. unprovable in PA means not true in PA, and true in EBAC > means provable in EBAC. Nothing in this response is relevant to the responded message. In particular, none of the simple questions were answered. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-04 12:57 -0500 |
| Message-ID | <t4ueqe$tp2$5@dont-email.me> |
| In reply to | #49640 |
On 5/4/2022 2:19 AM, Mikko wrote: > On 2022-05-03 18:06:24 +0000, olcott said: > >> On 5/3/2022 12:17 PM, Mikko wrote: >>> On 2022-05-03 14:38:57 +0000, olcott said: >>> >>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>>> >>>>>> It seems to me that all infinitely recursive definitions are >>>>>> invalid and I am having an excellent dialogue with some Prolog >>>>>> folks about this in comp.lang.prolog. >>>>> >>>>> One of the rules that define Prolog language is >>>>> >>>>> arguments ::= argument | argument "," arguments >>>>> >>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid >>>>> because >>>>> of this and other infinitely recursive rules? >>>>> >>>>> Mikko >>>>> >>>> >>>> If would have to be invalid because it can never be resolved. >>> >>> What would be invalid? Prolog? Definition of Prolog? >>> Why "would be" and not "is"? >>> >>> Mikko >>> >> >> Expressions that cannot be resolved in Prolog that fail the >> unify_with_occurs_check test proves that these expressions are >> semantically incorrect. > > No, it does not mean anything like that. It only means that no well founded > data structure matches both arguments. > > For example, unify_with_occurs_check(1, 2) fails but there is nothing > sematically incorrect in 1, 2. > BEGIN:(Clocksin & Mellish 2003:254) Finally, a note about how Prolog matching sometimes differs from the unification used in Resolution. Most Prolog systems will allow you to satisfy goals like: equal(X, X). ?- equal(foo(Y), Y). that is, they will allow you to match a term against an uninstantiated subterm of itself. In this example, foo(Y) is matched against Y, which appears within it. As a result, Y will stand for foo(Y), which is foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))), and so on. So Y ends up standing for some kind of infinite structure. <inserted for clarity> foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(...)))))))))))) </inserted for clarity> Note that, whereas they may allow you to construct something like this, most Prolog systems will not be able to write it out at the end. According to the formal definition of Unification, this kind of “infinite term” should never come to exist. Thus Prolog systems that allow a term to match an uninstantiated subterm of itself do not act correctly as Resolution theorem provers. In order to make them do so, we would have to add a check that a variable cannot be instantiated to something containing itself. Such a check, an occurs check, would be straightforward to implement, but would slow down the execution of Prolog programs considerably. Since it would only affect very few programs, most implementors have simply left it out 1. 1 The Prolog standard states that the result is undefined if a Prolog system attempts to match a term against an uninstantiated subterm of itself, which means that programs which cause this to happen will not be portable. A portable program should ensure that wherever an occurs check might be applicable the built-in predicate unify_with_occurs_check/2 is used explicitly instead of the normal unification operation of the Prolog implementation. As its name suggests, this predicate acts like =/2 except that it fails if an occurs check detects an illegal attempt to instantiate a variable. END:(Clocksin & Mellish 2003:254) Clocksin, W.F. and Mellish, C.S. 2003. Programming in Prolog Using the ISO Standard Fifth Edition, 254. Berlin Heidelberg: Springer-Verlag. >> It is generally the case that every expression of any natural of >> formal language that cannot be derived by applying truth preserving >> operations (such as Prolog rules) to expressions known to be true >> (such as Prolog facts) cannot possibly be correctly construed as true. >> >> Dogs are animals (purely analytic) >> There is a small dog in my living room right now (Empirical). >> >> This is true for the entire body of analytic knowledge which only >> excludes expressions of language that rely on sense data from the >> sense organs to verify truth. >> >> The proof that this is correct is that no counter-examples exist. >> When G is considered true and unprovable there is some way the "true" >> is derived, it is not merely a wild guess. >> >> Just like Prolog databases True is limited to a specific formal >> system, one formal system is the entire body of analytic knowledge: >> EBAK. This is an entirely different formal system than PA. >> >> unprovable in PA and true in EBAC is not the same thing as true and >> unprovable. unprovable in PA means not true in PA, and true in EBAC >> means provable in EBAC. > > Nothing in this response is relevant to the responded message. > In particular, none of the simple questions were answered. > > Mikko > -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-05-04 18:53 -0400 |
| Message-ID | <ZtDcK.5443$r5xa.1496@fx37.iad> |
| In reply to | #49666 |
On 5/4/22 1:57 PM, olcott wrote: > On 5/4/2022 2:19 AM, Mikko wrote: >> On 2022-05-03 18:06:24 +0000, olcott said: >> >>> On 5/3/2022 12:17 PM, Mikko wrote: >>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>> >>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>>>> >>>>>>> It seems to me that all infinitely recursive definitions are >>>>>>> invalid and I am having an excellent dialogue with some Prolog >>>>>>> folks about this in comp.lang.prolog. >>>>>> >>>>>> One of the rules that define Prolog language is >>>>>> >>>>>> arguments ::= argument | argument "," arguments >>>>>> >>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid >>>>>> because >>>>>> of this and other infinitely recursive rules? >>>>>> >>>>>> Mikko >>>>>> >>>>> >>>>> If would have to be invalid because it can never be resolved. >>>> >>>> What would be invalid? Prolog? Definition of Prolog? >>>> Why "would be" and not "is"? >>>> >>>> Mikko >>>> >>> >>> Expressions that cannot be resolved in Prolog that fail the >>> unify_with_occurs_check test proves that these expressions are >>> semantically incorrect. >> >> No, it does not mean anything like that. It only means that no well >> founded >> data structure matches both arguments. >> >> For example, unify_with_occurs_check(1, 2) fails but there is nothing >> sematically incorrect in 1, 2. >> > > > > BEGIN:(Clocksin & Mellish 2003:254) > Finally, a note about how Prolog matching sometimes differs from the > unification used in Resolution. Most Prolog systems will allow you to > satisfy goals like: > > equal(X, X). > ?- equal(foo(Y), Y). > > that is, they will allow you to match a term against an uninstantiated > subterm of itself. In this example, foo(Y) is matched against Y, which > appears within it. As a result, Y will stand for foo(Y), which is > foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))), > and so on. So Y ends up standing for some kind of infinite structure. > > <inserted for clarity> > foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(...)))))))))))) > </inserted for clarity> > > Note that, whereas they may allow you to construct something like this, > most Prolog systems will not be able to write it out at the end. > According to the formal definition of Unification, this kind of > “infinite term” should never come to exist. Thus Prolog systems that > allow a term to match an uninstantiated subterm of itself do not act > correctly as Resolution theorem provers. In order to make them do so, we > would have to add a check that a variable cannot be instantiated to > something containing itself. Such a check, an occurs check, would be > straightforward to implement, but would slow down the execution of > Prolog programs considerably. Since it would only affect very few > programs, most implementors have simply left it out 1. > > 1 The Prolog standard states that the result is undefined if a Prolog > system attempts to match a term against an uninstantiated subterm of > itself, which means that programs which cause this to happen will not > be portable. A portable program should ensure that wherever an occurs > check might be applicable the built-in predicate > unify_with_occurs_check/2 is used explicitly instead of the normal > unification operation of the Prolog implementation. As its name > suggests, this predicate acts like =/2 except that it fails if an occurs > check detects an illegal attempt to instantiate a variable. > END:(Clocksin & Mellish 2003:254) > > Clocksin, W.F. and Mellish, C.S. 2003. Programming in Prolog Using the > ISO Standard Fifth Edition, 254. Berlin Heidelberg: Springer-Verlag. > > And Prolog implements a logic system simpler than needed to handle the proof you are talking about. Prolog can't handle the needed logic to express the needed properties of mathematics, so you "proof" just fails. >>> It is generally the case that every expression of any natural of >>> formal language that cannot be derived by applying truth preserving >>> operations (such as Prolog rules) to expressions known to be true >>> (such as Prolog facts) cannot possibly be correctly construed as true. >>> >>> Dogs are animals (purely analytic) >>> There is a small dog in my living room right now (Empirical). >>> >>> This is true for the entire body of analytic knowledge which only >>> excludes expressions of language that rely on sense data from the >>> sense organs to verify truth. >>> >>> The proof that this is correct is that no counter-examples exist. >>> When G is considered true and unprovable there is some way the "true" >>> is derived, it is not merely a wild guess. >>> >>> Just like Prolog databases True is limited to a specific formal >>> system, one formal system is the entire body of analytic knowledge: >>> EBAK. This is an entirely different formal system than PA. >>> >>> unprovable in PA and true in EBAC is not the same thing as true and >>> unprovable. unprovable in PA means not true in PA, and true in EBAC >>> means provable in EBAC. >> >> Nothing in this response is relevant to the responded message. >> In particular, none of the simple questions were answered. >> >> Mikko >> > >
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-05 12:37 +0300 |
| Message-ID | <t505s7$s6f$1@dont-email.me> |
| In reply to | #49666 |
On 2022-05-04 17:57:32 +0000, olcott said: > On 5/4/2022 2:19 AM, Mikko wrote: >> On 2022-05-03 18:06:24 +0000, olcott said: >> >>> On 5/3/2022 12:17 PM, Mikko wrote: >>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>> >>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>>>> >>>>>>> It seems to me that all infinitely recursive definitions are invalid >>>>>>> and I am having an excellent dialogue with some Prolog folks about this >>>>>>> in comp.lang.prolog. >>>>>> >>>>>> One of the rules that define Prolog language is >>>>>> >>>>>> arguments ::= argument | argument "," arguments >>>>>> >>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>> of this and other infinitely recursive rules? >>>>>> >>>>>> Mikko >>>>>> >>>>> >>>>> If would have to be invalid because it can never be resolved. >>>> >>>> What would be invalid? Prolog? Definition of Prolog? >>>> Why "would be" and not "is"? >>>> >>>> Mikko >>>> >>> >>> Expressions that cannot be resolved in Prolog that fail the >>> unify_with_occurs_check test proves that these expressions are >>> semantically incorrect. >> >> No, it does not mean anything like that. It only means that no well founded >> data structure matches both arguments. >> >> For example, unify_with_occurs_check(1, 2) fails but there is nothing >> sematically incorrect in 1, 2. >> > > > > BEGIN:(Clocksin & Mellish 2003:254) > Finally, a note about how Prolog matching sometimes differs from the > unification used in Resolution. Most Prolog systems will allow you to > satisfy goals like: > > equal(X, X). > ?- equal(foo(Y), Y). > > that is, they will allow you to match a term against an uninstantiated > subterm of itself. In this example, foo(Y) is matched against Y, which > appears within it. As a result, Y will stand for foo(Y), which is > foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))), > and so on. So Y ends up standing for some kind of infinite structure. > > <inserted for clarity> > foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(...)))))))))))) > </inserted for clarity> > > Note that, whereas they may allow you to construct something like this, > most Prolog systems will not be able to write it out at the end. > According to the formal definition of Unification, this kind of > “infinite term” should never come to exist. Thus Prolog systems that > allow a term to match an uninstantiated subterm of itself do not act > correctly as Resolution theorem provers. In order to make them do so, > we would have to add a check that a variable cannot be instantiated to > something containing itself. Such a check, an occurs check, would be > straightforward to implement, but would slow down the execution of > Prolog programs considerably. Since it would only affect very few > programs, most implementors have simply left it out 1. > > 1 The Prolog standard states that the result is undefined if a Prolog > system attempts to match a term against an uninstantiated subterm of > itself, which means that programs which cause this to happen will not > be portable. A portable program should ensure that wherever an occurs > check might be applicable the built-in predicate > unify_with_occurs_check/2 is used explicitly instead of the normal > unification operation of the Prolog implementation. As its name > suggests, this predicate acts like =/2 except that it fails if an > occurs check detects an illegal attempt to instantiate a variable. > END:(Clocksin & Mellish 2003:254) > > Clocksin, W.F. and Mellish, C.S. 2003. Programming in Prolog Using the > ISO Standard Fifth Edition, 254. Berlin Heidelberg: Springer-Verlag. Nice that you now agree and retract your earlier statement. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-05 12:52 -0500 |
| Message-ID | <t512th$1un$1@dont-email.me> |
| In reply to | #49711 |
On 5/5/2022 4:37 AM, Mikko wrote: > On 2022-05-04 17:57:32 +0000, olcott said: > >> On 5/4/2022 2:19 AM, Mikko wrote: >>> On 2022-05-03 18:06:24 +0000, olcott said: >>> >>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>> >>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>>>>> >>>>>>>> It seems to me that all infinitely recursive definitions are >>>>>>>> invalid and I am having an excellent dialogue with some Prolog >>>>>>>> folks about this in comp.lang.prolog. >>>>>>> >>>>>>> One of the rules that define Prolog language is >>>>>>> >>>>>>> arguments ::= argument | argument "," arguments >>>>>>> >>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid >>>>>>> because >>>>>>> of this and other infinitely recursive rules? >>>>>>> >>>>>>> Mikko >>>>>>> >>>>>> >>>>>> If would have to be invalid because it can never be resolved. >>>>> >>>>> What would be invalid? Prolog? Definition of Prolog? >>>>> Why "would be" and not "is"? >>>>> >>>>> Mikko >>>>> >>>> >>>> Expressions that cannot be resolved in Prolog that fail the >>>> unify_with_occurs_check test proves that these expressions are >>>> semantically incorrect. >>> >>> No, it does not mean anything like that. It only means that no well >>> founded >>> data structure matches both arguments. >>> >>> For example, unify_with_occurs_check(1, 2) fails but there is nothing >>> sematically incorrect in 1, 2. >>> >> >> >> >> BEGIN:(Clocksin & Mellish 2003:254) >> Finally, a note about how Prolog matching sometimes differs from the >> unification used in Resolution. Most Prolog systems will allow you to >> satisfy goals like: >> >> equal(X, X). >> ?- equal(foo(Y), Y). >> >> that is, they will allow you to match a term against an uninstantiated >> subterm of itself. In this example, foo(Y) is matched against Y, which >> appears within it. As a result, Y will stand for foo(Y), which is >> foo(foo(Y)) (because of what Y stands for), which is foo(foo(foo(Y))), >> and so on. So Y ends up standing for some kind of infinite structure. >> >> <inserted for clarity> >> foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(foo(...)))))))))))) >> </inserted for clarity> >> >> Note that, whereas they may allow you to construct something like >> this, most Prolog systems will not be able to write it out at the end. >> According to the formal definition of Unification, this kind of >> “infinite term” should never come to exist. Thus Prolog systems that >> allow a term to match an uninstantiated subterm of itself do not act >> correctly as Resolution theorem provers. In order to make them do so, >> we would have to add a check that a variable cannot be instantiated to >> something containing itself. Such a check, an occurs check, would be >> straightforward to implement, but would slow down the execution of >> Prolog programs considerably. Since it would only affect very few >> programs, most implementors have simply left it out 1. >> >> 1 The Prolog standard states that the result is undefined if a Prolog >> system attempts to match a term against an uninstantiated subterm of >> itself, which means that programs which cause this to happen will not >> be portable. A portable program should ensure that wherever an occurs >> check might be applicable the built-in predicate >> unify_with_occurs_check/2 is used explicitly instead of the normal >> unification operation of the Prolog implementation. As its name >> suggests, this predicate acts like =/2 except that it fails if an >> occurs check detects an illegal attempt to instantiate a variable. >> END:(Clocksin & Mellish 2003:254) >> >> Clocksin, W.F. and Mellish, C.S. 2003. Programming in Prolog Using the >> ISO Standard Fifth Edition, 254. Berlin Heidelberg: Springer-Verlag. > > Nice that you now agree and retract your earlier statement. > > Mikko > I never retracted anything. -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-06 12:23 +0300 |
| Message-ID | <t52pf6$oq7$1@dont-email.me> |
| In reply to | #49742 |
On 2022-05-05 17:52:48 +0000, olcott said: >>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>> >>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>>>> One of the rules that define Prolog language is >>>>>>>> >>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>> >>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>>>> of this and other infinitely recursive rules? >>>>>>>> >>>>>>>> Mikko >>>>>>> If would have to be invalid because it can never be resolved. >>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>> Why "would be" and not "is"? > I never retracted anything. So you still claim that Prolog is invalid? Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-06 14:14 -0500 |
| Message-ID | <t53s2i$i8e$1@dont-email.me> |
| In reply to | #49834 |
On 5/6/2022 4:23 AM, Mikko wrote: > On 2022-05-05 17:52:48 +0000, olcott said: > >>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>> >>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: > >>>>>>>>> One of the rules that define Prolog language is >>>>>>>>> >>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>> >>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid >>>>>>>>> because >>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>> >>>>>>>>> Mikko > >>>>>>>> If would have to be invalid because it can never be resolved. > >>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>> Why "would be" and not "is"? > >> I never retracted anything. > > So you still claim that Prolog is invalid? > > Mikko > I said exactly the opposite. When Prolog implements its system based on Facts and Rules it implements the sound deductive inference model by applying only truth preserving operations to expressions of language known to be true. Also negation as failure can detect and reject expressions that are neither true nor false. Conventional logic cannot possibly do this because it presumes that ~True entails False (even when it doesn't). -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-07 11:42 +0300 |
| Message-ID | <t55bd8$1ft$1@dont-email.me> |
| In reply to | #49874 |
On 2022-05-06 19:14:24 +0000, olcott said: > On 5/6/2022 4:23 AM, Mikko wrote: >> On 2022-05-05 17:52:48 +0000, olcott said: >> >>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>> >>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >> >>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>> >>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>> >>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>> >>>>>>>>>> Mikko >> >>>>>>>>> If would have to be invalid because it can never be resolved. >> >>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>> Why "would be" and not "is"? >> >>> I never retracted anything. >> >> So you still claim that Prolog is invalid? >> >> Mikko >> > > I said exactly the opposite. As can be seen above: You did not. I asked: "Is Prolog invalid?" You said "It would have to be invalid." Here "It" apparently means "Prolog" but I wansn't quite sure so I asked whether you meant something else. In your reply you didn't say I was misinterpreting you so obviously I wasn't. If you now say otherwise it can only mean that you have changed your mind. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-07 11:16 -0500 |
| Message-ID | <t5661j$6fe$2@dont-email.me> |
| In reply to | #49930 |
On 5/7/2022 3:42 AM, Mikko wrote: > On 2022-05-06 19:14:24 +0000, olcott said: > >> On 5/6/2022 4:23 AM, Mikko wrote: >>> On 2022-05-05 17:52:48 +0000, olcott said: >>> >>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>> >>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>> >>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>> >>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>> >>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog >>>>>>>>>>> invalid because >>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>> >>>>>>>>>>> Mikko >>> >>>>>>>>>> If would have to be invalid because it can never be resolved. >>> >>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>> Why "would be" and not "is"? >>> >>>> I never retracted anything. >>> >>> So you still claim that Prolog is invalid? >>> >>> Mikko >>> >> >> I said exactly the opposite. > > As can be seen above: > You did not. > I asked: "Is Prolog invalid?" > You said "It would have to be invalid." > Here "It" apparently means "Prolog" but I wansn't quite sure > so I asked whether you meant something else. In your reply > you didn't say I was misinterpreting you so obviously I wasn't. > If you now say otherwise it can only mean that you have changed > your mind. > > Mikko > Prolog is valid, it is much valid, much more valid than symbolic or classical logic. -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-08 11:21 +0300 |
| Message-ID | <t57uhi$3nh$1@dont-email.me> |
| In reply to | #49951 |
On 2022-05-07 16:16:49 +0000, olcott said: > On 5/7/2022 3:42 AM, Mikko wrote: >> On 2022-05-06 19:14:24 +0000, olcott said: >> >>> On 5/6/2022 4:23 AM, Mikko wrote: >>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>> >>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>> >>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>> >>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>> >>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>> >>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>> >>>>>>>>>>>> Mikko >>>> >>>>>>>>>>> If would have to be invalid because it can never be resolved. >>>> >>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>> Why "would be" and not "is"? >>>> >>>>> I never retracted anything. >>>> >>>> So you still claim that Prolog is invalid? >>>> >>>> Mikko >>>> >>> >>> I said exactly the opposite. >> >> As can be seen above: >> You did not. >> I asked: "Is Prolog invalid?" >> You said "It would have to be invalid." >> Here "It" apparently means "Prolog" but I wansn't quite sure >> so I asked whether you meant something else. In your reply >> you didn't say I was misinterpreting you so obviously I wasn't. >> If you now say otherwise it can only mean that you have changed >> your mind. >> >> Mikko >> > > Prolog is valid, it is much valid, much more valid than symbolic or > classical logic. OK, now it is clear enough. You have said that an infinite recursion in the definition makes Prolog invalid but it is valid anyway. So we can see that your opinions are incoherent and not worth of attention. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-05-09 10:41 -0500 |
| Message-ID | <Rv-dndResPaiq-T_nZ2dnUU7_81g4p2d@giganews.com> |
| In reply to | #50014 |
On 5/8/2022 3:21 AM, Mikko wrote: > On 2022-05-07 16:16:49 +0000, olcott said: > >> On 5/7/2022 3:42 AM, Mikko wrote: >>> On 2022-05-06 19:14:24 +0000, olcott said: >>> >>>> On 5/6/2022 4:23 AM, Mikko wrote: >>>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>>> >>>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>>> >>>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>> >>>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>>> >>>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>>> >>>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog >>>>>>>>>>>>> invalid because >>>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>>> >>>>>>>>>>>>> Mikko >>>>> >>>>>>>>>>>> If would have to be invalid because it can never be resolved. >>>>> >>>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>>> Why "would be" and not "is"? >>>>> >>>>>> I never retracted anything. >>>>> >>>>> So you still claim that Prolog is invalid? >>>>> >>>>> Mikko >>>>> >>>> >>>> I said exactly the opposite. >>> >>> As can be seen above: >>> You did not. >>> I asked: "Is Prolog invalid?" >>> You said "It would have to be invalid." >>> Here "It" apparently means "Prolog" but I wansn't quite sure >>> so I asked whether you meant something else. In your reply >>> you didn't say I was misinterpreting you so obviously I wasn't. >>> If you now say otherwise it can only mean that you have changed >>> your mind. >>> >>> Mikko >>> >> >> Prolog is valid, it is much valid, much more valid than symbolic or >> classical logic. > > OK, now it is clear enough. You have said that an infinite recursion > in the definition makes Prolog invalid but it is valid anyway. I never said anything like that. An expression of the language of Prolog is invalid, Prolog itself is valid. > So we can see that your opinions are incoherent and not worth of attention. If you only glance at ten percent of the words that I say before artificially contriving a rebuttal your rebuttals are going to be pretty shitty. > > Mikko > -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-09 19:45 +0300 |
| Message-ID | <t5bgf3$ld8$1@dont-email.me> |
| In reply to | #50076 |
On 2022-05-09 15:41:50 +0000, olcott said: > On 5/8/2022 3:21 AM, Mikko wrote: >> On 2022-05-07 16:16:49 +0000, olcott said: >> >>> On 5/7/2022 3:42 AM, Mikko wrote: >>>> On 2022-05-06 19:14:24 +0000, olcott said: >>>> >>>>> On 5/6/2022 4:23 AM, Mikko wrote: >>>>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>>>> >>>>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>>>> >>>>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>> >>>>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>>>> >>>>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>>>> >>>>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>>>> >>>>>>>>>>>>>> Mikko >>>>>> >>>>>>>>>>>>> If would have to be invalid because it can never be resolved. >>>>>> >>>>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>>>> Why "would be" and not "is"? >>>>>> >>>>>>> I never retracted anything. >>>>>> >>>>>> So you still claim that Prolog is invalid? >>>>>> >>>>>> Mikko >>>>>> >>>>> >>>>> I said exactly the opposite. >>>> >>>> As can be seen above: >>>> You did not. >>>> I asked: "Is Prolog invalid?" >>>> You said "It would have to be invalid." >>>> Here "It" apparently means "Prolog" but I wansn't quite sure >>>> so I asked whether you meant something else. In your reply >>>> you didn't say I was misinterpreting you so obviously I wasn't. >>>> If you now say otherwise it can only mean that you have changed >>>> your mind. >>>> >>>> Mikko >>>> >>> >>> Prolog is valid, it is much valid, much more valid than symbolic or >>> classical logic. >> >> OK, now it is clear enough. You have said that an infinite recursion >> in the definition makes Prolog invalid but it is valid anyway. > > I never said anything like that. An expression of the language of > Prolog is invalid, Prolog itself is valid. Yes, you did. See above. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2022-05-09 12:11 -0500 |
| Message-ID | <kdadnRgGeaeh1uT_nZ2dnUU7_8xh4p2d@giganews.com> |
| In reply to | #50093 |
On 5/9/2022 11:45 AM, Mikko wrote: > On 2022-05-09 15:41:50 +0000, olcott said: > >> On 5/8/2022 3:21 AM, Mikko wrote: >>> On 2022-05-07 16:16:49 +0000, olcott said: >>> >>>> On 5/7/2022 3:42 AM, Mikko wrote: >>>>> On 2022-05-06 19:14:24 +0000, olcott said: >>>>> >>>>>> On 5/6/2022 4:23 AM, Mikko wrote: >>>>>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>>>>> >>>>>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>>>>> >>>>>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>>> >>>>>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog >>>>>>>>>>>>>>> invalid because >>>>>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>>>>> >>>>>>>>>>>>>>> Mikko >>>>>>> >>>>>>>>>>>>>> If would have to be invalid because it can never be resolved. >>>>>>> >>>>>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>>>>> Why "would be" and not "is"? >>>>>>> >>>>>>>> I never retracted anything. >>>>>>> >>>>>>> So you still claim that Prolog is invalid? >>>>>>> >>>>>>> Mikko >>>>>>> >>>>>> >>>>>> I said exactly the opposite. >>>>> >>>>> As can be seen above: >>>>> You did not. >>>>> I asked: "Is Prolog invalid?" >>>>> You said "It would have to be invalid." >>>>> Here "It" apparently means "Prolog" but I wansn't quite sure >>>>> so I asked whether you meant something else. In your reply >>>>> you didn't say I was misinterpreting you so obviously I wasn't. >>>>> If you now say otherwise it can only mean that you have changed >>>>> your mind. >>>>> >>>>> Mikko >>>>> >>>> >>>> Prolog is valid, it is much valid, much more valid than symbolic or >>>> classical logic. >>> >>> OK, now it is clear enough. You have said that an infinite recursion >>> in the definition makes Prolog invalid but it is valid anyway. >> >> I never said anything like that. An expression of the language of >> Prolog is invalid, Prolog itself is valid. > > Yes, you did. See above. > > Mikko > Prolog is not invalid. Prolog is able to detect expressions of the Prolog language that are invalid using unify_with_occurs_check. -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-05-09 19:21 -0400 |
| Message-ID | <mmheK.59313$XU1.13300@fx09.iad> |
| In reply to | #50097 |
On 5/9/22 1:11 PM, olcott wrote: > On 5/9/2022 11:45 AM, Mikko wrote: >> On 2022-05-09 15:41:50 +0000, olcott said: >> >>> On 5/8/2022 3:21 AM, Mikko wrote: >>>> On 2022-05-07 16:16:49 +0000, olcott said: >>>> >>>>> On 5/7/2022 3:42 AM, Mikko wrote: >>>>>> On 2022-05-06 19:14:24 +0000, olcott said: >>>>>> >>>>>>> On 5/6/2022 4:23 AM, Mikko wrote: >>>>>>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>>>>>> >>>>>>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>>>>>> >>>>>>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>>>> >>>>>>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog >>>>>>>>>>>>>>>> invalid because >>>>>>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Mikko >>>>>>>> >>>>>>>>>>>>>>> If would have to be invalid because it can never be >>>>>>>>>>>>>>> resolved. >>>>>>>> >>>>>>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>>>>>> Why "would be" and not "is"? >>>>>>>> >>>>>>>>> I never retracted anything. >>>>>>>> >>>>>>>> So you still claim that Prolog is invalid? >>>>>>>> >>>>>>>> Mikko >>>>>>>> >>>>>>> >>>>>>> I said exactly the opposite. >>>>>> >>>>>> As can be seen above: >>>>>> You did not. >>>>>> I asked: "Is Prolog invalid?" >>>>>> You said "It would have to be invalid." >>>>>> Here "It" apparently means "Prolog" but I wansn't quite sure >>>>>> so I asked whether you meant something else. In your reply >>>>>> you didn't say I was misinterpreting you so obviously I wasn't. >>>>>> If you now say otherwise it can only mean that you have changed >>>>>> your mind. >>>>>> >>>>>> Mikko >>>>>> >>>>> >>>>> Prolog is valid, it is much valid, much more valid than symbolic or >>>>> classical logic. >>>> >>>> OK, now it is clear enough. You have said that an infinite recursion >>>> in the definition makes Prolog invalid but it is valid anyway. >>> >>> I never said anything like that. An expression of the language of >>> Prolog is invalid, Prolog itself is valid. >> >> Yes, you did. See above. >> >> Mikko >> > > Prolog is not invalid. > Prolog is able to detect expressions of the Prolog language that are > invalid using unify_with_occurs_check. > But the key is that just because they are valid Prolog, doesn't mean they aren't valid logic in a more powerful logic system. If you want to limit the logic you use to just what Prolog offers, fine, but realize that you are leaving a LOT of Logic Theory outside your ability to deal with. This includes things like Computation Theory and systems for which Godel's incompleteness theory hold.
[toc] | [prev] | [next] | [standalone]
| From | Mikko <mikko.levanto@iki.fi> |
|---|---|
| Date | 2022-05-10 10:34 +0300 |
| Message-ID | <t5d4is$r1p$1@dont-email.me> |
| In reply to | #50097 |
On 2022-05-09 17:11:24 +0000, olcott said: > On 5/9/2022 11:45 AM, Mikko wrote: >> On 2022-05-09 15:41:50 +0000, olcott said: >> >>> On 5/8/2022 3:21 AM, Mikko wrote: >>>> On 2022-05-07 16:16:49 +0000, olcott said: >>>> >>>>> On 5/7/2022 3:42 AM, Mikko wrote: >>>>>> On 2022-05-06 19:14:24 +0000, olcott said: >>>>>> >>>>>>> On 5/6/2022 4:23 AM, Mikko wrote: >>>>>>>> On 2022-05-05 17:52:48 +0000, olcott said: >>>>>>>> >>>>>>>>>>>>> On 5/3/2022 12:17 PM, Mikko wrote: >>>>>>>>>>>>>> On 2022-05-03 14:38:57 +0000, olcott said: >>>>>>>>>>>>>> >>>>>>>>>>>>>>> On 5/3/2022 4:36 AM, Mikko wrote: >>>>>>>> >>>>>>>>>>>>>>>> One of the rules that define Prolog language is >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> arguments ::= argument | argument "," arguments >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>>>>>>>>>>>>>> of this and other infinitely recursive rules? >>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>> Mikko >>>>>>>> >>>>>>>>>>>>>>> If would have to be invalid because it can never be resolved. >>>>>>>> >>>>>>>>>>>>>> What would be invalid? Prolog? Definition of Prolog? >>>>>>>>>>>>>> Why "would be" and not "is"? >>>>>>>> >>>>>>>>> I never retracted anything. >>>>>>>> >>>>>>>> So you still claim that Prolog is invalid? >>>>>>>> >>>>>>>> Mikko >>>>>>>> >>>>>>> >>>>>>> I said exactly the opposite. >>>>>> >>>>>> As can be seen above: >>>>>> You did not. >>>>>> I asked: "Is Prolog invalid?" >>>>>> You said "It would have to be invalid." >>>>>> Here "It" apparently means "Prolog" but I wansn't quite sure >>>>>> so I asked whether you meant something else. In your reply >>>>>> you didn't say I was misinterpreting you so obviously I wasn't. >>>>>> If you now say otherwise it can only mean that you have changed >>>>>> your mind. >>>>>> >>>>>> Mikko >>>>>> >>>>> >>>>> Prolog is valid, it is much valid, much more valid than symbolic or >>>>> classical logic. >>>> >>>> OK, now it is clear enough. You have said that an infinite recursion >>>> in the definition makes Prolog invalid but it is valid anyway. >>> >>> I never said anything like that. An expression of the language of >>> Prolog is invalid, Prolog itself is valid. >> >> Yes, you did. See above. >> >> Mikko >> > > Prolog is not invalid. > Prolog is able to detect expressions of the Prolog language that are > invalid using unify_with_occurs_check. So now you have retracted your > If would have to be invalid because it can never be resolved. Mikko
[toc] | [prev] | [next] | [standalone]
| From | olcott <polcott2@gmail.com> |
|---|---|
| Date | 2022-05-03 13:13 -0500 |
| Message-ID | <t4rrcv$vft$2@dont-email.me> |
| In reply to | #49574 |
On 5/3/2022 12:17 PM, Mikko wrote: > On 2022-05-03 14:38:57 +0000, olcott said: > >> On 5/3/2022 4:36 AM, Mikko wrote: >>> On 2022-05-02 16:18:36 +0000, olcott said: >>> >>>> It seems to me that all infinitely recursive definitions are invalid >>>> and I am having an excellent dialogue with some Prolog folks about >>>> this in comp.lang.prolog. >>> >>> One of the rules that define Prolog language is >>> >>> arguments ::= argument | argument "," arguments >>> >>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>> of this and other infinitely recursive rules? >>> >>> Mikko >>> >> >> If would have to be invalid because it can never be resolved. > > What would be invalid? Prolog? Definition of Prolog? > Why "would be" and not "is"? > > Mikko > Failing a unify_with_occurs_check which would otherwise derive this: [trace] ?- LP = \+(LP). LP = (\+LP). [trace] ?- LP. % ... 1,000,000 ............ 10,000,000 years later % % >> 42 << (last release gives the question) [trace] ?- -- Copyright 2022 Pete Olcott "Talent hits a target no one else can hit; Genius hits a target no one else can see." Arthur Schopenhauer
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-05-03 21:58 -0400 |
| Message-ID | <G4lcK.18178$h6X.17238@fx04.iad> |
| In reply to | #49581 |
On 5/3/22 2:13 PM, olcott wrote: > On 5/3/2022 12:17 PM, Mikko wrote: >> On 2022-05-03 14:38:57 +0000, olcott said: >> >>> On 5/3/2022 4:36 AM, Mikko wrote: >>>> On 2022-05-02 16:18:36 +0000, olcott said: >>>> >>>>> It seems to me that all infinitely recursive definitions are >>>>> invalid and I am having an excellent dialogue with some Prolog >>>>> folks about this in comp.lang.prolog. >>>> >>>> One of the rules that define Prolog language is >>>> >>>> arguments ::= argument | argument "," arguments >>>> >>>> which is infinitely recursive. Is it invalid? Is Prolog invalid because >>>> of this and other infinitely recursive rules? >>>> >>>> Mikko >>>> >>> >>> If would have to be invalid because it can never be resolved. >> >> What would be invalid? Prolog? Definition of Prolog? >> Why "would be" and not "is"? >> >> Mikko >> > > Failing a unify_with_occurs_check which would otherwise derive this: > > [trace] ?- LP = \+(LP). > LP = (\+LP). > > [trace] ?- LP. > % ... 1,000,000 ............ 10,000,000 years later > % > % >> 42 << (last release gives the question) > [trace] ?- > So, it just says that the question is beyond Prolog ability to process. Doesn't mean it is an invalid logical sentence. Prolog has a VERY limited form of logic, and can't express a LOT of true propositions.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2022-05-02 18:32 -0400 |
| Message-ID | <NZYbK.49$UWx1.11@fx41.iad> |
| In reply to | #49506 |
On 5/2/22 11:47 AM, Mr Flibble wrote: > Not all infinitely recursive definitions are invalid however infinitely > recursive definitions that arise out of a category error (as is the > case with the halting problem) are invalid. > > The halting problem (as currently defined) is invalid due to the > invalid "impossible program" [Strachey, 1965] that is actually > impossible due to the category error present in its definition and > *not* because of any function call-like recursion; confusion between > these two types of recursion are why Olcott is having difficulty > communicating his ideas with the rest of you shower. > > The categories involved in the category error are the decider and that > which is being decided. Currently extant attempts to conflate the > decider with that which is being decided are infinitely > recursive and thus invalid. > > /Flibble > Except that the "impossible program" isn't part of the definition of the Halting Problem. By your definition, I suspect much of Mathematics becomes a category error. If you are willing to say that this is a natural result of your logic system, fine, but just remember that consequence, which actually says your logic doesn't refute Gobel, as the Theorm specifically requires working in a field that supports some minimums that your logic doesn't handle.
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2022-05-02 23:38 +0100 |
| Message-ID | <20220502233810.000023d2@reddwarf.jmc> |
| In reply to | #49521 |
On Mon, 2 May 2022 18:32:16 -0400 Richard Damon <Richard@Damon-Family.org> wrote: > On 5/2/22 11:47 AM, Mr Flibble wrote: > > Not all infinitely recursive definitions are invalid however > > infinitely recursive definitions that arise out of a category error > > (as is the case with the halting problem) are invalid. > > > > The halting problem (as currently defined) is invalid due to the > > invalid "impossible program" [Strachey, 1965] that is actually > > impossible due to the category error present in its definition and > > *not* because of any function call-like recursion; confusion between > > these two types of recursion are why Olcott is having difficulty > > communicating his ideas with the rest of you shower. > > > > The categories involved in the category error are the decider and > > that which is being decided. Currently extant attempts to conflate > > the decider with that which is being decided are infinitely > > recursive and thus invalid. > > > > /Flibble > > > > Except that the "impossible program" isn't part of the definition of > the Halting Problem. It is according to [Wikipedia, 2022]. /Flibble
[toc] | [prev] | [next] | [standalone]
Page 8 of 11 — ← Prev page 1 … 6 7 [8] 9 10 11 Next page →
Back to top | Article view | comp.theory
csiph-web