Special Topics¶

This page provides detailed information on specialized functionalities in MIMIQ.

BitString¶

The BitString class represents the state of bits and can be used to represent classical registers with specified values for each bit (0 or 1). At its core, it is simply a vector of booleans. BitString allows direct bit manipulation, bitwise operations, and conversion to other data formats like integers. It’s designed for flexibility in binary manipulation tasks within quantum computations.

Using BitString in MIMIQ Operations¶

In MIMIQ, several operations use BitString as a direct input for conditional logic or specific quantum operations, such as IfStatement and Amplitude. See non-unitary operations and statistical operations pages. Here are some examples:

>>> if_statement = IfStatement(GateX(), BitString("01011"))
>>> if_statement
IF (c==01011) X

# Amplitude Operation
>>> Amplitude(BitString("001"))
Amplitude(bs"001")

Constructors¶

BitString objects can be constructed in different ways.

From a String: Use BitString(“binary_string”) to initialize a BitString by parsing a string in binary format.
```
>>> BitString("1101")
bs"1101"
```
From bit locations: Use BitString(numbits, bit_indices) to initialize a BitString of numbits, setting specific bits to 1.
```
# Initializing with Specific Bits
>>> BitString(8, [2, 4, 6])
bs"00101010"
```

From a function: Use BitString(f, numbits) to initialize a BitString with numbits, where each bit is set based on the function f.

# Initialize an 8-bit BitString where bits are set based on even indices
>>> BitString.fromfunction(8, lambda i: i % 2 == 0)
bs"10101010"

Accessing and Modifying Bits¶

Each bit in a BitString can be accessed or modified individually in the same way as vectors, making it easy to retrieve or set specific bit values.

# Accessing a Bit
>>> bs = BitString(4, [1, 3])
>>> bs
bs"0101"
>>> bs[2]
0

>>> # Modifying a Bit
>>> bs[2] = True
>>> bs
bs"0111"

A useful function is nonzeros(), which returns the indices of non-zero bits in a BitString.

>>> bs = BitString(6, [1, 3, 5])
>>> bs.nonzeros()
[1, 3, 5]

Conversion and Manipulation Methods¶

The BitString class includes functionality for conversion to integer representations, indexing, and other methods for retrieving and manipulating bit values:

BitString to Integer: Use tointeger() to convert a BitString into its integer representation,

By default it uses a big-endian order.

>>> bs = BitString("101010")
>>> bs
bs"101010"

# Convert BitString to Integer (big-endian by default)
>>> bs.tointeger()
21

# Convert BitString to Integer (little-endian)
>>> bs.tointeger(endianess='little')
42

Alternatively, you can use the function toindex(), which converts a BitString to an index for purposes like vector indexing, checking bounds, and compatibility with 64-bit indexing constraints. It’s essentially the same as tointeger().

>>> bs.toindex()
21

BitString to String: Use to01().

# Convert BitString to String of "0"s and "1"s (big-endian (default))
>>> bs.to01()
'101010'

# Convert BitString to String of "0"s and "1"s (little-endian)
>>> bs.to01(endianess='little')
'010101'

Bitwise Operators¶

BitString supports bitwise operations such as NOT, AND, OR, XOR, as well as bitwise shifts:

NOT (~):

>>> bs = BitString("1011")
>>> ~bs
bs"0100"

AND (&), OR (|):

>>> bs1 = BitString("1100")
>>> bs2 = BitString("0110")

# Bitwise AND
>>> bs1 & bs2
bs"0100"

# Bitwise OR
>>> bs1 | bs2
bs"1110"

XOR (^):
```
# Bitwise XOR
>>> bs1 ^ bs2
bs"1010"
```

Left Shift (<<) and Right Shift (>>):

# Left Shift
>>> bs << 1
bs"0110"

# Right Shift
>>> bs >> 1
bs"0101"

Concatenation and Repetition¶

BitString supports concatenation and repetition, allowing you to combine or extend bitstrings efficiently:

Concatenation (+) Use + perator to combines two BitString objects by appending the bits of rhs to lhs.

>>> bs1 = BitString("1010")
>>> bs2 = BitString("0101")
>>> bs1 + bs2
bs"10100101"

