cpp-pd-code-simplify-interface 0.1.0__tar.gz → 0.1.2__tar.gz

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpp-pd-code-simplify-interface
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -47,6 +47,10 @@ result = simplify.simplify(pd_code)
 print(result["simplification_found"])
 ```
 
+The default `max_paths=-1` uses deterministic heuristic green-path sampling in
+the C++ backend. Use `ban_heuristic=True` to request exhaustive green-path
+enumeration for a manageable input.
+
 Batch use:
 
 ```python
@@ -72,7 +76,7 @@ Python process needs a 64-bit compiler target.
 Command-line use also supports multi-line PD-code files:
 
 ```sh
-python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths 100
+python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths -1
 ```
 
 ## Build And Publish

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/README.md

@@ -27,6 +27,10 @@ result = simplify.simplify(pd_code)
 print(result["simplification_found"])
 ```
 
+The default `max_paths=-1` uses deterministic heuristic green-path sampling in
+the C++ backend. Use `ban_heuristic=True` to request exhaustive green-path
+enumeration for a manageable input.
+
 Batch use:
 
 ```python
@@ -52,7 +56,7 @@ Python process needs a 64-bit compiler target.
 Command-line use also supports multi-line PD-code files:
 
 ```sh
-python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths 100
+python -m cpp_pd_code_simplify_interface --pd-file inputs.pd --max-paths -1
 ```
 
 ## Build And Publish

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -48,7 +48,8 @@ struct GreenCrossing {
 };
 
 struct SimplifierOptions {
-    int max_paths = 100;
+    int max_paths = -1;
+    bool ban_heuristic = false;
 };
 
 struct LinkComponentSummary {
@@ -98,6 +99,7 @@ struct PDSimplificationResult {
 struct SimplificationResult {
     bool found = false;
     Direction direction = Direction::Left;
+    std::string path_search_mode;
     std::vector<Endpoint> red_path;
     std::vector<int> green_path;
     std::vector<GreenCrossing> green_crossings;

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/cpp_pd_code_simplify_interface/data/src/native_interface.cpp

@@ -81,7 +81,8 @@ std::string result_to_json(
     append_component_counts(out, search_components);
     out << "},";
     out << "\"tested_red_paths\":" << result.tested_red_paths << ",";
-    out << "\"tested_green_paths\":" << result.tested_green_paths;
+    out << "\"tested_green_paths\":" << result.tested_green_paths << ",";
+    out << "\"path_search_mode\":\"" << json_escape(result.path_search_mode) << "\"";
     if (result.found) {
         out << ",";
         out << "\"direction\":\"" << pdcode_simplify::format_direction(result.direction) << "\",";
@@ -137,6 +138,7 @@ __declspec(dllexport)
 char* pdcode_simplify_run_json(
     const char* pd_text,
     int max_paths,
+    int ban_heuristic,
     unsigned long long known_crossingless_components,
     const int* removed_crossings,
     unsigned long long removed_crossing_count) {
@@ -148,6 +150,7 @@ char* pdcode_simplify_run_json(
         const std::string text(pd_text);
         pdcode_simplify::SimplifierOptions options;
         options.max_paths = max_paths;
+        options.ban_heuristic = ban_heuristic != 0;
 
         const pdcode_simplify::PDCode code = pdcode_simplify::parse_pd_code(text);
         std::size_t crossingless = static_cast<std::size_t>(known_crossingless_components);

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp

@@ -7,6 +7,7 @@
 #include <limits>
 #include <map>
 #include <numeric>
+#include <queue>
 #include <random>
 #include <set>
 #include <sstream>
@@ -18,6 +19,11 @@ namespace pdcode_simplify {
 namespace {
 
 constexpr int kBlockedWeight = 10000;
+constexpr int kHeuristicBeamWidth = 8;
+constexpr int kHeuristicMinStateBudget = 128;
+constexpr int kHeuristicMaxStateBudget = 4096;
+constexpr int kHeuristicMinPathBudget = 24;
+constexpr int kHeuristicMaxPathBudget = 384;
 
 int positive_mod(int value, int modulus) {
     int result = value % modulus;
@@ -1076,6 +1082,203 @@ std::vector<std::vector<int>> collect_simple_paths(
     return paths;
 }
 
+std::vector<int> heuristic_distances_to_target(
+    const DualGraph& graph,
+    int target,
+    int cutoff) {
+    const int face_count = static_cast<int>(graph.faces.size());
+    const int infinity = std::numeric_limits<int>::max() / 4;
+    std::vector<int> distance(face_count, infinity);
+    std::deque<int> queue;
+    distance[target] = 0;
+    queue.push_back(target);
+
+    while (!queue.empty()) {
+        const int current = queue.front();
+        queue.pop_front();
+        for (int edge_index : graph.adjacency[current]) {
+            const GraphEdge& edge = graph.edges[edge_index];
+            if (edge.weight >= cutoff) {
+                continue;
+            }
+            const int next = edge.u == current ? edge.v : edge.u;
+            if (distance[next] != infinity) {
+                continue;
+            }
+            distance[next] = distance[current] + 1;
+            queue.push_back(next);
+        }
+    }
+    return distance;
+}
+
+struct HeuristicState {
+    std::vector<int> path;
+    std::vector<char> visited;
+    int weight = 0;
+    int branch_penalty = 0;
+    int estimated_weight = 0;
+    int estimated_length = 0;
+    int serial = 0;
+};
+
+struct HeuristicStateWorse {
+    bool operator()(const HeuristicState& lhs, const HeuristicState& rhs) const {
+        if (lhs.estimated_weight != rhs.estimated_weight) {
+            return lhs.estimated_weight > rhs.estimated_weight;
+        }
+        if (lhs.estimated_length != rhs.estimated_length) {
+            return lhs.estimated_length > rhs.estimated_length;
+        }
+        if (lhs.branch_penalty != rhs.branch_penalty) {
+            return lhs.branch_penalty > rhs.branch_penalty;
+        }
+        if (lhs.weight != rhs.weight) {
+            return lhs.weight > rhs.weight;
+        }
+        if (lhs.path.size() != rhs.path.size()) {
+            return lhs.path.size() > rhs.path.size();
+        }
+        return lhs.serial > rhs.serial;
+    }
+};
+
+struct HeuristicStep {
+    int next = -1;
+    int edge_index = -1;
+    int edge_weight = 0;
+    int distance = 0;
+    int degree_penalty = 0;
+};
+
+bool heuristic_step_less(const HeuristicStep& lhs, const HeuristicStep& rhs) {
+    if (lhs.edge_weight != rhs.edge_weight) {
+        return lhs.edge_weight < rhs.edge_weight;
+    }
+    if (lhs.distance != rhs.distance) {
+        return lhs.distance < rhs.distance;
+    }
+    if (lhs.degree_penalty != rhs.degree_penalty) {
+        return lhs.degree_penalty < rhs.degree_penalty;
+    }
+    if (lhs.next != rhs.next) {
+        return lhs.next < rhs.next;
+    }
+    return lhs.edge_index < rhs.edge_index;
+}
+
+std::vector<std::vector<int>> collect_heuristic_paths(
+    const DualGraph& graph,
+    int source,
+    int target,
+    int cutoff) {
+    std::vector<std::vector<int>> paths;
+    const int face_count = static_cast<int>(graph.faces.size());
+    if (source == target || source < 0 || target < 0 ||
+        source >= face_count || target >= face_count || cutoff <= 0) {
+        return paths;
+    }
+
+    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff);
+    const int infinity = std::numeric_limits<int>::max() / 4;
+    if (distance[source] == infinity || distance[source] >= cutoff) {
+        return paths;
+    }
+
+    const int state_budget = std::max(
+        kHeuristicMinStateBudget,
+        std::min(kHeuristicMaxStateBudget, face_count * std::max(1, cutoff) * 8));
+    const int path_budget = std::max(
+        kHeuristicMinPathBudget,
+        std::min(kHeuristicMaxPathBudget, face_count * 2 + cutoff * 8));
+
+    std::priority_queue<HeuristicState, std::vector<HeuristicState>, HeuristicStateWorse> queue;
+    int serial = 0;
+    HeuristicState initial;
+    initial.path.push_back(source);
+    initial.visited.assign(face_count, false);
+    initial.visited[source] = true;
+    initial.estimated_weight = distance[source];
+    initial.estimated_length = distance[source];
+    initial.serial = serial++;
+    queue.push(initial);
+
+    std::map<long long, int> popped_by_depth_face;
+    int popped_states = 0;
+    while (!queue.empty() && popped_states < state_budget &&
+           static_cast<int>(paths.size()) < path_budget) {
+        HeuristicState state = queue.top();
+        queue.pop();
+        ++popped_states;
+
+        const int current = state.path.back();
+        const int depth = static_cast<int>(state.path.size()) - 1;
+        if (current == target) {
+            if (state.weight < cutoff) {
+                paths.push_back(state.path);
+            }
+            continue;
+        }
+        if (depth >= cutoff - 1) {
+            continue;
+        }
+
+        const long long beam_key =
+            static_cast<long long>(depth) * static_cast<long long>(face_count) + current;
+        int& beam_count = popped_by_depth_face[beam_key];
+        if (beam_count >= kHeuristicBeamWidth) {
+            continue;
+        }
+        ++beam_count;
+
+        std::vector<HeuristicStep> steps;
+        for (int edge_index : graph.adjacency[current]) {
+            const GraphEdge& edge = graph.edges[edge_index];
+            const int next = edge.u == current ? edge.v : edge.u;
+            if (state.visited[next]) {
+                continue;
+            }
+            if (distance[next] == infinity) {
+                continue;
+            }
+            const int new_weight = state.weight + edge.weight;
+            if (new_weight >= cutoff) {
+                continue;
+            }
+            const int new_depth = depth + 1;
+            if (new_depth + distance[next] >= cutoff) {
+                continue;
+            }
+            HeuristicStep step;
+            step.next = next;
+            step.edge_index = edge_index;
+            step.edge_weight = edge.weight;
+            step.distance = distance[next];
+            step.degree_penalty = std::max(0, static_cast<int>(graph.adjacency[next].size()) - 2);
+            steps.push_back(step);
+        }
+        std::sort(steps.begin(), steps.end(), heuristic_step_less);
+
+        for (const HeuristicStep& step : steps) {
+            const GraphEdge& edge = graph.edges[step.edge_index];
+            HeuristicState next_state;
+            next_state.path = state.path;
+            next_state.path.push_back(step.next);
+            next_state.visited = state.visited;
+            next_state.visited[step.next] = true;
+            next_state.weight = state.weight + edge.weight;
+            next_state.branch_penalty = state.branch_penalty + step.degree_penalty;
+            next_state.estimated_weight = next_state.weight + distance[step.next];
+            next_state.estimated_length =
+                static_cast<int>(next_state.path.size()) - 1 + distance[step.next];
+            next_state.serial = serial++;
+            queue.push(std::move(next_state));
+        }
+    }
+
+    return paths;
+}
+
 bool contains_endpoint_key(const std::vector<int>& endpoints, int key) {
     return std::find(endpoints.begin(), endpoints.end(), key) != endpoints.end();
 }
@@ -1627,6 +1830,13 @@ SimplificationResult find_simplification(
     const PDCode& code,
     const SimplifierOptions& options) {
     SimplificationResult result;
+    if (options.max_paths == -1 && !options.ban_heuristic) {
+        result.path_search_mode = "heuristic";
+    } else if (options.max_paths == -1) {
+        result.path_search_mode = "bruteforce";
+    } else {
+        result.path_search_mode = "bounded";
+    }
     Diagram diagram(code);
     DualGraph graph(diagram);
     const auto red_lines = possible_red_lines(diagram);
@@ -1657,7 +1867,12 @@ SimplificationResult find_simplification(
         const int cutoff = static_cast<int>(red_path.size()) - 1;
         for (int source : sources) {
             for (int destination : destinations) {
-                auto found_paths = collect_simple_paths(graph, source, destination, cutoff, options.max_paths);
+                std::vector<std::vector<int>> found_paths;
+                if (options.max_paths == -1 && !options.ban_heuristic) {
+                    found_paths = collect_heuristic_paths(graph, source, destination, cutoff);
+                } else {
+                    found_paths = collect_simple_paths(graph, source, destination, cutoff, options.max_paths);
+                }
                 paths.insert(paths.end(), found_paths.begin(), found_paths.end());
                 if (options.max_paths != -1 && static_cast<int>(paths.size()) > options.max_paths) {
                     break;

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/cpp_pd_code_simplify_interface/main.py

@@ -87,6 +87,72 @@ def normalize_pd_codes(pd_codes: PdManyInput) -> list[str]:
     return [normalize_pd_code(pd_code) for pd_code in pd_codes]
 
 
+def _label_for_block(text: str, block_start: int, label_prefix: str, index: int) -> str:
+    line_start = text.rfind("\n", 0, block_start)
+    line_start = 0 if line_start == -1 else line_start + 1
+    before_block = text[line_start:block_start]
+    if ":" in before_block:
+        line_label = before_block.split(":", 1)[0].strip()
+        if line_label:
+            return f"{label_prefix}:{line_label}"
+    if index == 0:
+        return label_prefix
+    return f"{label_prefix}#{index + 1}"
+
+
+def _pd_file_jobs(path: str) -> list[tuple[str, str]]:
+    text = pathlib.Path(path).read_text(encoding="utf-8")
+    jobs: list[tuple[str, str]] = []
+    position = 0
+    index = 0
+
+    while True:
+        start = text.find("PD[", position)
+        if start == -1:
+            break
+        depth = 0
+        end = -1
+        for cursor in range(start + 2, len(text)):
+            if text[cursor] == "[":
+                depth += 1
+            elif text[cursor] == "]":
+                depth -= 1
+                if depth == 0:
+                    end = cursor
+                    break
+        if end == -1:
+            jobs.append((f"{path}#{index + 1}", text[start:].strip()))
+            break
+        jobs.append((
+            _label_for_block(text, start, path, index),
+            text[start : end + 1],
+        ))
+        index += 1
+        position = end + 1
+
+    if jobs:
+        if len(jobs) == 1:
+            jobs[0] = (path, jobs[0][1])
+        return jobs
+
+    for line in text.splitlines():
+        cleaned = line.strip()
+        if not cleaned or cleaned.startswith("#"):
+            continue
+        label = path
+        payload = cleaned
+        if ":" in cleaned:
+            line_label, payload = cleaned.split(":", 1)
+            line_label = line_label.strip()
+            payload = payload.strip()
+            if line_label:
+                label = f"{path}:{line_label}"
+        elif jobs:
+            label = f"{path}#{len(jobs) + 1}"
+        jobs.append((label, payload))
+    return jobs
+
+
 @contextlib.contextmanager
 def _resource_paths():
     package = "cpp_pd_code_simplify_interface"
@@ -335,6 +401,7 @@ def _load_library() -> ctypes.CDLL:
     library.pdcode_simplify_run_json.argtypes = [
         ctypes.c_char_p,
         ctypes.c_int,
+        ctypes.c_int,
         ctypes.c_ulonglong,
         ctypes.POINTER(ctypes.c_int),
         ctypes.c_ulonglong,
@@ -350,7 +417,8 @@ def _load_library() -> ctypes.CDLL:
 def _run_one(
     pd_text: str,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> dict[str, Any]:
@@ -363,6 +431,7 @@ def _run_one(
     pointer = library.pdcode_simplify_run_json(
         pd_text.encode("utf-8"),
         int(max_paths),
+        1 if ban_heuristic else 0,
         int(known_crossingless_components),
         removed_array,
         int(removed_count),
@@ -386,7 +455,8 @@ def _run_one(
 def simplify(
     pd_code: PdInput,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> dict[str, Any]:
@@ -395,6 +465,7 @@ def simplify(
     return _run_one(
         normalize_pd_code(pd_code),
         max_paths=max_paths,
+        ban_heuristic=ban_heuristic,
         known_crossingless_components=known_crossingless_components,
         remove_crossings=remove_crossings,
     )
@@ -403,7 +474,8 @@ def simplify(
 def simplify_many(
     pd_codes: PdManyInput,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> list[dict[str, Any]]:
@@ -413,6 +485,7 @@ def simplify_many(
         _run_one(
             pd_text,
             max_paths=max_paths,
+            ban_heuristic=ban_heuristic,
             known_crossingless_components=known_crossingless_components,
             remove_crossings=remove_crossings,
         )
@@ -424,7 +497,8 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     parser = argparse.ArgumentParser(description="Run cpp-pd-code-simplify through the Python interface.")
     parser.add_argument("pd_code", nargs="?", help="PD code as PD[...] text or a Python-style list of crossings.")
     parser.add_argument("--pd-file", "-f", help="read one file containing one or more labelled PD-code lines")
-    parser.add_argument("--max-paths", type=int, default=100)
+    parser.add_argument("--max-paths", type=int, default=-1)
+    parser.add_argument("--ban-heuristic", action="store_true")
     parser.add_argument("--known-crossingless-components", type=int, default=0)
     parser.add_argument("--remove-crossings", help="comma-separated zero-based crossing indices")
     args = parser.parse_args(argv)
@@ -436,38 +510,41 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     if args.remove_crossings:
         remove_crossings = [int(token) for token in re.findall(r"-?\d+", args.remove_crossings)]
 
+    exit_code = 0
     if args.pd_file:
-        lines = []
-        for line in pathlib.Path(args.pd_file).read_text(encoding="utf-8").splitlines():
-            cleaned = line.strip()
-            if not cleaned or cleaned.startswith("#"):
-                continue
-            payload = cleaned.split(":", 1)[1].strip() if ":" in cleaned else cleaned
-            lines.append(payload)
+        jobs = _pd_file_jobs(args.pd_file)
         batch_payload = []
-        for line in lines:
+        show_labels = len(jobs) > 1
+        for label, line in jobs:
             try:
-                batch_payload.append(
-                    simplify(
-                        line,
-                        max_paths=args.max_paths,
-                        known_crossingless_components=args.known_crossingless_components,
-                        remove_crossings=remove_crossings,
-                    )
+                item = simplify(
+                    line,
+                    max_paths=args.max_paths,
+                    ban_heuristic=args.ban_heuristic,
+                    known_crossingless_components=args.known_crossingless_components,
+                    remove_crossings=remove_crossings,
                 )
+                if show_labels:
+                    item = {"label": label, **item}
+                batch_payload.append(item)
             except Exception as exc:
-                batch_payload.append({"error": str(exc)})
+                exit_code = 2
+                item = {"error": str(exc)}
+                if show_labels:
+                    item = {"label": label, **item}
+                batch_payload.append(item)
         payload: Any = batch_payload
     else:
         payload = simplify(
             args.pd_code or "",
             max_paths=args.max_paths,
+            ban_heuristic=args.ban_heuristic,
             known_crossingless_components=args.known_crossingless_components,
             remove_crossings=remove_crossings,
         )
 
     print(json.dumps(payload, indent=2))
-    return 0
+    return exit_code
 
 
 if __name__ == "__main__":

{cpp_pd_code_simplify_interface-0.1.0 → cpp_pd_code_simplify_interface-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cpp-pd-code-simplify-interface"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python interface for cpp-pd-code-simplify with runtime C++ compilation."
 authors = [
     {name = "GGN_2015", email = "neko@jlulug.org"}