New mapping class hierarchy (sympde part)

.github/workflows/testing.yml

@@ -84,3 +84,37 @@ jobs:
       working-directory: ./scratch
       run: |
         coverage report --ignore-errors --show-missing --sort=cover
+
+  minimum-sympy:
+    name: Ubuntu / Python 3.11 / SymPy 1.12
+    runs-on: ubuntu-24.04
+
+    steps:
+    - uses: actions/checkout@v6
+
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v6
+      with:
+        python-version: '3.11'
+        cache: 'pip'
+        cache-dependency-path: |
+          pyproject.toml
+
+    - name: Upgrade pip, setuptools, and wheel
+      run: |
+        pip install --upgrade pip setuptools wheel
+
+    - name: Install project with minimum SymPy
+      run: |
+        pip install .[test] 'sympy == 1.12'
+        pip freeze
+
+    - name: Initialize test directory
+      run: |
+        mkdir scratch
+
+    - name: Run tests
+      working-directory: ./scratch
+      run: >-
+        pytest -n auto --dist loadgroup
+        --pyargs sympde -ra

CHANGELOG.md

@@ -14,13 +14,19 @@ All notable changes to this project will be documented in this file.
 ### Changed
 
 - Convert the README to Markdown and expand the installation, testing, and documentation-build instructions.
+- #106: Require SymPy 1.12 or newer and support maintained SymPy releases below 1.15.
+- #106: Update SymPDE's symbolic objects for modern SymPy's structural arguments, traversal, substitution, and reconstruction requirements.
 - [DEVELOPER] Modernize the package metadata and consolidate the pytest and coverage configuration in `pyproject.toml`.
 - [DEVELOPER] Modernize the Sphinx configuration, API-documentation generation, and API docstring markup.
+- [DEVELOPER] Test the minimum supported SymPy version in a dedicated CI job.
 
 ### Fixed
 
 - #140: Fix the rendering of the `Domain.join()` API documentation.
 - #166: Restore warning-free documentation builds, including bibliography and mathematical notation support.
+- #106: Preserve symbol assumptions and free-symbol information with modern SymPy.
+- #106: Keep same-named functions from different function spaces distinct during symbolic simplification.
+- #106: Fix form-linearity checks involving integral sums with modern SymPy.
 
 ### Removed
 

pyproject.toml

@@ -24,7 +24,7 @@ classifiers  = [
     "Topic :: Scientific/Engineering :: Mathematics",
 ]
 dependencies = [
-    'sympy >= 1.5, < 1.10',
+    'sympy >= 1.12, < 1.15',
     'h5py',
     'pyyaml',
     'numpy',

sympde/calculus/core.py

@@ -102,8 +102,8 @@
 from sympy.core.containers    import Tuple
 from sympy.core.singleton     import S
 from sympy.core.decorators    import call_highest_priority
+from sympy.utilities.iterables import is_sequence
 
-from sympde.old_sympy_utilities import is_sequence
 from sympde.core.basic        import CalculusFunction
 from sympde.core.basic        import _coeffs_registery
 from sympde.topology.space    import ScalarFunction, VectorFunction
@@ -1860,4 +1860,3 @@ def add_basicop(expr):
 Basic._constructor_postprocessor_mapping[BasicOperator] = {
     "Add": [add_basicop],
 }
-

sympde/calculus/matrices.py

@@ -2,7 +2,7 @@
 from sympy                 import Add, Mul, Pow
 from sympy                 import sympify
 from sympy.core.decorators import call_highest_priority
-from sympde.core.basic     import _coeffs_registery, Basic
+from sympde.core.basic     import _coeffs_registery, _new_basic, Basic
 
 class MatrixSymbolicExpr(Expr):
     is_commutative = False
@@ -275,7 +275,7 @@ def _sympystr(self, printer):
 
 class MatrixElement(Expr):
     def __new__(cls, base, indices, **options):
-        return Expr.__new__(cls, base, indices)
+        return _new_basic(cls, base, indices)
 
     @property
     def base(self):
@@ -293,4 +293,3 @@ def _sympystr(self, printer):
     "Mul": [lambda x: MatSymbolicMul(*x.args)],
     "Add": [lambda x: MatSymbolicAdd(*x.args)]
 }
-

sympde/core/algebra.py

@@ -33,8 +33,8 @@
 from sympy import S
 from sympy import Basic
 from sympy import Indexed, IndexedBase
+from sympy.utilities.iterables import is_sequence
 
-from sympde.old_sympy_utilities import is_sequence
 from .basic import CalculusFunction
 from .basic import _coeffs_registery
 

sympde/core/basic.py

@@ -3,9 +3,78 @@
 from sympy        import Function
 from sympy        import Number
 from sympy        import NumberSymbol
+from sympy        import Integer
+from sympy        import sympify
 from sympy.core   import Basic
 from sympy.core   import Symbol
