Evolved operator functions

crates/accelerate/src/circuit_library/mod.rs

@@ -17,6 +17,7 @@ mod iqp;
 mod pauli_evolution;
 mod pauli_feature_map;
 mod quantum_volume;
+mod utils;
 
 pub fn circuit_library(m: &Bound<PyModule>) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(pauli_evolution::py_pauli_evolution))?;

crates/accelerate/src/circuit_library/pauli_evolution.rs

@@ -14,18 +14,12 @@ use pyo3::prelude::*;
 use pyo3::types::{PyList, PyString, PyTuple};
 use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::operations::{multiply_param, radd_param, Param, PyInstruction, StandardGate};
-use qiskit_circuit::packed_instruction::PackedOperation;
-use qiskit_circuit::{imports, Clbit, Qubit};
+use qiskit_circuit::{imports, Qubit};
 use smallvec::{smallvec, SmallVec};
 
+use crate::circuit_library::utils::{Instruction, StandardInstruction};
+
 // custom types for a more readable code
-type StandardInstruction = (StandardGate, SmallVec<[Param; 3]>, SmallVec<[Qubit; 2]>);
-type Instruction = (
-    PackedOperation,
-    SmallVec<[Param; 3]>,
-    Vec<Qubit>,
-    Vec<Clbit>,
-);
 
 /// Return instructions (using only StandardGate operations) to implement a Pauli evolution
 /// of a given Pauli string over a given time (as Param).

crates/accelerate/src/circuit_library/pauli_feature_map.rs

@@ -17,22 +17,15 @@ use qiskit_circuit::circuit_data::CircuitData;
 use qiskit_circuit::imports;
 use qiskit_circuit::operations::PyInstruction;
 use qiskit_circuit::operations::{add_param, multiply_param, multiply_params, Param, StandardGate};
-use qiskit_circuit::packed_instruction::PackedOperation;
 use qiskit_circuit::{Clbit, Qubit};
-use smallvec::{smallvec, SmallVec};
+use smallvec::smallvec;
 use std::f64::consts::PI;
 
 use crate::circuit_library::entanglement;
 use crate::circuit_library::pauli_evolution;
+use crate::circuit_library::utils::Instruction;
 use crate::QiskitError;
 
-type Instruction = (
-    PackedOperation,
-    SmallVec<[Param; 3]>,
-    Vec<Qubit>,
-    Vec<Clbit>,
-);
-
 /// Build a Pauli feature map circuit.
 ///
 /// Args:

crates/accelerate/src/circuit_library/utils.rs

@@ -0,0 +1,26 @@
+// This code is part of Qiskit.
+//
+// (C) Copyright IBM 2024
+//
+// This code is licensed under the Apache License, Version 2.0. You may
+// obtain a copy of this license in the LICENSE.txt file in the root directory
+// of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+//
+// Any modifications or derivative works of this code must retain this
+// copyright notice, and modified files need to carry a notice indicating
+// that they have been altered from the originals.
+
+use qiskit_circuit::{
+    operations::{Param, StandardGate},
+    packed_instruction::PackedOperation,
+    Clbit, Qubit,
+};
+use smallvec::SmallVec;
+
+pub(super) type StandardInstruction = (StandardGate, SmallVec<[Param; 3]>, SmallVec<[Qubit; 2]>);
+pub(super) type Instruction = (
+    PackedOperation,
+    SmallVec<[Param; 3]>,
+    Vec<Qubit>,
+    Vec<Clbit>,
+);

crates/circuit/src/operations.rs

@@ -2335,13 +2335,15 @@ pub fn add_param(param: &Param, summand: f64, py: Python) -> Param {
                 .call_method1(py, intern!(py, "__add__"), (summand,))
                 .expect("Sum of Parameter expression and float failed."),
         ),
-        Param::Obj(_) => unreachable!(),
+        Param::Obj(_) => unreachable!("Unsupported addition of a Param::Obj."),
     }
 }
 
 pub fn radd_param(param1: Param, param2: Param, py: Python) -> Param {
     match [param1, param2] {
         [Param::Float(theta), Param::Float(lambda)] => Param::Float(theta + lambda),
+        [param, Param::Float(lambda)] => add_param(&param, lambda, py),
+        [Param::Float(theta), param] => add_param(&param, theta, py),
         [Param::ParameterExpression(theta), Param::ParameterExpression(lambda)] => {
             Param::ParameterExpression(
                 theta
@@ -2350,7 +2352,7 @@ pub fn radd_param(param1: Param, param2: Param, py: Python) -> Param {
                     .expect("Parameter expression addition failed"),
             )
         }
-        _ => unreachable!(),
+        _ => unreachable!("Unsupported addition."),
     }
 }
 

qiskit/circuit/library/__init__.py

@@ -366,6 +366,13 @@
    ExcitationPreserving
    QAOAAnsatz
 
+The following functions return a parameterized :class:`.QuantumCircuit` to use as ansatz in
+a broad set of variational algorithms:
+
+.. autofunction:: hamiltonian_variational_ansatz
+.. autofunction:: evolved_operator_ansatz
+.. autofunction:: qaoa_ansatz
+
 
 Data encoding circuits
 ======================
@@ -576,8 +583,11 @@
     PauliTwoDesign,
     RealAmplitudes,
     EfficientSU2,
+    hamiltonian_variational_ansatz,
+    evolved_operator_ansatz,
     EvolvedOperatorAnsatz,
     ExcitationPreserving,
+    qaoa_ansatz,
     QAOAAnsatz,
 )
 from .data_preparation import (

qiskit/circuit/library/n_local/__init__.py

@@ -17,17 +17,24 @@
 from .pauli_two_design import PauliTwoDesign
 from .real_amplitudes import RealAmplitudes
 from .efficient_su2 import EfficientSU2
-from .evolved_operator_ansatz import EvolvedOperatorAnsatz
+from .evolved_operator_ansatz import (
+    EvolvedOperatorAnsatz,
+    evolved_operator_ansatz,
+    hamiltonian_variational_ansatz,
+)
 from .excitation_preserving import ExcitationPreserving
-from .qaoa_ansatz import QAOAAnsatz
+from .qaoa_ansatz import QAOAAnsatz, qaoa_ansatz
 
 __all__ = [
     "NLocal",
     "TwoLocal",
     "RealAmplitudes",
     "PauliTwoDesign",
     "EfficientSU2",
+    "hamiltonian_variational_ansatz",
+    "evolved_operator_ansatz",
     "EvolvedOperatorAnsatz",
     "ExcitationPreserving",
+    "qaoa_ansatz",
     "QAOAAnsatz",
 ]