HDTenEightyP/NetNews huggingface dataset:
From: lhe@sics.se (Lars-Henrik Eriksson)
Newsgroups: comp.lang.prolog
Subject: Re: To all who posted supposedly solutions of J.W. Lloyds example
Date: 15 Apr 92 17:42:01 GMT
Reply-To: lhe@sics.se (Lars-Henrik Eriksson)
Organization: SICS, Kista (Stockholm), Sweden

In article <3729@tuegate.tue.nl>, wsbusup4@rwa (Jan Stout) writes:
>
>You all assume that :- means logical equivalence, i.e. <->, but I was taught
>that it means logical consequence, i.e. <-.

You are right, but misunderstood the postings. The discussion is about
the *completed* program, which is a set of logical equivalences that
can obtained from the program.

The completed program is of interest when defining semantics of
negated queries.
-- 
Lars-Henrik Eriksson				Internet: lhe@sics.se
Swedish Institute of Computer Science		Phone (intn'l): +46 8 752 15 09
Box 1263					Telefon (nat'l): 08 - 752 15 09
S-164 28  KISTA, SWEDEN
Newsgroups: comp.lang.prolog
From: billaud@geocub.UUCP (Michel BILLAUD)
Newsgroups: comp.lang.prolog
Subject: Re: Purpose of Prolog Semantics
Date: 13 Apr 92 17:41:37 GMT
Organization: LABRI - Universite Bordeaux I - France

In article <10805@cs.tulane.edu> feldman@cs.tulane.edu (Damon Feldman) writes:
>What are the advantages to the formal semantics of (pure) Prolog?
>In particular what are the individual advantages of the fixpoint
>semantics and the least model semantics?
>
>My feeling is that the model-theoretic semantics (declaritive) is by
>far more important than the others, because it allows the programmer
>to think in the predicate calc. rather than mentally model the actions
>of the interpretor. 

Predicate calculus is totally inadequate as a tool to think
about Prolog programs (even pure Prolog) !

Facts:
	repeat , fail		is an endless loop
+	fail , repeat		stops immediatly
------	--------------  	------------------
conclusion			',' is not modelled by the predicate
				calculus operator 'and'

Same thing can be told about ';' and 'or' (';' is not commutative),
and what about idempotence, distributivity... ? Clearly, Pre. Calc.
doesn't work if you have to consider the possibility of infinite
computations, the order in which the solutions are produced
and such things relevant to programming.

On the other hand, it can be shown (in a recent paper by me, hurray :-)
that the behaviour of ';',',' true and fail in "Pure Prolog + I-O"
can be described by a pepsi-axiomatization (looks like Pred-calc,
but isn't !) :-)

>The fixpoint semantics is then little more than a
>link to the least model semantics. 

And thus is a inappropriate tool, for the same reason!

M Billaud

PS: "Axiomatizations of Backtracking" by M Billaud
	in Proceedings STACS'92, LNCS xxx-- 
Michel BILLAUD                 :  billaud@geocub.greco-prog.fr
Departement d'Informatique     :  phone W: 56.84.57.92  // 56.84.69.22
IUT "A", Universite Bordeaux I :  "Je n'y comprends rien,
33405 Talence  (FRANCE)        :   ca doit etre de l'informatique"
From: mcovingt@athena.cs.uga.edu (Michael A. Covington)
Newsgroups: comp.lang.prolog
Subject: Re: Revised instructions to download ISO Prolog draft
Summary: Available from University of Georgia too
Date: 13 Apr 92 04:08:34 GMT
Organization: University of Georgia, Athens

The ISO Prolog draft is also (about to be) available by anonymous FTP from

    aisun1.ai.uga.edu,    directory ai.prolog.standard

which should give faster transfers to sites on this side of
the Atlantic.  

We have the TeX files only.  You can download them individually
or download (in binary format) the file d7complete.tar.Z, which contains
all of them.

-- 
==========================================================================
Michael A. Covington, Ph.D. |  mcovingt@uga.cc.uga.edu  |  ham radio N4TMI
Artificial Intelligence Programs | U of Georgia | Athens, GA 30602  U.S.A.
==========================================================================
From: ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe)
Newsgroups: comp.lang.prolog
Subject: Re: Programming vs. Specification
Date: 7 Apr 92 00:44:17 GMT
Organization: Comp Sci, RMIT, Melbourne, Australia

In article <9209722.15242@mulga.cs.mu.OZ.AU>, lee@munta.cs.mu.OZ.AU (Lee Naish) writes:
> A couple of points raised by Richard's postings:
> >If it is possible to get a better approximation to solutions/3 without
> >coroutining, I would very much like to know how to do it.

> There are a couple of things:

> 1) Do quantifiers *properly*.  With code which has variables which should
> be local to the all solutions construct appearing elsewhere (eg
> 
> 	setof(X, ...), ...... X ...
> 
> ), either the different occurrences of X should be considered different
> variables or the compiler should generate an error.  At the very least,
> "style checkers" should COMPLAIN VERY LOUDLY.

Agreed.  David Scott Warren ran into this problem once, and was very
surprised.  Commercial Prologs are stuck with the backwards compatibility
issue:  the DEC-10 Prolog manual defined "X^p(X)" to be _exactly_ like
"p(X)" outside setof/bagof forms.  This overspecification was regrettable.
In fact the DEC-10 Prolog library treats existential quantifiers
specially inside not(_) as well, so that not(X^p(X)) is ok.

My preference would be for the compiler to rename existentially quantified
variables _and_ for the style checker to warn about it.

> 2) It wouldn't hurt to have versions of setof/3 which produced errors
> when called "outside their design envelope", rather than returning
> *something*.

