Exemplo n.º 1
0
    def construct_circuit(self, parameters, q=None):
        """ construct circuit """
        if not len(parameters) == self.num_parameters:
            raise ValueError(
                'Incorrect number of angles: expecting {}, but {} given.'.
                format(self.num_parameters, len(parameters)))

        # initialize circuit, possibly based on given register/initial state
        if isinstance(self._initial_state, QuantumCircuit):
            circuit_op = CircuitStateFn(self._initial_state)
        elif self._initial_state is not None:
            circuit_op = CircuitStateFn(
                self._initial_state.construct_circuit('circuit'))
        else:
            circuit_op = (H ^ self._num_qubits)

        # iterate over layers
        for idx in range(self._p):
            # the first [:self._p] parameters are used for the cost operator,
            # so we apply them here
            circuit_op = (self._cost_operator *
                          parameters[idx]).exp_i().compose(circuit_op)
            if isinstance(self._mixer, OperatorBase):
                mixer = cast(OperatorBase, self._mixer)
                # we apply beta parameter in case of operator based mixer.
                circuit_op = (
                    mixer *
                    parameters[idx + self._p]).exp_i().compose(circuit_op)
            else:
                # mixer as a quantum circuit that can be parameterized
                mixer = cast(QuantumCircuit, self._mixer)
                num_params = mixer.num_parameters
                # the remaining [self._p:] parameters are used for the mixer,
                # there may be multiple layers, so parameters are grouped by layers.
                param_values = parameters[self._p + num_params * idx:self._p +
                                          num_params * (idx + 1)]
                param_dict = dict(zip(mixer.parameters, param_values))
                mixer = mixer.assign_parameters(param_dict)
                circuit_op = CircuitOp(mixer).compose(circuit_op)

        evolution = EvolutionFactory.build(self._cost_operator)
        circuit_op = evolution.convert(circuit_op)
        return circuit_op.to_circuit()
Exemplo n.º 2
0
    def _construct_circuit(self, parameters) -> QuantumCircuit:
        """Construct a parameterized circuit."""
        if not len(parameters) == self._num_parameters:
            raise ValueError(
                'Incorrect number of angles: expecting {}, but {} given.'.
                format(self._num_parameters, len(parameters)))

        # local imports to avoid circular imports
        from qiskit.opflow import CircuitStateFn
        from qiskit.opflow import CircuitOp, EvolutionFactory
        from qiskit.opflow import OperatorBase

        circuit_op = CircuitStateFn(self.initial_state)

        # iterate over layers
        for idx in range(self._reps):
            # the first [:self._reps] parameters are used for the cost operator,
            # so we apply them here
            circuit_op = (self._cost_operator *
                          parameters[idx]).exp_i().compose(circuit_op)
            mixer = self.mixer_operator
            if isinstance(mixer, OperatorBase):
                mixer = cast(OperatorBase, mixer)
                # we apply beta parameter in case of operator based mixer.
                circuit_op = (
                    mixer *
                    parameters[idx + self._reps]).exp_i().compose(circuit_op)
            else:
                # mixer as a quantum circuit that can be parameterized
                mixer = cast(QuantumCircuit, mixer)
                num_params = mixer.num_parameters
                # the remaining [self._p:] parameters are used for the mixer,
                # there may be multiple layers, so parameters are grouped by layers.
                param_values = parameters[self._reps +
                                          num_params * idx:self._reps +
                                          num_params * (idx + 1)]
                param_dict = dict(zip(mixer.parameters, param_values))
                mixer = mixer.assign_parameters(param_dict)
                circuit_op = CircuitOp(mixer).compose(circuit_op)

        evolution = EvolutionFactory.build(self._cost_operator)
        circuit_op = evolution.convert(circuit_op)
        return circuit_op.to_circuit()