merge main

Author: GDeLaurentis

CHANGELOG.md

@@ -17,6 +17,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Deprecated
 
 
+## [0.6.0] - 2026-03-06
+
+### Added
+
+- `Particle.is_massless` and `.is_lightlike` properties
+- introducing `minimal` shift type, as opposed to `generic`
+- `codim_upper_bound` optional parameter for `Particles.univariate_slice`
+- Tentative implementation of slices with approximate (p-adic) constraints
+- Tentative option `conjugation_acts_on_spin_indices` (boolean, package level) - unclear if it's correct to have two togglable behaviours 
+- `massive_spins` in `Particles.cluster` allows setting left and right spin indices separately
+- tests for massive spin 1 polarizations
+
+### Changed
+
+- `Particles.subs` updated to support massive particles
+- `tr5` computation uses difference of traces `tr` rather than spinor strings to support arbitrary sequences of massless/massive legs
+- Allowing custom traces (`tr`) to be taken in lips ast evaluator
+- Improved `LipsIdeal` init, removed list vs tuple logic in favour of check of what variables appear in the polynomials (unparsed spinors, or parsed spinor components)
+- Migration of basic tools to pycoretools (e.g. `flatten`); cleanup of old python2.x remnants
+- `spin_index` split into `left_spin_index` and `right_spin_index`
+
+### Fixed
+
+- Fixed issue where p-adic slice would have constraints applied only at leading digit
+- Fixed issue where `all_symmetries` would not return conjugation permutation when all little group weights were zero.
+- Fixed issue where `Particles.compute` did not recognized `<` and `>` symbols as alternatives for unicode angle brackets in spinor chains.
+
+### Deprecated
+
+- `flatten` should be imported from pycoretools
+- `Field` should be imported from syngular
+
+
 ## [0.5.1] - 2025-07-22
 
 ### Added
@@ -31,7 +64,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `seed` is no longer saved as a `Particles` attribute. WARNING: invalidates hash-tables.
 - `Particles.randomise` drasticaly simplified by using `field.random()` instead of handling all cases separately.
 - `spin_index` now saves both the position ('u' or 'd') and the value (1, 2, or all). If this was used explicitly it will require a simple fix to restore compatibility.
-- twistor functions, `randomise_twist` and `comp_twist_x` are not implemented in a covariant formulation.
+- twistor functions, `randomise_twist` and `comp_twist_x` are now implemented in a covariant formulation.
 
 ### Fixed
 
@@ -171,7 +204,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Numerical computation of Lorentz invariant spinor strings.
 
 
-[unreleased]: https://github.com/GDeLaurentis/lips/compare/v0.5.1...HEAD
+[unreleased]: https://github.com/GDeLaurentis/lips/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/GDeLaurentis/lips/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/GDeLaurentis/lips/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/GDeLaurentis/lips/compare/v0.4.5...v0.5.0
 [0.4.5]: https://github.com/GDeLaurentis/lips/compare/v0.4.4...v0.4.5

README.md

