triples 0.2.0__tar.gz → 0.3.0__tar.gz

{triples-0.2.0 → triples-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: triples
-Version: 0.2.0
+Version: 0.3.0
 Summary: Automatic sum-of-squares proofs for algebraic inequalities
 Author-email: ForeverHaibara <1378855363@qq.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{triples-0.2.0 → triples-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "triples"
-version = "0.2.0"
+version = "0.3.0"
 description = "Automatic sum-of-squares proofs for algebraic inequalities"
 readme = "notebooks/README_pypi.md"
 license = {file = "LICENSE"}
@@ -46,6 +46,44 @@ include = ["triples*"]
 [tool.setuptools.package-data]
 triples = ["**/*.npz"]
 
+[tool.mypy]
+# mypy 2.3 no longer supports Python 3.6 as a checking target.  Keep the
+# source annotations Python 3.6-compatible while using the oldest target
+# supported by the installed checker.
+python_version = "3.10"
+files = ["triples/core", "triples/utils", "triples/sdp"]
+exclude = "(^|/)(benchmarks|gui|testing|tests)(/|$)"
+show_error_codes = true
+warn_unused_ignores = true
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = [
+    "scipy",
+    "scipy.*",
+    "mpmath",
+    "mpmath.*",
+    "pandas",
+    "pandas.*",
+    "tqdm",
+    "tqdm.*",
+    "clarabel",
+    "clarabel.*",
+    "cvxopt",
+    "cvxopt.*",
+    "cvxpy",
+    "cvxpy.*",
+    "mosek",
+    "mosek.*",
+    "picos",
+    "picos.*",
+    "qics",
+    "qics.*",
+    "sdpap",
+    "sdpap.*",
+]
+ignore_missing_imports = true
+
 [tool.ruff]
 # from SymPy
 lint.select = [
@@ -100,3 +138,6 @@ exclude = ["triples/benchmarks/run_benchmark.py"]
 [tool.ruff.lint.flake8-type-checking]
 quote-annotations = true
 strict = true
+
+# [tool.ruff.lint.isort]
+# relative-imports-order = "closest-to-furthest"

{triples-0.2.0 → triples-0.3.0}/triples/__init__.py

@@ -4,7 +4,7 @@ from .core import sum_of_squares, StructuralSOS, LinearSOS, SDPSOS, SOSPoly
 
 from .sdp import SDPProblem, congruence
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     '__version__',

{triples-0.2.0 → triples-0.3.0}/triples/benchmarks/problems/books/vasile.py

@@ -739,7 +739,6 @@ class MathematicalInequalitiesVol1(MathematicalInequalities):
     def problem_vasile_p13098(self):
         return c4p(a-1) - (x-1)**4, [a,b,c,d], [c4s(1/a**2) - 4/x**2]
 
-    @mark(mark.skip)
     def problem_vasile_p13099(self):
         return c4p((1+a**3)/(1+a**2)) - (1+c4p(a))/2, [a,b,c,d], []
 
@@ -806,15 +805,12 @@ class MathematicalInequalitiesVol1(MathematicalInequalities):
     def problem_vasile_p13115(self):
         return 31*c5s(a**2)-150-c5s(a**4), [a,b,c,d,e], [c5s(a)-5]
 
-    @mark(mark.skip)
     def problem_vasile_p13116(self):
         return 5 - c5p(a)*c5s(a**4), [a,b,c,d,e], [c5s(a**2)-5]
 
-    @mark(mark.skip)
     def problem_vasile_p13117(self):
         return c5s(1/a) + 20/c5s(a**2) - 9, [a,b,c,d,e], [c5s(a)-5]
 
-    @mark(mark.skip)
     def problem_vasile_p13118(self):
         return c5p(a+1/a) + 68 - 4*c5s(a)*c5s(1/a), [a-1,b-1,c-1,d-1,e-1], []
 
@@ -1005,11 +1001,9 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21042_p1(self):
         return Rational(3,2) - c3s(1/(3-a*b)), [a,b,c], [c3s(a**2)-3]
 
-    @mark(mark.skip)
     def problem_vasile_p21042_p2(self):
         return 3/(sqrt(6)-1) - c3s(1/(sqrt(6)-a*b)), [a,b,c], [c3s(a**2)-3]
 
-    @mark(mark.skip)
     def problem_vasile_p21043(self):
         return c3s(1/(1+a**5)) - Rational(3,2), [a,b,c], [c3s(a**2)-3]
 
@@ -1122,7 +1116,6 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21071(self):
         return c3s((a*b+(k-1)*b*c+c*a)/(b**2+k*b*c+c**2)) - 3*(k+1)/(k+2), [a,b,c,k+2], []
 
-    @mark(mark.skip)
     def problem_vasile_p21072(self):
         return 3/(k+2) - c3s((3*b*c-a*(b+c))/(b**2+k*b*c+c**2)), [a,b,c,k+2], []
 
@@ -1153,11 +1146,9 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21081(self):
         return c3s((2*a**2+5*b*c)/(b+c)**2) - Rational(21,4), [a,b,c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21082(self):
         return c3s((2*a**2+(2*k+1)*b*c)/(b**2+k*b*c+c**2)) - 3*(2*k+3)/(k+2), [a,b,c,k+2], []
 
-    @mark(mark.skip)
     def problem_vasile_p21083(self):
         return 3/(k+2) - c3s((3*b*c-2*a**2)/(b**2+k*b*c+c**2)), [a,b,c,k+2], []
 
@@ -1170,11 +1161,9 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21086(self):
         return c3s((a**2+64*b*c)/(b+c)**2) - 18, [a,b,c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21087(self):
         return c3s((a**2*(b+c)+k*a*b*c)/(b**2+k*b*c+c**2)) - c3s(a), [a,b,c,k+1], []
 
-    @mark(mark.skip)
     def problem_vasile_p21088(self):
         return c3s((a**3+(k+1)*a*b*c)/(b**2+k*b*c+c**2)) - c3s(a), [a,b,c,k+Rational(3,2)], []
 
@@ -1194,15 +1183,12 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21092(self):
         return c3s((b**2+c**2-a**2)/(2*a**2+(b+c)**2)) - Rational(1,2), [a,b,c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21093(self):
         return 3/k - c3s((3*a**2-2*b*c)/(k*a**2+(b-c)**2)), [a,b,c,k], []
 
-    @mark(mark.skip)
     def problem_vasile_p21094_p1(self):
         return c3s(a/(a**2+k*b*c)) - 9/c3s(a)/(1+k), [a,b,c,k-3-sqrt(7)], []
 
-    @mark(mark.skip)
     def problem_vasile_p21094_p2(self):
         return c3s(a/(k*a**2+b*c)) - 9/c3s(a)/(1+k), [a,b,c,k-3-sqrt(7)], []
 
@@ -1281,11 +1267,9 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21114(self):
         return 9/c3s(a*b)/2 - c3s(1/(b**2+c**2)), [b+c-a,c+a-b,a+b-c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21115_p1(self):
         return Abs(c3s((a+b)/(a-b))) - 5, [b+c-a,c+a-b,a+b-c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21115_p2(self):
         return Abs(c3s((a**2+b**2)/(a**2-b**2))) - 3, [b+c-a,c+a-b,a+b-c], []
 
@@ -1298,7 +1282,6 @@ class MathematicalInequalitiesVol2(MathematicalInequalities):
     def problem_vasile_p21118(self):
         return c3s((a*(b+c)-2*b*c)/((b+c)*(3*a+b+c))), [a,b,c], []
 
-    @mark(mark.skip)
     def problem_vasile_p21119(self):
         return c3s((a**5-a**2)/(a**5+b**2+c**2)), [a,b,c,c3s(a**2)-3], []
 
@@ -2335,7 +2318,6 @@ class MathematicalInequalitiesVol3(MathematicalInequalities):
     def problem_vasile_p31087_p2(self):
         return c3s(1/a/sqrt(a+8*b)) - sqrt(1/c3p(a)), [a,b,c], []
 
-    @mark(mark.skip)
     def problem_vasile_p31088(self):
         return sqrt(c3s(a)/3) - c3s(a/sqrt(5*a+4*b)), [a,b,c], []
 
@@ -2613,7 +2595,6 @@ class MathematicalInequalitiesVol3(MathematicalInequalities):
     def problem_vasile_p31160(self):
         return c4p(1+2*a/(b+c)) - 9, [a,b,c,d] ,[]
 
-    @mark(mark.skip)
     def problem_vasile_p31161(self):
         return c4p(1+k*a/(b+c)) - (1+k)**2, [a,b,c,d,k], []
 
@@ -2651,7 +2632,7 @@ class MathematicalInequalitiesVol3(MathematicalInequalities):
     def problem_vasile_p31172_p1(self):
         return (sqrt(5)-1)/4 - c5s(a*b)/c5s(a**2), [], [c5s(a)]
 
-    def problem_vasile_p31172_p1(self):
+    def problem_vasile_p31172_p2(self):
         return (sqrt(5)+1)/4 + c5s(a*b)/c5s(a**2), [], [c5s(a)]
 
     def problem_vasile_p31173(self):
@@ -3033,7 +3014,6 @@ class MathematicalInequalitiesVol3(MathematicalInequalities):
         return x + y + z - sqrt(4*(a + b + c + sqrt(a*b) + sqrt(b*c) + sqrt(c*a)) + 3*(a*b*c)**Rational(1,3)), [a,b,c,x,y,z],\
             [a/(y*z) + b/(z*x) + c/(x*y) - 1]
 
-    @mark(mark.skip)
     def problem_vasile_p32080_p2(self):
         return x + y + z - (sqrt(a + b) + sqrt(b + c) + sqrt(c + a)), [a,b,c,x,y,z], [a/(y*z) + b/(z*x) + c/(x*y) - 1]
 

{triples-0.2.0 → triples-0.3.0}/triples/core/dispatch.py

@@ -10,11 +10,11 @@ To control the behaviour of `InequalityProblem` on new types, you can either:
 from functools import singledispatch
 from typing import (
     List, Tuple, Set, Optional, Callable,
-    Any, TypeVar, TYPE_CHECKING
+    Any, TYPE_CHECKING, cast
 )
 
 from sympy import (
-    Expr, Dummy, Poly, Integer, Add, Mul,
+    Expr, Dummy, Poly, Integer, Add, Mul, Pow,
     sympify, signsimp
 )
 from sympy import __version__ as SYMPY_VERSION
@@ -35,15 +35,17 @@ else:
     _sqf_list = lambda p: p.factor_list() # it would be slower, but correct
 
 if SYMPY_VERSION_TUPLE >= (1, 14):
-    _polyelement_init = PolyElement
-    _fracelement_init = FracElement
+    _polyelement_init = cast(Callable[..., Any], PolyElement)
+    _fracelement_init = cast(Callable[..., Any], FracElement)
 else:
-    def _polyelement_init(ring, init):
+    def _polyelement_init_legacy(ring, init):
         return ring.zero.new(init)
-    def _fracelement_init(field, numer, denom):
+    def _fracelement_init_legacy(field, numer, denom):
         obj = object.__new__(FracElement)
         obj.field, obj.numer, obj.denom = field, numer, denom
         return obj
+    _polyelement_init = _polyelement_init_legacy
+    _fracelement_init = _fracelement_init_legacy
 
 from ..utils.expressions.exraw import HAS_EXRAW
 
@@ -53,39 +55,51 @@ if TYPE_CHECKING:
     )
     from sympy.combinatorics import Permutation
 
-T = TypeVar('T')
-
 @singledispatch
-def _dtype_free_symbols(x: T) -> Set['Symbol']:
+def _dtype_free_symbols(x: Any) -> Set['Symbol']:
     return x.free_symbols
 
 @singledispatch
-def _dtype_gens(x: T) -> Tuple['Symbol', ...]:
+def _dtype_gens(x: Any) -> Tuple['Symbol', ...]:
     return x.gens
 
 @singledispatch
-def _dtype_is_zero(x: T) -> Optional[bool]:
+def _dtype_is_zero(x: Any) -> Optional[bool]:
     return x.is_zero
 
 @singledispatch
-def _dtype_convert(x: T, y: Any) -> T:
+def _dtype_convert(x: Any, y: Any) -> Any:
     return x.convert(y)
 
 @singledispatch
-def _dtype_homogenize(x: T, s: 'Symbol') -> T:
+def _dtype_homogenize(x: Any, s: 'Symbol') -> Any:
     return x.homogenize(s)
 
 @singledispatch
-def _dtype_is_homogeneous(x: T) -> Optional[bool]:
+def _dtype_is_homogeneous(x: Any) -> Optional[bool]:
     return x.is_homogeneous
 
 @singledispatch
-def _dtype_sqf_list(x: T) -> Tuple[Expr, List[Tuple[T, int]]]:
+def _dtype_sqf_list(x: Any) -> Tuple[Expr, List[Tuple[Any, int]]]:
     return x.sqf_list()
 
 @singledispatch
-def _dtype_make_reorder_func(x: T, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], T]:
-    """Return a callable `f` such that `f(perm) == x.xreplace(dict(zip(gens, perm(gens))))`."""
+def _dtype_make_reorder_func(x: Any, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], Any]:
+    """
+    Return a callable `f` such that `f(perm) == x.xreplace(dict(zip(gens, perm(gens))))`.
+
+    Unlike `Poly.reorder`, this function changes the value of `x`.
+
+    Examples
+    --------
+    >>> from sympy.abc import a, b, c
+    >>> from sympy.combinatorics import Permutation
+    >>> x = (a+2*b+3*c).as_poly(a,b,c)
+    >>> x.reorder(b,c,a)
+    Poly(2*b + 3*c + a, b, c, a, domain='ZZ')
+    >>> _dtype_make_reorder_func(x, (a,b,c))(Permutation([1,2,0]))
+    Poly(3*a + b + 2*c, a, b, c, domain='ZZ')
+    """
     return lambda perm: x.xreplace(dict(zip(gens, perm(gens))))
 
 
@@ -114,14 +128,14 @@ def _expr_homogenize(x: Expr, s: 'Symbol') -> Expr:
             for a in xargs:
                 if a == s:
                     power += 1
-                elif a.is_Pow and a.base == s:
+                elif isinstance(a, Pow) and a.base == s:
                     power += a.exp
                 else:
                     other_args.append(a)
             return (power, Mul(*other_args))
         return (0, x)
 
-    def extract(x: Add) -> Add:
+    def extract(x: Add) -> Expr:
         """Collect all terms of an Add expression by the power of s."""
         args = Add.make_args(x)
         ex = [extract_mul(a) for a in args]
@@ -144,15 +158,21 @@ def _expr_is_homogeneous(x: Expr) -> Optional[bool]:
 @_dtype_sqf_list.register(Expr)
 def _expr_sqf_list(x: Expr) -> Tuple[Expr, List[Tuple[Expr, int]]]:
     if x.is_Mul:
-        return (Integer(1), [(a, 1) if not (a.is_Pow and a.exp.is_Rational)
-            else (a.base**(Integer(1)/a.exp.q), int(a.exp.p)) for a in x.args])
-    if x.is_Pow and x.exp.is_Rational:
+        factors = []
+        for arg in x.args:
+            a = cast(Expr, arg)
+            if isinstance(a, Pow) and a.exp.is_Rational:
+                factors.append((a.base**(Integer(1)/a.exp.q), int(a.exp.p)))
+            else:
+                factors.append((a, 1))
+        return Integer(1), factors
+    if isinstance(x, Pow) and x.exp.is_Rational:
         return (Integer(1), [(x.base**(Integer(1)/x.exp.q), int(x.exp.p))])
     return (Integer(1), [(x, 1)])
 
 @_dtype_make_reorder_func.register(Expr)
-def _expr_make_reorder_func(x: Expr, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], T]:
-    return lambda perm: signsimp(x.xreplace(dict(zip(gens, perm(gens)))))
+def _expr_make_reorder_func(x: Expr, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], Expr]:
+    return lambda perm: cast(Expr, signsimp(x.xreplace(dict(zip(gens, perm(gens))))))
 
 
 
@@ -170,7 +190,7 @@ def _poly_sqf_list(x: Poly) -> Tuple[Expr, List[Tuple[Poly, int]]]:
     return _sqf_list(x)
 
 @_dtype_make_reorder_func.register(Poly)
-def _poly_make_reorder_func(x: Poly, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], T]:
+def _poly_make_reorder_func(x: Poly, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], Poly]:
     if x.gens == gens:
         return lambda perm: Poly.new(x.reorder(*perm.__invert__()(gens)).rep, *gens)
     return lambda perm: Poly(x.as_expr().xreplace(dict(zip(gens, perm(gens)))), *gens)
@@ -195,7 +215,7 @@ def _polyelement_free_symbols(x: PolyElement) -> Set['Symbol']:
     symbols = {g for g, d in zip(x.ring.gens, x.degrees()) if d > 0}
     domain = x.ring.domain
     if domain.is_Composite:
-        for gen in domain.symbols:
+        for gen in domain.symbols: # type: ignore
             symbols |= gen.free_symbols
     elif domain.is_EX:
         for coeff in x.coeffs():
@@ -203,7 +223,7 @@ def _polyelement_free_symbols(x: PolyElement) -> Set['Symbol']:
     elif HAS_EXRAW and domain.is_EXRAW:
         for coeff in x.coeffs():
             symbols |= coeff.free_symbols
-    return symbols
+    return cast(Set['Symbol'], symbols)
 
 
 @_dtype_homogenize.register(PolyElement)
@@ -223,6 +243,12 @@ def _polyelement_is_homogeneous(x: PolyElement) -> bool:
     d = sum(monoms[0])
     return all(sum(m) == d for m in monoms)
 
+@_dtype_make_reorder_func.register(PolyElement)
+def _polyelement_make_reorder_func(x: PolyElement, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], PolyElement]:
+    def reorder(perm):
+        inv = perm.__invert__()._array_form
+        return x.new({tuple(m[i] for i in inv): v for m, v in x.items()})
+    return reorder
 
 
 @_dtype_free_symbols.register(FracElement)
@@ -242,3 +268,9 @@ def _fracelement_is_homogeneous(x: FracElement) -> bool:
 def _fracelement_homogenize(x: FracElement, s: 'Symbol') -> FracElement:
     numer, denom = _polyelement_homogenize(x.numer, s), _polyelement_homogenize(x.denom, s)
     return _fracelement_init(numer.ring.to_field(), *numer.cancel(denom))
+
+@_dtype_make_reorder_func.register(FracElement)
+def _fracelement_make_reorder_func(x: FracElement, gens: Tuple['Symbol', ...]) -> Callable[['Permutation'], FracElement]:
+    rn = _polyelement_make_reorder_func(x.numer, gens)
+    rd = _polyelement_make_reorder_func(x.denom, gens)
+    return lambda perm: _fracelement_init(x.numer.ring.to_field(), *rn(perm).cancel(rd(perm)))