In mathematics, an **expression** is a written arrangement of symbols following the context-dependent, syntactic conventions of mathematical notation. Symbols can denote numbers (constants), variables, operations, functions. Other symbols include punctuation signs and brackets (often used for grouping, that is for considering a part of the expression as a single symbol).

Many authors distinguish an expression from a *formula*, the former denoting a mathematical object, and the latter denoting a statement about mathematical objects.^{[1]} This is analogous to natural language, where a noun phrase refers to an object, and a whole sentence refers to a fact. For example, is an expression, while is a formula.

Expressions can be *evaluated* or *partially evaluated* by replacing operations that appear in them with their result. For example, the expression evaluates partially to and totally to

An expression is often used to define a function, by taking the variables to be arguments, or inputs, of the function, and assigning the output to be the total evaluation of the resulting expression.^{[2]} For example, and define the function that associates to each number its square plus one. An expression with no variables would define a constant function.

The use of expressions ranges from the simple:

- (linear polynomial)

- (quadratic polynomial)

- (rational fraction)

to the complex:

Many expressions include variables. Any variable can be classified as being either a free variable or a bound variable.

For a given combination of values for the free variables, an expression may be evaluated, although for some combinations of values of the free variables, the value of the expression may be undefined. Thus an expression represents an operation over constants and free variables and whose output is the resulting value of the expression.^{[3]}

For example, if the expression is evaluated with *x* = 10, *y* = 5, it evaluates to 2; this is denoted

- The evaluation is undefined for
*y*= 0

Two expressions are said to be equivalent if, for each combination of values for the free variables, they have the same output, i.e., they represent the same function. ^{[4]}^{[5]}
The equivalence between two expressions is called an identity and is often denoted with

For example, in the expression the variable *n* is
bound, and the variable *x* is free. This expression is equivalent to the simpler expression 12 *x*; that is
The value for *x* = 3 is 36, which can be denoted

An expression is a syntactic construct. It must be well-formed. It can be described somewhat informally as follows: the allowed operators must have the correct number of inputs in the correct places, the characters that make up these inputs must be valid, have a clear order of operations, etc. Strings of symbols that violate the rules of syntax are not well-formed and are not valid mathematical expressions.^{[6]}

For example, in arithmetic, the expression *1 + 2 × 3* is well-formed, but

- .

is not.

Semantics is the study of meaning. Formal semantics is about attaching meaning to expressions.

In algebra, an expression may be used to designate a value, which might depend on values assigned to variables occurring in the expression.^{[citation needed]} The determination of this value depends on the semantics attached to the symbols of the expression. The choice of semantics depends on the context of the expression. The same syntactic expression *1 + 2 × 3* can have different values (mathematically 7, but also 9), depending on the order of operations implied by the context (See also Operations § Calculators).

The semantic rules may declare that certain expressions do not designate any value (for instance when they involve division by 0); such expressions are said to have an undefined value, but they are well-formed expressions nonetheless. In general the meaning of expressions is not limited to designating values; for instance, an expression might designate a condition, or an equation that is to be solved, or it can be viewed as an object in its own right that can be manipulated according to certain rules.^{[citation needed]} Certain expressions that designate a value simultaneously express a condition that is assumed to hold, for instance those involving the operator to designate an internal direct sum.

A well-formed expression in mathematics can be described as part of a formal language, and defined recursively as follows:^{[7]}

The alphabet consists of:

- A set of Constants / Definites: Symbols representing fixed objects in the domain of discourse, such as numbers (1, 2.5, 1/7, ...), sets (, ...), truth values (T or F), etc.

- A set of variable names: A countably infinite amount of variables used for representing mathematical objects in the domain. (Usually letters like x, or y)

- A set of operations: Symbols representing operations that can be performed on elements over the domain, like addition (+), multiplication (×), or set operations like union (∪), or intersection (∩). (Functions can be understood as unary operations)

- Brackets ( )

With this alphabet, the recursive rules for forming well-formed expression (WFE) are as follows:

