Hubbry Logo
Signature (logic)Signature (logic)Main
Open search
Signature (logic)
Community hub
Signature (logic)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Signature (logic)
Signature (logic)
from Wikipedia

In mathematical logic, a signature is a description of the non-logical symbols of a formal language. In universal algebra, a signature lists the operations that characterize an algebraic structure. In model theory, signatures are used for both purposes. They are rarely made explicit in more philosophical treatments of logic.

Definition

[edit]

Formally, a (single-sorted) signature can be defined as a 4-tuple where and are disjoint sets not containing any other basic logical symbols, called respectively

  • function symbols (examples: ),
  • relation symbols or predicates (examples: ),
  • constant symbols (examples: ),

and a function which assigns a natural number called arity to every function or relation symbol. A function or relation symbol is called -ary if its arity is Some authors define a nullary (-ary) function symbol as constant symbol, otherwise constant symbols are defined separately.

A signature with no function symbols is called a relational signature, and a signature with no relation symbols is called an algebraic signature.[1] A finite signature is a signature such that and are finite. More generally, the cardinality of a signature is defined as

The language of a signature is the set of all well formed sentences built from the symbols in that signature together with the symbols in the logical system.

Other conventions

[edit]

In universal algebra the word type or similarity type is often used as a synonym for "signature". In model theory, a signature is often called a vocabulary, or identified with the (first-order) language to which it provides the non-logical symbols. However, the cardinality of the language will always be infinite; if is finite then will be .

As the formal definition is inconvenient for everyday use, the definition of a specific signature is often abbreviated in an informal way, as in:

"The standard signature for abelian groups is where is a unary operator."

Sometimes an algebraic signature is regarded as just a list of arities, as in:

"The similarity type for abelian groups is "

Formally this would define the function symbols of the signature as something like (which is binary), (which is unary) and (which is nullary), but in reality the usual names are used even in connection with this convention.

In mathematical logic, very often symbols are not allowed to be nullary,[citation needed] so that constant symbols must be treated separately rather than as nullary function symbols. They form a set disjoint from on which the arity function is not defined. However, this only serves to complicate matters, especially in proofs by induction over the structure of a formula, where an additional case must be considered. Any nullary relation symbol, which is also not allowed under such a definition, can be emulated by a unary relation symbol together with a sentence expressing that its value is the same for all elements. This translation fails only for empty structures (which are often excluded by convention). If nullary symbols are allowed, then every formula of propositional logic is also a formula of first-order logic.

An example for an infinite signature uses and to formalize expressions and equations about a vector space over an infinite scalar field where each denotes the unary operation of scalar multiplication by This way, the signature and the logic can be kept single-sorted, with vectors being the only sort.[2]

Use of signatures in logic and algebra

[edit]

In the context of first-order logic, the symbols in a signature are also known as the non-logical symbols, because together with the logical symbols they form the underlying alphabet over which two formal languages are inductively defined: The set of terms over the signature and the set of (well-formed) formulas over the signature.

In a structure, an interpretation ties the function and relation symbols to mathematical objects that justify their names: The interpretation of an -ary function symbol in a structure with domain is a function and the interpretation of an -ary relation symbol is a relation Here denotes the -fold cartesian product of the domain with itself, and so is in fact an -ary function, and an -ary relation.

Many-sorted signatures

[edit]

For many-sorted logic and for many-sorted structures, signatures must encode information about the sorts. The most straightforward way of doing this is via symbol types that play the role of generalized arities.[3]

Symbol types

[edit]

Let be a set (of sorts) not containing the symbols or

The symbol types over are certain words over the alphabet : the relational symbol types and the functional symbol types for non-negative integers and (For the expression denotes the empty word.)

Signature

[edit]

A (many-sorted) signature is a triple consisting of

  • a set of sorts,
  • a set of symbols, and
  • a map which associates to every symbol in a symbol type over

See also

