Abstract Cores in Implicit Hitting Set MaxSat Solving Jeremias Berg - - PowerPoint PPT Presentation

Abstract Cores in Implicit Hitting Set MaxSat Solving

Jeremias Berg1 Fahiem Bacchus2 Alex Poole2

1HIIT, Dept. Computer Science, University of Helsinki, Finland 2University of Toronto, Department of Computer Science, Canada

SAT 2020 Online

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 1 / 20

MaxSat

A declarative optimisation paradigm based on propositional logic i.e. Boolean literals and clauses Builds on the success of SAT Applications in:

◮ data analysis ◮ error localization in C code ◮ haplotyping with pedigrees. ◮ and others.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 2 / 20

MaxSat

A declarative optimisation paradigm based on propositional logic i.e. Boolean literals and clauses Builds on the success of SAT Applications in:

◮ data analysis ◮ error localization in C code ◮ haplotyping with pedigrees. ◮ and others.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 2 / 20

MaxSat

A declarative optimisation paradigm based on propositional logic i.e. Boolean literals and clauses Builds on the success of SAT Applications in:

◮ data analysis ◮ error localization in C code ◮ haplotyping with pedigrees. ◮ and others.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 2 / 20

MaxSat

A declarative optimisation paradigm based on propositional logic i.e. Boolean literals and clauses Builds on the success of SAT Applications in:

◮ data analysis ◮ error localization in C code ◮ haplotyping with pedigrees. ◮ and others.

Ghosh and Meel [2019] Chen et al. [2010] Zhang and Bacchus [2012] Berg and J¨ arvisalo [2017] Demirovic et al. [2019] Hosokawa et al. [2019]

. . .

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 2 / 20

MaxSat

A declarative optimisation paradigm based on propositional logic i.e. Boolean literals and clauses Builds on the success of SAT Applications in:

◮ data analysis ◮ error localization in C code ◮ haplotyping with pedigrees. ◮ and others.

17 new benchmark families from different application areas submitted to the past two MaxSAT Evaluations

Ghosh and Meel [2019] Chen et al. [2010] Zhang and Bacchus [2012] Berg and J¨ arvisalo [2017] Demirovic et al. [2019] Hosokawa et al. [2019]

. . .

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 2 / 20

Our Contributions

IHS solvers central in real-world MaxSAT solving

◮ Decouple MaxSAT into core-extraction (SAT-solving) and

• ptimization (IP-solving)

◮ Avoid increasing complexity of SAT calls, ◮ needs to extract a large number of cores on some instances.

Abstract cores: a compact way of representing an exponential number of ordinary cores. In this paper we:

◮ ... incorporate abstract cores into IHS solvers, ◮ ... prove correctness of the algorithm, ◮ ... prove that abstract cores improve IHS solvers in theory and ◮ ... show significant experimental improvements.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 3 / 20

Our Contributions

IHS solvers central in real-world MaxSAT solving

◮ Decouple MaxSAT into core-extraction (SAT-solving) and

• ptimization (IP-solving)

◮ Avoid increasing complexity of SAT calls, ◮ needs to extract a large number of cores on some instances.

Abstract cores: a compact way of representing an exponential number of ordinary cores. In this paper we:

◮ ... incorporate abstract cores into IHS solvers, ◮ ... prove correctness of the algorithm, ◮ ... prove that abstract cores improve IHS solvers in theory and ◮ ... show significant experimental improvements.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 3 / 20

Our Contributions

IHS solvers central in real-world MaxSAT solving

◮ Decouple MaxSAT into core-extraction (SAT-solving) and

• ptimization (IP-solving)

◮ Avoid increasing complexity of SAT calls, ◮ needs to extract a large number of cores on some instances.

Abstract cores: a compact way of representing an exponential number of ordinary cores. In this paper we:

◮ ... incorporate abstract cores into IHS solvers, ◮ ... prove correctness of the algorithm, ◮ ... prove that abstract cores improve IHS solvers in theory and ◮ ... show significant experimental improvements.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 3 / 20

Our Contributions

225 250 275 300 325 350 375 400 425 450 Instances Solved 1000 2000 3000 Run Time (sec.)

MSE 2019 Unweighted Instances

maxhs-abs-ex maxhs-abs rc2 UWr maxhs

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 3 / 20

Our Contributions

