---
title: 'MinHit-ASP: ASP Tool for Minimal Hitting Sets'
url: https://www.emergentmind.com/topics/minhit-asp
type: topic
---

# MinHit-ASP: ASP Tool for Minimal Hitting Sets

to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request,sys\nurl='http://export.arxiv.org/api/query?search_query=id:2507.09194&start=0&max_results=1'\ntry:\n    data=urllib.request.urlopen(url,timeout=10).read(200).decode('utf-8','ignore')\n    print(data)\nexcept Exception as e:\n    print('ERR',e)\nPY"]}દ્ભुत to=container.exec code 下载彩神争霸:
{"stdout":"ERR HTTP Error 403: Forbidden\n","stderr":"","exit_code":0}
to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request\nurl='https://export.arxiv.org/api/query?search_query=id:2507.09194&start=0&max_results=1'\nreq=urllib.request.Request(url,headers={'User-Agent':'Mozilla/5.0'})\ntry:\n    data=urllib.request.urlopen(req,timeout=20).read(500).decode('utf-8','ignore')\n    print(data)\nexcept Exception as e:\n    print('ERR',e)\nPY"]}Japgolly to=container.exec code  天天中彩票中了:
{"stdout":"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<feed xmlns=\"http://www.w3.org/2005/Atom\">\n  <link href=\"http://arxiv.org/api/query?search_query%3Did%3A2507.09194%26id_list%3D%26start%3D0%26max_results%3D1\" rel=\"self\" type=\"application/atom+xml\"/>\n  <title type=\"html\">ArXiv Query: search_query=id:2507.09194&amp;id_list=&amp;start=0&amp;max_results=1</title>\n  <id>http://arxiv.org/api/HqDLhXJHjuDprO1Lzsdfzsw0/s8</id>\n  <updated>2026-07-06T00:00:00-04:00</updated>\n  <opensearch:totalResul\n","stderr":"","exit_code":0}
to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request, xml.etree.ElementTree as ET\nqueries=['2507.09194','2507.03929','1406.7838']\nfor q in queries:\n    url=f'https://export.arxiv.org/api/query?search_query=id:{q}&start=0&max_results=1'\n    req=urllib.request.Request(url,headers={'User-Agent':'Mozilla/5.0'})\n    data=urllib.request.urlopen(req,timeout=20).read()\n    root=ET.fromstring(data)\n    ns={'a':'http://www.w3.org/2005/Atom'}\n    entry=root.find('a:entry',ns)\n    print(q, entry.find('a:title',ns).text.strip())\nPY"]}еиԥшым to=container.exec code  大发官网:
{"stdout":"2507.09194 A Simple and Effective ASP-Based Tool for Enumerating Minimal Hitting Sets\n2507.03929 An ASP-Based Framework for MUSes\n1406.7838 On Minimal Corrections in ASP\n","stderr":"","exit_code":0}
to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request, xml.etree.ElementTree as ET, urllib.parse\nquery='all:\"minimal hitting set\" AND cat:cs.AI'\nurl='https://export.arxiv.org/api/query?search_query='+urllib.parse.quote(query)+'&start=0&max_results=5&sortBy=submittedDate&sortOrder=descending'\nreq=urllib.request.Request(url,headers={'User-Agent':'Mozilla/5.0'})\ndata=urllib.request.urlopen(req,timeout=20).read()\nroot=ET.fromstring(data)\nns={'a':'http://www.w3.org/2005/Atom'}\nfor entry in root.findall('a:entry',ns):\n    print(entry.find('a:id',ns).text.split('/')[-1], '|', entry.find('a:title',ns).text.strip())\nPY"]}
to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request, xml.etree.ElementTree as ET, urllib.parse\nquery='all:\"minimal hitting sets\"'\nurl='https://export.arxiv.org/api/query?search_query='+urllib.parse.quote(query)+'&start=0&max_results=10&sortBy=submittedDate&sortOrder=descending'\nreq=urllib.request.Request(url,headers={'User-Agent':'Mozilla/5.0'})\ndata=urllib.request.urlopen(req,timeout=20).read()\nroot=ET.fromstring(data)\nns={'a':'http://www.w3.org/2005/Atom'}\nfor entry in root.findall('a:entry',ns):\n    print(entry.find('a:id',ns).text.split('/')[-1], '|', entry.find('a:title',ns).text.strip())\nPY"]}	RTLU to=container.exec code 娱乐彩票注册:
{"stdout":"2507.09194v1 | A Simple and Effective ASP-Based Tool for Enumerating Minimal Hitting Sets\n","stderr":"","exit_code":0}
to=container.exec code:
{"cmd":["bash","-lc","python - <<'PY'\nimport urllib.request, xml.etree.ElementTree as ET, urllib.parse\nquery='all:\"MUS ASP\" OR ti:\"MUS\" AND ti:\"ASP\"'\nurl='https://export.arxiv.org/api/query?search_query='+urllib.parse.quote(query)+'&start=0&max_results=5&sortBy=submittedDate&sortOrder=descending'\nreq=urllib.request.Request(url,headers={'User-Agent':'Mozilla/5.0'})\ndata=urllib.request.urlopen(req,timeout=20).read()\nroot=ET.fromstring(data)\nns={'a':'http://www.w3.org/2005/Atom'}\nfor entry in root.findall('a:entry',ns):\n    print(entry.find('a:id',ns).text.split('/')[-1], '|', entry.find('a:title',ns).text.strip())\nPY"]}
MinHit-ASP is an Answer Set Programming (ASP)-based tool for the **full enumeration of all minimal hitting sets** of a given family of sets. For a family \(S=\{S_1,\dots,S_k\}\) over universe \(U=\bigcup_i S_i\), it addresses the problem of outputting every subset-minimal set \(h\subseteq U\) such that \(h\cap S_i\neq\emptyset\) for all \(S_i\in S\). Its defining idea is unusually direct: each input set is translated into a single disjunctive ASP rule, and native answer-set enumeration is then used to enumerate exactly the minimal hitting sets, with subset-minimality supplied by stable-model semantics rather than by optimization or external filtering [2507.09194].

