Skip to content

Subtraction

Subtraction (denoted as '-') is implemented by negation and addition in 2-complement representation.

\[ a - b \longleftrightarrow a + (-b) \longleftrightarrow a + \sim{b} + lsb \\_ value \]

Where '~' is bitwise not and lsb_value is the least significant bit value.

Note that integer and fixed-point numbers are represented in a 2-complement method during function evaluation. The binary number is extended in the case of a register size miss-match. For example, the positive signed number \((110)_2=6\) is expressed as \((00110)_2\) when operating with a 5-qubit register. Similarly, the negative signed number \((110)_2=-2\) is expressed as \((11110)_2\).

Examples:

5 + 3 = 8 , 0101 + 0011 = 1000

5 - 3 = 5 + (-3) = 2, 0101 + 1101 = 0010

-5 + -3 = -8, 1011 + 1101 = 1000

Syntax

Function: Subtractor

Parameters:

{
  "function": "Subtractor",
  "function_params": {
    "left_arg": 3,
    "right_arg": {
      "size": 3
    },
    "inplace_arg": null
  }
}

Register Names

By default, the input registers are called left_arg and right_arg. If the name field of a RegisterUserInput object is specified, then the name of the register is determined accordingly. If one of the arguments is a constant then it is not available as an input register.

The output registers include the result register. By default, it is called difference, but its name may be overridden by the output_name argument. The inplace_arg argument sets the argument to override. If it is set to None, the input registers are also available as output registers, with the same names. If it is set to left or right, only the right or left argument will be available, respectively. The qubits of the overriden argument will be used for the result.

Example 1: Two Register

{
        "logic_flow": [
            {
                "function": "Subtractor",
                "function_params": {
                    "left_arg": {"size": 3},
                    "right_arg": {"size": 3}
                }
            }
        ]
    }

from classiq import Model, QUInt
from classiq.builtin_functions import Subtractor

params = Subtractor(
    left_arg=QUInt(size=3).to_register_user_input(),
    right_arg=QUInt(size=3).to_register_user_input(),
)
model = Model()
model.Subtractor(params)
circuit = model.synthesize()

This example generates a circuit which subtracts two arguments. The left_arg is defined to be a quantum register of size three. The right_arg is defined to be a quantum register of size three.

Output circuit:

img_1.png

Example 2: Float and Register

{
    "logic_flow": [
        {
            "function": "Subtractor",
            "function_params": {
                "left_arg": 3.5,
                "right_arg": {
                    "size": 3
                }
            }
        }
    ]
}

from classiq import Model, RegisterUserInput
from classiq.builtin_functions import Subtractor

params = Subtractor(left_arg=3.5, right_arg=RegisterUserInput(size=3))
model = Model()
model.Subtractor(params)
circuit = model.synthesize()

This example generates a circuit which subtracts two argument. The left_arg is defined to be a fix point number \((11.1)_2\). The right_arg is defined to be a quantum register of size of three.

Output circuit:

img.png