**Symbolic Manipulation Program**, usually called **SMP**, was a computer algebra system designed by Chris A. Cole and Stephen Wolfram at Caltech circa 1979 and initially developed in the Caltech physics department. It was first sold commercially in 1981 by the Computer Mathematics Corporation of Los Angeles which later became part of Inference Corporation; Inference Corp. further developed the program and marketed it commercially from 1983 to 1988. SMP was essentially Version Zero of the more ambitious Mathematica system.

As we can assume due to the name, the core of SMP is (was) symbol. Let’s study it more.

### Motivation for SMP (see)

The primary motivation for the construction of the SMP program was the necessity of performing very complicated algebraic manipulations in certain areas of theoretical physics. The need to deal with advanced mathematical constructs required the program to be of great generality. In addition, the size of the calculations anticipated demanded that the program should operate quickly and be capable of handling very large amounts of data. The resulting program is expected to be valuable in a wide variety of applications.

### Main principles of SMP (see)

The basic purpose of SMP is to manipulate symbolic expressions. These expressions may represent algebraic formulae, on which mathematical operations are performed. By virtue of their symbolic nature, they may also represent procedures and actions.

**The ability to manipulate symbolic expressions, as well as sets of numbers, allows for much greater generality and a much richer architecture than in numerical computer languages. **

**The structure of expressions in SMP is defined recursively as follows:**

exprconsists ofsymbol(1)

orexpr[expr,expr,…] (projection) (2)

or { [expr]:expr, [expr]:expr,…} (list) (3)

Symbols are the fundamental units. Projections represent extraction of a part in an expression. Lists allow expressions to be collected together.

**These three fundamental forms suffice to represent all the objects, operations and procedures required in symbolic manipulations.**

### Comparison with Symbolic Analysis

In Symbolic Analysis our model to represent all objects etc is even more simple, much simpler. In it the only artefact is symbol itself. It is possible because of the hybrid structure of the symbolic element (see more about AHO and Symbol). We argue, that Symbol is the core of core computer science.

### Case 1: Symbol at SMP (see)

Symbols are labelled by a unique name (e.g. `x3` or `Mult`) which is used to represent them for input and output. Expressions may be assigned as values for symbols. A symbol to which a value has been assigned becomes essentially a short notation for its value, and is replaced by the value whenever it occurs. If no value has been assigned to a symbol, the results of (most) operations are such as would hold for any possible value of the symbol. The set of possible values represented by a symbol may be delimited by assigning a list of properties to the symbol.

### Case 2: Projection at SMP (see)

The projection `f[ expr]` represents the part of the expression

`f`selected by the “filter”

*expr*. If

`f`is a list, the entry with index

*expr*is selected. If

`f`is a symbol with no value, operations performed on

`f[`hold for any value of

*expr*]`f`. Properties assigned to

`f`may specify particular treatment. “System-defined” symbols stand for many fundamental operations. Projections from these symbols (e.g.

`Plus`) yield expressions which represent the action of these operations on the filter expressions.

### Case 3: Lists at SMP (see)

Lists are ordered and indexed sets of expressions. The index and value of each entry in a list may be arbitrary expressions. A particular value in a list is extracted by projection with the corresponding index as a filter. If the value of some symbol `f` is a list, the entries of the list describe parts of the “object” `f`: they give the values for projections of `f` with different filters. Entries may be introduced into such a list by assignment of values for projections of `f`.

For example, `f:{ [1]: a} ` (or `f[1]: a`) defines `f` to be an object whose projection with filter `1` is `a`. The values of other projections from `f` remain unspecified. `f[x+y]: (x+y)^2` then yields {`{ `[x+y]: (x+y)^2, [1]: a} } and defines the value for a projection of `f` with filter `x+y` to be `(x+y)^2`.

### Symbolic Analysis is a Reverse Engineering Architecture and Methodology

Meanwhile SMP has been written for expressing mathematical formulas and equations, the main purpose of symbolic analysis was reverse engineering: expressing program models in the symbolic notation. However, there are many similar needs and goals in both of them. It is obvious that symbolic analysis can be extended into mathematic formulations, too, because its internal formalism allows presenting semantics for a wide range of formal languages expressions.

### Correspondence between SMP and symbolic analysis

It is obvious that any expression of SMP can be transformed into the symbolic analysis model, only by extending the Symbolic language for the necessary expressions. Lists (case 3) and projections (case 2) can be some extensions to the Symbolic language, the *clause *definition.

### Mathematica

Mathematica is the follower of SMP. In it **everything is an expression**. There are 3000 different expressions in it. See a video .

*Note***: In symbolic analysis (Laitila) everything is a symbol.**

### Some links:

- Symbolic Manipulation Program at Wiki: http://en.wikipedia.org/wiki/Symbolic_Manipulation_Program
- Foundation for SMP: http://www.stephenwolfram.com/publications/articles/computing/81-smp/index.html
- Documentation for Mathematica at WolframResearch: http://reference.wolfram.com/mathematica/guide/Mathematica.html

## Leave a comment

Comments feed for this article