sopy-quantum 1.0.0__tar.gz

sopy_quantum-1.0.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-Present Jonathan Jerke at Quantum Galaxies Corporation
+
+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.

sopy_quantum-1.0.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: sopy-quantum
+Version: 1.0.0
+Summary: Representation and Decomposition with Sums of Product for Operations in separated dimensions
+Author-email: Jonathan Jerke <jonathan@quantumgalaxies.org>
+License-Expression: MIT
+Project-URL: Homepage, https://sopy.quantumgalaxies.org
+Project-URL: Issues, https://github.com/quantumgalaxies/sopy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: tensorflow>=2.16.1
+Requires-Dist: scikit-learn>=1.6.1
+Dynamic: license-file
+
+# SoPy
+
+## Representation and Decomposition with Sums of Product for Operations in separated dimensions
+
+### How to Contribute
+	* Wrap work in a class for user friendliness
+        * Write to disk/database/json
+    * Develop amplitude/component to various non-local resources
+	* Engage with Quantum Galaxies deploying matrices in separated dimensions
+
+### Contact Info
+    sopy.quantumgalaxies.org

sopy_quantum-1.0.0/README.md

@@ -0,0 +1,12 @@
+# SoPy
+
+## Representation and Decomposition with Sums of Product for Operations in separated dimensions
+
+### How to Contribute
+	* Wrap work in a class for user friendliness
+        * Write to disk/database/json
+    * Develop amplitude/component to various non-local resources
+	* Engage with Quantum Galaxies deploying matrices in separated dimensions
+
+### Contact Info
+    sopy.quantumgalaxies.org

sopy_quantum-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sopy-quantum"
+version = "1.0.0"
+authors = [
+  { name="Jonathan Jerke", email="jonathan@quantumgalaxies.org" },
+]
+description = "Representation and Decomposition with Sums of Product for Operations in separated dimensions"
+readme = "README.md"
+requires-python = ">=3.12"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    'Intended Audience :: Science/Research',
+    'Intended Audience :: Developers',
+]
+dependencies = ['tensorflow>=2.16.1','scikit-learn>=1.6.1']
+dynamic = []
+license = "MIT"
+license-files = ["LICENSE.txt"]
+
+[project.urls]
+Homepage = "https://sopy.quantumgalaxies.org"
+Issues = "https://github.com/quantumgalaxies/sopy/issues"

sopy_quantum-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sopy_quantum-1.0.0/sopy/__init__.py

@@ -0,0 +1,3 @@
+from .component.component import component
+from .amplitude.amplitude import amplitude
+from .vector.vector import vector

sopy_quantum-1.0.0/sopy/amplitude/__init__.py

@@ -0,0 +1 @@
+from . import amplitude

sopy_quantum-1.0.0/sopy/amplitude/amplitude.py

@@ -0,0 +1,109 @@
+####################  ##########################
+################  SoPy        ##################
+####################  ########################## 
+
+################################################
+###          by Quantum Galaxies Corp        ###
+##           (2023,2024,2025)                 ##
+################################################
+
+
+import tensorflow as tf
+
+class amplitude :
+    """
+    d = 0
+    """
+
+    def __init__(self, a = 1 , contents = [[]]):
+        if contents == [[]]:
+            self.contents = tf.constant([[a]], dtype = tf.float64)
+        else:
+            self.contents = contents
+
+    def boost(self):
+        return self
+
+    def set_boost(self, transform = [[]]):
+        return self
+    
+    def unboost(self):
+        return self
+    
+    def copy(self):
+        other = amplitude(contents = self.contents)
+        return other
+    
+    def __len__(self):
+        """
+        for SoP like (canonRanks)* N*[R] 
+        return CanonRanks, which is the number of product sums
+        """
+        try:
+            return len(self.values())
+        except:
+            return 0
+            
+    def normalize(self):
+        """
+        take another component and map its canonical norms to amplitudes
+        """
+        self.contents = tf.linalg.normalize(self.values(),axis=1)[1]
+        return self
+
+
+    def sample(self, num_samples):
+        """
+        Manifestly obvious, the reconstruction under frequency sampling of this output would be q
+    
+        Parameters
+        ----------
+        q : SoP
+        lattices : dict of lattice positions
+    
+        Returns
+        -------
+        A sample in q
+        """
+        
+        def discrete_inverse_transform_sampling(pdf_values):
+            """
+            Generates random samples from a discrete PDF using inverse transform sampling.
+        
+            Args:
+                pdf_values: A NumPy array representing the PDF values.
+                pdf_domain: A NumPy array representing the corresponding domain values.
+                num_samples: The number of samples to generate.
+        
+            Returns:
+                sample.
+    
+            advised by Gemini
+            """
+            pdf_values -= tf.math.reduce_min(pdf_values, axis=0)
+            # 1. Normalize             
+            pdf_values = tf.math.abs(pdf_values) / tf.math.abs(tf.math.reduce_sum(pdf_values))
+            # 2. Calculate the CDF
+
+            cdf = tf.reshape(tf.math.cumsum(pdf_values),-1)
+            # 3. Generate uniform samples
+            uniform_samples = tf.random.uniform(shape=(num_samples,), dtype = tf.float64)
+            # 4. Inverse lookup
+
+            sampled_value = tf.searchsorted( cdf, uniform_samples)
+            return sampled_value
+    
+        return tf.convert_to_tensor( discrete_inverse_transform_sampling ( self.values()) )
+
+    def __getitem__(self,r):
+        if r <  len(self): 
+            return amplitude( contents = [self.contents[r]] )
+            
+
+    
+    def __imul__(self, m):
+        self.contents *= m
+        return self
+
+    def values(self):
+        return (self.contents)

