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

cppkh_interface/data/src/main.cpp

@@ -1,11 +1,11 @@
 #include <algorithm>
 #include <array>
 #include <cctype>
-#include <chrono>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-#include <dirent.h>
+#include <chrono>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <dirent.h>
 #include <fstream>
 #include <functional>
 #include <iostream>
@@ -298,14 +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 simplifyR1 = true;
-    bool simplifyNugatory = 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;
@@ -682,8 +682,8 @@ static bool operator==(const ArenaAllocator<T>&, const ArenaAllocator<U>&) { ret
 template <typename T, typename U>
 static bool operator!=(const ArenaAllocator<T>&, const ArenaAllocator<U>&) { return false; }
 
-typedef std::vector<Small, ArenaAllocator<Small> > SmallVec;
-typedef std::vector<int, ArenaAllocator<int> > ArenaIntVec;
+typedef std::vector<Small, ArenaAllocator<Small> > SmallVec;
+typedef std::vector<int, ArenaAllocator<int> > ArenaIntVec;
 
 template <size_t InlineN>
 struct IntBuffer {
@@ -875,9 +875,9 @@ struct Cobordism {
     mutable std::string keyCache;
     mutable bool hashReady = false;
     mutable uint64_t hashCache = 0;
-    mutable ArenaIntVec boundaryOffset;
-    mutable SmallVec boundaryItems;
-    mutable ArenaIntVec edgeOffset;
+    mutable ArenaIntVec boundaryOffset;
+    mutable SmallVec boundaryItems;
+    mutable ArenaIntVec edgeOffset;
     mutable SmallVec edgeItems;
 
     Cobordism() = default;
@@ -1003,10 +1003,10 @@ struct Cobordism {
     CobPtr composeHorizontal(int start, const CobPtr& cc, int cstart, int nc) const;
 };
 
-template <typename... Args>
-static CobPtr makeCob(Args&&... args) {
-    return std::make_shared<Cobordism>(std::forward<Args>(args)...);
-}
+template <typename... Args>
+static CobPtr makeCob(Args&&... args) {
+    return std::make_shared<Cobordism>(std::forward<Args>(args)...);
+}
 
 static SimpleMutex g_cobMutex;
 static std::unordered_map<uint64_t, std::vector<CobPtr> > g_cobCache;
@@ -1495,11 +1495,11 @@ CobPtr Cobordism::composeHorizontal(int start, const CobPtr& cc, int cstart, int
     return cacheCob(ret);
 }
 
-struct TermList {
-    typedef std::pair<CobPtr, BigInt> Term;
-    size_t n = 0;
-    Term first;
-    std::vector<Term, ArenaAllocator<Term> > rest;
+struct TermList {
+    typedef std::pair<CobPtr, BigInt> Term;
+    size_t n = 0;
+    Term first;
+    std::vector<Term, ArenaAllocator<Term> > rest;
 
     bool empty() const { return n == 0; }
     size_t size() const { return n; }
@@ -1617,24 +1617,24 @@ struct LCCC {
         return ret;
     }
 
-    LCCC multiplied(const BigInt& c) const {
-        LCCC r;
-        if (c.isZero()) return r;
-        r.terms.reserve(terms.size());
-        for (size_t i = 0; i < terms.size(); ++i) r.terms.push_back(std::make_pair(terms[i].first, coeffProduct(terms[i].second, c)));
-        r.alreadyReduced = alreadyReduced;
-        return r;
-    }
-
-    void multiplyInPlace(const BigInt& c) {
-        if (c == BI_ONE) return;
-        alreadyReduced = false;
-        if (c == BI_MINUS_ONE) {
-            for (size_t i = 0; i < terms.size(); ++i) terms[i].second = -terms[i].second;
-        } else {
-            for (size_t i = 0; i < terms.size(); ++i) terms[i].second = coeffProduct(terms[i].second, c);
-        }
-    }
+    LCCC multiplied(const BigInt& c) const {
+        LCCC r;
+        if (c.isZero()) return r;
+        r.terms.reserve(terms.size());
+        for (size_t i = 0; i < terms.size(); ++i) r.terms.push_back(std::make_pair(terms[i].first, coeffProduct(terms[i].second, c)));
+        r.alreadyReduced = alreadyReduced;
+        return r;
+    }
+
+    void multiplyInPlace(const BigInt& c) {
+        if (c == BI_ONE) return;
+        alreadyReduced = false;
+        if (c == BI_MINUS_ONE) {
+            for (size_t i = 0; i < terms.size(); ++i) terms[i].second = -terms[i].second;
+        } else {
+            for (size_t i = 0; i < terms.size(); ++i) terms[i].second = coeffProduct(terms[i].second, c);
+        }
+    }
 
     LCCC composeVertical(const LCCC& other) const {
         KH_PROFILE(lcccComposeVertical);
@@ -1678,25 +1678,25 @@ struct LCCC {
         if (isZero()) return LCCC();
         if (alreadyReduced) return *this;
         LCCC ret;
-        for (size_t ti = 0; ti < terms.size(); ++ti) {
-            CobPtr cc = terms[ti].first;
-            BigInt num = terms[ti].second;
-            bool canonical = cc->hpower == 0 && cc->ncc == cc->nbc;
-            if (canonical) {
-                for (int i = 0; i < cc->nbc; ++i) {
-                    if (cc->connectedComponent[i] != i || cc->genus[i] != 0 || cc->dots[i] > 1) {
-                        canonical = false;
-                        break;
-                    }
-                }
-                if (canonical) {
-                    if (ret.isZero()) ret.terms.push_back(std::make_pair(cc, num));
-                    else ret.addTerm(cc, num);
-                    continue;
-                }
-            }
-            cc->reverseMaps();
-            SmallVec dots(cc->nbc, 0);
+        for (size_t ti = 0; ti < terms.size(); ++ti) {
+            CobPtr cc = terms[ti].first;
+            BigInt num = terms[ti].second;
+            bool canonical = cc->hpower == 0 && cc->ncc == cc->nbc;
+            if (canonical) {
+                for (int i = 0; i < cc->nbc; ++i) {
+                    if (cc->connectedComponent[i] != i || cc->genus[i] != 0 || cc->dots[i] > 1) {
+                        canonical = false;
+                        break;
+                    }
+                }
+                if (canonical) {
+                    if (ret.isZero()) ret.terms.push_back(std::make_pair(cc, num));
+                    else ret.addTerm(cc, num);
+                    continue;
+                }
+            }
+            cc->reverseMaps();
+            SmallVec dots(cc->nbc, 0);
             SmallVec genus(cc->nbc, 0);
             WorkInts moreWork(cc->ncc);
             int moreWorkCount = 0;
@@ -1733,12 +1733,12 @@ struct LCCC {
                 else ret.addTerm(cached, num);
                 continue;
             }
-            std::vector<SmallVec, ArenaAllocator<SmallVec> > neckCutting;
-            neckCutting.push_back(dots);
-            for (int wi = 0; wi < moreWorkCount; ++wi) {
-                int concomp = moreWork[wi];
-                int nbc = cc->boundaryCount(concomp);
-                std::vector<SmallVec, ArenaAllocator<SmallVec> > next;
+            std::vector<SmallVec, ArenaAllocator<SmallVec> > neckCutting;
+            neckCutting.push_back(dots);
+            for (int wi = 0; wi < moreWorkCount; ++wi) {
+                int concomp = moreWork[wi];
+                int nbc = cc->boundaryCount(concomp);
+                std::vector<SmallVec, ArenaAllocator<SmallVec> > next;
                 next.reserve(neckCutting.size() * static_cast<size_t>(nbc));
                 for (size_t j = 0; j < neckCutting.size(); ++j) {
                     SmallVec base = neckCutting[j];
@@ -1777,8 +1777,8 @@ struct SmoothingColumn {
     }
 };
 
-typedef std::pair<int, LCCC> MatrixEntry;
-typedef std::vector<MatrixEntry, ArenaAllocator<MatrixEntry> > MatrixRow;
+typedef std::pair<int, LCCC> MatrixEntry;
+typedef std::vector<MatrixEntry, ArenaAllocator<MatrixEntry> > MatrixRow;
 
 static MatrixRow::iterator findRowEntry(MatrixRow& row, int column) {
     return std::lower_bound(row.begin(), row.end(), column,
@@ -1976,88 +1976,88 @@ struct CobMatrix {
         return result;
     }
 
-    CobMatrix extractColumns(const std::vector<int>& columns) {
-        int oldSourceN = source.n;
-        std::vector<int> selectedIndex(oldSourceN, -1);
-        std::vector<char> selected(oldSourceN, 0);
-        for (size_t i = 0; i < columns.size(); ++i) {
-            selectedIndex[columns[i]] = static_cast<int>(i);
-            selected[columns[i]] = 1;
-        }
-        std::vector<int> removedBefore(oldSourceN + 1, 0);
-        for (int c = 0; c < oldSourceN; ++c) removedBefore[c + 1] = removedBefore[c] + (selected[c] ? 1 : 0);
-        SmoothingColumn sc(static_cast<int>(columns.size()));
-        for (size_t i = 0; i < columns.size(); ++i) {
-            sc.smoothings[i] = source.smoothings[columns[i]];
-            sc.numbers[i] = source.numbers[columns[i]];
-        }
-        std::vector<CapPtr> newSmoothings;
-        std::vector<int> newNumbers;
-        newSmoothings.reserve(oldSourceN - columns.size());
-        newNumbers.reserve(oldSourceN - columns.size());
-        for (int c = 0; c < oldSourceN; ++c) {
-            if (!selected[c]) {
-                newSmoothings.push_back(source.smoothings[c]);
-                newNumbers.push_back(source.numbers[c]);
-            }
-        }
-        source.smoothings.swap(newSmoothings);
-        source.numbers.swap(newNumbers);
-        source.n -= static_cast<int>(columns.size());
-        CobMatrix result(sc, target);
-        for (size_t r = 0; r < entries.size(); ++r) {
-            MatrixRow remaining;
-            remaining.reserve(entries[r].size());
-            for (size_t e = 0; e < entries[r].size(); ++e) {
-                int oldColumn = entries[r][e].first;
-                if (selected[oldColumn]) {
-                    putRowEntry(result.entries[r], selectedIndex[oldColumn], entries[r][e].second);
-                } else {
-                    entries[r][e].first = oldColumn - removedBefore[oldColumn];
-                    remaining.push_back(std::move(entries[r][e]));
-                }
-            }
-            entries[r].swap(remaining);
-        }
-        return result;
-    }
-
-    CobMatrix extractRows(const std::vector<int>& rows) {
-        int oldTargetN = target.n;
-        std::vector<int> selectedIndex(oldTargetN, -1);
-        std::vector<char> selected(oldTargetN, 0);
-        for (size_t i = 0; i < rows.size(); ++i) {
-            selectedIndex[rows[i]] = static_cast<int>(i);
-            selected[rows[i]] = 1;
-        }
-        SmoothingColumn sc(static_cast<int>(rows.size()));
-        for (size_t i = 0; i < rows.size(); ++i) {
-            sc.smoothings[i] = target.smoothings[rows[i]];
-            sc.numbers[i] = target.numbers[rows[i]];
-        }
-        std::vector<CapPtr> newSmoothings;
-        std::vector<int> newNumbers;
-        newSmoothings.reserve(oldTargetN - rows.size());
-        newNumbers.reserve(oldTargetN - rows.size());
-        for (int r = 0; r < oldTargetN; ++r) {
-            if (!selected[r]) {
-                newSmoothings.push_back(target.smoothings[r]);
-                newNumbers.push_back(target.numbers[r]);
-            }
-        }
-        target.smoothings.swap(newSmoothings);
-        target.numbers.swap(newNumbers);
-        target.n -= static_cast<int>(rows.size());
-        CobMatrix result(source, sc);
-        std::vector<MatrixRow> remaining;
-        remaining.reserve(oldTargetN - rows.size());
-        for (int r = 0; r < oldTargetN; ++r) {
-            if (selected[r]) result.entries[selectedIndex[r]] = std::move(entries[r]);
-            else remaining.push_back(std::move(entries[r]));
-        }
-        entries.swap(remaining);
-        return result;
-    }
+    CobMatrix extractColumns(const std::vector<int>& columns) {
+        int oldSourceN = source.n;
+        std::vector<int> selectedIndex(oldSourceN, -1);
+        std::vector<char> selected(oldSourceN, 0);
+        for (size_t i = 0; i < columns.size(); ++i) {
+            selectedIndex[columns[i]] = static_cast<int>(i);
+            selected[columns[i]] = 1;
+        }
+        std::vector<int> removedBefore(oldSourceN + 1, 0);
+        for (int c = 0; c < oldSourceN; ++c) removedBefore[c + 1] = removedBefore[c] + (selected[c] ? 1 : 0);
+        SmoothingColumn sc(static_cast<int>(columns.size()));
+        for (size_t i = 0; i < columns.size(); ++i) {
+            sc.smoothings[i] = source.smoothings[columns[i]];
+            sc.numbers[i] = source.numbers[columns[i]];
+        }
+        std::vector<CapPtr> newSmoothings;
+        std::vector<int> newNumbers;
+        newSmoothings.reserve(oldSourceN - columns.size());
+        newNumbers.reserve(oldSourceN - columns.size());
+        for (int c = 0; c < oldSourceN; ++c) {
+            if (!selected[c]) {
+                newSmoothings.push_back(source.smoothings[c]);
+                newNumbers.push_back(source.numbers[c]);
+            }
+        }
+        source.smoothings.swap(newSmoothings);
+        source.numbers.swap(newNumbers);
+        source.n -= static_cast<int>(columns.size());
+        CobMatrix result(sc, target);
+        for (size_t r = 0; r < entries.size(); ++r) {
+            MatrixRow remaining;
+            remaining.reserve(entries[r].size());
+            for (size_t e = 0; e < entries[r].size(); ++e) {
+                int oldColumn = entries[r][e].first;
+                if (selected[oldColumn]) {
+                    putRowEntry(result.entries[r], selectedIndex[oldColumn], entries[r][e].second);
+                } else {
+                    entries[r][e].first = oldColumn - removedBefore[oldColumn];
+                    remaining.push_back(std::move(entries[r][e]));
+                }
+            }
+            entries[r].swap(remaining);
+        }
+        return result;
+    }
+
+    CobMatrix extractRows(const std::vector<int>& rows) {
+        int oldTargetN = target.n;
+        std::vector<int> selectedIndex(oldTargetN, -1);
+        std::vector<char> selected(oldTargetN, 0);
+        for (size_t i = 0; i < rows.size(); ++i) {
+            selectedIndex[rows[i]] = static_cast<int>(i);
+            selected[rows[i]] = 1;
+        }
+        SmoothingColumn sc(static_cast<int>(rows.size()));
+        for (size_t i = 0; i < rows.size(); ++i) {
+            sc.smoothings[i] = target.smoothings[rows[i]];
+            sc.numbers[i] = target.numbers[rows[i]];
+        }
+        std::vector<CapPtr> newSmoothings;
+        std::vector<int> newNumbers;
+        newSmoothings.reserve(oldTargetN - rows.size());
+        newNumbers.reserve(oldTargetN - rows.size());
+        for (int r = 0; r < oldTargetN; ++r) {
+            if (!selected[r]) {
+                newSmoothings.push_back(target.smoothings[r]);
+                newNumbers.push_back(target.numbers[r]);
+            }
+        }
+        target.smoothings.swap(newSmoothings);
+        target.numbers.swap(newNumbers);
+        target.n -= static_cast<int>(rows.size());
+        CobMatrix result(source, sc);
+        std::vector<MatrixRow> remaining;
+        remaining.reserve(oldTargetN - rows.size());
+        for (int r = 0; r < oldTargetN; ++r) {
+            if (selected[r]) result.entries[selectedIndex[r]] = std::move(entries[r]);
+            else remaining.push_back(std::move(entries[r]));
+        }
+        entries.swap(remaining);
+        return result;
+    }
 };
 
 struct IntMatrix {
@@ -2480,19 +2480,19 @@ bool Komplex::reductionLemma(int i) {
 }
 
 void Komplex::reductionLemma(int i, int j, int k, const BigInt& n) {
-    CapPtr isoSource = columns[i].smoothings[k];
-    CapPtr isoTarget = columns[i + 1].smoothings[j];
-    CobMatrix m = std::move(matrices[i]);
-    CobMatrix delta = m.extractRow(j);
+    CapPtr isoSource = columns[i].smoothings[k];
+    CapPtr isoTarget = columns[i + 1].smoothings[j];
+    CobMatrix m = std::move(matrices[i]);
+    CobMatrix delta = m.extractRow(j);
     delta.extractColumn(k);
     CobMatrix gamma = m.extractColumn(k);
-    BigInt coeff = (n == BI_ONE ? BI_MINUS_ONE : BI_ONE);
-    for (size_t row = 0; row < gamma.entries.size(); ++row) {
-        for (size_t e = 0; e < gamma.entries[row].size(); ++e) {
-            if (gamma.entries[row][e].first == 0) gamma.entries[row][e].second.multiplyInPlace(coeff);
-        }
-    }
-    CobMatrix gpd = gamma.compose(delta);
+    BigInt coeff = (n == BI_ONE ? BI_MINUS_ONE : BI_ONE);
+    for (size_t row = 0; row < gamma.entries.size(); ++row) {
+        for (size_t e = 0; e < gamma.entries[row].size(); ++e) {
+            if (gamma.entries[row][e].first == 0) gamma.entries[row][e].second.multiplyInPlace(coeff);
+        }
+    }
+    CobMatrix gpd = gamma.compose(delta);
     gpd.add(m);
     matrices[i] = gpd;
     columns[i] = delta.source;
@@ -2505,30 +2505,30 @@ void Komplex::reductionLemma(int i, int j, int k, const BigInt& n) {
     }
 }
 
-std::vector<Komplex::Isomorphism> Komplex::findBlock(const CobMatrix& m) const {
-    std::vector<Isomorphism> isos;
-    std::vector<char> disallowedColumns(m.source.n, 0);
-    std::vector<char> isomorphismColumns(m.source.n, 0);
-    std::vector<int> potentialDisallowedColumns;
-    for (int j = 0; j < static_cast<int>(m.entries.size()); ++j) {
-        bool foundIsomorphismOnRow = false;
-        bool rowForbidden = false;
-        bool hasRowCandidate = false;
-        Isomorphism rowCandidate;
-        potentialDisallowedColumns.clear();
-        potentialDisallowedColumns.reserve(m.entries[j].size());
-        for (const auto& kv : m.entries[j]) {
-            int k = kv.first;
-            const LCCC& lc = kv.second;
-            if (isomorphismColumns[k]) rowForbidden = true;
-            if (disallowedColumns[k]) continue;
-            if (foundIsomorphismOnRow) {
-                disallowedColumns[k] = 1;
-            } else {
-                potentialDisallowedColumns.push_back(k);
-                if (!hasRowCandidate && lc.numberOfTerms() == 1) {
-                    CobPtr cc = lc.firstTerm();
-                    BigInt n = lc.firstCoefficient();
+std::vector<Komplex::Isomorphism> Komplex::findBlock(const CobMatrix& m) const {
+    std::vector<Isomorphism> isos;
+    std::vector<char> disallowedColumns(m.source.n, 0);
+    std::vector<char> isomorphismColumns(m.source.n, 0);
+    std::vector<int> potentialDisallowedColumns;
+    for (int j = 0; j < static_cast<int>(m.entries.size()); ++j) {
+        bool foundIsomorphismOnRow = false;
+        bool rowForbidden = false;
+        bool hasRowCandidate = false;
+        Isomorphism rowCandidate;
+        potentialDisallowedColumns.clear();
+        potentialDisallowedColumns.reserve(m.entries[j].size());
+        for (const auto& kv : m.entries[j]) {
+            int k = kv.first;
+            const LCCC& lc = kv.second;
+            if (isomorphismColumns[k]) rowForbidden = true;
+            if (disallowedColumns[k]) continue;
+            if (foundIsomorphismOnRow) {
+                disallowedColumns[k] = 1;
+            } else {
+                potentialDisallowedColumns.push_back(k);
+                if (!hasRowCandidate && lc.numberOfTerms() == 1) {
+                    CobPtr cc = lc.firstTerm();
+                    BigInt n = lc.firstCoefficient();
                     if (!(n == BI_ONE || n == BI_MINUS_ONE)) continue;
                     if (!cc->isIsomorphism()) continue;
                     rowCandidate = Isomorphism(j, k, n);
@@ -2536,17 +2536,17 @@ std::vector<Komplex::Isomorphism> Komplex::findBlock(const CobMatrix& m) const {
                     foundIsomorphismOnRow = true;
                 }
             }
-        }
-        if (!rowForbidden && hasRowCandidate) {
-            isos.push_back(rowCandidate);
-            isomorphismColumns[rowCandidate.column] = 1;
-            for (size_t p = 0; p < potentialDisallowedColumns.size(); ++p) {
-                disallowedColumns[potentialDisallowedColumns[p]] = 1;
-            }
-        }
-    }
-    return isos;
-}
+        }
+        if (!rowForbidden && hasRowCandidate) {
+            isos.push_back(rowCandidate);
+            isomorphismColumns[rowCandidate.column] = 1;
+            for (size_t p = 0; p < potentialDisallowedColumns.size(); ++p) {
+                disallowedColumns[potentialDisallowedColumns[p]] = 1;
+            }
+        }
+    }
+    return isos;
+}
 
 void Komplex::blockReductionLemma(int i, const std::vector<Isomorphism>& block) {
     KH_PROFILE(blockReductionApply);
@@ -2561,20 +2561,20 @@ void Komplex::blockReductionLemma(int i, const std::vector<Isomorphism>& block)
         cols.push_back(iso.column);
         coeffs.push_back(iso.coefficient);
     }
-    CobMatrix m = std::move(matrices[i]);
+    CobMatrix m = std::move(matrices[i]);
     CobMatrix delta = m.extractRows(rows);
     delta.extractColumns(cols);
     CobMatrix gamma = m.extractColumns(cols);
-    for (size_t k = 0; k < block.size(); ++k) {
-        BigInt coeff = (coeffs[k] == BI_ONE ? BI_MINUS_ONE : BI_ONE);
-        for (size_t row = 0; row < gamma.entries.size(); ++row) {
-            MatrixRow::iterator it = findRowEntry(gamma.entries[row], static_cast<int>(k));
-            if (it != gamma.entries[row].end() && it->first == static_cast<int>(k)) {
-                it->second.multiplyInPlace(coeff);
-            }
-        }
-    }
-    CobMatrix gpd = gamma.compose(delta);
+    for (size_t k = 0; k < block.size(); ++k) {
+        BigInt coeff = (coeffs[k] == BI_ONE ? BI_MINUS_ONE : BI_ONE);
+        for (size_t row = 0; row < gamma.entries.size(); ++row) {
+            MatrixRow::iterator it = findRowEntry(gamma.entries[row], static_cast<int>(k));
+            if (it != gamma.entries[row].end() && it->first == static_cast<int>(k)) {
+                it->second.multiplyInPlace(coeff);
+            }
+        }
+    }
+    CobMatrix gpd = gamma.compose(delta);
     gpd.add(m);
     matrices[i] = gpd;
     columns[i] = delta.source;
@@ -2759,12 +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) {
-    // 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());
+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]) {
@@ -2823,91 +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) {
-    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 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;
@@ -2990,17 +2990,17 @@ static PDCode renumberR1Order(PDCode pd) {
     return pd;
 }
 
-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;
+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));
-                if (signs) signs->erase(signs->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);
@@ -3155,9 +3155,9 @@ static PDCode renumberFullDfs(PDCode pd) {
     return pd;
 }
 
-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");
+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];
@@ -3179,28 +3179,28 @@ static PDCode eraseOneNugatory(PDCode pd, size_t index, std::vector<int>* signs)
     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));
-    if (signs) signs->erase(signs->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, 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 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;
@@ -3208,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);
@@ -3217,13 +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);
-    // 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;
+    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)
@@ -3403,17 +3403,83 @@ 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();
-    std::vector<int> signs = getSigns(pd);
-    PDCode working = simplifyPDCode(pd, &signs, g_options.simplifyR1, g_options.simplifyNugatory);
-    Komplex k = generateFast(working, signs);
+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 computePDWithSigns(const std::vector<std::vector<int> >& pd,
+                                      const std::vector<int>& xsigns) {
+    if (xsigns.size() != pd.size()) throw std::runtime_error("sign count does not match PD crossing count");
+    for (int sign : xsigns) {
+        if (sign != 1 && sign != -1) throw std::runtime_error("crossing signs must be +1 or -1");
+    }
+    flushCobCache();
+    g_smallArena.reset();
+    Komplex k = generateFast(pd, xsigns);
+    ProfileScope khScope(g_profile.kh);
+    return k.KhForZ();
+}
+
+static std::string trimAscii(const std::string& s) {
+    size_t first = 0;
+    while (first < s.size() && std::isspace(static_cast<unsigned char>(s[first]))) ++first;
+    size_t last = s.size();
+    while (last > first && std::isspace(static_cast<unsigned char>(s[last - 1]))) --last;
+    return s.substr(first, last - first);
+}
+
+static std::vector<int> parseSignsLine(const std::string& line) {
+    std::vector<int> signs;
+    size_t pos = 0;
+    while (pos < line.size()) {
+        char ch = line[pos];
+        if (std::isspace(static_cast<unsigned char>(ch)) || ch == ',' ||
+            ch == '[' || ch == ']' || ch == '(' || ch == ')' || ch == ';') {
+            ++pos;
+            continue;
+        }
+        int sign = 1;
+        bool sawExplicitSign = false;
+        if (ch == '+' || ch == '-') {
+            sign = (ch == '-') ? -1 : 1;
+            sawExplicitSign = true;
+            ++pos;
+        }
+        int value = 0;
+        bool sawDigit = false;
+        while (pos < line.size() && std::isdigit(static_cast<unsigned char>(line[pos]))) {
+            sawDigit = true;
+            value = value * 10 + (line[pos++] - '0');
+        }
+        if (!sawExplicitSign && !sawDigit) throw std::runtime_error("invalid crossing sign token");
+        if (sawDigit && value != 1) throw std::runtime_error("crossing signs must be +1 or -1");
+        signs.push_back(sign);
+    }
+    return signs;
+}
+
+static std::vector<std::vector<int> > parseSignsDocument(const std::string& text) {
+    std::vector<std::vector<int> > result;
+    if (trimAscii(text).empty()) {
+        result.push_back(std::vector<int>());
+        return result;
+    }
+    std::istringstream lines(text);
+    std::string line;
+    while (std::getline(lines, line)) {
+        if (!trimAscii(line).empty()) result.push_back(parseSignsLine(line));
+    }
+    if (result.empty()) result.push_back(std::vector<int>());
+    return result;
+}
+
+static std::string formatPDCode(const PDCode& pd) {
     std::ostringstream out;
     out << "PD[";
     for (size_t i = 0; i < pd.size(); ++i) {
@@ -3426,164 +3492,198 @@ static std::string formatPDCode(const PDCode& pd) {
         out << "]";
     }
     out << "]";
-    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
-
-#if defined(CPPKH_SHARED_LIBRARY)
-#if defined(_WIN32)
-#define CPPKH_API extern "C" __declspec(dllexport)
-#else
-#define CPPKH_API extern "C" __attribute__((visibility("default")))
-#endif
-
-static thread_local std::string g_cppkhLastError;
-
-static char* cppkhDuplicateString(const std::string& value) {
-    char* out = static_cast<char*>(std::malloc(value.size() + 1));
-    if (!out) {
-        g_cppkhLastError = "out of memory";
-        return nullptr;
-    }
-    std::memcpy(out, value.c_str(), value.size() + 1);
-    return out;
-}
-
-struct CppkhOptionsGuard {
-    kh::Options oldOptions;
-    CppkhOptionsGuard() : oldOptions(kh::g_options) {}
-    ~CppkhOptionsGuard() { kh::g_options = oldOptions; }
-};
-
-CPPKH_API const char* cppkh_version() {
-    return "cppkh/1";
-}
-
-CPPKH_API const char* cppkh_last_error() {
-    return g_cppkhLastError.c_str();
-}
-
-CPPKH_API void cppkh_free(char* value) {
-    std::free(value);
-}
-
-CPPKH_API char* cppkh_compute_pd_ex(const char* pd_code, int simplify_pd, int reorder_crossings) {
-    try {
-        g_cppkhLastError.clear();
-        if (!pd_code) throw std::runtime_error("pd_code is null");
-        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_code, "ctypes");
-        if (parsed.empty()) throw std::runtime_error("no PD code found");
-        if (parsed.size() != 1) throw std::runtime_error("cppkh_compute_pd_ex expects exactly one PD code");
-
-        CppkhOptionsGuard guard;
-        kh::g_options.progress = false;
-        kh::g_options.profile = false;
-        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);
-    } catch (const std::exception& e) {
-        g_cppkhLastError = e.what();
-        return nullptr;
-    } catch (...) {
-        g_cppkhLastError = "unknown error";
-        return nullptr;
-    }
-}
-
-CPPKH_API char* cppkh_compute_pd(const char* pd_code) {
-    return cppkh_compute_pd_ex(pd_code, 1, 1);
-}
-
-CPPKH_API char* cppkh_compute_pd_batch_ex(const char* pd_codes, int simplify_pd, int reorder_crossings) {
-    try {
-        g_cppkhLastError.clear();
-        if (!pd_codes) throw std::runtime_error("pd_codes is null");
-        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_codes, "ctypes-batch");
-        if (parsed.empty()) throw std::runtime_error("no PD code found");
-
-        CppkhOptionsGuard guard;
-        kh::g_options.progress = false;
-        kh::g_options.profile = false;
-        kh::g_options.simplifyR1 = simplify_pd != 0;
-        kh::g_options.simplifyNugatory = simplify_pd != 0;
-        kh::g_options.reorderCrossings = reorder_crossings != 0;
-
-        std::ostringstream out;
-        for (size_t i = 0; i < parsed.size(); ++i) {
-            if (i) out << "\n";
-            out << kh::computePD(parsed[i].second);
-        }
-        return cppkhDuplicateString(out.str());
-    } catch (const std::exception& e) {
-        g_cppkhLastError = e.what();
-        return nullptr;
-    } catch (...) {
-        g_cppkhLastError = "unknown error";
-        return nullptr;
-    }
-}
-
-CPPKH_API char* cppkh_compute_pd_batch(const char* pd_codes) {
-    return cppkh_compute_pd_batch_ex(pd_codes, 1, 1);
-}
-
-CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
-    try {
-        g_cppkhLastError.clear();
-        if (!pd_code) throw std::runtime_error("pd_code is null");
-        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_code, "ctypes");
-        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.simplifyR1 = true;
-        kh::g_options.simplifyNugatory = true;
-        std::string result = kh::simplifiedPDString(parsed[0].second);
-        return cppkhDuplicateString(result);
-    } catch (const std::exception& e) {
-        g_cppkhLastError = e.what();
-        return nullptr;
-    } catch (...) {
-        g_cppkhLastError = "unknown error";
-        return nullptr;
-    }
-}
-#endif
-
-#ifndef CPPKH_SHARED_LIBRARY
-static void usage() {
-    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";
-}
-
-int main(int argc, char** argv) {
+    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
+
+#if defined(CPPKH_SHARED_LIBRARY)
+#if defined(_WIN32)
+#define CPPKH_API extern "C" __declspec(dllexport)
+#else
+#define CPPKH_API extern "C" __attribute__((visibility("default")))
+#endif
+
+static thread_local std::string g_cppkhLastError;
+
+static char* cppkhDuplicateString(const std::string& value) {
+    char* out = static_cast<char*>(std::malloc(value.size() + 1));
+    if (!out) {
+        g_cppkhLastError = "out of memory";
+        return nullptr;
+    }
+    std::memcpy(out, value.c_str(), value.size() + 1);
+    return out;
+}
+
+struct CppkhOptionsGuard {
+    kh::Options oldOptions;
+    CppkhOptionsGuard() : oldOptions(kh::g_options) {}
+    ~CppkhOptionsGuard() { kh::g_options = oldOptions; }
+};
+
+CPPKH_API const char* cppkh_version() {
+    return "cppkh/1";
+}
+
+CPPKH_API const char* cppkh_last_error() {
+    return g_cppkhLastError.c_str();
+}
+
+CPPKH_API void cppkh_free(char* value) {
+    std::free(value);
+}
+
+CPPKH_API char* cppkh_compute_pd_ex(const char* pd_code, int simplify_pd, int reorder_crossings) {
+    try {
+        g_cppkhLastError.clear();
+        if (!pd_code) throw std::runtime_error("pd_code is null");
+        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_code, "ctypes");
+        if (parsed.empty()) throw std::runtime_error("no PD code found");
+        if (parsed.size() != 1) throw std::runtime_error("cppkh_compute_pd_ex expects exactly one PD code");
+
+        CppkhOptionsGuard guard;
+        kh::g_options.progress = false;
+        kh::g_options.profile = false;
+        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);
+    } catch (const std::exception& e) {
+        g_cppkhLastError = e.what();
+        return nullptr;
+    } catch (...) {
+        g_cppkhLastError = "unknown error";
+        return nullptr;
+    }
+}
+
+CPPKH_API char* cppkh_compute_pd(const char* pd_code) {
+    return cppkh_compute_pd_ex(pd_code, 1, 1);
+}
+
+CPPKH_API char* cppkh_compute_pd_batch_ex(const char* pd_codes, int simplify_pd, int reorder_crossings) {
+    try {
+        g_cppkhLastError.clear();
+        if (!pd_codes) throw std::runtime_error("pd_codes is null");
+        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_codes, "ctypes-batch");
+        if (parsed.empty()) throw std::runtime_error("no PD code found");
+
+        CppkhOptionsGuard guard;
+        kh::g_options.progress = false;
+        kh::g_options.profile = false;
+        kh::g_options.simplifyR1 = simplify_pd != 0;
+        kh::g_options.simplifyNugatory = simplify_pd != 0;
+        kh::g_options.reorderCrossings = reorder_crossings != 0;
+
+        std::ostringstream out;
+        for (size_t i = 0; i < parsed.size(); ++i) {
+            if (i) out << "\n";
+            out << kh::computePD(parsed[i].second);
+        }
+        return cppkhDuplicateString(out.str());
+    } catch (const std::exception& e) {
+        g_cppkhLastError = e.what();
+        return nullptr;
+    } catch (...) {
+        g_cppkhLastError = "unknown error";
+        return nullptr;
+    }
+}
+
+CPPKH_API char* cppkh_compute_pd_batch(const char* pd_codes) {
+    return cppkh_compute_pd_batch_ex(pd_codes, 1, 1);
+}
+
+CPPKH_API char* cppkh_compute_pd_signed_variants_ex(const char* pd_code,
+                                                     const char* signs_text,
+                                                     int reorder_crossings) {
     try {
-        std::vector<std::string> files;
-        std::vector<std::pair<std::string, std::vector<std::vector<int> > > > jobs;
-        bool printSimplifiedPD = false;
-        bool printCrossingSigns = false;
+        g_cppkhLastError.clear();
+        if (!pd_code) throw std::runtime_error("pd_code is null");
+        if (!signs_text) throw std::runtime_error("signs_text is null");
+        std::vector<std::pair<std::string, kh::PDCode> > parsed =
+            kh::parsePDDocument(pd_code, "ctypes-signed");
+        if (parsed.size() != 1) {
+            throw std::runtime_error("signed variants expect exactly one PD code");
+        }
+        std::vector<std::vector<int> > signs = kh::parseSignsDocument(signs_text);
+        CppkhOptionsGuard guard;
+        kh::g_options.progress = false;
+        kh::g_options.profile = false;
+        kh::g_options.simplifyR1 = false;
+        kh::g_options.simplifyNugatory = false;
+        kh::g_options.reorderCrossings = reorder_crossings != 0;
+        std::ostringstream out;
+        for (size_t i = 0; i < signs.size(); ++i) {
+            if (i) out << "\n";
+            out << kh::computePDWithSigns(parsed[0].second, signs[i]);
+        }
+        return cppkhDuplicateString(out.str());
+    } catch (const std::exception& e) {
+        g_cppkhLastError = e.what();
+        return nullptr;
+    } catch (...) {
+        g_cppkhLastError = "unknown error";
+        return nullptr;
+    }
+}
+
+CPPKH_API char* cppkh_simplify_pd(const char* pd_code) {
+    try {
+        g_cppkhLastError.clear();
+        if (!pd_code) throw std::runtime_error("pd_code is null");
+        std::vector<std::pair<std::string, kh::PDCode> > parsed = kh::parsePDDocument(pd_code, "ctypes");
+        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.simplifyR1 = true;
+        kh::g_options.simplifyNugatory = true;
+        std::string result = kh::simplifiedPDString(parsed[0].second);
+        return cppkhDuplicateString(result);
+    } catch (const std::exception& e) {
+        g_cppkhLastError = e.what();
+        return nullptr;
+    } catch (...) {
+        g_cppkhLastError = "unknown error";
+        return nullptr;
+    }
+}
+#endif
+
+#ifndef CPPKH_SHARED_LIBRARY
+static void usage() {
+    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";
+}
+
+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;
+        bool printCrossingSigns = false;
         for (int i = 1; i < argc; ++i) {
             std::string a = argv[i];
             if (a == "--help" || a == "-h") { usage(); return 0; }
@@ -3601,18 +3701,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.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 == "--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];
@@ -3639,10 +3739,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 if (printCrossingSigns) std::cout << kh::formatCrossingSigns(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();
@@ -3651,7 +3751,7 @@ int main(int argc, char** argv) {
         return 0;
     } catch (const std::exception& e) {
         std::cerr << "error: " << e.what() << "\n";
-        return 1;
-    }
-}
-#endif
+        return 1;
+    }
+}
+#endif