ArticleslgStudy

computer science

SNePS

SNePS is a computer science topic covered in the lgStudy science library. This page brings together a partial reference excerpt, illustrations, worked examples, real-world applications and a short study plan, so you can understand SNePS rather than just read about it. In short: SNePS is a knowledge representation, reasoning, and acting (KRRA) system developed and maintained by Stuart C. Shapiro and colleagues at the State University of New York at Buffalo.

Key takeaways

  • SNePS belongs to computer science; place it in that map before memorising details.
  • Learn the definition first, then one example that makes the definition concrete.
  • Connect SNePS to a quantity you can measure, compute or draw — that is where exam questions come from.
  • Reproduce the core statement of SNePS from memory before moving on to harder problems.

Reference excerpt

SNePS is a knowledge representation, reasoning, and acting (KRRA) system developed and maintained by Stuart C. Shapiro and colleagues at the State University of New York at Buffalo. SNePS is simultaneously a logic-based, frame-based, and network-based KRRA system. It uses an assertional model of knowledge, in that a SNePS knowledge base (KB) consists of a set of assertions (propositions) about various entities. Its intended model is of an intensional domain of mental entities—the entities conceived of by some agent, and the propositions believed by it. The intensionality is primarily accomplished by the absence of a built-in equality operator, since any two syntactically different terms might have slightly different Fregean senses. SNePS has three styles of inference: formula-based, derived from its logic-based personality; slot-based, derived from its frame-based personality; and path-based, derived from its network-based personality. However, all three are integrated, operating together. SNePS may be used as a stand-alone KRR system. It has also been used, along with its integrated acting component, to implement the mind of intelligent agents (cognitive robots), in accord with the GLAIR agent architecture (a layered cognitive architecture). The SNePS Research Group often calls its agents Cassie.

SNePS as a Logic-Based System As a logic-based system, a SNePS KB consists of a set of terms, and functions and formulas over those terms. The set of logical connectives and quantifiers extends the usual set used by first-order logics, all taking one or more arbitrarily-sized sets of arguments. In accord with the intended use of SNePS to represent the mind of a natural-language-competent intelligent agent, propositions are first-class entities of the intended domain, so formulas are actually proposition-denoting functional terms. SNePSLOG, the input-output language of the logic-based face of SNePS, looks like a naive logic in that function symbols (including "predicates"), and formulas (actually proposition-denoting terms) may be the arguments of functions and may be quantified over. The underlying SNePS, however, is a first order logic, with the user's function symbols and formulas reified. Formula-based inference is implemented as a natural-deduction-style inference engine in which there are introduction and elimination rules for the connectives and quantifiers. SNePS formula-based inference is sound but not complete, as rules of inference that are less useful for natural language understanding and commonsense reasoning have not been implemented. A proposition-denoting term in a SNePS KB might or might not be "asserted", that is, treated as true in the KB. The SNePS logic is a paraconsistent version of relevance logic, so that a contradiction does not imply anything whatsoever. Nevertheless, SNeBR, the SNePS Belief Revision subsystem, will notice any explicit contradiction and engage the user in a dialogue to repair it. SNeBR is an Assumption-Based Truth Maintenance System (ATMS), and removes the assertion status of any proposition whose support has been removed.

SNePS as a Frame-Based System As a frame-based system, every SNePS functional term (including proposition-valued terms) is represented by a frame with slots and fillers. Each slot may be filled by an arbitrarily-sized set of other terms. However, cycles cannot be constructed. SNePSUL, the SNePS User Language is an input-output language for interacting with SNePS in its guise as a frame-based system. SNePSLOG may be used in any of three modes. In two modes, the caseframe (set of slots) associated with each functional term is determined by the system. In mode 3, the user declares what caseframe is to be used for each function symbol. In slot-based inference, any proposition-valued frame is considered to imply the frame with any of its slots filled by a subset of its fillers. In the current implementation, this is not always sound.