sopy_quantum-1.0.0/sopy/component/__init__.py

@@ -0,0 +1 @@
+from . import component

sopy_quantum-1.0.0/sopy/component/component.py

@@ -0,0 +1,154 @@
+####################  ##########################
+################  SoPy        ##################
+####################  ########################## 
+
+################################################
+###          by Quantum Galaxies Corp        ###
+##           (2023,2024,2025)                 ##
+################################################
+
+
+import tensorflow as tf
+pi2 = 6.283185307179586476925286766559005768394338798
+
+class component :
+    """
+    d > 0 
+    """
+
+    def __init__ (self, lattice : [float] , contents = [[]], transform = [[]] ):
+        self.contents = contents
+        self.transform = transform
+        self.lattice   = lattice
+
+    def copy(self):
+        other = component(lattice = self.lattice, contents = self.contents, transform = self.transform)
+        return other
+    
+    def __len__(self):
+        """
+        for SoP like (canonRanks)* N*[R] 
+        return CanonRanks, which is the number of product sums
+        """
+        try:
+            return len(self.contents)
+        except:
+            return 0
+
+    def inner(self, other  ):
+        """
+        inner product on naturalized collective space
+
+        return matrix across canon ranks
+        """
+        assert isinstance(other, component)
+        u = self.values()
+        v = other.values()
+        return tf.linalg.matmul(u,v, transpose_a = False, transpose_b = True)
+
+    def normalize(self):
+        self.contents = tf.transpose(tf.linalg.normalize(tf.transpose(self.contents),axis=0)[0])
+        return self
+
+    def amplitude(self):
+        return tf.linalg.normalize((self.contents),axis=1)[1]
+      
+    def add(self, other  ):
+        assert isinstance(other, component)
+        u = self.values()
+        v = other.values()
+        self.contents = tf.concat([(u[space]),(v[space])],0)
+        return self
+
+    def set_boost(self, transform = [[]]):
+        if transform == [[]]:
+            u = self.values()
+            q,r = tf.linalg.qr(tf.transpose(u) , full_matrices = False)
+            self.transform = q
+        else:
+            self.transform = transform
+        return self
+
+    def boost(self):
+        u = self.values()
+        self.contents =  tf.transpose(tf.linalg.matmul(tf.transpose(self.transform),tf.transpose(u)))
+        return self
+
+    
+    def unboost(self):
+        u = self.values()
+        self.contents =  tf.transpose(tf.linalg.matmul(self.transform,tf.transpose(u)))
+        return self
+        
+    def len(self):
+        return len(tf.transpose(self.contents))
+
+
+    def __getitem__(self, r):
+        if r < len(self):
+            return component(lattice = self.lattice, contents = [self.contents[r]], transform = self.transform )
+    
+    def sample(self, sample_rank, num_samples = 1):
+        """
+        Manifestly obvious, the reconstruction under frequency sampling of this output would be q
+    
+        Parameters
+        ----------
+        q : SoP
+        lattices : dict of lattice positions
+    
+        Returns
+        -------
+        A sample in q
+        """
+
+        u = self.values()
+        
+        def discrete_inverse_transform_sampling(pdf_values, pdf_domain):
+            """
+            Generates random samples from a discrete PDF using inverse transform sampling.
+        
+            Args:
+                pdf_values: A NumPy array representing the PDF values.
+                pdf_domain: A NumPy array representing the corresponding domain values.
+                num_samples: The number of samples to generate.
+        
+            Returns:
+                sample.
+    
+            advised by Gemini
+            """
+            pdf_values -= tf.math.reduce_min(pdf_values, axis=0)    
+            # 1. Normalize the PDF
+            pdf_values = tf.math.abs(pdf_values) / tf.math.abs(tf.math.reduce_sum(pdf_values))
+            # 2. Calculate the CDF
+
+            cdf = tf.reshape(tf.math.cumsum(pdf_values),-1)
+            # 3. Generate uniform samples
+            uniform_samples = tf.random.uniform(shape=(num_samples,), dtype = tf.float64)
+            # 4. Inverse lookup
+
+            sampled_value = tf.searchsorted( cdf, uniform_samples)
+            return pdf_domain[sampled_value]
+    
+        return  tf.convert_to_tensor(discrete_inverse_transform_sampling ( u[sample_rank], self.lattice ) )
+
+
+    def gaussian(self, position  , sigma ,l: int = 0 ):
+        position = tf.constant(position, dtype=tf.float64)
+        sigma    = tf.constant(sigma, dtype=tf.float64)
+
+        self.contents = tf.convert_to_tensor([[ tf.math.sqrt( 1. / pi2 / sigma**2 ) * (tf.math.exp( -1/2. * ( x - position )**2/sigma**2 ))*(x-position)**l for x in self.lattice ]])
+        return self
+
+
+    def delta(self, position  , spacing ):
+        position = tf.constant(position, dtype=tf.float64)
+        spacing    = tf.constant(spacing, dtype=tf.float64)
+        
+        self.contents =  tf.convert_to_tensor([[ (tf.math.sin( pi2/2. *  ( x - position )/ spacing )/( pi2/2. *  ( x - position )/ spacing ) if x != position else 1 ) for x in self.lattice ]])
+        return self
+
+    def values(self):
+        return (self.contents)
+

sopy_quantum-1.0.0/sopy/vector/__init__.py

@@ -0,0 +1 @@
+from . import vector

sopy_quantum-1.0.0/sopy/vector/vector.py

@@ -0,0 +1,249 @@
+####################  ##########################
+################  SoPy        ##################
+####################  ########################## 
+
+################################################
+###          by Quantum Galaxies Corp        ###
+##           (2023,2024,2025)                 ##
+################################################
+
+from .. import amplitude
+from .. import component
+import tensorflow as tf
+from sklearn.cluster import KMeans
+class vector :
+
+    def __init__(self):
+        self.contents = []
+
+    def __len__(self):
+        ranks = len(self.contents) 
+        return ranks
+
+    def dist( self, other):
+        return tf.math.sqrt(tf.math.abs(self.dot(self) + other.dot(other) - self.dot(other) - other.dot(self)))
+
+    def ld1(self):
+        return tf.math.reduce_sum(tf.math.abs(self[0]))
+
+    def ld2(self):
+        return tf.math.sqrt(tf.math.reduce_sum(tf.math.abs(self[0])**2))
+    
+    def n(self):
+        return tf.math.sqrt(self.dot(self))
+
+    def boost(self):
+        transforms =[[]]+ [component ( contents = self[d] ,lattice = self.contents[0][d].lattice ).set_boost().transform for d in self.dims(True)]
+        new = vector()
+        for r in range(len(self)):
+            new.contents += [ [self.contents[r][d].copy().set_boost(transform = transforms[d]).boost() for d in self.dims(False)] ]
+        return new
+        
+    def unboost(self):
+        new = vector()
+        for r in range(len(self)):
+            new.contents += [ [self.contents[r][d].copy().unboost() for d in self.dims(False)] ]
+        return new    
+    
+    def dot(self, other, norm_ = False, exclude_dim : int = -1 , sum_ = True):
+        """
+        inner product Euclidiean between v and u in [R]**N, same as (canonRanks)* N*[R]
+
+        norm_=True will not include dim=0
+        """
+        assert isinstance(other, vector)
+        def innert(vector1, vector2):
+            uv = []
+            for dim in vector1.dims(norm_):
+                if dim != exclude_dim:
+                  uv += [tf.matmul(vector1[dim],vector2[dim], transpose_b = True)]
+            return tf.math.reduce_prod(tf.convert_to_tensor(uv),axis=0)
+        uv = innert(self,other)
+        if sum_:
+            return tf.math.reduce_sum(uv)
+        else:
+            return tf.convert_to_tensor(uv)
+
+    def copy(self, norm_ = False):
+        other = vector()
+        for r in range(len(self)):
+            contents = [self.contents[r][0].copy()]
+            for d in self.dims(True):
+                if norm_:
+                    contents += [self.contents[r][d].normalize().copy()]
+                else:
+                    contents += [self.contents[r][d].copy()]
+            other.contents += [contents]
+        return other
+        
+    def mul(self, m , norm_ = False):
+        other = self.copy()
+        for r in range(len(self)):
+            other.contents[r][0] *= m
+        return other
+
+    def learn(self, other , iterate = 0, alpha = 1e-9):
+        assert isinstance(other, vector)
+        u = self##train
+        v = other##origin
+        eye = tf.linalg.eye(len(u),dtype = tf.float64)            
+        q = vector()
+        comps = [[]]+[ component(contents =tf.linalg.matmul(  
+                        tf.linalg.inv( u.dot(u,norm_ = True, exclude_dim = target_dim, sum_ = False) + alpha*eye),
+                        tf.linalg.matmul(u.dot(v,norm_ = True, exclude_dim = target_dim, sum_ = False),
+                                         tf.multiply(v[0],v[target_dim]), transpose_b = False) )
+                         , lattice = u.contents[0][target_dim].lattice, transform = self.contents[0][target_dim].transform
+                        ) for target_dim in u.dims(True) ]
+        amps = amplitude(contents = 1./len(u.dims(True))*tf.math.reduce_sum([comps[d].amplitude() for d in u.dims(True) ],axis=0))
+        q.contents = [[ amps[r] ] + [ comps[d][r].normalize() for d in u.dims(True) ] for r in range(len(u)) ]
+        if iterate == 0:
+            return q
+        else:
+            return q.learn(other, iterate - 1, alpha = alpha )  
+
+    def decompose(self, partition , iterate = 0 , alpha = 1e-9):
+        new = self.max(partition)
+        return new.learn( self, iterate = iterate, alpha = alpha)
+
+    def fibonacci(self, partition, iterate = 0 , total_iterate = 0, alpha = 1e-9, total_alpha = 1e-9):
+        Y = vector()
+        for like_ranks in self.set(partition=partition):
+            Y += like_ranks.decompose(partition = 1, alpha = alpha , iterate = iterate)
+        return Y.learn( self, iterate = total_iterate, alpha = total_alpha )
+        
+    
+    def dims(self, norm = True):
+        """
+        an interator for N dim where 
+        SoP like (canonRanks)* N*[R]
+    
+        norm == False will loop over Weights as well...
+        """
+        return range(norm==True, len(self.contents[0]))
+
+    def __getitem__(self, dim):
+        return tf.concat([ (self.contents)[r][dim].values() for r in range(len(self)) ],0)
+
+    def __imul__(self, m):
+        for r in range(len(self)):
+            self.contents[r][0] *= m
+        return self
+
+    def __add__(self, other):
+        new = self.copy()
+        new.contents += other.contents
+        return new
+
+    def __iadd__(self,other):
+        return self+other
+
+    def __isub__(self,other):
+        return self-other
+
+    def __sub__(self,other):
+        kmeans = KMeans(n_clusters=min(len(self), len(other)+1), random_state=42, n_init="auto")
+        M = (self+other).dot(other, sum_ = False)
+        kmeans.fit( M)
+        new = vector()
+        for i in range(len(M)):
+            if kmeans.labels_[i] not in kmeans.labels_[len(self):] :
+                new.contents += [ self.contents[i] ] 
+        return new
+
+    def max(self, num = 1):
+        new = vector()
+        def modify_tensor(x, i):
+            """Modifies q2[0][i][0] using tensor_scatter_nd_update."""
+        
+            indices = [[i, 0]]
+            updates = [0.0]
+        
+            x = tf.tensor_scatter_nd_update(x, indices, updates)
+            return x
+    
+            
+        args =(tf.math.abs(self[0]))
+        for n in range(min(len(self),num)):
+            i = tf.math.argmax(args)[0]
+            new.contents += [self.contents[i]]
+            args = modify_tensor(args, i )
+        return new
+
+    def min(self, num = 1):
+        new = vector()
+        def modify_tensor(x, i):
+            """Modifies q2[0][i][0] using tensor_scatter_nd_update."""
+        
+            indices = [[i, 0]]
+            updates = [tf.math.max(x)]
+        
+            x = tf.tensor_scatter_nd_update(x, indices, updates)
+            return x
+        args =(tf.math.abs(self[0]))
+        for n in range(min(len(self),num)):
+            i = tf.math.argmin(args)[0]
+            new.contents += [self.contents[i]]
+            args = modify_tensor(args, i )
+        return new
+
+    
+    def gaussian(self, a , positions  , sigmas ,ls , lattices ):
+        lens = [ len(x) for x in [ls,positions,sigmas,lattices]]
+        assert min(lens) == max(lens)
+        v =  [ amplitude(a) ]
+        for d,(l,position, sigma,lattice) in enumerate(zip( ls, positions, sigmas ,lattices)):
+             v +=[ component(lattice = lattice).gaussian(position = position,sigma = sigma, l = l).normalize()]
+        self.contents += [v]
+        return self
+
+    def set(self,partition):
+        self.partition = partition
+        return self
+    
+    def __iter__(self):
+        kmeans = KMeans(n_clusters=self.partition, random_state=42, n_init="auto")
+        kmeans.fit(self.dot(self,  sum_ = False))
+        labels = (kmeans.labels_)
+        new = self.copy()
+        
+        new.index = 0
+        new.labels = labels
+        return new
+
+    def __next__(self):
+        new = vector()
+        for index in range(len(self)):
+            if self.labels[index] == self.index:
+                new.contents += [self.contents[index]]
+        self.index += 1
+        if len(new) == 0:
+            raise StopIteration
+        return new
+    
+    def delta(self, a , positions  , spacings, lattices  ):
+        lens = [ len(x) for x in [positions,spacings,lattices]]
+        assert min(lens) == max(lens)
+        v =  [ amplitude(a) ] 
+        for d,(position, spacing,lattice) in enumerate(zip( positions, spacings ,lattices)):
+             v +=[ component(lattice = lattice).delta(position = position,spacing = spacing).normalize()]
+        self.contents += [v]
+        return self
+
+    def sample(self, num_samples ):
+        sample_ranks = amplitude( contents = self[0] ).sample( num_samples ) 
+        return tf.convert_to_tensor([ [ self.contents[r][d].sample(sample_rank=0,num_samples=1) for d in self.dims() ] for r in sample_ranks ])
+
+
+    def transpose(self,tl):
+        """
+        meant to input a dictionary with integer keys, which includes 0 as a amplitude
+        """
+        
+        comps = [ amplitude( contents = tl[0]) ]+ [ component( contents = tl[key], lattice = range(len(tl[key]))) for key in tl if key != 0 ]   
+        other = vector()
+        other.contents = [ [ comps[d][r] for d in range(len(comps)) ] for r in range(len(comps[0])) ]
+        return other
+
+
+
+

