WeightedAdder¶

class WeightedAdder(num_state_qubits=None, weights=None, name='adder')[source]¶

A circuit to compute the weighted sum of qubit registers.

Given \(n\) qubit basis states \(q_0, \ldots, q_{n-1} \in \{0, 1\}\) and non-negative integer weights \(\lambda_0, \ldots, \lambda_{n-1}\), this circuit performs the operation

\[|q_0 \ldots q_{n-1}\rangle |0\rangle_s \mapsto |q_0 \ldots q_{n-1}\rangle |\sum_{j=0}^{n-1} \lambda_j q_j\rangle_s\]

where \(s\) is the number of sum qubits required. This can be computed as

\[s = 1 + \left\lfloor \log_2\left( \sum_{j=0}^{n-1} \lambda_j \right) \right\rfloor\]

or \(s = 1\) if the sum of the weights is 0 (then the expression in the logarithm is invalid).

For qubits in a circuit diagram, the first weight applies to the upper-most qubit. For an example where the state of 4 qubits is added into a sum register, the circuit can be schematically drawn as

           ┌────────┐
  state_0: ┤0       ├ | state_0 * weights[0]
           │        │ |
  state_1: ┤1       ├ | + state_1 * weights[1]
           │        │ |
  state_2: ┤2       ├ | + state_2 * weights[2]
           │        │ |
  state_3: ┤3       ├ | + state_3 * weights[3]
           │        │
    sum_0: ┤4       ├ |
           │  Adder │ |
    sum_1: ┤5       ├ | = sum_0 * 2^0 + sum_1 * 2^1 + sum_2 * 2^2
           │        │ |
    sum_2: ┤6       ├ |
           │        │
  carry_0: ┤7       ├
           │        │
  carry_1: ┤8       ├
           │        │
control_0: ┤9       ├
           └────────┘

Computes the weighted sum controlled by state qubits.

Parameters

num_state_qubits (Optional[int]) – The number of state qubits.
weights (Optional[List[int]]) – List of weights, one for each state qubit. If none are provided they default to 1 for every qubit.
name (str) – The name of the circuit.

Attributes

`WeightedAdder.clbits`	Returns a list of classical bits in the order that the registers were added.
`WeightedAdder.data`	Return the circuit data (instructions and context).
`WeightedAdder.extension_lib`
`WeightedAdder.header`
`WeightedAdder.instances`
`WeightedAdder.n_qubits`	Deprecated, use `num_qubits` instead.
`WeightedAdder.num_ancilla_qubits`	The number of ancilla qubits required to implement the weighted sum.
`WeightedAdder.num_carry_qubits`	The number of carry qubits required to compute the sum.
`WeightedAdder.num_clbits`	Return number of classical bits.
`WeightedAdder.num_control_qubits`	The number of additional control qubits required.
`WeightedAdder.num_parameters`	Convenience function to get the number of parameter objects in the circuit.
`WeightedAdder.num_qubits`	Return number of qubits.
`WeightedAdder.num_state_qubits`	The number of qubits to be summed.
`WeightedAdder.num_sum_qubits`	The number of sum qubits in the circuit.
`WeightedAdder.parameters`	Convenience function to get the parameters defined in the parameter table.
`WeightedAdder.prefix`
`WeightedAdder.qregs`	A list of the quantum registers associated with the circuit.
`WeightedAdder.qubits`	Returns a list of quantum bits in the order that the registers were added.
`WeightedAdder.weights`	The weights for the qubit states.

Methods

