def test_parse_cnf():
    # Empty formula corner cases
    assert parse_cnf("p cnf 0 0\n") == ('and', )
    assert parse_cnf("p cnf 1 0\n") == ('and', )

    # Empty clause corner cases
    assert parse_cnf("p cnf 0 1\n0") == ('and', ('or', ),)
    assert parse_cnf("p cnf 1 2\n0 0") == ('and', ('or', ),('or', ))

    assert parse_cnf("p cnf 2 2\n-1 2 0 1 -2 0") == ('and', ('or', ('not', ('var', ('x', ), (1, ))), ('var', ('x', ), (2, ))), ('or', ('var', ('x', ), (1, )), ('not', ('var', ('x', ), (2, )))))
    def __init__(self, expression=None, optimization='off', mct_mode='basic'):
        """
        Constructor.

        Args:
            expression (str): The string of the desired logical expression.
                It could be either in the DIMACS CNF format,
                or a general boolean logical expression, such as 'a ^ b' and 'v[0] & (~v[1] | v[2])'
            optimization (str): The mode of optimization to use for minimizing the circuit.
                Currently, besides no optimization ('off'), Aqua also supports an 'espresso' mode
                <https://en.wikipedia.org/wiki/Espresso_heuristic_logic_minimizer>
            mct_mode (str): The mode to use for building Multiple-Control Toffoli.
        """

        self.validate(locals())
        super().__init__()

        self._mct_mode = mct_mode
        self._optimization = optimization

        if expression is None:
            raw_expr = expr(None)
        else:
            try:
                raw_expr = expr(expression)
            except:
                try:
                    raw_expr = ast2expr(parse_cnf(expression.strip(), varname='v'))
                except:
                    raise AquaError('Failed to parse the input expression: {}.'.format(expression))

        self._expr = raw_expr
        self._process_expr()
        self.construct_circuit()
def redistribute_SAT_sols_allDimesions(cnf_input_file, cnf_output_file):
    with open(cnf_input_file, 'r') as f:
        cnf_as_string = f.read()
        cnf_abstract_syntax_tree = parse_cnf(cnf_as_string)

    cnf_expression = ast2expr(cnf_abstract_syntax_tree)
    print(cnf_expression)
    print()

    litmap, nvars, clauses = cnf_expression.encode_cnf()

    # for var in range(1, nvars + 1):
    for var in range(1, 10):
        output_cnf = redistribute_SAT_sols_oneDimesion(input_cnf=cnf_expression, split_var=1)   
        litmap, nvars, clauses = output_cnf.encode_cnf()
        print('split on var', var, 'now we have', len(clauses), 'clauses')
        # for clause in clauses:
        #     for var in clause:
        #         print(var, end=' ')         
        #     print()
        # print()
        cnf_expression = output_cnf

    cnf_string = expr2dimacscnf(output_cnf)
    # print(cnf_string[1])
    # print(type(cnf_string[1]))
    with open(cnf_output_file, 'w') as ofile:
        ofile.write(str(cnf_string[1]))
        
    return output_cnf
Example #4
0
def test_parse_cnf():
    # Empty formula corner cases
    assert parse_cnf("p cnf 0 0\n") == ('and', )
    assert parse_cnf("p cnf 1 0\n") == ('and', )

    # Empty clause corner cases
    assert parse_cnf("p cnf 0 1\n0") == (
        'and',
        ('or', ),
    )
    assert parse_cnf("p cnf 1 2\n0 0") == ('and', ('or', ), ('or', ))

    assert parse_cnf("p cnf 2 2\n-1 2 0 1 -2 0") == ('and',
                                                     ('or', ('not',
                                                             ('var', ('x', ),
                                                              (1, ))),
                                                      ('var', ('x', ), (2, ))),
                                                     ('or', ('var', ('x', ),
                                                             (1, )),
                                                      ('not', ('var', ('x', ),
                                                               (2, )))))
    exit(0)

    # /atlas/u/jkuck/sharpSAT/build/Release/sharpSAT /atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/hypercube.cnf
    # /atlas/u/jkuck/sharpSAT/build/Release/sharpSAT /atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/test_redistribute_cnf.cnf
    # /atlas/software/cluster/cryptominisat/build/cryptominisat5 --printsol 0  --verb 1 --maxtime=8 --maxsol=1 /atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/test_redistribute_cnf.cnf

    '''
python3 /atlas/u/jkuck/F2_clean/src/python/f2.py --cmsat-exe /atlas/u/jkuck/software/cryptominisat_BIRD/cryptominisat-5.6.6/build/cryptominisat5 --cmsat-version 5 --skip-sharpsat --sharpsat-exe /atlas/u/jkuck/sharpSAT/build/Release/sharpSAT --mode lb --var-degree 1 --max-time 3600 --error-prob .05  --random-seed 0 /atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/test_redistribute_cnf.cnf
python3 /atlas/u/jkuck/F2_clean/src/python/f2.py --cmsat-exe /atlas/u/jkuck/software/cryptominisat_BIRD/cryptominisat-5.6.6/build/cryptominisat5 --cmsat-version 5 --skip-sharpsat --sharpsat-exe /atlas/u/jkuck/sharpSAT/build/Release/sharpSAT --mode lb --var-degree 3 --max-time 3600 --error-prob .05  --random-seed 0 /atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/c432.isc

    '''
    cnf_file = '/atlas/u/jkuck/low_density_parity_checks/SAT_problems_cnf/%s' % 'test_cnf.cnf'
              
    with open(cnf_file, 'r') as f:
        cnf_as_string = f.read()
        abstract_syntax_tree = parse_cnf(cnf_as_string)

    expression = ast2expr(abstract_syntax_tree)
    print(expression)
    print()

    litmap, nvars, clauses = expression.encode_cnf()
    print("litmap:", litmap)
    print("nvars:", nvars)
    print("clauses:", clauses)
    print()

    half1_orig_cnf_as_expr = None
    for clause in clauses:
        cur_vars = []
        for var in clause: