IntegralElimination 0.1.0__tar.gz

integralelimination-0.1.0/IntegralElimination/IntegralAlgebra.py

@@ -0,0 +1,312 @@
+import sympy as sp
+from ordered_set import OrderedSet
+from IPython.display import display, Math
+
+from .ordering import IMO
+from .IntegralMonomial import IM
+from .utils import (
+    is_int,
+    ShuffleList 
+)
+from .IntegralPolynomial import IntegralPolynomial
+from .reduction import (
+    reduction_M_by_P_simple_case,
+    reduction_M_by_P_reduced_power, 
+    reduction_M_by_P, 
+    reduce,auto_reduce
+)
+from .critical_pairs import (
+    critical_pairs_PI_QI,
+    critical_pairs_PI_QN,
+    critical_pairs_PN_QN,
+    critical_pairs
+)
+from .exponentials import (
+    find_A_A0_G_F, 
+    update_exp, 
+    extend_X_with_exp
+)
+from .integral_elimination import integral_elimination
+
+class IntegralAlgebra():
+    """
+    integral polynomials will be represented as follows :
+    eq = {IM(x(t):3, IM(y(t),1,y(t)):theta+lambda}
+    using eq.as_coefficients_dict(IM)
+    It means that eq is the sum of the two tuples 
+    """
+    def __init__(self, order, parameters):
+        self.order = order
+        self.t = sp.Symbol("t")
+        self.used_order = order
+        self.IMO_le = lambda m1, m2 : IMO(m1, m2, self.used_order) 
+        self.parameters = parameters
+    
+    
+    def update_IMO(self, order):
+        self.used_order = order
+        self.IMO = lambda m1, m2 : IMO(m1, m2, self.used_order)
+ 
+
+    def LM_LC(self, P:IntegralPolynomial) -> tuple[IM, sp.Expr]:
+        """
+        get leading monomials and coeff
+        """
+        L = list(P.dict.items())
+        LC, LM = L[0][1], L[0][0]
+        for M,coeff in L:   
+            #if True then M <= LM, else M > LM
+            if self.IMO_le(M, LM) == False: 
+                LM = M # im > LM
+                LC = coeff
+        return LM, LC
+    
+        
+    def display_rules(self, sys):
+        display(Math(r"\{")) 
+        for eq in sys:
+            LM, LC = self.LM_LC(eq)
+            key = IntegralPolynomial(LC*LM)
+            value = self.polynomials_subtraction(eq, key)
+            arrow = r"{\Huge \color{red} \mathbf{\rightarrow}}"  
+            key_repr = key.repr_display_math()
+            value_repr = value.repr_display_math()
+            export = Math(f"{key_repr} {arrow} {value_repr}") 
+            display(export)
+        display(Math(r"\}"))
+         
+
+    def normalize_LC_of_P(self, 
+                        P: IntegralPolynomial) -> IntegralPolynomial:
+        _, LC = self.LM_LC(P)
+        normalized_P = {}
+        for M, coeff in P.dict.items():
+            normalized_P[M] = coeff/LC
+        # Since we only have division 
+        # coeffs can't be zero  after 
+        # a simplification process
+        # then, using copy=True, we disable de simplification
+        # to optimize the reduction process
+        return IntegralPolynomial(normalized_P,copy=True), LC
+    
+    def monomials_product(self, M: IM, N: IM )-> IntegralPolynomial:
+        e = M.get_nb_int()
+        f = N.get_nb_int()
+        m0n0 = M.get_content()[0]*N.get_content()[0]
+        if e == f == 0:
+            MN = IM(m0n0)
+        elif e == 0 and f != 0:
+            N1p = N.cut("1+").get_content() #N1plus
+            MN = IM(m0n0,*N1p) 
+        elif e != 0 and f== 0 :
+            M1p = M.cut("1+").get_content() #N1plus
+            MN = IM(m0n0,*M1p) 
+        else:
+            N1p = N.cut("1+").get_content() #N1plus
+            M1p = M.cut("1+").get_content() #N1plus
+            sh = ShuffleList(M1p,N1p)
+            MN = sp.Add(*[IM(m0n0,*elem) for elem in sh]) 
+        return IntegralPolynomial(MN)
+
+    def product_P_Coeff(self, 
+                        P: IntegralPolynomial, 
+                        alpha: sp.Expr) -> IntegralPolynomial:
+        """
+        alpha is cst 
+        """
+        alpha_P = {}
+        for M in P.dict:
+            alpha_P[M] = P.dict[M]*alpha
+        return IntegralPolynomial(alpha_P)
+        
+    def polynomials_add(self, 
+                        P: IntegralPolynomial, 
+                        Q: IntegralPolynomial) -> IntegralPolynomial: 
+        PplusQ = P.copy().dict
+        for N in Q.dict:
+            c_N = Q.dict[N]
+            if N not in PplusQ:
+                PplusQ[N] = c_N
+            else:
+                PplusQ[N] += c_N
+        PplusQ = {M:coeff for M, coeff in PplusQ.items() if coeff != 0}
+        return IntegralPolynomial(PplusQ)
+    
+    def polynomials_subtraction(self, 
+                                P: IntegralPolynomial, 
+                                Q: IntegralPolynomial) -> IntegralPolynomial: 
+        PminusQ = P.copy().dict
+        for N in Q.dict:
+            c_N = Q.dict[N]
+            if N not in PminusQ:
+                PminusQ[N] = -c_N
+            else:
+                PminusQ[N] -= c_N
+        PminusQ = {M:coeff for M, coeff in PminusQ.items() if coeff != 0}
+        return IntegralPolynomial(PminusQ)
+    
+    def polynomials_product(self,
+                            P: IntegralPolynomial,
+                            Q: IntegralPolynomial) -> IntegralPolynomial: 
+        PQ = IntegralPolynomial(0)
+        for M_P, c_P in P.dict.items():
+            for M_Q, c_Q in Q.dict.items(): 
+                M_PdotM_Q = self.monomials_product(M_P,M_Q)
+                c_P_c_Q_M_PdotM_Q = self.product_P_Coeff(M_PdotM_Q, c_P*c_Q)
+                PQ = self.polynomials_add(PQ, c_P_c_Q_M_PdotM_Q)
+        return PQ 
+    
+    def integrate_monomial(self, M: IM):
+        return IM(1,*M.get_content())
+
+    def integrate_polynomial(self, 
+                             P: IntegralPolynomial) -> IntegralPolynomial:
+        Int_P = {}
+        for M, coeff in P.dict.items():
+            Int_M = self.integrate_monomial(M)
+            Int_P[Int_M] = coeff
+        return IntegralPolynomial(Int_P)
+ 
+    def add_prefix_to_polynomial(self, 
+                                prefix: IM, 
+                                P: IntegralPolynomial) -> IntegralPolynomial:
+        new_P = {} 
+        for M, coeff in P.dict.items():
+            pref_M = M.add_prefix(prefix)
+            new_P[pref_M] = coeff
+        return IntegralPolynomial(new_P)
+
+    def reduced_product(self, 
+                        P:IntegralPolynomial, 
+                        M:IM) -> IntegralPolynomial:
+        """
+        see section 3.1  
+        
+        reduced_product = (P \cdot \int M) - \int (M \cdot P)
+        """
+        M = IntegralPolynomial(M)
+        IntM = self.integrate_polynomial(M)
+
+        #(P \cdot \int M)
+        PdotIntM = self.polynomials_product(P,IntM) 
+        
+        #\int (M \cdot P)
+        IntMdotP = self.integrate_polynomial(
+                        self.polynomials_product(M,P)
+                    ) 
+
+        reduced_product = self.polynomials_add(
+                            PdotIntM ,self.product_P_Coeff(IntMdotP, -1)
+                        )
+        return reduced_product
+    
+    def polynomial_power(self, 
+                        P:IntegralPolynomial,
+                        n:int) -> IntegralPolynomial:
+        assert is_int(n) 
+        assert isinstance(P,IntegralPolynomial)
+        if n == 0: return IntegralPolynomial(IM(1))
+        P_pow_n = P
+        for _ in range(n-1):
+            P_pow_n = self.polynomials_product(P_pow_n,P)
+        return P_pow_n
+    
+    def reduced_power(self, 
+                      P:IntegralPolynomial, 
+                      n:int) -> IntegralPolynomial:
+        """
+        see section 3.2  
+
+        P^{\circled{n}} = n (\int (P_I[cut{1+}] cdot P_N^{n-1})) + P_N^n
+        """
+        assert is_int(n) and n >= 1 
+        P_I = P.get_P_I()
+        P_N = P.get_P_N() 
+        P_I_1plus = P_I.cut_P("1+") 
+        P_N_pow_n_minus_one = self.polynomial_power(P_N, n-1)
+        P_N_pow_n = self.polynomials_product(P_N_pow_n_minus_one, P_N)
+        
+        #lets compute n (\int (P_I[cut{1+}] cdot P_N^{n-1})) in temp
+        temp = self.integrate_polynomial(
+                    self.polynomials_product(P_I_1plus, P_N_pow_n_minus_one)
+                )
+        temp = self.product_P_Coeff(temp, n)
+
+        reduced_power = self.polynomials_add(temp, P_N_pow_n)
+        return reduced_power
+    
+    def reduction_M_by_P_simple_case(self,
+                                    M: IM, 
+                                    P: IntegralPolynomial
+                                    ) -> IntegralPolynomial:
+        return reduction_M_by_P_simple_case(self, M, P)
+    
+    def reduction_M_by_P_reduced_power(self,
+                                       M: IM, 
+                                       P: IntegralPolynomial
+                                       ) -> IntegralPolynomial:
+        return reduction_M_by_P_reduced_power(self, M, P)
+    
+    def reduction_M_by_P(self,
+                         M: IM, 
+                         P: IntegralPolynomial
+                        ) -> IntegralPolynomial:
+        return reduction_M_by_P(self,M,P)
+    
+    def reduce(self, 
+                Q: IntegralPolynomial, 
+                T: OrderedSet[IntegralPolynomial]
+            ) -> IntegralPolynomial:
+        return reduce(self,Q,T)
+    
+    def auto_reduce(self,  
+                    T:OrderedSet[IntegralPolynomial]
+                ) -> OrderedSet[IntegralPolynomial]:
+        return auto_reduce(self,T)
+    
+    def critical_pairs_PI_QI(self,
+                            P: IntegralPolynomial,
+                            Q: IntegralPolynomial) -> IntegralPolynomial:
+        return critical_pairs_PI_QI(self,P,Q)
+    
+    def critical_pairs_PI_QN(self,
+                            P: IntegralPolynomial,
+                            Q: IntegralPolynomial) -> IntegralPolynomial:
+        return critical_pairs_PI_QN(self,P,Q)
+    
+    def critical_pairs_PN_QN(self,
+                            P: IntegralPolynomial,
+                            Q: IntegralPolynomial) -> IntegralPolynomial:
+        return critical_pairs_PN_QN(self,P,Q)
+    
+    def critical_pairs(self,
+                       R: OrderedSet[IntegralPolynomial]
+                    ) -> OrderedSet [IntegralPolynomial]:
+        return critical_pairs(self,R)
+    
+    def find_A_A0_G_F(self, 
+                      P:IntegralPolynomial
+                      ) -> tuple[IntegralPolynomial]:
+        return find_A_A0_G_F(self,P)
+    
+    def update_exp(self, 
+                T_prime: OrderedSet[IntegralPolynomial],
+                E: OrderedSet[sp.Function, sp.Function, IntegralPolynomial]
+                ) -> tuple:
+        return update_exp(self,T_prime,E)
+    
+    def extend_X_with_exp(self,
+                      E: set[sp.Function, sp.Function, IntegralPolynomial]
+                      ) -> list:
+        return extend_X_with_exp(self, E)
+    
+    def integral_elimination(self,
+                            F: OrderedSet[IntegralPolynomial],
+                            disable_exp: bool = False,
+                            disable_critical_pairs: bool = False,
+                            nb_iter: int = 0) -> tuple:
+        return integral_elimination(self, 
+                                F, 
+                                disable_exp=disable_exp,
+                                disable_critical_pairs=disable_critical_pairs,
+                                nb_iter=nb_iter)

