Fix rigetti docs, links, and shots

samples/hello-world/HW-quantinuum-qiskit.ipynb

@@ -237,8 +237,8 @@
     "quantinuum_api_val_backend = provider.get_backend(\"quantinuum.sim.h1-1sc\")\n",
     "\n",
     "# Using the Quantinuum target, call \"run\" to submit the job. We'll\n",
-    "# use a count of 100 (simulated runs).\n",
-    "job = quantinuum_api_val_backend.run(circuit, count=100)\n",
+    "# use 100 shots (simulated runs).\n",
+    "job = quantinuum_api_val_backend.run(circuit, shots=100)\n",
     "print(\"Job id:\", job.id())"
    ]
   },

samples/hello-world/HW-rigetti-qiskit.ipynb

@@ -135,8 +135,9 @@
         "| Target name | Target ID | Number of qubits | Description |\n",
         "| --- | --- | --- | --- |\n",
         "| Rigetti QVM (simulator) | `rigetti.sim.qvm` | 20 qubits | Rigetti's cloud-based, [open-source](https://github.com/quil-lang/qvm) \"Quantum Virtual Machine\" simulator. Free to use. |\n",
-        "| Aspen M-3 (hardware) | `rigetti.qpu.aspen-m-3` | 80 qubits | Rigetti's \"Aspen-M-3\" universal, physical QPU. Read more at [Rigetti's website](https://qcs.rigetti.com/qpus). |\n",
-        "\n",
+        "| Ankaa-9q-1 (hardware) | `rigetti.qpu.ankaa-9q-1` | 9 qubits | A 4th-generation, square-lattice processor. Pricing based on QPUs. |\n",
+        "| Ankaa-2 (hardware) | `rigetti.qpu.ankaa-2` | 84 qubits | A 4th-generation, square-lattice processor. Pricing based on QPUs. |\n",
+        "| Aspen M-3 (hardware) | `rigetti.qpu.aspen-m-3` | 8 qubits | An octagonal-lattice processor. Pricing based on QPUs. Deprecation pending. |\n",
         "\n",
         "For this example, we will use `rigetti.sim.qvm`. To learn more about Rigetti's targets, check out [Rigetti's Azure Quantum documentation](https://docs.microsoft.com/azure/quantum/provider-rigetti)."
       ]
@@ -246,7 +247,7 @@
         "\n",
         "# Using the Rigetti simulator target, call \"run\" to submit the job. We'll\n",
         "# use 100 shots (simulated runs).\n",
-        "job = rigetti_simulator_backend.run((circuit), count=100)\n",
+        "job = rigetti_simulator_backend.run((circuit), shots=100)\n",
         "print(\"Job id:\", job.id())"
       ]
     },

samples/hello-world/HW-rigetti-qsharp.ipynb

@@ -128,7 +128,9 @@
         "| Target name | Target ID | Number of qubits | Description |\n",
         "| --- | --- | --- | --- |\n",
         "| Rigetti QVM (simulator) | `rigetti.sim.qvm` | 20 qubits | Rigetti's cloud-based, [open-source](https://github.com/quil-lang/qvm) \"Quantum Virtual Machine\" simulator. Free to use. |\n",
-        "| Aspen M-3 (hardware) | `rigetti.qpu.aspen-m-3` | 80 qubits | Rigetti's \"Aspen-M-3\" universal, physical QPU. Read more at [Rigetti's website](https://qcs.rigetti.com/qpus). |\n",
+        "| Ankaa-9q-1 (hardware) | `rigetti.qpu.ankaa-9q-1` | 9 qubits | A 4th-generation, square-lattice processor. Pricing based on QPUs. |\n",
+        "| Ankaa-2 (hardware) | `rigetti.qpu.ankaa-2` | 84 qubits | A 4th-generation, square-lattice processor. Pricing based on QPUs. |\n",
+        "| Aspen M-3 (hardware) | `rigetti.qpu.aspen-m-3` | 8 qubits | An octagonal-lattice processor. Pricing based on QPUs. Deprecation pending. |\n",
         "\n",
         "For this example, we will use `rigetti.sim.qvm`. To learn more about Rigetti's targets, check out [Rigetti's Azure Quantum documentation](https://docs.microsoft.com/azure/quantum/provider-rigetti)."
       ]

