def natural_spline(t, knots=None, order=3, intercept=False): """ Return a Formula containing a natural spline Spline for a Term with specified `knots` and `order`. Parameters ---------- t : ``Term`` knots : None or sequence, optional Sequence of float. Default None (same as empty list) order : int, optional Order of the spline. Defaults to a cubic (==3) intercept : bool, optional If True, include a constant function in the natural spline. Default is False Returns ------- formula : Formula A Formula with (len(knots) + order) Terms (if intercept=False, otherwise includes one more Term), made up of the natural spline functions. Examples -------- The following results depend on machine byte order >>> x = Term('x') >>> n = natural_spline(x, knots=[1,3,4], order=3) >>> xval = np.array([3,5,7.]).view(np.dtype([('x', np.float)])) >>> n.design(xval, return_float=True) array([[ 3., 9., 27., 8., 0., -0.], [ 5., 25., 125., 64., 8., 1.], [ 7., 49., 343., 216., 64., 27.]]) >>> d = n.design(xval) >>> print d.dtype.descr [('ns_1(x)', '<f8'), ('ns_2(x)', '<f8'), ('ns_3(x)', '<f8'), ('ns_4(x)', '<f8'), ('ns_5(x)', '<f8'), ('ns_6(x)', '<f8')] >>> """ if knots is None: knots = {} fns = [] for i in range(order + 1): n = 'ns_%d' % i def f(x, i=i): return x**i s = aliased_function(n, f) fns.append(s(t)) for j, k in enumerate(knots): n = 'ns_%d' % (j + i + 1, ) def f(x, k=k, order=order): return (x - k)**order * np.greater(x, k) s = aliased_function(n, f) fns.append(s(t)) if not intercept: fns.pop(0) ff = Formula(fns) return ff
parser.add_argument('-S', help="The strategy to be used") parser.add_argument('input_file', help="The input file containing the SAT problem") # Parse the arguments arguments = parser.parse_args() if not arguments.input_file: raise Exception("Invalid input file") utils.lambda_value = 0.45 utils.beta_value = 0.5 split_method = SplitMethod.DEFAULT if arguments.S == "2": split_method = SplitMethod.MOM elif arguments.S == "3": split_method = SplitMethod.TK formula = Formula(Operation.AND) formula.add_elements_from_file(arguments.input_file) sat_solver = SatSolver(formula, split_method) solved, values = sat_solver.solve() output_file_name = f'{arguments.input_file}.out' file_saver = FileSaver() if solved: file_saver.save_values_in_dimacs(values, output_file_name) else: file_saver.save_values_in_dimacs({}, output_file_name)
signal(SIGPIPE, SIG_DFL) parser = argparse.ArgumentParser( description="Dynamic programming on a TD of a MaxSAT instance") parser.add_argument("file") parser.add_argument("--log", default="info") args = parser.parse_args() log_level_number = getattr(logging, args.log.upper(), None) if not isinstance(log_level_number, int): raise ValueError(f"Invalid log level: {loglevel}") logging.basicConfig(level=log_level_number) with open(args.file) as f: print("Parsing...") formula = Formula(f) log.debug(formula) print("Constructing primal graph...") g = formula.primal_graph() log.debug(g) print("Decomposing...") tds = Decomposer(g, Graph.min_degree_vertex, normalize=TD.weakly_normalize).decompose() assert len(tds) == 1 td = tds[0] log.debug(td) root_table = Table(td, formula) print("Solving...") root_table.compute()
def formula(self): """ Return a Formula with only terms=[self]. """ return Formula([self])
def _construct_tree(self): def add_vertex(stage): vertex = self._graph.add_vertex() index = self._graph.vertex_index[vertex] self._vertices[index] = stage return index def add_edge(i, j): self._graph.add_edge(i, j) phi = Formula() phi.assert_some_states_present(self.protocol.initial_states) root_stage = Stage(set(), set(), set(), set(), phi) root_index = add_vertex(root_stage) unprocessed = [(root_index, root_stage)] mem = {"K": {}, "K_": {}} # For memoization while len(unprocessed) > 0: index, stage = unprocessed.pop(0) children, refined = new_stages(self.protocol, stage, mem, self._use_t_invariants) if not refined: # TODO find criterion to continue if refinement fails self._failed_stages.add(index) continue #self._strong_witness = False #self._all_good = False # If node failed to be expanded, # then flag as failure and skip to next iteration if children is None: self._failed_stages.add(index) continue # Check termination witness if self._check_termination_witness: witness = check_termination_witness(self.protocol, stage, refined) if witness is None: self._failed_witness_stages.add(index) elif witness is False: self._strong_witness = False self._all_good = False elif self._all_good: self._all_good = is_good(self.protocol, stage, mem, self._use_t_invariants) # If stage in stable consensus, then flag its consensus if self.protocol.false_states <= stage.absent: self._true_stages.add(index) elif self.protocol.true_states <= stage.absent: self._false_stages.add(index) # Construct stage successors is_terminal = True for child_stage in children: is_terminal = False # Add child if depth does not exceed max depth if ((self._max_depth is None) or (child_stage.depth() <= self._max_depth)): child_index = add_vertex(child_stage) add_edge(index, child_index) unprocessed.append((child_index, child_stage)) # If stage is terminal, then flag as terminal if is_terminal: self._terminal_stages.add(index)
sizes = list(product(range(2, 10), repeat=3)) print(len(sizes)) architectures = [NeuralNet(size) for size in sizes] for i, nn in enumerate(architectures): start = time.time() nn.train() print(i, time.time() - start) scores = [0 for _ in architectures] testFormulas = FormulaSource() testFormulas.gen_data(NUM_TEST_FORMULAS) numCorrect = 0 numTotal = 0 for f in testFormulas.data: t = TruthTable(Formula(f)) oracle(t) oracleT = copy(t.table) baseline(t) baseT = copy(t.table) nn_tables = [] for nn in architectures: nn.solve_table(t) nn_tables.append(copy(t.table)) for k in oracleT: numTotal += 1 if oracleT[k] == baseT[k]: numCorrect += 1 for i, nnT in enumerate(nn_tables):
def get_formula(formula): """Parsing formula to store as an element -> number of atoms dictionary""" parsed_formula = Formula(formula).parse_formula_to_elem_numatoms() return parsed_formula
def __init__(self: PropagatingFormula, file_object: TextIO) -> None: self.formula = Formula(file_object) self.decision_level: DecisionLevel = 0 self.propagate() self.decision_history: List[Optional[Tuple[Variable, Value]]] = [None]
def new_stage(protocol, stage, valuation, mem): new_valuation = new_stage_valuation(protocol, valuation, stage.disabled) if is_stable_or_dead(protocol, new_valuation, stage.disabled): return Stage(Formula(new_valuation), new_valuation, stage.disabled, speed=Speed.ZERO, parent=stage) F, J, graph, vertices, edges, V = eventually_disabled( protocol, new_valuation, stage.disabled, mem) # Compute new_formula (Φ) and new_disabled (T) if len(F) > 0: if len(J) > 0: new_disabled = set(stage.disabled) | set(J) new_formula = Formula(new_valuation, new_disabled) if v_disabled(J, valuation): new_formula.assert_valuation(valuation) elif v_enabled(J, valuation): K = posts_from_pres(protocol, new_valuation, J) new_formula.assert_some_pair_present(K) # Compute speed if is_very_fast(protocol, new_valuation, stage.disabled): new_speed = Speed.QUADRATIC elif is_fast(protocol, new_valuation, stage.disabled): new_speed = Speed.QUADRATIC_LOG else: new_speed = Speed.CUBIC small, emptycommons = is_small(protocol, new_valuation, stage.disabled, J, graph, vertices, edges, V) if small and emptycommons: new_speed = Speed.QUADRATIC elif small and (not (new_speed == Speed.QUADRATIC)): new_speed = Speed.QUADRATIC_LOG else: new_disabled = set(stage.disabled) | set(F) new_formula = Formula(new_valuation, new_disabled) new_speed = Speed.POLYNOMIAL else: new_disabled = set(stage.disabled) new_formula = Formula(new_valuation, new_disabled) new_speed = Speed.EXPONENTIAL I = compute_I(protocol, new_valuation, stage.disabled) if any(valuation[Var(q)] is True for q in I): L = compute_L(protocol, new_valuation, stage.disabled, I) new_formula.assert_all_states_absent(I) new_formula.assert_some_pair_present(L) elif all(valuation[Var(q)] is False for q in I): new_formula.assert_valuation(valuation) else: new_formula.assert_all_states_absent(I) return Stage(new_formula, new_valuation, new_disabled, speed=new_speed, parent=stage)