Merge branch 'main' into public

Author: GDeLaurentis

.github/workflows/cd_pypi.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install setuptools wheel twine
+        pip install setuptools wheel importlib-metadata==7.2.1 twine==4.0.2
 
     - name: Build
       run: |

CHANGELOG.md

@@ -10,15 +10,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+### Changed
+
+### Fixed
+
+### Deprecated
+
+
+## [0.5.0] - 2025-04-24
+
+### Added
+
 - Support for arbitrary Gram determinants, e.g. for a box gram: `Δ_12|3|4|5`
+- Support for spinor strings with two open indices, e.g.: `|1+2|3|4|`. The first open index is assumed to be a lower alpha.
+- Raising and lowering of spinor indices does works in the presence of additional spin indices.
+- `Particles.cluster` accepts a new keyword arguement `massive_fermions`, which allows to specify the states of the fermions. E.g. `massive_fermions=((3, 'u', all), (4, 'd', all))` results in tensor output with open indices IJ, or `massive_fermions=((3, 'u', 1), (4, 'd', 1))` picks the scalar I=1, J=1 component.
+- Support for bold numbers representing spinors of massive particles. If a bold number appears where e.g. an integer or rational number should be, the evaluation will fail.
 
 ### Changed
 
+- Support for Particles string evaluation containing sqrt (in arbitrary field insteald of only with `mpmath`).
+- Particles compute and eval may return a tensor if additional spin indices are present.
+
 ### Fixed
 
+- Missleading `Particles.masses` and `Particle.mass` no longer exist (they used to return squared masses). Use `Particles.ms`, `Particles.m2s`, `Particle.m`, `Particle.m2` instead.
 - Sphinx fails if autodoc fails, instead of quitely raising a warning.
-
-### Deprecated
+- Fixed some spinor string regex parsing.
 
 
 ## [0.4.5] - 2025-01-31
@@ -70,8 +88,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fixed issue with `Particles.variety` not correctly recognizing when an hardcoded limit failed with p-adics.
 
-### Deprecated
-
 
 ## [0.4.1] - 2024-01-08
 
@@ -113,6 +129,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Fixed issue where manipulations (such as via arithmetic operations) of `Particles` would lose track of the underlying field.
 
