|
|
| Line 1: |
Line 1: |
| {{About|the mathematical concept|the musical term|Tuplet}}
| | Hello! <br>My name is King and I'm a 24 years old girl from Austria.<br><br>my web blog :: [https://www.youtube.com/watch?v=uboG8ZUzlqI music making software download free] |
| {{Redir|Octuple|the type of rowing boat|Octuple scull}}
| |
| {{Redir|Duodecuple|the term in music|Twelve-tone technique}}
| |
| | |
| In [[mathematics]], [[computer science]], [[linguistics]],<ref>http://www.oxfordreference.com/view/10.1093/acref/9780199202720.001.0001/acref-9780199202720-e-2276</ref> and [[philosophy]]<ref>http://www.oxfordreference.com/view/10.1093/acref/9780199541430.001.0001/acref-9780199541430-e-2262</ref> a '''tuple''' is an ordered list of elements. In [[set theory]], an '''(ordered) <math>n</math>-tuple''' is a [[sequence]] (or ordered list) of <math>n</math> elements, where <math>n</math> is a non-negative integer. There is only one 0-tuple, an empty sequence. An <math>n</math>-tuple is [[Recursive definition|defined inductively]] using the construction of an [[ordered pair]]. Tuples are usually written by listing the elements within parentheses "<math>(\text{ })</math>" and separated by commas; for example, <math>(2, 7, 4, 1, 7)</math> denotes a 5-tuple. Sometimes other delimiters are used, such as square brackets "<math>[\text{ }]</math>" or angle brackets "<math>\langle\text{ }\rangle</math>". Braces "<math>\{\}</math>" are almost never used for tuples, as they are the standard notation for [[set (mathematics)|sets]].
| |
| | |
| Tuples are often used to describe other mathematical objects, such as [[Vector (mathematics and physics)|vectors]]. In computer science, tuples are directly implemented as [[product type]]s in most [[functional programming|functional programming languages]]. More commonly, they are implemented as [[Record (computer science)|record types]], where the components are labeled instead of being identified by position alone. This approach is also used in [[relational algebra]]. Tuples are also used in relation to programming the [[semantic web]] with [[Resource Description Framework]] or RDF.
| |
| | |
| ==Etymology==
| |
| The term originated as an abstraction of the sequence: single, double, triple, quadruple, quintuple, sextuple, septuple, octuple, ..., ''n''‑tuple, ..., where the prefixes are taken from the [[Latin]] names of the numerals. The unique 0‑tuple is called the null tuple. A 1‑tuple is called a singleton, a 2‑tuple is called an ordered pair and a 3‑tuple is a triple or triplet. ''n'' can be any nonnegative integer. For example, a [[complex number]] can be represented as a 2‑tuple, a [[quaternion]] can be represented as a 4‑tuple, an [[octonion]] can be represented as an 8‑tuple and a [[sedenion]] can be represented as a 16‑tuple.
| |
| | |
| Although these uses treat ''‑tuple'' as the suffix, the original suffix was ''‑ple'' as in "triple" (three-fold) or "decuple" (ten‑fold). This originates from a medieval Latin suffix ''‑plus'' (meaning "more") related to Greek ‑πλοῦς, which replaced the classical and late antique ''‑plex'' (meaning "folded"), as in "duplex".<ref>''OED'', ''s.v.'' "triple", "quadruple", "quintuple", "decuple"</ref>
| |
| | |
| ===Names for tuples of specific lengths===
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| ! Tuple Length <math>n</math> !! Name !! Alternate names | |
| |-
| |
| | align="right" | 0 || empty tuple || unit
| |
| |-
| |
| | align="right" | 1 || single ||
| |
| |-
| |
| | align="right" | 2 || double || pair / dual / twin
| |
| |-
| |
| | align="right" | 3 || triple || treble
| |
| |-
| |
| | align="right" | 4 || quadruple || quad
| |
| |-
| |
| | align="right" | 5 || quintuple || pentuple
| |
| |-
| |
| | align="right" | 6 || sextuple || hextuple
| |
| |-
| |
| | align="right" | 7 || septuple ||
| |
| |-
| |
| | align="right" | 8 || octuple ||
| |
| |-
| |
| | align="right" | 9 || nonuple ||
| |
| |-
| |
| | align="right" | 10 || decuple ||
| |
| |-
| |
| | align="right" | 11 || undecuple || hendecuple
| |
| |-
| |
| | align="right" | 12 || duodecuple ||
| |
| |-
| |
| | align="right" | 13 || tredecuple ||
| |
| |-
| |
| | align="right" | 100 || centuple ||
| |
| |}
| |
| | |
| ==Properties==
| |
| The general rule for the identity of two <math>n</math>-tuples is
| |
| : <math>(a_1, a_2, \ldots, a_n) = (b_1, b_2, \ldots, b_n)</math> [[if and only if]] <math>a_1=b_1,\text{ }a_2=b_2,\text{ }\ldots,\text{ }a_n=b_n.</math>
| |
| | |
| Thus a tuple has properties that distinguish it from a [[Set (mathematics)|set]].
| |
| # A tuple may contain multiple instances of the same element, so {{break|
| |
| }}tuple <math>(1,2,2,3) \neq (1,2,3)</math>; but set <math>\{1,2,2,3\} = \{1,2,3\}</math>.
| |
| # Tuple elements are ordered: tuple <math>(1,2,3) \neq (3,2,1)</math>, but set <math>\{1,2,3\} = \{3,2,1\}</math>.
| |
| # A tuple has a finite number of elements, while a set or a multiset may have an infinite number of elements.
| |
| | |
| ==Definitions==
| |
| | |
| There are several definitions of tuples that give them the properties described in the previous section.
| |
| | |
| ===Tuples as functions===
| |
| An <math>n</math>-tuple can be regarded as a [[Function (mathematics)#Definition|function]], ''F'', whose domain is the tuple's implicit set of element indices, ''X'', and whose codomain, ''Y'', is the tuple's set of elements. Formally:
| |
| : <math>(a_1, a_2, \dots, a_n) \equiv (X,Y,F)</math>
| |
| where:
| |
| : <math>
| |
| \begin{align}
| |
| X & = \{1, 2, \dots, n\} \\
| |
| Y & = \{a_1, a_2, \ldots, a_n\} \\
| |
| F & = \{(1, a_1), (2, a_2), \ldots, (n, a_n)\} \\
| |
| \end{align}
| |
| </math>
| |
| | |
| ===Tuples as nested ordered pairs===
| |
| Another way of formalizing tuples is as nested [[ordered pair]]s. This approach assumes that the notion of ordered pair has already been defined; thus a 2-tuple
| |
| # The 0-tuple (i.e. the empty tuple) is represented by the empty set <math>\emptyset</math>.
| |
| # An <math>n</math>-tuple, with <math>n > 0</math>, can be defined as an ordered pair of its first entry and an <math>(n-1)</math>-tuple (which contains the remaining entries when <math>n > 1</math>):
| |
| #: <math>(a_1, a_2, a_3, \ldots, a_n) = (a_1, (a_2, a_3, \ldots, a_n))</math>
| |
| This definition can be applied recursively to the <math>(n-1)</math>-tuple:
| |
| : <math>(a_1, a_2, a_3, \ldots, a_n) = (a_1, (a_2, (a_3, (\ldots, (a_n, \emptyset)\ldots))))</math>
| |
| | |
| Thus, for example:
| |
| : <math>
| |
| \begin{align}
| |
| (1, 2, 3) & = (1, (2, (3, \emptyset))) \\
| |
| (1, 2, 3, 4) & = (1, (2, (3, (4, \emptyset)))) \\
| |
| \end{align}
| |
| </math>
| |
| | |
| A variant of this definition starts "peeling off" elements from the other end:
| |
| # The 0-tuple is the empty set <math>\emptyset</math>.
| |
| # For <math>n > 0</math>:
| |
| #: <math>(a_1, a_2, a_3, \ldots, a_n) = ((a_1, a_2, a_3, \ldots, a_{n-1}), a_n)</math>
| |
| This definition can be applied recursively:
| |
| : <math>(a_1, a_2, a_3, \ldots, a_n) = ((\ldots(((\emptyset, a_1), a_2), a_3), \ldots), a_n)</math>
| |
| | |
| Thus, for example:
| |
| : <math>
| |
| \begin{align}
| |
| (1, 2, 3) & = (((\emptyset, 1), 2), 3) \\
| |
| (1, 2, 3, 4) & = ((((\emptyset, 1), 2), 3), 4) \\
| |
| \end{align}
| |
| </math>
| |
| | |
| ===Tuples as nested sets===
| |
| Using [[ordered pair#Kuratowski definition|Kuratowski's representation for an ordered pair]], the second definition above can be reformulated in terms of pure [[set theory]]:
| |
| # The 0-tuple (i.e. the empty tuple) is represented by the empty set <math>\emptyset</math>;
| |
| # Let <math>x</math> be an <math>n</math>-tuple <math>(a_1, a_2, \ldots, a_n)</math>, and let <math>x \rightarrow b \equiv (a_1, a_2, \ldots, a_n, b)</math>. Then, <math>x \rightarrow b \equiv \{\{x\}, \{x, b\}\}</math>. (The right arrow, <math>\rightarrow</math>, could be read as "adjoined with".)
| |
| | |
| In this formulation:
| |
| : <math>
| |
| \begin{array}{lclcl}
| |
| () & & &=& \emptyset \\
| |
| & & & & \\
| |
| (1) &=& () \rightarrow 1 &=& \{\{()\},\{(),1\}\} \\
| |
| & & &=& \{\{\emptyset\},\{\emptyset,1\}\} \\
| |
| & & & & \\
| |
| (1,2) &=& (1) \rightarrow 2 &=& \{\{(1)\},\{(1),2\}\} \\
| |
| & & &=& \{\{\{\{\emptyset\},\{\emptyset,1\}\}\}, \\
| |
| & & & & \{\{\{\emptyset\},\{\emptyset,1\}\},2\}\} \\
| |
| & & & & \\
| |
| (1,2,3) &=& (1,2) \rightarrow 3 &=& \{\{(1,2)\},\{(1,2),3\}\} \\
| |
| & & &=& \{\{\{\{\{\{\emptyset\},\{\emptyset,1\}\}\}, \\
| |
| & & & & \{\{\{\emptyset\},\{\emptyset,1\}\},2\}\}\}, \\
| |
| & & & & \{\{\{\{\{\emptyset\},\{\emptyset,1\}\}\}, \\
| |
| & & & & \{\{\{\emptyset\},\{\emptyset,1\}\},2\}\},3\}\} \\
| |
| \end{array}
| |
| </math>
| |
| | |
| == Relational model ==
| |
| | |
| In [[database theory]], the [[relational model]] uses a tuple definition similar to [[#Tuples_as_functions|tuples as functions]], but each tuple element is identified by a distinct name, called an ''attribute'', instead of a number; this leads to a more [[user-friendly]] and practical notation.<ref name=ahv>[[Serge Abiteboul]], [[Richard Hull (computer scientist)|Richard Hull]], [[Victor Vianu]], ''Foundations of databases'', Addison-Wesley, 1995, ISBN 0-201-53771-0, p. 29–33</ref> A tuple in the relational model is formally defined as a finite [[function (mathematics)|function]] that maps attributes to values. For example:
| |
| : (player : "Harry", score : 25)
| |
| In this notation, attribute–value pairs may appear in any order. The distinction between tuples in the relational model and those in set theory is only superficial; the above example can be interpreted as a 2-tuple if an arbitrary [[total order]] is imposed on the attributes (e.g. <math>player \leq score</math>) and then the elements are distinguished by this ordering rather than by the attributes themselves. Conversely, a 2-tuple may be interpreted as relational model tuple over the attributes <math>\{1, 2\}</math>.<ref name=ahv/>
| |
| | |
| In the relational model, a [[Relation (database)|relation]] is a (possibly empty) finite set of tuples all having the same finite set of attributes. This set of attributes is more formally called the [[Sort (mathematical logic)|sort]] of the relation, or more casually referred to as the set of [[Column (database)|column names]].<ref name=ahv/> A tuple is usually implemented as a [[Row (database)|row]] in a [[database table]], but see [[relational algebra]] for means of deriving tuples not physically represented in a table.
| |
| | |
| == Type theory ==
| |
| {{main|Product type}}
| |
| In [[type theory]], commonly used in [[programming language]]s, a tuple has a [[product type]]; this fixes not only the length, but also the underlying types of each component. Formally:
| |
| : <math>(x_1, x_2, \ldots, x_n) : \mathsf{T}_1 \times \mathsf{T}_2 \times \ldots \times \mathsf{T}_n</math>
| |
| and the [[Projection (mathematics)|projection]]s are term constructors:
| |
| : <math>\pi_1(x) : \mathsf{T}_1,~\pi_2(x) : \mathsf{T}_2,~\ldots,~\pi_n(x) : \mathsf{T}_n</math>
| |
| | |
| The tuple with labeled elements used in the [[#Relational_model|relational model]] has a [[record type]]. Both of these types can be defined as simple extensions of the [[simply typed lambda calculus]].<ref name="pierce2002">{{cite book|last=Pierce|first=Benjamin|title=Types and Programming Languages|publisher=MIT Press|year=2002|isbn=0-262-16209-1|pages=126–132}}</ref>
| |
| | |
| The notion of a tuple in type theory and that in set theory are related in the following way: If we consider the natural [[model theory|model]] of a type theory, and use the Scott brackets to indicate the semantic interpretation<!-- do not link; that article needs to be a dab first-->, then the model consists of some sets <math>S_1, S_2, \ldots, S_n</math> (note: the use of italics here that distinguishes sets from types) such that:
| |
| : <math>[\![\mathsf{T}_1]\!] = S_1,~[\![\mathsf{T}_2]\!] = S_2,~\ldots,~[\![\mathsf{T}_n]\!] = S_n</math>
| |
| and the interpretation of the basic terms is:
| |
| : <math>[\![x_1]\!] \in [\![\mathsf{T}_1]\!],~[\![x_2]\!] \in [\![\mathsf{T}_2]\!],~\ldots,~[\![x_n]\!] \in [\![\mathsf{T}_n]\!]</math>.
| |
| | |
| The <math>n</math>-tuple of type theory has the natural interpretation as an <math>n</math>-tuple of set theory:<ref>Steve Awodey, [http://www.andrew.cmu.edu/user/awodey/preprints/stcsFinal.pdf ''From sets, to types, to categories, to sets''], 2009, [[preprint]]</ref>
| |
| : <math>[\![(x_1, x_2, \ldots, x_n)]\!] = ([\![x_1]\!], [\![x_2]\!], \ldots, [\![x_n]\!])</math>
| |
| The [[unit type]] has as semantic interpretation the 0-tuple.
| |
| | |
| ==See also==
| |
| {{Wiktionary|tuple}}
| |
| * [[Arity]]
| |
| * [[Exponential object]]
| |
| * [[Formal language]]
| |
| * [[Multidimensional Expressions#MDX data types|OLAP: Multidimensional Expressions]]
| |
| * [[Prime k-tuple]]
| |
| * [[Relation (mathematics)]]
| |
| * [[Tuplespace]]
| |
| | |
| ==Notes==
| |
| {{Reflist}}
| |
| | |
| ==References==
| |
| The set theory definitions herein are found in any textbook on the topic, e.g.
| |
| {{refbegin}}
| |
| * [[Abraham Adolf Fraenkel]], [[Yehoshua Bar-Hillel]], [[Azriel Lévy]], ''[http://books.google.com/books?q=Foundations+of+set+theory&btnG=Search+Books Foundations of set theory]'', Elsevier Studies in Logic Vol. 67, Edition 2, revised, 1973, ISBN 0-7204-2270-1, p. 33
| |
| * [[Gaisi Takeuti]], W. M. Zaring, ''Introduction to Axiomatic Set Theory'', Springer [[Graduate texts in mathematics|GTM]] 1, 1971, ISBN 978-0-387-90024-7, p. 14
| |
| * George J. Tourlakis, ''[http://books.google.com/books?as_isbn=9780521753746 Lecture Notes in Logic and Set Theory. Volume 2: Set theory]'', Cambridge University Press, 2003, ISBN 978-0-521-75374-6, pp. 182–193
| |
| * [[Keith Devlin]], ''The Joy of Sets''. Springer Verlag, 2nd ed., 1993, ISBN 0-387-94094-4, pp. 7–8
| |
| {{refend}}
| |
| | |
| <!--Interwikies-->
| |
| | |
| <!--Categories-->
| |
| [[Category:Data management]]
| |
| [[Category:Mathematical notation]]
| |
| [[Category:Sequences and series]]
| |
| [[Category:Basic concepts in set theory]]
| |
| [[Category:Type theory]]
| |