[Top] [All Lists]

Re: [ontolog-forum] Inconsistent Theories

To: "'[ontolog-forum] '" <ontolog-forum@xxxxxxxxxxxxxxxx>
From: "Rich Cooper" <rich@xxxxxxxxxxxxxxxxxxxxxx>
Date: Tue, 9 Feb 2010 09:37:57 -0800
Message-id: <20100209173803.38292138D3B@xxxxxxxxxxxxxxxxx>

Hi Chris,



Rich Cooper


Rich AT EnglishLogicKernel DOT com


On Feb 9, 2010, at 12:56 AM, Rich Cooper wrote:

> Chris,




>       Define( F(x), (x^3+27*x^2) )


I think you are referring to the LISP operator "defun", in which case you want:


         (defun F (x)

            (* (+ (expt x 3) 27) (expt x 2))))


Yes, thanks for completing the lisp expr in proper format.  


> Which states that the identify of the symbol F(x) is defined to be equal to

> the evaluable structure (x^3+27*x^2) which can be used to calculate the

> value of F(x) bound to any x.


> Those are two different views of '=' - by value and by defined structure

> (_expression_ or object, perhaps). 


No, they aren't.  Equality and defun are two entirely different things in LISP. 


Isn't that what I just said above?  Defun puts the structure on an association list with the decomposition above as its 'value' propery.  That means, its value is defined by evaluating the 'value' property.  But there is still a significant difference between the definition and the value of (F x).  


If you're going to appeal to LISP, you might be able to make your point more profitably by appealing to its several related but distinct notions: -- "eq", "eql", "equal", and "equalp".  But the general problem, again, is that you are conflating the semantics of first-order logic with the semantics of programming languages.


Its not Lisp per se which I am trying to use in explaining the property concept, but the fact that any lisp atom or expr can have as many properties as you want to associate with it.  The various versions of '=' in Lisp are there for various programming reasons.  But the particular reason I am bringing up in this discussion is not Lisp, it’s the multiplicity of different kinds of properties that an object in a database can exhibit.  Don't get hung up on Lisp - I wanted to use something we all know to make the point about how there are many properties, one of which is definition, another value, ... etc.  


> The interpretation can be calculated to get the value, but the interpretation is distinct from the value it gets at any given time.


You illustrate my point nicely.  LISP is a programming language; it is not a first-order language. 


Actually, no.  Lisp has often been used to record FOL functionality.  Any programming language can perform any FOL calculation short of infinite.  For example, the conjunct:


(And  (Box 'A)

      (Rectangle 'B)

      (OnTopOf 'A 'B))


Is a perfectly feasible FOL situation description.  And in fact, not only lisp, but any programming language incorporates full FOL functionality (short of infinities). 


The semantics of programming languages is far more specialized and, generally, far more complex than the semantics of first-order languages; consider, e.g., the mathematics of domain theory that underlies the denotational semantics of Scott and Strachey.  The semantics of LISP, in particular, is a very rich and difficult subject that involves not only general issues in the semantics of programming languages such as support for recursion but also issues related to list processing and the semantics of LISP's distinctive operators like "defun", "cons", "car", "cdr", "setq", etc.  These issues are light years removed from vanilla first-order model theory.


Wrong, as described above.  FOL is a SUBSET of modern programming languages without infinity. 


> HTH,








Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/  
Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/  
Unsubscribe: mailto:ontolog-forum-leave@xxxxxxxxxxxxxxxx
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/ 
To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx    (01)

<Prev in Thread] Current Thread [Next in Thread>