The Quintus library contains bag_of_all/3 and set_of_all/3 which are
"safe" versions of findall/3.  If there are any free variables in the
Goal argument they report an error.  (This makes it safe for them to
return empty lists.)  I'll add
	safe_{bag_of,set_of,bag_of_all,set_of_all}/3
	safe_grouped_{bag_of,set_of}/4
that report an error if the list of solutions is non-ground.

-- 
I am writing a book on debugging aimed at 1st & 2nd year CS students using
C/Modula/Pascal-like languages.  Please send suggestions (other than "you
_must_ cite "C Traps and Pitfalls") to ok@goanna.cs.rmit.oz.au
From: csa09@seq1.keele.ac.uk (P. Singleton)
Newsgroups: comp.lang.prolog
Subject: Re: ?: Efficient implementation of HASHING in PROLOG
Date: 16 Apr 92 14:09:07 GMT
Organization: University of Keele, England

From article <10280@goanna.cs.rmit.oz.au>, by ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe):

>> foo(X,Y,Z) :- hash_term(X-Y,Hash), foo2(Hash,X,Y,Z).

> Note that the predicate SHOULD be called term_hash(Term, Hash);
> with the name hash_term/2 one expects the hash argument to precede
> the term argument.

And Quintus' copy_term/2 SHOULD be called term_copy :-)
----
  __   __    Paul Singleton (Mr)           JANET: paul@uk.ac.keele.cs
 |__) (__    Computer Science Dept.        other: paul@cs.keele.ac.uk
 |  .  __).  Keele University, Newcastle,    tel: +44 (0)782 621111 x7355
             Staffs ST5 5BG, ENGLAND         fax: +44 (0)782 713082
From: csa09@seq1.keele.ac.uk (P. Singleton)
Newsgroups: comp.lang.prolog
Subject: Re: How to get the n'th element of a list
Date: 9 Apr 92 11:52:07 GMT
Organization: University of Keele, England

From article <rsqauINNbn6@agate.berkeley.edu>, by stolcke@ICSI.Berkeley.EDU (Andreas Stolcke):

> BTW, technically, your constraint "with only one predicate" is of course
> vacuous since your can simulate as many predicates as you want in only
> one predicate.

Presumably, any program could be rewritten as a single predicate, and it
is partly a matter of style how one factors out bits of such a program
into distinct procedures.  Are there any meta-programs out there which
rewrite programs to improve (optimise?) their predicatisation?  Do the
demands of efficiency, readability and reuseability conflict?  Should I
read "The Craft of Prolog"?  Wouldn't a structure-editor for Prolog e.g.
allow me to highlight some goals in the body of a procedure and, with
one mouse-click, extract them into a separate procedure, automatically
deciding what arguments are necessary?
----
  __   __    Paul Singleton (Mr)           JANET: paul@uk.ac.keele.cs
 |__) (__    Computer Science Dept.        other: paul@cs.keele.ac.uk
 |  .  __).  Keele University, Newcastle,    tel: +44 (0)782 621111 x7355
             Staffs ST5 5BG, ENGLAND         fax: +44 (0)782 713082