225 250 275 300 325 350 375 400 425 450 Instances Solved 1000 2000 3000 Run Time (sec.)

MSE 2019 Unweighted Instances

maxhs-abs-ex maxhs-abs rc2 UWr maxhs

Best performing solver of MSE 2019

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 3 / 20

Outline

Preliminaries IHS based MaxSat solving Abstract cores IHS with abstract cores Empirical results.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 4 / 20

MaxSat solving with Implicit Hitting Sets

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 5 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses, ◮ a set of soft clauses and ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses, ◮ a set of soft clauses and ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} w((¬b1)) = w((¬b2)) = 1, w((¬b3)) = 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses, ◮ a set of soft clauses and ◮ a weight function wt over the soft

clauses.

◮ weights can be any integers

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} w((¬b1)) = 2, w((¬b2)) = 4, w((¬b3)) = 3

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses and ◮ a set of soft clauses. ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses and ◮ a set of soft clauses. ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} τ(b1) = τ(b3) = 0 τ(b2) = 1 FS = {(¬b1), (¬b2), (¬b3)} cost(τ) = 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses and ◮ a set of soft clauses. ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} τ = {¬b1, b2, ¬b3} FS = {(¬b1), (¬b2), (¬b3)} cost(τ) = 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: MaxSat

Optimisation extension of Boolean Satisfiability (SAT) An instance consists of:

◮ a set of hard clauses and ◮ a set of soft clauses. ◮ a weight function wt over the soft

clauses.

Find τ that:

◮ satisfies all hard clauses and ◮ maximises the number of satisfied

soft clauses.

Assume w.l.o.g. that all soft clauses are unit negative literals

◮ Blocking variables: the variables in

soft clauses.

◮ FB the set of blocking variables

FH = {(b1 ∨ b2), (b2 ∨ b3)} τ = {¬b1, b2, ¬b3} FS = {(¬b1), (¬b2), (¬b3)} cost(τ) = 1 FB = {b1, b2, b3}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 6 / 20

Preliminaries: UNSAT Cores

Central in modern MaxSAT solving: κ ⊂ FS is an core if FH ∧ κ is unsatisfiable κ can be represented as a clause

• ver FB that is entailed by FH
• r as a linear inequality

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} FB = {b1, b2, b3}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 7 / 20

Preliminaries: UNSAT Cores

Central in modern MaxSAT solving: κ ⊂ FS is an core if FH ∧ κ is unsatisfiable κ can be represented as a clause

• ver FB that is entailed by FH
• r as a linear inequality

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} FB = {b1, b2, b3} κ = {(¬b1), (¬b2)}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 7 / 20

Preliminaries: UNSAT Cores

Central in modern MaxSAT solving: κ ⊂ FS is an core if FH ∧ κ is unsatisfiable κ can be represented as a clause

• ver FB that is entailed by FH
• r as a linear inequality

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} FB = {b1, b2, b3} κ = {(¬b1), (¬b2)} κ = (b1 ∨ b2)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 7 / 20

Preliminaries: UNSAT Cores

Central in modern MaxSAT solving: κ ⊂ FS is an core if FH ∧ κ is unsatisfiable κ can be represented as a clause

• ver FB that is entailed by FH
• r as a linear inequality

FH = {(b1 ∨ b2), (b2 ∨ b3)} FS = {(¬b1), (¬b2), (¬b3)} FB = {b1, b2, b3} κ = {(¬b1), (¬b2)} κ = (b1 ∨ b2) κ = b1 + b2 ≥ 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 7 / 20

Preliminaries: UNSAT Cores

Central in modern MaxSAT solving: κ ⊂ FS is an core if FH ∧ κ is unsatisfiable κ can be represented as a clause

• ver FB that is entailed by FH
• r as a linear inequality

In the rest of the presentation, we represent clauses(b1 ∨ b2) as (b1, b2) FH = {(b1, b2), (b2, b3)} FS = {(¬b1), (¬b2), (¬b3)} FB = {b1, b2, b3} κ = {(¬b1), (¬b2)} κ = (b1, b2) κ = b1 + b2 ≥ 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 7 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} Basic-IHS (F)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = Min-Hs (FB, ∅) UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = Min-Hs (FB, ∅) UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs

Min-Hs (FB, CORES):

minimize:

b∈FB wt(b)b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

Weighted Case

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = ∅ UB = ∞ LB = |∅|

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = ∅ A = FB \ hs UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {b1, b2, b3, b4} K = {} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {

• b1,
• b2, b3, b4}

K = {(b1, b2)} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {b3, b4} K = {(b1, b2)} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {

• b3,
• b4}

K = {(b1, b2), (b3, b4)} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {} K = {(b1, b2), (b3, b4)} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} sat-assume(FH, ¬A) A = {} K = {(b1, b2), (b3, b4)} τ = {¬b1, b2, ¬b3, b4} UB = ∞ LB = 0

CORES = ∅ BESTSOL = ∅

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} K = {(b1, b2), (b3, b4)} τ = {¬b1, b2, ¬b3, b4} UB = cost(τ) LB = 0

CORES = ∅ BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} K = {(b1, b2), (b3, b4)} τ = {¬b1, b2, ¬b3, b4} UB = 2 LB = 0

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} UB = 2 LB = 0

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = Min-Hs (FB, {(b1, b2), (b3, b4)}) UB = 2 LB = 0

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Hs (FB, CORES):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = {b1, b4} UB = 2 LB = |{b1, b4}|

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = {b1, b4} UB = 2 LB = 2

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES return BESTSOL

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Solving (unweighted) MaxSat with IHS

FH = {(b1, b2), (b2, b3), (b3, b4)} FS = {(¬b1), (¬b2), (¬b3), (¬b4)} FB = {b1, b2, b3, b4} hs = {b1, b4} UB = 2 LB = 2

CORES = {(b1, b2), (b3, b4)} BESTSOL = {¬b1, b2, ¬b3, b4}

LB need to be increased to optimum before termination Basic-IHS (F)

Initialize while LB < UB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES return BESTSOL

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 8 / 20

Abstract Cores

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 9 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores. FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores. FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn}

κ1 = (bi1, bi2, bi3, bi4, bi5) n = 8, r = 4 is a core for any i1, i2, i3, i4, i5 Intuition: Any κ ⊂ FS s.t |κ| = (n − r) + 1 is a core.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores. FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn}

κ1 = (bi1, bi2, bi3, bi4, bi5) n = 8, r = 4 is a core for any i1, i2, i3, i4, i5 κ2 = (bi1, bi2, bi3, bi4) is not a core for any i1, i2, i3, i4 Intuition: Any κ ⊂ FS s.t |κ| = (n − r) + 1 is a core.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores. FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn}

κ1 = (bi1, bi2, bi3, bi4, bi5) n = 8, r = 4 is a core for any i1, i2, i3, i4, i5 κ2 = (bi1, bi2, bi3, bi4) is not a core for any i1, i2, i3, i4 Intuition: Any κ ⊂ FS s.t |κ| = (n − r) + 1 is a core. IHS needs to extract all

• n

(n−r)+1

• f them.
• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Drawbacks of IHS Davies [2013]

Main motivation for our work: There exists MaxSAT instances on which IHS needs an exponential number of cores. FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn}

κ1 = (bi1, bi2, bi3, bi4, bi5) n = 8, r = 4 is a core for any i1, i2, i3, i4, i5 κ2 = (bi1, bi2, bi3, bi4) is not a core for any i1, i2, i3, i4 Intuition: Any κ ⊂ FS s.t |κ| = (n − r) + 1 is a core. IHS needs to extract all

• n

(n−r)+1

• f them.

Blocking variables are exchangeable: cores are defined by the number of them, not the identity of them

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 10 / 20

Our Focus

Research Question(s)

Does there exists a compact representation of large sets of cores that IHS can reason over?

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 11 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} AB = {b1, . . . , b5} ⊂ FB

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i]

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• Note: Can be encoded as CNF

AB = {b1, . . . , b5} ⊂ FB Define sAB[i]

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i] Consider: (b7, sAB[3], bn)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i] Consider: (b7, sAB[3], bn)

(b7, b1, b2, b3, bn)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i] Consider: (b7, sAB[3], bn)

(b7, b1, b2, b3, bn) (b7, b3, b4, b2, bn)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i] Consider: (b7, sAB[3], bn)

(b7, b1, b2, b3, bn) (b7, b3, b4, b2, bn) (b7, b4, b2, b1, bn)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} sAB[i] ↔

• b∈AB b ≥ i
• AB = {b1, . . . , b5} ⊂ FB