@@ -5,7 +5,7 @@
 [![Coverage](https://img.shields.io/badge/Coverage-81%25-greenyellow?labelColor=2a2f35)](https://github.com/GDeLaurentis/lips/actions)
 [![Docs](https://github.com/GDeLaurentis/lips/actions/workflows/cd_docs.yml/badge.svg?label=Docs)](https://gdelaurentis.github.io/lips/)
 [![PyPI](https://img.shields.io/pypi/v/lips?label=PyPI)](https://pypi.org/project/lips/)
-[![PyPI Downloads](https://img.shields.io/pypi/dm/lips.svg?label=PyPI%20downloads)](https://pypi.org/project/lips/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/lips.svg?label=PyPI%20downloads)](https://pypistats.org/packages/lips)
 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/GDeLaurentis/lips/HEAD)
 [![DOI](https://zenodo.org/badge/210320784.svg)](https://zenodo.org/doi/10.5281/zenodo.11518261)
 [![Python](https://img.shields.io/pypi/pyversions/lips?label=Python)](https://pypi.org/project/lips/)

lips/__init__.py

@@ -16,12 +16,52 @@
    oParticles.set_pair(spinor_string_1, small_value_1, spinor_string_2, small_value_2)
 """
 
-from syngular import Field                       # noqa
-
-from .version import __version__                 # noqa
-from .particle import Particle                   # noqa
-from .particles import Particles                 # noqa
-from .tools import myException, ldot, flatten    # noqa
-from .invariants import Invariants               # noqa
+from .version import __version__
+from .particle import Particle
+from .particles import Particles
+from .tools import myException, ldot
+from .invariants import Invariants
 
 spinor_convention = 'symmetric'  # or 'asymmetric'
+conjugation_acts_on_spin_indices = False
+
+__all__ = [
+    "__version__",
+    "Particle",
+    "Particles",
+    "myException",
+    "ldot",
+    "Invariants",
+]
+
+
+# Back-compatibility - to be removed
+
+import warnings  # noqa
+
+
+def __getattr__(name):
+    if name in {"flatten", }:
+        warnings.warn(
+            f"lips.{name} is deprecated and will be removed in a future release; "
+            f"use pycoretools.iterables.{name} (or: from pycoretools import {name}).",
+            FutureWarning,
+            stacklevel=2,
+        )
+        from pycoretools import iterables
+        return getattr(iterables, name)
+    if name in {"Field", }:
+        warnings.warn(
+            "lips.Field is deprecated and will be removed in a future release; "
+            "use syngular.Field instead.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        from syngular import Field
+        return Field
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__():
+    return sorted(list(globals().keys()) + ["flatten", "Field", ])

lips/algebraic_geometry/covariant_ideal.py

@@ -5,7 +5,7 @@
 
 from collections import defaultdict
 
-from lips.tools import flatten
+from pycoretools import flatten
 from lips.algebraic_geometry.tools import lips_covariant_symbols, lips_invariant_symbols, conversionIdeal
 from lips.algebraic_geometry.invariant_ideal import SpinorIdeal
 from syngular import Ideal, Ring
@@ -17,23 +17,36 @@
 class LipsIdeal(Ideal):
     """Lorentz Covariant Ideal - based on spinor components."""
 
-    def __init__(self, ring_or_multiplicity, generators_or_covariants, momentum_conservation=None):
-        """Initialises a fully analytical Ideal, either from a tuple of covariants, or from a list of generators."""
+    def __init__(self, ring_or_multiplicity, generators_or_covariants, momentum_conservation=None, verbose=False):
+        """Initialises a fully analytical Ideal, generators_or_covariants can be either already parsed in term spinor components or not."""
+        from lips import Particles
 
         if isinstance(ring_or_multiplicity, int):
             self.multiplicity = ring_or_multiplicity
+            ring = Ring('0', lips_covariant_symbols(self.multiplicity), 'dp')
         elif isinstance(ring_or_multiplicity, Ring):
             self.multiplicity = len(ring_or_multiplicity.variables) // 2 // 2
+            ring = ring_or_multiplicity
         else:
             raise Exception("Invalid LipsIdeal intialisation.")
 
-        if type(generators_or_covariants) is tuple:
-            from lips import Particles
+        try:
+            if (isinstance(generators_or_covariants, (list, tuple)) and len(generators_or_covariants) == 0 and
+               (momentum_conservation is True or momentum_conservation is None)):
+                raise Exception("Add momentum conservation.")
+            if (isinstance(generators_or_covariants, (list, tuple)) and len(generators_or_covariants) > 0 and
+               any([symbol in eq for symbol in ['[', ']', '|', '<', '>', '⟨', '⟩', ] for eq in generators_or_covariants])):
+                raise Exception("Needs parsing.")
+            # already in the ring variables
+            super().__init__(ring, generators_or_covariants)
+        except Exception:
+            # parse first the spinor expressions
             oParticles = Particles(self.multiplicity)
             oParticles.make_analytical_d()
             generators = []
             for covariant in generators_or_covariants:
-                poly_or_polys = 4 * oParticles(covariant)  # TODO: remove 4 * when https://github.com/sympy/sympy/pull/28139 is accepted
+                # TODO: remove 4 * when https://github.com/sympy/sympy/pull/28139 is accepted
+                poly_or_polys = 4 * oParticles(covariant)
                 if hasattr(poly_or_polys, 'shape'):
                     polys = flatten(poly_or_polys)
                     for poly in polys:
@@ -42,17 +55,10 @@ def __init__(self, ring_or_multiplicity, generators_or_covariants, momentum_cons
                     generators += [str(sympy.Poly(sympy.expand(poly_or_polys))).replace("Poly(", "").split(", ")[0]]
             if momentum_conservation is True or momentum_conservation is None:
                 generators += [str(sympy.Poly(entry)).replace("Poly(", "").split(", ")[0] for entry in flatten(oParticles.total_mom)]
+            super().__init__(ring, generators)
 
-        elif type(generators_or_covariants) is list:
-            generators = generators_or_covariants
-
-        else:
-            raise Exception("Invalid LipsIdeal intialisation.")
-
-        if isinstance(ring_or_multiplicity, int):
-            super().__init__(Ring('0', lips_covariant_symbols(self.multiplicity), 'dp'), generators)
-        elif isinstance(ring_or_multiplicity, Ring):
-            super().__init__(ring_or_multiplicity, generators)
+        if verbose:
+            print("Initialized Lips Ideal:\n", repr(self))
 
     def __contains__(self, covariant):
         """Extends ideal membership to Lorentz covariant expressions computable with lips."""

lips/algebraic_geometry/particles_singular_variety.py

@@ -1,9 +1,8 @@
 import numpy
 
+from pycoretools import flatten
 from pyadic import ModP, PAdic
 
-from ..tools import flatten
-
 from .covariant_ideal import LipsIdeal
 
 

lips/hardcoded_limits/particles_set.py

@@ -10,7 +10,8 @@
 import numpy
 import re
 
-from ..tools import flatten, pSijk, pDijk, pOijk, pPijk, pA2, pS2, pNB, ptr5, p5Bdiff, myException
+from pycoretools import flatten
+from ..tools import pSijk, pDijk, pOijk, pPijk, pA2, pS2, pNB, ptr5, p5Bdiff, myException
 
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

lips/hardcoded_limits/particles_set_pair.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 #   ___          _   _    _          ___      _   ___      _
 #  | _ \__ _ _ _| |_(_)__| |___ ___ / __| ___| |_| _ \__ _(_)_ _
 #  |  _/ _` | '_|  _| / _| / -_|_-<_\__ \/ -_)  _|  _/ _` | | '_|
@@ -10,7 +8,8 @@
 import numpy
 import mpmath
 
-from ..tools import flatten, pSijk, pDijk, pA2, pS2, p3B, pNB, myException
+from pycoretools import flatten
+from ..tools import pSijk, pDijk, pA2, pS2, p3B, pNB, myException
 
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #

lips/invariants.py

@@ -1,6 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
 #   ___                  _          _                                    _
 #  |_ _|_ ___ ____ _ _ _(_)__ _ _ _| |_ ___   __ _ ___ _ _  ___ _ _ __ _| |_ ___ _ _
 #   | || ' \ V / _` | '_| / _` | ' \  _(_-<  / _` / -_) ' \/ -_) '_/ _` |  _/ _ \ '_|

lips/particle.py

@@ -12,11 +12,11 @@
 from copy import copy
 from sympy import NotInvertible
 
+from pycoretools import flatten
 from syngular import Field
-
 from pyadic.field_extension import FieldExtension
 
-from .tools import MinkowskiMetric, LeviCivita, rand_frac, Pauli, Pauli_bar, flatten
+from .tools import MinkowskiMetric, LeviCivita, rand_frac, Pauli, Pauli_bar
 
 
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
@@ -110,10 +110,10 @@ def __getitem__(self, key):
         return self.four_mom[key]
 
     def __hash__(self):
-        if abs(self.m2) <= self.field.tollerance:
+        if self.is_massless:
             return hash(tuple([tuple(self.r_sp_d.flatten()), tuple(self.l_sp_d.flatten())]))
         else:
-            return hash(tuple(self.r2_sp.flatten()))
+            return hash(tuple([tuple(self.r2_sp.flatten()), tuple(self.r_sp_d.flatten()), tuple(self.l_sp_d.flatten())]))
 
     # GETTERS and SETTERS
 
@@ -299,6 +299,14 @@ def four_mom_d(self, temp_four_mom_d):
             self._l_sp_u = None
             self._l_sp_d = None
 
+    @property
+    def spin_index(self):
+        raise Exception("Spin index is set only - access left_spin_index and right_spin_index separately.")
+
+    @spin_index.setter
+    def spin_index(self, value):
+        self.left_spin_index = self.right_spin_index = value
+
     # PUBLIC METHODS
 
     def randomise(self, real_momentum=False):
@@ -331,13 +339,28 @@ 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
             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[0] == 'u':
+            if hasattr(self, '_l_sp_d_all') and hasattr(self, '_r_sp_d_all'):
+                self._l_sp_d_all, self._r_sp_d_all = self._r_sp_d_all.T, self._l_sp_d_all.T
+            if lips.conjugation_acts_on_spin_indices and hasattr(self, 'right_spin_index') and hasattr(self, 'left_spin_index'):
+                # see arXiv:2309.03323 - A.28 and A.29
+                if self.left_spin_index[0] == 'u':  # [i|
+                    self.left_spin_index = ('d',) + self.left_spin_index[1:]
                     self._l_sp_d *= -1
-                elif self.spin_index[0] == 'd':
+                    if hasattr(self, '_l_sp_d_all'):
+                        self._l_sp_d_all *= -1
+                elif self.left_spin_index[0] == 'd':
+                    self.left_spin_index = ('u',) + self.left_spin_index[1:]
+                else:
+                    raise Exception(f"Left spin index not understood: {self.left_spin_index[0]}")
+                if self.right_spin_index[0] == 'd':  # |i⟩
+                    self.right_spin_index = ('u',) + self.right_spin_index[1:]
                     self._r_sp_d *= -1
+                    if hasattr(self, '_r_sp_d_all'):
+                        self._r_sp_d_all *= -1
+                elif self.right_spin_index[0] == 'u':
+                    self.right_spin_index = ('d',) + self.right_spin_index[1:]
                 else:
-                    raise Exception("Spin index not understood.")
+                    raise Exception(f"Right spin index not understood: {self.right_spin_index[0]}")
             self._sps_d_to_sps_u()
         self._r2_sp = self._r2_sp.T
         self._r2_sp_b = self._r2_sp_b.T
@@ -483,3 +506,9 @@ def m2(self):
     @property
     def m(self):
         return self.field.sqrt(self.lsq())
+
+    @property
+    def is_massless(self):
+        return (self.m2 in self.field and abs(self.m2) <= self.field.tollerance) or (self.m2 == 0)
+
+    is_lightlike = is_massless