samples/hidden-shift/hidden-shift.ipynb

@@ -543,7 +543,7 @@
         "transpiled = transpile(circ, quantinuum_backend)\n",
         "\n",
         "# And we estimate the cost of simulating the circuit 100 times.\n",
-        "cost = quantinuum_backend.estimate_cost(transpiled, count=100)\n",
+        "cost = quantinuum_backend.estimate_cost(transpiled, shots=100)\n",
         "print(f\"Estimated cost: {cost.estimated_total} {cost.currency_code}\")"
       ]
     },
@@ -564,7 +564,7 @@
       },
       "outputs": [],
       "source": [
-        "# job = quantinuum_backend.run(transpiled, count=100)\n",
+        "# job = quantinuum_backend.run(transpiled, shots=100)\n",
         "# print(\"Job id:\", job.id())\n",
         "# job_monitor(job)\n",
         "# result = job.result()\n",
@@ -980,7 +980,7 @@
         "transpiled = transpile(circ, quantinuum_backend)\n",
         "\n",
         "# And we estimate the cost of simulating the circuit 100 times\n",
-        "cost = quantinuum_backend.estimate_cost(transpiled, count=100)\n",
+        "cost = quantinuum_backend.estimate_cost(transpiled, shots=100)\n",
         "print(f\"Estimated cost: {cost.estimated_total} {cost.currency_code}\")"
       ]
     },