integralelimination-0.1.0/IntegralElimination/IntegralMonomial.py

@@ -0,0 +1,107 @@
+import sympy as sp
+
+from .utils import (
+    has_add_in_list,
+    is_float
+)
+
+def has_multiplicative_constant(expr): 
+    """
+    Search if expr has a multiplicative cst != than 1
+    """ 
+    if is_float(expr):
+        if expr == 1:
+            return False
+        else:
+            return True
+    elif expr.is_Mul:
+        factors = expr.as_ordered_factors() 
+        for factor in factors:
+            if factor.is_number and factor != 1:
+                return True  
+    return False
+
+
+class IM(sp.Function): 
+    def __init__(self, *args):  
+        self.c = (*args,) 
+        self.t = sp.Symbol("t") 
+
+        assert "IM" not in str(self.c)
+        assert not has_add_in_list(self.c)
+
+        #check if parameters (symbols) are in self.c
+        assert not any([
+                        len(elem.free_symbols - {self.t}) 
+                        for elem in self.c if not is_float(elem)
+                       ])
+        #check that every multiplicative csts are 1
+        assert not any([
+                        has_multiplicative_constant(elem) 
+                        for elem in self.c
+                       ])
+
+    def get_nb_int(self):
+        return len(self.c) - 1
+
+    def get_content(self):
+        return self.c
+    
+    def cut(self, cut_type):
+        """
+        See Definition 7 
+        """
+        if cut_type ==  "0":
+            return IM(self.c[0])
+        
+        elif cut_type ==  "1":
+            assert self.get_nb_int() >= 1
+            return IM(self.c[1])
+        
+        elif cut_type ==  "1+":
+            assert self.get_nb_int() >= 1
+            return IM(*self.c[1:])
+        
+        elif cut_type ==  "i1+":
+            if self.get_nb_int() == 0:
+                return IM(1)
+            else:
+                return IM(1,*self.c[1:])
+          
+        elif cut_type == "i2+":
+            if self.get_nb_int() == 1: 
+                return IM(1)
+            else:
+                assert self.get_nb_int() >= 2
+                return IM(1,*self.c[2:])
+        else:
+            raise NotImplementedError
+        
+    def get_suffix(self, i):
+        assert 0 <= i <= self.get_nb_int()
+        return IM(*self.get_content()[i:])
+    
+    def get_prefix(self, i):
+        assert 0 <= i <= self.get_nb_int()
+        return IM(*self.get_content()[:i])
+
+    def add_prefix(self, M):
+        prefixed_M = IM(*M.get_content(),*self.get_content())
+        return prefixed_M
+
+    def __str__(self):
+        return f"IM({str(self.c)[1:-1]})"
+    
+    def get_sympy_repr(self): 
+        if len(self.c) > 1:
+            expr = sp.Integral(self.c[-1], self.t)
+            for e in reversed(self.c[1:-1]): 
+                expr = (sp.Integral(e*expr, self.t))
+            expr = self.c[0]*expr
+        elif len(self.c) == 1:
+            expr = self.c[0]
+        return expr
+
+    def _latex(self, printer=None):  
+        return f"{printer.doprint(self.get_sympy_repr())}"
+    

