Beispiel #1
0
    def __exit__(self, typ, value, tb):
        """
        EXAMPLE::

           sage: from sage.libs.giac import GiacSettingsDefaultContext  # optional - giacpy
           sage: from giacpy import giacsettings # optional - giacpy
           sage: giacsettings.proba_epsilon = 1e-16 # optional - giacpy
           sage: with GiacSettingsDefaultContext(): giacsettings.proba_epsilon = 1e-30 # optional - giacpy
           sage: giacsettings.proba_epsilon < 1e-20 # optional - giacpy
           False

        """
        try:
            from giacpy import giacsettings, libgiac
        except ImportError:
            raise ImportError("""One of the optional packages giac or giacpy is missing""")

        # Restore the debug level first to not have messages at each modification
        libgiac('debug_infolevel')(self.debuginfolevel)
        # NB: giacsettings.epsilon has a different meaning that giacsettings.proba_epsilon.
        giacsettings.proba_epsilon = self.proba_epsilon
        giacsettings.threads = self.threads
Beispiel #2
0
    def __enter__(self):
        """
        EXAMPLE::

           sage: from sage.libs.giac import GiacSettingsDefaultContext  # optional - giacpy
           sage: from giacpy import giacsettings # optional - giacpy
           sage: giacsettings.proba_epsilon = 1e-16 # optional - giacpy
           sage: with GiacSettingsDefaultContext(): giacsettings.proba_epsilon = 1e-12 # optional - giacpy
           sage: giacsettings.proba_epsilon < 1e-14 # optional - giacpy
           True

        """
        try:
            from giacpy import giacsettings, libgiac
        except ImportError:
            raise ImportError("""One of the optional packages giac or giacpy is missing""")

        self.proba_epsilon = giacsettings.proba_epsilon
        self.threads = giacsettings.threads
        # Change the debug level at the end to not have messages at each modification
        self.debuginfolevel = libgiac('debug_infolevel()')