From: mcovingt@athena.cs.uga.edu (Michael A. Covington)
Newsgroups: comp.lang.prolog
Subject: Re: ?: Efficient implementation of HASHING in PROLOG
Keywords: Prolog, Hashing
Date: 9 Apr 92 00:40:44 GMT
Organization: University of Georgia, Athens

Prolog already uses hashing to look up facts and rules.  Hashing is
applied to the predicate name itself (with arity) and (in most
implementations) to the first argument of the predicate.

-- 
==========================================================================
Michael A. Covington, Ph.D. |  mcovingt@uga.cc.uga.edu  |  ham radio N4TMI
Artificial Intelligence Programs | U of Georgia | Athens, GA 30602  U.S.A.
==========================================================================
Newsgroups: comp.lang.prolog
From: ludemann@quintus.com (Peter Ludemann)
Subject: Re: ?: Efficient implementation of HASHING in PROLOG
Keywords: Prolog, Hashing
Organization: Quintus Corporation, Palo Alto, CA
Date: Tue, 14 Apr 1992 18:14:52 GMT

In article <1992Apr9.004044.22425@athena.cs.uga.edu>, mcovingt@athena.cs.uga.edu (Michael A. Covington) writes:
> Prolog already uses hashing to look up facts and rules.  Hashing is
> applied to the predicate name itself (with arity) and (in most
> implementations) to the first argument of the predicate.

And in some Prologs, the hashing function is available to programmers,
so that complex terms can be hashed.  So, for example, you can do:

foo(X,Y,Z) :- hash_term(X-Y,Hash), foo2(Hash,X,Y,Z).

add_foo(X,Y,Z) :- hash_term(X-Y,Hash), assertz(foo2(Hash,X,Y,Z)).

Note that this depends on hash_term/2 returning a variable whenever
its first argument is not ground.

[If your Prolog implementation doesn't have hash_term/2, writing a C
function to implement it is a good test of how good the C interface is.]

-- 
	Peter Ludemann  +1-415-813-3800  ludemann@quintus.com
From: ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe)
Newsgroups: comp.lang.prolog
Subject: Re: want a bagoff impl. without assert/retracts
Date: 9 Apr 92 12:35:16 GMT
Organization: Comp Sci, RMIT, Melbourne, Australia

In article <5821@charon.cwi.nl>, kwakkel@cwi.nl (Fred Kwakkel) writes:
> SWI prolog gives for the following query:
> 	1 ?- S=[1,2,3,X,4], bagof( Y, member( Y, S ), L ).
> 	L = [1,2,3,G413,4]
> 	S = [1,2,3,G325,4]
> 	X = G325
> 	Y = G334

You have used bagof/3 outside its domain of definition.  Different Prolog
systems do different things, because bagof/3 was only ever defined to work
when all the solutions are GROUND.

> But I want L and S to be EXACTLY the same and NOT different
> uninstantiated vars:

Well, you could use Quintus Prolog, which goes to some trouble to put
the original variables back.  SICStus Prolog's bagof/3 is based on the
same PD implementation, so it does what you want too.  (That thud you
just heard was the author of the PD implementation falling over from
patting himself on the back too much. (:-))  But such a hack can only
be justified on pragmatic grounds (= "paying customers want this
frightful kluge").

> I think it means that I need a bagof implementation without assert/retracts.

Nope, not at all.  The PD implementation is based on assert/retract,
and most "bubble-in-the-heap" findall/3 implementations I've heard of
will introduce new variables too.  What you need is something that collects
solutions just like findall/3 then walks along them putting back the
original variables whenever it is possible to do so.

> I don't know how to write this, can you help me?

Pick up the PD implementation from the Edinburgh Prolog library,
available from the University of Edinburgh.

The very best thing to do is to redesign your program so that it doesn't
want to do this.  Why do you want such a non-logical thing for?

-- 
I am writing a book on debugging aimed at 1st & 2nd year CS students using
C/Modula/Pascal-like languages.  Please send suggestions (other than "you
_must_ cite "C Traps and Pitfalls") to ok@goanna.cs.rmit.oz.au
From: erwvegm@cs.vu.nl (Erwin van Egmond)
Newsgroups: comp.lang.prolog
Subject: Breadth_first question
Date: 8 Apr 92 08:42:11 GMT
Organization: Fac. Wiskunde & Informatica, Vrije Universiteit, Amsterdam

Hi there,
	I'm programming something which uses breadthfirst search.
	However when I use the standard breadthfirst I run out of
	local stack. (Who doesn't? ) So I started scouting around
	for a better implementation for this search method.
	I came up with a breadthfirst search with an improvement
	based on using 'the difference-pair representation' for
	the list of candidate paths.
	(It would make concat more efficient.)
	Is there someone out there who knows about this implementation?
	If yes, please enlighten me about it!!!!

Thankx in advance,
		Erwin van Egmond. (erwvegm@cs.vu.nl)


	
--
++ Erwin van Egmond UUCP: ...!mcsun!cs.vu.nl!erwvegm            ++
++								++
++  With a rubber duck, one's never alone		   	++
++	-- "The Hitchhiker's Guide to the Galaxy"		++
Newsgroups: comp.lang.prolog
From: bharat@acsu.buffalo.edu (Bharat Jayaraman)
Newsgroups: comp.lang.prolog
Subject: Re: memoization
Date: 7 Apr 92 20:06:14 GMT
Organization: State University of New York at Buffalo/Comp Sci

Extract from my original posting:

>>....  To 
>>motivate a related but perhaps more general use of memoization,  consider 
>>the following natural program for the set of reachable nodes of a graph,
>>represented as a set of ordered pairs edge(a,b): 
>>
>>reach(V, G)    = {V}  U  {Y : X in adjacent(V, G),  Y in reach(X, G)}
>>
>>adjacent(V, G) = {A : edge(V,A) in G}    
>>
>>This program would loop if graph G is cyclic, but wouldn't under memoization.
>>However, memoization alone is not enough to compute the desired answer!  


David Warren's reply:

>I don't understand this claim. I think that memoization (as I
>understand it, as OLDT) DOES compute the desired answer. Consider
>the following Prolog translation of Bharat's program:
>
>/************temp.pl***************************************/
>:- ensure_loaded('~/xoldt/xoldt.pl').
>:- op(700,xfx,in).
>:- table in/2.
>
>%reach(V, G)    = {V}  U  {Y : X in adjacent(V, G),  Y in reach(X, G)}
>V in reach(V,_G).
>Y in reach(V,G) :- X in adjacent(V,G), Y in reach(X,G).
>
>%adjacent(V, G) = {A : edge(V,A) in G}    
>A in adjacent(V,G) :- edge(V,A) in G.
>
>% example cyclic graph
>edge(a,b) in g1.
>edge(a,c) in g1.
>edge(b,d) in g1.
>edge(d,b) in g1.
>/**********************************************/
>
>I'm making no claim about being able always to translate programs in
>Bharat's langauges into Prolog so directly, but this does seem to be
>a relatively straightforward translation. The (:- table in/2.)
>directive is to tell my memoing subsystem to memo the in/2 predicate.
>Executing this with my XOLDT system (Plug: see an earlier message on
>how to obtain it), I get:

>	I have edited the details out -- BJ 


David,  

Thanks for your reply.  I was a bit sloppy in my phrasing.
You're right about memoization being enough in the XOLDT version 
of my program.  My remark was directed at memoization not being enough 
given the way that it is used in a functional language setting --- where 
all that is done is to look up a pre-computed value.  The main difference 
lies in the need to initialize the memoized call to the empty set.  As I 
alluded to in my message,  the "reach" example does not illustrate the 
full use of the "re-do" mechanism.  Here's a better example, taken from 
the "dragon book" by Aho and Ullman, page 431 (1977), to define
the set of so-called "reaching definitions" in a program flowgraph:

	out(B) = (in(B) - kill(B)) U gen(B)

	in (B) = U {out(P) : P in pred(B)}

I note your remark that you don't claim to be able to handle such 
definition.  But it would be interesting to see what XOLDT does in 
this case (you would have to refer to the dragon book for details of 
the function kill, gen and pred).

Bharat
From: bayram@cis.uab.edu (Zeki Bayram)
Newsgroups: comp.lang.prolog
Subject: database applications of functional/logic languages
Date: 16 Apr 92 08:23:08 GMT
Organization: University of Alabama at Birmingham
Originator: bayram@orion

Thanks in advance,
Zeki Bayram
UAB
From: djensen@copper.denver.colorado.edu (Dallas Jensen)
Newsgroups: comp.lang.prolog
Subject: SBPROLOG on a Sequent Symmetry?
Summary: Has anyone ported SB to a Sequent or other INtel 386 based system?
Keywords: Porting, Dynix, SBPROLOG
Date: 8 Apr 92 23:26:15 GMT
Organization: University of Colorado at Denver

Hi,
   We are looking at porting sbprolog to a Sequent system. After I have gone 
through the install procedure, I find problems in what appear to be some 
fairly low level routines. FOr example, when I attempt to run the makeall 
on the '.P ' files, sbprolog reports the the 'file **.P not found'. 

    Has anyone out there done this port? I really would prefer to not 
re-invent the wheel.

							Thanks in advance....
							Dallas Jensen
Internet: djensen@cudnvr.denver.colorado.edu

-----------------------------------------------------------------------------
                 )-:   WHAT NO .SIG!   ;-(
From: Shinji.Kono@newcastle.ac.uk (Shinji KONO)
Newsgroups: comp.lang.prolog
Subject: Re: Breadth_first question
Date: 10 Apr 92 15:26:29 GMT
Organization: University of Newcastle upon Tyne, UK NE1 7RU

In article <13856@star.cs.vu.nl> erwvegm@cs.vu.nl (Erwin van Egmond) writes:
>Hi there,
>	I'm programming something which uses breadthfirst search.
>	Is there someone out there who knows about this implementation?

How about try DIFD search?
	0) let depth  = 1
	1) do depth first search once
	2) if no solution increment depth and goto 1)