[edit]
  • Term algebra – Freely generated algebraic structure over a given signature

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia
from Grokipedia
In , a signature (also known as a ) is a of the non-logical symbols available in a language, consisting of a set of constant symbols, function symbols each equipped with an (the number of arguments it takes), and relation symbols (predicates) each equipped with an . These components define the basic building blocks for constructing terms and formulas in the language, excluding logical connectives and quantifiers. Constant symbols represent specific individuals in the domain and have arity zero, serving as 0-ary functions; for example, a constant like cc denotes a fixed element. Function symbols denote operations on the domain, such as a unary function ff (arity 1) or a binary function like ++ (arity 2), which map tuples of elements to another element. Relation symbols, on the other hand, denote predicates that specify or relations among elements, such as a binary relation \leq (arity 2) for ordering or a unary predicate PP (arity 1) for a property like "even." Signatures may be finite or infinite, single-sorted (one domain type) or multi-sorted (multiple domain types or sorts), allowing for flexible modeling of mathematical structures like groups or vector spaces. A Σ\Sigma underpins the and semantics of theories by determining the language in which axioms are expressed; for instance, the of groups uses a for , a for inverse, and a constant for the identity. In semantics, a Σ\Sigma-structure (or model) interprets the over a nonempty domain: constants map to domain elements, functions to domain operations, and relations to subsets of domain tuples, the of formulas or falsity. This framework supports key results in , such as the Löwenheim-Skolem theorem, which guarantees models of various cardinalities for any consistent over a countable . The concept extends to higher-order logics and equational theories, but remains foundational in classical for formalizing and reasoning about structures.

Basic Concepts

Definition

In mathematical logic, particularly in the context of and , a specifies the non-logical symbols available in a , distinguishing them from logical connectives, quantifiers, variables, and the equality symbol. It serves as the foundational vocabulary for defining structures and theories, prescribing the operations, relations, and constants that can be interpreted in models. Formally, a signature Σ\Sigma consists of two : FF, the set of function symbols, and PP, the set of predicate symbols, along with an function ar:FPNar: F \cup P \to \mathbb{N} that assigns to each the number of arguments it takes. Function symbols in FF represent mappings on the domain of a ; for instance, a symbol like ++ has 2 and denotes a function from pairs of elements to a single element. Predicate symbols in PP represent relations; a binary predicate like less-than << has 2 and denotes a subset of pairs from the domain. Equality (=)(=) is a logical binary predicate symbol with fixed interpretation as identity, always present in the language but not part of the signature. Symbols with 0 are constants: 0-ary functions act as individual constants (e.g., a specific element like zero), while 0-ary predicates are propositional constants (true or false statements). This structure ensures that the language generated by Σ\Sigma is precise and interpretable. For example, the signature for elementary arithmetic might include the constant 0 (arity 0), successor S (arity 1), addition + (arity 2), multiplication ⋅ (arity 2), and the binary predicate < (arity 2), allowing formulas like x(S(x)0)\forall x (S(x) \neq 0). In universal algebra, signatures emphasize algebraic operations but share the same core components, focusing on function symbols to define varieties of algebras. Signatures can be extended or restricted to form sublanguages or supertheories, maintaining compatibility with interpretations in models.

Conventions and Notation

