Merge pull request #100 from eclipse-qrisp/QAOAQIRO_experiments

Qaoaqiro experiments

Author: positr0nium

documentation/source/general/tutorial/QIROtutorial.rst

@@ -111,7 +111,9 @@ To run the instance and solve the optimization problem we use the :meth:`.run <q
 Maximum independent set example
 ===============================
 
-We now investigate a code example for the maximum independent set problem.
+We now investigate a code example for the maximum independent set problem. The in-depth explanation will focus on the unconnected cost operator implementation displayed. 
+In constrast, our :ref:` general QAOA implementation for the MIS problem  <maxIndepSetQAOA>` is based on a constrained mixer approach. This can also be used for the QIRO implementation, 
+which we show at the end of this tutorial!
 
 Preliminaries
 -------------
@@ -166,10 +168,10 @@ All in all, the function remains straight forward. We employ a ``find_max`` subr
     return new_graph, solutions, sign, exclusions
 
 As you might have noticed in the code above, we add the nodes that are included into (respective excluded from) the solution to a list ``solutions`` (``exclusions``). 
-This allows us to directly :ref:`recycle the QAOA code <maxIndepSetQAOA>` for the  ``cost_operator``, ``mixer`` and ``init_function`` of the original QAOA implementation with minor adjustments.
+This allows us to directly use the same ideas for the  ``cost_operator``, ``mixer`` and ``init_function`` of the original unconstrained QAOA theory with minor adjustments.
 
-Since we have to consider nodes that are already asigned to be in the solution set, or exluded from the algorithm, we do not want to apply these functions to said nodes. 
-We therefore include some simple lines of code into the functions, for example in the ``qiro_RXMixer``:
+Since we have to consider nodes that are already asigned to be in the solution set, or exluded from the algorithm, we do not want to apply ``cost_operator`` or ``mixer`` to said nodes. 
+We therefore include some simple lines of code into the functions to take this into account, for example the ``if not``-statement in the ``qiro_RXMixer``:
 
 ::
 
@@ -182,6 +184,28 @@ We therefore include some simple lines of code into the functions, for example i
                     rx(2 * beta, qv[i])
         return RX_mixer
 
+
+Similarly an ``if not``-statement is included in the cost operator, which is named ``create_max_indep_cost_operator_reduced`` due to it respecting the problem reduction:
+
+::
+
+    def create_max_indep_cost_operator_reduced(problem_updated):
+
+        problem = problem_updated[0]
+        solutions = problem_updated[1]
+        def cost_operator(qv, gamma):
+            for pair in list(problem.edges()):
+                #cx(qv[pair[0]], qv[pair[1]])
+                rzz(3*gamma, qv[pair[0]], qv[pair[1]])
+                rz(-gamma, qv[pair[0]])
+                rz(-gamma, qv[pair[1]])
+            for i in problem.nodes():
+                # DONT apply gates on nodes in the solution set
+                if not i in solutions:
+                    rz(gamma, qv[i])
+
+        return cost_operator
+
 With the preliminaries out of the way, let us jump right into the code example:
 
 
@@ -249,7 +273,6 @@ We can further compare our results to the `NetworkX MIS algorithm <https://netwo
     print("Networkx solution")
     print(nx.approximation.maximum_independent_set(G))
 
-Chances are, you will see a result in the QIRO implementation, that is better than the classical algorithm provided by Networkx!
 
 As a final caveat, we can look at the graph we are left with after all reduction steps.
 
@@ -261,6 +284,29 @@ As a final caveat, we can look at the graph we are left with after all reduction
     plt.title('Final QIRO graph')
     plt.show()
 