sopy_quantum-1.0.0/sopy_quantum.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: sopy-quantum
+Version: 1.0.0
+Summary: Representation and Decomposition with Sums of Product for Operations in separated dimensions
+Author-email: Jonathan Jerke <jonathan@quantumgalaxies.org>
+License-Expression: MIT
+Project-URL: Homepage, https://sopy.quantumgalaxies.org
+Project-URL: Issues, https://github.com/quantumgalaxies/sopy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: tensorflow>=2.16.1
+Requires-Dist: scikit-learn>=1.6.1
+Dynamic: license-file
+
+# SoPy
+
+## Representation and Decomposition with Sums of Product for Operations in separated dimensions
+
+### How to Contribute
+	* Wrap work in a class for user friendliness
+        * Write to disk/database/json
+    * Develop amplitude/component to various non-local resources
+	* Engage with Quantum Galaxies deploying matrices in separated dimensions
+
+### Contact Info
+    sopy.quantumgalaxies.org

sopy_quantum-1.0.0/sopy_quantum.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.txt
+README.md
+pyproject.toml
+sopy/__init__.py
+sopy/amplitude/__init__.py
+sopy/amplitude/amplitude.py
+sopy/component/__init__.py
+sopy/component/component.py
+sopy/vector/__init__.py
+sopy/vector/vector.py
+sopy_quantum.egg-info/PKG-INFO
+sopy_quantum.egg-info/SOURCES.txt
+sopy_quantum.egg-info/dependency_links.txt
+sopy_quantum.egg-info/requires.txt
+sopy_quantum.egg-info/top_level.txt

sopy_quantum-1.0.0/sopy_quantum.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sopy_quantum-1.0.0/sopy_quantum.egg-info/requires.txt

@@ -0,0 +1,2 @@
+tensorflow>=2.16.1
+scikit-learn>=1.6.1

sopy_quantum-1.0.0/sopy_quantum.egg-info/top_level.txt

@@ -0,0 +1 @@
+sopy