├── makefile.in
├── LICENSE
├── src
    ├── hash_val.h
    ├── substitution_engine.h
    ├── parser.h
    ├── hash_val.cpp
    ├── polynomial_solver.h
    ├── nss.h
    ├── variable.h
    ├── substitution_engine.cpp
    ├── slicing.h
    ├── monomial.cpp
    ├── signal_statistics.h
    ├── monomial.h
    ├── aig.cpp
    ├── pac.h
    ├── parser.cpp
    ├── signal_statistics.cpp
    ├── polynomial_solver.cpp
    ├── aig.h
    ├── pac.cpp
    ├── polynomial.h
    ├── term.h
    ├── nss.cpp
    ├── elimination.h
    ├── term.cpp
    ├── substitution.h
    ├── amulet.cpp
    ├── polynomial.cpp
    ├── gate.cpp
    ├── gate.h
    └── slicing.cpp
├── configure.sh
├── README.md
└── includes
    ├── LICENSE
    └── aiger.h


/makefile.in:
--------------------------------------------------------------------------------
 1 | CC=@CC@
 2 | CFLAGS=@CFLAGS@
 3 | DEP=@DEP@
 4 | 
 5 | BUILD_PATH=build/
 6 | SRC_PATH=src/
 7 | SRC      :=  $(wildcard src/*.cpp) \
 8 | 
 9 | OBJECTS := $(SRC:$(SRC_PATH)%.cpp=$(BUILD_PATH)%.o)
10 | 
11 | all: aiger amulet
12 | 
13 | aiger:
14 | 	gcc -O3 -DNDEBUG -c includes/aiger.c -o includes/aiger.o
15 | 
16 | $(BUILD_PATH)%.o: $(SRC_PATH)%.cpp
17 | 	$(CC) $(CFLAGS) $(INCLUDE) -c $< -o $@
18 | 
19 | amulet: $(OBJECTS) aiger
20 | 	$(CC) $(CFLAGS)  -o  $@ $(OBJECTS) includes/aiger.o -lgmp
21 | 
22 | clean:
23 | 	rm -f amulet makefile includes/aiger.o \
24 | 	rm -rf build/
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Daniela Kaufmann
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/hash_val.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file hash_val.h
 3 |     \brief contains functions used to compute hash values for variables
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_HASH_VAL_H_
10 | #define AMULET2_SRC_HASH_VAL_H_
11 | /*------------------------------------------------------------------------*/
12 | #include <assert.h>
13 | 
14 | #include <string>
15 | /*------------------------------------------------------------------------*/
16 | 
17 | 
18 | /**
19 |     Fills a 32-bit array with 64-bit random numbers
20 | */
21 | void init_nonces();
22 | 
23 | /**
24 |     Returns the 64-bit random number in our array of random numbers
25 | 
26 |     @param index size_t
27 | 
28 |     @return returns the random number stored in nonces[index]
29 | */
30 | uint64_t get_nonces_entry(size_t index);
31 | 
32 | /**
33 |     Computes the hash value for the given string
34 | 
35 |     @param str a const std::string
36 | 
37 |     @return a uint64_t computed hash value for the input string
38 | */
39 | uint64_t hash_string(const std::string& str);
40 | 
41 | #endif  // AMULET2_SRC_HASH_VAL_H_
42 | 


--------------------------------------------------------------------------------
/src/substitution_engine.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file substitution_engine.h
 3 |     \brief contains the substitution engine
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_SUBSTITUTION_ENGINE_H_
10 | #define AMULET2_SRC_SUBSTITUTION_ENGINE_H_
11 | /*------------------------------------------------------------------------*/
12 | #include "substitution.h"
13 | /*------------------------------------------------------------------------*/
14 | /**
15 |     Initializes the internal gate structure, with necessary informations
16 |     for substitution.
17 |     Uses the AIG module
18 | */
19 | void init_gate_substitution();
20 | 
21 | /**
22 |     Calls the substitution routine.
23 |     We first detect the GP adder, then generate the equivalent miter
24 |     and print the CNF miter and the rewritten AIG to the output files.
25 | 
26 |     @param out_f1 name of first output file
27 |     @param out_f2 name of second output file
28 | 
29 |     @returns boolean whether substitution happened (1) or original is returned (0)
30 | */
31 | bool substitution(const char * out_f1, const char * out_f2);
32 | 
33 | 
34 | #endif  // AMULET2_SRC_SUBSTITUTION_ENGINE_H_
35 | 


--------------------------------------------------------------------------------
/src/parser.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file parser.h
 3 |     \brief contains functions necessary to parse the AIG
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_PARSER_H_
10 | #define AMULET2_SRC_PARSER_H_
11 | /*------------------------------------------------------------------------*/
12 | #include "aig.h"
13 | /*------------------------------------------------------------------------*/
14 | /**
15 |     Checks whether 'model' contains an aiger node with
16 |     output lhs and inputs rhs0 and rhs1.
17 | 
18 |     @param lhs unsigned integer
19 |     @param rhs0 unsigned integer
20 |     @param rhs1 unsigned integer
21 | 
22 |     @return True if 'model' contains such an aiger node
23 | */
24 | bool match_and(unsigned lhs, unsigned rhs0, unsigned rhs1);
25 | 
26 | /**
27 |     Identifies whether the input vectors are separated or interleaved.
28 | */
29 | void determine_input_order();
30 | 
31 | /**
32 |     Checks whether the input AIG fullfills our requirements.
33 | */
34 | void init_aiger_with_checks();
35 | 
36 | /**
37 |     Reads the input aiger given in the file called input_name to the aiger 'model'
38 |     using the parserer function of aiger.h
39 | 
40 |     @param input_name char * ame of input file
41 | */
42 | void parse_aig(const char * input_name);
43 | 
44 | 
45 | #endif  // AMULET2_SRC_PARSER_H_
46 | 


--------------------------------------------------------------------------------
/src/hash_val.cpp:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file hash_val.cpp
 3 |     \brief contains functions used to compute hash values for variables
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #include <random>
10 | 
11 | #include "hash_val.h"
12 | /*------------------------------------------------------------------------*/
13 | // Local variables
14 | 
15 | // / array used to hold 64-bit random numbers
16 | uint64_t nonces[32];
17 | 
18 | // / number of random numbers
19 | const size_t num_nonces = sizeof nonces / sizeof nonces[0];
20 | 
21 | std::random_device rd;
22 | std::mt19937_64 gen(42);
23 | std::uniform_int_distribution<unsigned long long> dis;
24 | /*------------------------------------------------------------------------*/
25 | 
26 | 
27 | void init_nonces() {
28 |   for (size_t i = 0; i < num_nonces; i++)
29 |     nonces[i] = dis(gen) | 1;
30 | }
31 | 
32 | /*------------------------------------------------------------------------*/
33 | 
34 | uint64_t get_nonces_entry(size_t index) {
35 |   assert(index < 32);
36 |   return nonces[index];
37 | }
38 | 
39 | /*------------------------------------------------------------------------*/
40 | 
41 | uint64_t hash_string(const std::string& str) {
42 |   uint64_t res = 0;
43 |   size_t i = 0;
44 |   for (std::string::const_iterator it = str.cbegin(); it != str.cend(); ++it) {
45 |     res += *it;
46 |     res *= nonces[i++];
47 |     if (i == num_nonces) i = 0;
48 |   }
49 |   return res;
50 | }
51 | 


--------------------------------------------------------------------------------
/src/polynomial_solver.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file polynomial_solver.h
 3 |     \brief contains the polynomial solving routine
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_POLYNOMIAL_SOLVER_H_
10 | #define AMULET2_SRC_POLYNOMIAL_SOLVER_H_
11 | /*------------------------------------------------------------------------*/
12 | #include "elimination.h"
13 | /*------------------------------------------------------------------------*/
14 | // / If final remainder is not equal to zero a counter example is generated and
15 | // / printed to file <input_name>.wit, default is true, can be turned of
16 | //  using command line input
17 | extern bool gen_witness;
18 | /*------------------------------------------------------------------------*/
19 | 
20 | /**
21 |     Initializes the internal gate structure, with necessary informations
22 |     for verification.
23 |     Uses the AIG module
24 | */
25 | void init_gates_verify();
26 | 
27 | /**
28 |     Calls the preprocessing, slicing, reduction routines
29 |     If certify is true, files need to be provided to store the proof.
30 | 
31 |     @param inp_f name of input file
32 |     @param out_f1 name of first output file
33 |     @param out_f2 name of second output file
34 |     @param out_f3 name of third output file
35 |     @param certify true when modus -certify is used
36 | 
37 |     @returns boolean whether circuit is correct (1) or incorrect (0)
38 | */
39 | bool verify(const char * inp_f = 0,
40 |             const char * out_f1 = 0,
41 |             const char * out_f2 = 0,
42 |             const char * out_f3 = 0,
43 |             bool certify = 0);
44 | 
45 | 
46 | #endif  // AMULET2_SRC_POLYNOMIAL_SOLVER_H_
47 | 


--------------------------------------------------------------------------------
/src/nss.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file nss.h
 3 |     \brief contains functions necessary to generate Nullstellensatz proofs
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_NSS_H_
10 | #define AMULET2_SRC_NSS_H_
11 | /*------------------------------------------------------------------------*/
12 | #include "gate.h"
13 | /*------------------------------------------------------------------------*/
14 | /**
15 |     Prints the specification polynomial to the file
16 | 
17 |     @param file output file
18 | */
19 | void print_spec_poly(FILE * file);
20 | /**
21 |     Prints the circuit poly to the file(without indices)
22 | 
23 |     @param file output file
24 | */
25 | void print_circuit_poly_nss(FILE * file);
26 | 
27 | /**
28 |     Prints the cofactors of the circuit polynomials
29 | 
30 |     @param file output file for cofactors
31 | */
32 | void print_cofactors_poly_nss(FILE * file);
33 | 
34 | 
35 | /**
36 |     Adding an ancestor polynomial to the ancestors of n
37 | 
38 |     @param n      Gate* to which ancestor is added
39 |     @param anc    Gate* to Ancestor gate
40 |     @param fac    Polynomial* definng ancestor polynomial
41 |     @param depth  true if function is called internally(default = 0)
42 | */
43 | void add_ancestors(
44 |   Gate * n, Gate * anc, const Polynomial * fac, bool internal = 0);
45 | 
46 | /**
47 |     Updates the cofactor of the modulo polynomial
48 | 
49 |     @param fac Polynomial* which is added to the cofactor of the modpoly
50 | */
51 | void add_fac_mod(const Polynomial * fac);
52 | 
53 | /**
54 |     Updates the cofactor of the gate n
55 | 
56 |     @param n      Gate* for which the cofactor is updated
57 |     @param fac    Polynomial* which is added to the cofactor of n
58 | */
59 | void add_fac(Gate * n, const Polynomial * fac);
60 | 
61 | #endif  // AMULET2_SRC_NSS_H_
62 | 


--------------------------------------------------------------------------------
/src/variable.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file variable.h
 3 |     \brief contains the class Var
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_VARIABLE_H_
10 | #define AMULET2_SRC_VARIABLE_H_
11 | /*------------------------------------------------------------------------*/
12 | #include <string>
13 | #include <cstdint>
14 | 
15 | #include "hash_val.h"
16 | /*------------------------------------------------------------------------*/
17 | 
18 | /** \class Var
19 |     represents a variable is assigned to a gate(see <gate.h>) and is
20 |     used to represent variables in terms, see <term.h>
21 | */
22 | 
23 | class Var {
24 |     // / name of variable
25 |     const std::string name;
26 | 
27 |     // / Hash value of variables, used for storing terms
28 |     int hash;
29 | 
30 |     // / Increasing value that indicates the order of the variable
31 |     const int level;
32 | 
33 |     // / corresponding value used to relate AIG gates to Gate class
34 |     const int num;
35 | 
36 |  public:
37 |   /** Constructor
38 | 
39 |      @param name_ name
40 |      @param level_ level
41 |      @param num_ num, default is 0
42 | 
43 |   */
44 |   Var(std::string name_, int level_, int num_ = 0):
45 |      name(name_),  level(level_), num(num_) {
46 |        hash = hash_string(name_);
47 |      }
48 | 
49 |    /** Getter for member name, and converts string to char*
50 | 
51 |        @return const char *
52 |    */
53 |   const char * get_name() const {return name.c_str();}
54 | 
55 |   /** Getter for member hash
56 | 
57 |       @return integer
58 |   */
59 |   int get_hash() const {return hash;}
60 | 
61 |   /** Getter for member level
62 | 
63 |       @return integer
64 |   */
65 |   int get_level() const {return level;}
66 | 
67 |   /** Getter for member num
68 | 
69 |       @return integer
70 |   */
71 |   int get_num() const {return num;}
72 | };
73 | 
74 | 
75 | #endif  // AMULET2_SRC_VARIABLE_H_
76 | 


--------------------------------------------------------------------------------
/src/substitution_engine.cpp:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file substitution_engine.cpp
 3 |     \brief contains the substitution engine
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #include "substitution_engine.h"
10 | 
11 | /*------------------------------------------------------------------------*/
12 | // ERROR CODES:
13 | static int err_write_file  = 51; // error write to file
14 | static int err_write_aig   = 52; // error write aig
15 | /*------------------------------------------------------------------------*/
16 | void init_gate_substitution() {
17 |   allocate_gates();
18 |   mark_aig_outputs();
19 |   set_parents_and_children(0);
20 |   set_xor();
21 | }
22 | 
23 | /*------------------------------------------------------------------------*/
24 | 
25 | bool substitution(const char * out_f1, const char * out_f2) {
26 |   assert(out_f1);
27 |   assert(out_f2);
28 | 
29 |   FILE * f1;
30 |   if (!(f1 = fopen(out_f1, "w")))
31 |       die(err_write_file, "can not write output to '%s'", out_f1);
32 | 
33 |   FILE *f2;
34 |   if (!(f2 = fopen(out_f2, "w")))
35 |       die(err_write_aig, "can not write output to '%s'", out_f2);
36 | 
37 |   init_aig_substitution();
38 |   init_time = process_time();
39 | 
40 |   bool res;
41 | 
42 |   if (identify_final_stage_adder() && build_adder_miter()) {
43 |     res = 1;
44 | 
45 |     if (!miter_to_file(f1))
46 |       die(err_write_file, "failed to write miter to '%s'", out_f1);
47 |     else
48 |       msg("writing miter to %s", out_f1);
49 | 
50 |     generate_rewritten_aig();
51 | 
52 |     if (!aiger_write_to_file(rewritten, aiger_binary_mode, f2))
53 |       die(err_write_aig, "failed to write rewritten aig to '%s'", out_f2);
54 |     else
55 |       msg("writing rewritten aig to '%s'", out_f2);
56 | 
57 | 
58 |   } else {
59 |     res = 0;
60 | 
61 |     if (!trivial_miter_to_file(f1))
62 |       die(err_write_file, "failed to write trivial miter to '%s'", out_f1);
63 |     else
64 |       msg("writing trivial miter to %s", out_f1);
65 | 
66 |     if (!write_model(f2))
67 |       die(err_write_aig, "failed to write original aig to '%s'", out_f2);
68 |     else
69 |       msg("writing original aig to '%s'", out_f2);
70 |   }
71 | 
72 |   substitution_time = process_time();
73 | 
74 |   fclose(f1);
75 |   fclose(f2);
76 |   reset_aig_substitution();
77 | 
78 |   return res;
79 | }
80 | 


--------------------------------------------------------------------------------
/src/slicing.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file slicing.h
 3 |     \brief contains functions slice and order the gates
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_SLICING_H_
10 | #define AMULET2_SRC_SLICING_H_
11 | /*------------------------------------------------------------------------*/
12 | #include <vector>
13 | #include <list>
14 | 
15 | #include "gate.h"
16 | /*------------------------------------------------------------------------*/
17 | // / vector-list Gate* matrix to store slices
18 | extern std::vector<std::list<Gate*>> slices;
19 | /*------------------------------------------------------------------------*/
20 | 
21 | /**
22 |     Allocates the memory for the slices
23 |     and adds the output gate of each slice
24 | */
25 | void init_slices();
26 | 
27 | /**
28 |     Prints the polynomials in the slices to stdout
29 | */
30 | void print_slices();
31 | 
32 | 
33 | /**
34 |     Returns the child that has the highest position in a slice
35 | 
36 |     @param n Gate* for parent
37 | 
38 |     @return Gate*
39 | */
40 | const Gate * topological_largest_child(const Gate * n);
41 | 
42 | /**
43 |     Overall slicing routine based on xor gates, calls all other functions
44 |     automatically
45 | */
46 | bool slicing_xor();
47 | 
48 | /*------------------------------------------------------------------------*/
49 | 
50 | /**
51 |     Mark the children of gate n to slice num, if not assigned otherwise.
52 | 
53 |     @param n Gate*
54 |     @param num integer for  slice index
55 | */
56 | void input_cone(Gate * n, int num);
57 | 
58 | /**
59 |     Identify those gates that are input in bigger slices
60 | */
61 | void find_carries();
62 | 
63 | /**
64 |     Identifies whether polynomials use a booth pattern(as in the aoki benchmarks)
65 | 
66 |     @return True if booth pattern are found
67 | */
68 | bool search_for_booth_pattern();
69 | 
70 | /**
71 |    We repeatedly move gates to smaller slices.
72 | */
73 | void merge_all();
74 | 
75 | /**
76 |     We repeatedly move gates to bigger slices.
77 | */
78 | void promote_all();
79 | 
80 | /**
81 |     Fills the slices by adding the gates that are assigned to slices
82 | */
83 | void fill_slices();
84 | 
85 | 
86 | /**
87 |     Undoes slicing attempt
88 | */
89 | void clean_slices();
90 | 
91 | /**
92 |     Overall slicing routine, that does not depend on xor-chains
93 | */
94 | void slicing_non_xor();
95 | 
96 | #endif  // AMULET2_SRC_SLICING_H_
97 | 


--------------------------------------------------------------------------------
/src/monomial.cpp:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file monomial.cpp
 3 |     \brief contains the class Monomial and further functions to
 4 |     manipulate monomials
 5 | 
 6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 8 | */
 9 | /*------------------------------------------------------------------------*/
10 | #include "monomial.h"
11 | /*------------------------------------------------------------------------*/
12 | 
13 | Monomial::Monomial(mpz_t _c, Term * _t): ref(1) {
14 |   mpz_init_set(coeff, _c);
15 |   if (mpz_sgn(_c) == 0) term = 0;
16 |   else  term = _t;
17 | }
18 | 
19 | /*------------------------------------------------------------------------*/
20 | 
21 | Monomial * Monomial::copy() {
22 |   Monomial * m = this;
23 |   if (!m) return 0;
24 |   assert(ref > 0);
25 | 
26 |   ++ref;
27 |   assert(ref);
28 |   return this;
29 | }
30 | 
31 | /*------------------------------------------------------------------------*/
32 | 
33 | Monomial::~Monomial() {
34 |   assert(ref == 0);
35 | 
36 |   mpz_clear(coeff);
37 |   deallocate_term(term);
38 | }
39 | 
40 | /*------------------------------------------------------------------------*/
41 | 
42 | void Monomial::print(FILE * file, bool lm) const {
43 |   int sign = mpz_sgn(coeff);
44 |   if (!sign) return;
45 |   else if (!lm && sign > 0) fputc_unlocked('+', file);
46 | 
47 |   if (term) {
48 |     if (mpz_cmp_si(coeff, -1) == 0) { fputc_unlocked('-', file);
49 |     } else if (mpz_cmp_si(coeff, 1) != 0) {
50 |       mpz_out_str(file, 10, coeff);
51 |       fputc_unlocked('*', file);
52 |     } term->print(file);
53 |   }
54 |   else  mpz_out_str(file, 10, coeff);
55 | }
56 | 
57 | /*------------------------------------------------------------------------*/
58 | 
59 | Monomial * multiply_monomial(const Monomial * m1, const Monomial *m2) {
60 |   assert(m1);
61 |   assert(m2);
62 | 
63 |   mpz_t coeff;
64 |   mpz_init(coeff);
65 |   mpz_mul(coeff, m1->coeff, m2->coeff);
66 | 
67 |   Term * t;
68 |   if (m1->get_term() && m2->get_term())
69 |     t = multiply_term(m1->get_term(), m2->get_term());
70 |   else if (m2->get_term()) t = m2->get_term_copy();
71 |   else if (m1->get_term()) t = m1->get_term_copy();
72 |   else
73 |     t = 0;
74 | 
75 |   Monomial * mon = new Monomial(coeff, t);
76 | 
77 |   mpz_clear(coeff);
78 |   return mon;
79 | }
80 | 
81 | /*------------------------------------------------------------------------*/
82 | 
83 | void deallocate_monomial(Monomial * m) {
84 |   assert(m->get_ref() > 0);
85 |   if (m->dec_ref() > 0) return;
86 | 
87 |   delete(m);
88 | }
89 | 


--------------------------------------------------------------------------------
/src/signal_statistics.h:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file signal_statistics.h
 3 |     \brief used to handle signals, messages and statistics
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #ifndef AMULET2_SRC_SIGNAL_STATISTICS_H_
10 | #define AMULET2_SRC_SIGNAL_STATISTICS_H_
11 | /*------------------------------------------------------------------------*/
12 | #include <stdarg.h>
13 | #include <signal.h>
14 | #include <sys/time.h>
15 | #include <sys/resource.h>
16 | 
17 | #include <iostream>
18 | /*------------------------------------------------------------------------*/
19 | extern void(*original_SIGINT_handler)(int);
20 | extern void(*original_SIGSEGV_handler)(int);
21 | extern void(*original_SIGABRT_handler)(int);
22 | extern void(*original_SIGTERM_handler)(int);
23 | 
24 | /**
25 |     Returns name of signal
26 | 
27 |     @param sig integer
28 | 
29 |     @return char *
30 | */
31 | const char * signal_name(int sig);
32 | 
33 | /**
34 |     Initialize all signals
35 | */
36 | void init_all_signal_handers();
37 | 
38 | 
39 | /**
40 |     Catch signal and prints corresponding message
41 | 
42 |     @param sig integer
43 | */
44 | void catch_signal(int sig);
45 | 
46 | /**
47 |     Resets all signal handlers
48 | */
49 | void reset_all_signal_handlers();
50 | 
51 | /*------------------------------------------------------------------------*/
52 | // / Level of output verbosity, ranges from 0 to 4
53 | extern int verbose;
54 | 
55 | /**
56 |     Prints an error message to stderr and exits the program
57 | 
58 |     @param char* fmt message
59 |     @param int error_code
60 | */
61 | void die(int error_code, const char *fmt,...);
62 | 
63 | /**
64 |     Prints a message to stdout
65 | 
66 |     @param char* fmt message
67 | */
68 | void msg(const char *fmt, ...);
69 | /*------------------------------------------------------------------------*/
70 | 
71 | // / Time measures used for verify/certify modus
72 | extern double init_time;          // /< measure initializing time
73 | extern double slicing_elim_time;  // /< measure time used to eliminate & slice
74 | extern double reduction_time;     // /< measure time used to reduce
75 | extern double reset_time;         // /< measure resetting time
76 | extern double substitution_time;  // /< measure time used in substitution
77 | 
78 | /**
79 |     Determines max used memory
80 | */
81 | size_t maximum_resident_set_size();
82 | 
83 | /**
84 |     Determines the used process time
85 | */
86 | double process_time();
87 | 
88 | /**
89 |     Print statistics of maximum memory and used process time depending on
90 |     selected modus
91 | 
92 |     @param modus integer
93 | */
94 | void print_statistics(int modus);
95 | 
96 | #endif  // AMULET2_SRC_SIGNAL_STATISTICS_H_
97 | 


--------------------------------------------------------------------------------
/configure.sh:
--------------------------------------------------------------------------------
  1 | #!/bin/sh
  2 | die () {
  3 |   echo "*** configure.sh: $*" 1>&2
  4 |   exit 1
  5 | }
  6 | usage () {
  7 | cat <<EOF
  8 | usage: configure.sh [ <option> ... ]
  9 | 
 10 | where <option> is one of the following
 11 | 
 12 |   -h      print this command line option summary
 13 |   -g      compile with debugging support
 14 |   -c      compile with assertion checking (default with '-g')
 15 | 
 16 | and for debugging and testing you can also use
 17 | 
 18 |   --test-only          do not compile checker but only unit test
 19 |   --verbose-parsing    print scanned tokens and parsed polynomials
 20 | EOF
 21 | }
 22 | debug=no
 23 | check=undefined
 24 | test
 25 | while [ $# -gt 0 ]
 26 | do
 27 |   case "$1" in
 28 |     -h|--help) usage; exit 0;;
 29 |     -c) check=yes;;
 30 |     -g) debug=yes;;
 31 |     -*) die "invalid option '$1' (try '-h')";;
 32 |   esac
 33 |   shift
 34 | done
 35 | if [ $debug = yes ]
 36 | then
 37 |   check=yes
 38 | elif [ $check = undefined ]
 39 | then
 40 |   check=no
 41 | fi
 42 | CFLAGS="-Wall -Wextra -std=c++11"
 43 | if [ $debug = yes ]
 44 | then
 45 |   CFLAGS="$CFLAGS -g3"
 46 | else
 47 |   CFLAGS="$CFLAGS -O3"
 48 | fi
 49 | [ $check = no ] && CFLAGS="$CFLAGS -DNDEBUG"
 50 | [ "$CC" = "" ] && CC=g++
 51 | 
 52 | 
 53 | if [ -d /tmp/ ]
 54 | then
 55 |   tmp=/tmp/amulet-configure-$$
 56 |   trap "rm -f $tmp*" 2
 57 | cat >$tmp.c <<EOF
 58 | #include <stdio.h>
 59 | #include <stdlib.h>
 60 | #include <sys/time.h>
 61 | #include <sys/resource.h>
 62 | int main () {
 63 |   struct rusage u;
 64 |   if (getrusage (RUSAGE_SELF, &u)) return 0;
 65 |   double t = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
 66 |   t += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
 67 |   size_t s = ((size_t) u.ru_maxrss) << 10;
 68 |   printf ("%f seconds\n%zu bytes\n", t, s);
 69 |   return 42;
 70 | }
 71 | EOF
 72 |   if $CC $CFLAGS $tmp.c -o $tmp.exe 1>/dev/null 2>/dev/null
 73 |   then
 74 |     $tmp.exe 1>/dev/null 2>/dev/null
 75 |     [ $? = 42 ] && CFLAGS="$CFLAGS -DHAVEGETRUSAGE"
 76 |   fi
 77 |   rm -f $tmp*
 78 | cat >$tmp.c <<EOF
 79 | #include <stdio.h>
 80 | int main () {
 81 |   FILE * file = fopen ("configure.sh", "r");
 82 |   if (!file) return 1;
 83 |   int ch = getc_unlocked (file);
 84 |   fclose (file);
 85 |   return ch == '#' ? 42 : 1;
 86 | }
 87 | EOF
 88 |   if $CC $CFLAGS $tmp.c -o $tmp.exe 1>/dev/null 2>/dev/null
 89 |   then
 90 |     $tmp.exe 1>/dev/null 2>/dev/null
 91 |     [ $? = 42 ] && CFLAGS="$CFLAGS -DHAVEUNLOCKEDIO"
 92 |   fi
 93 |   rm -f $tmp*
 94 | fi
 95 | AIGLIB="../aiger/aiger.o"
 96 | 
 97 | 
 98 | echo "$CC $CFLAGS"
 99 | rm -f makefile
100 | 
101 | BUILD=build/
102 | if [ -d "$BUILD" ]
103 | then
104 |   echo "reusing existing build directory '$BUILD'"
105 | else
106 |   mkdir "$BUILD" || exit 1
107 |   echo "new build directory '$BUILD'"
108 | fi
109 | 
110 | 
111 | sed \
112 |   -e "s,@CC@,$CC," \
113 |   -e "s,@CFLAGS@,$CFLAGS," \
114 |   -e "s,@AIGLIB@,$AIGLIB," \
115 | makefile.in > makefile
116 | 


