def all_differ_from_at_most_k_pos(k, lst): """ Enforce all pairs of distinct vectors of the VECTORS collection to differ from at most K positions. """ nil1 = satx.integer() nil2 = satx.integer() for V in lst: nil1.is_not_in(V) nil2.is_not_in(V) assert nil1 == nil2 t = satx.tensor(dimensions=(len(lst[0]),)) assert sum(t[[i]](0, 1) for i in range(len(lst[0]))) >= len(lst[0]) - k for i1 in range(len(lst) - 1): for i2 in range(i1 + 1, len(lst)): for j in range(len(lst[0])): assert t[[j]](nil1, lst[i1][j]) == t[[j]](nil2, lst[i2][j])
import satx satx.engine(bits=80, cnf_path='4d_perfect_euler_bricks.cnf', simplify=True, signed=True) a = satx.integer() b = satx.integer() c = satx.integer() d = satx.integer() p = satx.integer() q = satx.integer() r = satx.integer() s = satx.integer() t = satx.integer() u = satx.integer() v = satx.integer() satx.apply_single([a, b, c, d, p, q, r, s, t, u, v], lambda x: x > 0) assert a ** 2 + b ** 2 == p ** 2 assert a ** 2 + c ** 2 == q ** 2 assert b ** 2 + c ** 2 == r ** 2 assert a ** 2 + d ** 2 == s ** 2 assert b ** 2 + d ** 2 == t ** 2 assert c ** 2 + d ** 2 == u ** 2 assert a ** 2 + b ** 2 + c ** 2 + d ** 2 == v ** 2 if satx.satisfy(solver='./slime', log=True): print(a, b, c, d, p, q, r, s, t, u, v) else: print('Infeasible...')
""" See model in OscaR A number with an interesting property: when I divide it by v, the remainder is v-1, and this from v ranging from 2 to 9. It's not a small number, but it's not really big, either. When I looked for a smaller number with this property I couldn't find one. Can you find it? """ import satx satx.engine(14, cnf_path='aux.cnf') x = satx.integer() for i in range(2, 10): assert x % i == i - 1 while satx.satisfy('kissat'): print(x)
import satx k = 33 e = 80 satx.engine(bits=3 * e, cnf_path='sum_of_three_cubes_33_unknown_representation.cnf', simplify=True, signed=True) x = satx.integer() y = satx.integer() z = satx.integer() assert satx.one_of([x ** 3 - y ** 3 - z ** 3, x ** 3 + y ** 3 - z ** 3]) == k assert x > 8866128975287528 if satx.satisfy(solver='./slime', log=True): print(x, y, z, x ** 3 - y ** 3 - z ** 3, x ** 3 + y ** 3 - z ** 3) else: print('Infeasible...')
""" See Model in OscaR Martin Gardner Problem: * Call a number "prime-looking" if it is composite but not divisible by 2,3 or 5. * The three smallest prime-looking numbers are 49, 77 and 91. * There are 168 prime numbers less than 1000. * How many prime-looking numbers are there less than 1000? """ import satx satx.engine(10, cnf_path='aux.cnf') # the number we look for x = satx.integer() # a first divider d1 = satx.integer() # a second divider d2 = satx.integer() assert x < 1000 assert 2 <= d1 < 1000 assert 2 <= d2 < 1000 assert x == d1 * d2 assert x % 2 != 0 assert x % 3 != 0 assert x % 5 != 0 assert d1 <= d2
""" My son came to me the other day and said, "Dad, I need help with a math problem." The problem went like this: - We're going out to dinner taking 1-6 grandparents, 1-10 parents and/or 1-40 children - Grandparents cost $3 for dinner, parents $2 and children $0.50 - There must be 20 total people at dinner and it must cost $20 How many grandparents, parents and children are going to dinner? """ import satx satx.engine(10, cnf_path='aux.cnf') # g is the number of grandparents g = satx.integer() # c is the number of children c = satx.integer() # p is the number of parents p = satx.integer() assert 1 <= g <= 7 assert 1 <= p <= 11 assert 1 <= c <= 41 assert g * 6 + p * 2 + c * 1 == 40 assert g + p + c == 20 while satx.satisfy('slime'): print(g, p, c)
import satx satx.engine(bits=80, cnf_path='3d_perfect_euler_bricks.cnf', simplify=True, signed=True) a = satx.integer() b = satx.integer() c = satx.integer() p = satx.integer() q = satx.integer() r = satx.integer() s = satx.integer() satx.apply_single([a, b, c, p, q, r, s], lambda x: x > 0) assert a ** 2 + b ** 2 == p ** 2 assert a ** 2 + c ** 2 == q ** 2 assert b ** 2 + c ** 2 == r ** 2 assert a ** 2 + b ** 2 + c ** 2 == s ** 2 if satx.satisfy(solver='./slime', log=True): print(a, b, c, p, q, r, s) else: print('Infeasible...')
There are 5 non trivial numbers for base 10, and the highest such number is formed of 5 digits. Below, the model is given for base 10. """ from math import ceil import satx # for base 10 n_digits = 5 satx.engine((10**n_digits).bit_length(), cnf_path='aux.cnf') # n is a (non-trivial) Dudeney number n = satx.integer() # s is the perfect cubic root of n s = satx.integer() # d[i] is the ith digit of the Dudeney number d = satx.vector(size=n_digits) satx.apply_single(d, lambda t: t < 10) assert 2 <= n < 10**n_digits assert s < ceil((10**n_digits)**(1 / 3)) + 1 assert n == s * s * s assert sum(d) == s assert satx.dot(d, [10**(n_digits - i - 1) for i in range(n_digits)]) == n while satx.satisfy('slime'): print(n, s, d)
import satx satx.engine(bits=16, cnf_path='brocard_problem.cnf', simplify=True, signed=True) n = satx.integer() m = satx.integer() n.is_not_in([0, 4, 5, 7]) assert satx.factorial(n) + 1 == m**2 if satx.satisfy(solver='./slime', log=True): print(n, m) else: print('Infeasible...')