Beispiel #3
0
def groebner_basis(gens, proba_epsilon=None, threads=None, prot=False, *args, **kwds):
    """
    Computes a Groebner Basis of an ideal using giacpy. The result is
    automatically converted to sage.

    INPUT:

    - ``gens`` - an ideal (or a list) of polynomials over a prime field
      of characteristic 0 or p<2^31

    - ``proba_epsilon`` - (default: None) majoration of the probability
       of a wrong answer when probabilistic algorithms are allowed.

        * if ``proba_epsilon`` is None, the value of
          ``sage.structure.proof.all.polynomial()`` is taken. If it is
          false then the global ``giacpy.giacsettings.proba_epsilon`` is
          used.

        * if ``proba_epsilon`` is 0, probabilistic algorithms are
          disabled.

    - ``threads`` - (default: None) Maximal number of threads allowed
      for giac. If None, the global ``giacpy.giacsettings.threads`` is
      considered.

    - ``prot`` - (default: False) if True print detailled informations

    OUTPUT:

    Polynomial sequence of the reduced Groebner basis.

    EXAMPLES::

        sage: from sage.libs.giac import groebner_basis as gb_giac # optional - giacpy
        sage: P = PolynomialRing(GF(previous_prime(2**31)), 6, 'x') # optional - giacpy
        sage: I = sage.rings.ideal.Cyclic(P) # optional - giacpy
        sage: B=gb_giac(I.gens());B # optional - giacpy
        <BLANKLINE>
        // Groebner basis computation time ...
        Polynomial Sequence with 45 Polynomials in 6 Variables
        sage: B.is_groebner() # optional - giacpy
        True

    Computations over QQ can benefit from

    * a probabilistic lifting::

        sage: P = PolynomialRing(QQ,5, 'x') # optional - giacpy
        sage: I = ideal([P.random_element(3,7) for j in range(5)]) # optional - giacpy
        sage: B1 = gb_giac(I.gens(),1e-16) # optional - giacpy, long time (1s)
        Running a probabilistic check for the reconstructed Groebner basis.
        If successfull, error probability is less than 1e-16 ...
        sage: sage.structure.proof.all.polynomial(True) # optional - giacpy
        sage: B2 = gb_giac(I.gens()) # optional - giacpy, long time (4s)
        <BLANKLINE>
        // Groebner basis computation time...
        sage: B1==B2 # optional - giacpy, long time
        True
        sage: B1.is_groebner() # optional - giacpy, long time (20s)
        True

    * multi threaded operations::

        sage: P = PolynomialRing(QQ, 8, 'x') # optional - giacpy
        sage: I=sage.rings.ideal.Cyclic(P) # optional - giacpy
        sage: time B = gb_giac(I.gens(),1e-6,threads=2) # doctest: +SKIP
        Running a probabilistic check for the reconstructed Groebner basis...
        Time: CPU 168.98 s, Wall: 94.13 s

    You can get detailled information by setting ``prot=True``

    ::

        sage: I=sage.rings.ideal.Katsura(P) # optional - giacpy
        sage: gb_giac(I,prot=True)  # optional - giacpy, random, long time (3s)
        9381383 begin computing basis modulo 535718473
        9381501 begin new iteration zmod, number of pairs: 8, base size: 8
        ...end, basis size 74 prime number 1
        G=Vector [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,...
        ...creating reconstruction #0
        ...
        ++++++++basis size 74
        checking pairs for i=0, j=
        checking pairs for i=1, j=2,6,12,17,19,24,29,34,39,42,43,48,56,61,64,69,
        ...
        checking pairs for i=72, j=73,
        checking pairs for i=73, j=
        Number of critical pairs to check 373
        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++...
        Successfull check of 373 critical pairs
        12380865 end final check
        Polynomial Sequence with 74 Polynomials in 8 Variables


    TESTS::

        sage: from giacpy import libgiac # optional - giacpy
        sage: libgiac("x2:=22; x4:='whywouldyoudothis'") # optional - giacpy
        22,whywouldyoudothis
        sage: gb_giac(I) # optional - giacpy
        Traceback (most recent call last):
        ...
        ValueError: Variables names ['x2', 'x4'] conflict in giac. Change them or purge them from in giac with libgiac.purge('x2')
        sage: libgiac.purge('x2'),libgiac.purge('x4') # optional - giacpy
        (22, whywouldyoudothis)
        sage: gb_giac(I) # optional - giacpy, long time (3s)
        <BLANKLINE>
        // Groebner basis computation time...
        Polynomial Sequence with 74 Polynomials in 8 Variables

        sage: I=ideal(P(0),P(0)) # optional - giacpy
        sage: I.groebner_basis() == gb_giac(I) # optional - giacpy
        True

    """
    try:
        from giacpy import libgiac, giacsettings
    except ImportError:
        raise ImportError("""One of the optional packages giac or giacpy is missing""")

    try:
        iter(gens)
    except TypeError:
        gens = gens.gens()

    # get the ring from gens
    P = next(iter(gens)).parent()
    K = P.base_ring()
    p = K.characteristic()

    # check if the ideal is zero. (giac 1.2.0.19 segfault)
    from sage.rings.ideal import Ideal
    if (Ideal(gens)).is_zero():
        return PolynomialSequence([P(0)], P, immutable=True)

    # check for name confusions
    blackgiacconstants = ['i', 'e'] # NB e^k is expanded to exp(k)
    blacklist = blackgiacconstants + [str(j) for j in libgiac.VARS()]
    problematicnames = list(set(P.gens_dict().keys()).intersection(blacklist))

    if(len(problematicnames)>0):
        raise ValueError("Variables names %s conflict in giac. Change them or purge them from in giac with libgiac.purge(\'%s\')"
                         %(problematicnames, problematicnames[0]))

    if K.is_prime_field() and p == 0:
        F = libgiac(gens)
    elif K.is_prime_field() and p < 2**31:
        F = (libgiac(gens) % p)
    else:
        raise NotImplementedError("Only prime fields of cardinal < 2^31 are implemented in Giac for Groebner bases.")

    if P.term_order() != "degrevlex":
        raise NotImplementedError("Only degrevlex term orderings are supported in Giac Groebner bases.")

    # proof or probabilistic reconstruction
    if proba_epsilon is None:
        if proof_polynomial():
            giacsettings.proba_epsilon = 0
        else:
            giacsettings.proba_epsilon = 1e-15
    else:
        giacsettings.proba_epsilon = proba_epsilon

    # prot
    if prot:
        libgiac('debug_infolevel(2)')

    # threads
    if threads is not None:
        giacsettings.threads = threads

    # compute de groebner basis with giac
    gb_giac = F.gbasis([P.gens()], "revlex")

    return PolynomialSequence(gb_giac, P, immutable=True)
Beispiel #4
0
def rational_univariate_representation(ideal):
    I = libgiac(ideal.gens())
    vars = list(ideal.ring().gens())
    return I.gbasis(libgiac(vars), 'rur')