The way we have treated concepts in this paper, especially
when we put variables in them, suggests trying to identify them with
terms in some language. It seems to me that this can be done
provided we use a suitable notion of *abstract language*.

Ordinarily a language is identified with a set of strings of
symbols taken from some alphabet. McCarthy (1963) introduces the idea of
*abstract syntax*, the idea being that it doesn't matter whether
sums are represented *a*+*b* or +*ab* or *ab*+ or by the integer
or by the LISP S-expression (PLUS A B),
so long as there are predicates for deciding whether
an expression is a sum and functions for forming sums from summands
and functions for extracting the summands from the sum. In
particular, abstract syntax facilitates defining the semantics of
programming languages, and proving the properties of interpreters and
compilers. From that point of view, one can refrain from specifying
any concrete representation of the ``expressions'' of the language and
consider it merely a collection of abstract synthetic and analytic
functions and predicates for forming, discriminating and taking apart
*abstract expressions*. However, the languages considered at that
time always admitted representations as strings of symbols.

If we consider concepts as a free algebra on basic concepts,
then we can regard them as strings of symbols on some alphabet if we
want to, assuming that we don't object to a non-denumerable alphabet
or infinitely long expressions if we want standard concepts for all
the real numbers. However, if we want to regard *Equal*(*X*,*Y*) and
*Equal*(*Y*,*X*) as the same concept, and hence as the same ``expression''
in our language, and we want to regard expressions related by
renaming bound variables as denoting the same concept, then
the algebra is no longer free, and regarding
concepts as strings of symbols becomes awkward even if possible.

It seems better to accept the notion of *abstract language*
defined by the collection of functions and predicates that form,
discriminate, and extract the parts of its ``expressions''.
In that case it would seem that
concepts can be identified with expressions in an abstract language.

Sun Mar 10 22:57:10 PST 1996