In mathematics and computer science, the BIT predicate, sometimes written ${\displaystyle {\text{BIT}}(i,j)}$, is a predicate that tests whether the ${\displaystyle j}$th bit of the number ${\displaystyle i}$ (starting from the least significant bit) is 1, when ${\displaystyle i}$ is written as a binary number. Its mathematical applications include modeling the membership relation of hereditarily finite sets, and defining the adjacency relation of the Rado graph. In computer science, it is used for efficient representations of set data structures using bit vectors, in defining the private information retrieval problem from communication complexity, and in descriptive complexity theory to formulate logical descriptions of complexity classes.

The BIT predicate was first introduced in 1937 by Wilhelm Ackermann to define the Ackermann coding, which encodes hereditarily finite sets as natural numbers. The BIT predicate can be used to perform membership tests for the encoded sets: ${\displaystyle {\text{BIT}}(i,j)}$ is true if and only if the set encoded by ${\displaystyle j}$ is a member of the set encoded by ${\displaystyle i}$.

Ackermann denoted the predicate ${\displaystyle {\text{BIT}}(i,j)}$ as ${\displaystyle {\mathfrak {El}}(j,i)}$, using a Fraktur font to distinguish it from the notation ${\displaystyle \mathrm {El} (j,i)}$ that he used for set membership (short for "${\displaystyle j}$ is an element of ${\displaystyle i}$" in German). The notation ${\displaystyle {\text{BIT}}(i,j)}$, and the name "the BIT predicate", come from the work of Ronald Fagin and Neil Immerman, who applied this predicate in computational complexity theory as a way to encode and decode information in the late 1980s and early 1990s.

The binary representation of a number ${\displaystyle i}$ is an expression for ${\displaystyle i}$ as a sum of distinct powers of two, $${\displaystyle i=\cdots b_{3}2^{3}+b_{2}2^{2}+b_{1}2^{1}+b_{0}2^{0}}$$ where each bit ${\displaystyle b_{j}}$ in this expression is either 0 or 1. It is commonly written in binary notation as just the sequence of these bits, ${\displaystyle \cdots b_{3}b_{2}b_{1}b_{0}}$. Given this expansion for ${\displaystyle i}$, the BIT predicate ${\displaystyle {\text{BIT}}(i,j)}$ is defined to equal ${\displaystyle b_{j}}$. It can be calculated from the formula $${\displaystyle {\text{BIT}}(i,j)=\left\lfloor {\frac {i}{2^{j}}}\right\rfloor {\bmod {2}},}$$ where ${\displaystyle \lfloor \cdot \rfloor }$ is the floor function and mod is the modulo function. The BIT predicate is a primitive recursive function. As a binary relation (producing true and false values rather than 1 and 0 respectively), the BIT predicate is asymmetric: there do not exist two numbers ${\displaystyle i}$ and ${\displaystyle j}$ for which both ${\displaystyle {\text{BIT}}(i,j)}$ and ${\displaystyle {\text{BIT}}(j,i)}$ are true.

In programming languages such as C, C++, Java, or Python that provide a right shift operator >> and a bitwise Boolean and operator &, the BIT predicate ${\displaystyle {\text{BIT}}(i,j)}$ can be implemented by the expression (i>>j)&1. The subexpression i>>j shifts the bits in the binary representation of ${\displaystyle i}$ so that bit ${\displaystyle b_{j}}$ is shifted to position 0, and the subexpression &1 masks off the remaining bits, leaving only the bit in position 0. As with the modular arithmetic formula above, the value of the expression is 1 or 0, respectively as the value of ${\displaystyle {\text{BIT}}(i,j)}$ is true or false.

For a set represented as a bit array, the BIT predicate can be used to test set membership. For instance, subsets of the non-negative integers ${\displaystyle \{0,1,\ldots \}}$ may be represented by a bit array with a one in position ${\displaystyle i}$ when ${\displaystyle i}$ is a member of the subset, and a zero in that position when it is not a member. When such a bit array is interpreted as a binary number, the set ${\displaystyle \{i,j,k,\dots \}}$ for distinct ${\displaystyle i,j,k,\dots }$ is represented as the binary number ${\displaystyle 2^{i}+2^{j}+2^{k}+\cdots }$. If ${\displaystyle S}$ is a set, represented in this way, and ${\displaystyle i}$ is a number that may or may not be an element of ${\displaystyle S}$, then ${\displaystyle {\text{BIT}}(S,i)}$ returns a nonzero value when ${\displaystyle i}$ is a member and zero when it is not.

The same technique may be used to test membership in subsets of any sequence ${\displaystyle x_{0},x_{1},\dots }$ of distinct values, encoded using powers of two whose exponents are the positions of the elements in this sequence, rather than their values. For instance, in the Java collections framework, java.util.EnumSet uses this technique to implement a set data structure for enumerated types. Ackermann's encoding of the hereditarily finite sets is an example of this technique, for the recursively-generated sequence of hereditarily finite sets.

In the mathematical study of computer security, the private information retrieval problem can be modeled as one in which a client, communicating with a collection of servers that store a binary number ${\displaystyle i}$, wishes to determine the result of a BIT predicate ${\displaystyle {\text{BIT}}(i,j)}$ without divulging the value of ${\displaystyle j}$ to the servers. Chor et al. (1998) describe a method for replicating ${\displaystyle i}$ across two servers in such a way that the client can solve the private information retrieval problem using a substantially smaller amount of communication than would be necessary to recover the complete value of ${\displaystyle i}$.