It is easy to implement and stack size can be very small.
Of course it is slower than breadth-first search. But you will find
if breadth first pays, DIFD pays also.

I find it in the book called Search method in AI, but I can't remember exactly.
-- 
Shinji Kono @ Computing Laboratory, University Newcastle upon Tyne
kono@csl.sony.co.jp                     Room: 616 Claremont Bridge
from Sony Computer Science Laboratory, Inc, Japan.
From: bayram@cis.uab.edu (Zeki Bayram)
Newsgroups: comp.lang.prolog
Subject: database applications of functional/logic languages
Date: 16 Apr 92 08:27:31 GMT
Organization: University of Alabama at Birmingham
Originator: bayram@orion


 
I am investigating database applications of functional/logic programming languages.
I will appreciate any references to published papers, technical reports and
the like on this subject. Functional database languages are also of relevance.
Please send me e-mail. I will post the collection of references on the newsnet.

Thanks in advance,
Zeki Bayram
UAB
Newsgroups: comp.lang.prolog
From: alufml@purple.fnma.com (Francois-Michel Lang)
Subject: Re: Breadth_first question
Organization: Fannie Mae, Washington, DC
Date: Sun, 12 Apr 1992 13:35:33 GMT

In article <1992Apr10.152629.23461@newcastle.ac.uk> Shinji.Kono@newcastle.ac.uk (Shinji KONO) writes:
>In article <13856@star.cs.vu.nl> erwvegm@cs.vu.nl (Erwin van Egmond) writes:
> ...
>How about try DIFD search?
>	0) let depth  = 1
>	1) do depth first search once
>	2) if no solution increment depth and goto 1)
>
> ...
>I find it in the book called Search method in AI, but I can't remember exactly.

Some references on DFID (= Depth-First Iterative Deepening;
or, in Mark Stickel's terminology, consecutively-bounded
depth-first search):

@ARTICLE{Korf-DFID,
	AUTHOR="Richard E. Korf",
	TITLE="Depth-First Iterative-Deepening:
		An Optimal Admissible Tree Search",
	JOURNAL=AImag,
	VOLUME=27,
	NUMBER=1,
	YEAR=1985,
	PAGES="97-109"
	}

@ARTICLE{Korf-Planning,
	AUTHOR="Richard E. Korf",
	TITLE="Planning as Search:  A Quantitative Approach",
	JOURNAL=AImag,
	VOLUME=33,
	NUMBER=1,
	YEAR=1987,
	PAGES="65-88"
	}


@INPROCEEDINGS{Korf-AStar,
	AUTHOR="Richard E. Korf",
	TITLE="Iterative-Deepening A*:
		An Optimal Admissible Tree Search",
	BOOKTITLE=ijcai9,
	PAGES="1034-1036",
	PUBLISHER="Morgan Kaufmann Publishers, Inc.",
	ADDRESS="Los Altos, CA",
	YEAR=1985
	}

@INPROCEEDINGS{Korf-RealTimeHeuristic,
	AUTHOR="Richard E. Korf",
	TITLE="Real-Time Heuristic Search:  First Results",
	BOOKTITLE=aaai87,
	PAGES="133-138",
	PUBLISHER="Morgan Kaufmann Publishers, Inc.",
	ADDRESS="Los Altos, CA",
	YEAR=1987
	}