@@ -1016,7 +1016,7 @@
       "outputs": [],
       "source": [
         "# # Using the simulator target, call \"run\" to submit the job.\n",
-        "# job = quantinuum_backend.run(transpiled, count=100)\n",
+        "# job = quantinuum_backend.run(transpiled, shots=100)\n",
         "\n",
         "# # Get the job results (this method also waits for the Job to complete):\n",
         "# result = job.result()\n",

samples/resource-estimator/estimation-chemistry.ipynb

@@ -277,11 +277,11 @@
    "source": [
     "## ℹ️ Relationship with VQE sample\n",
     "\n",
-    "You may already be familiar with our [Variational Quantum Eigensolver (VQE) sample notebook](https://github.com/microsoft/Quantum/blob/main/samples/azure-quantum/variational-quantum-eigensolver/VQE-qiskit-hydrogen-session.ipynb), which also takes as input Hamiltonians recorded in FCIDUMP format. VQE algorithms are useful for building an understanding of the current limits of quantum hardware for the purposes of education and research. In the longer term, we will simulate quantum systems using more efficient algorithms tailored for large-scale fault-tolerant quantum hardware.\n",
+    "You may already be familiar with our [Variational Quantum Eigensolver (VQE) sample notebook](https://github.com/microsoft/azure-quantum-python/blob/main/samples/vqe/VQE-qiskit-hydrogen-session.ipynb), which also takes as input Hamiltonians recorded in FCIDUMP format. VQE algorithms are useful for building an understanding of the current limits of quantum hardware for the purposes of education and research. In the longer term, we will simulate quantum systems using more efficient algorithms tailored for large-scale fault-tolerant quantum hardware.\n",
     "\n",
     "Notable simulation algorithms, such as qubitization, quantum signal processing, or trotterization, can be used as subroutines in the quantum phase estimation (QPE) algorithm to obtain high-accuracy energy estimates of a targeted eigenstate. The Azure Quantum Resource Estimator is designed with these long-term algorithms (particularly QPE + qubitization) in mind (rather than VQE).\n",
     "\n",
-    "Please be aware that while you may use the FCIDUMP files included in the [VQE sample](https://github.com/microsoft/Quantum/blob/main/samples/azure-quantum/variational-quantum-eigensolver/VQE-qiskit-hydrogen-session.ipynb) to generate resource estimates in this end-to-end chemistry sample, the VQE samples provided are for very small systems that we can simulate using VQE optimized for quantum hardware today. As the current QPE + qubitization implementation is optimized for large-scale fault-tolerant quantum hardware, the quantum resource estimates generated by the Resource Estimator will be much larger than what is required to run VQE for these systems.\n",
+    "Please be aware that while you may use the FCIDUMP files included in the [VQE sample](https://github.com/microsoft/azure-quantum-python/blob/main/samples/vqe/VQE-qiskit-hydrogen-session.ipynb) to generate resource estimates in this end-to-end chemistry sample, the VQE samples provided are for very small systems that we can simulate using VQE optimized for quantum hardware today. As the current QPE + qubitization implementation is optimized for large-scale fault-tolerant quantum hardware, the quantum resource estimates generated by the Resource Estimator will be much larger than what is required to run VQE for these systems.\n",
     "\n",
     "The FCIDUMP sample files provided in this chemistry end-to-end sample are too large to run using VQE on today's quantum systems, so they will not work in the VQE notebook."
    ]

samples/sessions/introduction-to-sessions.ipynb

@@ -233,7 +233,7 @@
       },
       "source": [
         "### 4. Next steps\n",
-        "You now have everything you need to get starting building quantum algorithms with sessions! As a next step, you can explore advanced samples in the hybrid quantum computing sample gallery, including an example of using sessions to run the Variational Quantum Eigensolver to estimate the ground state energy of a hydrogen molecule. As you create more complex algorithms with extended runtime, we recommend [running them locally](https://learn.microsoft.com/en-us/azure/quantum/how-to-long-running-experiments#local-development) to avoid job failures caused by occasional connectivity issues with Azure Quantum's hosted notebooks.\n",
+        "You now have everything you need to get starting building quantum algorithms with sessions! As a next step, you can explore advanced samples in the hybrid quantum computing sample gallery, including an example of using sessions to run the Variational Quantum Eigensolver to estimate the ground state energy of a hydrogen molecule. As you create more complex algorithms with extended runtime, we recommend [running them locally](https://learn.microsoft.com/azure/quantum/how-to-long-running-experiments#local-development) to avoid job failures caused by occasional connectivity issues with Azure Quantum's hosted notebooks.\n",
         "\n",
         "For more information on sessions, including how Quantinuum provides **reserved QPU access** once a session is started, check out the [sessions documentation](https://aka.ms/AQ/Hybrid/Sessions/Docs).\n",
         "\n",

samples/vqe/VQE-qiskit-hydrogen-session.ipynb

@@ -399,7 +399,7 @@
         "\n",
         "Notable simulation algorithms, such as qubitization, quantum signal processing, or trotterization, can be used as subroutines in the quantum phase estimation (QPE) algorithm to obtain high-accuracy energy estimates of a targeted eigenstate. The Azure Quantum Resource Estimator is designed with these long-term algorithms (particularly QPE + qubitization) in mind (rather than VQE).\n",
         "\n",
-        "Please be aware that while you may use the FCIDUMP files included in this sample to generate resource estimates in the [chemistry resource estimation sample](https://github.com/microsoft/Quantum/blob/main/samples/azure-quantum/resource-estimation/estimation-chemistry.ipynb), the samples provided here are for very small systems that we can simulate using VQE optimized for quantum hardware today. As the current QPE + qubitization implementation is optimized for large-scale fault-tolerant quantum hardware, the quantum resource estimates generated by the Resource Estimator will be much larger than what is required to run VQE for these systems.\n",
+        "Please be aware that while you may use the FCIDUMP files included in this sample to generate resource estimates in the [chemistry resource estimation sample](https://github.com/microsoft/azure-quantum-python/blob/main/samples/resource-estimator/estimation-chemistry.ipynb), the samples provided here are for very small systems that we can simulate using VQE optimized for quantum hardware today. As the current QPE + qubitization implementation is optimized for large-scale fault-tolerant quantum hardware, the quantum resource estimates generated by the Resource Estimator will be much larger than what is required to run VQE for these systems.\n",
         "\n",
         "The FCIDUMP sample files provided in the chemistry end-to-end sample are too large to run using VQE on today's quantum systems, so they will not work in this VQE notebook."
       ]