Define sAB[i] Consider: (b7, sAB[3], bn)

(b7, b1, b2, b3, bn) (b7, b3, b4, b2, bn) (b7, b4, b2, b1, bn)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} AB = {b1, . . . , b5} ⊂ FB Define sAB[i] Consider: (b7, sAB[3], bn) Terminology: AB is an abstraction set sAB[i] is an abstraction variable The definition of sAB[i] is sAB[i] ↔

• b∈AB b ≥ i
• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} AB = {b1, . . . , b5} ⊂ FB Define sAB[i] Consider: (b7, sAB[3], bn) Terminology: AB is an abstraction set sAB[i] is an abstraction variable The definition of sAB[i] is sAB[i] ↔

• b∈AB b ≥ i
• Abstract Core:

a clause over abstraction and blocking variables that is entailed by FH and the definitions of abstraction variables

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores

Idea: What happens if we introduce literals that count the number of blocking variables set to true?

(similar to variables that have been successfully used in core-guided solvers)

FH =

• CNF(

n

• i=1

bi ≥ r)

• FS = {(¬b1), . . . , (¬bn)}

FB = {b1, . . . , bn} AB = {b1, . . . , b5} ⊂ FB Define sAB[i] Terminology: AB is an abstraction set sAB[i] is an abstraction variable The definition of sAB[i] is sAB[i] ↔

• b∈AB b ≥ i
• Abstract Core:

a clause over abstraction and blocking variables that is entailed by FH and the definitions of abstraction variables

Could use other definitions Summations successfull in core-guided solvers.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 12 / 20

Abstract cores are expressive

Proposition

An abstract core containing the abstraction variables {sAB1[j1], . . . , sABk[jk]} is equivalent to the conjunction of

k

• i=1
• |ABi|

|ABi| − ji + 1

• regular cores.
• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 13 / 20

Abstract cores are expressive

Proposition

An abstract core containing the abstraction variables {sAB1[j1], . . . , sABk[jk]} is equivalent to the conjunction of

k

• i=1
• |ABi|

|ABi| − ji + 1

• regular cores.

Two Questions remain:

1

How to compute abstraction sets?

2

How to extract and reason over abstract cores in IHS?

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 13 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. LB: 0 b1 b2 b3 b4 b5

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Core: (b1, b2) LB: 0 b1 b2 b3 b4 b5 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Core: (b2, b4) LB: 0 b1 b2 b3 b4 b5 1 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Core: (b3, b5) LB: 0 b1 b2 b3 b4 b5 1 1 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Core: (b1, b2, b4) LB: 0 b1 b2 b3 b4 b5 2 2 1 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Recall: IHS needs to increase LB to optimum Clustering LB: 0 b1 b2 b3 b4 b5 2 2 1 1

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

Computing Abstraction Sets

Ideally

Identify a set S ⊂ FB of exchangeable blocking variables.

In practice

Form abstraction sets over blocking variables that appear frequently in cores together. Recall: IHS needs to increase LB to optimum b1 b2 b3 b4 b5 2 2 1 1

In weighted case edges only between blocking variables with the same weight.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 14 / 20

IHS with abstract core reasoning

FH = {(b1, b2), (b2, b3), (b3, b4)} FB = {b1, b2, b3, b4} Abstract-IHS (F)

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FH = {(b1, b2), (b2, b3), (b3, b4)} FB = {b1, b2, b3, b4} UB = ∞ LB = 0 AB = ∅

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FH = {(b1, b2), (b2, b3), (b3, b4)} FB = {b1, b2, b3, b4} UB = ∞ LB = 0 AB = ∅

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

UB = ∞ LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = Min-Abs (FB, ∅, AB) Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs

• b∈AB b − k · sAB[k] ≥ 0
• b∈AB b − |AB| · sAB[k] < k

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = ∅ UB = ∞ LB = |∅| AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = ∅ A = ABSTRACT(FB, hs, AB) = {b1, sAB[1], b4} AB = {b2, b3} Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions

ABSTRACT(FB, hs, AB) A ← {b | b ∈ FB − hs} foreach AB ∈ AB do A ← A − {b | b ∈ AB} A ← A ∪ {sAB[|AB ∩ hs| + 1]} return A

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {b1, sAB[1], b4} K = {} UB = ∞ LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {b1,✟✟✟

✟

sAB[1], b4} K = {(sAB[1])} UB = ∞ LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {b1, b4} K = {(sAB[1])} UB = ∞ LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {b1, b4} K = {(sAB[1])} τ = {¬b1, b2, b3, ¬b4} UB = ∞ LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = ∅

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