--------------------------------------------------------------------------------
/src/monomial.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file monomial.h
  3 |     \brief contains the class Monomial and further functions to
  4 |     manipulate monomials
  5 | 
  6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  8 | */
  9 | /*------------------------------------------------------------------------*/
 10 | #ifndef AMULET2_SRC_MONOMIAL_H_
 11 | #define AMULET2_SRC_MONOMIAL_H_
 12 | /*------------------------------------------------------------------------*/
 13 | #include <gmp.h>
 14 | 
 15 | #include "term.h"
 16 | /*------------------------------------------------------------------------*/
 17 | 
 18 | /** \class Monomial
 19 |     This class is used to represent monomials in a polynomial.
 20 |     A monomial consist of a coefficient and a term.
 21 | */
 22 | 
 23 | class Monomial {
 24 |   // / Term*
 25 |   Term * term;
 26 | 
 27 |   // / reference counter
 28 |   unsigned ref;
 29 | 
 30 |  public:
 31 |   // / Coefficient
 32 |   mpz_t coeff;
 33 | 
 34 |   /** Constructor
 35 | 
 36 |       @param c mpz_t coefficient
 37 |       @param t Term*
 38 |   */
 39 |   Monomial(mpz_t _c, Term * _t);
 40 | 
 41 |   /** Getter for member term
 42 | 
 43 |       @return Term*
 44 |   */
 45 |   Term * get_term()       const {return term;}
 46 | 
 47 |   /** Getter for member term, calls copy routine of Term
 48 | 
 49 |       @return a copy of Term* term
 50 |   */
 51 |   Term * get_term_copy()  const {return term->copy();}
 52 | 
 53 |   /** Returns the size fo the term
 54 | 
 55 |       @return unsigned, the size of the term
 56 |   */
 57 |   unsigned get_term_size() const {return term->size();}
 58 | 
 59 |   /** Decreases the reference counter
 60 | 
 61 |       @return the decreases reference counter
 62 |   */
 63 |   unsigned dec_ref()             {return --ref;}
 64 | 
 65 |   /** Getter for the reference counter
 66 | 
 67 |       @return member ref
 68 |   */
 69 |   unsigned get_ref()       const {return ref;}
 70 | 
 71 |   /**
 72 |   Copy routine
 73 | 
 74 |   @return Same monomial with increased reference counter
 75 |   */
 76 |   Monomial * copy();
 77 | 
 78 |   /**
 79 |   Printing routine
 80 | 
 81 |   @param file Output file
 82 |   @param lm bool indicating whether we print a leading monomial
 83 |   */
 84 |   void print(FILE * file, bool lm = 0) const;
 85 | 
 86 |   /** Destructor */
 87 |   ~Monomial();
 88 | };
 89 | /*------------------------------------------------------------------------*/
 90 | 
 91 | /**
 92 |   Multiplies two monomials
 93 | 
 94 |   @param m1 Monomial*
 95 |   @param m2 Monomial*
 96 | 
 97 |   @return Product of m1*m2
 98 | */
 99 | Monomial * multiply_monomial(const Monomial * m1, const Monomial *m2);
100 | 
101 | /**
102 |   Wrapper for deconstructor, reduces the references of m until 0.
103 |   Then deconstructor is called.
104 | 
105 |   @param m Monomial*
106 | */
107 | void deallocate_monomial(Monomial * m);
108 | 
109 | #endif  // AMULET2_SRC_MONOMIAL_H_
110 | 


--------------------------------------------------------------------------------
/src/aig.cpp:
--------------------------------------------------------------------------------
 1 | /*------------------------------------------------------------------------*/
 2 | /*! \file aig.cpp
 3 |     \brief contains functions to parse and manipulate the input AIG
 4 | 
 5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
 6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 7 | */
 8 | /*------------------------------------------------------------------------*/
 9 | #include "aig.h"
10 | /*------------------------------------------------------------------------*/
11 | // Global Variables
12 | unsigned M, NN;
13 | unsigned a0, al, ainc;
14 | unsigned b0, bl, binc;
15 | 
16 | aiger * rewritten;
17 | aiger * miter;
18 | /*------------------------------------------------------------------------*/
19 | // Local Variables
20 | 
21 | aiger * model;   // /< aiger* object, used for storing the given AIG graph
22 | /*------------------------------------------------------------------------*/
23 | void init_aig_substitution() {
24 |   rewritten = aiger_init();
25 |   miter = aiger_init();
26 | }
27 | /*------------------------------------------------------------------------*/
28 | void reset_aig_substitution() {
29 |   aiger_reset(rewritten);
30 |   aiger_reset(miter);
31 | }
32 | /*------------------------------------------------------------------------*/
33 | void init_aig_parsing() {
34 |   model = aiger_init();
35 | }
36 | /*------------------------------------------------------------------------*/
37 | void reset_aig_parsing() {
38 |   aiger_reset(model);
39 | }
40 | /*------------------------------------------------------------------------*/
41 | const char * aiger_open_and_read_to_model(const char * input_name) {
42 |   return aiger_open_and_read_from_file(model, input_name);
43 | }
44 | /*------------------------------------------------------------------------*/
45 | 
46 | bool is_model_input(unsigned val) {
47 |   return aiger_is_input(model, val);
48 | }
49 | /*------------------------------------------------------------------------*/
50 | aiger_and * is_model_and(unsigned val) {
51 |   return aiger_is_and(model, val);
52 | }
53 | /*------------------------------------------------------------------------*/
54 | unsigned get_model_num_latches() {return model->num_latches;}
55 | unsigned get_model_num_inputs() {return model->num_inputs;}
56 | unsigned get_model_num_ands()   {return model->num_ands;}
57 | unsigned get_model_num_outputs() {return model->num_outputs;}
58 | unsigned get_model_maxvar()     {return model->maxvar;}
59 | /*------------------------------------------------------------------------*/
60 | unsigned get_model_inputs_lit(unsigned i) {
61 |   assert(i < NN);
62 |   return model->inputs[i].lit;
63 | }
64 | /*------------------------------------------------------------------------*/
65 | const char* get_model_inputs_name(unsigned i) {
66 |   assert(i < NN);
67 |   return model->inputs[i].name;
68 | }
69 | /*------------------------------------------------------------------------*/
70 | unsigned slit(unsigned i) {
71 |   if (!model) return -1;
72 |   assert(i < NN);
73 |   return model->outputs[i].lit;
74 | }
75 | /*------------------------------------------------------------------------*/
76 | int write_model(FILE *file) {
77 |   return aiger_write_to_file(model, aiger_binary_mode, file);
78 | }
79 | /*------------------------------------------------------------------------*/
80 | 


--------------------------------------------------------------------------------
/src/pac.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file pac.h
  3 |     \brief contains functions necessary to generate PAC proofs
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #ifndef AMULET2_SRC_PAC_H_
 10 | #define AMULET2_SRC_PAC_H_
 11 | /*------------------------------------------------------------------------*/
 12 | 
 13 | #include "gate.h"
 14 | /*------------------------------------------------------------------------*/
 15 | 
 16 | /**
 17 |     Prints all initial gate constraints to the file(with indices)
 18 | 
 19 |     @param file output file
 20 | */
 21 | void print_circuit_poly(FILE * file);
 22 | 
 23 | /**
 24 |     Prints a deletion rule
 25 | 
 26 |     @param p1 Polynomial*
 27 |     @param file output file
 28 | */
 29 | void print_pac_del_rule(FILE * file, const Polynomial *p1);
 30 | 
 31 | /**
 32 |     Prints the modulo rule
 33 | 
 34 |     @param file output file
 35 |     @param p1   Polynomial*, factor
 36 |     @param p    Polynomial*, conclusion
 37 | */
 38 | void print_pac_mod_rule(FILE * file, const Polynomial *p1, Polynomial *p);
 39 | 
 40 | /**
 41 |     Prints an addition rule for pac
 42 | 
 43 |     @param file output file
 44 |     @param p1   Polynomial*, First summand
 45 |     @param p2   Polynomial*, Second summand
 46 |     @param p    Polynomial*, Conclusion
 47 | */
 48 | void print_pac_add_rule(
 49 |   FILE * file, const Polynomial *p1, const Polynomial *p2, Polynomial *p);
 50 | 
 51 |   /**
 52 |       Prints a combination rule for pac sum(indices) = p
 53 | 
 54 |       @param file output file
 55 |       @param indices std::vector<int>
 56 |       @param p    Polynomial*, Conclusion
 57 |   */
 58 | void print_pac_vector_add_rule(
 59 |   FILE * file, std::vector<int> indices, Polynomial * p);
 60 | 
 61 | 
 62 | /**
 63 |     Prints a combination rule for pac p1*p2+p3=p
 64 | 
 65 |     @param file output file
 66 |     @param p    Polynomial*, Conclusion
 67 |     @param p1   Polynomial*, first poly
 68 |     @param p2   Polynomial*, first factor
 69 |     @param p3   Polynomial*, second poly
 70 |     @param p3   Polynomial*, second factor
 71 | */
 72 | void print_pac_combi_rule(
 73 |   FILE * file, const Polynomial *p1, const Polynomial *p2,
 74 |   const Polynomial *p3, const Polynomial *p4, Polynomial *p);
 75 | 
 76 |   /**
 77 |       Prints a combination rule for pac <indices>*<co_factors> = p
 78 | 
 79 |       @param file output file
 80 |       @param indices std::vector<int>
 81 |       @param co_factors std::vector<const Polynomial*>
 82 |       @param p    Polynomial*, Conclusion
 83 |   */
 84 | void print_pac_vector_combi_rule(
 85 |   FILE * file, std::vector<int> indices,
 86 |   std::vector<const Polynomial*> co_factors, Polynomial * p);
 87 | 
 88 | /**
 89 |     Prints the multiplication rule of pac
 90 | 
 91 |     @param file output file
 92 |     @param p1   Polynomial*, First factor
 93 |     @param p2   Polynomial*, Second factor
 94 |     @param p    Polynomial*, Conclusion
 95 | */
 96 | void print_pac_mul_rule(
 97 |   FILE * file, const Polynomial *p1, const Polynomial *p2, Polynomial *p);
 98 | 
 99 | #endif  // AMULET2_SRC_PAC_H_
100 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 2 | 
 3 | AMulet 2.2 - AIG Multiplier Examination Tool
 4 | ================================================================================
 5 | 
 6 | Our tool AMulet 2.2 is able to verify and certify unsigned and signed 
 7 | integer multipliers given as AIGs.
 8 | 
 9 | For further information we refer to the paper
