Negative base
A negative base, also known as a negative radix, is a positional numeral system that employs a negative integer (typically with absolute value greater than 1) as its base, enabling the representation of all integers—positive, negative, and zero—using only non-negative digits without requiring a dedicated sign bit.[1] The concept was first explored by Vittorio Grünwald in 1885.[2] In such systems, a number is expressed as n = \sum_{i=0}^{k} d_i b^i, where b < 0 is the base, each digit d_i satisfies $0 \leq d_i < |b|, and the powers b^i alternate in sign due to the negative radix, inherently encoding both magnitude and sign within the digit sequence.[3] This uniqueness of representation distinguishes negative bases from positive ones, as every integer has exactly one finite expansion without leading zeros.[1] Prominent examples include negabinary (base −2), which uses digits 0 and 1 analogous to standard binary but with place values of powers of −2, and negadecimal (base −10), which mirrors decimal digits 0–9 while incorporating negative powers for signed values.[3] Conversion to a negative base involves repeated division by the base, ensuring non-negative remainders (typically by adding |b| and adjusting the quotient if the remainder is negative), a process that guarantees completeness for integer representations.[4] Arithmetic operations in negative bases, such as addition and multiplication, follow adapted rules similar to positive bases but account for the alternating signs in carries and borrows, often resulting in finite results for integer inputs despite potential infinite carries in some cases.[5] These systems have been analyzed in theoretical computer science for their algebraic properties, particularly when the base relates to Pisot or Salem numbers, forming ring structures suitable for advanced numeration studies.[6] Historically, negative bases like negabinary appeared in mid-20th-century computing explorations, such as the Polish BINEG computer (1957–1959), and continue to find niche applications in parallel computing algorithms and non-standard data representations that reduce the need for explicit sign handling.[7]Fundamentals
Definition and Properties
A negative base numeral system, also known as a negabase system, is a type of positional numeral system where the base β is a negative integer, typically β ≤ -2. Unlike traditional positive base systems, which require a separate sign indicator for negative numbers, negative base systems allow every integer—positive, negative, or zero—to be represented without a sign bit using only non-negative digits. The digits range from 0 to |β| - 1, matching the cardinality of the digit set in the corresponding positive base |β| system.[8] In such a system, the value of a numeral represented as digits d_n d_{n-1} \dots d_1 d_0 in base β is given by the formula \sum_{k=0}^{n} d_k \beta^k, where each $0 \leq d_k < |\beta|. This formulation extends the standard positional notation used in positive bases, where the place values are successive powers of the base.[8][9] A key property of negative base systems is that every integer has a unique representation, with no leading zeros, ensuring unambiguous encoding without the ambiguities sometimes found in balanced ternary or other signed-digit systems. The place values, being powers of β, alternate in sign: for even exponents, β^k is positive, and for odd exponents, it is negative (e.g., in base -2, the positions from right to left are ..., 16, -8, 4, -2, 1). This alternation inherently encodes the sign of contributions from each digit position, eliminating the need for explicit negative number handling during arithmetic operations.[8][9] Compared to positive base systems, negative bases provide a symmetric treatment of positive and negative integers through their digit expansions, though the alternating signs in place values can lead to non-intuitive patterns in representations. For instance, while positive bases rely on a sign bit or complement methods for negatives, negative bases integrate signed values directly via the base's negativity, simplifying certain computational scenarios but requiring adjusted algorithms for conversion and arithmetic. Readers familiar with positive base positional notation will recognize the structural similarity, but the negative base introduces the novel feature of signless bidirectional number representation.[8][10]Basic Examples
One of the simplest negative bases is negabinary, or base −2, which uses digits 0 and 1 and alternates the sign of place values due to the powers of −2 (starting from the rightmost position as (+1), (−2), (+4), (−8), etc.). This system allows representation of both positive and negative integers without a separate sign bit.[3] For example, the number 6 in negabinary is written as $11010_{-2}. To verify, expand it positionally from right to left: \begin{align*} &1 \cdot (-2)^4 + \\ &1 \cdot (-2)^3 + \\ &0 \cdot (-2)^2 + \\ &1 \cdot (-2)^1 + \\ &0 \cdot (-2)^0 \end{align*} = 16 - 8 + 0 - 2 + 0 = 6. [3][11] Negative numbers are represented similarly, without an explicit minus sign, as the alternating signs in the powers naturally accommodate them. For instance, −6 in negabinary is $1110_{-2}. Expanding step by step: \begin{align*} &1 \cdot (-2)^3 + \\ &1 \cdot (-2)^2 + \\ &1 \cdot (-2)^1 + \\ &0 \cdot (-2)^0 \end{align*} = -8 + 4 - 2 + 0 = -6. [11] To illustrate the alternating signs further, consider these short examples in negabinary:- The number 2 is $110_{-2}: $1 \cdot (-2)^2 + 1 \cdot (-2)^1 + 0 \cdot (-2)^0 = 4 - 2 + 0 = 2.
- The number 3 is $111_{-2}: $1 \cdot (-2)^2 + 1 \cdot (-2)^1 + 1 \cdot (-2)^0 = 4 - 2 + 1 = 3.
Historical Context
Origins and Early Work
The concept of negative bases in numeral systems was first systematically explored in the late 19th century by Italian mathematician Vittorio Grünwald. In his 1885 monograph, Grünwald introduced the theoretical framework for representing numbers using negative integer bases, focusing on bases such as -10 with standard digits 0 through 9. He detailed methods for arithmetic operations, root extraction, divisibility tests, and conversions between positive and negative bases, demonstrating how such systems could uniquely represent all integers without a separate sign indicator. Published in the obscure Giornale di Matematiche di Battaglini, Grünwald's work emphasized the completeness of these representations but received little attention at the time.[2] Interest in negative bases revived in the mid-20th century amid growing fascination with unconventional numeral systems in recreational mathematics. In 1955, Donald E. Knuth, then a high school student, submitted a paper to a science talent search that discussed negative-radix systems alongside generalizations to complex bases, highlighting their potential for efficient number representation. Knuth illustrated how negative bases allow every integer to have a unique finite digit expansion using non-negative digits, avoiding the ambiguities of positive-base signed representations. This exploration, later published in 1960, positioned negative bases as an intriguing alternative for computational and mathematical curiosity, though practical applications remained limited. By the early 1960s, negative bases gained traction in computing contexts, particularly for handling signed numbers. George W. Reitwiesner introduced negabinary (base -2) in his 1960 paper on binary arithmetic, proposing it as a method to represent both positive and negative integers in a single unsigned format. Motivated by the challenges of two's complement arithmetic in early computers—which required special handling for overflow and sign extension—Reitwiesner argued that negabinary simplifies addition and subtraction by eliminating the need for sign bits or complement operations, as carries propagate naturally without altering the sign. He provided algorithms for these operations, noting their efficiency for hardware implementation in signed binary computations.Key Developments
In the 1970s and 1980s, research on negative bases extended to practical computational applications, including explorations of general negative bases in error-detecting and error-correcting codes, where their unique representational properties allowed for novel encoding schemes in digital systems.[12] In the 1980s and 1990s, advancements focused on computational implementations, such as negative base encoding in optical linear algebra processors and negabinary modular multiplication using digital partitioning techniques, enabling efficient arithmetic operations in specialized hardware like optical computing systems.[13] The introduction of negative base expansions for real numbers, analogous to beta-expansions in positive bases, was pioneered by Shunji Ito and Taizo Sadahiro in their 2009 work, which characterized representations in bases −β (β > 1) and established foundational properties like the greedy and lazy algorithms for such expansions, bridging to broader non-integer base theory.[14] In the 2000s, negative bases found applications in digital signal processing through balanced ternary-like systems, where signed-digit representations (equivalent to bases like −3 with digits 0,1,2) offered advantages in error characteristics, rounding, and parallelism for numerically intensive tasks such as filtering and multiplication in DSP subsystems.[15][16] Recent developments from 2020 to 2025 have emphasized theoretical connections, including links between negative base expansions and Pisot numbers; for instance, a 2022 study showed that certain alternate bases involving negative components yield Pisot numbers when expansions are finite, with implications for unique representations.[17] Additionally, a 2022 analysis explored tilings generated by Pisot numbers via beta-numeration.[18] In 2024, work on binary numeration systems with alternating signed digits—effectively extending negabinary (base −2)—demonstrated efficient computation through unique representations and graph-theoretic models, reducing redundancy in integer encoding for algorithmic efficiency.[19] Overall, negative base research has evolved from practical computing implementations in the late 20th century to abstract number theory in recent decades, with emerging ties to tiling applications that remain underexplored in standard literature.[20]Notation and Digit Usage
Standard Notation Conventions
In negative base numeral systems, the base \beta (where \beta < 0) is conventionally indicated by a subscript immediately following the sequence of digits, with the negative sign included in the subscript for clarity, such as $101_{-2} to denote a number in negabinary (base -2). This subscript notation parallels that used for positive bases but explicitly incorporates the negativity of the radix to distinguish it from standard positional systems.[2] Digits in these systems are symbolized using the standard non-negative integers from 0 to |\beta| - 1, mirroring the digit sets of positive base systems with the same absolute value; for instance, bases like -10 employ digits 0 through 9, while higher absolute values may use letters A–F for values 10–15, though decimal digits are preferred in textual descriptions for simplicity and to avoid special symbols. No negative or signed digits are necessary, as the alternating signs in the place values (arising from powers of the negative base) inherently accommodate both positive and negative integers without a separate sign prefix. All integers possess unique finite representations under this convention, eliminating ambiguities from leading zeros or infinite expansions that can occur in other non-standard systems like balanced ternary.[2][5] When printing or reading negative base numbers, the digits are arranged from most significant to least significant, read left-to-right as in decimal notation, with place values determined by successive integer powers of the base \beta^k for k = 0, 1, 2, \dots. For mixed or non-standard applications, such as varying radices within a single representation, the subscript convention is extended per position if needed, but uniformity is recommended; non-decimal digits are avoided in favor of explicit decimal equivalents to maintain readability across contexts.[2]Digit Sets and Constraints
In negative base numeral systems, where the base β is an integer of the form -r with r > 1, the standard digit set consists of non-negative integers satisfying 0 ≤ d < r, ensuring that each position contributes a value within the range needed for positional notation. This range, {0, 1, ..., r-1}, forms a complete residue system modulo r, which guarantees that every integer can be uniquely represented without leading zeros or redundant forms.[21] The use of non-negative digits is essential for achieving unique representations of all integers, positive and negative alike, while covering the entire real number line without gaps or overlaps that would arise from allowing negative digits. Negative digits would introduce multiple equivalent expansions for the same number, complicating computations and storage, whereas the non-negative set eliminates such redundancy by aligning with the alternating sign pattern of the powers of β.[22] For specific bases, the constraints adapt accordingly: in base -2 (negabinary), digits are restricted to {0, 1}, allowing binary-like hardware compatibility; in base -3, digits range from {0, 1, 2}. These limitations imply practical advantages in digital systems, such as the absence of a dedicated sign bit, since the negative base inherently encodes both positive and negative values through digit placement alone, simplifying representation in fixed-width registers.[3] An edge case arises with the maximum digit r-1, which plays a key role in facilitating "borrowing" mechanisms during conversions and operations by providing sufficient range to adjust remainders without introducing negative values prematurely, though this maintains the overall non-negativity constraint.[22]Number Conversion
General Conversion Algorithm
The standard algorithm for converting an integer n (positive, negative, or zero) to its representation in a negative base \beta, where \beta < 0 and |\beta| > 1 is an integer, relies on repeated division while ensuring remainders are non-negative integers in the range $0 to |\beta| - 1. This approach adapts the classical division algorithm for positive bases to handle the negative divisor by adjusting any negative remainder, guaranteeing that each step produces a valid digit and reduces the magnitude of the quotient sufficiently for termination. The method ensures a unique representation for every integer without requiring a separate sign bit, as the alternating signs of the place values (\beta^k) naturally accommodate both positive and negative values. To perform the conversion, denote r = |\beta|. Initialize an empty list to store the digits. While n \neq 0:- Compute the remainder rem = n \mod \beta and quotient q = \lfloor n / \beta \rfloor using the language's or system's modulo and division operations (which may yield a negative remainder if n < 0).
- If rem < 0, adjust it by adding r to rem and adding 1 to q.
- Append rem to the list of digits (as the next least significant digit).
- Update n to q.
This algorithm terminates because each quotient satisfies |q| \leq (|n| + r - 1)/r, and since r \geq 2, the absolute value of n strictly decreases after finitely many steps until reaching zero. Uniqueness follows from the covering property: the digit set \{0, 1, \dots, r-1\} ensures that every integer residue modulo r is covered exactly once, and the negative base's powers generate all integers without gaps or overlaps in their finite expansions. For negative inputs, the process is symmetric due to the base's sign, producing a representation that evaluates to the negative value without an explicit minus sign; for example, converting -13 to base -10 yields digits 2,7 corresponding to the value $2 \cdot (-10)^1 + 7 \cdot (-10)^0 = -20 + 7 = -13. [22]function toNegativeBase(n, beta): if n == 0: return [0] digits = [] while n != 0: rem = n % beta quotient = n // beta if rem < 0: rem -= beta # Equivalent to rem += |beta| since beta < 0 quotient += 1 digits.append(rem) n = quotient digits.reverse() return digitsfunction toNegativeBase(n, beta): if n == 0: return [0] digits = [] while n != 0: rem = n % beta quotient = n // beta if rem < 0: rem -= beta # Equivalent to rem += |beta| since beta < 0 quotient += 1 digits.append(rem) n = quotient digits.reverse() return digits
Shortcut Methods for Specific Bases
For the negabinary system (base -2), efficient conversion from a two's complement binary representation to negabinary can be achieved using bitwise operations that adjust bit positions to account for alternating positive and negative powers of 2. One seminal method involves adding a mask consisting of 1s in the odd bit positions (e.g., binary ...10101010) to the input number, followed by an XOR operation with the same mask; this propagates carries to effectively convert powers of 2 at even positions to the corresponding negabinary values while flipping signs for odd positions.[23] This approach, detailed in early computational hacks, enables single-pass conversion for fixed-width integers, such as 32-bit numbers using the mask 0xAAAAAAAA or 64-bit using 0xAAAAAAAAAAAAAAAA.[23] An alternative hardware-oriented shortcut uses pattern recognition via selective bit complementation, starting from the least significant bit (LSB). For positive binary numbers, bits remain unchanged until a 1 appears at an odd position (0-based from LSB), after which all subsequent bits are complemented until a complemented 0 becomes 1 at an even position; the process repeats from the next bit. For negative numbers (in two's complement), the process starts similarly but triggers on a 1 at an even position, complementing until a 1 at an odd position. This method reduces conversion delay in VLSI implementations compared to ripple-carry alternatives, achieving operation at 50 MHz with lower power consumption.[24] A simple iterative software method for negabinary conversion avoids complex division by extracting the least significant digit as the parity bit (num & 1) and updating the quotient as (num + (num & 1 ? 2 : 0)) // -2, ensuring integer arithmetic while adjusting for the negative base to keep remainders non-negative (0 or 1); this repeats until num reaches 0.[3] These shortcuts offer computational advantages over general base-agnostic algorithms, particularly for fixed-width integers, by minimizing operations to O(1) per bit in hardware or logarithmic steps in software. For example, a bitwise method implementation in languages with fixed-width two's complement integers like C for 64-bit signed integers (assuming input fits in 64 bits) uses:In Python, to simulate 64-bit two's complement:cuint64_t mask = 0xAAAAAAAAAAAAAAAAULL; uint64_t adjusted = (n + mask) ^ mask;uint64_t mask = 0xAAAAAAAAAAAAAAAAULL; uint64_t adjusted = (n + mask) ^ mask;
For negaternary (base -4), which uses digits 0-3, a shortcut involves grouping pairs of negabinary digits—since (-2)^2 = 4—and mapping their values (ranging from -3 to 3) to standard non-negative digits with carry adjustments: values -3 and -2 map to 1 and 0 with a carry of -1 to the next group, while positive values map directly with no carry. This leverages an existing negabinary representation for efficiency in multi-base systems. For base -3 (digits 0-2), efficient conversion follows similar iterative division by -3, taking remainders adjusted to [0, 2] by adding 3 if negative and incrementing the quotient; no specialized bitwise shortcut exists beyond this rule, but it enables faster computation than arbitrary negative bases by limiting digit options.[3]pythondef to_negabinary(n: int) -> str: if n == 0: return '0' width = 64 mask = (1 << width) // 3 * 2 # Equivalent to 0xAAAAAAAAAAAAAAAA n64 = n & ((1 << width) - 1) temp = (n64 + mask) % (1 << width) adjusted = temp ^ mask s = bin(adjusted)[2:] return s.lstrip('0') or '0'def to_negabinary(n: int) -> str: if n == 0: return '0' width = 64 mask = (1 << width) // 3 * 2 # Equivalent to 0xAAAAAAAAAAAAAAAA n64 = n & ((1 << width) - 1) temp = (n64 + mask) % (1 << width) adjusted = temp ^ mask s = bin(adjusted)[2:] return s.lstrip('0') or '0'
Arithmetic Operations
Addition and Subtraction
Addition in negative base numeral systems follows a process analogous to standard positional addition, but adjusted for the negative radix β (where β < 0). Digits are added column by column from the least significant position, incorporating any incoming carry. The sum at each position is the digits plus the carry-in. To ensure the result digit remains in the valid range [0, |β| - 1], carries are propagated according to the base's sign: if the temporary sum s satisfies s ≥ |β|, subtract |β| and generate a carry of sign(β) (negative for negative bases); if s < 0, add |β| and generate a carry of opposite sign. For general β = -r (r > 1 integer), the outgoing carry c_out = floor( (s + carry_in) / r ) with sign adjustments, but carries alternate in sign due to the negative weights, often resulting in carries of -1 or +1 in practice for small r like 2. This ensures no negative digits appear. In negabinary (base β = -2), the addition algorithm simplifies due to digits limited to {0, 1}. Start from the rightmost digit with carry-in = 0. Compute s = a_i + b_i + c_in, where a_i, b_i ∈ {0, 1} and c_in ∈ {-1, 0, 1}. The result digit d_i and outgoing carry c_out are determined as follows:- If s = -1, then d_i = 1, c_out = 1 (since -1 = (-2) · 1 + 1).
- If s = 0, then d_i = 0, c_out = 0.
- If s = 1, then d_i = 1, c_out = 0.
- If s = 2, then d_i = 0, c_out = -1 (since 2 = (-2) · (-1) + 0).
- If s = 3, then d_i = 1, c_out = -1 (since 3 = (-2) · (-1) + 1).
| A | B | C_in | S | C_out |
|---|---|---|---|---|
| 0 | 0 | -1 | 1 | 1 |
| 0 | 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 1 | 0 |
| 0 | 1 | -1 | 0 | 0 |
| 0 | 1 | 0 | 1 | 0 |
| 0 | 1 | 1 | 0 | -1 |
| 1 | 0 | -1 | 0 | 0 |
| 1 | 0 | 0 | 1 | 0 |
| 1 | 0 | 1 | 0 | -1 |
| 1 | 1 | -1 | 1 | 0 |
| 1 | 1 | 0 | 0 | -1 |
| 1 | 1 | 1 | 1 | -1 |
The negabinary representation of 6 is 11010_{-2} (reading left to right as MSB to LSB: 1·16 + 1·(-8) + 0·4 + 1·(-2) + 0·1 = 6).
The representation of -3 is 1101_{-2} (1·(-8) + 1·4 + 0·(-2) + 1·1 = -3), padded to 01101_{-2} for alignment. Aligning from LSB (right):
1 1 0 1 0 + 0 1 1 0 1 -----------1 1 0 1 0 + 0 1 1 0 1 -----------
- Position 0 (LSB): 0 + 1 + 0 = 1 → d_0 = 1, c = 0
- Position 1: 1 + 0 + 0 = 1 → d_1 = 1, c = 0
- Position 2: 0 + 1 + 0 = 1 → d_2 = 1, c = 0
- Position 3: 1 + 1 + 0 = 2 → d_3 = 0, c = -1 (2 - 2 = 0, carry -1)
- Position 4: 1 + 0 + (-1) = 0 → d_4 = 0, c = 0
Multiplication and Division
Multiplication in negative base numeral systems follows a shift-and-add approach analogous to positive bases, but adapted for the negative value of the base β, where β < 0. Each left shift by k positions multiplies the partial product by β^k, resulting in alternating signs due to the odd and even powers of the negative base. This can lead to sign flips in partial products, complicating the accumulation process as positive and negative contributions must be carefully added using the base's addition rules. For instance, in negabinary (base -2), the powers alternate between positive (even positions: (+1), (+4), (+16), ...) and negative (odd positions: (-2), (-8), (-32), ...), requiring adjustments during summation to handle carries that may propagate differently than in positive bases.[5][22] A worked example in negabinary illustrates this: multiply 3 (represented as 111_{-2}) by 4 (100_{-2}). The multiplicand is 111_{-2}, and the multiplier 100_{-2} has a single '1' in the position corresponding to (-2)^2 = +4. Thus, the partial product is the multiplicand shifted left by 2 positions: 11100_{-2}. Evaluating 11100_{-2} = 1 \cdot (-2)^4 + 1 \cdot (-2)^3 + 1 \cdot (-2)^2 + 0 \cdot (-2)^1 + 0 \cdot (-2)^0 = 16 - 8 + 4 = 12_{10}, which is correct since 3 \times 4 = 12. The result 12 in negabinary is 11100_{-2}, confirming the computation. The alternating signs in the shifted terms (-8 from the second position) highlight the potential for sign flips that must be resolved during final addition.[5] Booth's multiplication algorithm, originally designed for signed binary numbers, can be adapted for negative bases using non-negative digits (0 to |β|-1). The adaptation simplifies the recoding of the multiplier since digits are unsigned, reducing the number of partial additions compared to standard shift-and-add, though the negative base still introduces sign alternations in shifts. This is particularly useful for hardware implementations where minimizing additions improves efficiency. Division in negative bases employs long division with remainders constrained to be non-negative (0 ≤ r < |β|), similar to positive bases but with adjustments for the negative divisor. The quotient q is computed via repeated subtraction or estimation, ensuring the remainder satisfies the condition; if a negative remainder arises, it is incremented by |β| and the quotient decremented accordingly. A key formula for adjustment is q = \lfloor (n - r) / \beta \rfloor, where n is the dividend and r is chosen to keep 0 ≤ r < |β|, accounting for the floor function's behavior with negative β (towards negative infinity). This prevents invalid digits and maintains uniqueness.[27] A divide-and-correct algorithm provides an efficient method for multiple-precision division: an initial quotient is estimated by dividing the dividend by the divisor (treating the base as positive for approximation), then corrected by adding or subtracting a factor based on the error, applicable to any negative base like -10. This approach is suitable for computational implementation, reducing iterations compared to naive long division. Challenges include handling the sign of partial remainders, which may require additional steps to ensure non-negative results without introducing negative digits.[27]Magnitude Comparison
To compare the magnitudes of two integers represented in the same negative base b = -r (where r > 1 is an integer), align the representations by padding the shorter one with leading zeros to match the length of the longer one. This ensures both numbers have the same number of digits, with place values starting from the least significant digit (LSD) as b^0 = 1 > 0, b^1 = b < 0, b^2 = b^2 > 0, and so on, alternating signs with magnitudes increasing as r^k.[5] Begin the comparison from the most significant digit (MSD, leftmost position). Proceed rightward until finding the first position where the digits differ. Let the place value at that position have sign s = (-1)^k (where k is the power from the LSD). If the digit in the first number is larger than in the second and s > 0, the first number is greater; if s < 0, the first number is smaller. If all digits match, the numbers are equal. This method accounts for the alternating signs, as a larger digit in a positive place increases the value, while in a negative place it decreases it (making the number more negative).[5] If the original representations have different lengths and the leading digits are nonzero, the longer representation's MSD position determines the initial difference after padding. For instance, in base -2, the sign of the highest power (-2)^{n-1} is positive if n (the length) is odd and negative if even. Thus, a longer odd-length number with a positive leading digit (>0) generally has larger magnitude than a shorter one, while an even-length longer number tends to have smaller magnitude, but the full digit-by-digit check confirms the order.[5] Consider the example in base -2: compare $11010_{-2} = 1 \cdot (-2)^4 + 1 \cdot (-2)^3 + 0 \cdot (-2)^2 + 1 \cdot (-2)^1 + 0 \cdot (-2)^0 = 16 - 8 - 2 = 6 and $1110_{-2} = 1 \cdot (-2)^3 + 1 \cdot (-2)^2 + 1 \cdot (-2)^1 + 0 \cdot (-2)^0 = -8 + 4 - 2 = -6. Pad the second to five digits: $01110_{-2}. The positions from left (powers 4 to 0: +16, -8, +4, -2, +1) are:- Position 4 (+16): 1 > 0, and positive place, so $11010_{-2} > 1110_{-2} (i.e., 6 > -6).[5]