Example #1
0
def test_latex_PolyElement():
    Ruv, u,v = ring("u,v", ZZ);
    Rxyz, x,y,z = ring("x,y,z", Ruv.to_domain())

    assert latex(x - x) == r"0"
    assert latex(x - 1) == r"x - 1"
    assert latex(x + 1) == r"x + 1"

    assert latex((u**2 + 3*u*v + 1)*x**2*y + u + 1) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + u + 1"
    assert latex((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + \left(u + 1\right) x"
    assert latex((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + \left(u + 1\right) x + 1"
    assert latex((-u**2 + 3*u*v - 1)*x**2*y - (u + 1)*x - 1) == r"-\left({u}^{2} - 3 u v + 1\right) {x}^{2} y - \left(u + 1\right) x - 1"
Example #2
0
def test_latex_PolyElement():
    Ruv, u,v = ring("u,v", ZZ);
    Rxyz, x,y,z = ring("x,y,z", Ruv.to_domain())

    assert latex(x - x) == r"0"
    assert latex(x - 1) == r"x - 1"
    assert latex(x + 1) == r"x + 1"

    assert latex((u**2 + 3*u*v + 1)*x**2*y + u + 1) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + u + 1"
    assert latex((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + \left(u + 1\right) x"
    assert latex((u**2 + 3*u*v + 1)*x**2*y + (u + 1)*x + 1) == r"\left({u}^{2} + 3 u v + 1\right) {x}^{2} y + \left(u + 1\right) x + 1"
    assert latex((-u**2 + 3*u*v - 1)*x**2*y - (u + 1)*x - 1) == r"-\left({u}^{2} - 3 u v + 1\right) {x}^{2} y - \left(u + 1\right) x - 1"
Example #3
0
def example_20():
    """
    Example 20 from KK
    """
    R, x, y, z = ring('x,y,z', RR, grevlex)
    I = [z**2 + 3 * y - 7 * z,
         y * z - 4 * y,
         x * z - 4 * y,
         y**2 - 4*y,
         x*y - 4 * y,
         x**5 - 8 * x**4 + 14 * x**4 + 8 * x**2 - 15 * x + 15 * y,
        ]
    G = [z**2 + 3 * y - 7 *z,
            y * z - 4 * y,
            x * z - 4 * y,
            y**2 - 4*y,
            x *y - 4 * y,
            x**2 * z - 16 * y,
            x **2 * y - 16 * y,
            x**3 * z - 64 * y,
            x**3 * y - 64 * y,
            x**4 * z - 256 * y,
            x**4 * y - 256 * y,
            x **5 - 8 * x **4 + 14 * x **4 + 8 * x **2 - 15 * x + 15 * y,
            ]

    return R, I, G
Example #4
0
def test_episode_2(s, reward):
    R, x, y, z, t = sp.ring('x,y,z,t', sp.FF(32003), 'grlex')
    F = [x**31 - x**6 - x - y, x**8 - z, x**10 - t]
    ideal_gen = FixedIdealGenerator(F)
    env = BuchbergerEnv(ideal_gen, rewards='reductions')
    agent = BuchbergerAgent(selection=s)
    assert run_episode(agent, env) == reward
Example #5
0
def generate_parabolas(N=2, sigma=0.):
    R, x, y = ring('x, y', RR, order=grevlex)
    thetas = [2 * pi / N * t for t in xrange(N)]
    I = [(x * sin(t) + y * cos(t) - 1)**2 - (x + cos(t))**2 - (y + sin(t))**2 +
         sigma * randn() for t in thetas]

    return R, I
Example #6
0
def example_20():
    """
    Example 20 from KK
    """
    R, x, y, z = ring('x,y,z', RR, grevlex)
    I = [
        z**2 + 3 * y - 7 * z,
        y * z - 4 * y,
        x * z - 4 * y,
        y**2 - 4 * y,
        x * y - 4 * y,
        x**5 - 8 * x**4 + 14 * x**4 + 8 * x**2 - 15 * x + 15 * y,
    ]
    G = [
        z**2 + 3 * y - 7 * z,
        y * z - 4 * y,
        x * z - 4 * y,
        y**2 - 4 * y,
        x * y - 4 * y,
        x**2 * z - 16 * y,
        x**2 * y - 16 * y,
        x**3 * z - 64 * y,
        x**3 * y - 64 * y,
        x**4 * z - 256 * y,
        x**4 * y - 256 * y,
        x**5 - 8 * x**4 + 14 * x**4 + 8 * x**2 - 15 * x + 15 * y,
    ]

    return R, I, G
Example #7
0
        def get_measurement_polynomials(self, noise = 0, seed = 0):
            np.random.seed(seed)

            k, d = self.k, self.d
            params = self.get_parameters()
            R = ring([x for x, _ in params], RR)[0]
            names = {str(x) : R(x) for x in R.symbols}
            xs = array([[names[self.x(i,j)] for j in xrange(k)] for i in xrange(d)])
            params = [(names[x], v) for x, v in params]

            # Second order moments (TODO: 3rd order moments)
            P = zeros((d,d), dtype=np.object)
            p = zeros((d,), dtype=np.object)
            for i in xrange(d):
                p[i] = sum(xs[i,k_] for k_ in xrange(k))# / k
                for j in xrange(i, d):
                    P[i,j] = sum(xs[i,k_] * xs[j,k_] for k_ in xrange(k))# / k

            # Project and profit
            m = zeros((d,))
            M = zeros((d,d))
            for i in xrange(d):
                m[i] = p[i].evaluate(params)
                for j in xrange(i, d):
                    M[i,j] = P[i,j].evaluate(params)
            M = M + noise * np.random.randn(d,d)
            m = m + noise * np.random.randn(d)
            # TODO: Something is wrong here 
            #m = M.sum(1)

            # Finally return values.
            return R, [f - f_ 
                    for f, f_ in zip(p.flatten(), m.flatten())] + [f - f_ 
                            for f, f_ in zip(P[triu_indices_from(P)], M[triu_indices_from(M)])]
Example #8
0
def example_order_preservation():
    """
    Example 3.4 from paper. 5 variables, 7 equations. Method fails
    unless the lex basis is re-added to the original basis
    """
    R, x0, x1, x2, x3, x4 = ring('x0,x1,x2,x3,x4', QQ, lex)
    I = [x0 - x2, x0 - x3, x1 - x3, x1 - x4, x2 - x3, x3 - x4, x2**2]
    return R, I
Example #9
0
def example_simple():
    """
    Example 3.1 from paper. 4 variables, 4 equations, simple, method
    works
    """
    R, x0, x1, x2, x3 = ring('x0,x1,x2,x3', QQ, lex)
    I = [x0**4 - 1, x0**2 + x2, x1**2 + x2, x2**2 + x3]
    return R, I
 def test_extend():
     """
     Test extension
     """
     R = ring('x,y', RR)[0]
     L = BorderBasedUniverse(R, [(2, 1), (1, 2)])
     L.extend()
     assert L._border == [(3, 1), (2, 2), (1, 3)]
Example #11
0
def example_order_preservation():
    """
    Example 3.4 from paper. 5 variables, 7 equations. Method fails
    unless the lex basis is re-added to the original basis
    """
    R, x0, x1, x2, x3, x4 = ring('x0,x1,x2,x3,x4', QQ, lex)
    I = [x0 - x2, x0 - x3, x1 - x3, x1 - x4, x2 - x3, x3 - x4, x2**2]
    return R, I
Example #12
0
def example_simple():
    """
    Example 3.1 from paper. 4 variables, 4 equations, simple, method
    works
    """
    R, x0, x1, x2, x3 = ring('x0,x1,x2,x3', QQ, lex)
    I = [x0**4 - 1, x0**2 + x2, x1**2 + x2, x2**2 + x3]
    return R, I
Example #13
0
 def test_extend():
     """
     Test extension
     """
     R = ring('x,y', RR)[0]
     L = BorderBasedUniverse(R, [(2, 1), (1, 2)])
     L.extend()
     assert L._border == [(3, 1), (2, 2), (1, 3)]
Example #14
0
def example_subset_large():
    A = range(10)
    S = 5
    n = len(A)
    syms = [Symbol('s%d'%i) for i in xrange(n+1)]
    R = ring(syms, QQ, lex)[0]
    I = [syms[0]] + [(syms[i] - syms[i-1]) * (syms[i] - syms[i-1] - A[i-1]) for i in xrange(1,n+1)] + [syms[n] - S]
    return R, as_ring_exprs(R, I)
Example #15
0
 def _scalar_to_str(self, c):
     # not an elegant way to force elements of algebraic fields be printed with sqrt
     if isinstance(c, sympy.polys.polyclasses.ANP):
         dummy_ring = sympy.ring([], self.domain)[0]
         return f"({dummy_ring(c).as_expr()})"
     if isinstance(c, sympy.polys.fields.FracElement):
         return f"({c})"
     return str(c)
Example #16
0
def example_fail():
    """
    Example 3.2 from paper. 2 variables, 3 equations, method fails
    Failure mode: one of the ideal quotients is empty, which means that
    the variety could be the empty set.
    """
    R, x0, x1, x2 = ring('x0,x1,x2', QQ, lex)
    I = [x0 * x1 + 1, x1 + x2, x1 * x2]
    return R, I
Example #17
0
def example_fail():
    """
    Example 3.2 from paper. 2 variables, 3 equations, method fails
    Failure mode: one of the ideal quotients is empty, which means that
    the variety could be the empty set.
    """
    R, x0, x1, x2 = ring('x0,x1,x2', QQ, lex)
    I = [x0 * x1 + 1, x1 + x2, x1*x2]
    return R, I
Example #18
0
def example_subset_large():
    A = range(10)
    S = 5
    n = len(A)
    syms = [Symbol('s%d' % i) for i in xrange(n + 1)]
    R = ring(syms, QQ, lex)[0]
    I = [syms[0]] + [(syms[i] - syms[i - 1]) *
                     (syms[i] - syms[i - 1] - A[i - 1])
                     for i in xrange(1, n + 1)] + [syms[n] - S]
    return R, as_ring_exprs(R, I)
Example #19
0
def example_trivial():
    """
    My own example.
    """

    R, x, y = ring('x,y', RR, grevlex)

    I = [x**2 + y**2 - 2, x + y]

    return R, I
Example #20
0
def test_episode_1(e, reward):
    R, a, b, c, d = sp.ring('a,b,c,d', sp.FF(32003), 'grevlex')
    F = [
        a + b + c + d, a * b + b * c + c * d + d * a,
        a * b * c + b * c * d + c * d * a + d * a * b, a * b * c * d - 1
    ]
    ideal_gen = FixedIdealGenerator(F)
    env = BuchbergerEnv(ideal_gen, elimination=e, rewards='reductions')
    agent = BuchbergerAgent(selection=['normal', 'first'])
    assert run_episode(agent, env) == reward
Example #21
0
def generate_univariate_problem(n_common_zeros=1, max_degree=3, n_equations=5):
    R, x = ring('x', RR, order=grevlex)
    # set of common zeros.
    V = 1 - 2 * rand(n_common_zeros)
    I = [
        poly_for_zeros(
            R, x, np.hstack((V, 1 - 2 * rand(max_degree - n_common_zeros))))
        for _ in xrange(n_equations)
    ]
    return R, I, V
Example #22
0
def generate_dense_polynomial(nvars, deg):
    R, *variables = sp.ring([f"x{i}" for i in range(nvars)], sp.QQ)

    def gen_eq_deg(d: int):
        return reduce(add, [randrange(-10, 10) * reduce(mul, p) for p in itertools.product(variables, repeat=d)]) \
               + randrange(-10, 10)

    def gen_eq():
        return reduce(add, [gen_eq_deg(d) for d in range(1, deg + 1)])

    return [gen_eq() for _ in range(nvars)]
Example #23
0
def test_restrict_lt1():
    _, x, y = ring('x,y', RR, grevlex)
    I = [x + y + 1, x**2 + y + 1]
    L = get_order_basis(I)
    B = get_support_basis(I)
    W = unitary_basis(B, I)

    L_, B_, W_ = restrict_lt(L, B, W)

    assert L_ == L
    assert np.allclose(W_, W)
Example #24
0
def test_restrict_lt1():
    _, x, y = ring('x,y', RR, grevlex)
    I = [x + y + 1, x**2 + y + 1]
    L = get_order_basis(I)
    B = get_support_basis(I)
    W = unitary_basis(B, I)

    L_, B_, W_ = restrict_lt(L, B, W)

    assert L_ == L
    assert np.allclose(W_, W)
Example #25
0
def test_restrict_lt2():
    _, x, y = ring('x,y', RR, grevlex)
    I = [x * y**2, x**2 * y + x * y**2, x**3 * y**2]
    L = get_order_basis([x**2 * y])
    B = get_support_basis(I)
    W = unitary_basis(B, I)

    L_, B_, W_ = restrict_lt(L, B, W)

    assert len(difference(L_, L)) > 0 and len(difference(L, L_)) == 0
    assert len(B_) == 2
    assert np.allclose(W_, W[:2, 1:])
Example #26
0
def example():
    """
    Example 4.12
    """
    R, x, y, z = ring('x,y,z', RR, grevlex)
    I = [
        0.130 * z**2 + 0.39 * y - 0.911 * z, 0.242 * y * z - 0.97 * y,
        0.243 * x * z - 0.97 * y, 0.242 * y**2 - 0.97 * y,
        0.243 * x * y - 0.97 * y, 0.035 * x**5 - 0.284 * x**4 + 0.497 * x**3 +
        0.284 * x**2 - 0.532 * x + 0.533 * y
    ]
    return R, I
Example #27
0
def example_trivial():
    """
    My own example.
    """

    R, x, y = ring('x,y', RR, grevlex)

    I = [x**2 + y**2 - 2,
            x + y 
            ]

    return R, I
Example #28
0
def test_restrict_lt2():
    _, x, y = ring('x,y', RR, grevlex)
    I = [x*y**2, x**2 * y + x * y**2, x**3 * y**2]
    L = get_order_basis([x**2*y])
    B = get_support_basis(I)
    W = unitary_basis(B, I)

    L_, B_, W_ = restrict_lt(L, B, W)

    assert len(difference(L_, L)) > 0 and len(difference(L, L_)) == 0
    assert len(B_) == 2
    assert np.allclose(W_, W[:2,1:])
Example #29
0
def example():
    """
    Example 4.12
    """
    R, x, y, z = ring('x,y,z', RR, grevlex)
    I = [0.130 * z**2  + 0.39 * y - 0.911 * z,
         0.242 * y * z - 0.97 * y,
         0.243 * x * z - 0.97 * y,
         0.242 * y**2  - 0.97 * y,
         0.243 * x * y - 0.97 * y,
         0.035 * x**5 - 0.284 * x**4 + 0.497 * x**3 + 0.284 * x**2 - 0.532 * x + 0.533 * y
         ]
    return R, I
Example #30
0
def test_episode_0(s):
    R, a, b, c, d, e = sp.ring('a,b,c,d,e', sp.FF(32003), 'grevlex')
    F = [
        a + 2 * b + 2 * c + 2 * d + 2 * e - 1,
        a**2 + 2 * b**2 + 2 * c**2 + 2 * d**2 + 2 * e**2 - a,
        2 * a * b + 2 * b * c + 2 * c * d + 2 * d * e - b,
        b**2 + 2 * a * c + 2 * b * d + 2 * c * e - c,
        2 * b * c + 2 * a * d + 2 * b * e - d
    ]
    ideal_gen = FixedIdealGenerator(F)
    env = BuchbergerEnv(ideal_gen, rewards='reductions')
    agent = BuchbergerAgent(selection=s)
    assert run_episode(agent, env) == -28
Example #31
0
def generate_lifeware_conjecture(n):
    """
    Generate the system from Conjecture 3.1 from https://hal.inria.fr/hal-02900798v2/document
    Also is called Long Monomial in benchmarks.
    """
    variables = sp.ring([f"x{i}" for i in range(n)], sp.QQ)[1:]
    prod_all = 1
    for i in range(n):
        prod_all *= variables[i]**2

    system = []
    for i in range(n):
        system.append(variables[(i + 1) % n]**2 + prod_all)
    return system
Example #32
0
def generate_exponential():
    coef_field = sp.FractionField(
        sp.QQ, ["Apsi", "Atheta", "bpsi", "btheta", "gamma", "B", "D"])
    Apsi, Atheta, bpsi, btheta, gamma, B, D = coef_field.gens
    R, psi, theta, exp, thinv2, u, du = sp.ring(
        ["psi", "theta", "exp", "thinv2", "u", "u'"], coef_field)
    eqs = [
        Apsi * psi + bpsi * u - D * psi * exp,
        Atheta * theta + btheta * u + B * D * psi * exp
    ]
    eqs.append(gamma * eqs[0] * thinv2 * exp)
    eqs.append(eqs[0] * (-2) * thinv2 * psi)
    eqs.append(du)
    eqs.append(du**2)
    return eqs
Example #33
0
def test_LeadMonomialsEnv_1():
    R, x, y, z = sp.ring('x,y,z', sp.FF(101), 'grevlex')
    F = [y - x**2, z - x**3]
    ideal_gen = FixedIdealGenerator(F)
    env = LeadMonomialsEnv(ideal_gen)
    state = env.reset()
    assert np.array_equal(state, np.array([[2, 0, 0, 3, 0, 0]]))
    state, _, done, _ = env.step(0)
    assert np.array_equal(state, np.array([[2, 0, 0, 1, 1, 0]]))
    assert not done
    state, _, done, _ = env.step(0)
    assert np.array_equal(state, np.array([[1, 1, 0, 0, 2, 0]]))
    assert not done
    state, _, done, _ = env.step(0)
    assert done
Example #34
0
def example_simple():
    """
    Example 19 from KK
    """
    R, x, y = ring('x,y', RR, grevlex)
    I = [
        x**3 - x, y**3 - y, x**2 * y - 0.5 * y - 0.5 * y**2,
        x * y - x - 0.5 * y + x**2 - 0.5 * y**2,
        x * y**2 - x - 0.5 * y + x**2 - 0.5 * y**2
    ]
    G = [
        x**2 + x * y - 0.5 * y**2 - x - 0.5 * y, y**3 - y, x * y**2 - x * y,
        x**2 * y - 0.5 * y**2 - 0.5 * y
    ]

    return R, I, G
Example #35
0
def example_mog(sigma=0):
    R, x1, x2, y1, y2 = ring('x1,x2,y1,y2', RR, lex)
    m1x =  x1 + x2
    m1y =  y1 + y2
    m2xx = x1**2 + x2**2
    m2xy = x1 * y1 + x2 * y2
    m2yy = y1**2 + y2**2
    ms = [ m1x, m1y, m2xx, m2xy,] #m2yy, ]

    if True:
        x1v, x2v = 1, -1
        y1v, y2v = -1, 1

    I = [ (m - m(x1v, x2v, y1v, y2v) + sigma * np.random.randn()) for m in ms]

    return R, I
Example #36
0
def example_simple():
    """
    Example 19 from KK
    """
    R, x, y = ring('x,y', RR, grevlex)
    I = [x**3 - x,
         y**3 - y,
         x**2*y - 0.5 * y - 0.5 * y**2,
         x*y - x - 0.5 * y + x**2 - 0.5 * y**2,
         x * y**2 - x - 0.5 * y + x**2 - 0.5 * y**2
         ]
    G = [x**2 + x * y - 0.5 * y**2 - x - 0.5 * y,
         y**3 - y,
         x*y**2 - x*y,
         x**2 * y - 0.5 * y**2 - 0.5 * y
         ]

    return R, I, G
Example #37
0
def test_LeadMonomialsEnv_0():
    R, x, y, z = sp.ring('x,y,z', sp.FF(101), 'grevlex')
    F = [y - x**2, z - x**3]
    ideal_gen = FixedIdealGenerator(F)
    env = LeadMonomialsEnv(ideal_gen, elimination='none')
    state = env.reset()
    assert np.array_equal(state, np.array([[2, 0, 0, 3, 0, 0]]))
    state, _, done, _ = env.step(0)
    assert (np.array_equal(state,
                           np.array([[2, 0, 0, 1, 1, 0], [3, 0, 0, 1, 1, 0]]))
            or np.array_equal(
                state, np.array([[3, 0, 0, 1, 1, 0], [2, 0, 0, 1, 1, 0]])))
    assert not done
    action = 0 if np.array_equal(state[0], np.array([3, 0, 0, 1, 1, 0])) else 1
    state, _, done, _ = env.step(action)
    assert np.array_equal(state, np.array([[2, 0, 0, 1, 1, 0]]))
    assert not done
    for _ in range(4):
        state, _, done, _ = env.step(0)
    assert done
Example #38
0
def example_mog(sigma=0):
    R, x1, x2, y1, y2 = ring('x1,x2,y1,y2', RR, lex)
    m1x = x1 + x2
    m1y = y1 + y2
    m2xx = x1**2 + x2**2
    m2xy = x1 * y1 + x2 * y2
    m2yy = y1**2 + y2**2
    ms = [
        m1x,
        m1y,
        m2xx,
        m2xy,
    ]  #m2yy, ]

    if True:
        x1v, x2v = 1, -1
        y1v, y2v = -1, 1

    I = [(m - m(x1v, x2v, y1v, y2v) + sigma * np.random.randn()) for m in ms]

    return R, I
Example #39
0
        def get_measurement_polynomials(self, noise=0, seed=0):
            np.random.seed(seed)

            k, d = self.k, self.d
            params = self.get_parameters()
            R = ring([x for x, _ in params], RR)[0]
            names = {str(x): R(x) for x in R.symbols}
            xs = array([[names[self.x(i, j)] for j in xrange(k)]
                        for i in xrange(d)])
            params = [(names[x], v) for x, v in params]

            # Second order moments (TODO: 3rd order moments)
            P = zeros((d, d), dtype=np.object)
            p = zeros((d, ), dtype=np.object)
            for i in xrange(d):
                p[i] = sum(xs[i, k_] for k_ in xrange(k))  # / k
                for j in xrange(i, d):
                    P[i, j] = sum(xs[i, k_] * xs[j, k_]
                                  for k_ in xrange(k))  # / k

            # Project and profit
            m = zeros((d, ))
            M = zeros((d, d))
            for i in xrange(d):
                m[i] = p[i].evaluate(params)
                for j in xrange(i, d):
                    M[i, j] = P[i, j].evaluate(params)
            M = M + noise * np.random.randn(d, d)
            m = m + noise * np.random.randn(d)
            # TODO: Something is wrong here
            #m = M.sum(1)

            # Finally return values.
            return R, [f - f_ for f, f_ in zip(p.flatten(), m.flatten())] + [
                f - f_ for f, f_ in zip(P[triu_indices_from(P)], M[
                    triu_indices_from(M)])
            ]
Example #40
0
def test_get_order_basis():
    _, x, y = ring('x,y', RR, grevlex)
    f = x**2 + x * y + y
    g = x**2 + x * y + x
    b = get_order_basis([f, g])
    assert b == [(2, 0), (1, 1), (1, 0), (0, 1), (0, 0)]
Example #41
0
def generate_parabolas(N=2, sigma = 0.):
    R, x, y = ring('x, y', RR, order=grevlex)
    thetas = [2 * pi / N * t for t in xrange(N)]
    I = [(x * sin(t) + y * cos(t) - 1)**2 - (x+cos(t))**2 - (y+sin(t))**2 + sigma * randn() for t in thetas]

    return R, I
Example #42
0
def test_get_order_basis():
    _, x, y = ring('x,y', RR, grevlex)
    f = x**2 + x*y + y
    g = x**2 + x*y + x
    b = get_order_basis([f,g])
    assert b == [(2,0), (1,1), (1,0), (0,1), (0,0)]
Example #43
0
# Percy's playground.

from __future__ import print_function
import sympy as sp
import numpy as np
import BorderBasis as BB
np.set_printoptions(precision=3)
from IPython.display import display, Markdown, Math
sp.init_printing()

R, x, y = sp.ring('x,y', sp.RR, order=sp.grevlex)
I = [ x**2 + y**2 - 1.0, x + y ]

R, x, y, z = sp.ring('x,y,z', sp.RR, order=sp.grevlex)
I = [ x**2 - 1, y**2 - 4, z**2 - 9]

# n = 4 takes a long time
n = 4
Rvs = sp.ring(' '.join('v'+str(i) for i in range(1, n + 1)), sp.RR, order=sp.grevlex)
R, vs = Rvs[0], Rvs[1:]
I = []
I.extend([v**2 - 1 for v in vs])
#I.extend([(v-1)**2 for v in vs])
#I.extend([v-1 for v in vs])
#I.extend([vs[i] - vs[i-1] for i in range(1, len(vs))]) # Makes it fast

print('Generating')
B = BB.BorderBasisFactory(1e-5).generate(R,I)
print('Done')

print("=== Generator Basis:")
Example #44
0
def test_border():
    R, x, y = ring('x,y', RR, grevlex)
    O = get_order_basis([x, y])
    dO = border(R, O)
    assert dO == [(2, 0), (1, 1), (0, 2)]
Example #45
0
def test_border_basis_divide():
    R, x, y = ring('x,y', RR, grevlex)
    G = [x**2 + x + 1, x *y + y, y**2 + x + 1]
    f = x**3 * y**2 - x * y**2 + x**2 + 2
    r = border_basis_divide(R, G, f)
    assert r == -3.0 * x - 1.0
Example #46
0
def generate_univariate_problem(n_common_zeros=1, max_degree=3, n_equations=5):
    R, x = ring("x", RR, order=grevlex)
    # set of common zeros.
    V = 1 - 2 * rand(n_common_zeros)
    I = [poly_for_zeros(R, x, np.hstack((V, 1 - 2 * rand(max_degree - n_common_zeros)))) for _ in xrange(n_equations)]
    return R, I, V
Example #47
0
from timeit import default_timer as clock
from sympy import ring, ZZ
R, x, y, z, w = ring("x y z w", ZZ)
e = (x+y+z+w)**15
t1 = clock()
f = e*(e+w)
t2 = clock()
#print f
print "Total time:", t2-t1, "s"
print "number of terms:", len(f)
Example #48
0
def generate_lines(N=2, sigma = 0.):
    R, x, y = ring('x, y', RR, order=grevlex)
    thetas = [2 * pi / N * t for t in xrange(N)]
    I = [x * sin(t) + y * cos(t) + sigma * randn() for t in thetas]

    return R, I
Example #49
0
def test_get_coefficient_term():
    R, x, y, z = ring('x,y,z', QQ, lex)
    f = R(3 * x**2 * y * z + 2 * x**2 * y**2 + z + x * y * z)
    coeff = get_coefficient_term(R, f)
    assert coeff == R(2 * y**2 + 3 * y * z)
Example #50
0
def test_border():
    R, x, y = ring('x,y', RR, grevlex)
    O = get_order_basis([x, y])
    dO = border(R, O)
    assert dO == [(2,0), (1,1), (0,2)]
Example #51
0
def test_border_basis_divide():
    R, x, y = ring('x,y', RR, grevlex)
    G = [x**2 + x + 1, x * y + y, y**2 + x + 1]
    f = x**3 * y**2 - x * y**2 + x**2 + 2
    r = border_basis_divide(R, G, f)
    assert r == -3.0 * x - 1.0
Example #52
0
def generate_lines(N=2, sigma=0.):
    R, x, y = ring('x, y', RR, order=grevlex)
    thetas = [2 * pi / N * t for t in xrange(N)]
    I = [x * sin(t) + y * cos(t) + sigma * randn() for t in thetas]

    return R, I