+### Deprecated
+
+-  Import of Field from lips is deprecated. Use [syngular](https://github.com/GDeLaurentis/syngular).
+
 
 ## [0.3.1] - 2023-01-16
 
@@ -131,7 +151,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 [unreleased]: https://github.com/GDeLaurentis/lips/compare/v0.4.5...HEAD
-[0.4.4]: https://github.com/GDeLaurentis/lips/compare/v0.4.4...v0.4.5
+[0.4.5]: https://github.com/GDeLaurentis/lips/compare/v0.4.4...v0.4.5
 [0.4.4]: https://github.com/GDeLaurentis/lips/compare/v0.4.3...v0.4.4
 [0.4.3]: https://github.com/GDeLaurentis/lips/compare/v0.4.2...v0.4.3
 [0.4.2]: https://github.com/GDeLaurentis/lips/compare/v0.4.1...v0.4.2

lips/hardcoded_limits/particles_set.py

@@ -29,7 +29,7 @@ def _set(self, temp_string, temp_value, fix_mom=True, mode=1):
             if mom_cons is False:
                 raise myException("Setting: {} to {}. Momentum conservation is not satisfied: ", temp_string, temp_value, max(map(abs, flatten(self.total_mom))))
             elif on_shell is False:
-                raise myException("Setting: {} to {}. On shellness is not satisfied: ", temp_string, temp_value, max(map(abs, flatten(self.masses))))
+                raise myException("Setting: {} to {}. On shellness is not satisfied: ", temp_string, temp_value, max(map(abs, flatten(self.m2s))))
         if not abs_diff <= self.field.tollerance:
             raise myException("Failed to set {} to {}. Instead got {}. Absolute difference {}.".format(
                 temp_string, temp_value, self.compute(temp_string), abs_diff))

lips/hardcoded_limits/particles_set_pair.py

@@ -34,7 +34,7 @@ def _set_pair(self, t_s1, t_v1, t_s2, t_v2):
         if mom_cons is False:
             raise myException("Momentum conservation is not satisfied: ", max(map(abs, flatten(self.total_mom))))
         elif on_shell is False:
-            raise myException("On shellness is not satisfied: ", max(map(abs, flatten(self.masses))))
+            raise myException("On shellness is not satisfied: ", max(map(abs, flatten(self.m2s))))
         elif not all([abs_diff1 <= self.field.tollerance, abs_diff2 <= self.field.tollerance]):
             raise myException("Failed to set {} to {} and {} to {}. Instead got {} and {}. Absoute differences: {} and {}.".format(
                 t_s1, abs(t_v1), t_s2, abs(t_v2), abs(self.compute(t_s1)), abs(self.compute(t_s2)), abs_diff1, abs_diff2))

lips/particle.py

@@ -109,7 +109,7 @@ def __getitem__(self, key):
         return self.four_mom[key]
 
     def __hash__(self):
-        if abs(self.mass) <= self.field.tollerance:
+        if abs(self.m2) <= self.field.tollerance:
             return hash(tuple([tuple(self.r_sp_d.flatten()), tuple(self.l_sp_d.flatten())]))
         else:
             return hash(tuple(self.r2_sp.flatten()))
@@ -349,9 +349,14 @@ def randomise_padic(self):
     def angles_for_squares(self):
         """Flips left and right spinors."""
         if self.l_sp_d is not None and self.r_sp_d is not None:  # massive scalars do not have these defined
-            l_sp_d_shape, r_sp_d_shape = self.l_sp_d.shape, self.r_sp_d.shape
-            self._l_sp_d, self._r_sp_d = self._r_sp_d, self._l_sp_d
-            self._l_sp_d.shape, self._r_sp_d.shape = l_sp_d_shape, r_sp_d_shape
+            self._l_sp_d, self._r_sp_d = self._r_sp_d.T, self._l_sp_d.T
+            if hasattr(self, 'spin_index'):
+                if self.spin_index == 'u':
+                    self._l_sp_d *= -1
+                elif self.spin_index == 'd':
+                    self._r_sp_d *= -1
+                else:
+                    raise Exception("Spin index not understood.")
             self._sps_d_to_sps_u()
         self._r2_sp = self._r2_sp.T
         self._r2_sp_b = self._r2_sp_b.T
@@ -441,25 +446,19 @@ def _r1_sp_to_r2_sp_b(self):
         self._l_sp_d.shape = (1, 2)
         self._r2_sp_b = numpy.dot(self.r_sp_d, self.l_sp_d)
 
-    def _r_sp_d_to_r_sp_u(self):
-        self._r_sp_u = numpy.dot(LeviCivita, self.r_sp_d)
-        self._r_sp_u.shape = (1, 2)    # row vector
+    def _r_sp_d_to_r_sp_u(self):  # λ^α = ϵ^αβ λ_β
+        """⟨a| = λ^α = ϵ^αβ λ_β = ϵ |a⟩ or ⟨a^I| = λ^Iα = ϵ^αβ λ_β^I = ϵ |a^I⟩"""
+        self._r_sp_u = (LeviCivita @ self.r_sp_d).T
 
     def _l_sp_d_to_l_sp_u(self):
-        self._l_sp_d.shape = (2, 1)    # temporary column vector
-        self._l_sp_u = numpy.dot(LeviCivita, self.l_sp_d)
-        self._l_sp_d.shape = (1, 2)    # back to row vector
-        self._l_sp_u.shape = (2, 1)    # column vector
+        """|a] = λ^α˙ = ϵ^α˙β˙ λ_β˙ = λ_β˙ ϵ^β˙α˙ = [a| ϵ or |a^I] = λ^α˙I = ϵ^α˙β˙ λ^I_β˙ = λ^I_β˙ ϵ^β˙α˙ = [a^I|"""
+        self._l_sp_u = (self.l_sp_d @ LeviCivita.T).T
 
     def _r_sp_u_to_r_sp_d(self):
-        self._r_sp_u.shape = (2, 1)    # temporary column vector
-        self._r_sp_d = numpy.dot(numpy.transpose(LeviCivita), self.r_sp_u)
-        self._r_sp_u.shape = (1, 2)    # back to row vector
-        self._r_sp_d.shape = (2, 1)    # column vector
+        self._r_sp_d = (self.r_sp_u @ LeviCivita).T
 
     def _l_sp_u_to_l_sp_d(self):
-        self._l_sp_d = numpy.dot(numpy.transpose(LeviCivita), self.l_sp_u)
-        self._l_sp_d.shape = (1, 2)    # row vector
+        self._l_sp_d = (LeviCivita.T @ self.l_sp_u).T
 
     def _sps_u_to_sps_d(self):
         self._l_sp_u_to_l_sp_d()
@@ -509,6 +508,9 @@ def lsq(self):
         return lsq
 
     @property
-    def mass(self):
-        # Technically this is the mass squared - might want to rename
+    def m2(self):
         return self.lsq()
+
+    @property
+    def m(self):
+        return self.field.sqrt(self.lsq())

lips/particles.py

@@ -19,22 +19,24 @@
 from sympy import NotInvertible
 
 from syngular import Field
-from pyadic import PAdic
+from pyadic import PAdic, ModP
 
-from .tools import MinkowskiMetric, flatten, subs_dict, pNB, myException, indexing_decorator, pAu, pAd, pSu, pSd, pMVar
+from .tools import MinkowskiMetric, flatten, subs_dict, pNB, myException, indexing_decorator, pAu, pAd, pSu, pSd, pMVar, LeviCivita
 from .particle import Particle
 from .particles_compute import Particles_Compute
 from .particles_eval import Particles_Eval
 from .hardcoded_limits.particles_set import Particles_Set
 from .hardcoded_limits.particles_set_pair import Particles_SetPair
 from .algebraic_geometry.particles_singular_variety import Particles_SingularVariety
 from .particles_variety import Particles_Variety
+from .particles_slices import Particles_Slices
 
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
 
 
-class Particles(Particles_Compute, Particles_Eval, Particles_Set, Particles_SetPair, Particles_SingularVariety, Particles_Variety, list):
+class Particles(Particles_Compute, Particles_Eval, Particles_Set, Particles_SetPair, Particles_SingularVariety,
+                Particles_Variety, Particles_Slices, list):
     """Describes the kinematics of n particles. Base one list of Particle objects."""
 
     # MAGIC METHODS
@@ -101,9 +103,14 @@ def total_mom(self):
         return sum([oParticle.r2_sp for oParticle in self])
 
     @property
-    def masses(self):
+    def m2s(self):
+        """Masses squared of all particles in phase space."""
+        return [oParticle.m2 for oParticle in self]
+
+    @property
+    def ms(self):
         """Masses of all particles in phase space."""
-        return [oParticle.mass for oParticle in self]
+        return [oParticle.m for oParticle in self]
 
     @property
     def internal_masses_dict(self):
@@ -152,14 +159,35 @@ def copy(self):
         from .symmetries import identity
         return self.image(identity(len(self)))
 
-    def cluster(self, llIntegers):
-        """Returns clustered particle objects according to lists of lists of integers (e.g. corners of one loop diagram)."""
+    def cluster(self, llIntegers, massive_fermions=None):
+        """Returns clustered particle objects according to lists of lists of integers (e.g. corners of one loop diagram).
+        Massive legs are by default massive scalars.
+        Massive fermions can be specificed as e.g.: massive_fermions=((3, 'u', all), (4, 'd', all)))
+        """
         drule1 = dict(zip(["s" + "".join(map(str, entry)) for entry in llIntegers], [f"s{i}" for i in range(1, len(llIntegers) + 1)]))
         drule2 = dict(zip(["s_" + "".join(map(str, entry)) for entry in llIntegers], [f"s_{i}" for i in range(1, len(llIntegers) + 1)]))
         clustered_internal_masses = {key: (subs_dict(val, drule1 | drule2) if isinstance(val, str) else val)
                                      for key, val in self.internal_masses_dict.items()}
-        return Particles([sum([self[i] for i in corner_as_integers]) for corner_as_integers in llIntegers],
-                         field=self.field, fix_mom_cons=False, internal_masses=clustered_internal_masses)
+        selfClustered = Particles([sum([self[i] for i in corner_as_integers]) for corner_as_integers in llIntegers],
+                                  field=self.field, fix_mom_cons=False, internal_masses=clustered_internal_masses)
+        if massive_fermions is not None:
+            for leg, index_position, index_value in massive_fermions:
+                assert len(llIntegers[leg - 1]) == 2
+                a, b = llIntegers[leg - 1]
+                selfClustered[leg]._r_sp_d = numpy.block([self(f"|{a}⟩"), self(f"|{b}⟩")])  # |bold leg> = |leg^I> = (lambda_leg)_alpha^I
+                selfClustered[leg]._l_sp_d = numpy.block([[self(f"[{a}|")], [self(f"[{b}|")]])  # [bold leg| = [leg_I| = (tilde-lambda_leg)_I_alpha
+                if index_position == "u":
+                    selfClustered[leg]._l_sp_d = -LeviCivita @ selfClustered[leg]._l_sp_d  # [bold leg| = [leg^I||
+                elif index_position == "d":
+                    selfClustered[leg]._r_sp_d = selfClustered[leg]._r_sp_d @ -LeviCivita  # |bold leg> = |leg_I>
+                else:
+                    raise Exception("Massive fermion spin index position must be either 'u' or 'd'.")
+                selfClustered[leg].spin_index = index_position
+                if isinstance(index_value, int):
+                    selfClustered[leg]._r_sp_d = selfClustered[leg]._r_sp_d[:, index_value - 1:index_value]
+                    selfClustered[leg]._l_sp_d = selfClustered[leg]._l_sp_d[index_value - 1:index_value, :]
+                selfClustered[leg]._sps_d_to_sps_u()
+        return selfClustered
 
     def make_analytical_d(self, indepVars=None, symbols=('a', 'b', 'c', 'd')):
         """ """
@@ -202,6 +230,44 @@ def analytical_subs_d(self):
             subs_dict.update({lc[i]: iParticle.l_sp_d[0, 0], ld[i]: iParticle.l_sp_d[0, 1]})
         return subs_dict
 
+    def subs(self, myDict):
+        """For all rank-1 spinor components, substitutes symbols with values from myDict."""
+        for oP in self:
+            if isinstance(oP.r_sp_d[0, 0], (sympy.Add, sympy.Mul, sympy.Symbol)):
+                oP.r_sp_d[0, 0] = oP.r_sp_d[0, 0].subs(myDict)
+                if isinstance(oP.r_sp_d[0, 0], sympy.Integer) and self.field.name == "finite field":
+                    oP.r_sp_d[0, 0] = ModP(oP.r_sp_d[0, 0], self.field.characteristic)
+                elif isinstance(oP.r_sp_d[0, 0], sympy.Integer) and self.field.name == "padic":
+                    oP.r_sp_d[0, 0] = PAdic(oP.r_sp_d[0, 0], self.field.characteristic, self.field.digits)
+                else:
+                    oP.r_sp_d[0, 0] = sympy.poly(oP.r_sp_d[0, 0], modulus=self.field.characteristic ** self.field.digits).as_expr()
+            if isinstance(oP.r_sp_d[1, 0], (sympy.Add, sympy.Mul, sympy.Symbol)):
+                oP.r_sp_d[1, 0] = oP.r_sp_d[1, 0].subs(myDict)
+                if isinstance(oP.r_sp_d[1, 0], sympy.Integer) and self.field.name == "finite field":
+                    oP.r_sp_d[1, 0] = ModP(oP.r_sp_d[1, 0], self.field.characteristic)
+                elif isinstance(oP.r_sp_d[1, 0], sympy.Integer) and self.field.name == "padic":
+                    oP.r_sp_d[1, 0] = PAdic(oP.r_sp_d[1, 0], self.field.characteristic, self.field.digits)
+                else:
+                    oP.r_sp_d[1, 0] = sympy.poly(oP.r_sp_d[1, 0], modulus=self.field.characteristic ** self.field.digits).as_expr()
+            oP.r_sp_d = oP.r_sp_d  # trigger setter
+            if isinstance(oP.l_sp_d[0, 0], (sympy.Add, sympy.Mul, sympy.Symbol)):
+                oP.l_sp_d[0, 0] = oP.l_sp_d[0, 0].subs(myDict)
+                if isinstance(oP.l_sp_d[0, 0], sympy.Integer) and self.field.name == "finite field":
+                    oP.l_sp_d[0, 0] = ModP(oP.l_sp_d[0, 0], self.field.characteristic)
+                elif isinstance(oP.l_sp_d[0, 0], sympy.Integer) and self.field.name == "padic":
+                    oP.l_sp_d[0, 0] = PAdic(oP.l_sp_d[0, 0], self.field.characteristic, self.field.digits)
+                else:
+                    oP.l_sp_d[0, 0] = sympy.poly(oP.l_sp_d[0, 0], modulus=self.field.characteristic ** self.field.digits).as_expr()
+            if isinstance(oP.l_sp_d[0, 1], (sympy.Add, sympy.Mul, sympy.Symbol)):
+                oP.l_sp_d[0, 1] = oP.l_sp_d[0, 1].subs(myDict)
+                if isinstance(oP.l_sp_d[0, 1], sympy.Integer) and self.field.name == "finite field":
+                    oP.l_sp_d[0, 1] = ModP(oP.l_sp_d[0, 1], self.field.characteristic)
+                elif isinstance(oP.l_sp_d[0, 1], sympy.Integer) and self.field.name == "padic":
+                    oP.l_sp_d[0, 1] = PAdic(oP.l_sp_d[0, 1], self.field.characteristic, self.field.digits)
+                else:
+                    oP.l_sp_d[0, 1] = sympy.poly(oP.l_sp_d[0, 1], modulus=self.field.characteristic ** self.field.digits).as_expr()
+            oP.l_sp_d = oP.l_sp_d  # trigger setter
+
     def fix_mom_cons(self, A=0, B=0, real_momenta=False, axis=1):   # using real momenta changes both |⟩ and |] of A & B
         """Fixes momentum conservation using particles A and B."""
         if A == 0 and B == 0:                                       # defaults to random particles to fix mom cons
@@ -234,7 +300,7 @@ def momentum_conservation_check(self, silent=True):
 
     def onshell_relation_check(self, silent=True):
         """Returns true if all on-shell relations are satisfied."""
-        onshell_violation = max(map(abs, flatten(self.masses)))
+        onshell_violation = max(map(abs, flatten(self.m2s)))
         if silent is False:
             print("The largest on shell violation is {}".format(float(onshell_violation) if type(onshell_violation) is mpmath.mpf else onshell_violation))
         if onshell_violation > self.field.tollerance: