amazon-braket-algorithm-library 1.7.3__tar.gz → 1.7.4__tar.gz

{amazon_braket_algorithm_library-1.7.3/src/amazon_braket_algorithm_library.egg-info → amazon_braket_algorithm_library-1.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-braket-algorithm-library
-Version: 1.7.3
+Version: 1.7.4
 Summary: An open source library of quantum computing algorithms implemented on Amazon Braket
 Home-page: https://github.com/amazon-braket/amazon-braket-algorithm-library
 Author: Amazon Web Services
@@ -70,6 +70,7 @@ Running notebooks locally requires additional dependencies located in [notebooks
 | Quantum Circuit Born Machine | [Quantum_Circuit_Born_Machine.ipynb](notebooks/textbook/Quantum_Circuit_Born_Machine.ipynb) | [Benedetti2019](https://www.nature.com/articles/s41534-019-0157-8),  [Liu2018](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.062324) | 
 | QFT | [Quantum_Fourier_Transform.ipynb](notebooks/textbook/Quantum_Fourier_Transform.ipynb) | [Coppersmith2002](https://arxiv.org/abs/quant-ph/0201067) | 
 | QPE | [Quantum_Phase_Estimation_Algorithm.ipynb](notebooks/textbook/Quantum_Phase_Estimation_Algorithm.ipynb) | [Kitaev1995](https://arxiv.org/abs/quant-ph/9511026) |
+| Quantum Counting | [Quantum_Counting_Algorithm.ipynb](notebooks/textbook/Quantum_Counting_Algorithm.ipynb) | [Brassard1998](https://arxiv.org/abs/quant-ph/9805082) |
 | Quantum Walk | [Quantum_Walk.ipynb](notebooks/textbook/Quantum_Walk.ipynb) | [Childs2002](https://arxiv.org/abs/quant-ph/0209131) |
 |Shor's| [Shors_Algorithm.ipynb](notebooks/textbook/Shors_Algorithm.ipynb) | [Shor1998](https://arxiv.org/abs/quant-ph/9508027) |
 | Simon's | [Simons_Algorithm.ipynb](notebooks/textbook/Simons_Algorithm.ipynb) | [Simon1997](https://epubs.siam.org/doi/10.1137/S0097539796298637) |

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4}/README.md

@@ -22,6 +22,7 @@ Running notebooks locally requires additional dependencies located in [notebooks
 | Quantum Circuit Born Machine | [Quantum_Circuit_Born_Machine.ipynb](notebooks/textbook/Quantum_Circuit_Born_Machine.ipynb) | [Benedetti2019](https://www.nature.com/articles/s41534-019-0157-8),  [Liu2018](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.062324) | 
 | QFT | [Quantum_Fourier_Transform.ipynb](notebooks/textbook/Quantum_Fourier_Transform.ipynb) | [Coppersmith2002](https://arxiv.org/abs/quant-ph/0201067) | 
 | QPE | [Quantum_Phase_Estimation_Algorithm.ipynb](notebooks/textbook/Quantum_Phase_Estimation_Algorithm.ipynb) | [Kitaev1995](https://arxiv.org/abs/quant-ph/9511026) |
+| Quantum Counting | [Quantum_Counting_Algorithm.ipynb](notebooks/textbook/Quantum_Counting_Algorithm.ipynb) | [Brassard1998](https://arxiv.org/abs/quant-ph/9805082) |
 | Quantum Walk | [Quantum_Walk.ipynb](notebooks/textbook/Quantum_Walk.ipynb) | [Childs2002](https://arxiv.org/abs/quant-ph/0209131) |
 |Shor's| [Shors_Algorithm.ipynb](notebooks/textbook/Shors_Algorithm.ipynb) | [Shor1998](https://arxiv.org/abs/quant-ph/9508027) |
 | Simon's | [Simons_Algorithm.ipynb](notebooks/textbook/Simons_Algorithm.ipynb) | [Simon1997](https://epubs.siam.org/doi/10.1137/S0097539796298637) |

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4/src/amazon_braket_algorithm_library.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amazon-braket-algorithm-library
-Version: 1.7.3
+Version: 1.7.4
 Summary: An open source library of quantum computing algorithms implemented on Amazon Braket
 Home-page: https://github.com/amazon-braket/amazon-braket-algorithm-library
 Author: Amazon Web Services
@@ -70,6 +70,7 @@ Running notebooks locally requires additional dependencies located in [notebooks
 | Quantum Circuit Born Machine | [Quantum_Circuit_Born_Machine.ipynb](notebooks/textbook/Quantum_Circuit_Born_Machine.ipynb) | [Benedetti2019](https://www.nature.com/articles/s41534-019-0157-8),  [Liu2018](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.062324) | 
 | QFT | [Quantum_Fourier_Transform.ipynb](notebooks/textbook/Quantum_Fourier_Transform.ipynb) | [Coppersmith2002](https://arxiv.org/abs/quant-ph/0201067) | 
 | QPE | [Quantum_Phase_Estimation_Algorithm.ipynb](notebooks/textbook/Quantum_Phase_Estimation_Algorithm.ipynb) | [Kitaev1995](https://arxiv.org/abs/quant-ph/9511026) |
+| Quantum Counting | [Quantum_Counting_Algorithm.ipynb](notebooks/textbook/Quantum_Counting_Algorithm.ipynb) | [Brassard1998](https://arxiv.org/abs/quant-ph/9805082) |
 | Quantum Walk | [Quantum_Walk.ipynb](notebooks/textbook/Quantum_Walk.ipynb) | [Childs2002](https://arxiv.org/abs/quant-ph/0209131) |
 |Shor's| [Shors_Algorithm.ipynb](notebooks/textbook/Shors_Algorithm.ipynb) | [Shor1998](https://arxiv.org/abs/quant-ph/9508027) |
 | Simon's | [Simons_Algorithm.ipynb](notebooks/textbook/Simons_Algorithm.ipynb) | [Simon1997](https://epubs.siam.org/doi/10.1137/S0097539796298637) |

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4}/src/amazon_braket_algorithm_library.egg-info/SOURCES.txt

@@ -32,6 +32,8 @@ src/braket/experimental/algorithms/quantum_approximate_optimization/__init__.py
 src/braket/experimental/algorithms/quantum_approximate_optimization/quantum_approximate_optimization.py
 src/braket/experimental/algorithms/quantum_circuit_born_machine/__init__.py
 src/braket/experimental/algorithms/quantum_circuit_born_machine/qcbm.py
+src/braket/experimental/algorithms/quantum_counting/__init__.py
+src/braket/experimental/algorithms/quantum_counting/quantum_counting.py
 src/braket/experimental/algorithms/quantum_fourier_transform/__init__.py
 src/braket/experimental/algorithms/quantum_fourier_transform/quantum_fourier_transform.py
 src/braket/experimental/algorithms/quantum_phase_estimation/__init__.py

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4}/src/braket/_algos/_version.py

@@ -16,4 +16,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "1.7.3"
+__version__ = "1.7.4"

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4}/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator.py

@@ -33,7 +33,7 @@ def commute(a: str, b: str, qwc: bool = True) -> bool:
     Raises:
         ValueError: If the Pauli strigns are of different length.
     """
-    if len(a)!=len(b):
+    if len(a) != len(b):
         raise ValueError("Pauli strings must be of the same length.")
     count = 0
     for i in zip(a, b):
@@ -42,15 +42,17 @@ def commute(a: str, b: str, qwc: bool = True) -> bool:
 
 
 # Partial functions for specific commutation checks
-qwc_commute = partial(commute, qwc=True)   # Qubit-wise commutation
-gen_commute = partial(commute, qwc=False)   # General commutation
+qwc_commute = partial(commute, qwc=True)  # Qubit-wise commutation
+gen_commute = partial(commute, qwc=False)  # General commutation
 
 # BAYESIAN STATISTICS (closed formulas from Appendix B of arXiv:2110.15339v6)
 
 
-def term_variance_estimate(term_idx: int, measurements: Union[MeasurementData, None] = None) -> float:
+def term_variance_estimate(
+    term_idx: int, measurements: Union[MeasurementData, None] = None
+) -> float:
     """
-    Estimate variance for a single Pauli term. 
+    Estimate variance for a single Pauli term.
     See Eq 14 in Appendix B of "Adaptive Estimation of Quantum Observables (arXiv:2110.15339v6)
 
     Args:
@@ -64,10 +66,12 @@ def term_variance_estimate(term_idx: int, measurements: Union[MeasurementData, N
     if measurements:
         x0 = measurements[term_idx][term_idx][(1, 1)]
         x1 = measurements[term_idx][term_idx][(-1, -1)]
-    return 4*((x0+1)*(x1+1))/((x0+x1+2)*(x0+x1+3))
+    return 4 * ((x0 + 1) * (x1 + 1)) / ((x0 + x1 + 2) * (x0 + x1 + 3))
 
 
-def terms_covariance_estimate(i: int, j: int, measurements: Union[MeasurementData, None] = None) -> float:
+def terms_covariance_estimate(
+    i: int, j: int, measurements: Union[MeasurementData, None] = None
+) -> float:
     """
     Estimate covariance between two Pauli terms.
     See Eq 25-6 in Appendix B of "Adaptive Estimation of Quantum Observables (arXiv:2110.15339v6)
@@ -93,14 +97,17 @@ def terms_covariance_estimate(i: int, j: int, measurements: Union[MeasurementDat
         xy11 = measurements[i][j][(-1, -1)]
 
     # Calculate prior probabilities
-    p00 = 4*((x0+1)*(y0+1))/((x0+x1+2)*(y0+y1+2))
-    p01 = 4*((x0+1)*(y1+1))/((x0+x1+2)*(y0+y1+2))
-    p10 = 4*((x1+1)*(y0+1))/((x0+x1+2)*(y0+y1+2))
-    p11 = 4*((x1+1)*(y1+1))/((x0+x1+2)*(y0+y1+2))
+    p00 = 4 * ((x0 + 1) * (y0 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2))
+    p01 = 4 * ((x0 + 1) * (y1 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2))
+    p10 = 4 * ((x1 + 1) * (y0 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2))
+    p11 = 4 * ((x1 + 1) * (y1 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2))
 
     # Return Bayesian covariance estimate
-    return 4*((xy00+p00)*(xy11+p11) - (xy01+p01)*(xy10+p10)) / \
-        ((xy00+xy01+xy10+xy11+4)*(xy00+xy01+xy10+xy11+5))
+    return (
+        4
+        * ((xy00 + p00) * (xy11 + p11) - (xy01 + p01) * (xy10 + p10))
+        / ((xy00 + xy01 + xy10 + xy11 + 4) * (xy00 + xy01 + xy10 + xy11 + 5))
+    )
 
 
 class AdaptiveShotAllocator:
@@ -156,11 +163,10 @@ class AdaptiveShotAllocator:
             raise ValueError("Number of Paulis must match coefficients")
 
         # Validate Pauli strings
-        valid_chars = set('IXYZ')
+        valid_chars = set("IXYZ")
         for pauli in paulis:
             if not set(pauli).issubset(valid_chars):
-                raise ValueError(
-                    f"Invalid Pauli string: {pauli}. Must only contain I, X, Y, or Z")
+                raise ValueError(f"Invalid Pauli string: {pauli}. Must only contain I, X, Y, or Z")
         self.paulis = paulis
         self.coeffs = coeffs
         self.graph = self._generate_graph()
@@ -179,9 +185,10 @@ class AdaptiveShotAllocator:
         - Updates graph weights to initial values
         """
         # Initialize measurement counts for all term pairs
-        self.measurements = [[{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}
-                              for _ in range(self.num_terms)]
-                             for _ in range(self.num_terms)]
+        self.measurements = [
+            [{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} for _ in range(self.num_terms)]
+            for _ in range(self.num_terms)
+        ]
         self.shots = None  # Clear shot allocation history
         self._update_graph_weights()  # Reset graph weights
 
@@ -201,7 +208,9 @@ class AdaptiveShotAllocator:
             Edges are added between terms that commute according to the provided function.
         """
         if commute != qwc_commute:
-            warnings.warn("Braket only supports simultaneous measurement of qubit-wise commuting operators.")
+            warnings.warn(
+                "Braket only supports simultaneous measurement of qubit-wise commuting operators."
+            )
 
         # Create graph and add nodes with Pauli string labels
         self.graph = nx.Graph()
@@ -229,8 +238,9 @@ class AdaptiveShotAllocator:
         _, cliq = approximation.clique_removal(self.graph)
         self.cliq = [sorted(i) for i in cliq]  # Sort cliques for consistency
 
-    def visualize_graph(self, node_size: int = 1230, font_size: int = 10,
-                        show_cliques: bool = True) -> None:
+    def visualize_graph(
+        self, node_size: int = 1230, font_size: int = 10, show_cliques: bool = True
+    ) -> None:
         """
         Visualize the graph with colored edges based on clique membership.
 
@@ -242,15 +252,17 @@ class AdaptiveShotAllocator:
         """
 
         # Generate random colors for each clique
-        cliq_colors = ["#"+"".join([hex(random.randint(0, 255))[2:].zfill(2)
-                                   for _ in range(3)]) for _ in self.cliq]
+        cliq_colors = [
+            "#" + "".join([hex(random.randint(0, 255))[2:].zfill(2) for _ in range(3)])
+            for _ in self.cliq
+        ]
 
         # Build edge list and colors
         if show_cliques:
             el = []
             ec = []
             for e in self.graph.edges:
-                for i,c in enumerate(self.cliq):
+                for i, c in enumerate(self.cliq):
                     if (e[0] in c) and (e[1] in c):
                         el.append(e)
                         ec.append(cliq_colors[i])
@@ -258,23 +270,32 @@ class AdaptiveShotAllocator:
         else:
             el = list(self.graph.edges)
             # Use gray for all edges when showing full graph
-            ec = ['gray' for _ in el]
+            ec = ["gray" for _ in el]
 
         # Create layout
         pos = nx.circular_layout(self.graph)
 
         # Draw the graph
         plt.figure(figsize=(10, 10))
-        nx.draw(self.graph, pos=pos, with_labels=False,
-                node_color='white', node_size=node_size,
-                edgelist=el, edge_color=ec)
+        nx.draw(
+            self.graph,
+            pos=pos,
+            with_labels=False,
+            node_color="white",
+            node_size=node_size,
+            edgelist=el,
+            edge_color=ec,
+        )
 
         # Add labels
-        nx.draw_networkx_labels(self.graph, pos,
-                                labels=nx.get_node_attributes(
-                                    self.graph, 'label'),
-                                font_size=font_size, font_color="black",
-                                font_family="Times")
+        nx.draw_networkx_labels(
+            self.graph,
+            pos,
+            labels=nx.get_node_attributes(self.graph, "label"),
+            font_size=font_size,
+            font_color="black",
+            font_family="Times",
+        )
 
         # Set edge colors
         ax = plt.gca()
@@ -299,9 +320,12 @@ class AdaptiveShotAllocator:
             # Base weight from coefficients
             weight = self.coeffs[i] * self.coeffs[j]
             # Multiply by variance/covariance estimate
-            weight *= (term_variance_estimate(i, measurements) if i == j
-                       else terms_covariance_estimate(i, j, measurements))
-            self.graph[i][j]['weight'] = weight
+            weight *= (
+                term_variance_estimate(i, measurements)
+                if i == j
+                else terms_covariance_estimate(i, j, measurements)
+            )
+            self.graph[i][j]["weight"] = weight
 
     def incremental_shot_allocation(self, num_shots: int) -> List[int]:
         """
@@ -337,13 +361,14 @@ class AdaptiveShotAllocator:
         current_shots = self.shots if self.shots else [0 for c in self.cliq]
 
         # Calculate weighted covariance matrix for error estimates
-        weighted_covariance = nx.adjacency_matrix(
-            self.graph, weight="weight").toarray()
+        weighted_covariance = nx.adjacency_matrix(self.graph, weight="weight").toarray()
 
         # Initialize error estimates for each clique using current shots
         # Error = sqrt(sum of covariances) / number of shots
-        clique_error = [np.sqrt(weighted_covariance[c, c].sum())/(current_shots[e] or not current_shots[e])
-                        for e, c in enumerate(self.cliq)]
+        clique_error = [
+            np.sqrt(weighted_covariance[c, c].sum()) / (current_shots[e] or not current_shots[e])
+            for e, c in enumerate(self.cliq)
+        ]
 
         # Allocate shots one at a time
         for _ in range(num_shots):
@@ -356,8 +381,7 @@ class AdaptiveShotAllocator:
             # Update error estimate for the chosen clique
             # New error = Old error * (n/(n+1)) where n+1 is the updated shot count.
             total_shots = current_shots[cliq_id] + proposed_allocation[cliq_id]
-            clique_error[cliq_id] *= ((total_shots-1)
-                                      or not (total_shots-1))/(total_shots)
+            clique_error[cliq_id] *= ((total_shots - 1) or not (total_shots - 1)) / (total_shots)
 
         return proposed_allocation
 
@@ -379,18 +403,23 @@ class AdaptiveShotAllocator:
             ValueError: If graph weights have not been properly initialized
         """
         # Get weighted covariance matrix
-        weighted_covariance = nx.adjacency_matrix(
-            self.graph, weight="weight").toarray()
+        weighted_covariance = nx.adjacency_matrix(self.graph, weight="weight").toarray()
 
         # Sum variance contributions from each clique
-        variance_estimate = sum([(weighted_covariance[c, c].sum())/(self.shots[e] or not self.shots[e])
-                                 for e, c in enumerate(self.cliq)])
+        variance_estimate = sum(
+            [
+                (weighted_covariance[c, c].sum()) / (self.shots[e] or not self.shots[e])
+                for e, c in enumerate(self.cliq)
+            ]
+        )
 
         return np.sqrt(variance_estimate)
 
-    def expectation_from_measurements(self, measurements: Union[MeasurementData, None] = None) -> float:
+    def expectation_from_measurements(
+        self, measurements: Union[MeasurementData, None] = None
+    ) -> float:
         """
-        Calculate the energy expectation value from measurement results 
+        Calculate the energy expectation value from measurement results
         for the different Pauli string observables.
 
         For each Pauli term, computes <P> = (N++ - N--)/N_total where:
@@ -414,17 +443,15 @@ class AdaptiveShotAllocator:
         expectation = 0.0
         for i in range(len(self.coeffs)):
             # Verify no invalid measurements
-            assert measurements[i][i][(
-                1, -1)] == 0, "Invalid measurement detected: (+1,-1)"
-            assert measurements[i][i][(-1, 1)
-                                      ] == 0, "Invalid measurement detected: (-1,+1)"
+            assert measurements[i][i][(1, -1)] == 0, "Invalid measurement detected: (+1,-1)"
+            assert measurements[i][i][(-1, 1)] == 0, "Invalid measurement detected: (-1,+1)"
 
             # Calculate expectation for this term
-            term_shots = measurements[i][i][(
-                1, 1)] + measurements[i][i][(-1, -1)]
+            term_shots = measurements[i][i][(1, 1)] + measurements[i][i][(-1, -1)]
             if term_shots:
                 term_expect = (
-                    measurements[i][i][(1, 1)] - measurements[i][i][(-1, -1)]) / term_shots
+                    measurements[i][i][(1, 1)] - measurements[i][i][(-1, -1)]
+                ) / term_shots
                 expectation += self.coeffs[i] * term_expect
 
         return expectation
@@ -447,13 +474,11 @@ class AdaptiveShotAllocator:
         Raises:
             AssertionError: If any validation check fails
         """
-        assert len(
-            measurements) == self.num_terms, "Wrong number of measurement records"
+        assert len(measurements) == self.num_terms, "Wrong number of measurement records"
 
         for c in self.cliq:
             # Get total shots for this clique
-            m_cliq = (measurements[c[0]][c[0]][(1, 1)] +
-                      measurements[c[0]][c[0]][(-1, -1)])
+            m_cliq = measurements[c[0]][c[0]][(1, 1)] + measurements[c[0]][c[0]][(-1, -1)]
 
             # Check consistency within clique
             for i in c:
@@ -463,25 +488,31 @@ class AdaptiveShotAllocator:
                         assert v >= 0, "Measurement counts should not be negative"
 
                     # Measurements should be symmetric
-                    assert measurements[i][j][(1,1)]==measurements[j][i][(1,1)],\
-                         "Measurement should be symmetric"
-                    assert measurements[i][j][(-1,-1)]==measurements[j][i][(-1,-1)],\
-                         "Measurement should be symmetric"
-                    assert measurements[i][j][(1,-1)]==measurements[j][i][(-1,1)],\
-                         "Measurement should be symmetric"
-                    assert measurements[i][j][(-1,1)]==measurements[j][i][(1,-1)],\
-                         "Measurement should be symmetric"
+                    assert measurements[i][j][(1, 1)] == measurements[j][i][(1, 1)], (
+                        "Measurement should be symmetric"
+                    )
+                    assert measurements[i][j][(-1, -1)] == measurements[j][i][(-1, -1)], (
+                        "Measurement should be symmetric"
+                    )
+                    assert measurements[i][j][(1, -1)] == measurements[j][i][(-1, 1)], (
+                        "Measurement should be symmetric"
+                    )
+                    assert measurements[i][j][(-1, 1)] == measurements[j][i][(1, -1)], (
+                        "Measurement should be symmetric"
+                    )
 
                     # All pairs in clique should have same total measurements
-                    assert m_cliq == sum(measurements[i][j].values()), \
-                        (f"The number of times {i} and {j} were measured together should be "
-                         "equal to the number of measurements of their clique.")
+                    assert m_cliq == sum(measurements[i][j].values()), (
+                        f"The number of times {i} and {j} were measured together should be "
+                        "equal to the number of measurements of their clique."
+                    )
 
                     # Diagonal elements should not have invalid combinations
                     if i == j:
-                        assert measurements[i][i][(1, -1)] == measurements[i][i][(-1, 1)] == 0, \
-                            ("A measurement of a single term can only contribute to the "
-                            "(1,1) or (-1,-1) counts.")
+                        assert measurements[i][i][(1, -1)] == measurements[i][i][(-1, 1)] == 0, (
+                            "A measurement of a single term can only contribute to the "
+                            "(1,1) or (-1,-1) counts."
+                        )
         return True
 
     def shots_from_measurements(self, measurements: MeasurementData) -> List[int]:

{amazon_braket_algorithm_library-1.7.3 → amazon_braket_algorithm_library-1.7.4}/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator_braket_helpers.py

@@ -1,5 +1,5 @@
 """
-Helper functions to handle quantum measurements and adaptive shot allocation 
+Helper functions to handle quantum measurements and adaptive shot allocation
 experiments on Amazon Braket.
 """
 
@@ -13,6 +13,7 @@ from braket.experimental.algorithms.adaptive_shot_allocation.adaptive_allocator
     MeasurementData,
 )
 
+
 def observable_from_string(pauli_string: str) -> Observable:
     """
     Convert Pauli string to Braket observable.
@@ -23,15 +24,15 @@ def observable_from_string(pauli_string: str) -> Observable:
     Returns:
         Observable: Corresponding Braket observable
     """
-    gates = {"I": Observable.I, "X": Observable.X,
-             "Y": Observable.Y, "Z": Observable.Z}
+    gates = {"I": Observable.I, "X": Observable.X, "Y": Observable.Y, "Z": Observable.Z}
     return Observable.TensorProduct([gates[i[1]](i[0]) for i in enumerate(pauli_string)])
 
+
 def run_fixed_allocation(
     device: Union[LocalSimulator, AwsDevice],
     circuit: Circuit,
     estimator: AdaptiveShotAllocator,
-    shot_allocation: List[int]
+    shot_allocation: List[int],
 ) -> MeasurementData:
     """
     Run experiment with a specific shot allocation.
@@ -45,7 +46,7 @@ def run_fixed_allocation(
     Returns:
         MeasurementData: Measurement outcomes for each term pair
     """
-    
+
     # Step 1. Submit all tasks.
     tasks = {}
     for c_idx, c in enumerate(estimator.cliq):
@@ -54,41 +55,40 @@ def run_fixed_allocation(
 
         measurement_circ = circuit.copy()
         for p in c:
-            measurement_circ.sample(
-                observable_from_string(estimator.paulis[p]))
+            measurement_circ.sample(observable_from_string(estimator.paulis[p]))
+
+        tasks[c_idx] = device.run(measurement_circ, shots=shot_allocation[c_idx])
 
-        tasks[c_idx] = device.run(
-            measurement_circ, shots=shot_allocation[c_idx])
-        
     # Step 2. Post-process results.
-    measurements = [[{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}
-                for _ in range(len(estimator.paulis))]
-                for _ in range(len(estimator.paulis))]
-        
-    while(tasks):
+    measurements = [
+        [{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} for _ in range(len(estimator.paulis))]
+        for _ in range(len(estimator.paulis))
+    ]
+
+    while tasks:
         task_to_process = None
-        
+
         for c_idx in tasks:
             # Check task status
             state = tasks[c_idx].state()
-            assert state in ["CREATED", "QUEUED", "RUNNING", "COMPLETED"], \
+            assert state in ["CREATED", "QUEUED", "RUNNING", "COMPLETED"], (
                 f"Encountered quantum task failure (status: {state})."
+            )
 
             if state == "COMPLETED":
                 task_to_process = c_idx
                 break
-        
+
         if task_to_process is None:
             continue
-            
+
         # Task is ready for post-processing
         result = tasks[task_to_process].result()
         c = estimator.cliq[task_to_process]
         for i_idx, i in enumerate(c):
             for j_idx, j in enumerate(c):
                 for s in range(len(result.values[i_idx])):
-                    measurements[i][j][(result.values[i_idx][s],
-                                        result.values[j_idx][s])] += 1
+                    measurements[i][j][(result.values[i_idx][s], result.values[j_idx][s])] += 1
         # Remove task from the queue
         tasks.pop(task_to_process)
 
@@ -101,7 +101,7 @@ def run_adaptive_allocation(
     estimator: AdaptiveShotAllocator,
     shots_per_round: int,
     num_rounds: int,
-    verbose: bool = False
+    verbose: bool = False,
 ) -> MeasurementData:
     """
     Run adaptive shot allocation process.
@@ -118,14 +118,12 @@ def run_adaptive_allocation(
         MeasurementData: Final measurement outcomes
     """
     if verbose:
-        print(
-            f"Running {num_rounds} rounds with {shots_per_round} shots each:")
+        print(f"Running {num_rounds} rounds with {shots_per_round} shots each:")
     for i in range(num_rounds):
         if verbose:
-            print(f"Round {i+1}/{num_rounds}...")
+            print(f"Round {i + 1}/{num_rounds}...")
         shots_to_run = estimator.incremental_shot_allocation(shots_per_round)
-        new_measurements = run_fixed_allocation(
-            device, circuit, estimator, shots_to_run)
+        new_measurements = run_fixed_allocation(device, circuit, estimator, shots_to_run)
         estimator.update_measurements(new_measurements)
 
     return estimator.measurements

amazon_braket_algorithm_library-1.7.4/src/braket/experimental/algorithms/quantum_counting/__init__.py

@@ -0,0 +1,20 @@
+# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+from braket.experimental.algorithms.quantum_counting.quantum_counting import (  # noqa: F401, E501
+    build_grover_circuit,
+    build_oracle_circuit,
+    get_quantum_counting_results,
+    quantum_counting_circuit,
+    run_quantum_counting,
+)

amazon_braket_algorithm_library-1.7.4/src/braket/experimental/algorithms/quantum_counting/quantum_counting.py

@@ -0,0 +1,483 @@
+"""Quantum Counting Algorithm implementation using the Amazon Braket SDK.
+
+The quantum counting algorithm combines Grover's search operator with Quantum
+Phase Estimation (QPE) to count the number of marked items in an unstructured
+search space of N = 2^n elements.
+
+Reference:
+    G. Brassard, P. Høyer, and A. Tapp, "Quantum Counting",
+    Proceedings of ICALP 1998. arXiv:quant-ph/9805082
+"""
+
+import math
+from typing import Any, Dict, List, Tuple
+
+import numpy as np
+
+from braket.circuits import Circuit
+from braket.circuits.qubit_set import QubitSetInput
+from braket.devices import Device
+from braket.experimental.algorithms.grovers_search.grovers_search import amplify, build_oracle
+from braket.tasks import QuantumTask
+
+
+def build_oracle_circuit(
+    n_qubits: int,
+    marked_states: List[int],
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build an oracle circuit that flips the phase of marked states.
+
+    Composes individual oracle circuits from grovers_search.build_oracle
+    for each marked state. Each call flips the phase of one basis state,
+    and their composition marks all specified states.
+
+    Args:
+        n_qubits (int): Number of qubits in the search register.
+        marked_states (List[int]): Indices of marked computational-basis states.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Oracle circuit that flips the phase of all marked states.
+
+    Raises:
+        ValueError: If a marked state index is out of range.
+    """
+    dim = 2**n_qubits
+    for state in marked_states:
+        if state < 0 or state >= dim:
+            raise ValueError(
+                f"Marked state {state} is out of range for {n_qubits} qubits "
+                f"(must be in [0, {dim - 1}])."
+            )
+
+    oracle_circ = Circuit()
+    for state in marked_states:
+        bitstring = format(state, f"0{n_qubits}b")
+        oracle_circ.add_circuit(build_oracle(bitstring, decompose_ccnot))
+    return oracle_circ
+
+
+def build_grover_circuit(
+    n_qubits: int,
+    marked_states: List[int],
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build the Grover operator G = D · O as a circuit.
+
+    Uses circuit primitives from grovers_search: build_oracle for the phase
+    oracle and amplify for the diffusion operator (H · oracle_0 · H).
+
+    Args:
+        n_qubits (int): Number of qubits in the search register.
+        marked_states (List[int]): Indices of marked states.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Circuit implementing the Grover operator G.
+    """
+    oracle_circ = build_oracle_circuit(n_qubits, marked_states, decompose_ccnot)
+    diffusion_circ = amplify(n_qubits, decompose_ccnot)
+
+    grover_circ = Circuit()
+    grover_circ.add_circuit(oracle_circ)
+    grover_circ.add_circuit(diffusion_circ)
+    return grover_circ
+
+
+def _controlled_oracle_circuit(
+    control: int,
+    search_qubits: QubitSetInput,
+    marked_states: List[int],
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build a controlled oracle circuit using gate-level primitives.
+
+    Makes the phase-flip oracle controlled on the given qubit by prepending
+    "1" to each marked-state bitstring, so the MCZ gate gains an extra
+    control qubit.
+
+    Args:
+        control (int): Index of the control qubit.
+        search_qubits (QubitSetInput): Indices of the search register qubits.
+        marked_states (List[int]): Indices of marked computational-basis states.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Controlled oracle circuit.
+    """
+    n_search = len(search_qubits)
+    circ = Circuit()
+
+    for state in marked_states:
+        bitstring = format(state, f"0{n_search}b")
+        # Prepend "1" so the MCZ is controlled on the QPE qubit
+        controlled_bitstring = "1" + bitstring
+        oracle_sub = build_oracle(controlled_bitstring, decompose_ccnot)
+        # Map the oracle qubits: qubit 0 -> control, qubits 1..n -> search_qubits
+        target_mapping = [control] + list(search_qubits)
+        # The oracle may use ancilla qubits beyond n_search+1; they are
+        # automatically placed by add_circuit's target mapping.
+        all_targets = target_mapping + list(
+            range(
+                max(target_mapping) + 1,
+                max(target_mapping) + 1 + oracle_sub.qubit_count - len(target_mapping),
+            )
+        )
+        circ.add_circuit(oracle_sub, target=all_targets)
+
+    return circ
+
+
+def _controlled_diffusion_circuit(
+    control: int,
+    search_qubits: QubitSetInput,
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build a controlled diffusion (amplitude amplification) circuit.
+
+    The diffusion operator is D = H^⊗n · O_0 · H^⊗n, where O_0 flips the
+    phase of the |0⟩ state. To make it controlled:
+      - H gates become controlled-H (CH) gates
+      - O_0 becomes controlled by prepending "1" to the "00...0" bitstring
+
+    Args:
+        control (int): Index of the control qubit.
+        search_qubits (QubitSetInput): Indices of the search register qubits.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Controlled diffusion circuit.
+    """
+    n_search = len(search_qubits)
+    circ = Circuit()
+
+    # First set of controlled-H gates on search qubits
+    for sq in search_qubits:
+        _add_controlled_h(circ, control, sq)
+
+    # Controlled O_0: flip phase of |0⟩, controlled on QPE qubit
+    # O_0 uses build_oracle("00...0"). Controlled version: build_oracle("1" + "00...0")
+    controlled_zero_bitstring = "1" + "0" * n_search
+    zero_oracle = build_oracle(controlled_zero_bitstring, decompose_ccnot)
+    target_mapping = [control] + list(search_qubits)
+    all_targets = target_mapping + list(
+        range(
+            max(target_mapping) + 1,
+            max(target_mapping) + 1 + zero_oracle.qubit_count - len(target_mapping),
+        )
+    )
+    circ.add_circuit(zero_oracle, target=all_targets)
+
+    # Second set of controlled-H gates on search qubits
+    for sq in search_qubits:
+        _add_controlled_h(circ, control, sq)
+
+    # Apply Z gate to correct the -1 global phase difference between
+    # I - 2|s><s| and 2|s><s| - I when controlled.
+    circ.z(control)
+
+    return circ
+
+
+def _add_controlled_h(circ: Circuit, control: int, target: int) -> None:
+    """Add a controlled-Hadamard gate to the circuit.
+
+    Decomposition: CH(c, t) = S†(t) · H(t) · T†(t) · CX(c,t) · T(t) · H(t) · S(t)
+
+    Args:
+        circ (Circuit): Circuit to append the controlled-H to.
+        control (int): Control qubit index.
+        target (int): Target qubit index.
+    """
+    circ.s(target)
+    circ.h(target)
+    circ.t(target)
+    circ.cnot(control, target)
+    circ.ti(target)
+    circ.h(target)
+    circ.si(target)
+
+
+def controlled_grover_circuit(
+    control: int,
+    search_qubits: QubitSetInput,
+    marked_states: List[int],
+    power: int = 1,
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build a controlled Grover operator G^power as a gate-level circuit.
+
+    Constructs the controlled Grover operator C-G = C-D · C-O entirely from
+    gate-level primitives:
+      - The oracle is made controlled by prepending "1" to each marked-state
+        bitstring, adding the control qubit as an extra MCZ control.
+      - The diffusion operator is made controlled by using controlled-H (CH)
+        gates, a controlled zero-oracle, and a Z gate on the control qubit
+        to correct the inherent -1 global phase of the diffusion operator.
+
+    Args:
+        control (int): Index of the QPE control qubit.
+        search_qubits (QubitSetInput): Indices of the search register qubits.
+        marked_states (List[int]): Indices of marked computational-basis states.
+        power (int): Number of times to apply the Grover operator (default 1).
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Circuit implementing the controlled G^power operator.
+    """
+    circ = Circuit()
+
+    for _ in range(power):
+        # Controlled oracle
+        circ.add_circuit(
+            _controlled_oracle_circuit(control, search_qubits, marked_states, decompose_ccnot)
+        )
+
+        # Controlled diffusion
+        circ.add_circuit(
+            _controlled_diffusion_circuit(control, search_qubits, decompose_ccnot)
+        )
+
+    return circ
+
+
+def inverse_qft_for_counting(qubits: QubitSetInput) -> Circuit:
+    """Inverse Quantum Fourier Transform applied to the given qubits.
+
+    Args:
+        qubits (QubitSetInput): Qubits on which to apply the inverse QFT.
+
+    Returns:
+        Circuit: Circuit implementing the inverse QFT.
+    """
+    qft_circ = Circuit()
+    num_qubits = len(qubits)
+
+    # SWAP gates to reverse qubit order
+    for i in range(math.floor(num_qubits / 2)):
+        qft_circ.swap(qubits[i], qubits[-i - 1])
+
+    # Controlled phase rotations + Hadamard
+    for k in reversed(range(num_qubits)):
+        for j in reversed(range(1, num_qubits - k)):
+            angle = -2 * math.pi / (2 ** (j + 1))
+            qft_circ.cphaseshift(qubits[k + j], qubits[k], angle)
+        qft_circ.h(qubits[k])
+
+    return qft_circ
+
+
+def quantum_counting_circuit(
+    counting_circ: Circuit,
+    counting_qubits: QubitSetInput,
+    search_qubits: QubitSetInput,
+    marked_states: List[int],
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Create the full quantum counting circuit with result types.
+
+    Builds the controlled Grover operator as a gate-level circuit and
+    applies QPE.
+
+    Args:
+        counting_circ (Circuit): Initial circuit (may contain setup operations).
+        counting_qubits (QubitSetInput): Qubits for the counting (precision) register.
+        search_qubits (QubitSetInput): Qubits for the search register.
+        marked_states (List[int]): Indices of marked computational-basis states.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: The complete quantum counting circuit with result types.
+    """
+    new_circuit = Circuit().add_circuit(counting_circ)
+    new_circuit.add_circuit(
+        quantum_counting(
+            counting_qubits, search_qubits, marked_states, decompose_ccnot
+        )
+    )
+    return new_circuit.probability(counting_qubits)
+
+
+def quantum_counting(
+    counting_qubits: QubitSetInput,
+    search_qubits: QubitSetInput,
+    marked_states: List[int],
+    decompose_ccnot: bool = False,
+) -> Circuit:
+    """Build the core quantum counting circuit using QPE on the Grover operator.
+
+    Constructs the controlled Grover operator as a gate-level circuit from
+    grovers_search primitives (build_oracle for the phase oracle and
+    controlled-H gates for the diffusion operator).
+
+    The circuit structure:
+      1. Apply H to all counting qubits
+      2. Apply H to all search qubits (prepare uniform superposition |s⟩)
+      3. Apply controlled-G^(2^k) for each counting qubit k
+      4. Apply inverse QFT to counting qubits
+
+    Args:
+        counting_qubits (QubitSetInput): Qubits for the counting (precision) register.
+        search_qubits (QubitSetInput): Qubits for the search register.
+        marked_states (List[int]): Indices of marked computational-basis states.
+        decompose_ccnot (bool): Whether to decompose CCNOT (Toffoli) gates.
+
+    Returns:
+        Circuit: Circuit implementing the quantum counting algorithm.
+    """
+    qc_circ = Circuit()
+
+    # Hadamard on counting qubits
+    qc_circ.h(counting_qubits)
+
+    # Hadamard on search qubits (prepare |s⟩)
+    qc_circ.h(search_qubits)
+
+    # Controlled-G^(2^k)
+    for ii, qubit in enumerate(reversed(counting_qubits)):
+        power = 2**ii
+        qc_circ.add_circuit(
+            controlled_grover_circuit(
+                qubit, search_qubits, marked_states, power, decompose_ccnot
+            )
+        )
+
+    # Inverse QFT on counting qubits
+    qc_circ.add_circuit(inverse_qft_for_counting(counting_qubits))
+
+    return qc_circ
+
+
+def run_quantum_counting(
+    circuit: Circuit,
+    device: Device,
+    shots: int = 1000,
+) -> QuantumTask:
+    """Run the quantum counting circuit on a device.
+
+    Args:
+        circuit (Circuit): The quantum counting circuit to run.
+        device (Device): Braket device backend.
+        shots (int): Number of measurement shots (default is 1000).
+
+    Returns:
+        QuantumTask: Task from running quantum counting.
+    """
+    task = device.run(circuit, shots=shots)
+    return task
+
+
+def get_quantum_counting_results(
+    task,
+    counting_qubits: QubitSetInput,
+    search_qubits: QubitSetInput,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    """Post-process quantum counting results to estimate the number of marked items.
+
+    After measuring the counting qubits, the most likely outcome y gives
+    an estimate of the phase φ = y / 2^t. The number of marked items M is:
+        M = N · sin²(π · φ)
+    where N = 2^n_search.
+
+    Args:
+        task (QuantumTask): The task holding quantum counting results.
+        counting_qubits (QubitSetInput): Qubits of the counting register.
+        search_qubits (QubitSetInput): Qubits of the search register.
+        verbose (bool): If True, print detailed results (default False).
+
+    Returns:
+        Dict[str, Any]: Aggregate measurement results including:
+            - measurement_counts: raw measurement counts
+            - counting_register_results: counts collapsed to the counting register
+            - phases: estimated phases φ for each measured bitstring
+            - estimated_counts: estimated M for each measured bitstring
+            - best_estimate: best estimate of M (from most frequent outcome)
+            - search_space_size: N = 2^n_search
+    """
+    result = task.result()
+    measurement_counts = result.measurement_counts
+    n_counting = len(counting_qubits)
+    n_search = len(search_qubits)
+    N = 2**n_search
+
+    # Aggregate results on counting register (trace out search qubits)
+    counting_register_results: Dict[str, int] = {}
+    if measurement_counts:
+        for key in measurement_counts.keys():
+            counting_bits = key[:n_counting]
+            counting_register_results[counting_bits] = (
+                counting_register_results.get(counting_bits, 0) + measurement_counts[key]
+            )
+
+    # Convert counting register bitstrings to phase estimates and M estimates
+    phases, estimated_counts = _get_counting_estimates(counting_register_results, n_counting, N)
+
+    # Best estimate from most frequent outcome
+    if counting_register_results:
+        best_key = max(counting_register_results, key=counting_register_results.get)
+        best_y = int(best_key, 2)
+        raw_phase = best_y / (2**n_counting)
+        best_phase = raw_phase
+        best_M = N * (np.sin(np.pi * best_phase) ** 2)
+    else:
+        best_key = None
+        best_M = None
+
+    aggregate_results = {
+        "measurement_counts": measurement_counts,
+        "counting_register_results": counting_register_results,
+        "phases": phases,
+        "estimated_counts": estimated_counts,
+        "best_estimate": best_M,
+        "search_space_size": N,
+    }
+
+    if verbose:
+        print(f"Search space size N = {N}")
+        sorted_cr = sorted(
+            counting_register_results.items(), key=lambda x: x[1], reverse=True
+        )
+        print("\nCounting register distribution (top outcomes):")
+        for bitstring, count in sorted_cr[:6]:
+            y_val = int(bitstring, 2)
+            raw_ph = y_val / (2**n_counting)
+            ph = raw_ph
+            m_est = N * (np.sin(np.pi * ph) ** 2)
+            print(f"  |{bitstring}>: {count} counts  ->  phase = {ph:.4f},  M ~ {m_est:.4f}")
+        if len(sorted_cr) > 6:
+            print(f"  ... ({len(sorted_cr) - 6} more outcomes)")
+        print(f"\nBest estimate of M: {best_M}")
+
+    return aggregate_results
+
+
+def _get_counting_estimates(
+    counting_register_results: Dict[str, int],
+    n_counting: int,
+    N: int,
+) -> Tuple[List[float], List[float]]:
+    """Convert counting register bitstrings to phase and count estimates.
+
+    Args:
+        counting_register_results (Dict[str, int]): Measurement results on the counting register.
+        n_counting (int): Number of counting qubits.
+        N (int): Search space size.
+
+    Returns:
+        Tuple[List[float], List[float]]: (phases, estimated_counts) lists, one entry per unique
+            measured bitstring with counts > 0.
+    """
+    phases = []
+    estimated_counts = []
+
+    for bitstring in counting_register_results:
+        y = int(bitstring, 2)
+        raw_phase = y / (2**n_counting)
+        phase = raw_phase
+        M_est = N * (np.sin(np.pi * phase) ** 2)
+        phases.append(phase)
+        estimated_counts.append(M_est)
+
+    return phases, estimated_counts