+
+Constrained mixer implementation
+--------------------------------
+
+Before we end this tutorial we want to show you what the constrained mixer implementation looks like for the MIS QIRO algorithm. In analogy to our :ref:` general QAOA implementation for the MIS problem  <maxIndepSetQAOA>` 
+we use the :ref:`qiro_rz_mixer <QIRO>` as the mixer and the :ref:`create_max_indep_controlled_mixer_reduced <maxIndependentSetQIRO>` as the cost operator. In principle, these functions do the exact same thing as the general implementations,
+but they respect the solutions and exclusions chosen via the update routine.  We suggest to try this instance with larger graph sizes (more than 20 nodes). 
+
+::
+
+    # assign the correct update functions for constrained qiro 
+    qiro_instance = QIROProblem(G, 
+                                create_max_indep_replacement_routine,
+                                qiro_rz_mixer,
+                                create_max_indep_controlled_mixer_reduced,
+                                create_max_indep_set_cl_cost_function,
+                                qiro_max_indep_set_init_function,
+                                )
+
+    # We run the qiro instance and get the results!
+    res_qiro = qiro_instance.run_qiro(qarg=qarg, depth = 3, n_recursions = 1)
+
+
 Congratulations, you have reached the end of the tutorial and are now capable of solving the MIS problem in Qrisp!
 Should your appetite not be satisfied, we advise you to check out our other QIRO implementations:
 

documentation/source/reference/Algorithms/qiro/QIRO.rst

@@ -36,7 +36,9 @@ Collection of mixers and auxiliary functions
 
 .. autosummary::
 
-   qiro_RXMixer
+   qiro_rx_mixer
+   qiro_rz_mixer
+   qiro_controlled_RX_mixer_gen
    qiro_init_function
    find_max
 

documentation/source/reference/Algorithms/qiro/implementations/QIROMaxClique.rst

@@ -42,7 +42,7 @@ Example implementation
 ::   
 
     from qrisp import QuantumVariable
-    from qrisp.qiro import QIROProblem, create_max_clique_replacement_routine, create_max_clique_cost_operator_reduced, qiro_RXMixer, qiro_init_function
+    from qrisp.qiro import QIROProblem, create_max_clique_replacement_routine, create_max_clique_cost_operator_reduced, qiro_rx_mixer, qiro_init_function
     from qrisp.qaoa import max_clique_problem, create_max_clique_cl_cost_function
     import matplotlib.pyplot as plt
     import networkx as nx
@@ -56,7 +56,7 @@ Example implementation
     qiro_instance = QIROProblem(problem=G,
                                 replacement_routine= reate_max_clique_replacement_routine,
                                 cost_operator=create_max_clique_cost_operator_reduced,
-                                mixer=qiro_RXMixer,
+                                mixer=qiro_rx_mixer,
                                 cl_cost_function=create_max_clique_cl_cost_function,
                                 init_function=qiro_init_function
                                 )

documentation/source/reference/Algorithms/qiro/implementations/QIROMaxIndep.rst

@@ -34,13 +34,23 @@ QIRO Cost operator
 
 .. autofunction:: create_max_indep_cost_operator_reduced
 
+QIRO with Constrained mixer
+---------------------------
+
+.. autofunction:: create_max_indep_controlled_mixer_reduced
+
+.. autofunction:: qiro_max_indep_set_init_function
+
 
 Example implementation
 ----------------------
+
+The implementation below is for the standard unconstrained cost operator implementation. An implementation with a controlled mixer ansatz is shown in the tutorial section.
+
 ::
 
     from qrisp import QuantumVariable
-    from qrisp.qiro import QIROProblem, create_max_indep_replacement_routine, create_max_indep_cost_operator_reduced, qiro_RXMixer, qiro_init_function
+    from qrisp.qiro import QIROProblem, create_max_indep_replacement_routine, create_max_indep_cost_operator_reduced, qiro_rx_mixer, qiro_init_function
     from qrisp.qaoa import create_max_indep_set_cl_cost_function
     import matplotlib.pyplot as plt
     import networkx as nx
@@ -53,7 +63,7 @@ Example implementation
     qiro_instance = QIROProblem(G,
                                 replacement_routine=create_max_indep_replacement_routine,
                                 cost_operator=create_max_indep_cost_operator_reduced,
-                                mixer=qiro_RXMixer,
+                                mixer=qiro_rx_mixer,
                                 cl_cost_function=create_max_indep_set_cl_cost_function,
                                 init_function=qiro_init_function
                                 )