- Any constant or variable as defined are the atomic expressions (the simplest WFE's). For instance, the expressions "" or "" are syntactically correct expressions.

- Let be a metavariable for some n-ary operation over the domain, and let be metavariables for any WFE's.

- Then is also a WFE.
- For instance, if the domain of discorse is the real numbers, can denote the binary operation +, then is a WFE. Or can be the unary operation , then is as well.
- Brackets are initially around each non-atomic expression, but they can be deleted in cases where there is a defined order of operations, or where order doesn't matter (i.e. where operations are associative)

A well-formed expression can be thought as a syntax tree.^{[8]} The leaf nodes are always atomic expressions. Operations and have exactly two child nodes, while operations , and have exactly one. There are countably infinitely many WFE's, however, each WFE has a finite number of nodes.

Formal languages allow formalizing the concept of well-formed expressions.

In the 1930s, a new type of expressions, called lambda expressions, were introduced by Alonzo Church and Stephen Kleene for formalizing functions and their evaluation. ^{[9]}^{[a]} They form the basis for lambda calculus, a formal system used in mathematical logic and the theory of programming languages.

The equivalence of two lambda expressions is undecidable. This is also the case for the expressions representing real numbers, which are built from the integers by using the arithmetical operations, the logarithm and the exponential (Richardson's theorem)

An *algebraic expression* is an expression built up from algebraic constants, variables, and the algebraic operations (addition, subtraction, multiplication, division and exponentiation by a rational number).^{[10]} For example, 3*x*^{2} − 2*xy* + *c* is an algebraic expression. Since taking the square root is the same as raising to the power 1/2, the following is also an algebraic expression:

See also: Algebraic equation and Algebraic closure

A polynomial expression is an expression built with scalars (numbers of elements of some field), indeterminates, and the operators of addition, multiplication, and exponentiation to nonnegative integer powers; for example

Using associativity, commutativity and distributivity, every polynomial expression is equivalent to a polynomial, that is an expression that is a linear combination of products of integer powers of the indeterminates. For example the above polynomial expression is equivalent (denote the same polynomial as

Many author do not distinguish polynomials and polynomial expressions. In this case the expression of a polynomial expression as a linear combination is called the *canonical form*, *normal form*, or *expanded form* of the polynomial.

In computer science, an *expression* is a syntactic entity in a programming language that may be evaluated to determine its value^{[11]} or fail to terminate, in which case the expression is undefined.^{[12]} It is a combination of one or more constants, variables, functions, and operators that the programming language interprets (according to its particular rules of precedence and of association) and computes to produce ("to return", in a stateful environment) another value. This process, for mathematical expressions, is called *evaluation*.
In simple settings, the resulting value is usually one of various primitive types, such as string, boolean, or numerical (such as integer, floating-point, or complex).

In computer algebra, formulas are viewed as expressions that can be evaluated as a Boolean, depending on the values that are given to the variables occurring in the expressions. For example takes the value *false* if x is given a value less than 1, and the value *true* otherwise.

Expressions are often contrasted with statements—syntactic entities that have no value (an instruction).

Except for numbers and variables, every mathematical expression may be viewed as the symbol of an operator followed by a sequence of operands. In computer algebra software, the expressions are usually represented in this way. This representation is very flexible, and many things that seem not to be mathematical expressions at first glance, may be represented and manipulated as such. For example, an equation is an expression with "=" as an operator, a matrix may be represented as an expression with "matrix" as an operator and its rows as operands.

See: Computer algebra expression

In mathematical logic, a *"logical expression"* can reffer to either terms or formulas. A term denotes a mathematical object while a formula denotes a mathematical fact. In particular, terms appear as components of a formula.

A first-order term is recursively constructed from constant symbols, variables, and function symbols. An expression formed by applying a predicate symbol to an appropriate number of terms is called an atomic formula, which evaluates to true or false in bivalent logics, given an interpretation. For example, is a term built from the constant 1, the variable x, and the binary function symbols and ; it is part of the atomic formula which evaluates to true for each real-numbered value of x.

**^**Stoll, Robert R.*Set Theory and Logic*. San Francisco, CA: Dover Publications. ISBN 978-0-486-63829-4.**^**Codd, Edgar Frank (June 1970). "A Relational Model of Data for Large Shared Data Banks" (PDF).*Communications of the ACM*.**13**(6): 377–387. doi:10.1145/362384.362685. S2CID 207549016. Archived (PDF) from the original on 2004-09-08. Retrieved 2020-04-29.**^**C.C. Chang; H. Jerome Keisler (1977).*Model Theory*. Studies in Logic and the Foundation of Mathematics. Vol. 73. North Holland.; here: Sect.1.3**^**Equation. Encyclopedia of Mathematics. URL: http://encyclopediaofmath.org/index.php?title=Equation&oldid=32613**^**Pratt, Vaughan, "Algebra", The Stanford Encyclopedia of Philosophy (Winter 2022 Edition), Edward N. Zalta & Uri Nodelman (eds.), URL: https://plato.stanford.edu/entries/algebra/#Laws**^**Stoll, Robert R.*Set Theory and Logic*. San Francisco, CA: Dover Publications. ISBN 978-0-486-63829-4.**^**C.C. Chang; H. Jerome Keisler (1977).*Model Theory*. Studies in Logic and the Foundation of Mathematics. Vol. 73. North Holland.; here: Sect.1.3**^**Hermes, Hans (1973).*Introduction to Mathematical Logic*. Springer London. ISBN 3540058192. ISSN 1431-4657.; here: Sect.II.1.3**^**Church, Alonzo (1932). "A set of postulates for the foundation of logic".*Annals of Mathematics*. Series 2.**33**(2): 346–366. doi:10.2307/1968337. JSTOR 1968337.**^**Morris, Christopher G. (1992).*Academic Press dictionary of science and technology*. Gulf Professional Publishing. p. 74.algebraic expression over a field.

**^**Mitchell, J. (2002). Concepts in Programming Languages. Cambridge: Cambridge University Press,*3.4.1 Statements and Expressions*, p. 26**^**Maurizio Gabbrielli, Simone Martini (2010). Programming Languages - Principles and Paradigms. Springer London,*6.1 Expressions*, p. 120**^**Cassidy, Kevin G. (Dec 1985).*The Feasibility of Automatic Storage Reclamation with Concurrent Program Execution in a LISP Environment*(PDF) (Master's thesis). Naval Postgraduate School, Monterey/CA. p. 15. ADA165184.

**^**For a full history, see Cardone and Hindley's "History of Lambda-calculus and Combinatory Logic" (2006).

- Redden, John (2011). "Elementary Algebra".
*Flat World Knowledge*. Archived from the original on 2014-11-15. Retrieved 2012-03-18.

General | |||||||||
---|---|---|---|---|---|---|---|---|---|

Theorems (list) and paradoxes | |||||||||

Logics |
| ||||||||

Set theory |
| ||||||||

Formal systems (list), language and syntax |
| ||||||||

Proof theory | |||||||||

Model theory | |||||||||

Computability theory | |||||||||

Related | |||||||||