MoMPy 0.0.1__tar.gz

mompy-0.0.1/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mompy-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.3
+Name: MoMPy
+Version: 0.0.1
+Summary: Moment matrix generation package for SDP hierarchies
+Project-URL: Homepage, https://github.com/pypa/sampleproject
+Project-URL: Issues, https://github.com/pypa/sampleproject/issues
+Author-email: Carles Roch i Carceller <chalswater@gmail.com>
+License-File: LICENSE.md
+Keywords: SDP hierarchy,moment matrix,semidefinite programming
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+MoMPy: Moment matrix generation and managing package for SDP hierarchies.
+
+This is a package to generate moment matrices for SDP hierarchies. The package contains the following relevant functions:
+
+ - MomentMatrix: generates the moment matrix with operational equivalences already taken into account (except normalisation).
+
+ - normalisation_contraints: takes into account normalisation constraints. This is to be called inside the SDP and added as a constraint!
+
+More information in the code files.

mompy-0.0.1/README.md

@@ -0,0 +1,9 @@
+MoMPy: Moment matrix generation and managing package for SDP hierarchies.
+
+This is a package to generate moment matrices for SDP hierarchies. The package contains the following relevant functions:
+
+ - MomentMatrix: generates the moment matrix with operational equivalences already taken into account (except normalisation).
+
+ - normalisation_contraints: takes into account normalisation constraints. This is to be called inside the SDP and added as a constraint!
+
+More information in the code files.

mompy-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "MoMPy"
+version = "0.0.1"
+authors = [
+  { name="Carles Roch i Carceller", email="chalswater@gmail.com" },
+]
+description = "Moment matrix generation package for SDP hierarchies"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+keywords = [
+    "semidefinite programming",
+    "moment matrix",
+    "SDP hierarchy"
+]
+dependencies = ["NumPy"]
+
+[project.urls]
+Homepage = "https://github.com/pypa/sampleproject"
+Issues = "https://github.com/pypa/sampleproject/issues"