Repetition (*) Use * perator to repeat a BitString to a specified number of times, creating a new BitString with the pattern repeated.
```
>>> bs = BitString("1010")
>>> bs * 2
bs"10101010"
```

Reference¶

class mimiqcircuits.BitString(arg, indices=None)[source]

Bases: object

BitString for the quantum states.

Representation of the quantum state of a quantum register with definite values for each qubit.

Examples

Initialization:

>>> from mimiqcircuits import *
>>> from bitarray import bitarray
>>> BitString(16) # number of qubits
bs"0000000000000000"
>>> BitString('10101') # binary string
bs"10101"
>>> BitString([1,0,0,0,1]) # binary string
bs"10001"
>>> BitString((1,0,0,0,1)) # binary string
bs"10001"

>>> BitString(bitarray('101010')) # bitarray
bs"101010"

Other initializations:

>>> BitString.fromnonzeros(16, [1, 3, 5, 7, 9, 11, 13, 15])
bs"0101010101010101"
>>> BitString.fromfunction(16, lambda i: i % 2 == 1)
bs"0101010101010101"
>>> BitString.fromstring('10101')
bs"10101"
>>> BitString.fromint(16, 21)
bs"1010100000000000"
>>> BitString.fromint(16, 21, 'little')
bs"0000000000010101"

Accessing the bits:

>>> bs = BitString(16)
>>> bs[0] # get the 0th bit
0
>>> bs[0:4] # get the first 4 bits
bs"0000"

Bitwise operations:

>>> bs1 = BitString('10101')
>>> bs2 = BitString('11100')
>>> bs1 | bs2 # OR
bs"11101"
>>> bs1 & bs2 # AND
bs"10100"
>>> bs1 ^ bs2 # XOR
bs"01001"
>>> ~bs1 # NOT
bs"01010"
>>> bs1 << 2 # left shift
bs"10100"
>>> bs1 >> 2 # right shift
bs"00101"

Other operations:

>>> bs1 + bs2 # concatenation
bs"1010111100"
>>> bs1 * 2 # repetition
bs"1010110101"

__init__(arg, indices=None)[source]

Initialize the BitString.

If the number of qubits is given, then the BitString is initialized to the all-zero state. If a binary string or a bitarray is given, then the BitString is the corresponding state.

Examples

>>> BitString(16) # number of qubits
bs"0000000000000000"
>>> BitString('10101') # binary string
bs"10101"
>>> BitString(bitarray('101010')) # bitarray
bs"101010"

property bits

static fromnonzeros(num_qubits, nonzeros)[source]

Initialize a BitString with specific non-zero qubits.

Parameters:

num_qubits (int) – The number of qubits in the BitString.
nonzeros (list) – A list of non-zero qubit indices to set in the BitString.

Returns:

A BitString with the specified non-zero qubits.

static fromfunction(num_qubits, f)[source]

Initialize a BitString from a function.

Parameters:

num_qubits (int) – The number of qubits in the BitString.
f (function) – A function that takes an integer and returns a boolean.

Returns:

A BitString.

static fromstring(bitstring)[source]

Initialize a BitString from a string.

Parameters:: bitstring (str) – The string representation of the BitString.
Returns:: A BitString.

static fromint(num_qubits, integer, endianess='big')[source]

Initialize a BitString from an integer.

Parameters:

num_qubits (int) – The number of qubits in the BitString.
integer (int) – The integer value of the BitString.
endianess (str) – The endianess of the integer. Default is ‘big’.

Returns:

A BitString.

num_qubits()[source]: Return the number of qubits in the BitString.

nonzeros()[source]: Return the indices of the non-zero qubits.

zeros()[source]: Return the indices of the zero qubits.

tointeger(endianess='big')[source]

Return the integer value of the BitString.

Parameters:: endianess (str) – The endianess of the integer. Default is ‘big’.
Returns:: The integer value of the BitString.

to01(endianess='big')[source]

Return the binary string representation of the BitString.

Parameters:: endianess (str) – The endianess of the integer. Default is ‘big’

Retruns:: The binary string representation of the BitString.

toindex(endianess='big')[source]

Return the integer index of the BitString.

Parameters:: endianess (str) – The endianess of the integer. Default is ‘big’.
Returns:: The integer index of the BitString.

__setitem__(index, value)[source]: Set a specific bit by creating a new frozenbitarray.