-from sympy.tensor import IndexedBase
+from sympy.core.containers import Dict, Tuple
+from sympy.core.symbol import Str
+
+
+class _NoneArgument(Basic):
+    """SymPy-compatible representation of ``None`` in expression arguments."""
+
+
+_none = _NoneArgument()
+
+
+def _sympify_argument(value):
+    """Convert structural metadata to objects accepted in ``Basic.args``."""
+    if isinstance(value, Basic):
+        return value
+    if value is None:
+        return _none
+    if isinstance(value, str):
+        return Str(value)
+    if isinstance(value, dict):
+        return Dict(*((_sympify_argument(k), _sympify_argument(v))
+                      for k, v in value.items()))
+    if isinstance(value, (tuple, list)):
+        return Tuple(*(_sympify_argument(v) for v in value))
+    return sympify(value)
+
+
+def _new_basic(cls, *args, **options):
+    """Construct a ``Basic`` after normalizing all structural arguments."""
+    args = tuple(_sympify_argument(arg) for arg in args)
+    return Basic.__new__(cls, *args, **options)
+
+
+def _is_none_argument(value):
+    return value is _none
+
+
+def _restore_optional_argument(value):
+    """Restore an optional value stored in a symbolic argument list."""
+    return None if _is_none_argument(value) else value
+
+
+def _restore_string_argument(value):
+    """Restore a Python string stored as a SymPy ``Str`` object."""
+    return value.name if isinstance(value, Str) else value
+
+
+def _restore_int_argument(value):
+    """Restore a Python integer stored as a SymPy ``Integer`` object."""
+    value = _restore_optional_argument(value)
+    return int(value) if isinstance(value, Integer) else value
+
+
+def _restore_container_argument(value):
+    """Restore Python containers used as non-expression metadata."""
+    value = _restore_optional_argument(value)
+    if isinstance(value, Str):
+        return value.name
+    if isinstance(value, Dict):
+        return {
+            _restore_container_argument(k): _restore_container_argument(v)
+            for k, v in value.items()
+        }
+    if isinstance(value, Tuple):
+        return tuple(_restore_container_argument(v) for v in value)
+    if isinstance(value, Integer):
+        return int(value)
+    return value
 
 #==============================================================================
 class Constant(Symbol):