In mathematical logic, a signature, often denoted by the symbol Σ\Sigma, specifies the non-logical symbols of a first-order language, consisting of disjoint sets of function symbols FF and predicate (or relation) symbols RR (or PP), along with an arity function ar:FRN\mathrm{ar}: F \cup R \to \mathbb{N} that assigns to each symbol the number of arguments it takes. Equality (=)(=) is a logical binary predicate symbol, always included in the language with fixed interpretation as identity, but not part of the signature. For a function symbol fFf \in F with ar(f)=n>0\mathrm{ar}(f) = n > 0, ff is called an nn-ary function symbol, and it is applied to nn terms as f(t1,,tn)f(t_1, \dots, t_n); if n=0n = 0, ff is a constant symbol, denoted simply as cc without arguments. Similarly, for a predicate symbol RRR \in R with ar(R)=n>0\mathrm{ar}(R) = n > 0, RR forms an atomic formula R(t1,,tn)R(t_1, \dots, t_n) when applied to nn terms, and 0-ary predicates (propositional symbols) yield standalone atomic formulas like PP. To indicate arity explicitly in notation, symbols are often superscripted, such as fnf^n for an [n](/page/N+)[n](/page/N+)-ary function or RnR^n for an [n](/page/N+)[n](/page/N+)-ary predicate, though in practice, the arity is inferred from the or contextual usage. Variables are typically denoted by lowercase letters like x,y,zx, y, z or indexed as vi,xiv_i, x_i for iNi \in \mathbb{N}, distinguishing them from constants (often lowercase a,b,ca, b, c or cic_i) and function symbols (e.g., f,gf, g). A common convention is to present a signature by listing its symbols with their arities, such as the signature for Peano arithmetic Σ={0(0),S(1),+(2),(2),<(2)}\Sigma = \{0^{(0)}, S^{(1)}, +^{(2)}, \cdot^{(2)}, <^{(2)}\}, where superscripts denote arities and 00 is a constant, SS a unary successor function, ++ and \cdot binary operations, and << a binary relation. In many-sorted logics, signatures incorporate a set of sorts SS, with arities mapping to sequences over SS, but for single-sorted , a single universal sort is implicit. Languages are often denoted LL or LΣL_\Sigma to emphasize the underlying signature, and extensions add new symbols while preserving the original structure.

Applications

In Universal Algebra

In universal algebra, a signature, also known as a type, consists of a set of function symbols where each symbol is assigned a nonnegative integer called its arity, specifying the number of arguments the corresponding operation takes. This structure defines the operations available in a class of algebras, including binary operations like addition in rings, unary operations like inversion in groups, and nullary operations representing constants such as the identity element. Formally, a type τ\tau is a function that assigns to each operation symbol ff a nonnegative integer τ(f)\tau(f), the arity of ff. An algebra of a given type τ\tau is then an ordered pair (A,F)(A, F), where AA is a nonempty set serving as the universe, and FF is a family of operations on AA that match the arities specified by τ\tau; specifically, for each symbol ff with τ(f)=n\tau(f) = n, there is an operation fA:AnAf^A: A^n \to A. This ensures uniformity across structures sharing the same signature, allowing for the systematic study of algebraic properties without regard to specific interpretations of the symbols. For instance, the signature for groups includes a binary operation symbol \cdot (arity 2), a unary symbol 1^{-1} (arity 1), and a nullary symbol ee (arity 0), enabling the definition of group axioms in terms of these operations. Signatures play a central in defining varieties of algebras, which are equationally defined classes closed under homomorphic images, subalgebras, and direct products. Equations are formed using terms built from the function symbols in the and variables, and a variety consists of all algebras of that type satisfying a given set of identities. This framework, rooted in equational logic, facilitates like Birkhoff's variety theorem, which characterizes varieties precisely as those classes definable by equations over the . For example, the variety of abelian groups is captured by the group plus the identity xy=yxxy = yx.

In First-Order Logic

