satzilla 0.0.1__py3-none-any.whl

satzilla-0.0.1.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: satzilla
+Version: 0.0.1
+Summary: Python wrapper for the Revisiting SATZilla 2024 feature extractor
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: pysat
+Requires-Dist: python-sat; extra == "pysat"
+
+
+# Revisiting SATZilla in 2024
+
+  
+Code for the paper: "Revisiting SATZilla Features in 2024" by Hadar Shavit and Holger H. Hoos accepted to SAT 2024.
+
+## Abstract
+Boolean satisfiability (SAT) is an $\mathcal{NP}$-complete problem with important applications, notably in hardware and software verification.
+Characterising a SAT instance by a set of features has shown great potential for various tasks, ranging from algorithm selection to benchmark generation.
+In this work, we revisit the widely used SATZilla features and introduce a new version of the tool used to compute them.  
+In particular, we utilise a new preprocessor and SAT solvers, adjust the code to accommodate larger formulas, and determine better settings of the feature extraction time limits.
+We evaluate the extracted features on three downstream tasks: satisfiability prediction, running time prediction, and algorithm selection. 
+We observe that our new tool is able to extract features from a broader range of instances than before. 
+We show that the new version of the feature extractor produces features that achieve up to $25\%$ lower RMSE for running time prediction, up to $5\%$ higher accuracy for satisfiability prediction, and up to $80\%$ higher closed gap for algorithm selection on benchmarks from recent SAT competitions.
+
+
+## Usage
+We provide precompiled binaries for the SATZilla feature extraction tool for linux. Currently the SATZilla features extractor supports only linux.
+
+SAT-feature-computation code contains the new SATZilla feature extraction tool.
+
+Recompile by running `make`, then the executable `features` will be created.
+
+To run a package-level smoke test for the extractor, use `make test` inside `SAT-features-competition2024`.
+
+To compute features, simply run `./features [--timeout SECONDS] [--group-timeout SECONDS] [--preprocess-timeout SECONDS] [-base] [-structure] [-ncnf-graphs] [-ncnf-constraints] [-ncnf-rwh] [-dia] [-ls] [-lp] [-lobjois] INFILE OUTFILE`
+Where -lp, -dia etc are the feature groups:
+
+ - base: Base feature group, including pre, KLB, and clause graph
+ - structure: Structural features from SATfeatPy
+ - ncnf-graphs: New-CNF graph features
+ - ncnf-constraints: New-CNF constraint features
+ - ncnf-rwh: New-CNF recursive weight heuristic features
+ - dia: Diameter
+ - ls: Local search (both GSAT and Sparrow)
+ - lp: Linear programming
+ - lobjois: Lobjois
+ -  cl: Clause learning
+ - unit: Unit propagation
+ - sp: Survey propagation
+
+  To compute all features use the -all option.
+  The input INFILE is a DIMACS CNF file. NOTE: currently, only raw CNF files are supported, and not compressed one (like .cnf.xz)
+  The output is a CSV file containing the features for one instance.
+
+Timeout controls:
+- `--timeout`: total extraction timeout
+- `--group-timeout`: per-feature-group timeout override; timed-out groups emit reserved values and extraction continues with the next selected group
+- `--preprocess-timeout`: timeout override for the preprocessing step
+
+## Python Interface
+Install from PyPI:
+
+```bash
+pip install satzilla
+```
+
+An importable Python interface is available in the `satzilla_features` package. It accepts PySAT `CNF` formulas directly and
+calls the extractor through a bundled shared library using `ctypes`; it does not shell out to the CLI.
+
+PySAT documents that `pysat.formula.CNF` exposes `clauses` and `nv`, and supports DIMACS I/O:
+https://pysathq.github.io/docs/html/api/formula.html
+
+Example:
+
+```python
+from pysat.formula import CNF
+from satzilla_features import extract_features
+
+cnf = CNF(from_clauses=[[-1, 2], [-2, 3], [1, 3]])
+features = extract_features(
+    cnf,
+    groups=["base", "structure", "ncnf-graphs"],
+    group_timeout=180,
+)
+print(features["variable_alpha"])
+```
+
+You can also extract directly from a CNF file path with `extract_features_from_path(...)`.
+Both Python entry points accept `timeout=...`, `group_timeout=...`, and `preprocess_timeout=...`.
+
+When building the Python package, the C/C++ extractor is compiled into `libsatzilla_features.so` and packaged together with the
+solver binaries it needs at runtime. The direct Python interface is currently Linux-only.
+
+
+## Experiments
+rt_pred.py contains the code for running time prediction. sat_pred.py contains the code for satisfiability prediction. Both are using submitit for execution on a SLURM cluster.
+For algorithm selection, the scenarios are available in the aslib directory. The AutoFolio code is available at https://github.com/hadarshavit/AutoFolio.
+## Contact
+To contact us, please send an email to [shavit@aim.rwth-aachen.de](mailto:shavit@aim.rwth-aachen.de)

