After reading the answers each one of you gave, I concluded that although
some aspects were similar, there are some differences that are not syntactic.
The following is the summary of the opinions, followed by excerpts from the
answers I got.


Predicate logic -

1) When I want to precisely axiomatize some aspect of the world,
	without necessarily implementing it.
2) This is appropriate for systems that require high expressive power.
	An example might be a mathematical theorem-prover, which is
	operating on FOPL.

Production rules -

1) When I want to declaratively summarize the results of a search process.
2) Fine if you can compartmentalize the components of your system;
	bad if you have complex interrelationships.
3) Most useful in domains where most of the reasoning is of the "cause and
	effect" genre.
4) Most useful when one does not have a model of the system analyzed, or does
	not have a lot of inference power (e.g., expert systems).


Semantic nets -

1) For a quickly implementable organized description of a domain, in which
	I don't need sophisticated inference.  E.g., a computer network
	configuration.
2) Useful when the interrelatedness of concepts is critical; 
	this is excellently well-suited for systems designed to categorize 
	information or reason categorically.  However, it offers no guidance
	about how to reason.
3) Makes taxonomic-type representation and inferences very efficient and
	natural. Incomplete information can not be dealt.


Frames - 

1) Similar to semantic nets, where I need more structure. 
2) More inference complexity, and better representation power. Another point
	on the tradeoff scale.


CD -

1) No one uses it any more (But Schank's group).
2) Useful for Natural Language semantic representation. Useful for representing
	events, but very complicated to use.


Scripts -

1) Useful when you are reasoning about recurring scenarios, but useless when
	you haven't or can't build generic representations for episodes.
2) In NLP it is useful in filling in the details of a given narrative,
	or inferring about the plans and goals of the agents. Aids in filling
	in the missing details.


CYCL -

1) It was designed to serve the CYC project and may not have use elsewhere.
2) It should be at least as capable as frames or semantic nets (or 1st order
	logic for that matter) for representing	information, though it might
	be an overkill for smaller systems.
3) For domains where a great portion of reasoning is inheritance-related,
	but where a richer form of expression and constraints was occasionally
	required, it might be useful.



* Note the resemblance of CYC to KRYPTON. The latter has a better truth theory,
	and a clear semantics though.


-------------------------------------------------------------------------


Avi
===

Predicate logic - when I want to precisely axiomatize some aspect of the
world, without necessarily implementing it.  This can serve as a blueprint
for more practical representations.  E.g., formal theories of action.

Production rules - when I want to declaritively summarize the results of a
search process.   The search produces rules of the form "If the state is X,
do Y", where X and Y can be relationally specified.  Given a concrete set
of such rules, they can be analyzed to produce more general and abstract
rules.

Semantic nets - for a quickly implementable organized description of a
domain, in which I don't need sophisticated inference.  E.g., a computer
network configuration.

Frame systems - similar to semantic nets, where I need more structure. 
E.g., a computer network, its users, their permissions and so on.

Conceptual dependency - when I'm working for Schank.  Seriously, does
anyone use it anymore?  If I had to answer this with a straight face, I
would say it serves as a unifying language in which natural actions can be
expressed in terms of a few primitives.

Scripts - when I want to model the typical development of a real-world
scenario - this idea is independent of CD.

CYC - as a representational framework, I think it was designed to serve the
CYC project and may not have use elsewhere.   If I want to represent a
domain in a way that can interface with other domains, I would use
Ontolingua or Loom.



Patrick
=======

Gosh, this is a good question.

Predicate Logic:  This is appropriate for systems that require high 
expressive power.  An example might be a mathematical theorem-prover, which 
is operating on FOPL.  It would be inappropriate for systems that do not 
require that power (when the extra expressivity makes reasoning more 
difficult), such as a database engine.  The tradeoff issue here is full 
expressivity at the cost of complex reasoning.

Production Rules:  Fine if you can compartmentalize the components of your 
system; bad if you have complex interrelationships.  Laird and Newell (via 
SOAR) would argue that production rules are appropriate for all forms of 
reasoning, and in fact many agent architectures take this approach.  It 
makes creating and maintaining the system easy since each rule can be 
modified without directly affecting other rules.  It would be a bad system 
for representing simple declarative knowledge, though (for example, a 
database).

Semantic Nets:  Useful when the interrelatedness of concepts is critical; 
this is excellently well-suited for systems designed to categorize 
information or reason categorically.  However, it offers no guidance about 
how to reason.  Generally semantic nets cannot represent the negations of 
facts nor incomplete information.  Great for building a hierarchy of living 
creatures; not so good for ordered, non-abstract data such as occurs in a 
natural language sentence.

Frames:  Semantic nets with slots.  Appropriate for representing objects, 
general and specific, that are related to one another in a conceptual 
hierarchy.  Useful when you need a more complex representation than 
semantic nets will give you; for example, needing to record specific 
facts about objects in your hierarchy or relating the values of aspects 
of one object to the values of aspects in others.

Conceptual Dependency:  Ick.  A workable system for representing natural 
language descriptions of events, and lousy at almost everything else.  Bad 
for representing concepts, describing objects.  Designed for a very 
specific purpose.

Scripts:  Scripts are designed to give a semantic framework for a 
sequence of events in an abstract way.  They are useful when the system 
will often encounter the same kinds of situations (the restaurant 
example) and would like to use general knowledge about such situations to 
reason about them (what slots are filled, what slots need to be filled, 
what is coming next).  Useful when you are reasoning about recurring 
scenarios, but useless when you haven't or can't build generic 
representations for episodes.

CYC:  CYC is meant to be a comprehensive system for representing 
commonsense knowledge.  As such, it should be at least as capable as 
frames or semantic nets for representing information, though it might be 
overkill for smaller systems -- interestingly I'm not aware of anyone 
other than the CYC project using CYCL for knowledge representation.



Pedrito
=======


Predicate Logic
unrestricted predicate logic, being the powerful beast it is, can be
correspondingly intractible to reason with in the worst case. i would
resort to using it only if other subsets such as those listed below were
not expressive enough for the domain. even in this case, i would want to
try to take advantage of domain structure to help make the common forms of
reasoning efficient.

Production Rules
production rules are very efficient, i believe, for expressing and
reasoning with knowledge of the form "if a is true, then b is true" or "if
a is true, then do b". my guess is that production rules are most useful
in domains where most of the reasoning is of the "cause and effect" genre,
and where there aren't an intractable number of exceptions to the typical
sequences.

Semantic Nets and Frames
semantic nets and frames were designed to make taxonomic-type
representation and inferences very efficient and natural. i would consider
using them in hierarchical domains where questions about inheritance,
subsumption, etc. were common, but where incomplete information was not an
issue.

Conceptual Dependency
the theory of conceptual dependencies was developed to express the kind of
information about events described in natural language sentences.

Scripts
scripts are useful for describing stereotypical sequences of events, or at
least sequences that don't deviate significantly from the stereotypes.

question: what, if any, are the fundamental differences between the cd and
script representation methodologies?

CYC
cyc attempts to combine the benefits of a frame system, such as efficient
support for inheritance reasoning, with the expressive power of fol,
allowing fol constraints on the slots. thus, i would probably choose cyc
for domains where a great portion of reasoning was inheritance-related,
but where a richer form of expression and constraints was occasionally
required. 

the answers aren't as detailed--no concrete examples--or as double-checked
as i would have liked, but my clock was getting angsty. 

i was unaware that we would be just aggregating answers with names and
all.  i was under the impression that the questioner would compile the
"last word" on the subject from all the answers. i guess i'll just have to
be a bit careful and write my answers with a broader audience in mind :). 


Eyal
====

Predicate Logic - It is more expressive than all other but CYC. It is, on
the other hand, simpler than CYC, and sometime we do not need the full power
of a large knowledge base. Example: Proving mathematical theorems.

Production Rules - More functional oriented than all others, and thus is
more useful in planning and expert systems where the knowledge base is pretty
big, but the inference power need not necessarily be big. Example: Analysis
of a patient's problem such as the one in MYCIN, is definitely not model-based,
and rules are the most suitable from the above (which are mostly suitable for
model-based reasoning).

Semantic Nets - Simple inheritance and therefore simple calculation method.
More suitable to knowledge that emphasizes the links/relations among the
entities, rather than the entities themselves. Example: Representing the links
over the WWW.

Frames - More options for various parts of the entity, emphasizing the
frame rather than the link. We can have defaults, restrictions on types,
slots can be forward calculating (if-changed), or backward calculating
(if-needed). Example: Representing knowledge about animal families, and their
properties.

CDs - More suitable to NLP, low-level primitives. Event oriented. Example:
A generic representation for NLP, when we emphasize the events.

Scripts - Sequences of events in a context. Used to predict unobserved events.
Example: In NLP it is useful in filling in the details of a given narrative,
or infering about the plans and goals of the agents.

CYC - Large KB, Common Sense, Ontologies and many other KR tools. It is better
used in an environment using Common Sense, and in need for a large KB.
Example: Constructing a Plan fot having dinner with friends in a restaurant