`WeightedAdder.AND`(qr_variables, qb_target, …)	Build a collective conjunction (AND) circuit in place using mct.
`WeightedAdder.OR`(qr_variables, qb_target, …)	Build a collective disjunction (OR) circuit in place using mct.
`WeightedAdder.__getitem__`(item)	Return indexed operation.
`WeightedAdder.__len__`()	Return number of operations in circuit.
`WeightedAdder.add_register`(*regs)	Add registers.
`WeightedAdder.append`(instruction[, qargs, cargs])	Append one or more instructions to the end of the circuit, modifying the circuit in place.
`WeightedAdder.assign_parameters`(param_dict)	Assign parameters to new parameters or values.
`WeightedAdder.barrier`(*qargs)	Apply `Barrier`.
`WeightedAdder.bind_parameters`(value_dict)	Assign numeric parameters to values yielding a new circuit.
`WeightedAdder.cast`(value, _type)	Best effort to cast value to type.
`WeightedAdder.cbit_argument_conversion`(…)	Converts several classical bit representations (such as indexes, range, etc.) into a list of classical bits.
`WeightedAdder.ccx`(control_qubit1, …[, …])	Apply `CCXGate`.
`WeightedAdder.ch`(control_qubit, target_qubit, *)	Apply `CHGate`.
`WeightedAdder.cls_instances`()	Return the current number of instances of this class, useful for auto naming.
`WeightedAdder.cls_prefix`()	Return the prefix to use for auto naming.
`WeightedAdder.cnot`(control_qubit, …[, …])	Apply `CXGate`.
`WeightedAdder.combine`(rhs)	Append rhs to self if self contains compatible registers.
`WeightedAdder.compose`(other[, qubits, …])	Compose circuit with `other` circuit or instruction, optionally permuting wires.
`WeightedAdder.copy`([name])	Copy the circuit.
`WeightedAdder.count_ops`()	Count each operation kind in the circuit.
`WeightedAdder.crx`(theta, control_qubit, …)	Apply `CRXGate`.
`WeightedAdder.cry`(theta, control_qubit, …)	Apply `CRYGate`.
`WeightedAdder.crz`(theta, control_qubit, …)	Apply `CRZGate`.
`WeightedAdder.cswap`(control_qubit, …[, …])	Apply `CSwapGate`.
`WeightedAdder.cu1`(theta, control_qubit, …)	Apply `CU1Gate`.
`WeightedAdder.cu3`(theta, phi, lam, …[, …])	Apply `CU3Gate`.
`WeightedAdder.cx`(control_qubit, target_qubit, *)	Apply `CXGate`.
`WeightedAdder.cy`(control_qubit, target_qubit, *)	Apply `CYGate`.
`WeightedAdder.cz`(control_qubit, target_qubit, *)	Apply `CZGate`.
`WeightedAdder.dcx`(qubit1, qubit2)	Apply `DCXGate`.
`WeightedAdder.decompose`()	Call a decomposition pass on this circuit, to decompose one level (shallow decompose).
`WeightedAdder.depth`()	Return circuit depth (i.e., length of critical path).
`WeightedAdder.diag_gate`(diag, qubit)	Deprecated version of QuantumCircuit.diagonal.
`WeightedAdder.diagonal`(diag, qubit)	Attach a diagonal gate to a circuit.
`WeightedAdder.draw`([output, scale, …])	Draw the quantum circuit.
`WeightedAdder.extend`(rhs)	Append QuantumCircuit to the right hand side if it contains compatible registers.
`WeightedAdder.fredkin`(control_qubit, …[, …])	Apply `CSwapGate`.
`WeightedAdder.from_qasm_file`(path)	Take in a QASM file and generate a QuantumCircuit object.
`WeightedAdder.from_qasm_str`(qasm_str)	Take in a QASM string and generate a QuantumCircuit object.
`WeightedAdder.h`(qubit, *[, q])	Apply `HGate`.
`WeightedAdder.hamiltonian`(operator, time, qubits)	Apply hamiltonian evolution to to qubits.
`WeightedAdder.has_register`(register)	Test if this circuit has the register r.
`WeightedAdder.i`(qubit, *[, q])	Apply `IGate`.
`WeightedAdder.id`(qubit, *[, q])	Apply `IGate`.
`WeightedAdder.iden`(qubit, *[, q])	Deprecated identity gate.
`WeightedAdder.initialize`(params, qubits)	Apply initialize to circuit.
`WeightedAdder.inverse`()	Invert this circuit.
`WeightedAdder.iso`(isometry, q_input, …[, …])	Attach an arbitrary isometry from m to n qubits to a circuit.
`WeightedAdder.isometry`(isometry, q_input, …)	Attach an arbitrary isometry from m to n qubits to a circuit.
`WeightedAdder.iswap`(qubit1, qubit2)	Apply `iSwapGate`.
`WeightedAdder.mcmt`(gate, control_qubits, …)	Apply a multi-control, multi-target using a generic gate.
`WeightedAdder.mcrx`(theta, q_controls, q_target)	Apply Multiple-Controlled X rotation gate
`WeightedAdder.mcry`(theta, q_controls, …[, …])	Apply Multiple-Controlled Y rotation gate
`WeightedAdder.mcrz`(lam, q_controls, q_target)	Apply Multiple-Controlled Z rotation gate
`WeightedAdder.mct`(control_qubits, target_qubit)	Apply `MCXGate`.
`WeightedAdder.mcu1`(lam, control_qubits, …)	Apply `MCU1Gate`.
`WeightedAdder.mcx`(control_qubits, target_qubit)	Apply `MCXGate`.
`WeightedAdder.measure`(qubit, cbit)	Measure quantum bit into classical bit (tuples).
`WeightedAdder.measure_active`([inplace])	Adds measurement to all non-idle qubits.
`WeightedAdder.measure_all`([inplace])	Adds measurement to all qubits.
`WeightedAdder.mirror`()	Mirror the circuit by reversing the instructions.
`WeightedAdder.ms`(theta, qubits)	Apply `MSGate`.
`WeightedAdder.num_connected_components`([…])	How many non-entangled subcircuits can the circuit be factored to.
`WeightedAdder.num_nonlocal_gates`()	Return number of non-local gates (i.e.
`WeightedAdder.num_tensor_factors`()	Computes the number of tensor factors in the unitary (quantum) part of the circuit only.
`WeightedAdder.num_unitary_factors`()	Computes the number of tensor factors in the unitary (quantum) part of the circuit only.
`WeightedAdder.qasm`([formatted, filename])	Return OpenQASM string.
`WeightedAdder.qbit_argument_conversion`(…)	Converts several qubit representations (such as indexes, range, etc.) into a list of qubits.
`WeightedAdder.r`(theta, phi, qubit, *[, q])	Apply `RGate`.
`WeightedAdder.rcccx`(control_qubit1, …)	Apply `RC3XGate`.
`WeightedAdder.rccx`(control_qubit1, …)	Apply `RCCXGate`.
`WeightedAdder.remove_final_measurements`([…])	Removes final measurement on all qubits if they are present.
`WeightedAdder.reset`(qubit)	Reset q.
`WeightedAdder.rx`(theta, qubit, *[, label, q])	Apply `RXGate`.
`WeightedAdder.rxx`(theta, qubit1, qubit2)	Apply `RXXGate`.
`WeightedAdder.ry`(theta, qubit, *[, label, q])	Apply `RYGate`.
`WeightedAdder.ryy`(theta, qubit1, qubit2)	Apply `RYYGate`.
`WeightedAdder.rz`(phi, qubit, *[, q])	Apply `RZGate`.
`WeightedAdder.rzx`(theta, qubit1, qubit2)	Apply `RZXGate`.
`WeightedAdder.rzz`(theta, qubit1, qubit2)	Apply `RZZGate`.
`WeightedAdder.s`(qubit, *[, q])	Apply `SGate`.
`WeightedAdder.sdg`(qubit, *[, q])	Apply `SdgGate`.
`WeightedAdder.size`()	Returns total number of gate operations in circuit.
`WeightedAdder.snapshot`(label[, …])	Take a statevector snapshot of the internal simulator representation.
`WeightedAdder.snapshot_density_matrix`(label)	Take a density matrix snapshot of simulator state.
`WeightedAdder.snapshot_expectation_value`(…)	Take a snapshot of expectation value <O> of an Operator.
`WeightedAdder.snapshot_probabilities`(label, …)	Take a probability snapshot of the simulator state.
`WeightedAdder.snapshot_stabilizer`(label)	Take a stabilizer snapshot of the simulator state.
`WeightedAdder.snapshot_statevector`(label)	Take a statevector snapshot of the simulator state.
`WeightedAdder.squ`(unitary_matrix, qubit[, …])	Decompose an arbitrary 2*2 unitary into three rotation gates.
`WeightedAdder.swap`(qubit1, qubit2)	Apply `SwapGate`.
`WeightedAdder.t`(qubit, *[, q])	Apply `TGate`.
`WeightedAdder.tdg`(qubit, *[, q])	Apply `TdgGate`.
`WeightedAdder.to_gate`([parameter_map])	Create a Gate out of this circuit.
`WeightedAdder.to_instruction`([parameter_map])	Create an Instruction out of this circuit.
`WeightedAdder.toffoli`(control_qubit1, …[, …])	Apply `CCXGate`.
`WeightedAdder.u1`(theta, qubit, *[, q])	Apply `U1Gate`.
`WeightedAdder.u2`(phi, lam, qubit, *[, q])	Apply `U2Gate`.
`WeightedAdder.u3`(theta, phi, lam, qubit, *)	Apply `U3Gate`.
`WeightedAdder.uc`(gate_list, q_controls, q_target)	Attach a uniformly controlled gates (also called multiplexed gates) to a circuit.
`WeightedAdder.ucg`(angle_list, q_controls, …)	Deprecated version of uc.
`WeightedAdder.ucrx`(angle_list, q_controls, …)	Attach a uniformly controlled (also called multiplexed) Rx rotation gate to a circuit.
`WeightedAdder.ucry`(angle_list, q_controls, …)	Attach a uniformly controlled (also called multiplexed) Ry rotation gate to a circuit.
`WeightedAdder.ucrz`(angle_list, q_controls, …)	Attach a uniformly controlled (also called multiplexed gates) Rz rotation gate to a circuit.
`WeightedAdder.ucx`(angle_list, q_controls, …)	Deprecated version of ucrx.
`WeightedAdder.ucy`(angle_list, q_controls, …)	Deprecated version of ucry.
`WeightedAdder.ucz`(angle_list, q_controls, …)	Deprecated version of ucrz.
`WeightedAdder.unitary`(obj, qubits[, label])	Apply unitary gate to q.
`WeightedAdder.width`()	Return number of qubits plus clbits in circuit.
`WeightedAdder.x`(qubit, *[, label, ctrl_state, q])	Apply `XGate`.
`WeightedAdder.y`(qubit, *[, q])	Apply `YGate`.
`WeightedAdder.z`(qubit, *[, q])	Apply `ZGate`.
`WeightedAdder.__getitem__`(item)	Return indexed operation.
`WeightedAdder.__len__`()	Return number of operations in circuit.