mompy-0.0.1/src/MoMPy/MoM.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 27 22:41:00 2024
+
+@author: carles
+"""
+
+import numpy as np
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def Permute(v):
+    """ Cyclical permutation """
+    return [v[-1]] + v[:-1]
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def Commute(v,index):
+    """ Commute v[index] in v """
+    store = v[index]
+
+    v_copy = [ii for ii in v]
+    v_copy.remove(store)
+    
+    out = []
+    entered = False
+    for jj in range(len(v)):
+        if jj == index + 1:
+            out += [store]
+            entered = True
+        else:
+            if entered == True:
+                out += [v_copy[jj-1]]
+            else:
+                if jj < len(v_copy):
+                    out += [v_copy[jj]]
+
+    if len(out) < len(v):
+        out = [store] + out
+                
+    return out
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def fmap(table,i):
+    ''' A funciton that maps a value on table[item][0] --> table[item][1] in the same row'''
+    found = False
+    for item in range(len(table)):
+        if i in table[item][0]: # For non-commuting variables, i is a vector!
+            found = True
+            item_saved = item
+
+    if found == True:
+        return table[item_saved][1]
+    else:
+        return 'ERROR: The value does not appear in the mapping rule'
+    
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def reverse_list(lista):
+    return[k for k in reversed(lista)]
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def normalisation_contraints(element,list_identities_in):
+    
+    """ 
+        Def: 
+            List of elements which summed are equal to the last element in each list 
+            
+        Arguments:
+            
+            element: list of elements that require normalisation
+            
+            list_identities_in: lost of equivalences
+    
+    """
+    
+    # element: list of elements that require normalisation
+    # list_identities_in: list of exsisting equivalences
+    
+    output_ct = []
+    already_counted = []
+    
+    list_identities = list_identities_in[:]
+
+    for term in list_identities:
+        dd = 0
+        for pp in range(len(term[dd])):
+            yy = 0
+            string = []
+            if term[dd][pp] == element[yy]:
+                new_input = term[dd][:]
+                copy_without_element = new_input[:]
+                del copy_without_element[pp]
+                if len(copy_without_element) < 1:
+                    copy_without_element += [0]
+                for hh in range(len(element)):
+                    new_input[pp] = element[hh]
+                    copy = new_input[:]
+                    string += [copy]
+                string += [copy_without_element]
+
+            if len(string) > 1:
+                output_ct += [string]
+
+    """
+    
+    Output:
+        
+        list of indices which added are equal to the last one
+        
+    """
+
+    return output_ct
+
+#------------------------------------------------------------------------------------------
+#------------------------------------------------------------------------------------------
+
+def MomentMatrix(S_1,S_2,higher_order_elements,rank_1_projectors,orthogonal_projectors,commuting_elements,states):
+    
+    """ 
+        Generator of SDP hierarchy Moment matrix
+        
+        S_1:
+            list of first order elements (zero order not included)
+            
+        S_2:
+            list of elements to generate second order terms (zero order not included)
+            
+        higher_order_elements:
+            list of specific elements of higher orders
+            
+        rank_1_projectors:
+            list of rank-1 projectors
+            
+        orthogonal_projectors:
+            lists of orthogonal projectors
+            
+        commuting_elements:
+            list of elements that commute with everything EXCEPT with the states
+            
+        states:
+            delcare what are your states that don't commute with anything (only used for commutation constraints)        
+    """    
+    
+    S = []
+    for v in S_1:
+        S += [[v]] # Add first order monomials
+
+    for k in S_2:
+        for h in S_2:
+            S += [[h,k]] # Compute second order monomials
+            
+    S += higher_order_elements # Add additional higher order elements
+
+    Mexp = [] # Here we store the matrix for all explicit elements
+    complete_list_explicit = [] # Here we store all explicit elements in a list
+    for r in range(len(S)+1):
+        Mexp += [[]]
+        for c in range(len(S)+1):
+            if r == 0 and c > 0:
+                Mexp[r] += [reverse_list(S[c-1])]
+            elif c == 0 and r > 0:
+                Mexp[r] += [S[r-1]]
+            elif c == 0 and r == 0:
+                Mexp[r] += [[0]]
+            else:
+                Mexp[r] += [S[r-1]+reverse_list(S[c-1])]
+            if r >= c:
+                complete_list_explicit += [ Mexp[r][c] ]
+            
+    
+    # Detect the elemenets that are equal to zero by orthogonality rules
+    group_of_zeros = [] # Group of zeros 
+    for r in range(len(S)+1):
+        for c in range(len(S)+1):
+                
+            # Orthogonal projectors
+            if len(Mexp[r][c]) >= 2:
+                for ii in range(len(Mexp[r][c])):
+                    for kk in range(len(orthogonal_projectors)):
+                        if Mexp[r][c][ii] in orthogonal_projectors[kk] and Mexp[r][c][np.mod(ii+1,len(Mexp[r][c]))] in orthogonal_projectors[kk]:
+                                if Mexp[r][c][ii] != Mexp[r][c][np.mod(ii+1,len(Mexp[r][c]))]:
+                                    new_vec = [Mexp[r][c][jj] for jj in range(len(Mexp[r][c]))]
+                                    if new_vec not in group_of_zeros:  #if it is not in the list already, add it
+                                        group_of_zeros += [new_vec]
+                                        if Mexp[r][c] in complete_list_explicit:
+                                            complete_list_explicit.remove(Mexp[r][c]) # Remove element that was already taken into account
+
+    # Apply symmetry rules 
+    id_elements = [] # list containing groups of identical elements
+    ss = 0
+    for element in complete_list_explicit:     
+        
+        print(f'\r Building Moment Matrix: {np.round(ss/(len(complete_list_explicit)),2)}%'+'\r',end=' ')
+        equivalences_vec = [] # vector of equivalent elements
+    
+        missed_zero = False
+    
+        # Identical elements by cyclic permutation in traces
+        new_vec = element[:]
+        for ii in range(len(element)+1):
+            if new_vec not in equivalences_vec: # if it is not in the list already, add it
+                equivalences_vec += [new_vec]    
+            if new_vec in group_of_zeros:    
+                missed_zero = True
+            new_vec = Permute(new_vec) # Permute members (monomials) of the element
+            
+        # Identical elements by being rank-1 projectors (B^2 = B)
+        if len(element) >= 2:
+            for ii in range(len(element)): 
+                if element[ii] in rank_1_projectors:
+                    if element[ii] == element[np.mod(ii+1,len(element))]:
+                        new_vec = [element[jj] for jj in range(len(element)) if jj != ii]
+                        if new_vec not in equivalences_vec:  #if it is not in the list already, add it
+                            equivalences_vec += [new_vec]    
+                        if new_vec in group_of_zeros:    
+                            missed_zero = True
+            
+        # Identical elements by commuting rules
+        # When you commute an element, you completely change the whole set of elements, and so one needs to re-check ciclicity and rank-1
+        new_vec = element[:]
+        new_lists = equivalences_vec
+        diff = len(commuting_elements) # if there are no commuting elements, we don't need to do this re-checking
+        already_counted = []
+        while diff > 0: # While we keep adding elements in "new_lists" we will do the following
+            len_ini = len(new_lists)
+            for term in new_lists:
+                if term not in already_counted:
+                    already_counted += [term]
+                    new_vec = term[:]
+                    for hh in range(len(term)):
+                        if term[hh] in commuting_elements: #if the element is in the list of commuting elements
+                            for ii in range(len(new_vec)+1):
+                                new_vec = Commute(new_vec,np.mod(hh+ii,len(new_vec))) # permute members (monomials) of the element
+                                if new_vec not in new_lists:
+                                    new_lists += [new_vec]
+                                if new_vec not in equivalences_vec:
+                                    equivalences_vec += [new_vec]
+                                if new_vec in group_of_zeros:    
+                                    missed_zero = True    
+                    
+                    new_vec = term[:]
+                    for ii in range(len(new_vec)+1): # Include also the cyclic permutations of the new elements
+                        if new_vec not in equivalences_vec: # if it is not in the list already, add it
+                            equivalences_vec += [new_vec]   
+                        if new_vec in group_of_zeros:    
+                            missed_zero = True
+                        new_vec = Permute(new_vec) # Permute members (monomials) of the element
+                    
+                    new_vec = term[:]
+                    if len(new_vec) >= 2:
+                        for ii in range(len(new_vec)): # Also include all rank-1 element reductions that can happen
+                            if new_vec[ii] in rank_1_projectors:
+                                if new_vec[ii] == new_vec[np.mod(ii+1,len(new_vec))]:
+                                    new_vec_2 = [new_vec[jj] for jj in range(len(new_vec)) if jj != ii]
+                                    if new_vec_2 not in equivalences_vec:  #if it is not in the list already, add it
+                                        equivalences_vec += [new_vec_2]    
+                                    if new_vec_2 in group_of_zeros:    
+                                        missed_zero = True
+                                        
+                    # Check if the new element is zero or not (and we did not count it initially)
+                    new_vec = term[:]
+                    if len(new_vec) >= 2:
+                        for ii in range(len(new_vec)):
+                            for kk in range(len(orthogonal_projectors)):
+                                if new_vec[ii] in orthogonal_projectors[kk] and new_vec[np.mod(ii+1,len(new_vec))] in orthogonal_projectors[kk]:
+                                        if new_vec[ii] != new_vec[np.mod(ii+1,len(new_vec))]:
+                                            new_vec_2 = [new_vec[jj] for jj in range(len(new_vec))]
+                                            if new_vec_2 not in group_of_zeros:  #if it is not in the list already, add it
+                                                group_of_zeros += [new_vec_2]
+                                                missed_zero = True
+
+            len_fin = len(new_lists)
+            diff = len_fin - len_ini
+        
+        if missed_zero == True: # if we detected that an element is a zero, then all is zero
+            for el in equivalences_vec:
+                if el not in group_of_zeros:
+                    group_of_zeros += [el]
+        else:
+            # Check if any of the elements in the equivalences is already accounted for
+            found_one = False
+            saved_id = []
+            for el in equivalences_vec:
+                for ids in id_elements:
+                    if el in ids:
+                        found_one = True
+                        saved_id += [ids]
+                        id_elements.remove(ids)
+    
+            # If so, merge all elements in one without repetitions: 
+            if found_one == True:
+                for tt in range(len(saved_id)):
+                    for iss in saved_id[tt]:
+                        if iss not in equivalences_vec:
+                            equivalences_vec += [iss]
+        
+            # Add the equivalences in a bigger list of identities
+            id_elements += [equivalences_vec]
+        ss += 1
+
+    # Add the zeros
+    id_elements += [group_of_zeros] 
+        
+    Moment_Matrix = np.zeros((len(Mexp),len(Mexp)),dtype=int) # This is the output Gama matrix with numbers in each element
+    map_table = [] # Table to map explicit elements to the number group of identities
+    already_counted = []
+    already_counted_2 = []
+
+    ll = 0
+    for l in range(int(len(id_elements))):
+        if id_elements[l] not in already_counted_2:
+            map_table += [[id_elements[l],ll]]
+            already_counted_2 += [id_elements[l]]
+            already_counted += id_elements[l]   
+            ll += 1
+            
+    for j in range(len(Mexp)):
+        for i in range(j,len(Mexp)):
+            Moment_Matrix[i][j] = fmap(map_table,Mexp[i][j])
+            Moment_Matrix[j][i] = Moment_Matrix[i][j]
+    
+    list_of_eq_indices = np.unique(Moment_Matrix) # Unique elements in M
+
+    """
+        Outputs:
+            
+        Moment_Matrix: 
+            Moment Matrix with indices of equivalent elements
+            
+        map_table:
+            table used to map explicit elements to their equivalence index in Moment_Matrix
+            the last element in map_table are all the zeros emerging from orthogonality
+            
+        S:
+            complete list of all elements
+            
+        list_of_eq_indices:
+            list of all equivalence indices in Moment_Matrix
+            
+        Mexp:
+            Moment matrix with all explicit elements
+        
+    """
+    
+    return Moment_Matrix,map_table,S,list_of_eq_indices,Mexp
+
+

mompy-0.0.1/src/MoMPy/__init__.py

@@ -0,0 +1,8 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 27 22:05:20 2024
+
+@author: carles
+"""
+

