Hi Chris,
Sincerely,
Rich Cooper
EnglishLogicKernel.com
Rich AT EnglishLogicKernel DOT com
On Feb 9, 2010, at 12:56 AM, Rich Cooper wrote:
> Chris,
<snip/>
> 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,
Likewise.
-chris
Etc,
-Rich