integralelimination-0.1.0/IntegralElimination/IntegralPolynomial.py

@@ -0,0 +1,138 @@
+import sympy as sp
+import sympy.printing as printing
+
+from .IntegralMonomial import IM
+from .utils import is_float 
+
+
+class IntegralPolynomial(): 
+ 
+    def __init__(self, 
+                P,  
+                copy=False):  
+        if type(P) == dict:
+            self.dict = {} 
+            if not copy:  
+                for M, coeff in P.items(): 
+                    coeff = sp.cancel(coeff)
+                    if coeff != 0:
+                        self.dict[M] = coeff 
+            else:
+                for k,coeff in P.items():
+                    self.dict[k] = coeff
+        elif isinstance(P, sp.Expr):
+            self.dict = dict(P.as_coefficients_dict(IM))
+        elif P == 0:
+            self.dict = {}
+        else:
+            raise SyntaxError
+
+    def get_sympy_repr(self):
+        L = self.dict.items()
+        sympy_repr = sp.Add(*[coeff*M for M,coeff in L]) 
+        return sympy_repr
+    
+    def add_alpha_M(self, alpha, M):
+        if M in self.dict:
+            new_coeff = sp.cancel(alpha + self.dict[M])
+            if new_coeff !=0:
+                self.dict[M] = new_coeff
+            else:
+                del self.dict[M]
+        else:
+            self.dict[M] = alpha
+  
+    def is_zero(self):
+        return len(self.dict) ==0
+    
+    def __repr__(self):
+        return f"IntegralPolynomial({self.get_sympy_repr()})"
+    
+    def repr_display_math(self):
+        return '{}'.format(printing.latex(self.get_sympy_repr()))
+
+    def _repr_latex_(self):  
+        return '${}$'.format(printing.latex(self.get_sympy_repr()))
+
+    def copy(self):
+        # d = copy.deepcopy(self.dict)
+        d = self.dict
+        #avoid sp simplify on coeff when copy
+        return IntegralPolynomial(d, copy=True) 
+     
+    def cut_P(self, cut_type: str):
+        """
+        Definition 8 of Contribution to Integral Elimination
+        We simply extend the cut method of the Integral Monomial class to 
+        integral polynomials 
+        
+        Disclaimer: this method will throw an error if you use it on 
+        polynomial that can't be cutted 
+        for exemple, trying to cut a pol with monomials of depth < 2 will 
+        throw an error if you cut using i2+
+        """
+        P_cutted = {}
+        P = self.dict.items() 
+        for M,coeff in P:
+            M_cutted = M.cut(cut_type) 
+            if P_cutted.get(M_cutted) is None:
+                P_cutted[M_cutted] = coeff 
+            else:
+                P_cutted[M_cutted] += coeff 
+        return IntegralPolynomial(P_cutted)
+    
+    def get_P_I(self): 
+        P_I = {}
+        P = self.dict.items()
+        for M,coeff in P: 
+            M0 = M.cut("0") 
+            if M.get_nb_int() >= 1 and M0 == IM(1):
+                if M not in P_I:
+                    P_I[M] = coeff
+                else:
+                    # we are not supposed to have this case
+                    raise ValueError 
+        # we avoid the simplification process of the coeffs
+        # by using copy=True
+        return  IntegralPolynomial(P_I, copy=True)
+
+    def get_P_N(self): 
+        P_N = {}
+        P = self.dict.items()
+        for M,coeff in P:  
+            M0 = M.cut("0")
+            if M==IM(1): #cst
+                P_N[M] = coeff
+            elif M0 != IM(1):
+                if M not in P_N:
+                    P_N[M] = coeff
+                else:
+                    # we are not supposed to have this case
+                    raise ValueError 
+        # we avoid the simplification process of the coeffs
+        # by using copy=True
+        return  IntegralPolynomial(P_N, copy=True)
+    
+    def get_cst_terms(self):
+        CST = {}
+        P = self.dict.items()
+        for M,coeff in P:  
+            if M == IM(1):
+                if M in CST:
+                    CST[M] += coeff 
+                else:
+                    CST[M] = coeff 
+        return  IntegralPolynomial(CST)
+    
+    def get_time_dependant_functions(self):
+        """
+        example: if you have 
+        P = IntegralPolynomial(IM(x(t)) - x(0)*IM(1) 
+                        - theta*IM(1,x(t)*y(t)**2) - IM(1,y(t)))
+        it will return {x,y}
+        """
+        res = set()
+        for f in self.get_sympy_repr().atoms(sp.Function):
+            if f.func != IM and not is_float(f.args[0]):
+                res.add(f) 
+        return res