satzilla-0.0.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+satzilla_features/__init__.py,sha256=Xa1580axPuw-I_q7zzFuZ4lb8BBwaoOKhyF-yn01Ti0,282
+satzilla_features/api.py,sha256=uNMNZPEBX2PU7cVotW85lBJ9RQiBqE-80nPm6wA5HFg,9306
+satzilla_features/liblpk5.so,sha256=V5qjAP_9qRikNbcTyxpRQLsBv82qupQ0xW5TSLCKxc0,1480072
+satzilla_features/libsatzilla_features.so,sha256=fpVljd1mQ18MVjWUpkedMSp7lHEXIqDfubve2pvzCPU,2919080
+satzilla_features/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+"satzilla_features/satzilla_Solvers/best[mean+cv],firstlmstep[mean+median+cv+q10+q90],bestavgimpr[mean+cv],firstlmratio[mean+cv],estacl",sha256=nGuNoGc5pt6tiUyj0z6-NX-AmD1NDU35i9rE1ic3i-M,313
+satzilla_features/satzilla_Solvers/cadical2023,sha256=RX2gIx4RRTAMwsOm7-hyoCqnbx-Sh7sAsKESpFCVTBQ,1049976
+satzilla_features/satzilla_Solvers/kissatexe,sha256=Q6doDsp3l9USOvTCd_DHjrVOgeK9IATRbdFCvsgwCWA,375384
+satzilla_features/satzilla_Solvers/oo,sha256=cAeN1OZzf9k33AVT32hvawA2tlmEZe99-GZBuVz9NHI,412
+satzilla_features/satzilla_Solvers/out,sha256=pkDEYH-3HjguD_HcB3v8XIiL3ESkGySg5L8ZC4coqy4,487
+satzilla_features/satzilla_Solvers/satelite,sha256=OSWB1xB1h6act5XwV33GMBWJmf8fkKNzfkfUfd4yuO0,598625
+satzilla_features/satzilla_Solvers/sbva,sha256=YkbdMdmi-SDBtoQeJ6GACMpzXwjPkJoVJ7jnNHkwttk,76736
+satzilla_features/satzilla_Solvers/sol,sha256=yea9sjc-dqyQizdCmE8jxIGbNzJC3YxcOH-J0_i9W-c,942
+satzilla_features/satzilla_Solvers/ubcsat2006,sha256=xS-FRWGyG6p5U-j91VbkRol9xdWMVD-Ix1yYSTZv4zI,505432
+satzilla_features/satzilla_Solvers/ubcsatold,sha256=RWjPLb2OFxSTu4-JLiZOFxrekmifXxrlAIOVV33Nei0,300691
+satzilla_features/satzilla_Solvers/yalsat-03v.zip,sha256=WWrZ63Kd39Z8Ilatsg_41NnXAYAE2Dj2tORJuLW-Qmo,33679
+satzilla_features/satzilla_Solvers/zchaff07,sha256=6gVBR0gZ_VU_612QFL0xlh6kMT1aDsVSZsAFBXMCMVk,2056894
+satzilla_features/satzilla_Solvers/zchaff_rand,sha256=aB3o0UcZP-qhU35i4UpHNhYky3gTCXqgqxRRKuruhjk,3341970
+satzilla_features/satzilla_Solvers/yalsat-03v/FILES,sha256=9e4Pzm9BijPbbrDj1X3IzxltN5CVbtZ6YLN49V0BRA4,703
+satzilla_features/satzilla_Solvers/yalsat-03v/LICENSE,sha256=Wu3iswNOpb5qA_hyw0pcVmozy8USy3wbBNdheT-vtUs,1090
+satzilla_features/satzilla_Solvers/yalsat-03v/README,sha256=_gUo9eQ8SHupuYEk05racU-KTgM8dp12TpdIgUxVrzk,356
+satzilla_features/satzilla_Solvers/yalsat-03v/VERSION,sha256=TRS5JySS2dhPbgVwaipCl6BZ6d8g2Fa21UcHIFKszyQ,4
+satzilla_features/satzilla_Solvers/yalsat-03v/cflags.h,sha256=IdtxN2cPnGIkWKeGIknhSVi5AvcmktyM0pQcGi_VTCU,76
+satzilla_features/satzilla_Solvers/yalsat-03v/config.c,sha256=xPCfAYPp-hefVUNJSM-Ov3FlyQDEj03yTcnBYNa90HU,754
+satzilla_features/satzilla_Solvers/yalsat-03v/config.h,sha256=02STwvv6kFEJZDFc4dTqhVV_PHT09kscIN8pJVynn3Y,464
+satzilla_features/satzilla_Solvers/yalsat-03v/configure.sh,sha256=ze3D7T4I4sMPgKBfhogOK_dOAPQaqAeSEY1hFZnIpzE,1228
+satzilla_features/satzilla_Solvers/yalsat-03v/main.c,sha256=dLM7dEPKFFrtAJcKpxpD6dFJtxGbv3qw_SqiUawqmkQ,22977
+satzilla_features/satzilla_Solvers/yalsat-03v/makefile,sha256=Qy91rAi1Os3KQZLNsy6oxnm3e-z_D06a2zeKWiW7eWk,929
+satzilla_features/satzilla_Solvers/yalsat-03v/makefile.in,sha256=biQxUBT1KqiwOer3UaguE5LL1Uhp1nkScgQlWQ9q6WI,923
+satzilla_features/satzilla_Solvers/yalsat-03v/mkconfig.sh,sha256=E1SzKMUUBec707fNwJRxDTGJSgYOFJCEIaepmNxvts8,571
+satzilla_features/satzilla_Solvers/yalsat-03v/palsat,sha256=AZgJznjrnaeV4djAvQ496HPxQY5uuUKT0ZPbVnhqYdM,113144
+satzilla_features/satzilla_Solvers/yalsat-03v/yals.c,sha256=AIAkKKKMScSyanv7HOI7xluVcTRNzT96f8zqiA-aDoE,104236
+satzilla_features/satzilla_Solvers/yalsat-03v/yals.h,sha256=fCn_oDP_A8yu7C1F6nGg3jmF8qLg7A1m8MAap-cW8iE,2289
+satzilla_features/satzilla_Solvers/yalsat-03v/yalsat,sha256=g9rcj5fPvE49LZ2V_ha3yePad9CHA9ejbKOhbLLPBnA,99928
+satzilla_features/satzilla_Solvers/yalsat-03v/yils.h,sha256=9X8d5L3CoKM84abB7edgTJhLeNUt5dxZDmma3wPmFGU,1681
+satzilla-0.0.1.dist-info/METADATA,sha256=MvYPbSquzPuTuFK0fB2M7_9p7grKBZ9Fwv6RcAC6OCU,4860
+satzilla-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+satzilla-0.0.1.dist-info/top_level.txt,sha256=btiM7kEXFZEzdVsfMt4LxylSzVNaxtXs4SIYKq0bScs,18
+satzilla-0.0.1.dist-info/RECORD,,

