Changed EfficientSU2 to efficient_su2 (#2841)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Frank Harkins <[email protected]>

Author: 3 people

Diff for: docs/guides/ai-transpiler-passes.mdx

@@ -42,14 +42,14 @@ The `AIRouting` pass acts both as a layout stage and a routing stage. It can be
 
 ```python
 from qiskit.transpiler import PassManager
-from qiskit.circuit.library import EfficientSU2
+from qiskit.circuit.library import efficient_su2
 from qiskit_ibm_transpiler.ai.routing import AIRouting
 
 ai_passmanager = PassManager([
   AIRouting(backend_name="ibm_sherbrooke", optimization_level=2, layout_mode="optimize", local_mode=True)
 ])
 
-circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
+circuit = efficient_su2(101, entanglement="circular", reps=1)
 
 transpiled_circuit = ai_passmanager.run(circuit)
 ```
@@ -74,7 +74,7 @@ from qiskit_ibm_transpiler.ai.synthesis import AILinearFunctionSynthesis
 from qiskit_ibm_transpiler.ai.collection import CollectLinearFunctions
 from qiskit_ibm_transpiler.ai.synthesis import AIPauliNetworkSynthesis
 from qiskit_ibm_transpiler.ai.collection import CollectPauliNetworks
-from qiskit.circuit.library import EfficientSU2
+from qiskit.circuit.library import efficient_su2
 
 ai_passmanager = PassManager([
   AIRouting(backend_name="ibm_cairo", optimization_level=3, layout_mode="optimize", local_mode=True),  # Route circuit
@@ -84,7 +84,7 @@ ai_passmanager = PassManager([
   AIPauliNetworkSynthesis(backend_name="ibm_cairo", local_mode=False),  # Re-synthesize Pauli Network blocks. Only available in the Qiskit Transpiler Service
 ])
 
-circuit = EfficientSU2(10, entanglement="full", reps=1).decompose()
+circuit = efficient_su2(10, entanglement="full", reps=1)
 
 transpiled_circuit = ai_passmanager.run(circuit)
 ```
@@ -125,13 +125,13 @@ The `qiskit-ibm-transpiler` allows you to configure a hybrid pass manager that c
 
 ```python
     from qiskit_ibm_transpiler import generate_ai_pass_manager
-    from qiskit.circuit.library import EfficientSU2
+    from qiskit.circuit.library import efficient_su2
     from qiskit_ibm_runtime import QiskitRuntimeService
 
     backend = QiskitRuntimeService().backend("ibm_fez")
     fez_coupling_map = backend.coupling_map
 
-    su2_circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
+    su2_circuit = efficient_su2(101, entanglement="circular", reps=1)
 
     ai_transpiler_pass_manager = generate_ai_pass_manager(
         coupling_map=fez_coupling_map,

Diff for: docs/guides/dynamical-decoupling-pass-manager.ipynb

@@ -65,7 +65,7 @@
    "id": "0606fde9-d0d9-4ab5-a941-7ab96de50cc5",
    "metadata": {},
    "source": [
-    "Create an `EfficientSU2` circuit as an example. First, transpile the circuit to the backend because dynamical decoupling pulses need to be added after the circuit has been transpiled and scheduled. Dynamical decoupling often works best when there is a lot of idle time in the quantum circuits - that is, there are qubits that are not being used while others are active. This is the case in this circuit because the two-qubit `ecr` gates are applied sequentially in this ansatz."
+    "Create an `efficient_su2` circuit as an example. First, transpile the circuit to the backend because dynamical decoupling pulses need to be added after the circuit has been transpiled and scheduled. Dynamical decoupling often works best when there is a lot of idle time in the quantum circuits - that is, there are qubits that are not being used while others are active. This is the case in this circuit because the two-qubit `ecr` gates are applied sequentially in this ansatz."
    ]
   },
   {
@@ -90,9 +90,9 @@
    ],
    "source": [
     "from qiskit.transpiler import generate_preset_pass_manager\n",
-    "from qiskit.circuit.library import EfficientSU2\n",
+    "from qiskit.circuit.library import efficient_su2\n",
     "\n",
-    "qc = EfficientSU2(12, entanglement=\"circular\", reps=1)\n",
+    "qc = efficient_su2(12, entanglement=\"circular\", reps=1)\n",
     "pm = generate_preset_pass_manager(1, target=target, seed_transpiler=12345)\n",
     "qc_t = pm.run(qc)\n",
     "qc_t.draw(\"mpl\", fold=-1, idle_wires=False)"
@@ -157,7 +157,7 @@
    "id": "d3fef37d-1c01-4303-be85-1ff90be760ae",
    "metadata": {},
    "source": [
-    "Ansatz circuits such as `EfficientSU2` are parameterized, so they must have value bound to them before being sent to the backend. Here, assign random parameters."
+    "Ansatz circuits such as `efficient_su2` are parameterized, so they must have value bound to them before being sent to the backend. Here, assign random parameters."
    ]
   },
   {

Diff for: docs/guides/get-started-with-primitives.ipynb

@@ -290,9 +290,9 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from qiskit.circuit.library import EfficientSU2\n",
+    "from qiskit.circuit.library import efficient_su2\n",
     "\n",
-    "circuit = EfficientSU2(127, entanglement=\"linear\", flatten=True)\n",
+    "circuit = efficient_su2(127, entanglement=\"linear\")\n",
     "circuit.measure_all()\n",
     "# The circuit is parametrized, so we will define the parameter values for execution\n",
     "param_values = np.random.rand(circuit.num_parameters)"

Diff for: docs/guides/qiskit-transpiler-service.mdx

@@ -47,10 +47,10 @@ The following examples demonstrate how to transpile circuits using the Qiskit Tr
 1. Create a circuit and call the Qiskit Transpiler Service to transpile the circuit with `ibm_sherbrooke` as the `backend_name`, 3 as the `optimization_level`, and without using AI during the transpilation.
 
     ```python
-    from qiskit.circuit.library import EfficientSU2
+    from qiskit.circuit.library import efficient_su2
     from qiskit_ibm_transpiler.transpiler_service import TranspilerService
 
-    circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
+    circuit = efficient_su2(101, entanglement="circular", reps=1)
 
     cloud_transpiler_service = TranspilerService(
         backend_name="ibm_sherbrooke",
@@ -64,10 +64,10 @@ The following examples demonstrate how to transpile circuits using the Qiskit Tr
 2. Produce a similar circuit and transpile it, requesting AI transpiling capabilities by setting the flag `ai` to `True`:
 
     ```python
-    from qiskit.circuit.library import EfficientSU2
+    from qiskit.circuit.library import efficient_su2
     from qiskit_ibm_transpiler.transpiler_service import TranspilerService
 
-    circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
+    circuit = efficient_su2(101, entanglement="circular", reps=1)
 
     cloud_transpiler_service = TranspilerService(
         backend_name="ibm_sherbrooke",
@@ -81,10 +81,10 @@ The following examples demonstrate how to transpile circuits using the Qiskit Tr
 
 
     ```python
-    from qiskit.circuit.library import EfficientSU2
+    from qiskit.circuit.library import efficient_su2
     from qiskit_ibm_transpiler.transpiler_service import TranspilerService
 
-    circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
+    circuit = efficient_su2(101, entanglement="circular", reps=1)
 
     cloud_transpiler_service = TranspilerService(
         backend_name="ibm_sherbrooke",

Diff for: docs/guides/represent-quantum-computers.ipynb

@@ -80,8 +80,7 @@
    "id": "4064b5ad-8a3a-462b-ae30-29576230c084",
    "metadata": {},
    "source": [
-    "The example circuit uses an instance of [`EfficientSU2`](/api/qiskit/qiskit.circuit.library.EfficientSU2#efficientsu2) from Qiskit's circuit library.\n",
-    "The following cell decomposes the circuit before drawing it to show its gate structure."
+    "The example circuit uses an instance of [`efficient_su2`](/api/qiskit/qiskit.circuit.library.efficient_su2) from Qiskit's circuit library."
    ]
   },
   {
@@ -105,11 +104,11 @@
     }
    ],
    "source": [
-    "from qiskit.circuit.library import EfficientSU2\n",
+    "from qiskit.circuit.library import efficient_su2\n",
     "\n",
-    "qc = EfficientSU2(12, entanglement=\"circular\", reps=1)\n",
+    "qc = efficient_su2(12, entanglement=\"circular\", reps=1)\n",
     "\n",
-    "qc.decompose().draw(\"mpl\")"
+    "qc.draw(\"mpl\")"
    ]
   },
   {

Diff for: docs/guides/simulate-stabilizer-circuits.ipynb

@@ -49,7 +49,7 @@
     "Stabilizer circuits are important to the study of quantum error correction. Their classical simulability also makes them useful for verifying the output of quantum computers. For example, suppose you want to execute a quantum circuit that uses 100 qubits on a quantum computer. How do you know that the quantum computer is behaving correctly? A quantum circuit on 100 qubits is beyond the reach of brute-force classical simulation. By modifying your circuit so that it becomes a stabilizer circuit, you can run circuits on the quantum computer that have a similar structure to your desired circuit, but which you can simulate on a classical computer. By checking the output of the quantum computer on the stabilizer circuits, you can gain confidence that it is behaving correctly on the non-stabilizer circuits as well. See [*Evidence for the utility of quantum computing before fault tolerance*](https://www.nature.com/articles/s41586-023-06096-3) for an example of this idea in practice.\n",
     "\n",
     "\n",
-    "[Exact and noisy simulation with Qiskit Aer primitives](simulate-with-qiskit-aer) shows how to use [Qiskit Aer](https://qiskit.org/ecosystem/aer/) to perform exact and noisy simulations of generic quantum circuits. Consider the example circuit used in that article, an 8-qubit circuit built using [EfficientSU2](../api/qiskit/qiskit.circuit.library.EfficientSU2):"
+    "[Exact and noisy simulation with Qiskit Aer primitives](simulate-with-qiskit-aer) shows how to use [Qiskit Aer](https://qiskit.org/ecosystem/aer/) to perform exact and noisy simulations of generic quantum circuits. Consider the example circuit used in that article, an 8-qubit circuit built using [efficient_su2](../api/qiskit/qiskit.circuit.library.efficient_su2):"
    ]
   },
   {
@@ -73,11 +73,11 @@
     }
    ],
    "source": [
-    "from qiskit.circuit.library import EfficientSU2\n",
+    "from qiskit.circuit.library import efficient_su2\n",
     "\n",
     "n_qubits = 8\n",
-    "circuit = EfficientSU2(n_qubits)\n",
-    "circuit.decompose().draw(\"mpl\")"
+    "circuit = efficient_su2(n_qubits)\n",
+    "circuit.draw(\"mpl\")"
    ]
   },
   {
@@ -96,7 +96,7 @@
    "outputs": [],
    "source": [
     "n_qubits = 500\n",
-    "circuit = EfficientSU2(n_qubits)\n",
+    "circuit = efficient_su2(n_qubits)\n",
     "# don't try to draw the circuit because it's too large"
    ]
   },
@@ -105,7 +105,7 @@
    "id": "ecd975b0-2ec0-4a99-a0f6-790d43af19fb",
    "metadata": {},
    "source": [
-    "Because the cost of simulating quantum circuits scales exponentially with the number of qubits, such a large circuit would generally exceed the capabilities of even a high-performance simulator like Qiskit Aer. Classical simulation of generic quantum circuits becomes infeasible when the number of qubits exceeds roughly 50 to 100 qubits. However, note that the EfficientSU2 circuit is parameterized by angles on $R_y$ and $R_z$ gates. If all of these angles are contained in the set $\\{0, \\frac{\\pi}{2}, \\pi, \\frac{3\\pi}{2}\\}$, then the circuit is a stabilizer circuit, and it can be efficiently simulated!\n",
+    "Because the cost of simulating quantum circuits scales exponentially with the number of qubits, such a large circuit would generally exceed the capabilities of even a high-performance simulator like Qiskit Aer. Classical simulation of generic quantum circuits becomes infeasible when the number of qubits exceeds roughly 50 to 100 qubits. However, note that the efficient_su2 circuit is parameterized by angles on $R_y$ and $R_z$ gates. If all of these angles are contained in the set $\\{0, \\frac{\\pi}{2}, \\pi, \\frac{3\\pi}{2}\\}$, then the circuit is a stabilizer circuit, and it can be efficiently simulated!\n",
     "\n",
     "In the following cell, we run the circuit with the Sampler primitive backed by the stabilizer circuit simulator, using parameters chosen randomly such that the circuit is guaranteed to be a stabilizer circuit."
    ]

Diff for: docs/guides/simulate-with-qiskit-aer.ipynb

@@ -66,11 +66,11 @@
     }
    ],
    "source": [
-    "from qiskit.circuit.library import EfficientSU2\n",
+    "from qiskit.circuit.library import efficient_su2\n",
     "\n",
     "n_qubits = 8\n",
-    "circuit = EfficientSU2(n_qubits)\n",
-    "circuit.decompose().draw(\"mpl\")"
+    "circuit = efficient_su2(n_qubits)\n",
+    "circuit.draw(\"mpl\")"
    ]
   },
   {
@@ -180,7 +180,7 @@
     "\n",
     "where $n$ is the number of qubits, in this case, 2. That is, with probability $p$, the state is replaced with the completely mixed state, and the state is preserved with probability $1 - p$. After $m$ applications of the depolarizing channel, the probability of the state being preserved would be $(1 - p)^m$. Therefore, we expect the probability of retaining the correct state at the end of the simulation to go down exponentially with the number of CX gates in our circuit.\n",
     "\n",
-    "Let's count the number of CX gates in our circuit and compute $(1 - p)^m$. Because our circuit uses the EfficientSU2 class, we'll need to call `decompose` once to decompose it into CX gates. We call `count_ops` to get a dictionary that maps gate names to counts, and retrieve the entry for the CX gate."
+    "Let's count the number of CX gates in our circuit and compute $(1 - p)^m$. We call `count_ops` to get a dictionary that maps gate names to counts, and retrieve the entry for the CX gate."
    ]
   },
   {
@@ -201,7 +201,7 @@
     }
    ],
    "source": [
-    "cx_count = circuit.decompose().count_ops()[\"cx\"]\n",
+    "cx_count = circuit.count_ops()[\"cx\"]\n",
     "(1 - cx_depolarizing_prob) ** cx_count"
    ]
   },