In , a (also called a ) is a of the non-logical symbols available for constructing terms and formulas, consisting of disjoint sets of constant symbols CC, function symbols FF, and predicate (or relation) symbols PP, where each symbol except constants has an associated (a non-negative indicating the number of arguments it takes). Constants are often treated as 0-ary function symbols, simplifying the structure to just FF and PP. This setup distinguishes the signature from logical symbols like quantifiers (,\forall, \exists), connectives (,,¬,\land, \lor, \neg, \to), and the equality symbol ==, which are fixed and universal across all signatures. The defines the syntax of the language L\mathcal{L}: terms are built inductively from variables, constants, and function applications (e.g., if fFf \in F has 2 and t1,t2t_1, t_2 are terms, then f(t1,t2)f(t_1, t_2) is a term), while atomic formulas arise from predicate applications to terms (e.g., P(t1,,tn)P(t_1, \dots, t_n) for PPP \in P of nn), and complex formulas via logical connectives and quantifiers. For instance, the for Peano arithmetic includes the constant 0, unary successor function SS, and binary function symbols ++ and ×\times (interpreted as and ). This language allows the expression of properties about mathematical structures without presupposing their interpretations. A key application of the signature is in defining models or structures, which provide semantic interpretations: given a non-empty domain (or universe) DD, a structure A\mathfrak{A} for signature σ=(C,F,P)\sigma = (C, F, P) assigns to each constant cCc \in C an element cADc^\mathfrak{A} \in D, to each nn-ary function fFf \in F a function fA:DnDf^\mathfrak{A}: D^n \to D, and to each nn-ary predicate PPP \in P a subset PADnP^\mathfrak{A} \subseteq D^n (or equivalently, a relation). Satisfaction of formulas in A\mathfrak{A} is then defined recursively, enabling truth evaluations (e.g., AP(t1,,tn)\mathfrak{A} \models P(t_1, \dots, t_n) if the interpretations of t1,,tnt_1, \dots, t_n lie in PAP^\mathfrak{A}). Structures must interpret all signature symbols, ensuring completeness, and isomorphisms between structures preserve satisfaction for all formulas in the language. Signatures underpin first-order theories, which are sets of sentences (closed formulas without free variables) in L(σ)\mathcal{L}(\sigma) that are intended to axiomatize a class of models; for example, the theory of groups uses a single-sorted signature with binary multiplication \cdot, unary inverse 1^{-1}, and constant identity ee, axiomatized by equations like x(xe=x)\forall x \, (x \cdot e = x). A model of a theory Θ\Theta over σ\sigma is a structure for σ\sigma satisfying all sentences in Θ\Theta, facilitating proofs of properties like completeness (every consistent theory has a model) via tools such as the Löwenheim-Skolem theorem, which guarantees models of various cardinalities. This framework supports model-theoretic concepts, including elementary equivalence (structures satisfying the same sentences) and definability (properties expressible via formulas in the signature).

Advanced Variants

Many-Sorted Signatures

