Arity

In logic, mathematics, and computer science, arity (/ˈærɪti/ (listen)) is the number of arguments or operands taken by a function, operation or relation. In mathematics, arity may also be called rank,[1][2] but this word can have many other meanings. In logic and philosophy, arity may also be called adicity and degree.[3][4] In linguistics, it is usually named valency.[5]

## Contents

* 1 Examples
* 1.1 Nullary
* 1.2 Unary
* 1.3 Binary
* 1.4 Ternary
* 1.5 n-ary
* 1.6 Varying arity
* 2 Terminology
* 3 See also
* 4 References
* 5 External links

## Examples

In general, functions or operators with a given arity follow the naming conventions of n-based numeral systems, such as binary and hexadecimal. A Latin prefix is combined with the -ary suffix. For example:

* A nullary function takes no arguments.
* Example: f()=2
* A unary function takes one argument.
* Example: f(x)=2x
* A binary function takes two arguments.
* Example: f(x,y)=2xy
* A ternary function takes three arguments.
* Example: f(x,y,z)=2xyz
* An n-ary function takes n arguments.
* Example: f(x1,x2,…,xn)=2∏i=1nxi

### Nullary

A constant can be treated as the output of an operation of arity 0, called a nullary operation.

Also, outside of functional programming, a function without arguments can be meaningful and not necessarily constant (due to side effects). Such functions may have some hidden input, such as global variables or the whole state of the system (time, free memory, etc.).

### Unary

Examples of unary operators in mathematics and in programming include the unary minus and plus, the increment and decrement operators in C-style languages (not in logical languages), and the successor, factorial, reciprocal, floor, ceiling, fractional part, sign, absolute value, square root (the principal square root), complex conjugate (unary of "one" complex number, that however has two parts at a lower level of abstraction), and norm functions in mathematics. In programming the two's complement, address reference, and the logical NOT operators are examples of unary operators.

All functions in lambda calculus and in some functional programming languages (especially those descended from ML) are technically unary, but see n-ary below.

According to Quine, the Latin distributives being singuli, bini, terni, and so forth, the term "singulary" is the correct adjective, rather than "unary".[6] Abraham Robinson follows Quine's usage.[7]

In philosophy, the adjective monadic is sometimes used to describe a one-place relation such as 'is square-shaped' as opposed to a two-place relation such as 'is the sister of'.

### Binary

Most operators encountered in programming and mathematics are of the binary form. For both programming and mathematics, these include the multiplication operator, the radix operator, the often omitted exponentiation operator, the logarithm operator, the addition operator, and the division operator. Logical predicates such as OR, XOR, AND, IMP are typically used as binary operators with two distinct operands. In CISC architectures, it is common to have two source operands (and store result in one of them).

### Ternary

Most modern CPUs provide a ternary fused multiply–add (FMA) instruction for floating-point numbers, which multiplies two numbers and adds the result to a third number, only rounding once at the end. This avoids the inaccuracy resulting from rounding the multiplication and addition operations separately.

