func createLiterals(start int, n int) (literals []sat.Literal) {
p := sat.Pred("x")
literals = make([]sat.Literal, n)
for i := 0; i < n; i++ {
literals[i] = sat.Literal{true, sat.NewAtomP1(p, start+i)}
}
return
}
func createEntries(weights []int64) (entries []Entry) {
p := sat.Pred("x")
entries = make([]Entry, len(weights))
for i := 0; i < len(weights); i++ {
l := sat.Literal{true, sat.NewAtomP1(p, i)}
entries[i] = Entry{l, weights[i]}
}
return
}
// Translate monotone MDDs to SAT
// Together with AMO translation
func convertMDD2Clauses(store mdd.IntervalMddStore, pb *Threshold) (clauses sat.ClauseSet) {
pred := sat.Pred("mdd" + strconv.Itoa(pb.Id))
top_lit := sat.Literal{true, sat.NewAtomP1(pred, store.Top)}
clauses.AddTaggedClause("Top", top_lit)
for _, n := range store.Nodes {
v_id, l, vds := store.ClauseIds(*n)
if !n.IsZero() && !n.IsOne() {
v_lit := sat.Literal{false, sat.NewAtomP1(pred, v_id)}
last_id := -1
for i, vd_id := range vds {
if last_id != vd_id {
vd_lit := sat.Literal{true, sat.NewAtomP1(pred, vd_id)}
if i > 0 {
literal := pb.Entries[len(pb.Entries)-l+i-1].Literal
clauses.AddTaggedClause("1B", v_lit, sat.Neg(literal), vd_lit)
} else {
clauses.AddTaggedClause("0B", v_lit, vd_lit)
}
}
last_id = vd_id
}
} else if n.IsZero() {
v_lit := sat.Literal{false, sat.NewAtomP1(pred, v_id)}
clauses.AddTaggedClause("False", v_lit)
} else if n.IsOne() {
v_lit := sat.Literal{true, sat.NewAtomP1(pred, v_id)}
clauses.AddTaggedClause("True", v_lit)
}
}
return
}
// Create Encoding for Sorting Network
// 0) Omitted for clarity (ids as in paper)
// 1) A or -D
// 2) B or -D
// 3) -A or -B or D
// 4) -A or C
// 5) -B or C
// 6) A or B or -C
// 7) C or -D
// -1,0,1 = *, false, true
func CreateEncoding(input []sat.Literal, which [8]bool, output []sat.Literal, tag string, pred sat.Pred, sorter sorters.Sorter) (cs sat.ClauseSet) {
//cs.list = make([]Clause, 0, 7*len(sorter.Comparators))
backup := make(map[int]sat.Literal, len(sorter.Out)+len(sorter.In))
for i, x := range sorter.In {
backup[x] = input[i]
}
for i, x := range sorter.Out {
backup[x] = output[i]
}
for _, comp := range sorter.Comparators {
if comp.D == 1 || comp.C == 0 {
fmt.Println("something is wrong with the comparator", comp)
panic("something is wrong with the comparator")
}
getLit := func(x int) sat.Literal {
if lit, ok := backup[x]; ok {
return lit
} else {
return sat.Literal{true, sat.NewAtomP1(pred, x)}
}
}
a := getLit(comp.A)
b := getLit(comp.B)
c := getLit(comp.C)
d := getLit(comp.D)
if comp.C == 1 { // 6) A or B
//if which[6] {
cs.AddTaggedClause(tag, a, b)
//}
} else if comp.C > 0 { // 4) 5) 6)
//4)
if which[4] {
cs.AddTaggedClause(tag, sat.Neg(a), c)
}
//5)
if which[5] {
cs.AddTaggedClause(tag, sat.Neg(b), c)
}
//6)
if which[6] {
cs.AddTaggedClause(tag, a, b, sat.Neg(c))
}
}
if comp.D == 0 { //3)
//if which[3] {
cs.AddTaggedClause(tag, sat.Neg(a), sat.Neg(b))
//}
} else if comp.D > 0 { // 1) 2) 3)
//1)
if which[1] {
cs.AddTaggedClause(tag, a, sat.Neg(d))
}
//2)
if which[2] {
cs.AddTaggedClause(tag, b, sat.Neg(d))
}
//3)
if which[3] {
cs.AddTaggedClause(tag, sat.Neg(a), sat.Neg(b), d)
}
}
if which[7] && comp.C != 1 && comp.D != 0 && comp.C != -1 && comp.D != -1 { // 7)
if comp.C == 0 || comp.D == 1 {
panic("something is wrong with this comparator")
}
cs.AddTaggedClause(tag, c, sat.Neg(d))
}
}
return
}
func main() {
glob.Init()
input, err2 := os.Open(*glob.Filename_flag)
defer input.Close()
if err2 != nil {
panic("Could not read file")
return
}
scanner := bufio.NewScanner(input)
buf := make([]byte, 0, 64*1024)
scanner.Buffer(buf, 1024*1024)
state := 0 // 0: read size, 1: read graph 1, 2: read graph 2
vars := 0
orig_vars := 0
size := 0
i := 0
var entries []entry
for scanner.Scan() {
l := strings.Trim(scanner.Text(), " ")
if l == "" || strings.HasPrefix(l, "%") || strings.HasPrefix(l, "*") {
continue
}
elements := strings.Fields(l)
var b error
switch state {
case 0: // deprecated: for parsing the "header" of pb files, now parser is flexible
{
vars, b = strconv.Atoi(elements[0])
if b != nil {
panic("bad conversion of numbers")
}
orig_vars = vars
size, b = strconv.Atoi(elements[1])
if b != nil {
panic("bad conversion of numbers")
}
entries = make([]entry, size)
state = 1
}
case 1:
{
entries[i].id1, b = strconv.Atoi(elements[0])
if b != nil {
panic("bad conversion of numbers")
}
entries[i].id2, b = strconv.Atoi(elements[1])
if b != nil {
panic("bad conversion of numbers")
}
var f float64
f, b = strconv.ParseFloat(elements[2], 64)
if b != nil {
panic("bad conversion of numbers")
}
entries[i].c = int64(f)
if entries[i].id1 != entries[i].id2 {
vars++
entries[i].and = vars
}
i++
}
}
}
var clauses sat.ClauseSet
var opt constraints.Threshold
opt.Typ = constraints.OPT
lits := make([]sat.Literal, vars+1)
primaryVars := make(map[string]bool, 0)
for i := 0; i <= vars; i++ {
primaryVars[sat.NewAtomP1(sat.Pred("x"), i).Id()] = true
}
for i, _ := range lits {
lits[i] = sat.Literal{true, sat.NewAtomP1(sat.Pred("x"), i)}
}
for _, e := range entries {
if e.id1 == e.id2 {
opt.Entries = append(opt.Entries, constraints.Entry{lits[e.id1], int64(e.c)})
} else {
clauses.AddClause(sat.Neg(lits[e.id1]), sat.Neg(lits[e.id2]), lits[e.and])
clauses.AddClause(lits[e.id1], sat.Neg(lits[e.and]))
clauses.AddClause(lits[e.id2], sat.Neg(lits[e.and]))
opt.Entries = append(opt.Entries, constraints.Entry{lits[e.and], int64(e.c)})
}
}
if *glob.Gringo_flag {
for i := 0; i <= orig_vars; i++ {
fmt.Println("{x(", i, ")}.")
}
for _, e := range entries {
if e.id1 != e.id2 {
fmt.Println(lits[e.and].ToTxt(), ":-", lits[e.id1].ToTxt(), ",", lits[e.id2].ToTxt(), ".")
}
}
opt.PrintGringo()
return
}
g := sat.IdGenerator(clauses.Size()*7 + 1)
g.PrimaryVars = primaryVars
opt.NormalizePositiveCoefficients()
opt.Offset = opt.K
// opt.PrintGringo()
// clauses.PrintDebug()
glob.D("offset", opt.Offset)
glob.A(opt.Positive(), "opt only has positive coefficients")
g.Solve(clauses, &opt, *glob.Opt_bound_flag, -opt.Offset)
}
func TestAtMostOne(test *testing.T) {
glob.D("TestTranslateAtMostOne")
k := 6
lits := make([]sat.Literal, k)
atoms := make(map[string]bool)
for i, _ := range lits {
lits[i] = sat.Literal{true, sat.NewAtomP1(sat.Pred("x"), i)}
atoms[lits[i].A.Id()] = true
}
t := TranslateAtMostOne(Naive, "naive", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
t = TranslateAtMostOne(Split, "split", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
// t = TranslateAtMostOne(Sort, "sorter", lits)
// if t.Clauses.Size() == 0 {
// test.Fail()
// }
t = TranslateAtMostOne(Heule, "heule", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
t = TranslateAtMostOne(Log, "Log", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
//fmt.Println()
t = TranslateAtMostOne(Count, "counter", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
//t.Clauses.PrintDebug()
//g := sat.IdGenerator(t.Clauses.Size() * 7)
//g.Filename = "out.cnf"
//g.PrimaryVars = atoms
//g.Solve(t.Clauses)
//g.PrintSymbolTable("sym.txt")
//fmt.Println()
t = TranslateExactlyOne(Naive, "naive", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
t = TranslateExactlyOne(Split, "split", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
t = TranslateExactlyOne(Count, "counter", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
//t = TranslateExactlyOne(Sort, "sorter", lits)
//if t.Clauses.Size() == 0 {
// test.Fail()
//}
t = TranslateExactlyOne(Heule, "heule", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
t = TranslateExactlyOne(Log, "Log", lits)
if t.Clauses.Size() == 0 {
test.Fail()
}
}
func TranslateAtMostOne(typ OneTranslationType, tag string, lits []sat.Literal) (trans CardTranslation) {
var clauses sat.ClauseSet
switch typ {
case Naive:
for i, l := range lits {
for j := i + 1; j < len(lits); j++ {
clauses.AddTaggedClause(tag, sat.Neg(l), sat.Neg(lits[j]))
}
}
case Split:
// a constant that should be exposed,
// its the cuttoff for the split method of atMostOne
cutoff := 5
if len(lits) <= cutoff {
return TranslateAtMostOne(Naive, tag, lits)
} else {
aux := sat.NewAtomP1(sat.Pred("split"), newId())
trans.Aux = append(trans.Aux, sat.Literal{true, aux})
for _, l := range lits[:len(lits)/2] {
clauses.AddTaggedClause(tag, sat.Literal{true, aux}, sat.Neg(l))
}
for _, l := range lits[len(lits)/2:] {
clauses.AddTaggedClause(tag, sat.Literal{false, aux}, sat.Neg(l))
}
clauses.AddClauseSet(TranslateAtMostOne(typ, tag, lits[:len(lits)/2]).Clauses)
clauses.AddClauseSet(TranslateAtMostOne(typ, tag, lits[len(lits)/2:]).Clauses)
}
case Count:
pred := sat.Pred("c")
counterId := newId()
auxs := make([]sat.Literal, len(lits))
for i, _ := range auxs {
auxs[i] = sat.Literal{true, sat.NewAtomP2(pred, counterId, i)}
}
trans.Aux = auxs
// S_i -> S_{i-1}
for i := 1; i < len(lits); i++ {
clauses.AddTaggedClause(tag, auxs[i-1], sat.Neg(auxs[i]))
}
// X_i -> S_i
for i := 0; i < len(lits); i++ {
clauses.AddTaggedClause(tag, auxs[i], sat.Neg(lits[i]))
}
// X_i-1 -> -S_i
for i := 1; i < len(lits); i++ {
clauses.AddTaggedClause(tag, sat.Neg(auxs[i]), sat.Neg(lits[i-1]))
}
// (S_i-1 /\ -S_i) -> X_i-1
for i := 1; i <= len(lits); i++ {
if i != len(lits) {
clauses.AddTaggedClause(tag, sat.Neg(auxs[i-1]), auxs[i], lits[i-1])
} else {
clauses.AddTaggedClause(tag, sat.Neg(auxs[i-1]), lits[i-1])
}
}
case Heule:
k := 4 // fixed size for the heule encoding
if len(lits) > k+1 {
aux := sat.NewAtomP1(sat.Pred("heule"), newId())
trans.Aux = append(trans.Aux, sat.Literal{true, aux})
front := make([]sat.Literal, k+1)
copy(front, lits[:k])
front[k] = sat.Literal{true, aux}
trans2 := TranslateAtMostOne(Naive, tag, front)
clauses.AddClauseSet(trans2.Clauses)
back := make([]sat.Literal, len(lits)-k+1)
copy(back, lits[k:])
back[len(lits)-k] = sat.Literal{false, aux}
trans2 = TranslateAtMostOne(typ, tag, back)
trans.Aux = append(trans.Aux, trans2.Aux...)
clauses.AddClauseSet(trans2.Clauses)
} else {
trans2 := TranslateAtMostOne(Naive, tag, lits)
clauses.AddClauseSet(trans2.Clauses)
}
case Log:
cutoff := 5 //will be a parameter of this encoding
clauses = buildLogEncoding(sat.Pred("logE"), newId(), cutoff, 0, tag, lits)
case Sort:
panic("CNF translation for this type not implemented yet")
default:
panic("CNF translation for this type not implemented yet")
}
trans.Typ = typ
trans.Clauses = clauses
return
}