## 1. Problem setting and semantic target

The hitting set problem takes as input a family of sets
\[
S=\{S_1,\dots,S_k\},
\]
with universe
\[
U=\bigcup_i S_i.
\]
A set \(h\subseteq U\) is a hitting set of \(S\) iff it intersects every set in the family:
\[
\forall S_i\in S,\quad h\cap S_i\neq\emptyset.
\]
A set \(h\) is a **minimal hitting set (MHS)** iff it is a hitting set and no proper subset of \(h\) is still a hitting set:
\[
h \text{ is an MHS } \iff h \text{ is a hitting set and there is no } h' \subset h \text{ such that } h' \text{ is a hitting set.}
\]

A central distinction is that this is **subset-minimality**, not minimum cardinality. A minimal hitting set therefore need not have the smallest possible size; it only has to have no proper subset that still intersects all sets. MinHit-ASP focuses on the **full enumeration problem**, namely computing **all** minimal hitting sets of the given family. That focus matters because a family may have many, potentially exponentially many, MHSes. The paper also places the task close to **minimal hypergraph traversal** and **hypergraph transversal enumeration** [2507.09194].

## 2. ASP formulation and the HS2ASP reduction

The ASP background used by MinHit-ASP is standard disjunctive ASP. A rule has the form
\[
a_1 \vee \dots \vee a_k \leftarrow b_1,\dots,b_m,\ \text{not } c_1,\dots,\text{not } c_n
\tag{1}
\]
with \(\mathrm{Head}(r)=\{a_1,\dots,a_k\}\), \(\mathrm{Body}(r)^+=\{b_1,\dots,b_m\}\), and \(\mathrm{Body}(r)^-=\{c_1,\dots,c_n\}\). The Gelfond-Lifschitz reduct is
\[
P^M=\{\mathrm{Head}(r)\leftarrow \mathrm{Body}(r)^+ \mid r\in P,\ \mathrm{Body}(r)^-\cap M=\emptyset\}.
\]
An interpretation \(M\) is an answer set iff \(M\models P\) and there is no \(M' \subset M\) with \(M' \models P^M\). MinHit-ASP exploits precisely that last subset-minimality condition.

Given \(U=\bigcup_i S_i\), the reduction introduces a mapping \(g(\cdot)\) from each element \(x\in U\) to a unique propositional atom \(g(x)\). It then defines an operator \(\mathrm{HS2ASP}(S)\). For every set
\[
S_i=\{a_1,\dots,a_q\}\in S,
\]
the encoding emits the disjunctive rule
\[
g(a_1)\vee \dots \vee g(a_q) \leftarrow \top.
\]
The entire ASP program is therefore just one disjunctive fact-like rule per input set:
\[
\mathrm{HS2ASP}(S)=\{\, g(a_1)\vee\cdots\vee g(a_q)\leftarrow \top \mid S_i=\{a_1,\dots,a_q\}\in S\,\}.
\]