@@ -34,13 +103,6 @@ class CalculusFunction(Function):
     functions when manipulating our expressions"""
     pass
 
-#==============================================================================
-class BasicMapping(IndexedBase):
-    """
-    Represents a basic class for mapping.
-    """
-    pass
-
 #==============================================================================
 class BasicDerivable(Basic):
     pass

sympde/expr/equation.py

@@ -13,6 +13,11 @@
 from sympde.topology import Trace, trace_0, trace_1
 from sympde.calculus import grad, dot
 from sympde.core.utils import random_string
+from sympde.core.basic import (
+    _is_none_argument,
+    _new_basic,
+    _restore_optional_argument,
+)
 
 from .expr import BilinearForm, LinearForm
 from .expr import linearize
@@ -191,6 +196,8 @@ def rhs(self):
 class Equation(Basic):
 
     def __new__(cls, lhs, rhs, trials, tests, bc=None, constraint=None):
+        bc = _restore_optional_argument(bc)
+        constraint = _restore_optional_argument(constraint)
         # ...
         if not isinstance(lhs, BilinearForm):
             raise UnconsistentLhsError('> lhs must be a bilinear')
@@ -332,7 +339,7 @@ def __new__(cls, lhs, rhs, trials, tests, bc=None, constraint=None):
         tests  = Tuple(*tests)
         # ...
 
-        return Basic.__new__(cls, lhs, rhs, trials, tests, bc, constraint)
+        return _new_basic(cls, lhs, rhs, trials, tests, bc, constraint)
 
     @property
     def lhs(self):
@@ -352,11 +359,13 @@ def test_functions(self):
 
     @property
     def bc(self):
-        return self._args[4]
+        bc = self._args[4]
+        return None if _is_none_argument(bc) else bc
 
     @property
     def constraint(self):
-        return self._args[5]
+        constraint = self._args[5]
+        return None if _is_none_argument(constraint) else constraint
 
 #==============================================================================
 # TODO must subtitute expr by given args => call then create BasicForm

sympde/expr/evaluation.py

@@ -8,6 +8,7 @@
 
 from sympde.core.basic import _coeffs_registery
 from sympde.core.basic import CalculusFunction
+from sympde.core.basic import _new_basic
 from sympde.core.algebra import (Dot_1d,
                                  Dot_2d, Inner_2d, Cross_2d,
                                  Dot_3d, Inner_3d, Cross_3d)
@@ -973,15 +974,15 @@ def _tensorize_atomic_expr(expr, d_atoms):
 class Basic1dForm(AtomicExpr):
 
     def __new__(cls, name, axis, weight=S.One):
-        return Basic.__new__(cls, name, axis, weight)
+        return _new_basic(cls, name, axis, weight)
 
     @property
     def name(self):
-        return self._args[0]
+        return self._args[0].name
 
     @property
     def axis(self):
-        return self._args[1]
+        return int(self._args[1])
 
     @property
     def weight(self):
@@ -1003,38 +1004,48 @@ def _sympystr(self, printer):
 
 class Mass(Basic1dForm):
 
-    def __new__(cls, axis, weight=S.One):
+    def __new__(cls, axis, weight=S.One, *structural_args):
+        if structural_args:
+            return Basic1dForm.__new__(cls, axis, weight, *structural_args)
 #        name = 'Mass'
         name = 'M'
-        return Basic.__new__(cls, name, axis, weight)
+        return Basic1dForm.__new__(cls, name, axis, weight)
 
 class Stiffness(Basic1dForm):
 
-    def __new__(cls, axis, weight=S.One):
+    def __new__(cls, axis, weight=S.One, *structural_args):
+        if structural_args:
+            return Basic1dForm.__new__(cls, axis, weight, *structural_args)
 #        name = 'Stiffness'
         name = 'S'
-        return Basic.__new__(cls, name, axis, weight)
+        return Basic1dForm.__new__(cls, name, axis, weight)
 
 class Advection(Basic1dForm):
 
-    def __new__(cls, axis, weight=S.One):
+    def __new__(cls, axis, weight=S.One, *structural_args):
+        if structural_args:
+            return Basic1dForm.__new__(cls, axis, weight, *structural_args)
 #        name = 'Advection'
         name = 'A'
-        return Basic.__new__(cls, name, axis, weight)
+        return Basic1dForm.__new__(cls, name, axis, weight)
 
 class AdvectionT(Basic1dForm):
 
-    def __new__(cls, axis, weight=S.One):
+    def __new__(cls, axis, weight=S.One, *structural_args):
+        if structural_args:
+            return Basic1dForm.__new__(cls, axis, weight, *structural_args)
 #        name = 'AdvectionT'
         name = 'AT'
-        return Basic.__new__(cls, name, axis, weight)
+        return Basic1dForm.__new__(cls, name, axis, weight)
 
 class Bilaplacian(Basic1dForm):
 
-    def __new__(cls, axis, weight=S.One):
+    def __new__(cls, axis, weight=S.One, *structural_args):
+        if structural_args:
+            return Basic1dForm.__new__(cls, axis, weight, *structural_args)
 #        name = 'Bilaplacian'
         name = 'B'
-        return Basic.__new__(cls, name, axis, weight)
+        return Basic1dForm.__new__(cls, name, axis, weight)
 
 
 Mass_0 = Mass(0)

sympde/expr/expr.py

@@ -9,8 +9,8 @@
 from sympy.core import Expr, Add, Mul
 from sympy.core.numbers import Zero as sy_Zero
 from sympy.core.containers import Tuple
+from sympy.utilities.iterables import is_sequence
 
-from sympde.old_sympy_utilities import is_sequence
 from sympde.core.basic import CalculusFunction
 from sympde.core.basic import Constant
 from sympde.core.utils import random_string
@@ -402,7 +402,7 @@ def __call__(self, *tests, **kwargs):
         # Make sure that 'values' is always a list
         if len(tests) == 1:
             values = tests[0]
-            if not is_sequence(values, vector=isinstance(values, VectorFunction)):
+            if isinstance(values, VectorFunction) or not is_sequence(values):
                 values = [values]
         else:
             values = tests
@@ -513,8 +513,8 @@ def __call__(self, trials, tests, **kwargs):
         expr = self._update_free_variables(**kwargs)
 
         # If needed, convert positional arguments to lists
-        if not is_sequence(trials, vector=isinstance(trials, VectorFunction)): trials = [trials]
-        if not is_sequence(tests, vector=isinstance(tests, VectorFunction)): tests  = [tests ]
+        if isinstance(trials, VectorFunction) or not is_sequence(trials): trials = [trials]
+        if isinstance(tests, VectorFunction) or not is_sequence(tests): tests  = [tests ]
 
         # Concatenate input values into single list
         values = [*trials, *tests]
@@ -855,7 +855,7 @@ def mul_integral(expr):
 def mul_add(expr):
     args_int = [a for a in expr.args if isinstance(a, IntAdd)]
     coeff    = Mul(*[a for a in expr.args if not a in args_int])
-    args_int[0] = [IntAdd(*[coeff*i for i in args_int[0].args])]
+    args_int[0] = IntAdd(*[coeff*i for i in args_int[0].args])
     return Mul(*args_int)
 
 def add_int(expr):

sympde/expr/tests/test_equation_2d.py

@@ -109,6 +109,7 @@ def test_equation_2d_1():
     a = BilinearForm((v,u), a1(v,u) + a_B1(v,u))
     l = LinearForm(v, l1(v) + l2(v))
     equation = Equation(a, l, tests=v, trials=u)
+    assert equation.func(*equation.args) == equation
     # ...
 
     # ...
@@ -415,4 +416,3 @@ def teardown_module():
 def teardown_function():
     from sympy.core import cache
     cache.clear_cache()
-