SNePS as a Network-Based System As a network-based system, SNePS is a propositional semantic network, thus the original meaning of "SNePS" as "The Semantic Network Processing System". This view is obtained by considering every individual constant and every functional term to be a node of the network, and every slot to be a directed labeled arc from the frame-node it is in to every node in its filler. In the intended interpretation, every node denotes a mental entity, some of which are propositions, and every proposition represented in the network is represented by the node that denotes it. Some nodes are variables of the SNePS logic, and they range over nodes, and only over nodes. Path-based inference rules may be defined, although they, themselves, are not represented in SNePS. A path-based inference rule specifies that some labeled arc r may be inferred as present from some node n to some other node m just in case a given path exists from n to m. There is an extensive recursive set of path constructors available.

Components SNIP, the SNePS Inference Package, provides the rules of inference with which SNePS deduces new assertions from an existing KB. SNeBR, the SNePS Belief Revision package, is a component of SNePS that detects when the KB contains contradictory beliefs. When a contradiction is detected, the user is encouraged to unassert one of the contradictory beliefs by unasserting some underlying hypotheses that led to the contradiction. As a result, all propositions that had been inferred from the hypotheses that have been unasserted are also unasserted. SNeRE, the SNePS Rational Engine, provides an acting executive and a set of frames for building up complex acts and plans from a set of system-defined and user-defined primitive actions. System-defined frames allow for the specification of sequences of acts, conditional acts, and iteration over acts, as well as believing and disbelieving propositions. SNeRE policies connect acting to inference, specifying, for example, that a certain act is to be done when a certain proposition is believed (asserted). SNaLPS, the SNePS Natural Language Processing System, consists of a Generalized Augmented Transition Network Grammar interpreter and an English morphological analyzer and synthesizer so that natural language understanding and generation may be provided for SNePS-based agents.

… excerpt ends here. Continue reading the full article.

Worked examples

Example 1 — a first encounter with SNePS

Start with the simplest possible case. Write down what SNePS claims or describes in one sentence, then invent the smallest concrete situation in which that sentence is true. In computer science, the smallest case is usually a single object, a single equation or a single measurement. Check that every symbol or term in your sentence has a meaning in that case.

Example 2 — changing one variable

Take the situation from Example 1 and change exactly one quantity: double it, halve it, or set it to zero. Predict what should happen to SNePS before you calculate. Comparing your prediction with the result is the fastest way to find out whether you understand the idea or only the words.

Example 3 — an exam-style question

Typical questions about SNePS ask you to (a) state it precisely, (b) apply it to given data, and (c) explain a limitation. Practise writing all three answers in under five minutes; the third part is what separates a full-mark answer from an average one.

Applications of SNePS

In research
SNePS appears in computer science research whenever the underlying quantities have to be modelled precisely. Papers usually cite it as a starting assumption and then explore where it breaks down.
In technology and industry
Engineering practice reuses SNePS in design rules, simulations and safety margins. Knowing the idea lets you read a specification sheet and understand why the numbers look the way they do.
In the classroom
SNePS is common in secondary-school and first-year university syllabi. It links to neighbouring topics Cognitive architecture, Common Lisp (programming language) software, Knowledge representation software, so understanding it makes those chapters shorter.
In everyday life
Look for SNePS outside the textbook — in sport, cooking, traffic, electronics or the sky above you. An example you found yourself is remembered far longer than one you were given.

Affiliate

Preply — study more efficiently by working with a personal tutor. 50% off.

How to study SNePS in 20 minutes

  1. Read the reference excerpt below once, without taking notes.
  2. Close the page and write down what SNePS means in your own words.
  3. Compare your version with the excerpt and mark what you missed.
  4. Work through the three examples above with pen and paper.
  5. Explain SNePS out loud to somebody else — or to Teacher Smith in the lgStudy chat.

Frequently asked questions

What is SNePS in simple terms?

SNePS is a knowledge representation, reasoning, and acting (KRRA) system developed and maintained by Stuart C. Shapiro and colleagues at the State University of New York at Buffalo.

Why does SNePS matter?

Because it connects several computer science ideas at once: it gives you a definition you can apply, a quantity you can calculate, and a way to check whether a result is plausible.

How should I study SNePS?

Read the excerpt, restate it from memory, then work through the examples and applications listed on this page. The five-step study plan above takes about twenty minutes.

What does this page cover?

It gives you a compact reference excerpt plus original lgStudy explanations, examples, applications and study material on SNePS.

Tags

  • Cognitive architecture
  • Common Lisp (programming language) software
  • Knowledge representation software

Keep exploring