documentation/source/reference/Algorithms/qiro/implementations/QIROMaxSat.rst

@@ -67,7 +67,7 @@ Example implementation
 
     from qrisp import QuantumVariable
     from qrisp.qaoa import create_maxsat_cl_cost_function
-    from qrisp.qiro import QIROProblem, qiro_init_function, qiro_RXMixer, create_maxsat_replacement_routine, create_maxsat_cost_operator_reduced
+    from qrisp.qiro import QIROProblem, qiro_init_function, qiro_rx_mixer, create_maxsat_replacement_routine, create_maxsat_cost_operator_reduced
 
     clauses = [[1,2,-3],[1,4,-6],[4,5,6],[1,3,-4],[2,4,5],[1,3,5],[-2,-3,6],[1,7,8],[3,-7,-8],[3,4,8],[4,5,8],[1,2,7]]
     num_vars = 8
@@ -77,7 +77,7 @@ Example implementation
     qiro_instance = QIROProblem(problem = problem,
                                 replacement_routine = create_maxsat_replacement_routine,
                                 cost_operator = create_maxsat_cost_operator_reduced,
-                                mixer = qiro_RXMixer,
+                                mixer = qiro_rx_mixer,
                                 cl_cost_function = create_maxsat_cl_cost_function,
                                 init_function = qiro_init_function
                                 )

documentation/source/reference/Algorithms/qiro/implementations/QIROMaxSetPack.rst

@@ -27,7 +27,7 @@ Example implementation
 ::
 
     from qrisp import QuantumVariable
-    from qrisp.qiro import QIROProblem, create_max_indep_replacement_routine, create_max_indep_cost_operator_reduced, qiro_RXMixer, qiro_init_function
+    from qrisp.qiro import QIROProblem, create_max_indep_replacement_routine, create_max_indep_cost_operator_reduced, qiro_rx_mixer, qiro_init_function
     from qrisp.qaoa import create_max_indep_set_cl_cost_function
     import matplotlib.pyplot as plt
     import networkx as nx
@@ -41,7 +41,7 @@ Example implementation
     qiro_instance = QIROProblem(G,
                                 replacement_routine=create_max_indep_replacement_routine,
                                 cost_operator=create_max_indep_cost_operator_reduced,
-                                mixer=qiro_RXMixer,
+                                mixer=qiro_rx_mixer,
                                 cl_cost_function=create_max_indep_set_cl_cost_function,
                                 init_function=qiro_init_function
                                 )

src/qrisp/algorithms/qaoa/mixers.py

@@ -343,7 +343,7 @@ def portfolio_mixer():
         mixer_op(qv, np.pi/8)
 
     """
-    from qrisp.misc.dicke_state import dicke_state
+    from qrisp.alg_primitives import dicke_state
 
     def inv_prepare_dicke(qv, k):
         with invert():

src/qrisp/algorithms/qaoa/problems/maxSat.py

@@ -44,6 +44,7 @@ def create_maxsat_cost_polynomials(problem):
     cost_polynomials = []
     for clause in clauses:
         C = 1 - sp.prod((1-symbols[index-1]) if index>0 else symbols[-index-1] for index in clause)
+        
         cost_polynomials.append(C)
 
     return cost_polynomials, symbols

src/qrisp/algorithms/qaoa/qaoa_problem.py

@@ -522,7 +522,6 @@ def run(self, qarg, depth, mes_kwargs = {}, max_iter = 50, init_type = "random",
             self.cost_operator(qarg, optimal_theta[i])
             self.mixer(qarg, optimal_theta[i+depth])
         opt_res = qarg.get_measurement(**mes_kwargs)
-        
         return opt_res
 
     def train_function(self, qarg, depth, mes_kwargs = {}, max_iter = 50, init_type = "random", optimizer="COBYLA"):

src/qrisp/algorithms/qiro/qiro_mixers.py

@@ -17,9 +17,9 @@
 """
 
 
-from qrisp import x, rx
+from qrisp import x, rx, rz, auto_uncompute, control
 
-def qiro_RXMixer(solutions = [],exclusions = []):
+def qiro_rx_mixer(problem_updated):
     """
     RX-Mixer for QIRO algorithm. Works analogously to the normal RX-Mixer, but respects solutions and exclusions that have been found in the QIRO reduction steps.
 
@@ -36,14 +36,106 @@ def qiro_RXMixer(solutions = [],exclusions = []):
         The RX-mixer, according to the update steps that have been undertaken
 
     """
+
+    solutions = problem_updated[1]
+    exclusions =  problem_updated[2]
     union = solutions + exclusions
+
     def RX_mixer(qv, beta):
 
         for i in range(len(qv)):
             if not i in union:
                 rx(2 * beta, qv[i])
     return RX_mixer
 
+def qiro_rz_mixer(problem_updated):
+    """
+    This function applies an RZ gate with a negative phase shift to a given quantum variable.
+
+    Parameters
+    ----------
+    qv : QuantumVariable
+        The quantum variable to which the RZ gate is applied.
+    beta : float or sympy.Symbol
+        The phase shift value for the RZ gate.
+
+    """
+
+    solutions = problem_updated[1]
+    exclusions =  problem_updated[2]
+    union = solutions + exclusions
+
+    def RZ_mixer(qv, beta):
+
+        for i in range(len(qv)):
+            if not i in union:
+                rz(2 * beta, qv[i])
+    return RZ_mixer
+
+
+def qiro_controlled_RX_mixer_gen(predicate, union):
+    r"""
+    For a QIRO MIS instances, generate a controlled RX mixer for a given predicate function.
+
+    Parameters
+    ----------
+    predicate : function
+        A function receiving a ``QuantumVariable`` and an index $i$.
+        This function returns a ``QuantumBool`` indicating if the predicate is satisfied for ``qv[i]``,
+        that is, if the element ``qv[i]`` should be swapped in. 
+    union : List
+        List of Qubits which were found to be positively or negatively correlated, i.e. they should not be mixed again.  
+
+
+    Returns
+    -------
+    controlled_RX_mixer : function
+        A function receiving a ``QuantumVariable`` and a real parameter $\beta$.
+        This function performs the application of the mixing operator.
+
+    Examples
+    --------
+
+    We define the predicate function for the :ref:`MaxIndepSet <maxIndepSetQAOA>` problem. It returns ``True`` for the index (node) $i$ if 
+    all neighbors $j$ of the node $i$ in the graph $G$ are not selected, and ``False`` otherwise.
+
+    ::
+
+        from qrisp import QuantumVariable, QuantumBool, h, mcx, auto_uncompute, multi_measurement
+        import networkx as nx
+
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (1, 2), (2, 0)])  
+        neighbors_dict = {node: list(G.adj[node]) for node in G.nodes()}
+
+        def predicate(qv,i):
+            qbl = QuantumBool()
+            if len(neighbors_dict[i])==0:
+                x(qbl)
+            else:
+                mcx([qv[j] for j in neighbors_dict[i]],qbl,ctrl_state='0'*len(neighbors_dict[i]))
+            return qbl
+
+        qv = QuantumVariable(3)
+        h(qv)
+        qbl = predicate(qv,0)
+        multi_measurement([qv,qbl])
+        # Yields: {('000', True): 0.125,('100', True): 0.125,('010', False): 0.125,('110', False): 0.125,('001', False): 0.125,('101', False): 0.125,('011', False): 0.125,('111', False): 0.125}
+
+    The resulting ``controlled_RX_mixer`` then only swaps the node $i$ in if all neighbors $j$ in the graph $G$ are not selected.
+
+    """
+
+    @auto_uncompute
+    def controlled_RX_mixer(qv, beta):
+        m = qv.size
+        for i in range(m):
+            if i not in union:
+                with control(predicate(qv,i)):
+                    rx(beta,qv[i])
+
+    return controlled_RX_mixer
+
 
 def qiro_init_function(solutions = [], exclusions = []):
     """