The computer programming language C and its various descendants (including C++, C#, Java, Julia, Perl, and others) provide the ternary conditional operator `?:`. The first operand (the condition) is evaluated, and if it is true, the result of the entire expression is the value of the second operand, otherwise it is the value of the third operand. This operator has a lazy or 'shortcut' evaluation strategy that does not evaluate whichever of the second and third arguments is not used. Some functional programming languages, such as Agda, have such an evaluation strategy for all functions and consequently implement `if...then...else` as an ordinary function; several others, such as Haskell, can do this but for syntactic, performance or historical reasons choose to define keywords instead.

The Python language has a ternary conditional expression, `x if C else y`. In Elixir the equivalent would be `if(C, do: x, else: y)`.

The Forth language also contains a ternary operator, `*/`, which multiplies the first two (one-cell) numbers, dividing by the third, with the intermediate result being a double cell number. This is used when the intermediate result would overflow a single cell.

The Unix dc calculator has several ternary operators, such as `|`, which will pop three values from the stack and efficiently compute xymodz with arbitrary precision.

Many (RISC) assembly language instructions are ternary (as opposed to only two operands specified in CISC); or higher, such as `MOV %AX, (%BX, %CX)`, which will load (MOV) into register AX the contents of a calculated memory location that is the sum (parenthesis) of the registers BX and CX.

### n-ary

The arithmetic mean of n real numbers is an n-ary function: x¯=1n(∑i=1nxi)=x1+x2+…+xnn

Similarly, the geometric mean of n positive real numbers is an n-ary function: (∏i=1nai)1n= a1a2⋯ann. Note that a logarithm of the geometric mean is the arithmetic mean of the logarithms of its n arguments

From a mathematical point of view, a function of n arguments can always be considered as a function of a single argument that is an element of some product space. However, it may be convenient for notation to consider n-ary functions, as for example multilinear maps (which are not linear maps on the product space, if n ≠ 1).

The same is true for programming languages, where functions taking several arguments could always be defined as functions taking a single argument of some composite type such as a tuple, or in languages with higher-order functions, by currying.

### Varying arity

In computer science, a function that accepts a variable number of arguments is called variadic. In logic and philosophy, predicates or relations accepting a variable number of arguments are called multigrade, anadic, or variably polyadic.[8]

## Terminology

Latinate names are commonly used for specific arities, primarily based on Latin distributive numbers meaning "in group of n", though some are based on Latin cardinal numbers or ordinal numbers. For example, 1-ary is based on cardinal unus, rather than from distributive singulī that would result in singulary.

n-ary | Arity (Latin based) | Adicity (Greek based) | Example in mathematics | Example in computer science

|
|
|
|

0-ary | nullary (from nūllus) | niladic | a constant | a function without arguments, True, False
1-ary | unary | monadic | additive inverse | logical NOT operator
2-ary | binary | dyadic | addition | logical OR, XOR, AND operators
3-ary | ternary | triadic | triple product of vectors | ternary conditional operator
4-ary | quaternary | tetradic |  |
5-ary | quinary | pentadic |  |
6-ary | senary | hexadic |  |
7-ary | septenary | hebdomadic |  |
8-ary | octonary | ogdoadic |  |
9-ary | novenary (alt. nonary) | enneadic |  |
10-ary | denary (alt. decenary) | decadic |  |
more than 2-ary | multary and multiary | polyadic |  |
varying |  | variadic | sum; e.g., Σ | variadic function, reduce

n-ary means having n operands (or parameters), but is often used as a synonym of "polyadic".

These words are often used to describe anything related to that number (e.g., undenary chess is a chess variant with an 11×11 board, or the Millenary Petition of 1603).

The arity of a relation (or predicate) is the dimension of the domain in the corresponding Cartesian product. (A function of arity n thus has arity n+1 considered as a relation.)

In computer programming, there is often a syntactical distinction between operators and functions; syntactical operators usually have arity 1, 2, or 3 (the ternary operator ?: is also common). Functions vary widely in the number of arguments, though large numbers can become unwieldy. Some programming languages also offer support for variadic functions, i.e., functions syntactically accepting a variable number of arguments.

## See also

* Logic of relatives
* Binary relation
* Ternary relation
* Theory of relations
* Signature (logic)
* Parameter
* p-adic number
* Cardinality
* Valency (linguistics)
* n-ary code
* n-ary group
* Function prototype - Declaration of a function's name and type signature but not body
* Type signature - Defines the inputs and outputs for a function, subroutine or method
* Univariate and multivariate
* Finitary

## References

1. ↑ Hazewinkel, Michiel (2001). Encyclopaedia of Mathematics, Supplement III. Springer. p. 3. ISBN 978-1-4020-0198-7. https://books.google.com/books?id=47YC2h295JUC&pg=PA3.
2. ↑ Schechter, Eric (1997). Handbook of Analysis and Its Foundations. Academic Press. p. 356. ISBN 978-0-12-622760-4. https://books.google.com/books?id=eqUv3Bcd56EC&pg=PA356.
3. ↑ Detlefsen, Michael; McCarty, David Charles; Bacon, John B. (1999). Logic from A to Z. Routledge. p. 7. ISBN 978-0-415-21375-2. https://archive.org/details/logicfromtoz0000detl.
4. ↑ Cocchiarella, Nino B.; Freund, Max A. (2008). Modal Logic: An Introduction to its Syntax and Semantics. Oxford University Press. p. 121. ISBN 978-0-19-536658-7. https://books.google.com/books?id=zLmxqytfLhgC&pg=PA121.
5. ↑ Crystal, David (2008). Dictionary of Linguistics and Phonetics (6th ed.). John Wiley & Sons. p. 507. ISBN 978-1-405-15296-9.
6. ↑ Quine, W. V. O. (1940), Mathematical logic, Cambridge, Massachusetts: Harvard University Press, p. 13
7. ↑ Robinson, Abraham (1966), Non-standard Analysis, Amsterdam: North-Holland, p. 19
8. ↑ Oliver, Alex (2004). "Multigrade Predicates". Mind 113 (452): 609–681. doi:10.1093/mind/113.452.609.

## External links

A monograph available free online:

* Burris, Stanley N., and H.P. Sankappanavar, H. P., 1981. A Course in Universal Algebra. Springer-Verlag. ISBN 3-540-90578-2. Especially pp. 22–24.

* v
* t
* e

Mathematical logic

General|

* Formal language
* Formation rule
* Formal proof
* Formal semantics
* Well-formed formula
* Set
* Element
* Class
* Classical logic
* Axiom
* Rule of inference
* Relation
* Theorem
* Logical consequence
* Type theory
* Symbol
* Syntax
* Theory

Systems|

* Formal system
* Deductive system
* Axiomatic system
* Hilbert style systems
* Natural deduction
* Sequent calculus

Traditional logic|

* Proposition
* Inference
* Argument
* Validity
* Cogency
* Syllogism
* Square of opposition
* Venn diagram

Propositional calculus
and Boolean logic

* Boolean functions
* Propositional calculus
* Propositional formula
* Logical connectives
* Truth tables
* Many-valued logic

Predicate logic|

* First-order
* Quantifiers
* Predicate
* Second-order
* Monadic predicate calculus

Naive set theory|

* Set
* Empty set
* Element
* Enumeration
* Extensionality
* Finite set
* Infinite set
* Subset
* Power set
* Countable set
* Uncountable set
* Recursive set
* Domain
* Codomain
* Image
* Map
* Function
* Relation
* Ordered pair

Set theory|

* Foundations of mathematics
* Zermelo–Fraenkel set theory
* Axiom of choice
* General set theory
* Kripke–Platek set theory
* Von Neumann–Bernays–Gödel set theory
* Morse–Kelley set theory
* Tarski–Grothendieck set theory

Model theory|

* Model
* Interpretation
* Non-standard model
* Finite model theory
* Truth value
* Validity

Proof theory|

* Formal proof
* Deductive system
* Formal system
* Theorem
* Logical consequence
* Rule of inference
* Syntax

Computability
theory|

* Recursion
* Recursive set
* Recursively enumerable set
* Decision problem
* Church–Turing thesis
* Computable function
* Primitive recursive function

cs:Operace (matematika)#Arita operace

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Arity. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Arity&oldid=4297479"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template