cppkh-interface 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

cppkh_interface/data/src/main.cpp

@@ -298,13 +298,14 @@ static BigInt coeffProduct(const BigInt& a, const BigInt& b) {
     return a * b;
 }
 
-struct Options {
-    int matrixThreads = 1;
-    bool reorderCrossings = true;
-    bool progress = true;
-    bool simplifyPD = true;
-    bool profile = false;
-};
+struct Options {
+    int matrixThreads = 1;
+    bool reorderCrossings = true;
+    bool progress = true;
+    bool simplifyR1 = true;
+    bool simplifyNugatory = true;
+    bool profile = false;
+};
 
 static Options g_options;
 typedef std::vector<std::vector<int> > PDCode;
@@ -2758,9 +2759,12 @@ std::string Komplex::KhForZ() {
     return ret;
 }
 
-static int chooseXingRecursive(const std::vector<int>& edges, const std::vector<std::vector<int> >& pd,
-                               std::vector<char>& in, std::vector<char>& done, int depth, std::vector<int>& retmax) {
-    int nedges = static_cast<int>(edges.size());
+static int chooseXingRecursive(const std::vector<int>& edges, const std::vector<std::vector<int> >& pd,
+                               std::vector<char>& in, std::vector<char>& done, int depth, std::vector<int>& retmax) {
+    // Choose the next crossing for the growing tangle. The heuristic maximizes
+    // already-attached boundary arcs, with a short lookahead to keep later
+    // intermediate girth smaller. It affects runtime, not the homology result.
+    int nedges = static_cast<int>(edges.size());
     int best = -1, nconbest = -1;
     std::vector<int> rbest(depth, 0);
     for (size_t i = 0; i < pd.size(); ++i) if (!done[i]) {
@@ -2819,15 +2823,91 @@ static int takeNextCrossing(const std::vector<int>&, const std::vector<std::vect
     throw std::runtime_error("no crossing left");
 }
 
-static std::vector<int> getSigns(const std::vector<std::vector<int> >& pd) {
-    std::vector<int> xsigns(pd.size());
-    for (size_t i = 0; i < pd.size(); ++i) {
-        if (pd[i][1] - pd[i][3] == 1 || pd[i][3] - pd[i][1] > 1) xsigns[i] = 1;
-        else if (pd[i][3] - pd[i][1] == 1 || pd[i][1] - pd[i][3] > 1) xsigns[i] = -1;
-        else throw std::runtime_error("error finding crossing signs");
-    }
-    return xsigns;
-}
+static std::vector<int> getSigns(const std::vector<std::vector<int> >& pd) {
+    const int nodeCount = static_cast<int>(pd.size() * 4);
+    if (nodeCount == 0) return std::vector<int>();
+
+    int maxLabel = -1;
+    for (size_t i = 0; i < pd.size(); ++i) {
+        if (pd[i].size() != 4) throw std::runtime_error("PD crossing must have four entries");
+        for (int label : pd[i]) {
+            if (label < 0) throw std::runtime_error("PD arc labels must be positive");
+            maxLabel = std::max(maxLabel, label);
+        }
+    }
+
+    std::vector<int> first(maxLabel + 1, -1), second(maxLabel + 1, -1);
+    for (size_t i = 0; i < pd.size(); ++i) {
+        for (int slot = 0; slot < 4; ++slot) {
+            int label = pd[i][slot];
+            int node = static_cast<int>(4 * i) + slot;
+            if (first[label] == -1) first[label] = node;
+            else if (second[label] == -1) second[label] = node;
+            else throw std::runtime_error("PD arc label appears more than twice");
+        }
+    }
+
+    std::vector<int> other(nodeCount, -1);
+    for (int label = 0; label <= maxLabel; ++label) {
+        if (first[label] == -1) continue;
+        if (second[label] == -1) throw std::runtime_error("PD arc label does not appear twice");
+        other[first[label]] = second[label];
+        other[second[label]] = first[label];
+    }
+
+    // 1 means that this edge leaves the crossing at this incidence, and 0
+    // means that it enters. Opposite incidences at a crossing and the two
+    // incidences of one edge always have opposite directions.
+    std::vector<signed char> outgoing(nodeCount, -1);
+    std::vector<int> queue;
+    queue.reserve(nodeCount);
+    auto orientComponent = [&](int seed, signed char direction) {
+        if (outgoing[seed] != -1) {
+            if (outgoing[seed] != direction) throw std::runtime_error("inconsistent PD orientation");
+            return;
+        }
+        queue.clear();
+        outgoing[seed] = direction;
+        queue.push_back(seed);
+        for (size_t head = 0; head < queue.size(); ++head) {
+            int node = queue[head];
+            int crossing = node / 4;
+            int slot = node % 4;
+            int neighbors[2] = {4 * crossing + ((slot + 2) % 4), other[node]};
+            for (int next : neighbors) {
+                if (next < 0) throw std::runtime_error("broken PD edge incidence");
+                signed char nextDirection = static_cast<signed char>(1 - outgoing[node]);
+                if (outgoing[next] == -1) {
+                    outgoing[next] = nextDirection;
+                    queue.push_back(next);
+                } else if (outgoing[next] != nextDirection) {
+                    throw std::runtime_error("inconsistent PD orientation");
+                }
+            }
+        }
+    };
+
+    // In SageMath's PD convention slot 0 is the incoming under-edge and slot
+    // 2 is the outgoing under-edge. These seeds orient every component that
+    // passes under at least once.
+    for (size_t i = 0; i < pd.size(); ++i) orientComponent(static_cast<int>(4 * i + 2), 1);
+
+    // A component which is over at every crossing has no orientation encoded
+    // by the PD tuples. Match SageMath's deterministic traversal by taking the
+    // first occurrence of the smallest still-unoriented edge as a tail.
+    for (int label = 0; label <= maxLabel; ++label) {
+        if (first[label] != -1 && outgoing[first[label]] == -1) orientComponent(first[label], 1);
+    }
+
+    std::vector<int> xsigns(pd.size());
+    for (size_t i = 0; i < pd.size(); ++i) {
+        const std::vector<int>& crossing = pd[i];
+        if (crossing[0] == crossing[3] || crossing[2] == crossing[1]) xsigns[i] = -1;
+        else if (crossing[3] == crossing[2] || crossing[0] == crossing[1]) xsigns[i] = 1;
+        else xsigns[i] = outgoing[4 * i + 3] ? -1 : 1;
+    }
+    return xsigns;
+}
 
 static bool sanityPD(const PDCode& pd) {
     std::map<int, int> counts;
@@ -2910,15 +2990,17 @@ static PDCode renumberR1Order(PDCode pd) {
     return pd;
 }
 
-static PDCode eraseR1(PDCode pd) {
-    if (!sanityPD(pd)) throw std::runtime_error("invalid PD code: every arc label must appear exactly twice");
-    bool hasR1 = true;
+static PDCode eraseR1(PDCode pd, std::vector<int>* signs) {
+    if (!sanityPD(pd)) throw std::runtime_error("invalid PD code: every arc label must appear exactly twice");
+    if (signs && signs->size() != pd.size()) throw std::runtime_error("crossing sign count does not match PD code");
+    bool hasR1 = true;
     while (hasR1) {
         hasR1 = false;
         for (size_t i = 0; i < pd.size(); ++i) {
             if (uniqueCount(pd[i]) <= 3) {
-                std::vector<int> crossing = pd[i];
-                pd.erase(pd.begin() + static_cast<std::ptrdiff_t>(i));
+                std::vector<int> crossing = pd[i];
+                pd.erase(pd.begin() + static_cast<std::ptrdiff_t>(i));
+                if (signs) signs->erase(signs->begin() + static_cast<std::ptrdiff_t>(i));
                 std::vector<int> singles;
                 for (int v : crossing) {
                     if (std::count(crossing.begin(), crossing.end(), v) == 1) singles.push_back(v);
@@ -3073,8 +3155,9 @@ static PDCode renumberFullDfs(PDCode pd) {
     return pd;
 }
 
-static PDCode eraseOneNugatory(PDCode pd, size_t index) {
-    if (uniqueCount(pd[index]) != 4) throw std::runtime_error("nugatory erase requires R1-free PD code");
+static PDCode eraseOneNugatory(PDCode pd, size_t index, std::vector<int>* signs) {
+    if (uniqueCount(pd[index]) != 4) throw std::runtime_error("nugatory erase requires R1-free PD code");
+    if (signs && signs->size() != pd.size()) throw std::runtime_error("crossing sign count does not match PD code");
     int ax = pd[index][0];
     int bx = pd[index][1];
     int cx = pd[index][2];
@@ -3096,22 +3179,28 @@ static PDCode eraseOneNugatory(PDCode pd, size_t index) {
     if (!loopSet.count(ax) || !loopSet.count(bx) || !loopSet.count(cx) || !loopSet.count(dx)) {
         throw std::runtime_error("nugatory crossing arcs are not in one component");
     }
-    PDCode bad = pd;
-    bad.erase(bad.begin() + static_cast<std::ptrdiff_t>(index));
+    PDCode bad = pd;
+    bad.erase(bad.begin() + static_cast<std::ptrdiff_t>(index));
+    if (signs) signs->erase(signs->begin() + static_cast<std::ptrdiff_t>(index));
     bad = replaceArcValue(bad, ax, cx);
     bad = replaceArcValue(bad, dx, bx);
     return renumberFullDfs(bad);
 }
 
-static PDCode simplifyPDCode(PDCode pd) {
-    pd = eraseR1(pd);
-    while (true) {
-        int index = findNugatory(pd);
-        if (index < 0) break;
-        pd = eraseOneNugatory(pd, static_cast<size_t>(index));
-    }
-    return pd;
-}
+static PDCode simplifyPDCode(PDCode pd, std::vector<int>* signs,
+                             bool simplifyR1, bool simplifyNugatory) {
+    // The nugatory-crossing operation historically used by the Python API also
+    // removes R1 crossings, so nugatory-only mode still starts with R1 cleanup.
+    if (simplifyR1 || simplifyNugatory) pd = eraseR1(pd, signs);
+    if (simplifyNugatory) {
+        while (true) {
+            int index = findNugatory(pd);
+            if (index < 0) break;
+            pd = eraseOneNugatory(pd, static_cast<size_t>(index), signs);
+        }
+    }
+    return pd;
+}
 
 static int komplexSize(const Komplex& k) {
     int total = 0;
@@ -3119,8 +3208,8 @@ static int komplexSize(const Komplex& k) {
     return total;
 }
 
-static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std::vector<int>& xsigns) {
-    KH_PROFILE(generateFast);
+static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std::vector<int>& xsigns) {
+    KH_PROFILE(generateFast);
     if (pd.empty()) {
         Komplex kom(1);
         kom.columns[0] = SmoothingColumn(1);
@@ -3128,11 +3217,13 @@ static Komplex generateFast(const std::vector<std::vector<int> >& pd, const std:
         kom.reduce();
         return kom;
     }
-    std::vector<char> in(pd.size() * 4, 0), done(pd.size(), 0);
-    std::vector<std::vector<int> > pd1(1, std::vector<int>{0,1,2,3});
-    Komplex kplus(pd1, std::vector<int>{1}, 4);
-    Komplex kminus(pd1, std::vector<int>{-1}, 4);
-    std::vector<int> edges;
+    std::vector<char> in(pd.size() * 4, 0), done(pd.size(), 0);
+    std::vector<std::vector<int> > pd1(1, std::vector<int>{0,1,2,3});
+    Komplex kplus(pd1, std::vector<int>{1}, 4);
+    Komplex kminus(pd1, std::vector<int>{-1}, 4);
+    // Build the full complex by composing one crossing complex at a time and
+    // reducing after every composition, following JavaKh's tangle-growth path.
+    std::vector<int> edges;
     int firstdepth = pd.size() > 4 ? 3 : static_cast<int>(pd.size()) - 1;
     std::vector<int> firstdummy(firstdepth + 1, 0);
     int first = g_options.reorderCrossings ? chooseXingRecursive(edges, pd, in, done, firstdepth, firstdummy)
@@ -3312,16 +3403,17 @@ static std::vector<std::string> listInputFiles(const std::string& dir) {
     return files;
 }
 
-static std::string computePD(const std::vector<std::vector<int> >& pd) {
-    flushCobCache();
-    g_smallArena.reset();
-    PDCode working = g_options.simplifyPD ? simplifyPDCode(pd) : pd;
-    Komplex k = generateFast(working, getSigns(working));
+static std::string computePD(const std::vector<std::vector<int> >& pd) {
+    flushCobCache();
+    g_smallArena.reset();
+    std::vector<int> signs = getSigns(pd);
+    PDCode working = simplifyPDCode(pd, &signs, g_options.simplifyR1, g_options.simplifyNugatory);
+    Komplex k = generateFast(working, signs);
     ProfileScope khScope(g_profile.kh);
     return k.KhForZ();
 }
 
-static std::string formatPDCode(const PDCode& pd) {
+static std::string formatPDCode(const PDCode& pd) {
     std::ostringstream out;
     out << "PD[";
     for (size_t i = 0; i < pd.size(); ++i) {
@@ -3334,13 +3426,26 @@ static std::string formatPDCode(const PDCode& pd) {
         out << "]";
     }
     out << "]";
-    return out.str();
-}
-
-static std::string simplifiedPDString(const PDCode& pd) {
-    PDCode working = g_options.simplifyPD ? simplifyPDCode(pd) : pd;
-    return formatPDCode(working);
-}
+    return out.str();
+}
+
+static std::string formatCrossingSigns(const PDCode& pd) {
+    std::vector<int> signs = getSigns(pd);
+    std::ostringstream out;
+    out << "[";
+    for (size_t i = 0; i < signs.size(); ++i) {
+        if (i) out << ",";
+        out << signs[i];
+    }
+    out << "]";
+    return out.str();
+}
+
+static std::string simplifiedPDString(const PDCode& pd) {
+    getSigns(pd);
+    PDCode working = simplifyPDCode(pd, nullptr, g_options.simplifyR1, g_options.simplifyNugatory);
+    return formatPDCode(working);
+}
 
 } // namespace kh
 
@@ -3392,7 +3497,8 @@ CPPKH_API char* cppkh_compute_pd_ex(const char* pd_code, int simplify_pd, int re
         CppkhOptionsGuard guard;
         kh::g_options.progress = false;
         kh::g_options.profile = false;
-        kh::g_options.simplifyPD = simplify_pd != 0;
+        kh::g_options.simplifyR1 = simplify_pd != 0;
+        kh::g_options.simplifyNugatory = simplify_pd != 0;
         kh::g_options.reorderCrossings = reorder_crossings != 0;
         std::string result = kh::computePD(parsed[0].second);
         return cppkhDuplicateString(result);
@@ -3419,7 +3525,8 @@ CPPKH_API char* cppkh_compute_pd_batch_ex(const char* pd_codes, int simplify_pd,
         CppkhOptionsGuard guard;
         kh::g_options.progress = false;
         kh::g_options.profile = false;
-        kh::g_options.simplifyPD = simplify_pd != 0;
+        kh::g_options.simplifyR1 = simplify_pd != 0;
+        kh::g_options.simplifyNugatory = simplify_pd != 0;
         kh::g_options.reorderCrossings = reorder_crossings != 0;
 
         std::ostringstream out;
@@ -3449,7 +3556,8 @@ CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
         if (parsed.empty()) throw std::runtime_error("no PD code found");
         if (parsed.size() != 1) throw std::runtime_error("cppkh_simplify_pd expects exactly one PD code");
         CppkhOptionsGuard guard;
-        kh::g_options.simplifyPD = true;
+        kh::g_options.simplifyR1 = true;
+        kh::g_options.simplifyNugatory = true;
         std::string result = kh::simplifiedPDString(parsed[0].second);
         return cppkhDuplicateString(result);
     } catch (const std::exception& e) {
@@ -3464,7 +3572,7 @@ CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
 
 #ifndef CPPKH_SHARED_LIBRARY
 static void usage() {
-    std::cout << "Usage: javakh_cpp [--pd-file FILE] [--pd-dir DIR] [--pd-code CODE] [--ordered] [--threads N|auto] [--quiet] [--profile] [--no-simplify-pd] [--print-simplified-pd]\n";
+    std::cout << "Usage: cppkh [--pd-file FILE] [--pd-dir DIR] [--pd-code CODE] [--ordered] [--threads N|auto] [--quiet] [--profile] [--no-simplify-pd] [--simplify-r1|--no-simplify-r1] [--simplify-nugatory|--no-simplify-nugatory] [--print-simplified-pd] [--print-crossing-signs]\n";
     std::cout << "Thread backend: " << KH_THREAD_BACKEND_NAME << "\n";
     std::cout << "Detected CPU threads: " << kh::detectHardwareThreads() << "\n";
     std::cout << "PD simplification: R1 removal then nugatory crossing removal is enabled by default.\n";
@@ -3472,9 +3580,10 @@ static void usage() {
 
 int main(int argc, char** argv) {
     try {
-        std::vector<std::string> files;
-        std::vector<std::pair<std::string, std::vector<std::vector<int> > > > jobs;
-        bool printSimplifiedPD = false;
+        std::vector<std::string> files;
+        std::vector<std::pair<std::string, std::vector<std::vector<int> > > > jobs;
+        bool printSimplifiedPD = false;
+        bool printCrossingSigns = false;
         for (int i = 1; i < argc; ++i) {
             std::string a = argv[i];
             if (a == "--help" || a == "-h") { usage(); return 0; }
@@ -3492,9 +3601,18 @@ int main(int argc, char** argv) {
             } else if (a == "--ordered" || a == "-O") kh::g_options.reorderCrossings = false;
             else if (a == "--quiet" || a == "-q") kh::g_options.progress = false;
             else if (a == "--profile") kh::g_options.profile = true;
-            else if (a == "--no-simplify-pd" || a == "--raw-pd") kh::g_options.simplifyPD = false;
-            else if (a == "--simplify-pd") kh::g_options.simplifyPD = true;
-            else if (a == "--print-simplified-pd") printSimplifiedPD = true;
+            else if (a == "--no-simplify-pd" || a == "--raw-pd") {
+                kh::g_options.simplifyR1 = false;
+                kh::g_options.simplifyNugatory = false;
+            } else if (a == "--simplify-pd") {
+                kh::g_options.simplifyR1 = true;
+                kh::g_options.simplifyNugatory = true;
+            } else if (a == "--no-simplify-r1") kh::g_options.simplifyR1 = false;
+            else if (a == "--simplify-r1") kh::g_options.simplifyR1 = true;
+            else if (a == "--no-simplify-nugatory") kh::g_options.simplifyNugatory = false;
+            else if (a == "--simplify-nugatory") kh::g_options.simplifyNugatory = true;
+            else if (a == "--print-simplified-pd") printSimplifiedPD = true;
+            else if (a == "--print-crossing-signs") printCrossingSigns = true;
             else if (a == "--threads" || a == "-j") {
                 if (++i >= argc) throw std::runtime_error("--threads needs a number");
                 std::string v = argv[i];
@@ -3521,9 +3639,10 @@ int main(int argc, char** argv) {
                 kh::g_profile.reset();
                 profileStart = kh::profileNowNs();
             }
-            if (label) std::cout << jobs[i].first << "\t";
-            if (printSimplifiedPD) std::cout << kh::simplifiedPDString(jobs[i].second) << "\n";
-            else std::cout << "\"" << kh::computePD(jobs[i].second) << "\"\n";
+            if (label) std::cout << jobs[i].first << "\t";
+            if (printSimplifiedPD) std::cout << kh::simplifiedPDString(jobs[i].second) << "\n";
+            else if (printCrossingSigns) std::cout << kh::formatCrossingSigns(jobs[i].second) << "\n";
+            else std::cout << "\"" << kh::computePD(jobs[i].second) << "\"\n";
             if (kh::g_options.profile) {
                 kh::g_profile.totalNs = kh::profileNowNs() - profileStart;
                 kh::printProfile();

cppkh_interface/main.py

@@ -9,22 +9,17 @@ import pathlib
 import platform
 import re
 import shlex
+import shutil
 import subprocess
 import sys
 import tempfile
+import uuid
 from importlib import resources
 from typing import Optional, Sequence, Union
 
-import cpp_simple_interface
-import pd_code_de_r1
-import pd_code_delete_nugatory
-import pd_code_sanity
-
-
-PathLike = Union[str, os.PathLike]
 PdInput = Union[str, Sequence[Sequence[int]]]
 PdManyInput = Union[str, Sequence[PdInput]]
-UNKNOT_RESULT = "q^-1*t^0*Z[0] + q^1*t^0*Z[0]"
+_configured_cxx: Optional[str] = None
 
 
 class CppkhInterfaceError(RuntimeError):
@@ -77,13 +72,6 @@ def _as_crossings(pd_code: PdInput) -> list[list[int]]:
     return crossings
 
 
-def _check_sanity(crossings: list[list[int]]) -> None:
-    if crossings == []:
-        return
-    if not pd_code_sanity.sanity(crossings):
-        raise TypeError("pd_code does not satisfy PD-code sanity checks")
-
-
 def normalize_pd_code(pd_code: PdInput) -> str:
     """Normalize a supported PD-code value into standard ``PD[X[...],...]`` text."""
 
@@ -154,25 +142,84 @@ def _exe_suffix() -> str:
     return ".exe" if platform.system() == "Windows" else ""
 
 
-def _compiler_runtime_path_entries() -> list[str]:
-    compiler = cpp_simple_interface.get_gpp_filepath().strip()
-    if not compiler:
+def _compiler_parts(command: str) -> list[str]:
+    command = command.strip()
+    if not command:
         return []
-
-    candidates = []
-    unquoted = compiler
+    unquoted = command
     if len(unquoted) >= 2 and unquoted[0] == unquoted[-1] and unquoted[0] in ("'", '"'):
         unquoted = unquoted[1:-1]
-    candidates.append(unquoted)
+    if pathlib.Path(unquoted).is_file():
+        return [unquoted]
+    try:
+        parts = shlex.split(command, posix=os.name != "nt")
+    except ValueError as exc:
+        raise CppkhInterfaceError(f"invalid C++ compiler command: {command!r}") from exc
+    return [part.strip("\"'") for part in parts if part.strip("\"'")]
+
 
+def _subprocess_kwargs() -> dict:
+    kwargs = {
+        "stdout": subprocess.PIPE,
+        "stderr": subprocess.PIPE,
+        "text": True,
+        "encoding": "utf-8",
+        "errors": "replace",
+    }
+    if platform.system() == "Windows":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    return kwargs
+
+
+def _probe_compiler(parts: Sequence[str]) -> subprocess.CompletedProcess:
+    if not parts:
+        raise CppkhInterfaceError("empty C++ compiler command")
     try:
-        candidates.extend(shlex.split(compiler, posix=True))
-    except ValueError:
-        pass
+        result = subprocess.run([*parts, "--version"], timeout=15, **_subprocess_kwargs())
+    except (OSError, subprocess.SubprocessError) as exc:
+        raise CppkhInterfaceError(f"could not run C++ compiler {' '.join(parts)!r}: {exc}") from exc
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip()
+        raise CppkhInterfaceError(detail or f"C++ compiler {' '.join(parts)!r} is not usable")
+    return result
+
+
+def _resolve_compiler(cxx: Optional[str] = None) -> list[str]:
+    global _configured_cxx
+
+    explicit = cxx or _configured_cxx
+    if not explicit:
+        explicit = os.environ.get("CPPKH_INTERFACE_CXX") or os.environ.get("CXX")
+    if explicit:
+        parts = _compiler_parts(explicit)
+        _probe_compiler(parts)
+        if cxx:
+            _configured_cxx = cxx
+        return parts
+
+    errors = []
+    for name in ("g++", "clang++", "c++"):
+        candidate = shutil.which(name)
+        if not candidate:
+            continue
+        parts = [candidate]
+        try:
+            _probe_compiler(parts)
+            return parts
+        except CppkhInterfaceError as exc:
+            errors.append(str(exc))
+    detail = f" ({'; '.join(errors)})" if errors else ""
+    raise CppkhInterfaceError(
+        "no usable C++ compiler was found. Install a C++14 compiler or set "
+        f"CPPKH_INTERFACE_CXX/CXX to its command{detail}"
+    )
+
 
+def _compiler_runtime_path_entries(compiler: Sequence[str]) -> list[str]:
     paths = []
-    for candidate in candidates:
-        path = pathlib.Path(candidate)
+    for candidate in compiler:
+        resolved = shutil.which(candidate) or candidate
+        path = pathlib.Path(resolved)
         if path.exists() and path.is_file():
             parent = str(path.resolve().parent)
             if parent not in paths:
@@ -180,65 +227,84 @@ def _compiler_runtime_path_entries() -> list[str]:
     return paths
 
 
-def _cache_key(source_bytes: bytes, flags: Sequence[str]) -> str:
+def _compiler_identity(compiler: Sequence[str]) -> str:
+    result = _probe_compiler(compiler)
+    executable = shutil.which(compiler[0]) or compiler[0]
+    return "\0".join([str(pathlib.Path(executable).resolve()), *compiler[1:], result.stdout.strip()])
+
+
+def _cache_key(source_bytes: bytes, flags: Sequence[str], compiler: Sequence[str]) -> str:
     digest = hashlib.sha256()
     digest.update(source_bytes)
     digest.update("\0".join(flags).encode("utf-8"))
-    digest.update(cpp_simple_interface.get_gpp_filepath().encode("utf-8"))
+    digest.update(_compiler_identity(compiler).encode("utf-8"))
     digest.update(platform.platform().encode("utf-8"))
     return digest.hexdigest()[:20]
 
 
+def _compile_source(
+    compiler: Sequence[str],
+    source: pathlib.Path,
+    output: pathlib.Path,
+    flags: Sequence[str],
+) -> subprocess.CompletedProcess:
+    command = [*compiler, *flags, str(source), "-o", str(output)]
+    try:
+        return subprocess.run(command, **_subprocess_kwargs())
+    except OSError as exc:
+        raise CppkhInterfaceError(f"could not start C++ compiler: {exc}") from exc
+
+
 def compile_cppkh(
     *,
     force: bool = False,
     cxx: Optional[str] = None,
     extra_flags: Optional[Sequence[str]] = None,
 ) -> pathlib.Path:
-    """Compile the packaged C++ source with cpp-simple-interface and return the executable path."""
-
-    if cxx:
-        cpp_simple_interface.set_gpp_filepath(cxx)
+    """Compile the packaged C++ source and return the cached executable path."""
 
     with _resource_source_path() as source:
         source_path = pathlib.Path(source)
         source_bytes = source_path.read_bytes()
+        compiler = _resolve_compiler(cxx)
         flags = _default_compile_flags()
         if extra_flags:
             flags.extend(str(flag) for flag in extra_flags)
 
         cache = _cache_dir()
-        exe = cache / f"cppkh-{_cache_key(source_bytes, flags)}{_exe_suffix()}"
+        exe = cache / f"cppkh-{_cache_key(source_bytes, flags, compiler)}{_exe_suffix()}"
         if exe.exists() and not force:
             return exe
 
-        tmp_exe = cache / f"{exe.name}.tmp-{os.getpid()}{_exe_suffix()}"
-        if tmp_exe.exists():
-            tmp_exe.unlink()
-
-        success, message = cpp_simple_interface.compile_cpp_files(
-            [str(source_path)],
-            str(tmp_exe),
-            other_flags=flags,
-        )
-        if not success and "-march=native" in flags:
-            fallback_flags = [flag for flag in flags if flag != "-march=native"]
-            success, message = cpp_simple_interface.compile_cpp_files(
-                [str(source_path)],
-                str(tmp_exe),
-                other_flags=fallback_flags,
-            )
-
-        if not success:
-            raise CppkhInterfaceError(message)
-        if not tmp_exe.exists():
-            raise CppkhInterfaceError(f"compiled executable was not created: {tmp_exe}")
-        os.replace(tmp_exe, exe)
+        tmp_exe = cache / f"{exe.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}{_exe_suffix()}"
         try:
-            exe.chmod(exe.stat().st_mode | 0o755)
-        except OSError:
-            pass
-        return exe
+            result = _compile_source(compiler, source_path, tmp_exe, flags)
+            if result.returncode != 0 and "-march=native" in flags:
+                fallback_flags = [flag for flag in flags if flag != "-march=native"]
+                result = _compile_source(compiler, source_path, tmp_exe, fallback_flags)
+            if result.returncode != 0:
+                detail = (result.stderr or result.stdout or "").strip()
+                raise CppkhInterfaceError(detail or "C++ compilation failed")
+            if not tmp_exe.exists():
+                raise CppkhInterfaceError(f"compiled executable was not created: {tmp_exe}")
+
+            if exe.exists() and not force:
+                return exe
+            try:
+                os.replace(tmp_exe, exe)
+            except OSError:
+                if force or not exe.exists():
+                    raise
+            try:
+                exe.chmod(exe.stat().st_mode | 0o755)
+            except OSError:
+                pass
+            return exe
+        finally:
+            try:
+                tmp_exe.unlink()
+            except OSError:
+                pass
 
 
 def get_cppkh_executable() -> pathlib.Path:
@@ -252,7 +318,8 @@ def _run_cppkh_document(
     *,
     encoding: Optional[str] = None,
     threads: Union[str, int] = "1",
-    simplify_pd: bool = False,
+    de_r1: bool = False,
+    de_k8: bool = False,
     print_simplified_pd: bool = False,
 ) -> list[str]:
     exe = compile_cppkh()
@@ -270,8 +337,8 @@ def _run_cppkh_document(
         "--threads",
         str(threads),
     ]
-    if not simplify_pd:
-        command.append("--no-simplify-pd")
+    command.append("--simplify-r1" if de_r1 else "--no-simplify-r1")
+    command.append("--simplify-nugatory" if de_k8 else "--no-simplify-nugatory")
     if print_simplified_pd:
         command.append("--print-simplified-pd")
 
@@ -283,7 +350,7 @@ def _run_cppkh_document(
         "errors": "replace",
     }
     env = os.environ.copy()
-    runtime_paths = _compiler_runtime_path_entries()
+    runtime_paths = _compiler_runtime_path_entries(_resolve_compiler())
     if runtime_paths:
         env["PATH"] = os.pathsep.join(runtime_paths + [env.get("PATH", "")])
     kwargs["env"] = env
@@ -303,7 +370,8 @@ def _run_cppkh_document(
         raise CppkhInterfaceError(detail or f"cppkh exited with code {result.returncode}")
 
     if print_simplified_pd:
-        return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        lines = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        return [line.split("\t", 1)[-1] for line in lines]
 
     matches = re.findall(r'"([^"]*)"', result.stdout)
     if not matches:
@@ -316,14 +384,16 @@ def _run_cppkh(
     *,
     encoding: Optional[str] = None,
     threads: Union[str, int] = "1",
-    simplify_pd: bool = False,
+    de_r1: bool = False,
+    de_k8: bool = False,
     print_simplified_pd: bool = False,
 ) -> str:
     results = _run_cppkh_document(
         pd_text,
         encoding=encoding,
         threads=threads,
-        simplify_pd=simplify_pd,
+        de_r1=de_r1,
+        de_k8=de_k8,
         print_simplified_pd=print_simplified_pd,
     )
     if len(results) != 1:
@@ -331,37 +401,40 @@ def _run_cppkh(
     return results[0]
 
 
-def _prepare_crossings(pd_code: PdInput, de_r1: bool, de_k8: bool) -> list[list[int]]:
-    crossings = _as_crossings(pd_code)
-    _check_sanity(crossings)
-    if de_r1:
-        crossings = pd_code_de_r1.de_r1(crossings)
-    if de_k8:
-        crossings = pd_code_delete_nugatory.erase_all_nugatory(crossings)
-    return crossings
+def _prepare_many_for_cppkh(pd_codes: PdManyInput) -> str:
+    if isinstance(pd_codes, str):
+        return pd_codes.strip()
+    return "\n".join(normalize_pd_code(pd_code) for pd_code in pd_codes)
 
 
-def _prepare_many_for_cppkh(
-    pd_codes: PdManyInput,
+def _compute_one(
+    pd_code: PdInput,
     *,
+    encoding: Optional[str],
     de_r1: bool,
     de_k8: bool,
-) -> tuple[str, bool]:
-    if de_r1 != de_k8:
-        raise ValueError(
-            "cppkh batch mode supports de_r1 and de_k8 only as a pair. "
-            "Use both True for backend R1+nugatory simplification or both False for raw PD input."
+    show_real_pdcode: bool,
+    threads: Union[str, int],
+) -> str:
+    document = normalize_pd_code(pd_code)
+    if show_real_pdcode:
+        real_pd = _run_cppkh(
+            document,
+            encoding=encoding,
+            threads=threads,
+            de_r1=de_r1,
+            de_k8=de_k8,
+            print_simplified_pd=True,
         )
-    if isinstance(pd_codes, str):
-        return pd_codes.strip(), bool(de_r1 and de_k8)
-
-    prepared = []
-    use_cpp_simplify = bool(de_r1 and de_k8)
-    for pd_code in pd_codes:
-        crossings = _as_crossings(pd_code)
-        _check_sanity(crossings)
-        prepared.append(_format_pd(crossings))
-    return "\n".join(prepared), use_cpp_simplify
+        display_pd = real_pd if de_r1 and de_k8 else _as_crossings(real_pd)
+        print(f"Real PD code after de_r1 and de_k8: {display_pd}")
+    return _run_cppkh(
+        document,
+        encoding=encoding,
+        threads=threads,
+        de_r1=de_r1,
+        de_k8=de_k8,
+    )
 
 
 def solve_khovanov(
@@ -373,30 +446,14 @@ def solve_khovanov(
 ) -> str:
     """Compute Khovanov homology with a javakh-interface compatible signature."""
 
-    if de_r1 == de_k8:
-        crossings = _as_crossings(pd_code)
-        _check_sanity(crossings)
-        if show_real_pdcode:
-            if de_r1:
-                simplified = _run_cppkh_document(
-                    _format_pd(crossings),
-                    encoding=encoding,
-                    simplify_pd=True,
-                    print_simplified_pd=True,
-                )
-                print(f"Real PD code after de_r1 and de_k8: {simplified[0] if simplified else ''}")
-            else:
-                print(f"Real PD code after de_r1 and de_k8: {crossings}")
-        if crossings == []:
-            return UNKNOT_RESULT
-        return _run_cppkh(_format_pd(crossings), encoding=encoding, simplify_pd=de_r1)
-
-    crossings = _prepare_crossings(pd_code, de_r1=de_r1, de_k8=de_k8)
-    if show_real_pdcode:
-        print(f"Real PD code after de_r1 and de_k8: {crossings}")
-    if crossings == []:
-        return UNKNOT_RESULT
-    return _run_cppkh(_format_pd(crossings), encoding=encoding)
+    return _compute_one(
+        pd_code,
+        encoding=encoding,
+        de_r1=de_r1,
+        de_k8=de_k8,
+        show_real_pdcode=show_real_pdcode,
+        threads="1",
+    )
 
 
 def solve_many_khovanov(
@@ -414,22 +471,26 @@ def solve_many_khovanov(
     nugatory crossing removal for the whole batch.
     """
 
-    document, use_cpp_simplify = _prepare_many_for_cppkh(pd_codes, de_r1=de_r1, de_k8=de_k8)
-    if show_real_pdcode:
-        if use_cpp_simplify:
-            simplified = _run_cppkh_document(
-                document,
-                encoding=encoding,
-                threads=threads,
-                simplify_pd=True,
-                print_simplified_pd=True,
-            )
-            print(f"Real PD code after de_r1 and de_k8: {simplified}")
-        else:
-            print(f"Real PD code after de_r1 and de_k8: {document.splitlines()}")
+    document = _prepare_many_for_cppkh(pd_codes)
     if not document:
         return []
-    return _run_cppkh_document(document, encoding=encoding, threads=threads, simplify_pd=use_cpp_simplify)
+    if show_real_pdcode:
+        simplified = _run_cppkh_document(
+            document,
+            encoding=encoding,
+            threads=threads,
+            de_r1=de_r1,
+            de_k8=de_k8,
+            print_simplified_pd=True,
+        )
+        print(f"Real PD code after de_r1 and de_k8: {simplified}")
+    return _run_cppkh_document(
+        document,
+        encoding=encoding,
+        threads=threads,
+        de_r1=de_r1,
+        de_k8=de_k8,
+    )
 
 
 def compute_pd(
@@ -443,31 +504,14 @@ def compute_pd(
 ) -> str:
     """Compute Khovanov homology using the same defaults as solve_khovanov."""
 
-    if de_r1 == de_k8:
-        crossings = _as_crossings(pd_code)
-        _check_sanity(crossings)
-        if show_real_pdcode:
-            if de_r1:
-                simplified = _run_cppkh_document(
-                    _format_pd(crossings),
-                    encoding=encoding,
-                    threads=threads,
-                    simplify_pd=True,
-                    print_simplified_pd=True,
-                )
-                print(f"Real PD code after de_r1 and de_k8: {simplified[0] if simplified else ''}")
-            else:
-                print(f"Real PD code after de_r1 and de_k8: {crossings}")
-        if crossings == []:
-            return UNKNOT_RESULT
-        return _run_cppkh(_format_pd(crossings), encoding=encoding, threads=threads, simplify_pd=de_r1)
-
-    crossings = _prepare_crossings(pd_code, de_r1=de_r1, de_k8=de_k8)
-    if show_real_pdcode:
-        print(f"Real PD code after de_r1 and de_k8: {crossings}")
-    if crossings == []:
-        return UNKNOT_RESULT
-    return _run_cppkh(_format_pd(crossings), encoding=encoding, threads=threads)
+    return _compute_one(
+        pd_code,
+        encoding=encoding,
+        de_r1=de_r1,
+        de_k8=de_k8,
+        show_real_pdcode=show_real_pdcode,
+        threads=threads,
+    )
 
 
 def compute_many_pd(
@@ -494,7 +538,12 @@ def compute_many_pd(
 def simplify_pd(pd_code: PdInput, *, de_r1: bool = True, de_k8: bool = True) -> str:
     """Return the normalized PD string after optional R1 and nugatory simplification."""
 
-    return _format_pd(_prepare_crossings(pd_code, de_r1=de_r1, de_k8=de_k8))
+    return _run_cppkh(
+        normalize_pd_code(pd_code),
+        de_r1=de_r1,
+        de_k8=de_k8,
+        print_simplified_pd=True,
+    )
 
 
 def main(argv: Optional[Sequence[str]] = None) -> int:

{cppkh_interface-0.1.1.dist-info → cppkh_interface-0.1.3.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cppkh-interface
-Version: 0.1.1
-Summary: Python interface for cppkh Khovanov homology computation with runtime C++ compilation.
+Version: 0.1.3
+Summary: Dependency-free Python interface for cppkh with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
 Author-email: neko@jlulug.org
@@ -12,10 +12,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: cpp-simple-interface (>=0.1.2)
-Requires-Dist: pd-code-de-r1
-Requires-Dist: pd-code-delete-nugatory
-Requires-Dist: pd-code-sanity (>=0.0.1)
 Project-URL: Documentation, https://github.com/GGN-2015/cppkh/blob/main/docs/PYTHON_PACKAGE.md
 Project-URL: Homepage, https://github.com/GGN-2015/cppkh
 Project-URL: Repository, https://github.com/GGN-2015/cppkh
@@ -26,6 +22,10 @@ Description-Content-Type: text/markdown
 `cppkh-interface` is a Python package for computing integer Khovanov homology
 with the C++ `cppkh` implementation.
 
+Version `0.1.3` has no runtime Python-package dependencies. Link crossing signs,
+PD validation, R1 removal, and nugatory-crossing removal all use the bundled
+canonical `cppkh` C++ source and its SageMath-compatible orientation rules.
+
 The package is compatible with the main `javakh-interface` function:
 
 ```python
@@ -38,13 +38,13 @@ print(cppkh_interface.solve_many_khovanov([pd_code, pd_code]))
 
 Unlike wrappers that ship a prebuilt DLL or shared object, this package ships
 the `cppkh` C++ source file in built distributions and compiles a local
-executable on first use through `cpp-simple-interface`. The compiled executable
-is cached for later calls.
+executable on first use using only Python's standard library. The compiled
+executable is cached for later calls.
 
 In the repository checkout, the package does not keep a committed backup copy
 of the C++ source. The build backend copies `../../src/main.cpp` into the
-package data directory only while `poetry build` or `poetry publish --build` is
-running, then removes that temporary copy.
+package data directory only while the PEP 517 build is running, then removes
+that temporary copy.
 
 ## Install
 
@@ -52,17 +52,18 @@ running, then removes that temporary copy.
 pip install cppkh-interface
 ```
 
-A `g++` compatible compiler must be available at runtime. To select a compiler,
-set `CXX` before importing or calling the package:
+A C++14 compiler must be available at runtime. The package looks at
+`CPPKH_INTERFACE_CXX`, then `CXX`, then searches `PATH` for `g++`, `clang++`, or
+`c++`. To select a compiler explicitly:
 
 ```sh
-CXX=clang++ python your_script.py
+CPPKH_INTERFACE_CXX=clang++ python your_script.py
 ```
 
 Windows PowerShell:
 
 ```powershell
-$env:CXX = "C:\path\to\g++.exe"
+$env:CPPKH_INTERFACE_CXX = "C:\path\to\g++.exe"
 python your_script.py
 ```
 
@@ -71,11 +72,13 @@ python your_script.py
 From this directory:
 
 ```sh
-poetry build
+python -m build
 poetry publish
 ```
 
-Use `poetry publish --build` to build and upload in one command.
+Do not use `poetry build` or `poetry publish --build`: Poetry's direct builder
+bypasses the source-synchronizing PEP 517 backend. Build first with
+`python -m build`, inspect/test the wheel, then publish the existing artifacts.
 
 For local testing:
 

cppkh_interface-0.1.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+cppkh_interface/__init__.py,sha256=u6y6hezL7izQ_yVE9JhjU7znxICVzQNgLUPR3ObKLB0,489
+cppkh_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
+cppkh_interface/main.py,sha256=yYj01WZZn12pKlTPq-bsPrc0JxgoWzZUnC-1qsDItkQ,17724
+cppkh_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+cppkh_interface-0.1.3.dist-info/entry_points.txt,sha256=CsnHBNaO_RJe4eFXmEZpSxWu-c1aF0RpjVFaEGlIm4Y,61
+cppkh_interface-0.1.3.dist-info/METADATA,sha256=OpUBi9Go11i9yz4fCeRFfJ6sw_AcOnf9YmphsNNYxz4,2802
+cppkh_interface-0.1.3.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cppkh_interface/data/src/main.cpp,sha256=M5yNMOYBT559L2FvCEm7_PQi9u-bIQXRYGDg3XXVF9I,149049
+cppkh_interface-0.1.3.dist-info/RECORD,,

cppkh_interface-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-cppkh_interface/__init__.py,sha256=u6y6hezL7izQ_yVE9JhjU7znxICVzQNgLUPR3ObKLB0,489
-cppkh_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
-cppkh_interface/main.py,sha256=oIhYl-kh-2Ql_zxS1uHggww5Am3KRWUL2QXNGK1ayDM,16674
-cppkh_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cppkh_interface-0.1.1.dist-info/entry_points.txt,sha256=CsnHBNaO_RJe4eFXmEZpSxWu-c1aF0RpjVFaEGlIm4Y,61
-cppkh_interface-0.1.1.dist-info/METADATA,sha256=2UIZgh_EM5hBfhBZ7huIx21nDDhclwcZRx0tKkCSS8k,2499
-cppkh_interface-0.1.1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-cppkh_interface/data/src/main.cpp,sha256=lNg4DhWOcQNWCZoVfXGIObAiPHYWD2i7Pctd5445QT8,143069
-cppkh_interface-0.1.1.dist-info/RECORD,,