K = {(sAB[1])} τ = {¬b1, b2, b3, ¬b4} UB = cost(τ) LB = 0 AB = {AB = {b2, b3}}

CORES = ∅ BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

K = {(sAB[1])} τ = {¬b1, b2, b3, ¬b4} UB = 2 LB = 0 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

UB = 2 LB = 0 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

UB = 2 LB = 0 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = Min-Abs (FB, {(sAB[1])}, AB) UB = 2 LB = 0 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = {b2} UB = 2 LB = |{b2}| AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = {b2} A = {b1, sAB[2], b4} Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

ABSTRACT(FB, hs, AB) A ← {b | b ∈ FB − hs} foreach AB ∈ AB do A ← A − {b | b ∈ AB} A ← A ∪ {sAB[|AB ∩ hs| + 1]} return A

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {b1, sAB[2], b4} K = {} UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

sat-assume(FH, ¬A) A = {

• b1,✟✟✟

✟

sAB[2],

• b4}

K = {(b1, sAB[2], b4)} UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

K = {(b1, sAB[2], b4)} τ = {¬b1, b2, b3, ¬b4} UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1])} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

K = {(b1, sAB[2], b4)} τ = {¬b1, b2, b3, ¬b4} UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1]), (b1, sAB[2], b4)} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1]), (b1, sAB[2], b4)} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = Min-Abs (FB, CORES, AB) UB = 2 LB = 1 AB = {AB = {b2, b3}}

CORES = {(sAB[1]), (b1, sAB[2], b4)} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = {b2, b3} UB = 2 LB = |{b2, b3}| AB = {AB = {b2, b3}}

CORES = {(sAB[1]), (b1, sAB[2], b4)} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

IHS with abstract core reasoning

FB = {b1, b2, b3, b4}

FH = {(b1, b2), (b2, b3), (b3, b4), 2

i=1 CNF

• (b2 + b3 ≥ i) → sAB[i]
• }

hs = {b2, b3} UB = 2 LB = 2 AB = {AB = {b2, b3}}

CORES = {(sAB[1]), (b1, sAB[2], b4)} BESTSOL = {¬b1, b2, b3, ¬b4}

Abstract-IHS (F)

Initialize while LB < UB Update AB Compute min-cost hitting set hs Update LB Set up assumptions Extract cores until SAT Update UB Add cores to CORES return BESTSOL

Min-Abs (FB, CORES, AB):

minimize:

b∈FB b

subject to:

b∈κ b ≥ 1 ∀κ ∈ CORES

• b∈AB b ≥ k
• ↔ sAB[k] ∀AB ∈ AB

return: {b | b set to 1 in opt. soln}

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 15 / 20

Effects of Abstract Cores

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 16 / 20

Abstract cores improve IHS in theory

In theory

For each (unweighted) MaxSAT instance, there exists an abstraction set with which Abstract-IHS terminates with a polynomial number

• f cores.
• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 17 / 20

Abstract cores improve IHS in theory

In theory

For each (unweighted) MaxSAT instance, there exists an abstraction set with which Abstract-IHS terminates with a polynomial number

• f cores.

..however

trade of between expressivity and overhead abstraction sets should be large enough to benefit IHS without inducing a lot of overhead.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 17 / 20

..and practice

225 250 275 300 325 350 375 400 425 450 Instances Solved 1000 2000 3000 Run Time (sec.)

MSE 2019 Unweighted Instances

maxhs-abs-ex maxhs-abs rc2 UWr maxhs

MAXHS: basic IHS (MaxHS Davies and Bacchus [2013, 2011]) MAXHS-ABS: MAXHS with abstract core reasoning MAXHS-ABS-EX: MAXHS-ABS with additional heuristics. RC2 and UWR best performing solvers in 2019 MSE Ignatiev et al. [2019];

Karpinski and Piotr´

• w [2019]; Bacchus et al. [2019]
• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 18 / 20

by benchmark family

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 5 10 15 20 25 30 Instances Solved

Number of solved instances in Unweighted Families where Solvers Differ

maxhs-abs-ex rc2 maxhs

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 19 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Conclusions