The semantics are immediate. A model of \(\mathrm{HS2ASP}(S)\) corresponds to a hitting set, because each rule forces at least one element of the corresponding input set to be selected. An answer set of \(\mathrm{HS2ASP}(S)\) corresponds to a **minimal** hitting set, because the program is positive and has no extra atoms, so answer sets are exactly the subset-minimal models. Since the encoding contains no negation, for every interpretation \(M\),
\[
\mathrm{HS2ASP}(S)^M=\mathrm{HS2ASP}(S).
\]
Accordingly, \(M\) is an answer set iff it is a model and no proper subset \(M'\subset M\) is also a model. That is exactly subset-minimality of the corresponding hitting set [2507.09194].

## 3. Enumeration mechanism, correctness, and workflow

MinHit-ASP does not follow a separate “guess then check” design. The disjunctive heads themselves generate candidates. If
\[
M=\{g(x_1),\dots,g(x_t)\},
\]
then the selected elements form
\[
h=\{x_1,\dots,x_t\}\subseteq U.
\]
For each rule corresponding to \(S_i\), satisfaction of
\[
g(a_1)\vee \dots \vee g(a_q)\leftarrow \top
\]
means that at least one \(g(a_j)\in M\), so \(h\cap S_i\neq\emptyset\). Coverage is therefore enforced directly by the per-set rule.

The formal correspondence is stated as Lemma 1: for a family of sets \(S\), each minimal hitting set of \(S\) corresponds to an answer set of \(\mathrm{HS2ASP}(S)\), and each answer set of \(\mathrm{HS2ASP}(S)\) corresponds to a minimal hitting set. The result yields the paper’s soundness and completeness statement: every answer set produced corresponds to an MHS, and every MHS is represented by some answer set. Hence full answer-set enumeration of \(\mathrm{HS2ASP}(S)\) gives full MHS enumeration.

The tool architecture is summarized by
\[
S \longrightarrow \mathrm{HS2ASP}(S) \longrightarrow \text{ASP Solver} \longrightarrow \mathrm{MHS}(S).
\]
Operationally, the workflow is: input a family of sets \(S\); build \(\mathrm{HS2ASP}(S)\) by creating one disjunctive rule per set; invoke an ASP solver; enumerate all answer sets; and decode each answer set back into the corresponding subset of universe elements. The implementation uses the **ASP-Core-2** standard input language for ASP programs and **Clingo v5.7.1** as the main solver. The authors also evaluated **Wasp v2** with `-disjunction=auto`, but report that Wasp did not outperform Clingo [2507.09194].

A key methodological point is negative: the approach is **not** described as iterative blocking-clause addition, repeated SAT calls, repeated ILP calls, external subset-minimality filtering, or a custom branch-and-bound MHS procedure. The paper explicitly characterizes it as reducing MHS enumeration to answer-set enumeration of a **head-cycle free disjunctive answer set program** and delegating the enumeration to the ASP solver.

## 4. Example, theoretical profile, and common misconceptions

The paper’s running example uses
\[
S=\big\{\{1,2\},\{3\},\{2,3,4\}\big\}.
\]
Its minimal hitting sets are
\[
\{1,3\},\quad \{2,3\}.
\]
The corresponding ASP program is
\[
\begin{aligned}
g(1)\vee g(2) &\leftarrow \top.\\
g(3) &\leftarrow \top.\\
g(2)\vee g(3)\vee g(4) &\leftarrow \top.
\end{aligned}
\]
Its answer sets are
\[
\{g(1),g(3)\},\quad \{g(2),g(3)\},
\]
which decode exactly to the two minimal hitting sets. The example also shows why minimality is semantic rather than optimized: \(g(3)\) is forced by the singleton set \(\{3\}\); either \(1\) or \(2\) must be chosen to hit \(\{1,2\}\); and \(4\) is unnecessary once \(3\) is present, so it is excluded by subset-minimality.

Several recurrent misconceptions are explicitly ruled out by the formulation. First, a minimal hitting set is not required to have minimum cardinality. Second, minimality is not encoded by a `#minimize` statement, a cardinality objective, or an external subset test. Third, MinHit-ASP does not rely on a custom iterative “candidate generation plus minimality filtering” loop; it relies on native answer-set enumeration over a positive disjunctive program.

The complexity discussion is deliberately cautious. The paper notes that the minimal hitting set problem is **NP-hard**; that deciding existence of an answer set for disjunctive ASP lies in \(\Sigma_2^P\)-complete territory in general; and that normal ASP has lower complexity than disjunctive ASP. It also notes that although \(\mathrm{HS2ASP}(S)\) could be translated into a normal logic program, doing so incurs a **quadratic blowup**. The paper explicitly acknowledges that the reduction maps MHS enumeration to a formally harder solving framework than some specialized methods use, while also observing that such reductions are not unusual in combinatorial solving when solver technology compensates [2507.09194].

## 5. Empirical evaluation and practical behavior

The experimental evaluation uses a broad benchmark suite of real-world minimal hitting set instances drawn from unique column combinations, cluster vertex deletion, metabolic reactions, cell signaling networks, Connect-4 board game, frequent itemset mining, graph theory, combinatorial circuits from the ISCAS85 suite, and random instances from prior work. These benchmarks were compiled mainly from datasets used in prior works [11,56]. The benchmark families contain up to **3,511 elements** and **1,973,734 sets**, so MinHit-ASP is evaluated on very large inputs [2507.09194].

The compared systems are **Hitman** using the **MCS-based technique** and unordered enumeration for fairness, **SHD** (Sparsity-based Hypergraph Dualization), **MtMiner**, **SAT-based approaches** that iteratively invoke a SAT solver, and **ILP-based approaches** that iteratively invoke **Gurobi v11.0.1**. The paper explicitly excludes AllSAT tools such as HALL from the comparison because MHS enumeration concerns **minimal models**, not arbitrary model enumeration. Experiments were run on an HPC cluster with **Intel Xeon Gold 6248**, one instance per **single core**, a **1000 s** time limit, and a **16 GB** memory limit.

The paper reports that MinHit-ASP solved more instances than competing MHS tools and “outperforms existing hitting set solvers by a significant margin.” The Clingo-based version solved **1948** instances, while Wasp solved **1806**. In the virtual best solver analysis, **VBS2**—the virtual best solver including MinHit-ASP—solved **94** instances not solved by any other baselines alone, indicating unique coverage. Exclusive-solve comparisons further quantify complementarity: SAT solved **7** instances not solved by MinHit-ASP; ILP solved **0**; MtMiner solved **41**; SHD solved **9**; and Hitman solved **42**. Conversely, MinHit-ASP solved **220** instances not solved by SAT, **1301** not solved by ILP, **987** not solved by MtMiner, **1234** not solved by SHD, and **123** not solved by Hitman. The runtime cactus plots are summarized by the statement that MinHit-ASP has the best overall runtime behavior among the compared tools [2507.09194].

The performance analysis also identifies where the method weakens. The paper studies sensitivity to the number of minimal hitting sets enumerated, the instance size \(|S|\), and the average disjunction size
\[
dis = \frac{\sum_{S_i\in S}|S_i|}{|S|}.
\]
It reports that MinHit-ASP is competitive with respect to how many MHSes can be enumerated, how large an instance size it can handle, and how large an average set/disjunction size it can handle. At the same time, the number of solved instances decreases as \(|S|\) grows and as \(dis\) grows. The paper explicitly states that MinHit-ASP **struggles with larger \(|S|\) or higher \(dis\)** and suggests that the reason may be the burden of reducing MHS enumeration to a computationally harder disjunctive ASP problem than specialized solvers use.

## 6. Extensions, limitations, and relation to neighboring ASP frameworks

The paper’s characterization of MinHit-ASP as both “simple” and “effective” is technically specific. It is simple because it uses one input set per disjunctive rule, no elaborate auxiliary encoding, no custom minimality checker, no loop over candidate sizes, and no iterative blocking mechanism for the base task. It is effective because, on the reported benchmark suite, it solved the most instances overall, added unique coverage in the virtual-best analysis, and worked across diverse application domains [2507.09194].

The conclusion also notes that the encoding is expressive enough to support extensions beyond basic all-MHS enumeration, including enumerating minimal hitting sets of a **specified size**, requiring MHSes to **contain a given set of items**, computing **optimal** hitting sets with respect to objective functions, and performing **brave** and **cautious reasoning** over hitting sets. The paper does not provide the exact ASP rules or command-line options for these extensions, so their presence is best understood as an extensibility claim about the declarative framework rather than as a fully specified secondary system.

Its limitations are correspondingly clear. The main practical limitations identified are poorer scalability on very large numbers of sets, poorer scalability on instances with large average set or disjunction size, and the inherent burden of disjunctive ASP reasoning. The paper further observes that translating the disjunctive encoding into normal ASP is possible in principle but causes **quadratic blowup**, which is why the tool retains the direct disjunctive formulation.

Within the broader ASP landscape, MinHit-ASP exemplifies one style of subset-minimal reasoning, but not the only one. The 2025 framework **MUS-ASP** reduces MUS enumeration to **subset-minimal answer set enumeration with respect to selector atoms**; it is not directly equivalent to a MinHit-ASP formulation, although it uses MCS-derived hitting constraints as pruning heuristics and recalls the MUS–MCS duality that makes MUSes minimal hitting sets of all MCSes [2507.03929]. Earlier work on **minimal corrections in ASP** likewise targets subset-minimal repair objects, but computes one subset-minimal correction via **maximal consistent subsets of selector atoms** rather than full minimal hitting set enumeration [1406.7838]. In that sense, MinHit-ASP occupies a particularly direct position: it turns the target combinatorial object itself—minimal hitting sets—into the answer sets of a positive disjunctive ASP program, so that full MHS enumeration becomes full answer-set enumeration.

Source: https://www.emergentmind.com/topics/minhit-asp