satzilla-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

satzilla-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+satzilla_features

satzilla_features/__init__.py

@@ -0,0 +1,15 @@
+from .api import (
+    ALL_GROUPS,
+    DEFAULT_GROUPS,
+    FeatureExtractionError,
+    extract_features,
+    extract_features_from_path,
+)
+
+__all__ = [
+    "ALL_GROUPS",
+    "DEFAULT_GROUPS",
+    "FeatureExtractionError",
+    "extract_features",
+    "extract_features_from_path",
+]

satzilla_features/api.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import ctypes
+import subprocess
+from pathlib import Path
+from typing import Iterable, Mapping, Sequence
+
+
+_PACKAGE_DIR = Path(__file__).resolve().parent
+_REPO_ROOT = _PACKAGE_DIR.parent
+_FEATURES_DIR = _REPO_ROOT / "SAT-features-competition2024"
+_SOURCE_SHARED_LIBRARY = _FEATURES_DIR / "libsatzilla_features.so"
+_PACKAGE_SHARED_LIBRARY = _PACKAGE_DIR / "libsatzilla_features.so"
+
+ALL_GROUPS = (
+    "all",
+    "base",
+    "structure",
+    "ncnf-graphs",
+    "ncnf-constraints",
+    "ncnf-rwh",
+    "sp",
+    "dia",
+    "cl",
+    "lp",
+    "unit",
+    "ls",
+    "lobjois",
+)
+
+DEFAULT_GROUPS: tuple[str, ...] = ()
+
+
+class FeatureExtractionError(RuntimeError):
+    pass
+
+
+class _COptions(ctypes.Structure):
+    _fields_ = [
+        ("do_base", ctypes.c_int),
+        ("do_structure", ctypes.c_int),
+        ("do_ncnf_graphs", ctypes.c_int),
+        ("do_ncnf_constraints", ctypes.c_int),
+        ("do_ncnf_rwh", ctypes.c_int),
+        ("do_unit_probe", ctypes.c_int),
+        ("do_ls_probe", ctypes.c_int),
+        ("do_cl", ctypes.c_int),
+        ("do_dia", ctypes.c_int),
+        ("do_sp", ctypes.c_int),
+        ("do_lobjois", ctypes.c_int),
+        ("do_lp", ctypes.c_int),
+        ("timeout_seconds", ctypes.c_int),
+        ("group_timeout_seconds", ctypes.c_int),
+        ("preprocess_timeout_seconds", ctypes.c_int),
+        ("solver_root", ctypes.c_char_p),
+    ]
+
+
+class _CResult(ctypes.Structure):
+    _fields_ = [
+        ("status_code", ctypes.c_int),
+        ("feature_count", ctypes.c_size_t),
+        ("feature_names", ctypes.POINTER(ctypes.c_char_p)),
+        ("feature_values", ctypes.POINTER(ctypes.c_double)),
+        ("error_message", ctypes.c_char_p),
+    ]
+
+
+_GROUP_ATTRS = {
+    "base": "do_base",
+    "structure": "do_structure",
+    "ncnf-graphs": "do_ncnf_graphs",
+    "ncnf-constraints": "do_ncnf_constraints",
+    "ncnf-rwh": "do_ncnf_rwh",
+    "unit": "do_unit_probe",
+    "ls": "do_ls_probe",
+    "cl": "do_cl",
+    "dia": "do_dia",
+    "sp": "do_sp",
+    "lobjois": "do_lobjois",
+    "lp": "do_lp",
+}
+
+_LIB = None
+
+
+def _normalize_groups(groups: Iterable[str] | None) -> list[str]:
+    if groups is None:
+        return []
+
+    normalized = []
+    for group in groups:
+        key = group.strip().lower()
+        if key not in ALL_GROUPS:
+            raise ValueError(
+                f"unknown feature group {group!r}; expected one of {', '.join(ALL_GROUPS)}"
+            )
+        normalized.append(key)
+    return normalized
+
+
+def _candidate_library_paths() -> list[Path]:
+    return [_PACKAGE_SHARED_LIBRARY, _SOURCE_SHARED_LIBRARY]
+
+
+def _find_default_solver_root(lib_path: Path) -> Path:
+    package_candidate = lib_path.parent
+    if (package_candidate / "satzilla_Solvers").exists():
+        return package_candidate
+    return _FEATURES_DIR
+
+
+def _ensure_shared_library(build_if_missing: bool) -> Path:
+    for candidate in _candidate_library_paths():
+        if candidate.exists():
+            return candidate
+
+    if not build_if_missing:
+        raise FileNotFoundError(
+            "shared feature extractor library not found. "
+            "Build it with `make shared` in SAT-features-competition2024."
+        )
+
+    completed = subprocess.run(
+        ["make", "shared"],
+        cwd=_FEATURES_DIR,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    if completed.returncode != 0:
+        raise FeatureExtractionError(
+            "failed to build shared feature extractor with `make shared`\n"
+            f"stdout:\n{completed.stdout}\n"
+            f"stderr:\n{completed.stderr}"
+        )
+
+    for candidate in _candidate_library_paths():
+        if candidate.exists():
+            return candidate
+
+    raise FileNotFoundError("`make shared` completed but no shared library was found")
+
+
+def _load_library(build_if_missing: bool):
+    global _LIB
+    if _LIB is not None:
+        return _LIB
+
+    library_path = _ensure_shared_library(build_if_missing)
+    lib = ctypes.CDLL(str(library_path))
+    lib.satzilla_extract_from_dimacs_path.argtypes = [
+        ctypes.c_char_p,
+        ctypes.POINTER(_COptions),
+        ctypes.POINTER(_CResult),
+    ]
+    lib.satzilla_extract_from_dimacs_path.restype = ctypes.c_int
+    lib.satzilla_extract_from_clauses.argtypes = [
+        ctypes.c_int,
+        ctypes.c_size_t,
+        ctypes.POINTER(ctypes.c_int),
+        ctypes.POINTER(ctypes.c_size_t),
+        ctypes.POINTER(_COptions),
+        ctypes.POINTER(_CResult),
+    ]
+    lib.satzilla_extract_from_clauses.restype = ctypes.c_int
+    lib.satzilla_free_result.argtypes = [ctypes.POINTER(_CResult)]
+    lib.satzilla_free_result.restype = None
+    _LIB = lib
+    return lib
+
+
+def _extract_cnf_data(cnf: object) -> tuple[Sequence[Sequence[int]], int]:
+    clauses = getattr(cnf, "clauses", None)
+    nv = getattr(cnf, "nv", None)
+    if clauses is None or nv is None:
+        raise TypeError(
+            "expected a PySAT CNF-like object exposing `clauses` and `nv`"
+        )
+    return clauses, int(nv)
+
+
+def _build_options(
+    groups: Sequence[str],
+    timeout: int | None,
+    group_timeout: int | None,
+    preprocess_timeout: int | None,
+    solver_root: str | Path | None,
+    build_if_missing: bool,
+) -> _COptions:
+    lib_path = _ensure_shared_library(build_if_missing)
+    resolved_solver_root = (
+        Path(solver_root) if solver_root is not None else _find_default_solver_root(lib_path)
+    )
+
+    options = _COptions()
+    for group in groups:
+        if group == "all":
+            for attr in _GROUP_ATTRS.values():
+                setattr(options, attr, 1)
+        else:
+            setattr(options, _GROUP_ATTRS[group], 1)
+
+    options.timeout_seconds = -1 if timeout is None else int(timeout)
+    options.group_timeout_seconds = -1 if group_timeout is None else int(group_timeout)
+    options.preprocess_timeout_seconds = -1 if preprocess_timeout is None else int(preprocess_timeout)
+    options.solver_root = str(resolved_solver_root).encode("utf-8")
+    return options
+
+
+def _decode_result(result: _CResult) -> Mapping[str, float]:
+    features: dict[str, float] = {}
+    for idx in range(result.feature_count):
+        name = result.feature_names[idx].decode("utf-8")
+        features[name] = result.feature_values[idx]
+    return features
+
+
+def _raise_if_failed(status: int, result: _CResult) -> None:
+    if status == 0 and result.status_code == 0:
+        return
+
+    if result.error_message:
+        message = ctypes.cast(result.error_message, ctypes.c_char_p).value.decode("utf-8")
+    else:
+        message = f"feature extraction failed with status {status or result.status_code}"
+    raise FeatureExtractionError(message)
+
+
+def extract_features(
+    cnf: object,
+    *,
+    groups: Iterable[str] | None = None,
+    timeout: int | None = None,
+    group_timeout: int | None = None,
+    preprocess_timeout: int | None = None,
+    solver_root: str | Path | None = None,
+    build_if_missing: bool = True,
+) -> Mapping[str, float]:
+    """
+    Extract SAT features for a PySAT CNF-like object.
+
+    PySAT documents `CNF` formulas in the `formula` module and exposes CNF data
+    through the formula object interface used here (`clauses` and `nv`).
+    Source: https://pysathq.github.io/docs/html/api/formula.html
+    """
+
+    clauses, nv = _extract_cnf_data(cnf)
+    normalized_groups = _normalize_groups(groups)
+    options = _build_options(
+        normalized_groups,
+        timeout,
+        group_timeout,
+        preprocess_timeout,
+        solver_root,
+        build_if_missing,
+    )
+    lib = _load_library(build_if_missing)
+
+    flat_literals: list[int] = []
+    clause_offsets = [0]
+    for clause in clauses:
+        flat_literals.extend(int(lit) for lit in clause)
+        clause_offsets.append(len(flat_literals))
+
+    literal_array = (ctypes.c_int * len(flat_literals))(*flat_literals) if flat_literals else None
+    offset_array = (ctypes.c_size_t * len(clause_offsets))(*clause_offsets)
+    result = _CResult()
+    try:
+        status = lib.satzilla_extract_from_clauses(
+            int(nv),
+            len(clauses),
+            literal_array,
+            offset_array,
+            ctypes.byref(options),
+            ctypes.byref(result),
+        )
+        _raise_if_failed(status, result)
+        return _decode_result(result)
+    finally:
+        lib.satzilla_free_result(ctypes.byref(result))
+
+
+def extract_features_from_path(
+    cnf_path: str | Path,
+    *,
+    groups: Iterable[str] | None = None,
+    timeout: int | None = None,
+    group_timeout: int | None = None,
+    preprocess_timeout: int | None = None,
+    solver_root: str | Path | None = None,
+    build_if_missing: bool = True,
+) -> Mapping[str, float]:
+    normalized_groups = _normalize_groups(groups)
+    options = _build_options(
+        normalized_groups,
+        timeout,
+        group_timeout,
+        preprocess_timeout,
+        solver_root,
+        build_if_missing,
+    )
+    lib = _load_library(build_if_missing)
+
+    result = _CResult()
+    try:
+        status = lib.satzilla_extract_from_dimacs_path(
+            str(cnf_path).encode("utf-8"),
+            ctypes.byref(options),
+            ctypes.byref(result),
+        )
+        _raise_if_failed(status, result)
+        return _decode_result(result)
+    finally:
+        lib.satzilla_free_result(ctypes.byref(result))

satzilla_features/py.typed

@@ -0,0 +1 @@
+

satzilla_features/satzilla_Solvers/best[mean+cv],firstlmstep[mean+median+cv+q10+q90],bestavgimpr[mean+cv],firstlmratio[mean+cv],estacl

@@ -0,0 +1,18 @@
+
+
+Variables = 100
+Clauses = 429
+TotalLiterals = 1287
+TotalCPUTimeElapsed = 0.000     
+FlipsPerSecond = inf    
+RunsExecuted = 10
+SuccessfulRuns = 10
+PercentSuccess = 100.00
+Steps_Mean = 2874.6
+Steps_CoeffVariance = 0.93334263389
+Steps_Median = 1624
+CPUTime_Mean = 0
+CPUTime_CoeffVariance = 0
+CPUTime_Median = 0
+
+

satzilla_features/satzilla_Solvers/oo

@@ -0,0 +1,17 @@
+
+
+BestSolution_Mean = 0
+BestSolution_CoeffVariance = 0
+BestSolution_Min = 0
+FirstLocalMinStep_Mean = 23
+FirstLocalMinStep_CoeffVariance = 0
+FirstLocalMinStep_Median = 23
+FirstLocalMinStep_Q.10 = 23
+FirstLocalMinStep_Q.90 = 23
+BestAvgImprovement_Mean = 0.830985915493
+BestAvgImprovement_CoeffVariance = 0
+FirstLocalMinRatio_Mean = 0.881355932203
+FirstLocalMinRatio_CoeffVariance = 0
+EstACL_Mean = 828.382370599
+
+

satzilla_features/satzilla_Solvers/out

@@ -0,0 +1,17 @@
+
+
+BestSolution_Mean = 2151.5
+BestSolution_CoeffVariance = 0.0667135308541
+FirstLocalMinStep_Mean = 19123.7
+FirstLocalMinStep_CoeffVariance = 0.00537800205029
+FirstLocalMinStep_Median = 19159.5
+FirstLocalMinStep_Q.10 = 18871
+FirstLocalMinStep_Q.90 = 19201
+BestAvgImprovement_Mean = 0.63046249781
+BestAvgImprovement_CoeffVariance = 0.168727935973
+FirstLocalMinRatio_Mean = 0.892689448924
+FirstLocalMinRatio_CoeffVariance = 0.00309376829386
+EstACL_Mean = 228138913.529
+SuccessfulRuns = 0
+
+

satzilla_features/satzilla_Solvers/sol

@@ -0,0 +1,47 @@
+c 
+c UBCSAT version 1.2-b18 BETA -- avoid using for published results
+c 
+c http://ubcsat.dtompkins.com
+c 
+c ubcsat -h for help
+c 
+c  -runs 10 
+c  -cutoff 200 
+c  -timeout 0 
+c  -gtimeout 0 
+c  -abstime 0
+c  -systime 0
+c  -timeres 1000 
+c  -noimprove 0 
+c  -earlysteps 0 
+c  -earlyqual 0 
+c  -earlywqual 0 
+c  -strikes 0 
+c  -target 0 
+c  -wtarget 0 
+c  -seed 466967371 
+c  -solve 1
+c  -find,-numsol 1 
+c  -findunique 0 
+c  -srestart 0 
+c  -prestart 0 
+c  -drestart 0 
+c 
+c  -alpha 1.3 
+c  -rho 0.8 
+c  -ps 0.05 
+c  -wp 0.01 
+c  -sapsthresh -0.1 
+c 
+s SATISFIABLE
+v  -1 2 3 4 5 6 -7 8 9 -10
+v  11 -12 -13 -14 -15 16 -17 -18 19 -20
+v  -21 22 -23 -24 25 26 27 -28 -29 30
+v  31 -32 33 -34 -35 -36 37 38 39 -40
+v  -41 -42 43 44 45 -46 47 48 49 -50
+v  51 52 53 -54 55 -56 -57 -58 -59 -60
+v  -61 -62 63 64 -65 -66 -67 68 69 -70
+v  -71 -72 -73 -74 -75 76 -77 -78 79 -80
+v  81 82 -83 84 -85 86 -87 -88 -89 90
+v  -91 92 93 94 95 -96 97 98 -99 100
+v  0

satzilla_features/satzilla_Solvers/yalsat-03v/FILES

@@ -0,0 +1,14 @@
+yalsat          executable SAT solver
+palsat          executable SAT solver simple portfolio version
+main.c          front-end, e.g. dimacs parser, connects to library
+libyals.a       actual library 
+yals.h          library include file
+yals.c          library implementation
+yils.h          internal API calls
+config.c        prints banner (includes configuration)
+config.h        automatically generated from './mkconfig.sh'
+makefile        instantiated from 'makfile.in' by './configure.sh'
+configure.sh    configure script (try './configure -h')
+mkconfig.sh     prints version and compile time information
+getgidid.sh     determine current 'git id' (or of release)
+makefile.in     makefile template

satzilla_features/satzilla_Solvers/yalsat-03v/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2019, Armin Biere, Johannes Kepler University.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

satzilla_features/satzilla_Solvers/yalsat-03v/README

@@ -0,0 +1,12 @@
+YalSAT
+
+This is yet another local search SAT solver.
+
+To build run './configure.sh && make'.  See also './configure.sh -h',
+particularly the usage of './configure.sh -g' to compile a version
+with debugging, checking and logging support.
+
+This will build both the library 'libyals.a' with its API in file 'yals.h'
+and the stand-alone SAT solver 'yalsat'.
+
+

satzilla_features/satzilla_Solvers/yalsat-03v/VERSION

@@ -0,0 +1 @@
+03v

satzilla_features/satzilla_Solvers/yalsat-03v/cflags.h

@@ -0,0 +1,2 @@
+#define YALS_CC "gcc (GCC) 12.3.0"
+#define YALS_CFLAGS "-Wall -DNDEBUG -O3"