@INPROCEEDINGS{PTTP1,
	AUTHOR="Mark E. Stickel",
	TITLE="A Prolog Technology Theorem Prover",
	BOOKTITLE=slp84,
	PAGES="211-217",
	ADDRESS="Atlantic City",
	YEAR=1984
	}


@INPROCEEDINGS{PTTP2,
	AUTHOR="Mark E. Stickel",
	TITLE="A Prolog Technology Theorem Prover:
		Implementation by an Extended Prolog Compiler",
	BOOKTITLE=AD8,
	EDITOR={J\"org H. Siekmann},
	PAGES="573-587",
	PUBLISHER="Springer-Verlag",
	ADDRESS="New York",
	YEAR=1986
	}


@TECHREPORT{PTTP-Report,
	AUTHOR="Mark E. Stickel",
	TITLE="A Prolog Technology Theorem Prover:
	       Implementation by an Extended Prolog Compiler",
	TYPE="Technical Note",
	NUMBER="382R",
	INSTITUTION="SRI International",
	ADDRESS="Menlo Park, CA",
	MONTH=nov,
	YEAR=1987
	}

@INPROCEEDINGS{CBDFS,
	AUTHOR="Mark E. Stickel and W. Mabry Tyson",
	TITLE="An Analysis of Consecutively Bounded Depth-First Search
		with Applications in Automated Deduction",
	BOOKTITLE=ijcai9,
	PUBLISHER="Morgan Kaufmann Publishers, Inc.",
	ADDRESS="Los Altos, CA",
	PAGES="1073-1075",
	YEAR=1985
	}

For a discussion of the technique specifically in Prolog,
see Section 2.12 of Richard's Craft of Prolog.
-- 
------------------------------------------------------------------
Francois-Michel Lang          (202) 752-6067   FAX: (202) 752-4463
uunet!almserv!alufml ........ Fannie Mae; Asset/Liability Strategy
lang@linc.cis.upenn.edu ..... Dept of Comp & Info Science, U of PA
From: mcovingt@athena.cs.uga.edu (Michael A. Covington)
Newsgroups: comp.lang.prolog
Subject: Re: Help needed with DCG.
Date: 16 Apr 92 15:49:37 GMT
Organization: University of Georgia, Athens

> retrieve country where Population > 10000

You don't want 'Population' to be a Prolog variable here.  If it were,
you would not be able to distinguish it from 'Area' or 'Government'
or 'TotalNumberOfUnicornsInTheKingsPalace'.  Remember, variables only have
names while being input; as soon as Prolog determines which variables are
which, it forgets the names.

What you want to do is tokenize this as

[retrieve, country, where, population, >, 10000]

and then parse it in such a way that a variable for the population
gets generated, giving a query something like this:

?- country(X), population(X,Y), Y > 10000, display(X).

See Chapter 4 (maybe 3 after reorganization) of my book that will be
published a year or two hence... 

-- 
==========================================================================
Michael A. Covington, Ph.D. |  mcovingt@uga.cc.uga.edu  |  ham radio N4TMI
Artificial Intelligence Programs | U of Georgia | Athens, GA 30602  U.S.A.
==========================================================================
Newsgroups: comp.lang.prolog
From: enrico@cs.uh.edu
Subject: Re: To J.W. Lloyd (Foundations of Logic Programming)
Organization: University of Houston
Date: Tue, 14 Apr 1992 16:41:59 GMT

In article <3716@tuegate.tue.nl> wsbusup4@rwc.urc.tue.nl (Jan Stout) writes:
> Dear mister Lloyd,
> 
> In the 2nd Ext. edition of the book mentioned above, you claim on page 97
> that _it_is_easy_to_show_that ~q is a logical consequence of comp(P) where
> program P is:
> 
>    q :- ~r
>    r :- p
>    r :- ~p
>    p :- p
> 
> We have tried to to this in our class, but with no result. We would
> appreciate a little demonstration...
> 
> 
> 						Jan Stout
> 						wsbusup4@urc.tue.nl
> 
> P.S: Of course any comments of other newsnetters are equally welcome.

Comp(P) contains:

	q <-> ~r
	r <-> (p v ~p)
	p <-> p

plus something else (CET).
But (p v ~p) is TRUE so
	Comp(p) |= (q <-> ~TRUE) |= (q <-> FALSE) |= ~q