def apply_to_backend_request(self, block: Block, level: Tuple[Factor, Union[SimpleLevel, DerivedLevel]], backend_request: BackendRequest ) -> None: sublists = self._build_variable_sublists(block, level, self.k) implications = [] # Handle the regular cases (1 => 2 ^ ... ^ n ^ ~n+1) trim = len(sublists) if self.k > 1 else len(sublists) - 1 for idx, l in enumerate(sublists[:trim]): if idx > 0: p_list = [Not(sublists[idx-1][0]), l[0]] p = And(p_list) if len(p_list) > 1 else p_list[0] else: p = l[0] if idx < len(sublists) - 1: q_list = cast(List[Any], l[1:]) + [Not(sublists[idx+1][-1])] q = And(q_list) if len(q_list) > 1 else q_list[0] else: q = And(l[1:]) if len(l[1:]) > 1 else l[self.k - 1] implications.append(If(p, q)) # Handle the tail if len(sublists[-1]) > 1: tail = sublists[-1] tail.reverse() for idx in range(len(tail) - 1): implications.append(If(l[idx], l[idx + 1])) (cnf, new_fresh) = block.cnf_fn(And(implications), backend_request.fresh) backend_request.cnfs.append(cnf) backend_request.fresh = new_fresh
def test_tseitin_rep_and(): from sweetpea.logic import __tseitin_rep, _Cache clauses = [] cache = _Cache(4) # Make sure return is correct, and value was cached. assert __tseitin_rep(And([1, 2, 3]), clauses, cache) == 4 assert cache.get(str(And([1, 2, 3]))) == 4 # Make sure equivalence clauses were added. assert Or([1, Not(4)]) in clauses assert Or([2, Not(4)]) in clauses assert Or([3, Not(4)]) in clauses assert Or([Not(1), Not(2), Not(3), 4]) in clauses # Don't duplicate clauses when the cache was already populated clauses = [] cache = _Cache(4) # Prewarm the cache assert cache.get(str(And([1, 2, 3]))) == 4 assert __tseitin_rep(And([1, 2, 3]), clauses, cache) == 4 # Make sure no clauses were added assert clauses == []
def test_derivation_with_general_window(): block = fully_cross_block([color, text, congruent_bookend], [color, text], []) # congruent bookend - yes d = Derivation(16, [[0, 2], [1, 3]], congruent_bookend) backend_request = BackendRequest(19) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(17, Or([And([1, 3]), And([2, 4])])), Iff(19, Or([And([13, 15]), And([14, 16])])) ]), 19) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] # congruent bookend - no d = Derivation(17, [[0, 3], [1, 2]], congruent_bookend) backend_request = BackendRequest(19) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(18, Or([And([1, 4]), And([2, 3])])), Iff(20, Or([And([13, 16]), And([14, 15])])) ]), 19) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]
def test_eliminate_iff(): from sweetpea.logic import __eliminate_iff # P <-> Q ==> (P v ~Q) ^ (~P v Q) assert __eliminate_iff(Iff(1, 2)) == And([Or([1, Not(2)]), Or([Not(1), 2])]) assert __eliminate_iff(Iff(1, And([2, 3]))) == And([ Or([1, Not(And([2, 3]))]), Or([Not(1), And([2, 3])]) ])
def test_forbid(): f = Forbid(("color", "red")) backend_request = BackendRequest(0) f.apply(block, backend_request) assert backend_request.cnfs == [And([-1, -7, -13, -19])] f = Forbid(("congruent?", "con")) backend_request = BackendRequest(0) f.apply(block, backend_request) assert backend_request.cnfs == [And([-5, -11, -17, -23])]
def test_exclude(): f = Exclude(color, get_level_from_name(color, "red")) backend_request = BackendRequest(0) f.apply(block, backend_request) assert backend_request.cnfs == [And([-1, -7, -13, -19])] f = Exclude(con_factor, get_level_from_name(con_factor, "con")) backend_request = BackendRequest(0) f.apply(block, backend_request) assert backend_request.cnfs == [And([-5, -11, -17, -23])]
def test_distribute_ors_switching(): from sweetpea.logic import __distribute_ors_switching # When lhs or rhs is a single variable, just distribute it. assert __distribute_ors_switching(Or([1, And([2, 3])]), 4) == (And([Or([1, 2]), Or([1, 3])]), 4) assert __distribute_ors_switching(Or([And([1, 2]), 3]), 4) == (And([Or([1, 3]), Or([2, 3])]), 4) # Should distribute over multiple individual variables assert __distribute_ors_switching(Or([1, 2, And([3, 4])]), 5) == (And( [Or([1, 2, 3]), Or([1, 2, 4])]), 5) # When both the lhs and rhs are more than just a single variable, # then introduce a switching variable to limit the formula growth. assert __distribute_ors_switching(Or([And([1, 2]), And([3, 4])]), 5) == (And([ Or([1, Not(5)]), Or([2, Not(5)]), Or([3, 5]), Or([4, 5]) ]), 6)
def apply(block: MultipleCrossBlock, backend_request: BackendRequest) -> None: # Treat each crossing seperately, and repeat the same process as fullycross for c in block.crossing: fresh = backend_request.fresh # Step 1: Get a list of the trials that are involved in the crossing. crossing_size = max(block.min_trials, block.crossing_size()) crossing_trials = list(filter(lambda t: all(map(lambda f: f.applies_to_trial(t), c)), range(1, block.trials_per_sample() + 1))) crossing_trials = crossing_trials[:crossing_size] # Step 2: For each trial, cross all levels of all factors in the crossing. crossing_factors = list(map(lambda t: (list(product(*[block.factor_variables_for_trial(f, t) for f in c]))), crossing_trials)) # Step 3: For each trial, cross all levels of all design-only factors in the crossing. design_factors = cast(List[List[List[int]]], []) design_factors = list(map(lambda _: [], crossing_trials)) for f in list(filter(lambda f: f not in c and not f.has_complex_window, block.design)): for i, t in enumerate(crossing_trials): design_factors[i].append(block.factor_variables_for_trial(f, t)) design_combinations = cast(List[List[Tuple[int, ...]]], []) design_combinations = list(map(lambda l: list(product(*l)), design_factors)) # Step 4: For each trial, combine each of the crossing factors with all of the design-only factors. crossings = cast(List[List[List[Tuple[int, ...]]]], []) for i, t in enumerate(crossing_trials): crossings.append(list(map(lambda c: [c] + design_combinations[i], crossing_factors[i]))) # Step 5: Remove crossings that are not possible. # From here on ignore all values other than the first in every list. crossings = block.filter_excluded_derived_levels(crossings) # Step 6: Allocate additional variables to represent each crossing. num_state_vars = list(map(lambda c: len(c), crossings)) state_vars = list(range(fresh, fresh + sum(num_state_vars))) fresh += sum(num_state_vars) # Step 7: Associate each state variable with its crossing. flattened_crossings = list(chain.from_iterable(crossings)) iffs = list(map(lambda n: Iff(state_vars[n], And([*flattened_crossings[n][0]])), range(len(state_vars)))) # Step 8: Constrain each crossing to occur in only one trial. states = list(chunk(state_vars, block.crossing_size())) transposed = cast(List[List[int]], list(map(list, zip(*states)))) # We Use n < 2 rather than n = 1 here because they may exclude some levels from the crossing. # This ensures that there won't be duplicates, while still allowing some to be missing. # backend_request.ll_requests += list(map(lambda l: LowLevelRequest("LT", 2, l), transposed)) backend_request.ll_requests += list(map(lambda l: LowLevelRequest("GT", 0, l), transposed)) (cnf, new_fresh) = block.cnf_fn(And(iffs), fresh) backend_request.cnfs.append(cnf) backend_request.fresh = new_fresh
def __apply_derivation(self, block: Block, backend_request: BackendRequest) -> None: trial_size = block.variables_per_trial() cross_size = block.trials_per_sample() iffs = [] for n in range(cross_size): or_clause = Or(list(And(list(map(lambda x: x + (n * trial_size) + 1, l))) for l in self.dependent_idxs)) iffs.append(Iff(self.derived_idx + (n * trial_size) + 1, or_clause)) (cnf, new_fresh) = block.cnf_fn(And(iffs), backend_request.fresh) backend_request.cnfs.append(cnf) backend_request.fresh = new_fresh
def test_to_cnf_tseitin(): assert to_cnf_tseitin(Or([1, And([2, 3])]), 4) == (And([ # 4 <=> (2 ^ 3) Or([Not(2), Not(3), 4]), Or([2, Not(4)]), Or([3, Not(4)]), # 5 <=> (1 v 4) Or([1, 4, Not(5)]), Or([Not(1), 5]), Or([Not(4), 5]), # Final clause 5 ]), 6)
def test_uniform_combinatoric_is_always_valid(filename): failures = [] contents = None with open(filename, 'r') as f: contents = f.read() exec(contents, globals(), locals()) if 'block' not in vars(): pytest.fail( "File did not produce a variable named 'block', aborting. file={}". format(filename)) # Build the CNF for this block build_cnf_result = build_cnf(vars()['block']) # Build the sampler enumerator = UCSolutionEnumerator(vars()['block']) # Generate some samples, make sure they're all SAT. sample_count = min(enumerator.solution_count(), 200) print("Checking that UC samples are SAT for {}, sample count={}".format( filename, sample_count)) for s in range(sample_count): sample = enumerator.generate_solution_variables() if not cnf_is_satisfiable(build_cnf_result + CNF(cnf_to_json([And(sample)]))): failures.append("Found UNSAT solution! Solution={} File={}".format( sample, filename)) if failures: pytest.fail( '{} failures occurred in SAT checks for UC sampler: {}'.format( len(failures), failures))
def test_exclude_with_three_derived_levels(): color_list = ["red", "green", "blue"] color = Factor("color", color_list) text = Factor("text", color_list) def count_diff(colors, texts): changes = 0 if (colors[0] != colors[1]): changes += 1 if (texts[0] != texts[1]): changes += 1 return changes def make_k_diff_level(k): def k_diff(colors, texts): return count_diff(colors, texts) == k return DerivedLevel(str(k), Transition(k_diff, [color, text])) changed = Factor( "changed", [make_k_diff_level(0), make_k_diff_level(1), make_k_diff_level(2)]) exclude_constraint = Exclude(changed, get_level_from_name(changed, "2")) design = [color, text, changed] crossing = [color, text] block = fully_cross_block(design, crossing, [exclude_constraint]) backend_request = BackendRequest(0) exclude_constraint.apply(block, backend_request) assert backend_request.cnfs == [ And([-57, -60, -63, -66, -69, -72, -75, -78]) ]
def test_apply_demorgan(): from sweetpea.logic import __apply_demorgan # P ==> P, ~P ==> ~P assert __apply_demorgan(4) == 4 assert __apply_demorgan(Not(4)) == Not(4) # ~~P ==> P assert __apply_demorgan(Not(Not(4))) == 4 # ~(P v Q) ==> ~P ^ ~Q assert __apply_demorgan(Not(Or([1, 2]))) == And([Not(1), Not(2)]) # ~(P ^ Q) ==> ~P v ~Q assert __apply_demorgan(Not(And([1, 2]))) == Or([Not(1), Not(2)]) assert __apply_demorgan(Or([1, Not(And([2, 3]))])) == Or([1, Not(2), Not(3)])
def test_to_cnf_switching(): formula = Or([ And([3, 4]), And([Not(2), Or([1, 5])]) ]) expected_cnf = And([ Or([3, Not(6)]), Or([4, Not(6)]), Or([1, 5, 6]), Or([Not(2), 6]) ]) assert to_cnf_switching(formula, 6) == (expected_cnf, 7) formula = And([ Iff(1, And([2, 3])), Iff(4, And([5, 6])) ]) expected_cnf = And([ Or([1, Not(2), Not(3)]), Or([Not(1), 2]), Or([Not(1), 3]), Or([4, Not(5), Not(6)]), Or([Not(4), 5]), Or([Not(4), 6]) ]) assert to_cnf_switching(formula, 7) == (expected_cnf, 7)
def test_exclude_with_general_window(): block = fully_cross_block([color, text, congruent_bookend], [color, text], []) c = Exclude(congruent_bookend, get_level_from_name(congruent_bookend, "yes")) backend_request = BackendRequest(0) c.apply(block, backend_request) assert backend_request.cnfs == [And([-17, -19])]
def test_is_cnf_still_sat_should_respond_correctly(): # Build the CNF on the server. cnf_result = build_cnf(block) # with open(path_to_cnf_files+'/test_is_cnf_still_sat_should_respond_correctly.cnf', 'w') as f: # f.write(cnf_result.as_unigen_string()) with open( path_to_cnf_files + '/test_is_cnf_still_sat_should_respond_correctly.cnf', 'r') as f: old_cnf = f.read() assert old_cnf == cnf_result.as_unigen_string() assert is_cnf_still_sat(block, [And([1, 3])]) assert not is_cnf_still_sat(block, [And([7, 8])]) assert not is_cnf_still_sat(block, [And([1, 7, 13])])
def test_exclude_with_transition(): block = fully_cross_block([color, text, color_repeats_factor], [color, text], []) c = Exclude(color_repeats_factor, get_level_from_name(color_repeats_factor, "yes")) backend_request = BackendRequest(0) c.apply(block, backend_request) assert backend_request.cnfs == [And([-17, -19, -21])]
def apply_to_backend_request(self, block: Block, level: Tuple[Factor, Union[SimpleLevel, DerivedLevel]], backend_request: BackendRequest) -> None: # Request sublists for k+1 to allow us to determine the transition sublists = self._build_variable_sublists(block, level, self.k + 1) implications = [] if sublists: # Starting corner case implications.append(If(sublists[0][0], And(sublists[0][1:-1]))) for sublist in sublists: implications.append(If(And([Not(sublist[0]), sublist[1]]), And(sublist[2:]))) # Ending corner case implications.append(If(sublists[-1][-1], And(sublists[-1][1:-1]))) (cnf, new_fresh) = block.cnf_fn(And(implications), backend_request.fresh) backend_request.cnfs.append(cnf) backend_request.fresh = new_fresh
def __apply_derivation_with_complex_window(self, block: Block, backend_request: BackendRequest) -> None: trial_size = block.variables_per_trial() trial_count = block.trials_per_sample() iffs = [] f = self.factor window = f.levels[0].window t = 0 for n in range(trial_count): if not f.applies_to_trial(n + 1): continue num_levels = len(f.levels) get_trial_size = lambda x: trial_size if x < block.grid_variables() else len(block.decode_variable(x+1)[0].levels) or_clause = Or(list(And(list(map(lambda x: x + (t * window.stride * get_trial_size(x) + 1), l))) for l in self.dependent_idxs)) iffs.append(Iff(self.derived_idx + (t * num_levels) + 1, or_clause)) t += 1 (cnf, new_fresh) = block.cnf_fn(And(iffs), backend_request.fresh) backend_request.cnfs.append(cnf) backend_request.fresh = new_fresh
def test_cnf_to_json(): assert cnf_to_json([And([1])]) == [[1]] assert cnf_to_json([And([Or([1])])]) == [[1]] assert cnf_to_json([And([Or([Not(5)])])]) == [[-5]] assert cnf_to_json([And([Or([1, 2, Not(4)])])]) == [[1, 2, -4]] assert cnf_to_json([And([Or([1, 4]), Or([5, -4, 2]), Or([-1, -5])])]) == [ [1, 4], [5, -4, 2], [-1, -5]] assert cnf_to_json([And([ Or([1, 3, Not(2)]), Or([1, 3, 5]), Or([1, 4, Not(2)]), Or([1, 4, 5]), Or([2, 3, 1, 5]), Or([2, 4, 1, 5])])]) == [ [1, 3, -2], [1, 3, 5], [1, 4, -2], [1, 4, 5], [2, 3, 1, 5], [2, 4, 1, 5]]
def test_derivation_with_three_level_transition(): f = Factor("f", ["a", "b", "c"]) f_transition = Factor("transition", [ DerivedLevel("aa", Transition(lambda c: c[0] == "a" and c[1] == "a", [f])), DerivedLevel("ab", Transition(lambda c: c[0] == "a" and c[1] == "b", [f])), DerivedLevel("ac", Transition(lambda c: c[0] == "a" and c[1] == "c", [f])), DerivedLevel("ba", Transition(lambda c: c[0] == "b" and c[1] == "a", [f])), DerivedLevel("bb", Transition(lambda c: c[0] == "b" and c[1] == "b", [f])), DerivedLevel("bc", Transition(lambda c: c[0] == "b" and c[1] == "c", [f])), DerivedLevel("ca", Transition(lambda c: c[0] == "c" and c[1] == "a", [f])), DerivedLevel("cb", Transition(lambda c: c[0] == "c" and c[1] == "b", [f])), DerivedLevel("cc", Transition(lambda c: c[0] == "c" and c[1] == "c", [f])), ]) block = fully_cross_block([f, f_transition], [f], []) # a-a derivation d = Derivation(9, [[0, 3]], f_transition) backend_request = BackendRequest(28) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([Iff(10, Or([And([1, 4])])), Iff(19, Or([And([4, 7])]))]), 28) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]
def test_exclude_with_reduced_crossing(): color = Factor("color", ["red", "blue", "green"]) text = Factor("text", ["red", "blue"]) def illegal_stimulus(color, text): return color == "green" and text == "blue" def legal_stimulus(color, text): return not illegal_stimulus(color, text) stimulus_configuration = Factor("stimulus configuration", [ DerivedLevel("legal", WithinTrial(legal_stimulus, [color, text])), DerivedLevel("illegal", WithinTrial(illegal_stimulus, [color, text])) ]) c = Exclude(stimulus_configuration, get_level_from_name(stimulus_configuration, "illegal")) block = fully_cross_block([color, text, stimulus_configuration], [color, text], [c], require_complete_crossing=False) backend_request = BackendRequest(0) c.apply(block, backend_request) assert backend_request.cnfs == [And([-7, -14, -21, -28, -35])]
def test_fully_cross_with_transition_in_crossing(): direction = Factor("direction", ["up", "down"]) block = fully_cross_block([direction, color, color_repeats_factor], [direction, color_repeats_factor], []) backend_request = BackendRequest(29) FullyCross.apply(block, backend_request) (expected_cnf, _) = to_cnf_tseitin( And([ Iff(29, And([5, 21])), Iff(30, And([5, 22])), Iff(31, And([6, 21])), Iff(32, And([6, 22])), Iff(33, And([9, 23])), Iff(34, And([9, 24])), Iff(35, And([10, 23])), Iff(36, And([10, 24])), Iff(37, And([13, 25])), Iff(38, And([13, 26])), Iff(39, And([14, 25])), Iff(40, And([14, 26])), Iff(41, And([17, 27])), Iff(42, And([17, 28])), Iff(43, And([18, 27])), Iff(44, And([18, 28])), ]), 45) assert backend_request.fresh == 78 assert backend_request.cnfs == [expected_cnf] assert backend_request.ll_requests == [ LowLevelRequest("GT", 0, [29, 33, 37, 41]), LowLevelRequest("GT", 0, [30, 34, 38, 42]), LowLevelRequest("GT", 0, [31, 35, 39, 43]), LowLevelRequest("GT", 0, [32, 36, 40, 44]) ]
def test_to_cnf_naive(): assert to_cnf_naive(1, 2) == (And([1]), 2) assert to_cnf_naive(And([1]), 2) == (And([1]), 2) assert to_cnf_naive(And([1, 2]), 3) == (And([1, 2]), 3) assert to_cnf_naive(Or([1, 2]), 3) == (And([Or([1, 2])]), 3) assert to_cnf_naive(Or([1, And([2, 3])]), 4) == (And([Or([1, 2]), Or([1, 3])]), 4) formula = And([ Iff(1, And([2, 3])), Iff(4, And([5, 6])) ]) expected_cnf = And([ Or([1, Not(2), Not(3)]), Or([Not(1), 2]), Or([Not(1), 3]), Or([4, Not(5), Not(6)]), Or([Not(4), 5]), Or([Not(4), 6]) ]) assert to_cnf_switching(formula, 7) == (expected_cnf, 7)
def test_derivation(): # Congruent derivation d = Derivation(4, [[0, 2], [1, 3]], con_factor) backend_request = BackendRequest(24) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(5, Or([And([1, 3]), And([2, 4])])), Iff(11, Or([And([7, 9]), And([8, 10])])), Iff(17, Or([And([13, 15]), And([14, 16])])), Iff(23, Or([And([19, 21]), And([20, 22])])) ]), 24) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] # Incongruent derivation d = Derivation(5, [[0, 3], [1, 2]], con_factor) backend_request = BackendRequest(24) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(6, Or([And([1, 4]), And([2, 3])])), Iff(12, Or([And([7, 10]), And([8, 9])])), Iff(18, Or([And([13, 16]), And([14, 15])])), Iff(24, Or([And([19, 22]), And([20, 21])])) ]), 24) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]
def test_distribute_ors_naive(): from sweetpea.logic import __distribute_ors_naive # When f is int or Not, return it. (Not can only contain int, as we've # already applied DeMorgan's laws) assert __distribute_ors_naive(1) == 1 assert __distribute_ors_naive(Not(1)) == Not(1) # When f in an Or, distribute the Or over the contained clauses. assert __distribute_ors_naive(Or([1, 2])) == And([Or([1, 2])]) assert __distribute_ors_naive(Or([1, And([2, 3])])) == And([Or([1, 2]), Or([1, 3])]) assert __distribute_ors_naive(Or([And([1, 2]), And([3, 4])])) == And([ Or([1, 3]), Or([1, 4]), Or([2, 3]), Or([2, 4]) ]) # When f is an And, disitribute Ors over the contained clauses. assert __distribute_ors_naive(And([1, Not(2)])) == And([1, Not(2)]) assert __distribute_ors_naive(And([1, Or([2, And([3, 4])])])) == And([ Or([2, 3]), Or([2, 4]), 1 ])
def test_derivation_with_transition(): block = fully_cross_block([color, text, color_repeats_factor], [color, text], []) # Color repeats derivation d = Derivation(16, [[0, 4], [1, 5]], color_repeats_factor) backend_request = BackendRequest(23) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(17, Or([And([1, 5]), And([2, 6])])), Iff(19, Or([And([5, 9]), And([6, 10])])), Iff(21, Or([And([9, 13]), And([10, 14])])) ]), 23) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] # Color does not repeat derivation d = Derivation(17, [[0, 5], [1, 4]], color_repeats_factor) backend_request = BackendRequest(23) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(18, Or([And([1, 6]), And([2, 5])])), Iff(20, Or([And([5, 10]), And([6, 9])])), Iff(22, Or([And([9, 14]), And([10, 13])])) ]), 23) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]
def test_derivation_with_multiple_transitions(): block = fully_cross_block( [color, text, color_repeats_factor, text_repeats_factor], [color, text], []) # Text repeats derivation d = Derivation(22, [[2, 6], [3, 7]], text_repeats_factor) backend_request = BackendRequest(29) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(23, Or([And([3, 7]), And([4, 8])])), Iff(25, Or([And([7, 11]), And([8, 12])])), Iff(27, Or([And([11, 15]), And([12, 16])])) ]), 29) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] # Text does not repeat derivation d = Derivation(23, [[2, 7], [3, 6]], text_repeats_factor) backend_request = BackendRequest(29) d.apply(block, backend_request) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ Iff(24, Or([And([3, 8]), And([4, 7])])), Iff(26, Or([And([7, 12]), And([8, 11])])), Iff(28, Or([And([11, 16]), And([12, 15])])) ]), 29) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]
def test_fully_cross_with_uncrossed_simple_factors(): other = Factor('other', ['l1', 'l2']) block = fully_cross_block([color, text, other], [color, text], []) backend_request = BackendRequest(25) FullyCross.apply(block, backend_request) (expected_cnf, _) = to_cnf_tseitin( And([ Iff(25, And([1, 3])), Iff(26, And([1, 4])), Iff(27, And([2, 3])), Iff(28, And([2, 4])), Iff(29, And([7, 9])), Iff(30, And([7, 10])), Iff(31, And([8, 9])), Iff(32, And([8, 10])), Iff(33, And([13, 15])), Iff(34, And([13, 16])), Iff(35, And([14, 15])), Iff(36, And([14, 16])), Iff(37, And([19, 21])), Iff(38, And([19, 22])), Iff(39, And([20, 21])), Iff(40, And([20, 22])) ]), 41) assert backend_request.fresh == 74 assert backend_request.cnfs == [expected_cnf] assert backend_request.ll_requests == [ LowLevelRequest("GT", 0, [25, 29, 33, 37]), LowLevelRequest("GT", 0, [26, 30, 34, 38]), LowLevelRequest("GT", 0, [27, 31, 35, 39]), LowLevelRequest("GT", 0, [28, 32, 36, 40]) ]
def test_exactlykinarow(): backend_request = __run_kinarow( ExactlyKInARow(1, (color, get_level_from_name(color, "red")))) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ If(1, Not(7)), If(And([Not(1), 7]), Not(13)), If(And([Not(7), 13]), Not(19)) ]), 25) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] backend_request = __run_kinarow( ExactlyKInARow(2, (color, get_level_from_name(color, "red")))) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ If(1, And([7, Not(13)])), If(And([Not(1), 7]), And([13, Not(19)])), If(And([Not(7), 13]), 19), If(19, 13) ]), 25) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf] backend_request = __run_kinarow( ExactlyKInARow(3, (color, get_level_from_name(color, "red")))) (expected_cnf, expected_fresh) = to_cnf_tseitin( And([ If(1, And([7, 13, Not(19)])), If(And([Not(1), 7]), And([13, 19])), If(19, 13), If(13, 7) ]), 25) assert backend_request.fresh == expected_fresh assert backend_request.cnfs == [expected_cnf]