In logic, a many-sorted extends the basic notion of a by incorporating a set of sorts, which are distinct categories or types for the objects in the domain, allowing for more structured languages that distinguish between different kinds of entities, such as numbers and sets. This approach was pioneered in the axiomatic development of many-sorted theories, where sorts enable precise of variables and symbols to reflect separations in mathematical structures. Formally, a many-sorted signature Σ\Sigma is defined as a Σ=(S,C,F,P)\Sigma = (S, C, F, P), where SS is a nonempty set of sort symbols (the sorts), CC is a of constant symbols each assigned to a sort in SS, FF is a of function symbols each equipped with an specified as a sequence of input sorts σ1××σnσ\sigma_1 \times \cdots \times \sigma_n \to \sigma (with σ,σiS\sigma, \sigma_i \in S), and PP is a of predicate (or relation) symbols each with an σ1××σn\sigma_1 \times \cdots \times \sigma_n (with σiS\sigma_i \in S). Constants can be viewed as nullary functions, and equality is typically included as a binary predicate of each sort. This structure ensures that operations and relations are type-safe, preventing ill-formed expressions like applying a function expecting a sort of "numbers" to an argument of sort "points." The syntax of terms and formulas in a many-sorted language L(Σ)L(\Sigma) builds on this with sort-indexed variables. For each sort σS\sigma \in S, there is a countable set of variables VσV_\sigma. Terms of sort σ\sigma are defined inductively: variables in VσV_\sigma, constants of sort σ\sigma, or applications f(t1,,tn)f(t_1, \dots, t_n) where fFf \in F has σ1××σnσ\sigma_1 \times \cdots \times \sigma_n \to \sigma and each tit_i is a term of sort σi\sigma_i. Atomic formulas include equalities ttt \approx t' (where t,tt, t' are terms of the same sort) or p(t1,,tn)p(t_1, \dots, t_n) for pPp \in P with matching sorts. Complex formulas are formed using connectives ¬,,,,\neg, \land, \lor, \to, \leftrightarrow and quantifiers σx\forall^\sigma x or σx\exists^\sigma x (with xVσx \in V_\sigma), ensuring all subformulas respect sort constraints. Semantically, a Σ\Sigma-structure A\mathcal{A} consists of a nonempty domain AσA_\sigma for each sort σS\sigma \in S, together with interpretations: for each constant cc of sort σ\sigma, an element cAAσc^\mathcal{A} \in A_\sigma; for each function ff of arity σ1××σnσ\sigma_1 \times \cdots \times \sigma_n \to \sigma, a function fA:Aσ1××AσnAσf^\mathcal{A}: A_{\sigma_1} \times \cdots \times A_{\sigma_n} \to A_\sigma; and for each predicate pp of arity σ1××σn\sigma_1 \times \cdots \times \sigma_n, a relation pAAσ1××Aσnp^\mathcal{A} \subseteq A_{\sigma_1} \times \cdots \times A_{\sigma_n}. Satisfaction of formulas in A\mathcal{A} follows Tarski's recursive definition, with quantifiers ranging over the corresponding domain AσA_\sigma, and free variables assigned elements from their sorts. This setup allows models to enforce separations between sorts, such as disjoint domains for "points" and "lines" in geometry, avoiding the need for artificial predicates to distinguish types as in single-sorted logics. Many-sorted signatures offer advantages in modeling typed structures, reducing the axiomatic burden compared to single-sorted equivalents (where types are encoded via unary predicates), and facilitating translations between logics, such as from second-order to many-sorted first-order. For instance, consider a signature with sorts NN (natural numbers) and ZZ (integers), functions like addition +N:N×NN+^N: N \times N \to N and +Z:Z×ZZ+^Z: Z \times Z \to Z, and a coercion function ι:NZ\iota: N \to Z; this naturally captures arithmetic operations without mixing incompatible types. The completeness theorem for many-sorted first-order logic, establishing that every valid formula has a proof, holds analogously to the single-sorted case.

Typed Signatures

In logical systems, a typed formalizes the non-logical symbols of a equipped with a type discipline, typically to support simply typed or higher-order logics where expressions must respect type constraints. It comprises a set of base types T\mathcal{T}, often including atomic types like individuals or booleans, and a type generated by these base types using arrow types \to to form function types (e.g., ιι\iota \to \iota for functions from individuals to individuals). The then includes typed constants, function symbols, and relation symbols, each assigned a specific type from this ; for instance, a binary addition function might have type N×NN\mathbb{N} \times \mathbb{N} \to \mathbb{N}, where N\mathbb{N} is a base type for natural numbers. This structure ensures type safety in term formation, preventing ill-typed expressions such as applying a predicate of type ιo\iota \to o (where oo is the type of truth values) to arguments of incompatible types. Semantics for typed signatures are given by models that interpret base types as non-empty domains (e.g., sets in a category of types), arrow types as function spaces (via exponentials in Cartesian closed categories), and symbols as morphisms preserving these types. Such models often arise in categorical logic, where the signature corresponds to a functor from types to contexts, enabling initiality results for free typed algebras. Typed signatures generalize many-sorted signatures by allowing non-base types for symbols, thus accommodating higher-order constructs like quantifiers over functions or typed . A representative example is the signature for simply typed with equality, featuring base types ι\iota (individuals) and oo (propositions), constant symbols like c:ιc: \iota, unary functions f:ιιf: \iota \to \iota, binary relations R:ι×ιoR: \iota \times \iota \to o, and logical connectives typed accordingly (e.g., :ooo\land: o \to o \to o). This facilitates precise reasoning in domains like program verification, where types enforce domain-specific constraints without expanding to full dependent types.
Add your contribution
Related Hubs
User Avatar
No comments yet.