integralelimination-0.1.0/IntegralElimination/__init__.py

@@ -0,0 +1,4 @@
+from .IntegralAlgebra import *
+from .IntegralMonomial import *
+from .IntegralPolynomial import * 
+from .convert import *

integralelimination-0.1.0/IntegralElimination/convert.py

@@ -0,0 +1,38 @@
+import sympy as sp
+from ordered_set import OrderedSet
+
+from .utils import expr_has_symbol
+from .IntegralMonomial import IM
+from .IntegralPolynomial import IntegralPolynomial
+
+
+def first_order_ODE_to_IntegralPolynomial(
+                                        expr:sp.Expr, 
+                                        var=sp.Symbol("t")
+                                        ) -> IntegralPolynomial:
+        expr = sp.expand(expr)
+        dict_coeff = dict(expr.as_coefficients_dict(var))
+        P = IntegralPolynomial(0)
+        if expr_has_symbol(expr, sp.Integral): raise ValueError
+        expr_has_der = expr_has_symbol(expr,sp.Derivative)
+        for mons, coeff in dict_coeff.items():
+            if mons.func == sp.Derivative : 
+                assert mons.args[1][1] == 1 
+                m = mons.args[0]
+                CI = sp.Symbol(f"{m.func}0")
+                M = IM(m)
+                P.add_alpha_M(coeff, M)
+                P.add_alpha_M(-CI,IM(1))
+            else:
+                if expr_has_der:
+                    M = IM(1,mons)
+                    P.add_alpha_M(coeff,M)
+                else:
+                    M = IM(mons)
+                    P.add_alpha_M(coeff,M)
+        return P
+
+def ODE_sys_to_Integral_sys(sys: list[sp.Expr]
+                            ) -> OrderedSet[IntegralPolynomial]:
+    sys = OrderedSet([first_order_ODE_to_IntegralPolynomial(eq) for eq in sys])
+    return  sys