10 | 
11 | Daniela Kaufmann, Armin Biere. 
12 |  [`AMulet 2.0 for Verifying Multiplier Circuits.`](https://danielakaufmann.at/kaufmannbiere-tacas21/)
13 | In Proc. 14th Intl. Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS), 8 pages, 2021.
14 | 
15 | and the corresponding website http://fmv.jku.at/amulet2  
16 |   
17 | ----------------------------------------------------------------  
18 |   
19 | Dependencies: `libgmp` (https://gmplib.org/)
20 | 
21 | Use `./configure.sh && make` to configure and build `AMulet 2.2`.
22 | 
23 | 
24 | usage : `amulet <mode> <input.aig> <output files> [<option> ...]`
25 | 
26 | Depending on the `<mode>` the `<output files>` and `<options>` have to be set accordingly:
27 | 
28 | 
29 |     <mode> = -substitute:
30 |       <output files> =  2 output files need to be passed in the following order 
31 |         <out.cnf>:        miter for checking the equivalence of the substituted adder 
32 |         <out.aig>:        rewritten aiger is stored in this file` 
33 | 
34 |       <option> = the following options are available 
35 |         -h | --help       print this command line summary 
36 |         -v<1,2,3,4>       different levels of verbosity  (default -v1)
37 |         -signed           option for signed integer multipliers 
38 | 
39 | 
40 |     <mode> = -verify:
41 |       <output files> =  no output files are required 
42 |       
43 |       <option> = the following options are available 
44 |          -h | --help           print this command line summary 
45 |          -v<1,2,3,4>           different levels of verbosity (default -v1) 
46 |          -signed               option for signed integer multipliers    
47 |          -no-counter-examples  do not generate and write counter examples
48 |      
49 |      
50 |     <mode> = -certify:
51 |       <output files> =  3 output files need to be passed in the following order
52 |         <out.polys>:      initial polynomial set 
53 |         <out.proof>:      proof rules (depending whether PAC proof or NS proof is generated) 
54 |         <out.spec> :      spec which should be checked 
55 |       
56 |       <option> = the following options are available 
57 |          -h | --help           print this command line summary 
58 |          -v<1,2,3,4>           different levels of verbosity (default -v1) 
59 |          -signed               option for signed integer multipliers 
60 |          -no-counter-examples  do not generate and write counter examples
61 | 
62 |          -p1          expanded proof (no linear combinations, only multiplication and addition)
63 |          -p2          middle condensed proof(sequence of linear combinations, default)
64 |          -p3          condensed proof(one single linear combination)
65 | 
66 | --------------------------------------------------
67 | 28.10.2022 AMulet 2.2:
68 |   - Several bugfixes in the slicing routine, described in our TAP'22 paper [`Fuzzing and Delta Debugging And-Inverter Graph Verification Tools.`](https://danielakaufmann.at/wp-content/uploads/2022/07/TAP_Kaufmann.pdf)
69 | 
70 | 10.09.2021 AMulet 2.1:
71 |   - Reducing memory usage by changing data structure of polynomials
72 | 
73 | 17.02.2021 AMulet 2.1:  
74 |   - Instead of PAC and NSS we now support LPAC on different abstraction levels
75 |     See https://github.com/d-kfmnn/pacheck2 for a corresponding proof checker.
76 |            
77 |   - Optimized polynomial generation 
78 | 
79 | 


--------------------------------------------------------------------------------
/src/parser.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file parser.cpp
  3 |     \brief contains functions necessary to parse the AIG
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include "parser.h"
 10 | /*------------------------------------------------------------------------*/
 11 | // ERROR CODES:
 12 | static int err_parsing       = 20; // general parsing error
 13 | static int err_latches       = 21; // cannot handle latches
 14 | static int err_no_inputs     = 22; // no inputs
 15 | static int err_odd_inputs    = 23; // odd inputs
 16 | static int err_no_outputs    = 24; // no outputs
 17 | static int err_wrong_outputs = 25; // wrong number of outputs
 18 | /*------------------------------------------------------------------------*/
 19 | 
 20 | bool match_and(unsigned lhs, unsigned rhs0, unsigned rhs1) {
 21 |   if (lhs == aiger_false) return 0;
 22 |   if (aiger_sign(lhs)) return 0;
 23 |   assert(lhs != aiger_true);
 24 | 
 25 |   aiger_and * and1 = is_model_and(lhs);
 26 |   if (!and1) return 0;
 27 |   if (and1->rhs0 == rhs0 && and1->rhs1 == rhs1) return 1;
 28 |   if (and1->rhs0 == rhs1 && and1->rhs1 == rhs0) return 1;
 29 |   return 0;
 30 | }
 31 | 
 32 | /*------------------------------------------------------------------------*/
 33 | void determine_input_order() {
 34 |   unsigned s0 = 0, sl = NN-1;
 35 |   if (match_and(
 36 |         slit(0),
 37 |         get_model_inputs_lit(0),
 38 |         get_model_inputs_lit(1))) {
 39 |     a0 = 0, al = NN-2, ainc = 2;
 40 |     b0 = 1, bl = NN-1, binc = 2;
 41 |     msg("assuming ordering as in BTOR generated benchmarks");
 42 |   } else {
 43 |     a0 = 0, al = NN/2-1,   ainc = 1;
 44 |     b0 = NN/2, bl = NN-1, binc = 1;
 45 |     msg("assuming ordering as in the ABC generated or AOKI benchmarks");
 46 |   }
 47 |   if (verbose >= 2) {
 48 |     if (NN == 2) {
 49 |       msg("a[0] = input[%d]", a0);
 50 |       msg("b[0] = input[%d]", b0);
 51 |       msg("s[0] = output[%d]", s0);
 52 |     } else if (NN == 4) {
 53 |       msg("(a[0], a[1]) =(input[%d], input[%d])", a0, al);
 54 |       msg("(b[0], b[1]) =(input[%d], input[%d])", b0, bl);
 55 |       msg("(s[0], ..., s[3]) =(output[%d], ..., output[%d])", s0, sl);
 56 |     } else if (NN == 6) {
 57 |       msg("(a[0], a[1], a[2]) =(input[%d], input[%d], input[%d])",
 58 |         a0, a0 + ainc, al);
 59 |       msg("(b[0], b[1], b[2]) =(input[%d], input[%d], input[%d])",
 60 |         b0, b0 + binc, bl);
 61 |       msg("(s[0], ..., s[5]) =(output[%d], ..., output[%d])", s0, sl);
 62 |     } else {
 63 |       msg("(a[0], a[1], ..., a[%d]) =(input[%d], input[%d], ..., input[%d])",
 64 |         NN/2-1, a0, a0 + ainc, al);
 65 |       msg("(b[0], b[1], ..., b[%d]) =(input[%d], input[%d], ..., input[%d])",
 66 |         NN/2-1, b0, b0 + binc, bl);
 67 |       msg("(s[0], ..., s[%d]) =(output[%d], ..., output[%d])",
 68 |         NN-1, s0, sl);
 69 |     }
 70 |   }
 71 | }
 72 | 
 73 | /*------------------------------------------------------------------------*/
 74 | 
 75 | void init_aiger_with_checks() {
 76 |   if (get_model_num_latches()) die(err_latches, "can not handle latches");
 77 |   if (!get_model_num_inputs()) die(err_no_inputs, "no inputs");
 78 |   if ((get_model_num_inputs() & 1)) die(err_odd_inputs, "odd number of inputs");
 79 |   if (!get_model_num_outputs()) die(err_no_outputs, "no outputs");
 80 |   if (get_model_num_outputs() == get_model_num_inputs()) {
 81 |     M = get_model_maxvar() + 1;
 82 |     NN = get_model_num_outputs();
 83 |   }
 84 |   else  die(err_wrong_outputs, "expected %u but got %u outputs",
 85 |       get_model_num_inputs(), get_model_num_outputs());
 86 | 
 87 | 
 88 |   msg("MILOA %u %u %u %u %u",
 89 |     get_model_maxvar(),
 90 |     get_model_num_inputs(),
 91 |     get_model_num_latches(),
 92 |     get_model_num_outputs(),
 93 |     get_model_num_ands());
 94 | 
 95 |   determine_input_order();
 96 | }
 97 | 
 98 | /*------------------------------------------------------------------------*/
 99 | 
100 | void parse_aig(const char * input_name) {
101 |   init_aig_parsing();
102 | 
103 |   msg("reading '%s'", input_name);
104 |   const char * err = aiger_open_and_read_to_model(input_name);
105 |   if (err) die(err_parsing, "error parsing '%s': %s", input_name, err);
106 | 
107 |   init_aiger_with_checks();
108 | }
109 | 


--------------------------------------------------------------------------------
/src/signal_statistics.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file signal_statistics.cpp
  3 |     \brief used to handle signals, messages and statistics
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | 
 10 | #include "signal_statistics.h"
 11 | 
 12 | /*------------------------------------------------------------------------*/
 13 | // Global variable
 14 | void(*original_SIGINT_handler)(int);
 15 | void(*original_SIGSEGV_handler)(int);
 16 | void(*original_SIGABRT_handler)(int);
 17 | void(*original_SIGTERM_handler)(int);
 18 | /*------------------------------------------------------------------------*/
 19 | 
 20 | const char * signal_name(int sig) {
 21 |   switch (sig) {
 22 |     case SIGINT: return "SIGINT";
 23 |     case SIGSEGV: return "SIGSEGV";
 24 |     case SIGABRT: return "SIGABRT";
 25 |     case SIGTERM: return "SIGTERM";
 26 |     default: return "SIGUNKNOWN";
 27 |   }
 28 | }
 29 | 
 30 | /*------------------------------------------------------------------------*/
 31 | 
 32 | void init_all_signal_handers() {
 33 |   original_SIGINT_handler  = signal(SIGINT,  catch_signal);
 34 |   original_SIGSEGV_handler = signal(SIGSEGV, catch_signal);
 35 |   original_SIGABRT_handler = signal(SIGABRT, catch_signal);
 36 |   original_SIGTERM_handler = signal(SIGTERM, catch_signal);
 37 | }
 38 | 
 39 | /*------------------------------------------------------------------------*/
 40 | 
 41 | void catch_signal(int sig) {
 42 |   printf("c\nc caught signal '%s'(%d)\nc\n", signal_name(sig), sig);
 43 |   printf("c\nc raising signal '%s'(%d) again\n", signal_name(sig), sig);
 44 |   reset_all_signal_handlers();
 45 |   fflush(stdout);
 46 |   raise(sig);
 47 | }
 48 | 
 49 | /*------------------------------------------------------------------------*/
 50 | 
 51 | void reset_all_signal_handlers() {
 52 |   (void) signal(SIGINT, original_SIGINT_handler);
 53 |   (void) signal(SIGSEGV, original_SIGSEGV_handler);
 54 |   (void) signal(SIGABRT, original_SIGABRT_handler);
 55 |   (void) signal(SIGTERM, original_SIGTERM_handler);
 56 | }
 57 | 
 58 | /*------------------------------------------------------------------------*/
 59 | // Global variable
 60 | int verbose = 1;
 61 | /*------------------------------------------------------------------------*/
 62 | 
 63 | void msg(const char *fmt, ...) {
 64 |   va_list ap;
 65 |   fputs_unlocked("[amulet2] ", stdout);
 66 |   va_start(ap, fmt);
 67 |   vfprintf(stdout, fmt, ap);
 68 |   va_end(ap);
 69 |   fputc_unlocked('\n', stdout);
 70 |   fflush(stdout);
 71 | }
 72 | 
 73 | /*------------------------------------------------------------------------*/
 74 | 
 75 | void die(int error_code, const char *fmt, ...) {
 76 |   fflush(stdout);
 77 |   va_list ap;
 78 |   fprintf(stderr, "*** [amulet2] error code %i \n", error_code);
 79 |   fputs_unlocked("*** [amulet2] ", stderr);
 80 |   va_start(ap, fmt);
 81 |   vfprintf(stderr, fmt, ap);
 82 |   va_end(ap);
 83 |   fputc('\n', stderr);
 84 |   fflush(stderr);
 85 |   exit(error_code);
 86 | }
 87 | 
 88 | /*------------------------------------------------------------------------*/
 89 | // Global variables
 90 | 
 91 | double init_time, slicing_elim_time, reduction_time, reset_time;
 92 | double substitution_time;
 93 | 
 94 | /*------------------------------------------------------------------------*/
 95 | 
 96 | size_t maximum_resident_set_size() {
 97 |   struct rusage u;
 98 |   if (getrusage(RUSAGE_SELF, &u)) return 0;
 99 |   return((size_t) u.ru_maxrss) << 10;
100 | }
101 | 
102 | /*------------------------------------------------------------------------*/
103 | 
104 | double process_time() {
105 |   struct rusage u;
106 |   if (getrusage(RUSAGE_SELF, &u)) return 0;
107 |   double res = u.ru_utime.tv_sec + 1e-6 * u.ru_utime.tv_usec;
108 |   res += u.ru_stime.tv_sec + 1e-6 * u.ru_stime.tv_usec;
109 |   return res;
110 | }
111 | 
112 | /*------------------------------------------------------------------------*/
113 | 
114 | void print_statistics(int modus) {
115 |   msg("");
116 |   msg("maximum resident set size:     %22.2f MB",
117 |     maximum_resident_set_size() / static_cast<double>((1<<20)));
118 |   msg("used time for initializing:    %22.2f seconds",
119 |       init_time);
120 |   if (modus == 1) {
121 |     msg("used time for substituion:     %22.2f seconds",
122 |       substitution_time - init_time);
123 |     msg("used time for freeing memory:  %22.2f seconds",
124 |       reset_time - substitution_time);
125 |   } else {
126 |     msg("used time for slicing/elimination: %18.2f seconds",
127 |       slicing_elim_time - init_time);
128 |     msg("used time for reduction:           %18.2f seconds",
129 |       reduction_time - slicing_elim_time);
130 |     msg("used time for freeing memory:      %18.2f seconds",
131 |       reset_time  -reduction_time);
132 |   }
133 |   msg("total process time:            %22.2f seconds",  process_time());
134 | }
135 | 


--------------------------------------------------------------------------------
/src/polynomial_solver.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file polynomial_solver.cpp
  3 |     \brief contains the polynomial solving routine
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include "polynomial_solver.h"
 10 | /*------------------------------------------------------------------------*/
 11 | // Global variable
 12 | bool gen_witness = 1;
 13 | /*------------------------------------------------------------------------*/
 14 | // ERROR CODES:
 15 | static int err_writing = 41; // cannot write to
 16 | static int err_rem_poly =42; // remainder poly no witness
 17 | /*------------------------------------------------------------------------*/
 18 | void init_gates_verify() {
 19 |   init_mpz(NN);
 20 |   allocate_gates();
 21 |   mark_aig_outputs();
 22 |   set_parents_and_children(1);
 23 |   set_xor();
 24 | }
 25 | 
 26 | /*------------------------------------------------------------------------*/
 27 | // Print all gate constraints to `file` (if `file` is 0 prints to stdout)
 28 | static void print_all_gate_constraints(FILE * file) {
 29 |   for (unsigned i = NN; i < M-1; ++i) {
 30 |     Gate * g = gates[i];
 31 |     if (!g) continue;
 32 |     Polynomial * p = g->get_gate_constraint();
 33 |     if (!p) continue;
 34 |     if (file) {
 35 |       fprintf(file, "[amulet2] gate %s:\n", g->get_var_name());
 36 |       p->print(file);
 37 |       fprintf(file, "\n");
 38 |     } else {
 39 |       fprintf(stdout, "[amulet2] gate %s:\n", g->get_var_name());
 40 |       p->print(stdout);
 41 |       fprintf(stdout, "\n");
 42 |     }
 43 |   }
 44 | 
 45 |   // outputs
 46 |   for (unsigned j = 0; j < NN; ++j) {
 47 |     Gate * g = gates[j+M-1];
 48 |     if (!g) continue;
 49 |     Polynomial * p = g->get_gate_constraint();
 50 |     if (!p) continue;
 51 |     if (file) {
 52 |       fprintf(file, "[amulet2] output %s:\n", g->get_var_name());
 53 |       p->print(file);
 54 |       fprintf(file, "\n");
 55 |     } else {
 56 |       fprintf(stdout, "[amulet2] output %s:\n", g->get_var_name());
 57 |       p->print(stdout);
 58 |       fprintf(stdout, "\n");
 59 |     }
 60 |   }
 61 | }
 62 | 
 63 | /*------------------------------------------------------------------------*/
 64 | 
 65 | bool verify(const char * inp_f, const char * out_f1,
 66 |             const char * out_f2, const char * out_f3, bool certify) {
 67 |   assert(!certify || inp_f);
 68 |   assert(!certify || out_f1);
 69 |   assert(!certify || out_f2);
 70 |   assert(!certify || out_f3);
 71 | 
 72 |   FILE * f1 = 0, *f2 = 0, *f3 = 0;
 73 |   if (certify) {
 74 |     if (!(f1 = fopen(out_f1, "w")))
 75 |     die(err_writing, "can not write output to '%s'", out_f1);
 76 | 
 77 |     if (!(f2 = fopen(out_f2, "w")))
 78 |     die(err_writing, "can not write output to '%s'", out_f2);
 79 | 
 80 |     if (!(f3 = fopen(out_f3, "w")))
 81 |     die(err_writing, "can not write output to '%s'", out_f3);
 82 |   }
 83 | 
 84 |   if (certify) {
 85 |     print_circuit_poly(f1);
 86 |     print_spec_poly(f3);
 87 |   }
 88 | 
 89 |   init_slices();
 90 | 
 91 |   mark_xor_chain_in_last_slice();
 92 |   init_time = process_time();
 93 | 
 94 |   //print gate constraints before elimination
 95 |   print_all_gate_constraints(f2);
 96 | 
 97 | 
 98 |   remove_internal_xor_gates(f2);
 99 |   bool non_xor_slice = upper_half_xor_output();
100 |   bool xor_slicing_failure = 0;
101 |   if(non_xor_slice){
102 |     msg("slicing based on xor");
103 |     remove_single_occs_gates(f2);
104 | 
105 |     xor_slicing_failure = slicing_xor();
106 |     if(!xor_slicing_failure) remove_slice_minus_one_gates(f2);
107 |     else clean_slices();
108 |   }
109 | 
110 |   if (!non_xor_slice || xor_slicing_failure) {
111 |     msg("slicing based on input cones");
112 |     xor_chain = 1;
113 |     slicing_non_xor();
114 | 
115 |     if (search_for_booth_pattern()) eliminate_booth_pattern(f2);
116 |     decomposing(f2);
117 | 
118 |   }
119 | 
120 | 
121 | 
122 |   slicing_elim_time = process_time();
123 | 
124 |   const Polynomial * rem = reduce(f2);
125 |   bool res;
126 |   if (rem && !rem->is_constant_zero_poly())  {
127 |     if (!check_inputs_only(rem)){
128 |       msg("REMAINDER IS");
129 |       fputs("[amulet2] ", stdout);
130 |       rem->print(stdout);
131 |       msg("");
132 |       die(err_rem_poly, "slicing failure - remainder polynomial contains non-inputs");
133 | 
134 |     }
135 | 
136 |     res = 0;
137 |     msg("INCORRECT MULTIPLIER");
138 |     msg("");
139 | 
140 |     if (inp_f && gen_witness) {
141 |       msg("REMAINDER IS");
142 |       fputs("[amulet2] ", stdout);
143 |       rem->print(stdout);
144 |       msg("");
145 |       generate_witness(rem, inp_f);
146 |     }
147 |   } else {
148 |     res = 1;
149 |     msg("");
150 |     msg("CORRECT MULTIPLIER");
151 |     if (certify) {
152 |       msg("");
153 |       msg("writing gate constraints to '%s' ", out_f1);
154 |       msg("writing proof certificate to '%s'", out_f2);
155 |       msg("writing specification to '%s'    ", out_f3);
156 |     }
157 |   }
158 |   delete(rem);
159 | 
160 |   if (proof == 3) print_cofactors_poly_nss(f2);
161 | 
162 |   reduction_time = process_time();
163 |   if (certify) {
164 |     fclose(f1);
165 |     fclose(f2);
166 |     fclose(f3);
167 |   }
168 |   return res;
169 | }
170 | 


--------------------------------------------------------------------------------
/src/aig.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file aig.h
  3 |     \brief contains functions to parse and manipulate the input AIG
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #ifndef AMULET2_SRC_AIG_H_
 10 | #define AMULET2_SRC_AIG_H_
 11 | /*------------------------------------------------------------------------*/
 12 | #include <assert.h>
 13 | 
 14 | #include "signal_statistics.h"
 15 | 
 16 | extern "C" {
 17 |   #include "../includes/aiger.h"
 18 | }
 19 | /*------------------------------------------------------------------------*/
 20 | 
 21 | extern unsigned M;   // /< stores the maximum variable num of the input AIG
 22 | extern unsigned NN;  // /< stores the number of inputs of the input AIG
 23 | 
 24 | extern unsigned a0;    // /< input value for the LSB of input vector A
 25 | extern unsigned al;    // /< input value for the MSB of input vector A
 26 | extern unsigned ainc;  // /< distance between aiger values of A
 27 | 
 28 | extern unsigned b0;    // /< input value for the LSB of input vector B
 29 | extern unsigned bl;    // /< input value for the MSB of input vector B
 30 | extern unsigned binc;  // /< distance between aiger values of B
 31 | 
 32 | 
 33 | // / aiger * storing the generated miter during '-substitution'
 34 | // / Will be transformed into CNF and printed to the provided output file.
 35 | extern aiger * miter;
 36 | 
 37 | // / aiger * storing the generated rewritten AIG during '-substitution'
 38 | // / Will be printed to the provided output file.
 39 | extern aiger * rewritten;
 40 | 
 41 | /*------------------------------------------------------------------------*/
 42 | 
 43 | /**
 44 |     Initializes the 'aiger* miter' and 'aiger* rewritten'
 45 | */
 46 | void init_aig_substitution();
 47 | 
 48 | /**
 49 |     Initializes the 'aiger* model', which is local to aig.cpp
 50 | */
 51 | void init_aig_parsing();
 52 | 
 53 | /*------------------------------------------------------------------------*/
 54 | 
 55 | /**
 56 |     Resets the 'aiger* miter' and 'aiger* rewritten'
 57 | */
 58 | void reset_aig_substitution();
 59 | 
 60 | /**
 61 |     Resets the 'aiger* model', which is local to aig.cpp
 62 | */
 63 | void reset_aig_parsing();
 64 | /*------------------------------------------------------------------------*/
 65 | // Functions that interfer with aiger* model, that is used to store the
 66 | // input AIG.
 67 | 
 68 | /**
 69 |     Opens the input file and reads the contents to 'aiger* model'
 70 | 
 71 |     @param input_name a const char* refering to the name of the input file
 72 | 
 73 |     @return const char*, defining a possible error message
 74 |             Equal to zero if everything went right.
 75 |    )
 76 | */
 77 | const char * aiger_open_and_read_to_model(const char * input_name);
 78 | 
 79 | /**
 80 |     Checks whether the given value corrensponds to an input of 'aiger* model'
 81 | 
 82 |     @param val an unsigned integer
 83 | 
 84 |     @return true when val is an input in 'aiger* model'.
 85 | */
 86 | bool is_model_input(unsigned val);
 87 | 
 88 | /**
 89 |     Searches for the AIG node with value 'val' in 'aiger* model'
 90 | 
 91 |     @param val an unsigned integer
 92 | 
 93 |     @return an aiger_and* object, with lefthand side val
 94 | */
 95 | aiger_and * is_model_and(unsigned val);
 96 | 
 97 | /**
 98 |     Returns the number of latches in 'aiger* model'
 99 | 
100 |     @return an unsigned integer
101 | */
102 | unsigned get_model_num_latches();
103 | 
104 | /**
105 |     Returns the number of inputs in 'aiger* model'
106 | 
107 |     @return an unsigned integer
108 | */
109 | unsigned get_model_num_inputs();
110 | 
111 | /**
112 |     Returns the number of AND nodes in 'aiger* model'
113 | 
114 |     @return an unsigned integer
115 | */
116 | unsigned get_model_num_ands();
117 | 
118 | /**
119 |     Returns the number of outputs in 'aiger* model'
120 | 
121 |     @return an unsigned integer
122 | */
123 | unsigned get_model_num_outputs();
124 | 
125 | /**
126 |     Returns the maximum variable number of 'aiger* model'
127 | 
128 |     @return an unsigned integer
129 | */
130 | unsigned get_model_maxvar();
131 | 
132 | /**
133 |     Returns the value of the i'th input in 'aiger* model'
134 | 
135 |     @param i an unsigned integer, has to be smaller than NN
136 | 
137 |     @return an unsigned integer corresponding to the value of the i'th input
138 | */
139 | unsigned get_model_inputs_lit(unsigned i);
140 | 
141 | /**
142 |     Returns the name of the i'th input in 'aiger* model'
143 | 
144 |     @param i an unsigned integer, has to be smaller than NN
145 | 
146 |     @return a const char * corresponding to the name of the i'th input
147 | */
148 | const char* get_model_inputs_name(unsigned i);
149 | 
150 | 
151 | /**
152 |     Returns the aiger value of the i'th output in 'aiger* model'
153 | 
154 |     @param i an unsigned integer, has to be smaller than NN
155 | 
156 |     @return an unsigned integer corresponding to the value of the i'th output
157 | */
158 | unsigned slit(unsigned i);
159 | 
160 | 
161 | /**
162 |     Writes the 'aiger* model' to the provided file.
163 | 
164 |     @param file output file
165 | 
166 |     @return an integer value, zero if everything went right.
167 | */
168 | int write_model(FILE *file);
169 | 
170 | #endif  // AMULET2_SRC_AIG_H_
171 | 


--------------------------------------------------------------------------------
/src/pac.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file pac.cpp
  3 |     \brief contains functions necessary to generate PAC proofs
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include "pac.h"
 10 | /*------------------------------------------------------------------------*/
 11 | static int poly_idx;
 12 | /*------------------------------------------------------------------------*/
 13 | // ERROR CODES:
 14 | static int err_rule       = 81; // error in proof rule
 15 | /*------------------------------------------------------------------------*/
 16 | 
 17 | void print_circuit_poly(FILE * file) {
 18 |   fputs("1 ", file);
 19 |   mpz_out_str(file, 10, mod_coeff);
 20 |   fputs(";\n", file);
 21 | 
 22 |   for (unsigned i = NN; i < num_gates; i++) {
 23 |     Polynomial * p = gen_gate_constraint(i);
 24 |     assert(p);
 25 | 
 26 |     fprintf(file, "%i ", p->get_idx());
 27 |     p->print(file);
 28 |     delete(p);
 29 |   }
 30 |   poly_idx = M+1;
 31 | }
 32 | 
 33 | /*------------------------------------------------------------------------*/
 34 | 
 35 | void print_pac_del_rule(FILE * file, const Polynomial *p1) {
 36 |   assert(p1);
 37 | 
 38 |   fprintf(file, "%i d;\n", p1->get_idx());
 39 | }
 40 | 
 41 | /*------------------------------------------------------------------------*/
 42 | 
 43 | void print_pac_mod_rule(FILE * file, const Polynomial *p1, Polynomial *p) {
 44 |   assert(p1 && !p1->is_constant_zero_poly());
 45 |   assert(p  && !p->is_constant_zero_poly());
 46 | 
 47 |   fprintf(file, "%u ", poly_idx);
 48 |   fputs("% 1 *(", file);
 49 |   p1->print(file, 0); fputs("), ", file);
 50 |   p->print(file);
 51 | 
 52 |   p->set_idx(poly_idx++);
 53 | }
 54 | 
 55 | /*------------------------------------------------------------------------*/
 56 | 
 57 | 
 58 | 
 59 | void print_pac_add_rule(
 60 |     FILE * file, const Polynomial *p1, const Polynomial *p2, Polynomial *p) {
 61 |   assert(p1 && !p1->is_constant_zero_poly());
 62 |   assert(p2 && !p2->is_constant_zero_poly());
 63 |   assert(p  && !p->is_constant_zero_poly());
 64 | 
 65 |   fprintf(file, "%u %% %i + %i, ", poly_idx, p1->get_idx(), p2->get_idx());
 66 |   p->print(file);
 67 | 
 68 |   p->set_idx(poly_idx++);
 69 | }
 70 | 
 71 | /*------------------------------------------------------------------------*/
 72 | 
 73 | void print_pac_vector_add_rule(
 74 |   FILE * file, std::vector<int> indices, Polynomial * p){
 75 | 
 76 |   fprintf(file, "%u %% ", poly_idx);
 77 | 
 78 |   int ind;
 79 |   while (!indices.empty()) {
 80 |     ind = indices.back();
 81 |     indices.pop_back();
 82 | 
 83 |     fprintf(file, "%i",ind);
 84 |     if (indices.size() > 0) fputs(" + ", file);
 85 |   }
 86 |   fprintf(file, ", ");
 87 |   p->print(file);
 88 |   p->set_idx(poly_idx++);
 89 | }
 90 | /*------------------------------------------------------------------------*/
 91 | 
 92 | void print_pac_combi_rule(
 93 |     FILE * file, const Polynomial *p1, const Polynomial *p2,
 94 |     const Polynomial *p3, const Polynomial *p4, Polynomial *p) {
 95 |   assert(p1 && !p1->is_constant_zero_poly());
 96 |   assert(p2 && !p2->is_constant_zero_poly());
 97 |   assert(p3 && !p3->is_constant_zero_poly());
 98 |   assert(p  && !p->is_constant_zero_poly());
 99 | 
100 |   fprintf(file, "%u %% %i", poly_idx, p1->get_idx());
101 |   if (p2) {
102 |     fputs(" *(", file);
103 |     p2->print(file, 0); fputs(") ", file);
104 |   }
105 | 
106 |   fprintf(file, "+ %i", p3->get_idx());
107 |   if (p4) {
108 |     fputs(" *(", file);
109 |     p4->print(file, 0); fputs(") ", file);
110 |   }
111 | 
112 |   fprintf(file, ", ");
113 |   p->print(file);
114 |   p->set_idx(poly_idx++);
115 | }
116 | 
117 | /*------------------------------------------------------------------------*/
118 | 
119 | void print_pac_vector_combi_rule(
120 |   FILE * file, std::vector<int> indices,
121 |   std::vector<const Polynomial*> co_factors, Polynomial * p){
122 | 
123 |   if (co_factors.size() != indices.size()) die(err_rule, "combination rule receives invalid arguments;");
124 | 
125 |   fprintf(file, "%u %% ", poly_idx);
126 | 
127 |   const Polynomial * tmp;
128 |   int ind;
129 |   while (!co_factors.empty()) {
130 |     tmp = co_factors.back();
131 |     co_factors.pop_back();
132 |     ind = indices.back();
133 |     indices.pop_back();
134 | 
135 |     fprintf(file, "%i",ind);
136 |     if (!tmp->is_constant_one_poly()){
137 |       fputs(" *(", file);
138 |       tmp->print(file, 0); fputs(")", file);
139 |     }
140 | 
141 |     if (co_factors.size() > 0) fputs(" + ", file);
142 |     delete(tmp);
143 |   }
144 |   fprintf(file, ", ");
145 |   p->print(file);
146 |   p->set_idx(poly_idx++);
147 | }
148 | /*------------------------------------------------------------------------*/
149 | 
150 | void print_pac_mul_rule(
151 |     FILE * file, const Polynomial *p1, const Polynomial *p2, Polynomial *p) {
152 |   assert(p1 && !p1->is_constant_zero_poly());
153 |   assert(p2 && !p2->is_constant_zero_poly());
154 |   assert(p  && !p->is_constant_zero_poly());
155 | 
156 |   fprintf(file, "%u %% %i *(", poly_idx, p1->get_idx());
157 |   p2->print(file, 0); fputs("), ", file);
158 |   p->print(file);
159 | 
160 |   p->set_idx(poly_idx++);
161 | }
162 | 
163 | /*------------------------------------------------------------------------*/
164 | 


--------------------------------------------------------------------------------
/includes/LICENSE:
--------------------------------------------------------------------------------
 1 | This file describes the license and copyright for the AIGER source code.
 2 | 
 3 | Almost all of the source code of AIGER has so far been developed from
 4 | scratch at the Johannes Kepler University.  But contributions by authors of
 5 | other institutions are very much welcome.  The default license is an MIT
 6 | style license, acknowledging the copyright of all its authors, and we would
 7 | like to keep this license the default.  Currently the only exception is
 8 | 'bliftoaig.c' which contains parts of the CUDD library.  Therefore 
 9 | license of 'bliftoaig.c' has to fall back to the slightly more restrictive
10 | BSD style license used in CUDD and discussed further down.
11 | 
12 | More specifically, all source code of the AIGER library with the exception
13 | of the 'bliftoaig.c' utility falls under the following LICENSE.   
14 | 
15 | ---------------------------------------------------------------------------
16 | -- START OF DEFAULT LICENSE FOR AIGER SOURCE CODE -------------------------
17 | ---------------------------------------------------------------------------
18 | Copyright (c) 2006-2013, Armin Biere, Johannes Kepler University, Austria.
19 | Copyright (c) 2006, Marc Herbstritt, University of Freiburg, Germany.
20 | Copyright (c) 2006, Daniel Le Berre, Universite d'Artois, France.
21 | Copyright (c) 2011, Siert Wieringa, Alto University, Finland.
22 | Copyright (c) 2015, Aina Niemetz, Johannes Kepler University, Austria.
23 | 
24 | Permission is hereby granted, free of charge, to any person obtaining a copy
25 | of this software and associated documentation files (the "Software"), to
26 | deal in the Software without restriction, including without limitation the
27 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
28 | sell copies of the Software, and to permit persons to whom the Software is
29 | furnished to do so, subject to the following conditions:
30 | 
31 | The above copyright notice and this permission notice shall be included in
32 | all copies or substantial portions of the Software.
33 | 
34 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
37 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
39 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
40 | IN THE SOFTWARE.
41 | ---------------------------------------------------------------------------
42 | -- END OF DEFAULT LICENSE FOR AIGER SOURCE CODE ---------------------------
43 | ---------------------------------------------------------------------------
44 | 
45 | The list of authors and copyright holders listed in the default license
46 | contains all the authors and copyright holders of AIGER, individual source
47 | code files may only list the authors and copyright holders of the individual
48 | file.   The LICENSE is the same and thus should allow to cover all the
49 | source except 'bliftoaig.c' by the above default license which lists all
50 | authors.
51 | 
52 | The License for 'bliftoaig.c' is a BSD style license since it includes
53 | part of utilities derived from the CUDD library which uses a BSD style
54 | license.  The full license for 'bliftoaig.c' is as follows:
55 | 
56 | ---------------------------------------------------------------------------
57 | -- START OF LICENSE FOR 'bliftoaig.c' -------------------------------------
58 | ---------------------------------------------------------------------------
59 | Copyright (c) 2006 Armin Biere, Johannes Kepler University, Austria.
60 | Copyright (c) 2006 Marc Herbstritt, University of Freiburg, Germany.
61 | Copyright (c) 1995-2004, Regents of the University of Colorado, USA.
62 | 
63 | All rights reserved.
64 | 
65 | Redistribution and use in source and binary forms, with or without
66 | modification, are permitted provided that the following conditions
67 | are met:
68 | 
69 | Redistributions of source code must retain the above copyright
70 | notice, this list of conditions and the following disclaimer.
71 | 
72 | Redistributions in binary form must reproduce the above copyright
73 | notice, this list of conditions and the following disclaimer in the
74 | documentation and/or other materials provided with the distribution.
75 | 
76 | Neither the name of the authors, nor the names of contributors, nor the name
77 | of the copyright holders, including the name of the Johannes Kepler
78 | University, the name of the University of Freiburg, or the name of the
79 | University of Colorado may be used to endorse or promote products derived
80 | from this software without specific prior written permission.
81 | 
82 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
83 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
84 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
85 | FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
86 | COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
87 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
88 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
89 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
90 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
91 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
92 | ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
93 | POSSIBILITY OF SUCH DAMAGE.
94 | --------------------------------------------------------------------------
95 | -- END OF LICENSE FOR 'bliftoaig.c' --------------------------------------
96 | --------------------------------------------------------------------------
97 | 


--------------------------------------------------------------------------------
/src/polynomial.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file polynomial.h
  3 |     \brief contains arithmetic operations for polynomials
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #ifndef AMULET2_SRC_POLYNOMIAL_H_
 10 | #define AMULET2_SRC_POLYNOMIAL_H_
 11 | /*------------------------------------------------------------------------*/
 12 | #include <list>
 13 | #include <deque>
 14 | #include <cstring>
 15 | 
 16 | #include "monomial.h"
 17 | /*------------------------------------------------------------------------*/
 18 | 
 19 | /** \class Polynomial
 20 |     This class is used to polynomials.
 21 | */
 22 | class Polynomial {
 23 |   int idx;  // /< index as used in pac proofs
 24 | 
 25 |   int level = 1;  // /< level of polynomials needed for certificates
 26 | 
 27 |   Monomial ** mon;  // /< sorted deque of monomials
 28 | 
 29 |   size_t num_mon = 0;
 30 | 
 31 |  public:
 32 |   /** Constructor */
 33 |   Polynomial();
 34 | 
 35 |   Polynomial (Monomial ** m, size_t len);
 36 | 
 37 |   /** Getter for member idx
 38 | 
 39 |       @return integer
 40 |   */
 41 |   int get_idx() const {return idx;}
 42 | 
 43 |   /**
 44 |       Setter for idx
 45 | 
 46 |       @param idx_ integer
 47 |   */
 48 |   void set_idx(int idx_) {idx = idx_;}
 49 | 
 50 |   /** Getter for member level
 51 | 
 52 |       @return integer
 53 |   */
 54 |   int get_level() const {return level;}
 55 | 
 56 |   /**
 57 |       Setter for level
 58 | 
 59 |       @param level_ integer
 60 |   */
 61 |   void set_level(int level_) {level = level_;}
 62 | 
 63 |   Monomial * get_mon(size_t i) const {
 64 |      if(i < num_mon) return mon[i];
 65 |      else return 0;
 66 |    }
 67 | 
 68 |    size_t size() const { return num_mon;}
 69 | 
 70 |   /** Returns the leading term
 71 | 
 72 |       @return Term*
 73 |   */
 74 |   Term * get_lt() const {return mon[0]->get_term();}
 75 | 
 76 |   /**
 77 |       Copy routine
 78 | 
 79 |       @return A hard copy of the current polynomial
 80 |   */
 81 |   Polynomial * copy() const;
 82 | 
 83 |   /**
 84 |       Printing routine
 85 | 
 86 |       @param file Output file
 87 |       @param end if true we print trailing ";"
 88 |   */
 89 |   void print(FILE * file, bool end = 1) const;
 90 | 
 91 |   /** Destructor */
 92 |   ~Polynomial();
 93 | 
 94 | 
 95 |   /**
 96 |       Returns whether the polynomial is the constant zero polynomial
 97 | 
 98 |       @return bool
 99 |   */
100 |   bool is_constant_zero_poly() const;
101 | 
102 |   /**
103 |       Returns whether the polynomial is the constant one polynomial
104 | 
105 |       @return bool
106 |   */
107 |   bool is_constant_one_poly() const;
108 | 
109 |   /**
110 |       Returns the size of the smallest term
111 | 
112 |       @return integer
113 |   */
114 |   int min_term_size() const;
115 | };
116 | /*------------------------------------------------------------------------*/
117 | // Polynomials are generated using a sorted array "mstack"
118 | 
119 | /**
120 |     Enlarges the allocated size of mstack
121 | */
122 | void enlarge_mstack();
123 | 
124 | /**
125 |     Sets the number of elements in the stack to 0
126 | */
127 | void clear_mstack();
128 | 
129 | /**
130 |     Deallocates mstack
131 | */
132 | void deallocate_mstack();
133 | 
134 | /**
135 |     Checks whether mstack is empty
136 | 
137 |     @return true if mstack is empty
138 | */
139 | bool mstack_is_empty();
140 | 
141 | /**
142 |     Pushes a monomial to the end of the stack
143 | 
144 |     @param t monomial to be added to the mstack
145 | */
146 | void push_mstack_end(Monomial *t);
147 | 
148 | /**
149 |     Pushes a monomial to the stack such that mstack remains sorted
150 | 
151 |     @param t monomial to be added to the mstack
152 | */
153 | void push_mstack(Monomial *t);
154 | 
155 | 
156 | /**
157 |     Generates a polynomial from mstack and clears mstack
158 | 
159 |     @return Polynomial*
160 | */
161 | Polynomial * build_poly();
162 | 
163 | 
164 | /*------------------------------------------------------------------------*/
165 | 
166 | /**
167 |     Add two polynomials p1+p2
168 | 
169 |     @param p1 Polynomial*
170 |     @param p2 Polynomial*
171 | 
172 |     @return Polynomial*, sum of p1+p2
173 | */
174 | Polynomial * add_poly(const Polynomial *p1, const Polynomial *p2);
175 | 
176 | /**
177 |     Multiplies two polynomials p1*p2
178 | 
179 |     @param p1 Polynomial*
180 |     @param p2 Polynomial*
181 | 
182 |     @return Polynomial*, product of p1*p2
183 | */
184 | Polynomial * multiply_poly(const Polynomial *p1, const Polynomial *p2);
185 | 
186 | /**
187 |     Multiplies a polynomial p1 with a constant c
188 | 
189 |     @param p1: Polynomial*
190 |     @param c:  mpz_t object
191 | 
192 |     @return Polynomial*, product of c*p1
193 | */
194 | Polynomial * multiply_poly_with_constant(const Polynomial *p1, mpz_t c);
195 | 
196 | 
197 | /**
198 |     Returns the quotient of dividing a polynomial p1 by a term t
199 | 
200 |     @param p1 Polynomial*
201 |     @param t  Term *
202 | 
203 |     @return Polynomial defining the quotient of p1/t
204 | */
205 | Polynomial * divide_by_term(const Polynomial * p1, const Term * t);
206 | 
207 | 
208 | /*---------------------------------------------------------------------------*/
209 | // / gmp for 1
210 | extern mpz_t one;
211 | 
212 | // / gmp for -1
213 | extern mpz_t minus_one;
214 | 
215 | // / gmp for 2
216 | extern mpz_t base;
217 | 
218 | // / gmp for 2^NN
219 | extern mpz_t mod_coeff;
220 | /*---------------------------------------------------------------------------*/
221 | /**
222 |     Initializes all global gmp objects
223 | 
224 |     @param exp unsigned exponent for mod coeff
225 | */
226 | void init_mpz(unsigned exp);
227 | 
228 | /**
229 |     Clears all globally allocated gmp objects
230 | */
231 | void clear_mpz();
232 | 
233 | #endif  // AMULET2_SRC_POLYNOMIAL_H_
234 | 


--------------------------------------------------------------------------------
/src/term.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file term.h
  3 |     \brief contains the class Term and further functions to
  4 |     manipulate terms
  5 | 
  6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  8 | */
  9 | /*------------------------------------------------------------------------*/
 10 | #ifndef AMULET2_SRC_TERM_H_
 11 | #define AMULET2_SRC_TERM_H_
 12 | /*------------------------------------------------------------------------*/
 13 | #include <stack>
 14 | 
 15 | #include "variable.h"
 16 | /*------------------------------------------------------------------------*/
 17 | 
 18 | /** \class Term
 19 |     This class is used to represent terms in a polynomial.
 20 |     Terms are represented as ordered linked lists of variables.
 21 | */
 22 | 
 23 | class Term {
 24 |   // / head variable
 25 |   const Var * variable;
 26 | 
 27 |   // / tail in linked list
 28 |   Term * rest;
 29 | 
 30 |   // / reference counter
 31 |   uint64_t ref;
 32 | 
 33 |   // / hash value
 34 |   const uint64_t hash;
 35 | 
 36 |   // / hash collision chain link
 37 |   Term * next;
 38 | 
 39 |  public:
 40 |   /** Constructor
 41 | 
 42 |       @param _v Var*
 43 |       @param _r Term*
 44 |       @param _hash uint64_t
 45 |       @param _n Term*
 46 |   */
 47 |   Term(const Var * _v, Term * _r, uint64_t _hash, Term * _n);
 48 | 
 49 |   /** Getter for member variable
 50 | 
 51 |       @return Var*
 52 |   */
 53 |   const Var * get_var() const {return variable;}
 54 | 
 55 |   /** Getter for level of variable
 56 | 
 57 |       @return integer
 58 |   */
 59 |   int get_var_level() const {return variable->get_level();}
 60 | 
 61 |   /** Getter for num of variable
 62 | 
 63 |       @return integer
 64 |   */
 65 |   int get_var_num() const {return variable->get_num();}
 66 | 
 67 |   /** Getter for name of variable
 68 | 
 69 |       @return char*
 70 |   */
 71 |   const char * get_var_name() const {return variable->get_name();}
 72 | 
 73 |   /** Getter for member rest
 74 | 
 75 |       @return Term*
 76 |   */
 77 |   Term * get_rest() const {return rest;}
 78 | 
 79 |   /** Getter for member hash
 80 | 
 81 |       @return uint64_t
 82 |   */
 83 |   uint64_t get_hash() const {return hash;}
 84 | 
 85 |   /** Getter for member next
 86 | 
 87 |       @return Term*
 88 |   */
 89 |   Term * get_next() const {return next;}
 90 | 
 91 |   /** Setter for member term
 92 | 
 93 |       @param t Term*
 94 |   */
 95 |   void set_next(Term * t) {next = t;}
 96 | 
 97 |   /** Getter for member ref
 98 | 
 99 |       @return uint64_t
100 |   */
101 |   uint64_t get_ref() const {return ref;}
102 | 
103 |   /** Increases ref
104 | 
105 |       @return uint64_t
106 |   */
107 |   uint64_t inc_ref() {return ++ref;}
108 | 
109 |   /** Decreases ref
110 | 
111 |       @return uint64_t
112 |   */
113 |   uint64_t dec_ref() {return --ref;}
114 | 
115 |   /**
116 |       Copy routine
117 | 
118 |       @return A copy of the current term
119 |   */
120 |   Term * copy();
121 | 
122 |   /**
123 |       Printing routine
124 | 
125 |       @param file Output file
126 |   */
127 |   void print(FILE * file) const;
128 | 
129 |   /**
130 |       Returns the number of variables in a term
131 | 
132 |       @return unsigned integer
133 |   */
134 |   unsigned size() const;
135 | 
136 |   /**
137 |       Compares this term to term t using the levels of the variables
138 | 
139 |       @param t Term*
140 | 
141 |       @return +1 if this > t
142 |               -1 if this < t
143 |               0  if this = t
144 |   */
145 |   int cmp(const Term *t) const;
146 | 
147 |   /**
148 |       Checks whether v is contained in Term
149 | 
150 |       @param v Var*
151 | 
152 |       @return true if v is contained in term
153 |   */
154 |   bool contains(const Var * v) const;
155 | };
156 | 
157 | /*------------------------------------------------------------------------*/
158 | // We organize terms in a hash table that is dynamically enlarged.
159 | // Every time a new term is defined, we compute a hash value and insert
160 | // the term. Terms are counted using a reference counter, which is incremented
161 | // and decremented depending how often the term occurs in polynomials.
162 | 
163 | /**
164 |     Compute hash_values
165 | 
166 |     @param variable Variable*
167 |     @param rest Term*
168 | 
169 |     @return computed hash value for the term(variable, rest)
170 | */
171 | uint64_t compute_hash_term(const Var * variable, const Term * rest);
172 | 
173 | /**
174 |     Enlarges the hash table
175 | */
176 | void enlarge_terms();
177 | 
178 | /**
179 |     Builds a term, where variable is added at the front of rest
180 | 
181 |     @param variable Variable*
182 |     @param rest     Term*
183 | 
184 |     @return Term*
185 | */
186 | Term * new_term(const Var * variable, Term * rest);
187 | 
188 | 
189 | 
190 | /**
191 |     Decrements the reference count of a term, and actually deletes a
192 |     term if its reference count goes to zero.  In this case it also
193 |     removes it from the hash table and applies the same procedure to the
194 |     suffix 'rest'.
195 | 
196 |     @param t Term*
197 | */
198 | void deallocate_term(Term * t);
199 | 
200 | 
201 | /**
202 |     Deallocates the hash table "term_table"
203 | */
204 | void deallocate_terms();
205 | 
206 | /*------------------------------------------------------------------------*/
207 | // Terms are generated using a stack "vstack"
208 | 
209 | /**
210 |     Pushes a variable to the variable stack, thus variables have to be pushed
211 |     in order
212 | 
213 |     @param v Var*
214 | */
215 | void add_to_vstack(const Var* v);
216 | 
217 | /**
218 |     Generates a term from the variable stack
219 | 
220 |     @return Term* generated from the variable stack
221 | */
222 | Term * build_term_from_stack();
223 | 
224 | /**
225 |     Multiplies two terms
226 | 
227 |     @param t1 Term*
228 |     @param t2 Term*
229 | 
230 |     @return Term* which is product of t1*t2
231 | */
232 | Term * multiply_term(Term * t1, Term * t2);
233 | 
234 | /**
235 |     Remainder of t divided by v
236 | 
237 |     @param t Term*
238 |     @param v Var*
239 | 
240 |     @return Term* where v is removed from t
241 | */
242 | Term * remainder(const Term * t, const Var * v);
243 | 
244 | #endif  // AMULET2_SRC_TERM_H_
245 | 


--------------------------------------------------------------------------------
/src/nss.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file nss.cpp
  3 |     \brief contains functions necessary to generate Nullstellensatz proofs
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include <map>
 10 | 
 11 | #include "nss.h"
 12 | /*------------------------------------------------------------------------*/
 13 | static Polynomial * mod_factor;
 14 | /*------------------------------------------------------------------------*/
 15 | void print_spec_poly(FILE * file) {
 16 |   mpz_t coeff;
 17 |   mpz_init(coeff);
 18 | 
 19 |   // outputs
 20 |   for (int i = NN-1; i >= 0; i--) {
 21 |     const Var * v = gates[i+M-1]->get_var();
 22 | 
 23 |     mpz_pow_ui(coeff, base, i);
 24 |     mpz_neg(coeff, coeff);
 25 |     if (i == static_cast<int>(NN-1) && signed_mult) mpz_neg(coeff, coeff);
 26 | 
 27 |     Term * t1 = new_term(v, 0);
 28 |     Monomial * m1 = new Monomial(coeff, t1);
 29 |     push_mstack_end(m1);
 30 |   }
 31 | 
 32 |   // partial products
 33 |   for (int i = NN/2-1; i >= 0; i--) {
 34 |     const Var * a = gates[a0+i*ainc]->get_var();
 35 | 
 36 |     for (int j = NN/2-1; j >= 0; j--) {
 37 |       const Var * b = gates[b0+j*binc]->get_var();
 38 |       mpz_pow_ui(coeff, base, i+j);
 39 |       if (i == static_cast<int>(NN/2-1) && signed_mult) mpz_neg(coeff, coeff);
 40 |       if (j == static_cast<int>(NN/2-1) && signed_mult) mpz_neg(coeff, coeff);
 41 |       add_to_vstack(a);
 42 |       add_to_vstack(b);
 43 |       Term * t1 = build_term_from_stack();
 44 |       Monomial * m1 = new Monomial(coeff, t1);
 45 |       push_mstack_end(m1);
 46 |     }
 47 |   }
 48 |   mpz_clear(coeff);
 49 | 
 50 |   Polynomial * p = build_poly();
 51 |   p->print(file);
 52 |   delete(p);
 53 | }
 54 | 
 55 | /*------------------------------------------------------------------------*/
 56 | 
 57 | void print_cofactors_poly_nss(FILE * file) {
 58 |   bool first = 1;
 59 |   fprintf(file, "%i %% ", M+1);
 60 |   for (unsigned i = num_gates-1; i >= NN ; i--) {
 61 |     Polynomial * p = gates[i]->get_cofactor();
 62 | 
 63 |     if (p && !p->is_constant_zero_poly()) {
 64 |       if (!first) fputs(" + ", file);
 65 |       fprintf(file, "%i *(", 2+i-NN);
 66 |       p->print(file, 0);
 67 |       fputs(")\n", file);
 68 |       first = 0;
 69 |     }
 70 |   }
 71 | 
 72 |   if (mod_factor && !mod_factor->is_constant_zero_poly()) {
 73 |     fprintf(file, " + 1 *(");
 74 |     mod_factor->print(file, 0);
 75 |     fputs(")\n", file);
 76 |     delete(mod_factor);
 77 |   }
 78 | 
 79 |   fputs(" , ", file);
 80 |   print_spec_poly(file);
 81 | }
 82 | /*------------------------------------------------------------------------*/
 83 | 
 84 | void add_ancestors(
 85 |     Gate * n, Gate * anc, const Polynomial * fac, bool internal) {
 86 |   assert(n);
 87 |   assert(anc);
 88 | 
 89 |   if (!fac) return;
 90 | 
 91 |   /* if function is called from extern on a gate 'n' we need to add the tuple
 92 |    *(n,1) to the ancestors, to indicate that the original polynomial of n
 93 |    * is used in the ancestors.
 94 |    */
 95 |   if (!internal) {
 96 |     std::map<Gate*, Polynomial*>::const_iterator it = n->search_in_anc(n);
 97 |     if (it == n->anc_end()) {
 98 | 
 99 |       Monomial * m1 = new Monomial(one, 0);
100 |       push_mstack_end(m1);
101 |       Polynomial * p = build_poly();
102 |       n->set_ancestor(n, p);
103 |     }
104 |   }
105 | 
106 |   /* if 'anc' is original or add_ancestors is called internally
107 |    * we check whether 'anc' is already contained in the ancestors.
108 |    * If so, we add 'fac' to the corresponding co-factor of 'anc' in the ancestors.
109 |    * Otherwise, the tuple(anc,fac) is added to the ancestors.
110 |    */
111 |   if (anc->orig() || internal) {
112 |     std::map<Gate*, Polynomial*>::iterator it = n->search_in_anc(anc);
113 |     if (it != n->anc_end()) {
114 |       Polynomial * old_fac = it->second;
115 |       Polynomial * new_fac = add_poly(fac, old_fac);
116 |       it->second = new_fac;
117 |       delete(old_fac);
118 |     } else {
119 |       n->set_ancestor(anc, fac->copy());
120 |     }
121 |   } else {
122 |     /* if 'anc' is not original we traverse through its ancestors anc call
123 |      * add_ancestors from internal
124 |      */
125 |     for (std::map<Gate*, Polynomial*>::const_iterator it=anc->anc_begin();
126 |         it != anc->anc_end(); ++it) {
127 |       Polynomial * new_fac = multiply_poly(fac, it->second);
128 |       add_ancestors(n, it->first, new_fac, 1);
129 |       delete(new_fac);
130 |     }
131 |   }
132 | }
133 | /*------------------------------------------------------------------------*/
134 | 
135 | void add_fac_mod(const Polynomial * fac) {
136 |   if (!fac) return;
137 | 
138 |   if (!mod_factor) { mod_factor = fac->copy();
139 |   } else {
140 |     Polynomial * add = add_poly(mod_factor, fac);
141 |     delete(mod_factor);
142 |     mod_factor = add;
143 |   }
144 | }
145 | /*------------------------------------------------------------------------*/
146 | 
147 | void add_fac(Gate * n, const Polynomial * fac) {
148 |   assert(n);
149 |   if (!fac) return;
150 | 
151 |   if (n->orig()) {
152 |     /* If 'n' is original we add 'fac' as co-factor. */
153 |     if (!n->get_cofactor()) { n->set_cofactor(fac->copy());
154 |     } else {
155 |       Polynomial * add = add_poly(n->get_cofactor(), fac);
156 |       delete(n->get_cofactor());
157 |       n->set_cofactor(add);
158 |     }
159 |   } else {
160 |     /* Otherwise, we traverse through the ancestors of 'n' and add the product
161 |      * of 'fac' and ancestor cofactor to the cofactors of the ancestor gates.
162 |      */
163 |     for (std::map<Gate*, Polynomial*>::const_iterator it = n->anc_begin();
164 |         it != n->anc_end(); ++it) {
165 |       Gate       * n_anc = it->first;
166 |       Polynomial * p_anc = it->second;
167 | 
168 |       Polynomial * mul = multiply_poly(p_anc, fac);
169 | 
170 |       if (!n_anc->get_cofactor()) { n_anc->set_cofactor(mul);
171 |       } else {
172 |         Polynomial * add = add_poly(n_anc->get_cofactor(), mul);
173 |         delete(mul);
174 |         delete(n_anc->get_cofactor());
175 |         n_anc->set_cofactor(add);
176 |       }
177 |     }
178 |   }
179 | }
180 | 


--------------------------------------------------------------------------------
/src/elimination.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file elimination.h
  3 |     \brief contains functions used in the polynomial solver
  4 | 
  5 |   This file contains all functions used for preprocessing the Gröbner basis
  6 |   and for reducing the specification by the slices.
  7 | 
  8 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  9 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
 10 | */
 11 | /*------------------------------------------------------------------------*/
 12 | #ifndef AMULET2_SRC_ELIMINATION_H_
 13 | #define AMULET2_SRC_ELIMINATION_H_
 14 | /*------------------------------------------------------------------------*/
 15 | #include <string.h>
 16 | 
 17 | #include <vector>
 18 | 
 19 | #include "nss.h"
 20 | #include "pac.h"
 21 | #include "slicing.h"
 22 | /*------------------------------------------------------------------------*/
 23 | // / 1 for pac
 24 | // / 2 for hybrid
 25 | // / 3 for nss
 26 | extern int proof;
 27 | 
 28 | /*------------------------------------------------------------------------*/
 29 | // Functions used for PAC proofs
 30 | 
 31 | /**
 32 |     Adds up the computed factors of a slice to compute the sliced specification
 33 |     Prints PAC rules for the process. Used only when proof == 1 or proof == 2.
 34 | 
 35 |     @param file output file for PAC rules
 36 | 
 37 |     @return polynomial, which is the sum of all computed factors of a slice
 38 | */
 39 | Polynomial * add_up_factors(FILE * file, bool print);
 40 | 
 41 | 
 42 | /**
 43 |     Adds up the computed sliced specifications.
 44 |     Prints PAC rules for the process. Used only when proof == 1 or proof == 2.
 45 | 
 46 |     @param file output file for PAC rules
 47 | 
 48 |     @return polynomial, which is the sum of all computed slice specifcations
 49 | */
 50 | Polynomial * add_up_spec_of_slice(FILE * file, bool print);
 51 | /*------------------------------------------------------------------------*/
 52 | // These functions are used to eliminate by one gate constraint
 53 | 
 54 | /**
 55 |     Reduces the gate constraint of n1 by the gate constraint of n2
 56 | 
 57 |     @param n1 Gate that is reduced by n2
 58 |     @param n2 Gate
 59 |     @param file output file for PAC rules
 60 | */
 61 | void eliminate_by_one_gate(Gate * n1, Gate *n2, FILE * file);
 62 | 
 63 | /**
 64 |     Reduces p1 by the gate constraint of n
 65 | 
 66 |     @param p1 Polynomial to be reduced
 67 |     @param n  Gate
 68 |     @param file output file for PAC rules
 69 | 
 70 |     @return the computed polynomial remainder
 71 | */
 72 | Polynomial * reduce_by_one_poly(const Polynomial * p1, Gate * n, FILE * file);
 73 | /*------------------------------------------------------------------------*/
 74 | // Variable elimination heuristics in XOR-based slicing
 75 | 
 76 | /**
 77 |     Remove all internal gates in identified XOR gates
 78 | 
 79 |     @param file output file for PAC rules
 80 | */
 81 | void remove_internal_xor_gates(FILE * file);
 82 | 
 83 | /**
 84 |     Remove all single-parent gates(only one loop)
 85 | 
 86 |     @param file output file for PAC rules
 87 | */
 88 | void remove_single_occs_gates(FILE * file);
 89 | 
 90 | /**
 91 |     Remove all gates that have not been assigned to a slice
 92 | 
 93 |     @param file output file for PAC rules
 94 | */
 95 | void remove_slice_minus_one_gates(FILE * file);
 96 | 
 97 | /*------------------------------------------------------------------------*/
 98 | // Variable elimination heuristics taken from AMulet1.0
 99 | 
100 | /**
101 |     Remove repeatedly all single gates(until completion)
102 | 
103 |     @param file output file for PAC rules
104 | */
105 | void decomposing(FILE * file);
106 | 
107 | 
108 | /**
109 |     Remove all gates that are identified as a Booth pattern
110 | 
111 |     @param file output file for PAC rules
112 | */
113 | void eliminate_booth_pattern(FILE * file);
114 | 
115 | /*------------------------------------------------------------------------*/
116 | 
117 | /**
118 |     Defines the slice specification for slice i: -s_i + PP_i
119 | 
120 |     @param i unsigned integer for the index of the slice
121 | 
122 |     @return Polynomial for slice specification
123 | */
124 | Polynomial * inc_spec_poly(unsigned i);
125 | 
126 | /**
127 |     Reduces p1 by the constant 2^NN
128 | 
129 |     @param p1 Polynomial to be reduced
130 |     @param print_rule bool indicating whether we print the PAC rules
131 |     @param file output file for PAC rules
132 | 
133 |     @return the computed polynomial remainder
134 | */
135 | Polynomial * mod_poly(const Polynomial *p1, bool print_rule, FILE * file);
136 | 
137 | /**
138 |     Reduces the computed unsigned specification by the modulo constant
139 | 
140 |     @param p Polynomial to be reduced
141 |     @param file output file for PAC rules
142 | */
143 | void correct_pp_unsigned(const Polynomial * p, FILE * file);
144 | 
145 | /**
146 |     Reducing the computed signed specification by the modulo constant
147 | 
148 |     @param p Polynomial to be reduced
149 |     @param file output file for PAC rules
150 | */
151 | void correct_pp_signed(const Polynomial * p, FILE * file);
152 | 
153 | /**
154 |     Reducing the computed specification by the modulo constant,
155 |     by calling appropriate subfunctions.
156 |     @see correct_pp_unsigned(const Polynomial * p, FILE * file)
157 |     @see correct_pp_signed(const Polynomial * p, FILE * file)
158 | 
159 |     @param p Polynomial to be reduced
160 |     @param file output file for PAC rules
161 | */
162 | void correct_pp(const Polynomial * p, FILE * file);
163 | 
164 | /*------------------------------------------------------------------------*/
165 | /**
166 |     Incremental verification algorithm, where we reduce the slice-wise
167 |     specifcations by the gate constraints of the slices
168 | 
169 |     @param file output file for PAC rules
170 | 
171 |     @return the computed polynomial remainder, 0 if the circuit is correct
172 | 
173 | */
174 | const Polynomial * reduce(FILE * file);
175 | /*------------------------------------------------------------------------*/
176 | // Functions used to find counter examples
177 | /**
178 |     Checks whether the polynomial contains only input variables
179 | 
180 |     @param p Polynomial* to be checked
181 | 
182 |     @return true if p contains only input variables
183 | */
184 | bool check_inputs_only(const Polynomial *p);
185 | 
186 | /**
187 |     Writes a vector to the file such that all input variables in the term t
188 |     are set to 1, all other to 0.
189 | 
190 |     @param t Term
191 |     @param file output file for the counter example
192 | */
193 | void write_witness_vector(const Term * t, FILE * file);
194 | 
195 | /**
196 |     Search for the smallest term and calls write_witness_vector on that
197 | 
198 |     @param p Polynomial* for which counter examples are generated
199 |     @param file output file for the counter example
200 | */
201 | void write_witnesses(const Polynomial * p, FILE * file);
202 | 
203 | /**
204 |     Generates a witness for the remainder polynomial p, by identifying
205 |     the smallest term in the polynomial and setting all its variables
206 |     to 1.
207 | 
208 |     @param p Polynomial* for which counter examples are generated
209 |     @param name prefix name for the output file, suffix is '.cex'
210 | */
211 | void generate_witness(const Polynomial * p, const char * name);
212 | 
213 | #endif  // AMULET2_SRC_ELIMINATION_H_
214 | 


--------------------------------------------------------------------------------
/src/term.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file term.cpp
  3 |     \brief contains the class Term and further functions to
  4 |     manipulate terms
  5 | 
  6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  8 | */
  9 | /*------------------------------------------------------------------------*/
 10 | #include "term.h"
 11 | /*------------------------------------------------------------------------*/
 12 | 
 13 | Term::Term(const Var * _v,  Term * _r, uint64_t _hash, Term * _n):
 14 |   variable(_v), ref(1), hash(_hash), next(_n) {
 15 |   if (_r) rest = _r->copy();
 16 |   else
 17 |     rest = 0;
 18 | }
 19 | 
 20 | /*------------------------------------------------------------------------*/
 21 | 
 22 | Term * Term::copy() {
 23 |   assert(ref > 0);
 24 |   ++ref;
 25 |   assert(ref);
 26 |   return this;
 27 | }
 28 | 
 29 | /*------------------------------------------------------------------------*/
 30 | 
 31 | void Term::print(FILE * file) const {
 32 |   const Term * tmp = this;
 33 |   if (!tmp) fputc_unlocked('0', file);
 34 |   while (tmp) {
 35 |     fputs_unlocked(tmp->get_var_name(), file);
 36 |     tmp = tmp->get_rest();
 37 |     if (tmp) fputc_unlocked('*', file);
 38 |   }
 39 | }
 40 | 
 41 | /*------------------------------------------------------------------------*/
 42 | 
 43 | unsigned Term::size() const {
 44 |   const Term * tmp = this;
 45 |   if (!tmp) return 0;
 46 | 
 47 |   int i = 0;
 48 |   while (tmp) {
 49 |     i++;
 50 |     tmp = tmp->get_rest();
 51 |   }
 52 |   return i;
 53 | }
 54 | 
 55 | /*------------------------------------------------------------------------*/
 56 | 
 57 | int Term::cmp(const Term *t) const {
 58 |   const Term * tmp1 = this;
 59 |   if (!tmp1) return -1;
 60 |   const Term * tmp2 = t;
 61 |   if (!tmp2) return 1;
 62 | 
 63 |   if (tmp1 != tmp2) {
 64 |     while (tmp1 && tmp2) {
 65 |       if (tmp1->get_var_level() > tmp2->get_var_level()) return 1;
 66 |       else if (tmp1->get_var_level() < tmp2->get_var_level()) return -1;
 67 |       tmp1 = tmp1->get_rest();
 68 |       tmp2 = tmp2->get_rest();
 69 |     }
 70 |     if (tmp1) return 1;
 71 |     else if (tmp2) return -1;
 72 |   }
 73 | 
 74 |   return 0;
 75 | }
 76 | 
 77 | /*------------------------------------------------------------------------*/
 78 | 
 79 | bool Term::contains(const Var *v) const {
 80 |   assert(v);
 81 |   const Term * t = this;
 82 |   while (t) {
 83 |     if (t->get_var() == v) return 1;
 84 |     else if (t->get_var_level() < v->get_level()) return 0;
 85 |     t = t->get_rest();
 86 |   }
 87 |   return 0;
 88 | }
 89 | 
 90 | /*------------------------------------------------------------------------*/
 91 | 
 92 | uint64_t size_terms;
 93 | uint64_t current_terms;
 94 | Term ** term_table;
 95 | 
 96 | /*------------------------------------------------------------------------*/
 97 | 
 98 | uint64_t compute_hash_term(const Var * variable, const Term * rest) {
 99 |   assert(variable);
100 |   uint64_t res = rest ? rest->get_hash() : 0;
101 |   res *= get_nonces_entry(0);
102 |   res += variable->get_hash();
103 |   res *= get_nonces_entry(1);
104 |   return res;
105 | }
106 | 
107 | /*------------------------------------------------------------------------*/
108 | 
109 | void enlarge_terms() {
110 |   uint64_t new_size_terms = size_terms ? 2*size_terms : 1;
111 |   Term ** new_term_table = new Term*[new_size_terms]();
112 |   for (uint64_t i = 0; i < size_terms; i++) {
113 |     for (Term * m = term_table[i], * n; m; m = n) {
114 |       uint64_t h = m->get_hash() &(new_size_terms - 1);
115 |       n = m->get_next();
116 |       m->set_next(new_term_table[h]);
117 |       new_term_table[h] = m;
118 |     }
119 |   }
120 |   delete[] term_table;
121 |   term_table = new_term_table;
122 |   size_terms = new_size_terms;
123 | }
124 | 
125 | /*------------------------------------------------------------------------*/
126 | 
127 | Term * new_term(const Var * variable, Term * rest) {
128 |   if (current_terms == size_terms) enlarge_terms();
129 |   const uint64_t hash = compute_hash_term(variable, rest);
130 |   const uint64_t h = hash &(size_terms - 1);
131 | 
132 |   Term * res;
133 |   for (res = term_table[h];
134 |        res &&(res->get_var() != variable || res->get_rest() != rest);
135 |        res = res->get_next())
136 |        {}
137 | 
138 |   if (res) {
139 |     res->inc_ref();  // here we extend that we found term once more
140 |   } else {
141 |     res = new Term(variable, rest, hash, term_table[h]);
142 |     term_table[h] = res;
143 |     current_terms++;
144 |   }
145 |   return res;
146 | }
147 | 
148 | /*------------------------------------------------------------------------*/
149 | 
150 | void deallocate_term(Term * t) {
151 |   while (t) {
152 |     assert(t->get_ref() > 0);
153 |     if (t->dec_ref() > 0) break;  // t is still used
154 |     Term * rest = t->get_rest();
155 |     const uint64_t h = t->get_hash() &(size_terms - 1);
156 |     Term * p = term_table[h];
157 |     if (p == t) { term_table[h] = t->get_next();
158 |     } else {
159 |       Term * p2;
160 |       while ((p2 = p->get_next()) != t) p = p2;
161 |       p->set_next(t->get_next());
162 |     }
163 | 
164 |     assert(current_terms);
165 |     current_terms--;
166 |     delete(t);
167 |     t = rest;
168 |   }
169 | }
170 | 
171 | /*------------------------------------------------------------------------*/
172 | 
173 | void deallocate_terms() {
174 |   for (uint64_t i = 0; i < size_terms; i++) {
175 |     for (Term * m = term_table[i], *n; m; m = n) {
176 |       n = m->get_next();
177 |       assert(current_terms);
178 |       current_terms--;
179 | 
180 |       delete(m);
181 |     }
182 |   }
183 |   delete[] term_table;
184 | }
185 | 
186 | /*------------------------------------------------------------------------*/
187 | static std::stack<const Var*> vstack;  // /< used to build a term
188 | /*------------------------------------------------------------------------*/
189 | 
190 | void add_to_vstack(const Var* v) {
191 |   assert(v);
192 |   vstack.push(v);
193 | }
194 | 
195 | /*------------------------------------------------------------------------*/
196 | 
197 | Term * build_term_from_stack() {
198 |   Term * res = 0;
199 |   while (!vstack.empty()) {
200 |     Term * t = new_term(vstack.top(), res);
201 |     assert(t);
202 | 
203 |     vstack.pop();
204 |     deallocate_term(res);
205 |     res = t;
206 |   }
207 |   return res;
208 | }
209 | 
210 | /*------------------------------------------------------------------------*/
211 | 
212 | Term * multiply_term(Term * t1, Term * t2) {
213 |   if (!t1 || !t2) return 0;
214 |   if (t1 == t2) return t1->copy();
215 | 
216 |   const Term * tmp1 = t1;
217 |   const Term * tmp2 = t2;
218 | 
219 | 
220 |   while (tmp1 && tmp2) {
221 |     if (tmp1->get_var_level() > tmp2->get_var_level()) {
222 |       vstack.push(tmp1->get_var());
223 |       tmp1 = tmp1->get_rest();
224 |     } else if (tmp1->get_var_level() < tmp2->get_var_level()) {
225 |       vstack.push(tmp2->get_var());
226 |       tmp2 = tmp2->get_rest();
227 |     } else {
228 |       vstack.push(tmp1->get_var());
229 |       tmp1 = tmp1->get_rest();
230 |       tmp2 = tmp2->get_rest();
231 |     }
232 |   }
233 | 
234 |   while (tmp1) {
235 |     vstack.push(tmp1->get_var());
236 |     tmp1 = tmp1->get_rest();
237 |   }
238 | 
239 |   while (tmp2) {
240 |     vstack.push(tmp2->get_var());
241 |     tmp2 = tmp2->get_rest();
242 |   }
243 |   Term * t = build_term_from_stack();
244 | 
245 |   return t;
246 | }
247 | 
248 | /*------------------------------------------------------------------------*/
249 | 
250 | Term * remainder(const Term * t, const Var * v) {
251 |   assert(v);
252 | 
253 | 
254 |   while (t) {
255 |     const Var * v1 = t->get_var();
256 | 
257 |     if (v1 == v) {
258 |       t = t->get_rest();
259 |     } else {
260 |       vstack.push(v1);
261 |       t = t->get_rest();
262 |     }
263 |   }
264 | 
265 |   Term * res = build_term_from_stack();
266 |   return res;
267 | }
268 | 


--------------------------------------------------------------------------------
/src/substitution.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /* AMulet2 : AIG Multiplier Verification Tool.
  3 |  *
  4 |  * Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  5 |  *
  6 |  * substitution.h: functions used for adder substitution
  7 |  */
  8 | /*------------------------------------------------------------------------*/
  9 | #ifndef AMULET2_SRC_SUBSTITUTION_H_
 10 | #define AMULET2_SRC_SUBSTITUTION_H_
 11 | /*------------------------------------------------------------------------*/
 12 | #include <vector>
 13 | 
 14 | #include "gate.h"
 15 | /*------------------------------------------------------------------------*/
 16 | 
 17 | /**
 18 |     Checks whether all AIG outputs are used only once
 19 | 
 20 |     @return True if all AIG outputs are single gates
 21 | */
 22 | bool all_single_output();
 23 | 
 24 | /**
 25 |     Checks whether all AIG outputs are XOR gates
 26 | 
 27 |     @return True if all outputs in slices 1 to NN-2 are XOR gates
 28 | */
 29 | bool all_outputs_are_xor();
 30 | 
 31 | /**
 32 |     If the output of slice 2 has more than 3 parents, than the carry-in
 33 |     of the final stage is the output of slice 0(in the aoki benchmarks.)
 34 | 
 35 |     @return False if output of slice 2 has more than 3 parents but output
 36 |     of slice 0 is single gate
 37 | */
 38 | bool slice_two_needs_carry_in_slice_zero();
 39 | 
 40 | /**
 41 |     Checks whether the output of slice 0 is a possible carry-in for the
 42 |     final stage adder
 43 | 
 44 |     @return True if output of slice 0 has more than one parent.
 45 | */
 46 | bool cin_in_slice_0();
 47 | 
 48 | /**
 49 |     Returns the aiger value of last element of the inputs vector
 50 | 
 51 |     @param flip indicates whether the input has to be negated
 52 | 
 53 |     @return unsigned
 54 | */
 55 | unsigned get_input(bool flip = 0);
 56 | 
 57 | /**
 58 |     Adds the gate n to the inputs vector
 59 | 
 60 |     @param n Gate* to be pushed
 61 | */
 62 | void push_to_inputs(Gate * n);
 63 | 
 64 | /**
 65 |     Adds the gate n to the outputs vector and sets it's slice to i
 66 | 
 67 |     @param n Gate* to be pushed
 68 |     @param i integer indicating the slice index
 69 | */
 70 | void push_to_outputs(Gate * n, int i);
 71 | 
 72 | /**
 73 |     Adds the gate n to the cins vector and sets it's slice to i
 74 | 
 75 |     @param n Gate* to be pushed
 76 |     @param i integer indicating the slice index
 77 | */
 78 | void push_to_cins(Gate * n, int i);
 79 | 
 80 | /**
 81 |     Sets the gate n to the carry_in of the final stage adder
 82 | 
 83 |     @param n Gate*
 84 | */
 85 | void set_carry_in(Gate * n);
 86 | 
 87 | /**
 88 |     Identifies the carry out of the final stage adder
 89 | */
 90 | void identify_carry_out();
 91 | 
 92 | /**
 93 |     Identifies the propagate and generate gates of the final stage adder
 94 | 
 95 |     @return True if all checks succeeded
 96 | */
 97 | bool identify_propagate_and_generate_gates();
 98 | 
 99 | /**
100 |     For some multipliers we have to adjust the inputs, because they are sometimes
101 |     propagate or generate gate themselves.
102 | */
103 | void fix_inputs();
104 | 
105 | /**
106 |     Follow all paths from the gate n and check that we stop at
107 |     the identified inputs and carry-in of the final stage adder.
108 |     All gates that are seen on the way are marked to belong to the final stage
109 |     adder.
110 | 
111 |     @param n  Gate* pointing to root gate, from which we start the checks
112 |     @param init: bool indicating whether we started from the carry out
113 | 
114 |     @return True if all checks succeeded
115 | */
116 | bool follow_path_and_mark_gates(Gate * n, bool init = 0);
117 | 
118 | /**
119 |     Calls follow_path_and_mark_gates for all identified output gates of
120 |     the final stage adder.
121 | 
122 |     @return True if all checks succeeded
123 | */
124 | bool follow_all_output_paths_and_mark_gates();
125 | 
126 | /**
127 |     For all input gates we count how often they are used as inputs in the
128 |     final stage adder.
129 | */
130 | void correctly_mark_inputs();
131 | 
132 | /**
133 |     Routine for identifying the final stage adder
134 | 
135 |     @return True if all checks succeeded
136 | */
137 | bool identify_final_stage_adder();
138 | 
139 | /*------------------------------------------------------------------------*/
140 | /**
141 |     Adds the identified final stage adder to the miter
142 | */
143 | void add_original_adder();
144 | 
145 | /**
146 |     A vector called original_outputs is filled by the outputs of the
147 |     final stage adder. These gates are then later used, when the miter
148 |     is generated.
149 | */
150 | void fill_original_outputs();
151 | 
152 | /**
153 |     Generates an AIG of a half-adder with inputs i1 and i2.
154 |     These are added to the rewritten AIG as well as to the miter.
155 | 
156 |     @param i1 unsigned, input 1 of the half adder
157 |     @param i2 unsigned, input 2 of the half adder
158 |     @param carry: bool indicating whether we add the carry of the half-adder
159 |                   to the rewritten_outputs
160 | 
161 |     @return the sum output if carry = 0, and the carry output if carry = 1
162 | */
163 | unsigned btor_ha(unsigned i1, unsigned i2, bool carry = 1);
164 | 
165 | /**
166 |     Generates an AIG of a half-adder with inputs i1, i2 and i3.
167 |     These are added to the rewritten AIG as well as to the miter.
168 | 
169 |     @param i1 unsigned, input 1 of the full adder
170 |     @param i2 unsigned, input 2 of the full adder
171 |     @param i3 unsigned, input 3 of the full adder
172 |     @param carry: bool indicating whether we add the carry of the full-adder
173 |                   to the rewritten_outputs
174 | 
175 |     @return the sum output if carry = 0, and the carry output if carry = 1
176 | */
177 | unsigned btor_fa(unsigned i1, unsigned i2, unsigned i3, bool carry = 1);
178 | 
179 | /**
180 |     Generates a ripple-carry adder using the inputs, stored in the
181 |     inputs vector. The outpus of this adder are added to the rewritten_outputs
182 | */
183 | void add_btor_adder();
184 | 
185 | /**
186 |     Flips the last bit of a to negate the unsigned integer as
187 |     used in the aiger format
188 | 
189 |     @param a unsigned integer
190 | 
191 |     @return the negated aiger value of a
192 | */
193 | unsigned not_(unsigned a);
194 | 
195 | /**
196 |     Generates an AIG gate with inputs a and b
197 | 
198 |     @param a unsigned integer
199 |     @param b unsigned integer
200 | 
201 |     @return the value of the output gate
202 | */
203 | unsigned and_(unsigned a, unsigned b);
204 | 
205 | /**
206 |     Generates AIG gates for a implies b, using and_ and not_
207 | 
208 |     @param a unsigned integer
209 |     @param b unsigned integer
210 | 
211 |     @return the value of the output gate
212 | */
213 | unsigned implies_(unsigned a, unsigned b);
214 | 
215 | /**
216 |     Generates AIG gates for a xnor b, using implies_ and and_
217 | 
218 |     @param a unsigned integer
219 |     @param b unsigned integer
220 | 
221 |     @return the value of the output gate
222 | */
223 | unsigned xnor_(unsigned a, unsigned b);
224 | 
225 | /**
226 |     Builds the miter, where the the original_outputs and the rewritten_outputs
227 |     are combined elementwise using a sequence of xnor gates
228 | 
229 |     @return True if all checks succeeded
230 | */
231 | bool build_miter();
232 | 
233 | /**
234 |     Routine to generate the miter aig
235 | 
236 |     @return True if all checks succeeded
237 | */
238 | bool build_adder_miter();
239 | 
240 | /**
241 |     Translate the miter aig to CNF and prints it to the file
242 | 
243 |     @param file Output file
244 | 
245 |     @return True if all checks succeeded
246 | */
247 | bool miter_to_file(FILE * file);
248 | 
249 | /**
250 |     Prints the trivial CNF  "a and not a" to the file
251 | 
252 |     @param file Output file
253 | 
254 |     @return True if all checks succeeded
255 | */
256 | bool trivial_miter_to_file(FILE * file);
257 | /*------------------------------------------------------------------------*/
258 | 
259 | 
260 | /**
261 |     Generates the rewritten aig by adding all gates that are not marked as
262 |     the final stage adder.
263 |     The gates of the ripple carry adder have been already added in add_btor_adder.
264 | */
265 | void generate_rewritten_aig();
266 | 
267 | 
268 | 
269 | #endif  // AMULET2_SRC_SUBSTITUTION_H_
270 | 


--------------------------------------------------------------------------------
/src/amulet.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file amulet.cpp
  3 |     \brief main file of our tool AMulet2
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #define VERSION "2.2"
 10 | /*------------------------------------------------------------------------*/
 11 | // / Manual of AMulet2, will be printed with command line '-h'
 12 | static const char * USAGE =
 13 | "\n"
 14 | "### USAGE ###\n"
 15 | "usage : amulet2 <mode> <input.aig> <output files> [<option> ...] \n"
 16 | "\n"
 17 | "Depending on the <mode> the <output files> and <options> have to be set:"
 18 | "\n"
 19 | "\n"
 20 | "<mode> = -substitute:\n"
 21 | "    <output files> =  2 output files passed in the following order \n"
 22 | "      <out.cnf>:        CNF miter for correctness of adder substitution \n"
 23 | "      <out.aig>:        rewritten aiger is stored in this file \n"
 24 | "\n"
 25 | "    <option> = the following options are available \n"
 26 | "      -h | --help       print this command line summary \n"
 27 | "      -v<1,2,3,4>       different levels of verbosity(see below) \n"
 28 | "      -signed           option for non-negative integer multipliers \n"
 29 | "\n"
 30 | "\n"
 31 | "<mode> = -verify:\n"
 32 | "    <output files> =  no output files are required \n"
 33 | "     \n "
 34 | "    <option> = the following options are available \n"
 35 | "       -h | --help           print this command line summary \n"
 36 | "       -v<1,2,3,4>           different levels of verbosity(default -v1) \n"
 37 | "       -signed               option for non-negative integer multipliers \n"
 38 | "       -no-counter-examples  do not generate and write counter examples\n"
 39 | "     \n"
 40 | "     \n"
 41 | "<mode> = -certify:\n"
 42 | "    <output files> =  3 output files passed in the following order\n"
 43 | "      <out.polys>:      initial polynomial set \n"
 44 | "      <out.proof>:      proof rules \n"
 45 | "      <out.spec> :      spec which should be checked \n"
 46 | "     \n "
 47 | "    <option> = the following options are available \n"
 48 | "       -h | --help      print this command line summary \n"
 49 | "       -v<1,2,3,4>      different levels of verbosity(default -v1) \n"
 50 | "       -signed          option for non-negative integer multipliers \n"
 51 | "       -no-counter-examples  do not generate and write counter examples\n"
 52 | "\n"
 53 | "       -p1          expanded proof \n"
 54 | "       -p2          middle condensed proof(some linear combinations occur, default)\n"
 55 | "       -p3          condensed proof(one single linear combination)\n";
 56 | /*------------------------------------------------------------------------*/
 57 | #include "parser.h"
 58 | #include "substitution_engine.h"
 59 | #include "polynomial_solver.h"
 60 | /*------------------------------------------------------------------------*/
 61 | // / Name of the input file
 62 | static const char * input_name = 0;
 63 | 
 64 | // / \brief
 65 | // / Name of first output file, which stores the CNF miter in '-substitute', and
 66 | // / the gate constraints in '-certify'.
 67 | static const char * output_name1 = 0;
 68 | 
 69 | // / \brief
 70 | // / Name of second output file, storing the rewritten AIG in '-substitute',
 71 | // / and the core proof in '-certify'.
 72 | static const char * output_name2 = 0;
 73 | 
 74 | // / Name of third output file. Stores the specification in '-certify'.
 75 | static const char * output_name3 = 0;
 76 | 
 77 | // / Selected mode, '-substitute' = 1, '-verify' = 2, '-certify' = 3
 78 | static int mode;
 79 | /*------------------------------------------------------------------------*/
 80 | // ERROR CODES:
 81 | 
 82 | static int err_no_file    = 10; // no input file given
 83 | static int err_mode_sel   = 11; // mode has already been selected/not selected
 84 | static int err_wrong_arg  = 12; // wrong number of arguments given
 85 | static int err_proof_form = 13; // too many proof formats selected
 86 | 
 87 | 
 88 | /*------------------------------------------------------------------------*/
 89 | /**
 90 |     Calls the deallocaters of the involved data types
 91 |     @see reset_all_signal_handlers()
 92 |     @see delete_gates()
 93 |     @see deallocate_terms()
 94 |     @see deallocate_mstack()
 95 |     @see clear_mpz()
 96 | */
 97 | static void reset_all() {
 98 |   reset_all_signal_handlers();
 99 |   delete_gates();
100 |   deallocate_terms();
101 |   deallocate_mstack();
102 |   clear_mpz();
103 | }
104 | /*------------------------------------------------------------------------*/
105 | /**
106 |     Main Function of AMulet2.
107 |     Reads the given AIG and depending on the selected mode, either
108 |     calls the substution engine or the polynomial solver.
109 | 
110 |     Prints statistics to stdout after finishing.
111 | */
112 | int main(int argc, char ** argv) {
113 |   msg("AMulet Version " VERSION);
114 |   msg("Aiger multiplier examination tool");
115 |   msg("Copyright(C) 2020, 2021, Daniela Kaufmann, Johannes Kepler University Linz");
116 | 
117 |   for (int i = 1; i < argc; i++) {
118 |     if (!strcmp(argv[i], "-h") ||
119 |     !strcmp(argv[i], "--help")) {
120 |       fputs(USAGE, stdout);
121 |       fflush(stdout);
122 |       exit(0);
123 |     } else if (!strcmp(argv[i], "-v0")) { verbose = 0;
124 |     } else if (!strcmp(argv[i], "-v1")) { verbose = 1;
125 |     } else if (!strcmp(argv[i], "-v2")) { verbose = 2;
126 |     } else if (!strcmp(argv[i], "-v3")) { verbose = 3;
127 |     } else if (!strcmp(argv[i], "-v4")) { verbose = 4;
128 |     } else if (!strcmp(argv[i], "-substitute")) {
129 |       if (!mode) {
130 |         msg("selected mode: adder substitution");
131 |         mode = 1;
132 |       } else {
133 |         die(err_mode_sel, "mode has alreday been selected(try '-h')");
134 |       }
135 |     } else if (!strcmp(argv[i], "-verify")) {
136 |       if (!mode) {
137 |         msg("selected mode: verification");
138 |         mode = 2;
139 |       } else {
140 |         die(err_mode_sel, "mode has alreday been selected(try '-h')");
141 |       }
142 |     } else if (!strcmp(argv[i], "-certify")) {
143 |       if (!mode) {
144 |         msg("selected mode: verification + certificates");
145 |         mode = 3;
146 |       } else {
147 |         die(err_mode_sel, "mode has alreday been selected(try '-h')");
148 |       }
149 |     } else if (!strcmp(argv[i], "-p1")) {
150 |       if (proof) die(err_proof_form, "too many proof formats selected(try '-h')");
151 |       proof = 1;
152 |     } else if (!strcmp(argv[i], "-p2")) {
153 |       if (proof) die(err_proof_form, "too many proof formats selected(try '-h')");
154 |       proof = 2;
155 |     } else if (!strcmp(argv[i], "-p3")) {
156 |       if (proof) die(err_proof_form, "too many proof formats selected(try '-h')");
157 |       proof = 3;
158 |     } else if (!strcmp(argv[i], "-signed")) {
159 |       signed_mult = 1;
160 |     } else if (!strcmp(argv[i], "-no-counter-examples")) {
161 |       gen_witness = 0;
162 |     } else if (output_name3) {
163 |       die(err_wrong_arg, "too many arguments '%s', '%s', '%s', '%s' and '%s'(try '-h')",
164 |         input_name, output_name1, output_name2, output_name3, argv[i]);
165 |     } else if (output_name2) { output_name3 = argv[i];
166 |     } else if (output_name1) { output_name2 = argv[i];
167 |     } else if (input_name) { output_name1 = argv[i];
168 |     } else {
169 |       input_name = argv[i];
170 |     }
171 |   }
172 | 
173 |   if (!mode) die(err_mode_sel, "select mode(try -h for more information)");
174 |   if (!input_name)  die(err_no_file, "no input file given(try '-h')");
175 |   if (mode == 1) {
176 |     if (output_name3)
177 |       die(err_wrong_arg, "too many arguments '%s', '%s', '%s' and '%s'(try '-h')",
178 |     input_name, output_name1, output_name2, output_name3);
179 |     if (!output_name2) die(err_wrong_arg, "too few arguments(try '-h')");
180 |     if (proof) {
181 |       msg("option -p1, -p2 or -p3 are only possible in -certify");
182 |       msg("and will be ignored");
183 |     }
184 |     proof = 0;
185 |   } else if (mode == 2) {
186 |     if (output_name1) die(err_wrong_arg, "too many arguments(try '-h')");
187 |     if (proof) {
188 |       msg("option -p1, -p2 or -p3 are only possible in -certify");
189 |       msg("and will be ignored");
190 |     }
191 |     proof = 0;
192 |   } else if (mode == 3) {
193 |     if (!output_name3) die(err_wrong_arg, "too few arguments(try '-h')");
194 |     if (!proof) proof = 2;
195 |     if (proof == 3) msg("proof condensed level: high");
196 |     else if (proof == 2) msg("proof condensed level: medium");
197 |     else
198 |       msg("proof condensed level: expanded");
199 |   }
200 | 
201 |   init_all_signal_handers();
202 |   init_nonces();
203 | 
204 |   parse_aig(input_name);
205 |   bool res;
206 |   if (mode == 1) {
207 |     init_gate_substitution();
208 |     res = substitution(output_name1, output_name2);
209 |   } else {
210 |     init_gates_verify();
211 |     res = verify(input_name, output_name1, output_name2, output_name3, mode == 3);
212 |   }
213 | 
214 |   reset_aig_parsing();
215 |   reset_all();
216 | 
217 |   reset_time = process_time();
218 |   print_statistics(mode);
219 | 
220 |   return res;
221 | }
222 | 


--------------------------------------------------------------------------------
/src/polynomial.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file polynomial.cpp
  3 |     \brief contains arithmetic operations for polynomials
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include "polynomial.h"
 10 | /*------------------------------------------------------------------------*/
 11 | 
 12 | Polynomial::Polynomial() {}
 13 | Polynomial::Polynomial (Monomial ** m, size_t len):mon(m), num_mon(len) {}
 14 | 
 15 | /*------------------------------------------------------------------------*/
 16 | 
 17 | Polynomial * Polynomial::copy() const {
 18 | 
 19 |   for (size_t i = 0 ; i < size(); i++) {
 20 |     Monomial * m = get_mon(i);
 21 |     push_mstack_end(m->copy());
 22 |   }
 23 |   Polynomial * out = build_poly();
 24 |   out->set_idx(idx);
 25 |   return out;
 26 | }
 27 | 
 28 | /*------------------------------------------------------------------------*/
 29 | 
 30 | void Polynomial::print(FILE * file, bool end) const {
 31 |   if (size() == 0) { fputs_unlocked("0", file);
 32 |   } else {
 33 |     for (size_t i = 0 ; i < size(); i++) {
 34 |       Monomial * m = get_mon(i);
 35 |       if (i == 0) m->print(file, 1);
 36 |       else
 37 |         m->print(file, 0);
 38 |     }
 39 |   }
 40 |   if (end) fputs(";\n", file);
 41 | }
 42 | 
 43 | /*------------------------------------------------------------------------*/
 44 | 
 45 | Polynomial::~Polynomial() {
 46 |   for (size_t i = 0 ; i < size(); i++) {
 47 |     Monomial * m = get_mon(i);
 48 |     deallocate_monomial(m);
 49 |   }
 50 |   delete[]mon;
 51 | }
 52 | 
 53 | /*------------------------------------------------------------------------*/
 54 | 
 55 | bool Polynomial::is_constant_zero_poly() const {
 56 |   return size() == 0;
 57 | }
 58 | 
 59 | /*------------------------------------------------------------------------*/
 60 | 
 61 | bool Polynomial::is_constant_one_poly() const {
 62 |   if (size() != 1) return 0;
 63 | 
 64 |   Monomial * m = get_mon(0);
 65 |   if (m->get_term()) return 0;
 66 |   if (mpz_cmp_si(m->coeff, 1) != 0) return 0;
 67 | 
 68 |   return 1;
 69 | }
 70 | 
 71 | /*------------------------------------------------------------------------*/
 72 | 
 73 | int Polynomial::min_term_size() const {
 74 |     int len = INT_MAX;
 75 | 
 76 |     for (size_t i = 0 ; i < size(); i++) {
 77 |       Monomial * m = get_mon(i);
 78 | 
 79 |       int tlen = 0;
 80 |       if (m->get_term()) tlen=m->get_term_size();
 81 |       if (tlen < len) len = tlen;
 82 |     }
 83 |     return len;
 84 | }
 85 | 
 86 | /*------------------------------------------------------------------------*/
 87 | // Local variables
 88 | static size_t size_mstack;  // /< size of mstack
 89 | static size_t num_mstack = 0;  // /< number of elements in mstack
 90 | static Monomial ** mstack;  // /< Monomial** used for building poly
 91 | /*------------------------------------------------------------------------*/
 92 | 
 93 | void enlarge_mstack() {
 94 |   size_t new_size_mstack = size_mstack ? 2*size_mstack : 1;
 95 | 
 96 |   Monomial** newArr = new Monomial*[new_size_mstack];
 97 |   memcpy( newArr, mstack, size_mstack * sizeof(Monomial*) );
 98 |   delete [] mstack;
 99 |   mstack = newArr;
100 |   size_mstack = new_size_mstack;
101 | }
102 | 
103 | /*------------------------------------------------------------------------*/
104 | 
105 | void clear_mstack() {
106 |   num_mstack = 0;
107 |   size_mstack = 0;
108 |   mstack = 0;}
109 | 
110 | /*------------------------------------------------------------------------*/
111 | 
112 | void deallocate_mstack() { delete[](mstack); }
113 | 
114 | /*------------------------------------------------------------------------*/
115 | 
116 | bool mstack_is_empty() { return num_mstack == 0;}
117 | 
118 | /*------------------------------------------------------------------------*/
119 | void push_mstack_end(Monomial *m) {
120 |   if (size_mstack == num_mstack) enlarge_mstack();
121 | 
122 |   assert(m);
123 |   if (mpz_sgn(m->coeff) == 0) {
124 |     deallocate_monomial(m);
125 |     return;
126 |   }
127 | 
128 |   mstack[num_mstack++] = m;
129 | }
130 | 
131 | /*------------------------------------------------------------------------*/
132 | 
133 | void push_mstack(Monomial *m) {
134 |   assert(m);
135 |   if (mpz_sgn(m->coeff) == 0) {
136 |     deallocate_monomial(m);
137 |     return;
138 |   }
139 | 
140 |   if (size_mstack == num_mstack) enlarge_mstack();
141 |   if (num_mstack == 0) {
142 |     mstack[num_mstack++] = m;
143 |     return;
144 |   }
145 | 
146 |   if (!m->get_term()) {
147 |     Monomial * tmp = mstack[num_mstack-1];
148 | 
149 |     if (tmp->get_term()) { mstack[num_mstack++] = m;
150 |     } else {
151 |       mpz_t coeff;
152 |       mpz_init(coeff);
153 |       mpz_add(coeff, tmp->coeff, m->coeff);
154 |       deallocate_monomial(m);
155 |       deallocate_monomial(tmp);
156 | 
157 |       if (mpz_sgn(coeff) != 0)
158 |         mstack[num_mstack-1] = new Monomial(coeff, 0);
159 |       else
160 |         --num_mstack;
161 | 
162 |       mpz_clear(coeff);
163 |     }
164 |   } else {
165 |     assert(num_mstack > 0);
166 |     int i = num_mstack-1;
167 |     int cmp = -1;
168 |     Monomial * tmp = 0;
169 | 
170 |     while (i >= 0) {
171 |       tmp = mstack[i];
172 |       cmp = tmp->get_term()->cmp(m->get_term());
173 | 
174 |       if (cmp >= 0) break;
175 |       i--;
176 |     }
177 | 
178 |     if (cmp == 0) {
179 |       mpz_t coeff;
180 |       mpz_init(coeff);
181 |       mpz_add(coeff, tmp->coeff, m->coeff);
182 | 
183 |       if (mpz_sgn(coeff) == 0) {
184 |         for (unsigned j = i; j < num_mstack-1; j++)
185 |           mstack[j] = mstack[j+1];
186 |         num_mstack--;
187 |       } else {
188 |         mstack[i] = new Monomial(coeff, m->get_term_copy());
189 |       }
190 |       deallocate_monomial(m);
191 |       deallocate_monomial(tmp);
192 |       mpz_clear(coeff);
193 |     } else {
194 |       for (int j = num_mstack; j > i+1; j--)
195 |       mstack[j] = mstack[j-1];
196 |       mstack[i+1] = m;
197 |       num_mstack++;
198 |     }
199 |   }
200 | }
201 | 
202 | /*------------------------------------------------------------------------*/
203 | 
204 | Polynomial * build_poly() {
205 |   Polynomial * res = new Polynomial(mstack, num_mstack);
206 |   clear_mstack();
207 |   return res;
208 | }
209 | 
210 | /*------------------------------------------------------------------------*/
211 | 
212 | Polynomial * add_poly(const Polynomial * p1, const Polynomial * p2) {
213 |   if(!p1) return p2->copy();
214 |   if(!p2) return p1->copy();
215 |   assert(p1);
216 |   assert(p2);
217 | 
218 |   size_t i = 0, j= 0;
219 | 
220 |   Monomial * m1 = p1->get_mon(i);
221 |   Monomial * m2 = p2->get_mon(j);
222 |   mpz_t coeff;
223 |   mpz_init(coeff);
224 | 
225 |   while (i < p1->size() && j < p2->size()) {
226 |     if (!m1->get_term() || !m2->get_term()) {
227 |       if (!m1->get_term() && !m2->get_term()) {
228 |         mpz_add(coeff, m1->coeff, m2->coeff);
229 |         if (mpz_sgn(coeff) != 0) {
230 |           Monomial * m = new Monomial(coeff, 0);
231 |           push_mstack_end(m);
232 |         }
233 |         m1 = p1->get_mon(++i);
234 |         m2 = p2->get_mon(++j);
235 | 
236 |       } else if (!m1->get_term()) {
237 |         push_mstack_end(m2->copy());
238 |         m2 = p2->get_mon(++j);
239 |       } else {
240 |         push_mstack_end(m1->copy());
241 |         m1 = p1->get_mon(++i);
242 |       }
243 |     } else {
244 |       int cmp = m1->get_term()->cmp(m2->get_term());
245 |       if (cmp == 1) {
246 |         push_mstack_end(m1->copy());
247 |         m1 = p1->get_mon(++i);
248 |       } else if (cmp == -1) {
249 |         push_mstack_end(m2->copy());
250 |         m2 = p2->get_mon(++j);
251 |       } else {
252 |         mpz_add(coeff, m1->coeff, m2->coeff);
253 |         if (mpz_sgn(coeff) != 0) {
254 |           Monomial * m = new Monomial(coeff, m1->get_term_copy());
255 |           push_mstack_end(m);
256 |         }
257 |         m1 = p1->get_mon(++i);
258 |         m2 = p2->get_mon(++j);
259 |       }
260 |     }
261 |   }
262 |   mpz_clear(coeff);
263 | 
264 |   while (i < p1->size()) {
265 |     push_mstack_end(m1->copy());
266 |     m1 = p1->get_mon(++i);
267 |   }
268 |   while (j < p2->size()) {
269 |     push_mstack_end(m2->copy());
270 |     m2 = p2->get_mon(++j);
271 |   }
272 | 
273 |   Polynomial * p = build_poly();
274 |   return p;
275 | }
276 | 
277 | 
278 | /*------------------------------------------------------------------------*/
279 | 
280 | Polynomial * multiply_poly(const Polynomial * p1, const Polynomial * p2) {
281 |   if(!p1 || !p2) return 0;
282 |   assert(p1);
283 |   assert(p2);
284 |   
285 |   mpz_t coeff;
286 |   mpz_init(coeff);
287 |   Term * t;
288 |   for (size_t i = 0 ; i < p1->size(); i++) {
289 |     Monomial * m1 = p1->get_mon(i);
290 |     for (size_t j = 0 ; j < p2->size(); j++) {
291 |       Monomial * m2 = p2->get_mon(j);
292 |       if (mpz_cmp_si(m1->coeff, -1) == 0 ) mpz_neg(coeff, m2->coeff);
293 |       else if (mpz_cmp_si(m2->coeff, -1) == 0 ) mpz_neg(coeff, m1->coeff);
294 |       else
295 |         mpz_mul(coeff, m1->coeff, m2->coeff);
296 | 
297 |       if (m1->get_term() && m2->get_term())
298 |         t = multiply_term(m1->get_term(), m2->get_term());
299 |       else if (m2->get_term())
300 |         t = m2->get_term_copy();
301 |       else if (m1->get_term())
302 |         t = m1->get_term_copy();
303 |       else
304 |         t = 0;
305 |       push_mstack(new Monomial(coeff, t));
306 |     }
307 |   }
308 |   Polynomial * p = build_poly();
309 |   mpz_clear(coeff);
310 |   return p;
311 | }
312 | 
313 | /*------------------------------------------------------------------------*/
314 | 
315 | Polynomial * multiply_poly_with_constant(const Polynomial *p1, mpz_t c) {
316 |   if (mpz_sgn(c) == 0) return 0;
317 |   mpz_t coeff;
318 |   mpz_init(coeff);
319 | 
320 |   for (size_t i = 0 ; i < p1->size(); i++) {
321 |     Monomial * m = p1->get_mon(i);
322 |     mpz_mul(coeff, m->coeff, c);
323 |     if (m->get_term())
324 |       push_mstack_end(new Monomial(coeff, m->get_term_copy()));
325 |     else
326 |       push_mstack_end(new Monomial(coeff, 0));
327 |   }
328 |   Polynomial * tmp = build_poly();
329 |   mpz_clear(coeff);
330 |   return tmp;
331 | }
332 | 
333 | /*------------------------------------------------------------------------*/
334 | 
335 | Polynomial * divide_by_term(const Polynomial * p1, const Term * t) {
336 |   assert(t->size() == 1);
337 |   const Var * v = t->get_var();
338 | 
339 |   for (size_t i = 0 ; i < p1->size(); i++) {
340 |     Monomial * lm_tmp = p1->get_mon(i);
341 | 
342 |     if (!lm_tmp->get_term()) continue;
343 |     if (lm_tmp->get_term()->cmp(t) == -1) break;
344 | 
345 |     if (lm_tmp->get_term()->contains(v)) {
346 |       Term * t_rem = remainder(lm_tmp->get_term(), v);
347 |       if (t_rem) { push_mstack_end(new Monomial(lm_tmp->coeff, t_rem->copy()));
348 |       } else {
349 |         push_mstack_end(new Monomial(lm_tmp->coeff, 0));
350 |         break;
351 |       }
352 |     }
353 |   }
354 |   Polynomial * p = build_poly();
355 |   return p;
356 | }
357 | 
358 | 
359 | /*------------------------------------------------------------------------*/
360 | mpz_t one;
361 | mpz_t minus_one;
362 | mpz_t base;
363 | mpz_t mod_coeff;
364 | 
365 | /*------------------------------------------------------------------------*/
366 | 
367 | void init_mpz(unsigned exp) {
368 |   mpz_init_set_ui(one, 1);
369 |   mpz_init_set_si(minus_one, -1);
370 |   mpz_init_set_ui(base, 2);
371 | 
372 |   mpz_init(mod_coeff);
373 |   mpz_pow_ui(mod_coeff, base, exp);
374 | }
375 | 
376 | /*------------------------------------------------------------------------*/
377 | 
378 | void clear_mpz() {
379 |   mpz_clear(one);
380 |   mpz_clear(minus_one);
381 |   mpz_clear(base);
382 |   mpz_clear(mod_coeff);
383 | }
384 | 
385 | /*------------------------------------------------------------------------*/
386 | 


--------------------------------------------------------------------------------
/includes/aiger.h:
--------------------------------------------------------------------------------
  1 | /***************************************************************************
  2 | Copyright (c) 2006 - 2014, Armin Biere, Johannes Kepler University.
  3 | 
  4 | Permission is hereby granted, free of charge, to any person obtaining a copy
  5 | of this software and associated documentation files (the "Software"), to
  6 | deal in the Software without restriction, including without limitation the
  7 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  8 | sell copies of the Software, and to permit persons to whom the Software is
  9 | furnished to do so, subject to the following conditions:
 10 | 
 11 | The above copyright notice and this permission notice shall be included in
 12 | all copies or substantial portions of the Software.
 13 | 
 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 19 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 20 | IN THE SOFTWARE.
 21 | ***************************************************************************/
 22 | 
 23 | /*------------------------------------------------------------------------*/
 24 | /* This file contains the API of the 'AIGER' library, which is a reader and
 25 |  * writer for the AIGER AIG format.  The code of the library
 26 |  * consists of 'aiger.c' and 'aiger.h'.  It is independent of 'simpaig.c'
 27 |  * and 'simpaig.h'.
 28 |  * library.
 29 |  */
 30 | #ifndef aiger_h_INCLUDED
 31 | #define aiger_h_INCLUDED
 32 | 
 33 | 
 34 | 
 35 | #include <stdio.h>
 36 | 
 37 | /*------------------------------------------------------------------------*/
 38 | 
 39 | #define AIGER_VERSION "1.9"
 40 | 
 41 | /*------------------------------------------------------------------------*/
 42 | 
 43 | typedef struct aiger aiger;
 44 | typedef struct aiger_and aiger_and;
 45 | typedef struct aiger_symbol aiger_symbol;
 46 | 
 47 | /*------------------------------------------------------------------------*/
 48 | /* AIG references are represented as unsigned integers and are called
 49 |  * literals.  The least significant bit is the sign.  The index of a literal
 50 |  * can be obtained by dividing the literal by two.  Only positive indices
 51 |  * are allowed, which leaves 0 for the boolean constant FALSE.  The boolean
 52 |  * constant TRUE is encoded as the unsigned number 1 accordingly.
 53 |  */
 54 | #define aiger_false 0
 55 | #define aiger_true 1
 56 | 
 57 | #define aiger_sign(l) \
 58 |   (((unsigned)(l))&1)
 59 | 
 60 | #define aiger_strip(l) \
 61 |   (((unsigned)(l))&~1)
 62 | 
 63 | #define aiger_not(l) \
 64 |   (((unsigned)(l))^1)
 65 | 
 66 | /*------------------------------------------------------------------------*/
 67 | /* Each literal is associated to a variable having an unsigned index.  The
 68 |  * variable index is obtained by deviding the literal index by two, which is
 69 |  * the same as removing the sign bit.
 70 |  */
 71 | #define aiger_var2lit(i) \
 72 |   (((unsigned)(i)) << 1)
 73 | 
 74 | #define aiger_lit2var(l) \
 75 |   (((unsigned)(l)) >> 1)
 76 | 
 77 | /*------------------------------------------------------------------------*/
 78 | /* Callback functions for client memory management.  The 'free' wrapper will
 79 |  * get as last argument the size of the memory as it was allocated.
 80 |  */
 81 | typedef void *(*aiger_malloc) (void *mem_mgr, size_t);
 82 | typedef void (*aiger_free) (void *mem_mgr, void *ptr, size_t);
 83 | 
 84 | /*------------------------------------------------------------------------*/
 85 | /* Callback function for client character stream reading.  It returns an
 86 |  * ASCII character or EOF.  Thus is has the same semantics as the standard
 87 |  * library 'getc'.   See 'aiger_read_generic' for more details.
 88 |  */
 89 | typedef int (*aiger_get) (void *client_state);
 90 | 
 91 | /*------------------------------------------------------------------------*/
 92 | /* Callback function for client character stream writing.  The return value
 93 |  * is EOF iff writing failed and otherwise the character 'ch' casted to an
 94 |  * unsigned char.  It has therefore the same semantics as 'fputc' and 'putc'
 95 |  * from the standard library.
 96 |  */
 97 | typedef int (*aiger_put) (char ch, void *client_state);
 98 | 
 99 | /*------------------------------------------------------------------------*/
100 | 
101 | enum aiger_mode
102 | {
103 |   aiger_binary_mode = 0,
104 |   aiger_ascii_mode = 1,
105 |   aiger_stripped_mode = 2,	/* can be ORed with one of the previous */
106 | };
107 | 
108 | typedef enum aiger_mode aiger_mode;
109 | 
110 | /*------------------------------------------------------------------------*/
111 | 
112 | struct aiger_and
113 | {
114 |   unsigned lhs;			/* as literal [2..2*maxvar], even */
115 |   unsigned rhs0;		/* as literal [0..2*maxvar+1] */
116 |   unsigned rhs1;		/* as literal [0..2*maxvar+1] */
117 | };
118 | 
119 | /*------------------------------------------------------------------------*/
120 | 
121 | struct aiger_symbol
122 | {
123 |   unsigned lit;			/* as literal [0..2*maxvar+1] */
124 |   unsigned next, reset;		/* used only for latches */
125 |   unsigned size, * lits;	/* used only for justice */
126 |   char *name;
127 | };
128 | 
129 | /*------------------------------------------------------------------------*/
130 | /* This is the externally visible state of the library.  The format is
131 |  * almost the same as the ASCII file format.  The first part is exactly as
132 |  * in the header 'M I L O A' and optional 'B C J F' after the format identifier
133 |  * string.
134 |  */
135 | struct aiger
136 | {
137 |   /* variable not literal index, e.g. maxlit = 2*maxvar + 1
138 |    */
139 |   unsigned maxvar;
140 | 
141 |   unsigned num_inputs;
142 |   unsigned num_latches;
143 |   unsigned num_outputs;
144 |   unsigned num_ands;
145 |   unsigned num_bad;
146 |   unsigned num_constraints;
147 |   unsigned num_justice;
148 |   unsigned num_fairness;
149 | 
150 |   aiger_symbol *inputs;		/* [0..num_inputs[ */
151 |   aiger_symbol *latches;	/* [0..num_latches[ */
152 |   aiger_symbol *outputs;	/* [0..num_outputs[ */
153 |   aiger_symbol *bad;		/* [0..num_bad[ */
154 |   aiger_symbol *constraints;	/* [0..num_constraints[ */
155 |   aiger_symbol *justice;	/* [0..num_justice[ */
156 |   aiger_symbol *fairness;	/* [0..num_fairness[ */
157 | 
158 |   aiger_and *ands;		/* [0..num_ands[ */
159 | 
160 |   char **comments;		/* zero terminated */
161 | };
162 | 
163 | /*------------------------------------------------------------------------*/
164 | /* Version and CVS identifier.
165 |  */
166 | const char *aiger_id (void);  	     /* not working after moving to 'git' */
167 | const char *aiger_version (void);
168 | 
169 | /*------------------------------------------------------------------------*/
170 | /* You need to initialize the library first.  This generic initialization
171 |  * function uses standard 'malloc' and 'free' from the standard library for
172 |  * memory management.
173 |  */
174 | aiger *aiger_init (void);
175 | 
176 | /*------------------------------------------------------------------------*/
177 | /* Same as previous initialization function except that a memory manager
178 |  * from the client is used for memory allocation.  See the 'aiger_malloc'
179 |  * and 'aiger_free' definitions above.
180 |  */
181 | aiger *aiger_init_mem (void *mem_mgr, aiger_malloc, aiger_free);
182 | 
183 | /*------------------------------------------------------------------------*/
184 | /* Reset and delete the library.
185 |  */
186 | void aiger_reset (aiger *);
187 | 
188 | /*------------------------------------------------------------------------*/
189 | /* Treat the literal 'lit' as input, output, latch, bad, constraint,
190 |  * justice of fairness respectively.  The
191 |  * literal of latches and inputs can not be signed nor a constant (< 2).
192 |  * You can not register latches nor inputs multiple times.  An input can not
193 |  * be a latch.  The last argument is the symbolic name if non zero.
194 |  * The same literal can of course be used for multiple outputs.
195 |  */
196 | void aiger_add_input (aiger *, unsigned lit, const char *);
197 | void aiger_add_latch (aiger *, unsigned lit, unsigned next, const char *);
198 | void aiger_add_output (aiger *, unsigned lit, const char *);
199 | void aiger_add_bad (aiger *, unsigned lit, const char *);
200 | void aiger_add_constraint (aiger *, unsigned lit, const char *);
201 | void aiger_add_justice (aiger *, unsigned size, unsigned *, const char *);
202 | void aiger_add_fairness (aiger *, unsigned lit, const char *);
203 | 
204 | /*------------------------------------------------------------------------*/
205 | /* Add a reset value to the latch 'lit'.  The 'lit' has to be a previously
206 |  * added latch and 'reset' is either '0', '1' or equal to 'lit', the latter
207 |  * means undefined.
208 |  */
209 | void aiger_add_reset (aiger *, unsigned lit, unsigned reset);
210 | 
211 | /*------------------------------------------------------------------------*/
212 | /* Register an unsigned AND with AIGER.  The arguments are signed literals
213 |  * as discussed above, e.g. the least significant bit stores the sign and
214 |  * the remaining bit the variable index.  The 'lhs' has to be unsigned
215 |  * (even).  It identifies the AND and can only be registered once.  After
216 |  * registration an AND can be accessed through 'ands[aiger_lit2idx (lhs)]'.
217 |  */
218 | void aiger_add_and (aiger *, unsigned lhs, unsigned rhs0, unsigned rhs1);
219 | 
220 | /*------------------------------------------------------------------------*/
221 | /* Add a line of comments.  The comment may not contain a new line character.
222 |  */
223 | void aiger_add_comment (aiger *, const char *comment_line);
224 | 
225 | /*------------------------------------------------------------------------*/
226 | /* This checks the consistency for debugging and testing purposes.  In
227 |  * particular, it is checked that all 'next' literals of latches, all
228 |  * outputs, and all right hand sides of ANDs are defined, where defined
229 |  * means that the corresponding literal is a constant 0 or 1, or defined as
230 |  * an input, a latch, or AND gate.  Furthermore the definitions of ANDs are
231 |  * checked to be non cyclic.  If a check fails a corresponding error message
232 |  * is returned.
233 |  */
234 | const char *aiger_check (aiger *);
235 | 
236 | /*------------------------------------------------------------------------*/
237 | /* These are the writer functions for AIGER.  They return zero on failure.
238 |  * The assumptions on 'aiger_put' are the same as with 'fputc' from the
239 |  * standard library (see the 'aiger_put' definition above).  Note, that
240 |  * writing in binary mode triggers 'aig_reencode' and thus destroys the
241 |  * original literal association and may even delete AND nodes.  See
242 |  * 'aiger_reencode' for more details.
243 |  */
244 | int aiger_write_to_file (aiger *, aiger_mode, FILE *);
245 | int aiger_write_to_string (aiger *, aiger_mode, char *str, size_t len);
246 | int aiger_write_generic (aiger *, aiger_mode, void *state, aiger_put);
247 | 
248 | /*------------------------------------------------------------------------*/
249 | /* The following function allows to write to a file.  The write mode is
250 |  * determined from the suffix in the file name.  The mode used is ASCII for
251 |  * a '.aag' suffix and binary mode otherwise.  In addition a '.gz' suffix can
252 |  * be added which requests the file to written by piping it through 'gzip'.
253 |  * This feature assumes that the 'gzip' program is in your path and can be
254 |  * executed through 'popen'.  The return value is non zero on success.
255 |  */
256 | int aiger_open_and_write_to_file (aiger *, const char *file_name);
257 | 
258 | /*------------------------------------------------------------------------*/
259 | /* The binary format reencodes all indices.  After normalization the input
260 |  * indices come first followed by the latch and then the AND indices.  In
261 |  * addition the indices will be topologically sorted to respect the
262 |  * child/parent relation, e.g. child indices will always be smaller than
263 |  * their parent indices.   This function can directly be called by the
264 |  * client.  As a side effect, ANDs that are not in any cone of a next state
265 |  * function nor in any cone of an output function are discarded.  The new
266 |  * indices of ANDs start immediately after all input and latch indices.  The
267 |  * data structures are updated accordingly including 'maxvar'.  The client
268 |  * data within ANDs is reset to zero.
269 |  */
270 | int aiger_is_reencoded (aiger *);
271 | void aiger_reencode (aiger *);
272 | 
273 | /*------------------------------------------------------------------------*/
274 | /* This function computes the cone of influence (coi). The coi contains
275 |  * those literals that may have an influence to one of the outputs.   A
276 |  * variable 'v' is in the coi if the array returned as result is non zero at
277 |  * position 'v'. All other variables can be considered redundant.  The array
278 |  * returned is valid until the next call to this function and will be
279 |  * deallocated on reset.
280 |  *
281 |  * TODO: this is just a stub and actually not really implemented yet.
282 |  */
283 | const unsigned char * aiger_coi (aiger *);		/* [1..maxvar] */
284 | 
285 | /*------------------------------------------------------------------------*/
286 | /* Read an AIG from a FILE, a string, or through a generic interface.  These
287 |  * functions return a non zero error message if an error occurred and
288 |  * otherwise 0.  The paramater 'aiger_get' has the same return values as
289 |  * 'getc', e.g. it returns 'EOF' when done.  After an error occurred the
290 |  * library becomes invalid.  Only 'aiger_reset' or 'aiger_error' can be
291 |  * used.  The latter returns the previously returned error message.
292 |  */
293 | const char *aiger_read_from_file (aiger *, FILE *);
294 | const char *aiger_read_from_string (aiger *, const char *str);
295 | const char *aiger_read_generic (aiger *, void *state, aiger_get);
296 | 
297 | /*------------------------------------------------------------------------*/
298 | /* Returns a previously generated error message if the library is in an
299 |  * invalid state.  After this function returns a non zero error message,
300 |  * only 'aiger_reset' can be called (beside 'aiger_error').  The library can
301 |  * reach an invalid through a failed read attempt, or if 'aiger_check'
302 |  * failed.
303 |  */
304 | const char *aiger_error (aiger *);
305 | 
306 | /*------------------------------------------------------------------------*/
307 | /* Same semantics as with 'aiger_open_and_write_to_file' for reading.
308 |  */
309 | const char *aiger_open_and_read_from_file (aiger *, const char *);
310 | 
311 | /*------------------------------------------------------------------------*/
312 | /* Write symbol table or the comments to a file.  Result is zero on failure.
313 |  */
314 | int aiger_write_symbols_to_file (aiger *, FILE * file);
315 | int aiger_write_comments_to_file (aiger *, FILE * file);
316 | 
317 | /*------------------------------------------------------------------------*/
318 | /* Remove symbols and comments.  The result is the number of symbols
319 |  * and comments removed.
320 |  */
321 | unsigned aiger_strip_symbols_and_comments (aiger *);
322 | 
323 | /*------------------------------------------------------------------------*/
324 | /* If 'lit' is an input or a latch with a name, the symbolic name is
325 |  * returned.   Note, that literals can be used for multiple outputs.
326 |  * Therefore there is no way to associate a name with a literal itself.
327 |  * Names for outputs are stored in the 'outputs' symbols and can only be
328 |  * accesed through a linear traversal of the output symbols.
329 |  */
330 | const char *aiger_get_symbol (aiger *, unsigned lit);
331 | 
332 | /*------------------------------------------------------------------------*/
333 | /* Return tag of the literal:
334 |  *
335 |  * 0 = constant
336 |  * 1 = input
337 |  * 2 = latch
338 |  * 3 = and
339 |  */
340 | 
341 | int aiger_lit2tag (aiger *, unsigned lit);
342 | 
343 | /*------------------------------------------------------------------------*/
344 | /* Check whether the given unsigned, e.g. even, literal was defined as
345 |  * 'input', 'latch' or 'and'.  The command returns a zero pointer if the
346 |  * literal was not defined as 'input', 'latch', or 'and' respectively.
347 |  * Otherwise a pointer to the corresponding input or latch symbol is returned.
348 |  * In the case of an 'and' the AND node is returned.  The returned symbol
349 |  * if non zero is in the respective array of 'inputs', 'latches' and 'ands'.
350 |  * It thus also allows to extract the position of an input or latch literal.
351 |  * For outputs this is not possible, since the same literal may be used for
352 |  * several outputs.
353 |  */
354 | aiger_symbol *aiger_is_input (aiger *, unsigned lit);
355 | aiger_symbol *aiger_is_latch (aiger *, unsigned lit);
356 | aiger_and *aiger_is_and (aiger *, unsigned lit);
357 | 
358 | #endif
359 | 
360 | 
361 | 


--------------------------------------------------------------------------------
/src/gate.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file gate.cpp
  3 |     \brief contains the class Gate and further functions to
  4 |     organize the gate structure, such as initializing the gate constraints
  5 | 
  6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  8 | */
  9 | /*------------------------------------------------------------------------*/
 10 | #include <string>
 11 | #include <list>
 12 | 
 13 | #include "gate.h"
 14 | /*------------------------------------------------------------------------*/
 15 | // Global variables
 16 | bool xor_chain = 0;
 17 | bool booth = 0;
 18 | bool signed_mult = 0;
 19 | /*------------------------------------------------------------------------*/
 20 | // ERROR CODES:
 21 | static int err_allocate       = 91; // failed to allocate gates
 22 | /*------------------------------------------------------------------------*/
 23 | 
 24 | Gate::Gate(int n_, std::string name_, int level_, bool input_, bool output_):
 25 |   v(new Var(name_, level_, n_)), input(input_), output(output_)  {
 26 | }
 27 | 
 28 | /*------------------------------------------------------------------------*/
 29 | bool Gate::orig() const {
 30 |   return ancestors.empty();
 31 | }
 32 | 
 33 | /*------------------------------------------------------------------------*/
 34 | 
 35 | Gate::~Gate() {
 36 |   if(v) delete(v);
 37 |   delete(co_factor);
 38 |   if (gate_constraint) delete(gate_constraint);
 39 |   for (std::map<Gate*, Polynomial*>::const_iterator it=ancestors.begin();
 40 |       it != ancestors.end(); ++it) {
 41 |     delete(it->second);
 42 |   }
 43 | }
 44 | 
 45 | /*------------------------------------------------------------------------*/
 46 | bool Gate::all_parents_are_sliced() const {
 47 |   for (auto it=parents_begin(); it != parents_end(); ++it) {
 48 |     Gate * parents = *it;
 49 |     if (parents->get_slice() == -1) return 0;
 50 |   }
 51 |   return 1;
 52 | }
 53 | 
 54 | /*------------------------------------------------------------------------*/
 55 | 
 56 | bool Gate::is_in_parents(const Gate * n) const {
 57 |   for (auto it=parents_begin(); it != parents_end(); ++it) {
 58 |     Gate * parents = *it;
 59 |     if (parents == n) return 1;
 60 |   }
 61 |   return 0;
 62 | }
 63 | 
 64 | /*------------------------------------------------------------------------*/
 65 | 
 66 | bool Gate::is_child(const Gate * n) const {
 67 |   for (std::list<Gate*>::const_iterator it = children_begin();
 68 |       it != children_end(); ++it) {
 69 |     Gate * child = *it;
 70 |     if (child == n) return 1;
 71 |   }
 72 |   return 0;
 73 | }
 74 | 
 75 | /*------------------------------------------------------------------------*/
 76 | Polynomial * Gate::get_gate_constraint() const {
 77 |   if (!gate_constraint && !elim) {
 78 |     // output aig are 0, -1, ...-NN+2
 79 |     if (output) init_gate_constraint(-1*get_var_num()+M-1);
 80 |     // gates are numbered 2,4,6,8,..
 81 |     else
 82 |       init_gate_constraint(get_var_num()/2-1);
 83 |   }
 84 |   return gate_constraint;
 85 | }
 86 | 
 87 | Gate ** gates;
 88 | unsigned num_gates;
 89 | // dedicated constant-0 gate
 90 | Gate * const0_gate = 0;
 91 | 
 92 | /*------------------------------------------------------------------------*/
 93 | 
 94 | Gate * gate(unsigned lit) {
 95 |   assert(lit < 2*M);
 96 |   if (lit <2) return const0_gate;
 97 | 
 98 |   return gates[lit/2-1];
 99 | }
100 | 
101 | /*------------------------------------------------------------------------*/
102 | 
103 | void allocate_gates(bool assert) {
104 |   unsigned aiger;
105 |   num_gates = M + NN - 1;
106 | 
107 |   msg("allocating %i gates", num_gates);
108 |   gates = new Gate*[num_gates];
109 | 
110 |   if (!gates) die(err_allocate, "failed to allocate gates");
111 | 
112 |   // create dedicated constant-0 gate
113 |   const0_gate = new Gate(0, std::string("0"), 0, 1);
114 |   if (!const0_gate) die(err_allocate, "failed to allocate constant-0 gate");
115 |   if (verbose >= 4) msg("allocated constant-0 gate %s", const0_gate->get_var_name());
116 |   int level = 0;
117 | 
118 |   // inputs a
119 |   for (unsigned i = a0; i <= al; i+=ainc) {
120 |     aiger = 2*(i+1);
121 |     if (assert) assert(is_model_input(aiger));
122 | 
123 |     std::string name = "a" + std::to_string((i-a0)/ainc);
124 |     gates[i] = new Gate(aiger, name, ++level, 1);
125 |   }
126 | 
127 |   // inputs b
128 |   for (unsigned i = b0; i <= bl; i+=binc) {
129 |     aiger = 2*(i+1);
130 |     if (assert) assert(is_model_input(aiger));
131 | 
132 |     std::string name = "b" + std::to_string((i-b0)/binc);
133 |     gates[i] = new Gate(aiger, name, ++level, 1);
134 |   }
135 | 
136 |   // internal gates
137 |   for (unsigned i = NN; i < M-1; i++) {
138 |     aiger = 2*(i+1);
139 |     if (assert) assert(is_model_and(aiger));
140 | 
141 |     std::string name = "l" + std::to_string(aiger);
142 |     gates[i] = new Gate(aiger, name, ++level);
143 |   }
144 | 
145 |   // output s
146 |   for (unsigned i = M-1; i < num_gates; i++) {
147 |     aiger = i-M+1;
148 | 
149 |     std::string name = "s" + std::to_string(aiger);
150 |     gates[i] = new Gate(M-i-1, name, ++level, 0, 1);
151 |     gates[i]->set_slice(aiger);
152 |   }
153 | }
154 | 
155 | /*------------------------------------------------------------------------*/
156 | 
157 | void mark_aig_outputs() {
158 |   for (unsigned i = 0; i < NN; i++) {
159 |     unsigned lit = slit(i);
160 |     if(lit < 2) continue;
161 |     Gate * n = gate(lit);
162 |     n->mark_aig_output();
163 |   }
164 | }
165 | 
166 | /*------------------------------------------------------------------------*/
167 | 
168 | Gate * derive_ha_and_gate(const Gate *n) {
169 |   Gate * ll = xor_left_child(n);
170 |   Gate * rr = xor_right_child(n);
171 |   for (std::list<Gate*>::const_iterator it_l=ll->parents_begin();
172 |        it_l != ll->parents_end(); ++it_l) {
173 |     Gate * ll_parent = *it_l;
174 |     if (ll_parent -> get_xor_gate()) continue;
175 | 
176 |     aiger_and * and1 = is_model_and(ll_parent->get_var_num());
177 |     Gate * c1 = gate(and1->rhs0);
178 |     Gate * c2 = gate(and1->rhs1);
179 | 
180 |     if (c1 == ll && c2 == rr) return ll_parent;
181 |     if (c1 == rr && c2 == ll) return ll_parent;
182 |   }
183 |   return 0;
184 | }
185 | 
186 | /*------------------------------------------------------------------------*/
187 | 
188 | void set_xor() {
189 |   int found_xor = 0;
190 |   for (unsigned i = 0; i < M; i++) {
191 |     Gate * n = gates[i];
192 |     if (n->get_input() > 0) continue;
193 |     if (n->get_xor_gate() > 0) continue;
194 | 
195 |     aiger_and * and1 = is_model_and(n->get_var_num());
196 |     if (!and1) continue;
197 |     unsigned l = and1->rhs0, r = and1->rhs1;
198 |     if (!aiger_sign(l)) continue;
199 |     if (!aiger_sign(r)) continue;
200 |     if (l == r || l == aiger_not(r)) continue;
201 |     l = aiger_strip(l);
202 |     r = aiger_strip(r);
203 |     aiger_and * land = is_model_and(l);
204 |     if (!land) continue;
205 |     aiger_and * rand = is_model_and(r);
206 |     if (!rand) continue;
207 | 
208 |     unsigned ll = land->rhs0, lr = land->rhs1;
209 |     unsigned rl = rand->rhs0, rr = rand->rhs1;
210 |     if ((ll == aiger_not(rl) && lr == aiger_not(rr)) ||
211 |        (ll == aiger_not(rr) && lr == aiger_not(rl))) {
212 |       gate(l)->set_xor_gate(2);
213 |       gate(r)->set_xor_gate(2);
214 |       n->set_xor_gate(1);
215 |       found_xor++;
216 |       if (verbose >= 4) msg("xor-gate %s", n->get_var_name());
217 |     }
218 |   }
219 |   if (verbose >= 1) msg("found %i xor-gates", found_xor);
220 | }
221 | 
222 | /*------------------------------------------------------------------------*/
223 | 
224 | bool upper_half_xor_output() {
225 |   for (unsigned i = num_gates-2; i > M-1; i--) {
226 |     Gate * n = gates[i];
227 |     if(!n->children_size()) return 0;
228 |     n = n->children_front();
229 |     if (!n->get_xor_gate()) return 0;
230 |   }
231 | 
232 |   if(!gates[M-1]->children_size()) return 0;
233 | 
234 |   return 1;
235 | }
236 | 
237 | /*------------------------------------------------------------------------*/
238 | 
239 | Gate * xor_left_child(const Gate * n) {
240 |   if (!n->get_xor_gate() ) return 0;
241 | 
242 |   aiger_and * and1 = is_model_and(n->get_var_num());
243 |   if (!and1) return 0;
244 |   unsigned l = and1->rhs0;
245 |   if (!aiger_sign(l)) return 0;
246 |   l = aiger_strip(l);
247 | 
248 |   aiger_and * land = is_model_and(l);
249 |   if (!land) return 0;
250 | 
251 |   unsigned ll = land->rhs0;
252 |   return gate(ll);
253 | }
254 | 
255 | /*------------------------------------------------------------------------*/
256 | 
257 | Gate * xor_right_child(const Gate * n) {
258 |   if (!n->get_xor_gate() ) return 0;
259 | 
260 |   aiger_and * and1 = is_model_and(n->get_var_num());
261 |   if (!and1) return 0;
262 |   unsigned l = and1->rhs0;
263 |   if (!aiger_sign(l)) return 0;
264 |   l = aiger_strip(l);
265 | 
266 |   aiger_and * land = is_model_and(l);
267 |   if (!land) return 0;
268 | 
269 |   unsigned lr = land->rhs1;
270 |   return gate(lr);
271 | }
272 | 
273 | /*------------------------------------------------------------------------*/
274 | 
275 | void mark_xor_chain_in_last_slice() {
276 |   msg("marking xor chain gates");
277 |   int counter = 0;
278 | 
279 |   Gate * out = gates[num_gates-1];
280 |   if(out->children_size() == 0) return;
281 |   assert(out->children_size() == 1);
282 |   Gate * child = out->children_front();
283 |   if(child->get_input()) return;
284 | 
285 |   std::queue<Gate*> downwards_queue;
286 |   if (child->get_xor_gate() == 1) downwards_queue.push(child);
287 | 
288 |   while (!downwards_queue.empty()) {
289 |     Gate * n = downwards_queue.front();
290 |     downwards_queue.pop();
291 | 
292 |     aiger_and * and1 = is_model_and(n->get_var_num());
293 |     unsigned l = and1->rhs0;
294 |     aiger_and * land = is_model_and(l);
295 |     unsigned ll = land->rhs0, lr = land->rhs1;
296 |     Gate * ll_gate = gate(ll);
297 |     Gate * lr_gate = gate(lr);
298 | 
299 |     if (ll_gate && ll_gate->get_xor_gate()) downwards_queue.push(ll_gate);
300 |     if (lr_gate && lr_gate->get_xor_gate()) downwards_queue.push(lr_gate);
301 | 
302 |     n->mark_xor_chain();
303 |     if (verbose >= 4) msg("xor-chain %s", n->get_var_name());
304 |     counter++;
305 |   }
306 |   if (verbose >= 1) msg("marked %i xor gates in last slice", counter);
307 |   if (counter) xor_chain = 1;
308 | }
309 | 
310 | /*------------------------------------------------------------------------*/
311 | 
312 | void set_parents_and_children(bool set_children) {
313 |   unsigned pp = 0;
314 | 
315 |   for (unsigned i = NN; i < M; i++) {
316 |     Gate * n = gates[i];
317 |     assert(!n->get_input());
318 | 
319 |     aiger_and * and1 = is_model_and(n->get_var_num());
320 | 
321 |     if (!and1) continue;
322 |     unsigned l = and1->rhs0, r = and1->rhs1;
323 |     Gate * l_gate = gate(l), *r_gate = gate(r);
324 | 
325 |     if (set_children) {
326 |       n->children_push_back(l_gate);
327 |       n->children_push_back(r_gate);
328 |     }
329 | 
330 |     if(l_gate && r_gate) {
331 |       n->set_level(l_gate->get_level() > r_gate->get_level() ?
332 |                  l_gate->get_level()+1 : r_gate->get_level()+1);
333 | 
334 |       if (l_gate->get_input() && r_gate->get_input()
335 |             && !aiger_sign(l) && !aiger_sign(r)) {
336 |         n->mark_pp();
337 |         pp++;
338 |         if (verbose >= 4) msg("partial product %s", n->get_var_name());
339 |       }
340 | 
341 |     } else if (l_gate) {
342 |       n->set_level(l_gate->get_level()+1);
343 |     } else if (r_gate){
344 |       n->set_level(r_gate->get_level()+1);
345 |     }
346 | 
347 |     if(l_gate) l_gate->parents_push_back(n);
348 |     if(r_gate) r_gate->parents_push_back(n);
349 | 
350 | 
351 |   }
352 | 
353 |   // set children for extra outputs
354 |   for (unsigned i = 0; i < NN; i++) {
355 |     Gate * n = gates[i+M-1];
356 |     assert(n->get_output());
357 |     unsigned lit = slit(i);
358 |     if(lit < 2) continue;
359 |     Gate * model_output_gate = gate(lit);
360 |     if (set_children) n->children_push_back(model_output_gate);
361 |     model_output_gate->parents_push_back(n);
362 |   }
363 | 
364 |   if (verbose >= 1) msg("found %i partial products", pp);
365 |   if (pp == NN*NN/4) {
366 |     msg("assuming simple pp generator");
367 |   } else {
368 |     booth = 1;
369 |     msg("assuming booth recoding");
370 |   }
371 | }
372 | 
373 | /*------------------------------------------------------------------------*/
374 | 
375 | bool parents_are_in_equal_or_larger_slice(const Gate * n, int i) {
376 |   for (std::list<Gate*>::const_iterator it_n = n->parents_begin();
377 |        it_n != n->parents_end(); ++it_n) {
378 |     Gate * n_parent = *it_n;
379 |     if (n_parent->get_slice() != -1 && n_parent->get_slice() < i) return 0;
380 |   }
381 |   return 1;
382 | }
383 | 
384 | /*------------------------------------------------------------------------*/
385 | 
386 | Polynomial * negative_poly(const Var * v) {
387 | 
388 |   Term * t1 = new_term(v, 0);
389 |   Monomial * m1 = new Monomial(minus_one, t1);
390 |   push_mstack_end(m1);
391 | 
392 |   Monomial * m2 = new Monomial(one, 0);
393 |   push_mstack_end(m2);
394 | 
395 |   return build_poly();
396 | }
397 | 
398 | /*------------------------------------------------------------------------*/
399 | 
400 | Polynomial * positive_poly(const Var * v) {
401 |   Term * t = new_term(v, 0);
402 |   Monomial * m = new Monomial(one, t);
403 |   push_mstack_end(m);
404 | 
405 |   return build_poly();
406 | }
407 | 
408 | /*------------------------------------------------------------------------*/
409 | static Polynomial * get_node_constraint(Gate * g, unsigned sign){
410 |   // If g is the dedicated constant-0 gate, treat like missing gate
411 |   if (g && g != const0_gate) {
412 |     const Var * v1 = g->get_var();
413 |     if (sign) return negative_poly(v1);
414 |     else return positive_poly(v1);
415 |   } else {
416 |     // g is NULL or constant-0: return constant 1 for negated literal, 0 otherwise
417 |     if(sign) {
418 |       push_mstack_end(new Monomial(one, 0));
419 |       return build_poly();
420 |     } else return 0;
421 |   }
422 | }
423 | 
424 | /*------------------------------------------------------------------------*/
425 | 
426 | Polynomial * gen_gate_constraint(unsigned i) {
427 |   assert(i >= NN && i < M + NN - 1);
428 |   Polynomial * p = 0;
429 |   // gate constraint
430 |   if (i < M-1) {
431 |     Gate * n = gates[i];
432 |     assert(!n->get_input());
433 | 
434 |     aiger_and * and1 = is_model_and(n->get_var_num());
435 |     assert(and1);
436 | 
437 |     unsigned l = and1->rhs0, r = and1->rhs1;
438 | 
439 |     Gate * l_gate = gate(l), *r_gate = gate(r);
440 |     const Var * v = n->get_var();
441 |     Term * t1 = new_term(v, 0);
442 |     Monomial * m1 = new Monomial(minus_one, t1);
443 |     push_mstack_end(m1);
444 |     Polynomial * p_h = build_poly();
445 | 
446 |     Polynomial * p1 = get_node_constraint(l_gate, aiger_sign(and1->rhs0));
447 |     Polynomial * p2 = get_node_constraint(r_gate, aiger_sign(and1->rhs1));
448 |     Polynomial * p_tl = multiply_poly(p1, p2);
449 | 
450 |     p = add_poly(p_h, p_tl);
451 |     delete(p_h);
452 |     delete(p_tl);
453 | 
454 |     delete(p1);
455 |     delete(p2);
456 |   } else {  // output
457 |     Gate * n = gates[i];
458 |     assert(n->get_output());
459 | 
460 |     Gate * model_output_gate = n->children_front();
461 |     if (!model_output_gate) {
462 |       unsigned lit = slit(i-M+1);
463 |       const Var * v = n->get_var();
464 |       Term * t1 = new_term(v, 0);
465 |       Monomial * m1 = new Monomial(minus_one, t1);
466 |       push_mstack_end(m1);
467 |       if(lit == 1){
468 |         push_mstack_end(new Monomial(one, 0));
469 |       }
470 |       p = build_poly();
471 | 
472 |     } else {
473 |       const Var * v = n->get_var();
474 |       Term * t1 = new_term(v, 0);
475 |       Monomial * m1 = new Monomial(minus_one, t1);
476 | 
477 |       Polynomial * p_tl;
478 |       if (aiger_sign(slit(i-M+1)))
479 |         p_tl = negative_poly(model_output_gate->get_var());
480 |       else
481 |         p_tl = positive_poly(model_output_gate->get_var());
482 | 
483 |       push_mstack_end(m1);
484 |       Polynomial * p_h = build_poly();
485 | 
486 |       p = add_poly(p_h, p_tl);
487 |       delete(p_h);
488 |       delete(p_tl);
489 |     }
490 | 
491 |   }
492 |   p->set_idx(2+i-NN);
493 |   return p;
494 | }
495 | 
496 | 
497 | void init_gate_constraint(unsigned i) {
498 |   assert(i >= NN && i < M + NN - 1);
499 |   Polynomial * p = gen_gate_constraint(i);
500 |   Gate * n = gates[i];
501 |   n->set_gate_constraint(p);
502 | }
503 | 
504 | 
505 | void init_gate_constraints() {
506 |   for (unsigned i = NN; i < M-1; i++) {
507 |     init_gate_constraint(i);
508 |   }
509 | 
510 |   for (unsigned i = 0; i < NN; i++) {
511 |     init_gate_constraint(i+M-1);
512 |   }
513 | }
514 | 
515 | /*------------------------------------------------------------------------*/
516 | 
517 | void delete_gates() {
518 |   if (const0_gate) { if (verbose >= 4) msg("deleting constant-0 gate %s", const0_gate->get_var_name()); delete(const0_gate); const0_gate = 0; }
519 |   for (unsigned i = 0; i < num_gates; i++) {
520 |     delete(gates[i]);
521 |   }
522 |   delete[] gates;
523 | }
524 | 


--------------------------------------------------------------------------------
/src/gate.h:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file gate.h
  3 |     \brief contains the class Gate and further functions to
  4 |     organize the gate structure, such as initializing the gate constraints
  5 | 
  6 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  7 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  8 | */
  9 | /*------------------------------------------------------------------------*/
 10 | #ifndef AMULET2_SRC_GATE_H_
 11 | #define AMULET2_SRC_GATE_H_
 12 | /*------------------------------------------------------------------------*/
 13 | #include <list>
 14 | #include <map>
 15 | #include <queue>
 16 | #include <string>
 17 | 
 18 | #include "aig.h"
 19 | #include "polynomial.h"
 20 | /*------------------------------------------------------------------------*/
 21 | // / set to true when the last slice contains an xor_chain
 22 | extern bool xor_chain;
 23 | 
 24 | // / set to true when the multiplier contains a booth pattern
 25 | extern bool booth;
 26 | 
 27 | // / set to true when a signed or unsigned multiplier is verified
 28 | extern bool signed_mult;
 29 | /*------------------------------------------------------------------------*/
 30 | 
 31 | /** \class Gate
 32 |   Internal structure to represent the AIG graph.
 33 | */
 34 | class Gate {
 35 |   // / Variable of the gate, as used in the polynomials
 36 |   const Var * v;
 37 | 
 38 |   // / True if gate is an input
 39 |   bool input;
 40 | 
 41 |   // / True if the gate is an output s_i
 42 |   bool output;
 43 | 
 44 |   // / True if the gate is an output in the aig
 45 |   bool aig_output = 0;
 46 | 
 47 |   // / True if gate is identified as a partial product
 48 |   bool partial_product = 0;
 49 | 
 50 |   // / Distance to inputs
 51 |   int level = 0;
 52 | 
 53 |   // / True if gate belongs to xor_chain in last slice
 54 |   bool xor_chain = 0;
 55 | 
 56 |   // / is set to 1 for root node, 2 for internal nodes of XORs
 57 |   int  xor_gate = 0;
 58 | 
 59 |   // / Counts how often gate is used in bigger slice
 60 |   int carry_gate = 0;
 61 | 
 62 |   // / slice a gate is attached to
 63 |   int slice = -1;
 64 | 
 65 |   // / True if circuit is a prop_gen_gate(-substitute)
 66 |   bool prop_gen_gate = 0;
 67 | 
 68 |   // / True if gate is identified to belong to complex fsa(-substitute)
 69 |   bool fsa = 0;
 70 | 
 71 |   // / True if gate is input of complex fsa(-substitute)
 72 |   int fsa_inp = 0;
 73 | 
 74 |   // / True if gate occurs negative(-substitute)
 75 |   bool neg = 0;
 76 | 
 77 |   // / True if gate has been moved during fix_xors
 78 |   bool moved = 0;
 79 | 
 80 |   // / True if gate is identified to belong to booth pattern
 81 |   bool bo = 0;
 82 | 
 83 |   // / True if gate is eliminated during preprocessing
 84 |   bool elim = 0;
 85 | 
 86 |   // / Polynomial implied by the aig gate
 87 |   Polynomial * gate_constraint = 0;
 88 | 
 89 |   // / Polynomial generated as co-factor for nss proofs(-certify)
 90 |   Polynomial * co_factor = 0;
 91 | 
 92 |   // / Used to store all dependencies in nss proofs (-certify)
 93 |   std::map<Gate*, Polynomial*> ancestors;
 94 | 
 95 |   // / list of gates that are parents
 96 |   std::list<Gate*> parents;
 97 | 
 98 |   // / list of gates that are children
 99 |   std::list<Gate*> children;
100 | 
101 |  public:
102 |   /**
103 |       Constructor
104 |       Calls constructor of Var
105 | 
106 |       @param n_ value, corresponding to aiger value
107 |       @param name_ string name of the variable
108 |       @param level position in order of the variable
109 |   */
110 |   Gate(
111 |     int n_, std::string name_, int level_, bool input_ = 0, bool output_ = 0);
112 | 
113 |   /**
114 |       Getter for v
115 | 
116 |       @return member v
117 |   */
118 |   const Var * get_var() const {return v;}
119 | 
120 |   /**
121 |       Getter for number of v
122 | 
123 |       @return integer
124 |   */
125 |   int get_var_num() const {return v->get_num();}
126 | 
127 |   /**
128 |       Getter for name of v
129 | 
130 |       @return char*
131 |   */
132 |   const char * get_var_name()const {return v->get_name();}
133 | 
134 |   /**
135 |       Getter for input
136 | 
137 |       @return member input
138 |   */
139 |   bool get_input()  const {return input;}
140 | 
141 |   /**
142 |       Getter for output
143 | 
144 |       @return member output
145 |   */
146 |   bool get_output() const {return output;}
147 | 
148 |   /**
149 |       Getter for partial_product
150 | 
151 |       @return member partial_product
152 |   */
153 |   bool get_pp() const {return partial_product;}
154 | 
155 |   /**
156 |       Sets partial_product to true
157 |   */
158 |   void mark_pp() {partial_product = 1;}
159 | 
160 |   /**
161 |       Getter for  aig_output
162 | 
163 |       @return member  aig_output
164 |   */
165 |   bool get_aig_output() const {return aig_output;}
166 | 
167 |   /**
168 |       Sets aig_output to true
169 |   */
170 |   void mark_aig_output() {aig_output = 1;}
171 | 
172 |   /**
173 |       Getter for level
174 | 
175 |       @return member level
176 |   */
177 |   int get_level() const {return level;}
178 | 
179 |   /**
180 |       Setter for level
181 | 
182 |       @param l integer
183 |   */
184 |   void set_level(int l) {level = l;}
185 | 
186 |   /**
187 |       Getter for xor_chain
188 | 
189 |       @return member xor_chain
190 |   */
191 |   bool get_xor_chain() const {return xor_chain;}
192 | 
193 |   /**
194 |       Sets xor_chain to true
195 |   */
196 |   void mark_xor_chain() {xor_chain = 1;}
197 | 
198 |   /**
199 |       Getter for xor_gate
200 | 
201 |       @return member xor_gate
202 |   */
203 |   int get_xor_gate() const {return xor_gate;}
204 | 
205 |   /**
206 |       Setter for xor_gate
207 | 
208 |       @param val integer
209 |   */
210 |   void set_xor_gate(int val) {xor_gate = val;}
211 | 
212 |   /**
213 |       Getter for carry_gate
214 | 
215 |       @return member carry_gate
216 |   */
217 |   int get_carry_gate() const {return carry_gate;}
218 | 
219 |   /**
220 |       Setter for carry_gate
221 | 
222 |       @param integer
223 |   */
224 |   void set_carry_gate(int val) {carry_gate = val;}
225 | 
226 |   /**
227 |       Increases carry_gate
228 |   */
229 |   void inc_carry_gate() {carry_gate++;}
230 | 
231 |   /**
232 |       Decreases carry_gate
233 |   */
234 |   void dec_carry_gate() {carry_gate--;}
235 | 
236 |   /**
237 |       Getter for slice
238 | 
239 |       @return member slice
240 |   */
241 |   int get_slice() const {return slice;}
242 | 
243 |   /**
244 |       Setter for slice
245 | 
246 |       @param val integer
247 |   */
248 |   void set_slice(int val) {slice = val;}
249 | 
250 |   /**
251 |       Increases slice
252 |   */
253 |   void inc_slice() {slice++;}
254 | 
255 |   /**
256 |       Decreases slice
257 |   */
258 |   void dec_slice() {slice--;}
259 | 
260 |   /**
261 |       Getter for prop_gen_gate
262 | 
263 |       @return member prop_gen_gate
264 |   */
265 |   bool get_prop_gen_gate() const {return prop_gen_gate;}
266 | 
267 |   /**
268 |       Sets prop_gen_gate to true
269 |   */
270 |   void mark_prop_gen_gate() {prop_gen_gate = 1;}
271 | 
272 |   /**
273 |       Sets prop_gen_gate to false
274 |   */
275 |   void unmark_prop_gen_gate() {prop_gen_gate = 0;}
276 | 
277 |   /**
278 |       Getter for fsa
279 | 
280 |       @return member fsa
281 |   */
282 |   bool get_fsa() const {return fsa;}
283 | 
284 |   /**
285 |       Sets fsa to true
286 |   */
287 |   void mark_fsa() {fsa = 1;}
288 | 
289 |   /**
290 |       Getter for fsa_inp
291 | 
292 |       @return member fsa_inp
293 |   */
294 |   int get_fsa_inp() const {return fsa_inp;}
295 | 
296 |   /**
297 |       Increases fsa_inp
298 |   */
299 |   void inc_fsa_inp() {fsa_inp++;}
300 | 
301 |   /**
302 |       Sets fsa_inp to 0
303 |   */
304 |   void reset_fsa_inp() {fsa_inp = 0;}
305 | 
306 |   /**
307 |       Getter for neg
308 | 
309 |       @return member neg
310 |   */
311 |   bool get_neg() const {return neg;}
312 | 
313 |   /**
314 |       Setter for neg
315 | 
316 |       @param val Boolean
317 |   */
318 |   void set_neg(bool val) {neg = val;}
319 | 
320 |   /**
321 |       Getter for moved
322 | 
323 |       @return member moved
324 |   */
325 |   bool get_moved() const {return moved;}
326 | 
327 |   /**
328 |       Sets moved to true
329 |   */
330 |   void mark_moved() {moved = 1;}
331 | 
332 |   /**
333 |       Getter for bo
334 | 
335 |       @return member bo
336 |   */
337 |   bool get_bo() const {return bo;}
338 | 
339 |   /**
340 |       Sets bo to true
341 |   */
342 |   void mark_bo() {bo = 1;}
343 | 
344 |   /**
345 |       Getter for elim
346 | 
347 |       @return member elim
348 |   */
349 |   bool get_elim() const {return elim;}
350 | 
351 |   /**
352 |       Sets elim to true
353 |   */
354 |   void mark_elim() {elim = 1;}
355 | 
356 |   /**
357 |       Getter for gate_constraint
358 | 
359 |       @return member gate_constraint
360 |   */
361 |   Polynomial * get_gate_constraint() const;
362 | 
363 |   /**
364 |       Setter for gate_constraint
365 | 
366 |       @param p Polynomial *
367 |   */
368 |   void set_gate_constraint(Polynomial * p) {gate_constraint = p;}
369 | 
370 |   /**
371 |       Prints the gate constraint
372 | 
373 |       @param file output file
374 |   */
375 |   void print_gate_constraint(FILE * file) const { gate_constraint->print(file);}
376 | 
377 |   /**
378 |       Getter for co_factor
379 | 
380 |       @return member co_factor
381 |   */
382 |   Polynomial * get_cofactor() const {return co_factor;}
383 | 
384 |   /**
385 |       Setter for co_factor
386 | 
387 |       @param p Polynomial*
388 |   */
389 |   void set_cofactor(Polynomial * p) {co_factor = p;}
390 | 
391 |   /**
392 |       Getter for begin of ancestors
393 | 
394 |       @return std::map<Gate*, Polynomial*>::const_iterator
395 |   */
396 |   std::map<Gate*, Polynomial*>::const_iterator anc_begin() const {
397 |     return ancestors.begin();
398 |   }
399 | 
400 |   /**
401 |       Getter for end of ancestors
402 | 
403 |       @return std::map<Gate*, Polynomial*>::const_iterator
404 |   */
405 |   std::map<Gate*, Polynomial*>::const_iterator anc_end()   const {
406 |     return ancestors.end();
407 |   }
408 | 
409 |   /**
410 |       Searches for gate n in ancestors
411 | 
412 |       @param n Gate*
413 |       @return std::map<Gate*, Polynomial*>::iterator
414 |   */
415 |   std::map<Gate*, Polynomial*>::iterator search_in_anc(Gate *n) {
416 |     return ancestors.find(n);
417 |   }
418 | 
419 |   /**
420 |       Adds the tuple(n,p) to the ancestors
421 | 
422 |       @param n Gate*
423 |       @param p Polynomial*
424 |   */
425 |   void set_ancestor(Gate *n, Polynomial * p) {ancestors[n] = p;}
426 | 
427 |   /**
428 |       Getter for begin of parents
429 | 
430 |       @return std::list<Gate*>::const_iterator
431 |   */
432 |   std::list<Gate*>::const_iterator parents_begin() const {
433 |     return parents.begin();
434 |   }
435 | 
436 |   std::list<Gate*>::const_reverse_iterator parents_rbegin() const {
437 |     return parents.rbegin();
438 |   }
439 | 
440 |   /**
441 |       Getter for end of parents
442 | 
443 |       @return std::list<Gate*>::const_iterator
444 |   */
445 |   std::list<Gate*>::const_iterator parents_end()   const {
446 |     return parents.end();
447 |   }
448 | 
449 |   std::list<Gate*>::const_reverse_iterator parents_rend() const {
450 |     return parents.rend();
451 |   }
452 | 
453 |   /**
454 |       Getter for size of parents
455 | 
456 |       @return size_t
457 |   */
458 |   size_t parents_size() const {return parents.size();}
459 | 
460 |   /**
461 |       Returns whether all parents are contained in slcies
462 | 
463 |       @return bool
464 |   */
465 |   bool all_parents_are_sliced() const;
466 | 
467 |   /**
468 |       Getter for front of parents
469 | 
470 |       @return Gate*
471 |   */
472 |   Gate * parents_front() const {return parents.front();}
473 | 
474 |   /**
475 |       Appends gate n to the parents
476 | 
477 |       @param n Gate*
478 |   */
479 |   void parents_push_back(Gate * n) {parents.push_back(n);}
480 | 
481 |   /**
482 |       Removes gate n from the parents
483 | 
484 |       @param n Gate*
485 |   */
486 |   void parents_remove(Gate * n) {parents.remove(n);}
487 | 
488 |   /**
489 |       Getter for begin of children
490 | 
491 |       @return std::list<Gate*>::const_iterator
492 |   */
493 |   std::list<Gate*>::const_iterator children_begin() const {
494 |     return children.begin();
495 |   }
496 | 
497 |   /**
498 |       Getter for end of children
499 | 
500 |       @return std::list<Gate*>::const_iterator
501 |   */
502 |   std::list<Gate*>::const_iterator children_end()  const {
503 |     return children.end();
504 |   }
505 | 
506 |   /**
507 |       Getter for size of children
508 | 
509 |       @return size_t
510 |   */
511 |   size_t children_size() const {return children.size();}
512 | 
513 |   /**
514 |       Getter for front of children
515 | 
516 |       @return Gate*
517 |   */
518 |   Gate * children_front() const {return children.front();}
519 | 
520 |   /**
521 |       Getter for back of children
522 | 
523 |       @return Gate*
524 |   */
525 |   Gate * children_back() const {return children.back();}
526 | 
527 |   /**
528 |       Setter for front of children
529 | 
530 |       @param n Gate*
531 |   */
532 |   void set_children_front(Gate * n) {children.front() = n;}
533 | 
534 |   /**
535 |       Setter for back of children
536 | 
537 |       @param n Gate*
538 |   */
539 |   void set_children_back(Gate * n) {children.back() = n;}
540 | 
541 |   /**
542 |       Appends gate n to the children
543 | 
544 |       @param n Gate*
545 |   */
546 |   void children_push_back(Gate * n) { if(n) children.push_back(n);}
547 | 
548 |   /**
549 |       Removes gate n from the children
550 | 
551 |       @param n Gate*
552 |   */
553 |   void children_remove(Gate * n) {children.remove(n);}
554 | 
555 | 
556 |   /**
557 |       Determines whether gate constraint is original
558 | 
559 |       @return True if ancestors are empty, i.e., polynomial has not
560 |       been reduced
561 |   */
562 |   bool orig() const;
563 | 
564 | 
565 |   /**
566 |       Destructor
567 |   */
568 |   ~Gate();
569 | 
570 |   /**
571 |       Determines whether n is contained in the parents of this gate
572 | 
573 |       @param n Gate*
574 | 
575 |       @return True whether n is parent of this gate
576 |   */
577 |   bool is_in_parents(const Gate *n) const;
578 | 
579 |   /**
580 |       Determines whether n is contained in the children of this gate
581 | 
582 |       @param n Gate*
583 | 
584 |       @return True whether n is child of this gate
585 |   */
586 |   bool is_child(const Gate *n) const;
587 | };
588 | 
589 | /*------------------------------------------------------------------------*/
590 | // / Gate ** where all gates are stored
591 | extern Gate ** gates;
592 | 
593 | // / Counts the number of gates
594 | extern unsigned num_gates;
595 | /*------------------------------------------------------------------------*/
596 | 
597 | /**
598 |     Returns the gate with aiger value 'lit'
599 | 
600 |     @param lit unsigned integer
601 | 
602 |     @returns Gate*
603 | */
604 | Gate * gate(unsigned lit);
605 | 
606 | /**
607 |     Allocate the Gate** gates and filling it
608 | */
609 | void allocate_gates(bool assert = 1);
610 | 
611 | /**
612 |     Mark those gates that are outputs in the aig
613 | */
614 | void mark_aig_outputs();
615 | 
616 | /**
617 |     For the xor output n, derive the corresponding carry output of an
618 |     half-adder
619 | 
620 |     @param n Gate* that is an xor output
621 | 
622 |     @return Gate* that is the AND output of an half-adder
623 | */
624 | Gate * derive_ha_and_gate(const Gate * n);
625 | 
626 | /**
627 |     Identifies XOR gates in an AIG
628 | */
629 | void set_xor();
630 | 
631 | /**
632 |     Identifies whether the output gates of slice N until NN-2 are
633 |     XOR gates
634 | 
635 |     @return True when output gates of bigger slices are all xor gates
636 | */
637 | bool upper_half_xor_output();
638 | 
639 | /**
640 |     Returns the 'left' child of an XOR
641 | 
642 |     @param n Gate that is root of XOR
643 | 
644 |     @return Gate*
645 | */
646 | Gate * xor_left_child(const Gate * n);
647 | 
648 | /**
649 |     Returns the 'right' child of an XOR
650 | 
651 |     @param n Gate that is root of XOR
652 | 
653 |     @return Gate*
654 | */
655 | Gate * xor_right_child(const Gate * n);
656 | 
657 | /**
658 |     Mark all gates in the xor_chain in the last slice
659 | */
660 | void mark_xor_chain_in_last_slice();
661 | 
662 | /**
663 |     For all gates set the parents and children
664 | 
665 |     @param set_children indicate whether children will be set(0 in -substitute)
666 | */
667 | void set_parents_and_children(bool set_children);
668 | 
669 | /**
670 |     Check whether no parent is assigned to a smaller slice
671 | 
672 |     @param n  Gate *
673 |     @param i  slice
674 | */
675 | bool parents_are_in_equal_or_larger_slice(const Gate * n, int i);
676 | 
677 | /**
678 |     Defines the polynomial '1-v'
679 | 
680 |     @param v Var*
681 | 
682 |     @returns: Polynomial*
683 | */
684 | Polynomial * negative_poly(const Var * v);
685 | 
686 | /**
687 |     Defines the polynomial 'v'
688 | 
689 |     @param v Var*
690 | 
691 |     @return Polynomial*
692 | */
693 | Polynomial * positive_poly(const Var * v);
694 | 
695 | /**
696 |     Generates the gate constraints for gates[i]
697 | 
698 |     @param i unsigned with NN <= i < M + NN - 1
699 | */
700 | Polynomial * gen_gate_constraint(unsigned i);
701 | 
702 | /**
703 |     Initializes the gate constraints in gates[i]
704 | 
705 |     @param i unsigned with NN <= i < M + NN - 1
706 | */
707 | void init_gate_constraint(unsigned i);
708 | 
709 | 
710 | /**
711 |     Initializes all gate constraints in the gates[]
712 | */
713 | void init_gate_constraints();
714 | 
715 | /**
716 |     Deletes Gate** gates by calling destructur of Gate
717 | */
718 | void delete_gates();
719 | 
720 | #endif  // AMULET2_SRC_GATE_H_
721 | 


--------------------------------------------------------------------------------
/src/slicing.cpp:
--------------------------------------------------------------------------------
  1 | /*------------------------------------------------------------------------*/
  2 | /*! \file slicing.cpp
  3 |     \brief contains functions slice and order the gates
  4 | 
  5 |   Part of AMulet2 : AIG Multiplier Verification Tool.
  6 |   Copyright(C) 2020, 2021 Daniela Kaufmann, Johannes Kepler University Linz
  7 | */
  8 | /*------------------------------------------------------------------------*/
  9 | #include <queue>
 10 | #include <utility>
 11 | 
 12 | #include "slicing.h"
 13 | /*------------------------------------------------------------------------*/
 14 | // ERROR CODES:
 15 | static int err_top_child  = 31; // error in topological_largest_child
 16 | /*------------------------------------------------------------------------*/
 17 | // Global var
 18 | std::vector<std::list<Gate*>> slices;
 19 | /*------------------------------------------------------------------------*/
 20 | 
 21 | void init_slices() {
 22 |   for (unsigned i = 0; i < NN; i++) {
 23 |     std::list<Gate*> l;
 24 |     Gate * n = gates[i+M-1];
 25 |     assert(n->get_output());
 26 |     l.push_back(n);
 27 |     slices.push_back(l);
 28 |     if (verbose >= 4) msg("init slice %i with output %s", i, n->get_var_name());
 29 |   }
 30 | }
 31 | 
 32 | 
 33 | void clean_slices(){
 34 |   for (int i=NN-1; i>= 0; i--) {
 35 |   std::list<Gate*> sl = slices[i];
 36 | 
 37 |   while(sl.size() > 1){
 38 |     Gate * n = sl.back();
 39 |     n->set_slice(-1);
 40 |     sl.pop_back();
 41 |   }
 42 | 
 43 |   slices[i] = sl;
 44 |   }
 45 | }
 46 | 
 47 | /*------------------------------------------------------------------------*/
 48 | 
 49 | 
 50 | bool is_valid_available_xor(Gate * g, int i){
 51 | 
 52 |   if (g->get_slice() != -1) return 0;
 53 | 
 54 | 
 55 |   if (i == (int) NN-1){
 56 |     for (auto it = g->parents_begin(); it != g->parents_end(); ++it) {
 57 |       Gate * p = *it;
 58 |       if (p->get_slice() < i) return 0;
 59 |     }
 60 |   }
 61 | 
 62 |   if(g->get_pp()){
 63 |     for (auto it = g->parents_begin(); it != g->parents_end(); ++it) {
 64 |       Gate * p = *it;
 65 |       if (p->get_slice() < i) return 0;
 66 |     }
 67 |     return 1;
 68 |   }
 69 | 
 70 |   if(g->get_xor_gate() == 1) return 1;
 71 | 
 72 |   return 0;
 73 | }
 74 | 
 75 | /*------------------------------------------------------------------------*/
 76 | 
 77 | 
 78 | void slice_by_xor_chains() {
 79 |   for (unsigned i = 0; i < NN; i++) {
 80 |     Gate * output = gates[i+M-1];
 81 |     output->set_slice(i);
 82 | 
 83 |     if(!output->children_size()) continue;
 84 |     assert(output->children_size() == 1);
 85 |     Gate * child = output->children_front();
 86 |     if(child->get_slice() != -1) continue;
 87 |     if(child->get_input()) continue;
 88 | 
 89 |     std::queue<Gate*> downwards_queue;
 90 |     child->set_slice(i);
 91 |     slices[i].push_back(child);
 92 | 
 93 |     if (i != NN-1 || child->get_xor_gate() == 1) {
 94 |       downwards_queue.push(child);
 95 |     }
 96 | 
 97 |     while (!downwards_queue.empty()) {
 98 |       Gate * n = downwards_queue.front();
 99 |       downwards_queue.pop();
100 | 
101 |       for (auto it = n->children_begin(); it != n->children_end(); ++it) {
102 |         Gate * n_child = *it;
103 | 
104 |         if (is_valid_available_xor(n_child, i)) {
105 |           if (!n_child->get_pp()) downwards_queue.push(n_child);
106 |           n_child->set_slice(i);
107 |           slices[i].push_back(n_child);
108 |           if (verbose >= 4) msg("xor-chain assign %s to slice %i", n_child->get_var_name(), i);
109 |         } else if (!n_child->get_input() && !n_child->get_carry_gate()) {
110 |           n_child->set_carry_gate(i);
111 |           if (verbose >= 4) msg("set carry gate for %s to %i", n_child->get_var_name(), i);
112 |         }
113 |       }
114 |     }
115 |   }
116 | 
117 | }
118 | 
119 | /*------------------------------------------------------------------------*/
120 | static void move_inserted_children_from_larger_slices
121 |   (Gate *n, std::list<Gate*>::const_iterator it){
122 |     int i = n->get_slice();
123 |     auto insert_pos = it;
124 |     for(auto iit = n->children_begin(); iit != n->children_end(); ++iit){
125 |       Gate * n_child = *iit;
126 |       if (n_child->get_input()) continue;
127 | 
128 |       if(n_child->get_slice() == i){
129 |         for (auto it = slices[i].begin(); it != slices[i].end(); ++it) {
130 |           Gate * n_it = *it;
131 |           if(n_it == n) break;
132 |           if(n_it == n_child){
133 |             slices[i].remove(n_child);
134 |             slices[n->get_slice()].insert(insert_pos, n_child);
135 |               if (verbose >= 4) msg("internally moved %s", n_child->get_var_name());
136 |             move_inserted_children_from_larger_slices(n_child, insert_pos);
137 |             break;
138 |           }
139 |         }
140 |       } else if(n_child->get_slice() > i) {
141 |         slices[n->get_slice()].insert(insert_pos, n_child);
142 |         slices[n_child->get_slice()].remove(n_child);
143 |         n_child->set_slice(n->get_slice());
144 |           if (verbose >= 4) msg("moved %s", n_child->get_var_name());
145 |         move_inserted_children_from_larger_slices(n_child, insert_pos);
146 |       }
147 |     }
148 | }
149 | 
150 | 
151 | 
152 | static bool children_are_assigned_in_larger_slices(Gate * n, int i){
153 |   for(auto it = n->children_begin(); it != n->children_end(); ++it){
154 |     Gate * n_child = *it;
155 |     if (n_child->get_slice()> i) return 1;
156 |   }
157 |   return 0;
158 | }
159 | /*------------------------------------------------------------------------*/
160 | void print_slices(){
161 | 
162 |   for (int i=NN-1; i>= 0; i--) {
163 |   std::list<Gate*> sl = slices[i];
164 |   msg("slice %i", i);
165 |   for (auto it=sl.begin(); it != sl.end(); ++it) {
166 |     Gate * n_it = *it;
167 |     msg("%s", n_it->get_var_name());
168 |     }
169 |   msg("");
170 |   }
171 | }
172 | 
173 | static bool upwards_slicing(const Gate * n, const Gate * pre) {
174 |   if (n->get_slice() == -1 && pre->get_aig_output()) return 0;
175 | 
176 | 
177 |   for (auto it = n->parents_begin();
178 |        it != n->parents_end(); ++it) {
179 |     Gate * n_parent = *it;
180 | 
181 |     if (n_parent->get_elim()) continue;
182 |     if (n_parent->get_slice() != -1) continue;
183 |     if (n_parent->get_output()) continue;
184 | 
185 | 
186 |     if (!parents_are_in_equal_or_larger_slice(n_parent, pre->get_slice()))
187 |       continue;
188 | 
189 |     if( children_are_assigned_in_larger_slices(n_parent, 0)){
190 |       if (pre->get_slice() == 0) continue;
191 |       if(n_parent->get_carry_gate() -1 > pre->get_slice()) continue;
192 |     }
193 | 
194 |     n_parent->set_slice(pre->get_slice());
195 | 
196 | 
197 | 
198 |     if (!pre->is_child(n_parent)) {
199 |       int par_in_slice = 0;
200 |       std::list<Gate*> parents_in_slice;
201 |       for (auto it = slices[pre->get_slice()].begin();
202 |             it != slices[pre->get_slice()].end(); ++it) {
203 |         Gate * cmp = *it;
204 |         if (n_parent->is_in_parents(cmp)) {
205 |           parents_in_slice.push_back(cmp);
206 |         }
207 |       }
208 |       par_in_slice = parents_in_slice.size();
209 | 
210 |       for ( auto it = slices[pre->get_slice()].begin();
211 |             it != slices[pre->get_slice()].end(); ++it) {
212 |         Gate * cmp = *it;
213 | 
214 |         if(n_parent->is_child(cmp) && par_in_slice){
215 |           if(par_in_slice > 1) return 1;
216 | 
217 |           slices[pre->get_slice()].insert(it, n_parent);
218 | 
219 | 
220 |           for(auto iit =parents_in_slice.begin(); iit != parents_in_slice.end(); ++iit){
221 |             Gate * tmp = *iit;
222 |             auto insert_pos = it;
223 |             slices[pre->get_slice()].insert(--insert_pos, tmp);
224 |             par_in_slice--;
225 |           }
226 |         } else if (((cmp == pre || n_parent->is_child(cmp)) && !par_in_slice)) {
227 | 
228 |           slices[n_parent->get_slice()].insert(it, n_parent);
229 | 
230 |           move_inserted_children_from_larger_slices(n_parent, it);
231 |           break;
232 |         } else if (n_parent->is_in_parents(cmp) && par_in_slice > 1) {
233 |           par_in_slice--;
234 |           parents_in_slice.remove(cmp);
235 |         } else if (n_parent->is_in_parents(cmp) && par_in_slice == 1 ) {
236 |           msg("insert %s after %s", n_parent->get_var_name(), cmp->get_var_name());
237 |           slices[n_parent->get_slice()].insert(++it, n_parent);
238 |           move_inserted_children_from_larger_slices(n_parent, it);
239 |           break;
240 |         }
241 |       }
242 |     } else {
243 |       //does this ever happen?!
244 |       for ( auto it = slices[pre->get_slice()].begin();
245 |         it != slices[pre->get_slice()].end(); ++it) {
246 |         Gate * cmp = *it;
247 |         if (cmp == pre) {
248 |           slices[pre->get_slice()].insert(++it, n_parent);
249 |           break;
250 |         }
251 |       }
252 |     }
253 | 
254 |     if (!n_parent->get_carry_gate()) {
255 |       if(upwards_slicing(n_parent, n_parent)) return 1;
256 |     } else if (!n_parent->all_parents_are_sliced()) {
257 |       if(upwards_slicing(n_parent, n_parent)) return 1;
258 |     }
259 |   }
260 | 
261 |   return 0;
262 | 
263 | }
264 | 
265 | /*------------------------------------------------------------------------*/
266 | 
267 | static bool slice_jut_gates() {
268 |   for (int i = NN-1; i >= 0; i--) {
269 |     Gate * output = gates[i+M-1];
270 |     output->set_slice(i);
271 | 
272 |     if(!output->children_size()) continue;
273 |     assert(output->children_size() == 1);
274 |     Gate * child = output->children_front();
275 | 
276 |     std::queue<Gate*> downwards_queue;
277 |     if (child->get_xor_gate() == 1 || i != static_cast<int>(NN-1))
278 |       downwards_queue.push(child);
279 | 
280 |     if(child->parents_size() > 1) upwards_slicing(child, child);
281 | 
282 |     while (!downwards_queue.empty()) {
283 |       Gate * n = downwards_queue.front();
284 |       downwards_queue.pop();
285 | 
286 |       for (auto it = n->children_begin(); it != n->children_end(); ++it) {
287 |         Gate * n_child = *it;
288 | 
289 |         if (n_child->get_slice() == static_cast<int>(i))
290 |           downwards_queue.push(n_child);
291 | 
292 |         if ((n_child->get_xor_gate() == 1 || n_child->get_pp())) {
293 |           if (n_child->get_slice() == static_cast<int>(i))
294 |             if(upwards_slicing(n_child, n_child)) return 1;
295 | 
296 |         } else if (n_child->get_carry_gate() == static_cast<int>(i) &&
297 |             !n_child->get_input()) {
298 |             if (n_child->get_pp()) {
299 |                 if(upwards_slicing(n_child, n)) return 1;
300 |             } else if (!n_child->get_pp() &&
301 |               !n_child->children_front()->get_input() &&
302 |               !n_child->children_back()->get_input()) {
303 |                 if(upwards_slicing(n_child, n)) return 1;
304 |           }
305 |         }
306 |       }
307 |     }
308 |   }
309 |   return 0;
310 | }
311 | 
312 | /*------------------------------------------------------------------------*/
313 | const Gate * topological_largest_child(const Gate * n) {
314 |   int slice = n->children_front()->get_slice();
315 |   for (auto it_n = n->children_begin(); it_n != n->children_end(); ++it_n) {
316 |     Gate * n_child = *it_n;
317 |     if (n_child ->get_input()) return 0;
318 |     if (n_child->get_slice() != slice)
319 |       die(err_top_child, "error in topological_largest_child with %s %s %i %s %i",
320 |       //msg("error in topological_largest_child with %s %s %i %s %i",
321 |       n->get_var_name(),
322 |       n->children_front()->get_var_name(), slice,
323 |       n_child->get_var_name(), n_child->get_slice());
324 |   }
325 | 
326 |   Gate * n1 = n->children_front();
327 | 
328 |   for (auto it_s = slices[n1->get_slice()].begin();
329 |       it_s != slices[n1->get_slice()].end(); ++it_s) {
330 |     Gate * n_slice = *it_s;
331 |     for (auto it_n = n->children_begin(); it_n != n->children_end(); ++it_n) {
332 |       Gate * n_child = *it_n;
333 |       if (n_slice == n_child) return n_child;
334 |     }
335 |   }
336 |   return 0;
337 | }
338 | 
339 | /*------------------------------------------------------------------------*/
340 | 
341 | void fix_slice(Gate * n, int i) {
342 |   const Gate * after = topological_largest_child(n);
343 |   if(!after) return;
344 | 
345 |   if (n->get_slice() != -1) slices[n->get_slice()].remove(n);
346 |   if (n->get_elim()) return;
347 |   n->set_slice(i);
348 |   for (std::list<Gate*>::const_iterator it = slices[i].begin();
349 |       it != slices[i].end(); ++it) {
350 |     Gate * n_it = *it;
351 |     if (n_it == after) {
352 |       msg("fix slice of %s",n->get_var_name());
353 |       slices[i].insert(it, n);
354 |       return;
355 |     }
356 |   }
357 |   msg("fix slice of %s",n->get_var_name());
358 |   slices[i].push_back(n);
359 | }
360 | 
361 | /*------------------------------------------------------------------------*/
362 | int fix_xors() {
363 |   int counter = 0;
364 |   for (unsigned i = NN; i < M-1; i++) {
365 |     Gate * n = gates[i];
366 |     if (n->get_elim()) continue;
367 |     if (n->get_xor_gate() != 1) continue;
368 |     if (n->get_aig_output()) continue;
369 | 
370 | 
371 |     aiger_and * and1 = is_model_and(n->get_var_num());
372 |     unsigned l = and1->rhs0, r = and1->rhs1;
373 |     Gate *l_gate = gate(l), *r_gate = gate(r);
374 | 
375 |     aiger_and * land = is_model_and(l);
376 |     unsigned ll = land->rhs0, lr = land->rhs1;
377 |     Gate *ll_gate = gate(ll), *lr_gate = gate(lr);
378 |     if(ll_gate->get_pp() || lr_gate->get_pp()) continue;
379 |     if (ll_gate->get_slice() < lr_gate->get_slice())
380 |       std::swap(ll_gate, lr_gate);
381 | 
382 |     if (ll_gate->parents_size() + lr_gate->parents_size() <= 3) {
383 |       if (ll_gate->get_slice() == n->get_slice()-1 &&
384 |           lr_gate->get_slice() == ll_gate->get_slice()) {
385 |         if (!r_gate->get_elim()) fix_slice(r_gate, ll_gate->get_slice());
386 |         if (!l_gate->get_elim()) fix_slice(l_gate, ll_gate->get_slice());
387 | 
388 |         fix_slice(n, n->get_slice()-1);
389 |         counter++;
390 |         n->mark_moved();
391 |         if (verbose >= 3)
392 |           msg("moved gate %s to slice %i", n->get_var_name(), n->get_slice());
393 |       }
394 |     } else if (ll_gate->parents_size() == 2 && lr_gate->parents_size() == 2) {
395 |       if (ll_gate->get_slice() == n->get_slice()-1 &&
396 |           lr_gate->get_slice() == ll_gate->get_slice() &&
397 |           (ll_gate->get_moved() || lr_gate->get_moved())) {
398 |         if (!r_gate->get_elim()) fix_slice(r_gate, ll_gate->get_slice());
399 |         if (!l_gate->get_elim()) fix_slice(l_gate, ll_gate->get_slice());
400 | 
401 |         fix_slice(n, n->get_slice()-1);
402 |         ++counter;
403 |       if (verbose >= 3)
404 |           msg("moved gate %s to slice %i", n->get_var_name(), n->get_slice());
405 |       }
406 |     }
407 |   }
408 |   if (verbose >= 1)
409 |     msg("moved %i gates to smaller slices", counter);
410 |   return counter;
411 | }
412 | 
413 | /*------------------------------------------------------------------------*/
414 | 
415 | void fix_jut_gates() {
416 |   int counter = 0;
417 |   for (unsigned i = NN; i < M-1; i++) {
418 |     Gate * n = gates[i];
419 | 
420 |     if (n->get_xor_gate()) continue;
421 |     if (n->get_elim()) continue;
422 |     if (n->get_pp()) continue;
423 |     if (n->children_size() < 4) continue;  // CHANGED THIS FROM 3 to 4
424 | 
425 |     int slice = n->get_slice() - 1;
426 |     int flag = 0;
427 | 
428 |     for (std::list<Gate*>::const_iterator it = n->children_begin();
429 |         it != n->children_end(); ++it) {
430 |       Gate * n_child = *it;
431 |       if (n_child->get_input()) continue;
432 |       if (n_child->get_slice() != slice) {
433 |         flag = 1;
434 |         break;
435 |       }
436 |     }
437 |     if (flag) continue;
438 | 
439 |     fix_slice(n, n->get_slice()-1);
440 |     ++counter;
441 |     if (verbose >= 3)
442 |       msg("moved gate %s to slice %i", n->get_var_name(), n->get_slice());
443 |   }
444 |   if (verbose >= 1) msg("moved %i adjacent gates to smaller slices", counter);
445 | }
446 | 
447 | /*------------------------------------------------------------------------*/
448 | 
449 | bool slicing_xor() {
450 | 
451 |   slice_by_xor_chains();
452 |   if(slice_jut_gates()) return 1;
453 | 
454 |   for (int i=NN-1; i>= 0; i--) {
455 |   std::list<Gate*> sl = slices[i];
456 |   for (std::list<Gate*>::const_iterator it=sl.begin(); it != sl.end(); ++it) {
457 |     Gate * n = *it;
458 |     if (n->get_elim()) continue;
459 |     }
460 |   }
461 |   if (fix_xors()) fix_jut_gates();
462 | 
463 |   return 0;
464 | }
465 | 
466 | /*------------------------------------------------------------------------*/
467 | 
468 | void input_cone(Gate * n, int num) {
469 |     assert(num >= 0);
470 |     if (n->get_input()) return;
471 |     if (n->get_slice() >= 0) return;
472 | 
473 |     assert(n->get_slice() < 0);
474 |     assert(is_model_and(n->get_var_num()));
475 |     n->set_slice(num);
476 |     for (std::list<Gate*>::const_iterator it = n->children_begin();
477 |         it != n->children_end(); ++it) {
478 |       Gate * n_child = *it;
479 |       input_cone(n_child, num);
480 |     }
481 | }
482 | 
483 | /*------------------------------------------------------------------------*/
484 | 
485 | void find_carries() {
486 |   for (unsigned j = M-1; j > NN; j--) {
487 |     Gate * n = gates[j];
488 |     if (n->get_elim()) continue;
489 |     n->set_carry_gate(0);
490 |     for (std::list<Gate*>::const_iterator it=n->parents_begin();
491 |         it != n->parents_end(); ++it) {
492 |       Gate * n_parent = *it;
493 |       if (n_parent->get_slice() > n->get_slice()) {
494 |         n->inc_carry_gate();
495 |       }
496 |     }
497 |   }
498 | }
499 | 
500 | /*------------------------------------------------------------------------*/
501 | 
502 | bool search_for_booth_pattern() {
503 |   bool found_booth = 0;
504 |   for (unsigned i = NN; i < M-1; i++) {
505 |     Gate * n = gates[i];
506 |     if (n->get_elim()) continue;
507 | 
508 |     if (n->get_slice() == 1) {
509 |       // Special treatment for slice 1
510 |       if (!n->get_pp()) continue;
511 | 
512 |       aiger_and * and1 = is_model_and(n->get_var_num());
513 |       unsigned l = aiger_strip(and1->rhs0), r = aiger_strip(and1->rhs1);
514 |       if (!gate(l)->get_input() || !gate(r)->get_input()) continue;
515 | 
516 |       if (l-r != 2) continue;
517 | 
518 |       if (verbose >= 4) msg("found booth pattern %s", n->get_var_name());
519 |       n->mark_bo();
520 |       found_booth = 1;
521 |     } else {
522 | 
523 |       // all other slices
524 |       if (n->get_pp()) continue;
525 |       if (n->get_xor_gate() != 1) continue;
526 |       if (n->parents_size() != 1) continue;
527 | 
528 |       aiger_and * and_init = is_model_and(n->get_var_num());
529 | 
530 |       unsigned l = and_init->rhs0;
531 |       if (!aiger_sign(l)) continue;
532 | 
533 |       aiger_and * land = is_model_and(l);
534 |       unsigned ll = aiger_strip(land->rhs0), lr = aiger_strip(land->rhs1);
535 |       if (!gate(ll)->get_input() || !gate(lr)->get_input()) continue;
536 | 
537 | 
538 | 
539 |       Gate * xor1 = n;
540 |       aiger_and * and1 = is_model_and(xor1->get_var_num());
541 | 
542 |       Gate * vp = xor1->parents_front();
543 |       int p = vp->get_var_num();
544 |       if(p < 0) continue;
545 |       aiger_and * parent = is_model_and(p);
546 |       unsigned pl = parent->rhs0, pr = parent->rhs1;
547 |       Gate * xor2 =
548 |         (static_cast<int>(pl) == xor1->get_var_num()) ? gate(pl) : gate(pr);
549 | 
550 |       if (xor2->parents_size() < NN/2+1) continue;
551 | 
552 |       if (xor2->get_slice() >= xor1->get_slice()) continue;
553 | 
554 |       aiger_and * and2 = is_model_and(xor2->get_var_num());
555 |       if (!xor2->get_xor_gate()) continue;
556 | 
557 |       unsigned l2 = and2->rhs0;
558 |       if (!aiger_sign(l2)) continue;
559 |       aiger_and * land2 = is_model_and(l2);
560 |       unsigned ll2 = aiger_strip(land2->rhs0), lr2 = aiger_strip(land2->rhs1);
561 |       if (!gate(ll2)->get_input() || !gate(lr2)->get_input()) continue;
562 |       if (ll != ll2 && ll != lr2 && lr != ll2 && lr != lr2) continue;
563 | 
564 |       found_booth = 1;
565 |       xor1->mark_bo();
566 |       gate(and1->rhs0)->mark_bo();
567 |       gate(and1->rhs1)->mark_bo();
568 |       xor2->mark_bo();
569 |       gate(and2->rhs0)->mark_bo();
570 |       gate(and2->rhs1)->mark_bo();
571 |       vp->mark_bo();
572 | 
573 |       if (verbose >=4)
574 |         msg("found booth pattern %s, %s, %s", xor1->get_var_name(),
575 |                                               xor2->get_var_name(),
576 |                                               vp->get_var_name());
577 |     }
578 |   }
579 |   return found_booth;
580 | }
581 | 
582 | /*------------------------------------------------------------------------*/
583 | 
584 | void merge_all() {
585 |   int total_merge = 0;
586 |   int merged = 1;
587 |   while (merged) {
588 |     merged = 0;
589 |     for (unsigned i = M-2; i > NN; i--) {
590 |       Gate * n = gates[i];
591 | 
592 |       if (n->get_slice() < 1) continue;  // elim
593 |       if (n->get_elim()) continue;
594 |       if (is_model_input(n->get_var_num())) continue;
595 | 
596 |       if (n->get_xor_gate() == 2) {
597 |         aiger_and * and1 = is_model_and(n->get_var_num());
598 |         unsigned rhs0 = and1->rhs0;
599 |         unsigned rhs1 = and1->rhs1;
600 |         Gate * v0 = gate(rhs0);
601 |         Gate * v1 = gate(rhs1);
602 |         if (!(v0->get_slice() == v1->get_slice() &&
603 |              v1->get_slice() < n->get_slice() &&
604 |             !v0->get_pp() && !v1->get_pp()))
605 |           continue;
606 |       }
607 | 
608 |       if (n->get_xor_gate() == 1 && !n->get_aig_output()) continue;
609 |       if (n->get_xor_gate() == 1 && n->parents_size() > 1 ) continue;
610 | 
611 |       bool flag = 0;
612 |       for (std::list<Gate*>::const_iterator it=n->children_begin();
613 |           it != n->children_end(); ++it) {
614 |         Gate * n_child = *it;
615 |         if (n_child->get_input()) flag = 1;
616 |         else if (n_child->get_slice() == n->get_slice()) flag = 1;
617 |         else if (n_child->get_bo()) flag = 1;
618 |         if (flag) break;
619 |       }
620 |       if (flag) continue;
621 | 
622 |       n->dec_slice();
623 |       n->set_carry_gate(0);
624 |       for (std::list<Gate*>::const_iterator it = n->parents_begin();
625 |           it != n->parents_end(); ++it) {
626 |         Gate * n_parent = *it;
627 |         if (n_parent->get_slice() > n->get_slice()) n->inc_carry_gate();
628 |       }
629 |       for (std::list<Gate*>::const_iterator it = n->children_begin();
630 |           it != n->children_end(); ++it) {
631 |         Gate * n_child = *it;
632 |         if (n->get_slice() == n_child->get_slice()) n_child->dec_carry_gate();
633 |       }
634 | 
635 |       merged = 1;
636 |       if (verbose >= 3)
637 |         msg("merged gate %s to slice %i", n->get_var_name(), n->get_slice());
638 |       total_merge = total_merge +1;
639 |     }
640 |   }
641 |   msg("totally merged %i variable(s)", total_merge);
642 | }
643 | 
644 | /*------------------------------------------------------------------------*/
645 | 
646 | void promote_all() {
647 |   int total_promote = 0;
648 |   int promoted = 1;
649 |   while (promoted) {
650 |     promoted = 0;
651 |     for (unsigned i = NN; i < M; i++) {
652 |       Gate * n = gates[i];
653 |       if (!n->get_carry_gate()) continue;
654 |       if (n->get_pp()) continue;
655 |       if (static_cast<int>(n->parents_size()) != n->get_carry_gate()) continue;
656 | 
657 |       aiger_and * and1 = is_model_and(n->get_var_num());
658 |       unsigned rhs0 = and1->rhs0;
659 |       unsigned rhs1 = and1->rhs1;
660 |       Gate * v0 = gate(rhs0);
661 |       Gate * v1 = gate(rhs1);
662 | 
663 |       if(!v0 || !v1) continue;
664 | 
665 |       if (n->get_xor_gate() != 2 &&
666 |         (!v0->get_carry_gate() || !v1->get_carry_gate()) &&
667 |         (!v0->get_carry_gate() || !v1->get_input()) &&
668 |         (!v1->get_carry_gate() || !v0->get_input()))  continue;
669 | 
670 |       bool flag = 0;
671 | 
672 |       for (std::list<Gate*>::const_iterator it = n->parents_begin();
673 |           it != n->parents_end(); ++it) {
674 |         Gate * n_parent = *it;
675 |         if (n_parent->get_slice() == n->get_slice()) flag = 1;
676 |       }
677 | 
678 |       if (flag) continue;
679 | 
680 |       n->inc_slice();
681 |       v0->inc_carry_gate();
682 |       v1->inc_carry_gate();
683 |       n->set_carry_gate(0);
684 | 
685 |       for (std::list<Gate*>::const_iterator it = n->parents_begin();
686 |           it != n->parents_end(); ++it) {
687 |         Gate * n_parent = *it;
688 |         if (n_parent->get_slice() > n->get_slice()) n->inc_carry_gate();
689 |       }
690 | 
691 |       promoted = 1;
692 |       total_promote++;
693 | 
694 |       if (verbose >= 3)
695 |         msg("promoted gate %s to slice %i", n->get_var_name(), n->get_slice());
696 |     }
697 |   }
698 |   msg("totally promoted %i variable(s)", total_promote);
699 | }
700 | 
701 | /*------------------------------------------------------------------------*/
702 | 
703 | void fill_slices() {
704 |   for (unsigned i = 0; i <= NN-1; i++) {
705 |     for (unsigned j = M-2; j >= NN; j--) {
706 |       Gate * n = gates[j];
707 |       if (n->get_slice() == static_cast<int>(i)) {
708 |         slices[i].push_back(n);
709 |       }
710 |     }
711 |   }
712 |   msg("filled %i slices", NN);
713 | }
714 | 
715 | /*------------------------------------------------------------------------*/
716 | 
717 | void slicing_non_xor() {
718 |   for (unsigned i = 0; i < NN; i++){
719 |     unsigned lit = slit(i);
720 |     if(lit < 2) continue;
721 |     input_cone(gate(lit), i);
722 |   }
723 | 
724 | 
725 |   find_carries();
726 |   merge_all();
727 |   promote_all();
728 |   fill_slices();
729 | 
730 |   if (verbose > 3) print_slices();
731 | }
732 | 


--------------------------------------------------------------------------------