mompy-0.0.1/tests/to_test_MoM.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 27 23:02:24 2024
+
+@author: carles roch i carceller
+"""
+
+nX = 2 # number of state preparations
+nY = 1 # number of measurement settings
+nB = 2 # number of measurement outcomes
+nK = 2 # number of photon states (for avg photon numbe nK => n_trunc + 1
+
+#---------------------------------------------------------------------#
+#                        Collect all monomials                        #
+#---------------------------------------------------------------------#
+
+# Track operators in the tracial matrix
+w_R = [] # Prepared quantum state
+w_B = [] # Measurement
+w_P = [] # Observable (photon number projector)
+
+S_1 = [] # List of first order elements
+cc = 1
+
+for x in range(nX):
+    S_1 += [cc]
+    w_R += [cc]
+    cc += 1
+
+for y in range(nY):
+    w_B += [[]]
+    for b in range(nB):
+        S_1 += [cc]
+        w_B[y] += [cc]
+        cc += 1
+        
+for k in range(nK):
+    S_1 += [cc]
+    w_P += [cc]
+    cc += 1
+
+# Additional higher order elements
+S_high = [] # Some third order elements
+
+for k in range(nK):
+    for x in range(nX):
+        for kk in range(nK):
+            S_high += [[w_P[k],w_R[x],w_P[kk]]]
+            
+for b in range(nB):
+    for k in range(nK):
+        for kk in range(nK):
+            for y in range(nY):
+                S_high += [[w_B[y][b],w_P[k],w_P[kk]]]
+            
+for x in range(nX):
+    for b in range(nB):
+        for bb in range(nB):
+            for y in range(nY):
+                for yy in range(nY):    
+                    S_high += [[w_R[x],w_B[y][b],w_B[yy][bb]]]
+   
+for x in range(nX):
+    for b in range(nB):
+        for k in range(nK):
+            for y in range(nY):
+                 S_high += [[w_R[x],w_B[y][b],w_P[k]]]
+                 S_high += [[w_B[y][b],w_R[x],w_P[k]]]
+
+S_high = [] # Uncomment if we only allow up to some 2nd order elements in the hierarchy  
+
+# Second order elements
+some_second = True
+if some_second == True:
+    for x in range(nX):
+        for xx in range(nX):
+            S_high += [[w_R[x],w_R[xx]]]
+            
+    for x in range(nX):
+        for b in range(nB):
+            for y in range(nY):
+                S_high += [[w_R[x],w_B[y][b]]]
+            
+    for k in range(nK):
+        for b in range(nB):
+            for y in range(nY):
+                S_high += [[w_P[k],w_B[y][b]]]
+            
+    for x in range(nX):
+        for k in range(nK):
+              S_high += [[w_P[k],w_R[x]]]
+
+#S_high = []
+
+# Set the operational rules within the SDP relaxation
+list_states = [] # operators that do not commute with anything
+rank_1_projectors = w_R
+rank_1_projectors += [w_B[y][b] for y in range(nY) for b in range(nB)]
+rank_1_projectors += [w_P[k] for k in range(nK)]
+orthogonal_projectors = []
+orthogonal_projectors += [ w_B[y] for y in range(nY)]
+orthogonal_projectors += [ w_P ] 
+commuting_variables = [] # commuting elements (wxcept with elements in "list_states"
+
+print('Rank-1 projectors',rank_1_projectors)
+print('Orthogonal projectors',orthogonal_projectors)
+print('commuting elements',commuting_variables)
+
+[Moment_Matrix,map_table,S,list_of_eq_indices,Mexp] = MomentMatrix(S_1,[],S_high,rank_1_projectors,orthogonal_projectors,commuting_variables,list_states)
+
+print('Matrix size:',np.shape(G_new))
+
+print(Moment_Matrix)
+for element in map_table:
+    print(element)