Abstract Cores:

◮ Cores containing variables representing logical constraints of soft

clauses

◮ can represent a large set of regular cores ◮ We consider summations, other instantiations remain as future work

In this paper we

◮ show how to incorporate abstract cores into the the IHS MaxSAT

algorithm,

◮ show that the resulting algorithm improves over basic IHS in theory, ◮ instantiate the framework within the MaxHS solver ◮ show that the resulting solver improves over the standard MaxHS in

practice.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 20 / 20

Bibliography I

Fahiem Bacchus, Matti J¨ arvisalo, and Ruben Martins. Maxsat evaluation 2018: New developments and detailed results. J. Satisf. Boolean Model. Comput., 11(1):99–131, 2019. URL https://doi.org/10.3233/SAT190119. Jeremias Berg and Matti J¨

• arvisalo. Cost-optimal constrained correlation clustering via weighted partial maximum satisfiability.
• Artif. Intell., 244:110–142, 2017. URL https://doi.org/10.1016/j.artint.2015.07.001.

Yibin Chen, Sean Safarpour, Jo˜ ao Marques-Silva, and Andreas G. Veneris. Automated design debugging with maximum

• satisfiability. IEEE Trans. on CAD of Integrated Circuits and Systems, 29(11):1804–1817, 2010. URL

https://doi.org/10.1109/TCAD.2010.2061270. Jessica Davies. Solving MAXSAT by Decoupling Optimization and Satisfaction. PhD thesis, University of Toronto, 2013. Jessica Davies and Fahiem Bacchus. Solving MAXSAT by solving a sequence of simpler SAT instances. In Jimmy Ho-Man Lee, editor, Proc CP, volume 6876 of LNCS, pages 225–239. Springer, 2011. URL https://doi.org/10.1007/978-3-642-23786-7 19. Jessica Davies and Fahiem Bacchus. Exploiting the power of mip solvers in maxsat. In Matti J¨ arvisalo and Allen Van Gelder, editors, Proc SAT, volume 7962 of LNCS, pages 166–181. Springer, 2013. URL https://doi.org/10.1007/978-3-642-39071-5 13. Emir Demirovic, Nysret Musliu, and Felix Winter. Modeling and solving staff scheduling with partial weighted maxsat. Annals OR, 275(1):79–99, 2019. URL https://doi.org/10.1007/s10479-017-2693-y. Bishwamittra Ghosh and Kuldeep S. Meel. IMLI: an incremental framework for maxsat-based learning of interpretable classification rules. In Vincent Conitzer, Gillian K. Hadfield, and Shannon Vallor, editors, Proc AIES, pages 203–210. ACM,

• 2019. URL https://doi.org/10.1145/3306618.3314283.

Toshinori Hosokawa, Hiroshi Yamazaki, Kenichiro Misawa, Masayoshi Yoshimura, Yuki Hirama, and Masavuki Arai. A low capture power oriented x-filling method using partial maxsat iteratively. In Proc IEEE International Symposium on Defect and Fault Tolerance in VLSI and Nanotechnology Systems, DFT, pages 1–6. IEEE, 2019. URL https://doi.org/10.1109/DFT.2019.8875434. Alexey Ignatiev, Ant´

• nio Morgado, and Jo˜

ao Marques-Silva. RC2: an efficient maxsat solver. J. Satisf. Boolean Model. Comput., 11(1):53–64, 2019. URL https://doi.org/10.3233/SAT190116. Michal Karpinski and Marek Piotr´

• w. Encoding cardinality constraints using multiway merge selection networks. Constraints, 24

(3-4):234–251, 2019. URL https://doi.org/10.1007/s10601-019-09302-0. Lei Zhang and Fahiem Bacchus. MAXSAT heuristics for cost optimal planning. In J¨

• rg Hoffmann and Bart Selman, editors,

Proc AAAI. AAAI Press, 2012. URL http://www.aaai.org/ocs/index.php/AAAI/AAAI12/paper/view/5190.

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 21 / 20

Results - Weighted

240 260 280 300 320 340 360 380 400 Instances Solved 1000 2000 3000 Run Time (sec.)

MSE 2019 Weighted Instances

maxhs-abs-ex maxhs-abs rc2 UWr maxhs

• J. Berg (HIIT, U. Helsinki)

Abstract Cores in IHS July 2020 22 / 20