cpp-pd-code-simplify-interface 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -2,6 +2,7 @@
 
 #include <array>
 #include <cstddef>
+#include <functional>
 #include <iosfwd>
 #include <string>
 #include <vector>
@@ -48,7 +49,11 @@ struct GreenCrossing {
 };
 
 struct SimplifierOptions {
-    int max_paths = 100;
+    int max_paths = -1;
+    bool ban_heuristic = false;
+    bool require_applicable = false;
+    bool verbose = false;
+    std::function<void(const std::string&)> progress;
 };
 
 struct LinkComponentSummary {
@@ -98,6 +103,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;
@@ -105,6 +111,24 @@ struct SimplificationResult {
     std::size_t tested_green_paths = 0;
 };
 
+struct MidSimplificationApplyResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+};
+
+struct ReductionResult {
+    PDCode code;
+    std::size_t crossingless_components = 0;
+    int mid_simplification_rounds = 0;
+    int heuristic_failover_rounds = 0;
+    int reidemeister_i_moves = 0;
+    int nugatory_crossing_moves = 0;
+    std::size_t tested_red_paths = 0;
+    std::size_t tested_green_paths = 0;
+    std::string last_path_search_mode;
+    bool stopped_by_round_limit = false;
+};
+
 PDCODE_SIMPLIFY_API PDCode parse_pd_code(const std::string& text);
 PDCODE_SIMPLIFY_API std::string format_pd_code(const PDCode& code);
 PDCODE_SIMPLIFY_API std::string format_endpoint(const Endpoint& endpoint);
@@ -140,6 +164,17 @@ PDCODE_SIMPLIFY_API SimplificationResult find_simplification(
     const PDCode& code,
     const SimplifierOptions& options = SimplifierOptions{});
 
+PDCODE_SIMPLIFY_API MidSimplificationApplyResult apply_simplification_witness(
+    const PDCode& code,
+    const SimplificationResult& result,
+    std::size_t known_crossingless_components = 0);
+
+PDCODE_SIMPLIFY_API ReductionResult reduce_pd_code(
+    const PDCode& code,
+    std::size_t known_crossingless_components = 0,
+    const SimplifierOptions& options = SimplifierOptions{},
+    int reduction_round = -1);
+
 PDCODE_SIMPLIFY_API std::ostream& operator<<(std::ostream& out, const Endpoint& endpoint);
 
 }  // namespace pdcode_simplify

cpp_pd_code_simplify_interface/data/src/native_interface.cpp

@@ -3,6 +3,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <exception>
+#include <iostream>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -55,14 +56,14 @@ void append_component_counts(
 }
 
 std::string result_to_json(
-    const pdcode_simplify::SimplificationResult& result,
+    const pdcode_simplify::ReductionResult& result,
     const pdcode_simplify::ComponentAnalysis& input_components,
-    const pdcode_simplify::ComponentAnalysis* after_removal_components,
-    const pdcode_simplify::PDSimplificationResult& pd_simplification,
-    const pdcode_simplify::ComponentAnalysis& search_components) {
+    const pdcode_simplify::ComponentAnalysis& final_components,
+    const pdcode_simplify::ComponentAnalysis* after_removal_components) {
     std::ostringstream out;
     out << "{";
-    out << "\"simplification_found\":" << (result.found ? "true" : "false") << ",";
+    out << "\"simplification_found\":"
+        << (result.mid_simplification_rounds > 0 ? "true" : "false") << ",";
     out << "\"input_components\":{";
     append_component_counts(out, input_components);
     out << "},";
@@ -71,49 +72,21 @@ std::string result_to_json(
         append_component_counts(out, *after_removal_components);
         out << "},";
     }
-    out << "\"pd_simplification\":{"
-        << "\"enabled\":true,"
-        << "\"reidemeister_i_moves\":" << pd_simplification.reidemeister_i_moves << ","
-        << "\"nugatory_crossing_moves\":" << pd_simplification.nugatory_crossing_moves << ","
-        << "\"output_crossings\":" << pd_simplification.code.size()
-        << "},";
-    out << "\"search_components\":{";
-    append_component_counts(out, search_components);
+    out << "\"final_pd_code\":\"" << json_escape(pdcode_simplify::format_pd_code(result.code))
+        << "\",";
+    out << "\"final_crossings\":" << result.code.size() << ",";
+    out << "\"final_components\":{";
+    append_component_counts(out, final_components);
     out << "},";
+    out << "\"mid_simplification_rounds\":" << result.mid_simplification_rounds << ",";
+    out << "\"heuristic_failover_rounds\":" << result.heuristic_failover_rounds << ",";
+    out << "\"reidemeister_i_moves\":" << result.reidemeister_i_moves << ",";
+    out << "\"nugatory_crossing_moves\":" << result.nugatory_crossing_moves << ",";
     out << "\"tested_red_paths\":" << result.tested_red_paths << ",";
-    out << "\"tested_green_paths\":" << result.tested_green_paths;
-    if (result.found) {
-        out << ",";
-        out << "\"direction\":\"" << pdcode_simplify::format_direction(result.direction) << "\",";
-        out << "\"red_path\":[";
-        for (std::size_t i = 0; i < result.red_path.size(); ++i) {
-            if (i != 0) {
-                out << ",";
-            }
-            out << "{\"crossing\":" << result.red_path[i].crossing
-                << ",\"strand\":" << result.red_path[i].strand << "}";
-        }
-        out << "],";
-        out << "\"green_path\":[";
-        for (std::size_t i = 0; i < result.green_path.size(); ++i) {
-            if (i != 0) {
-                out << ",";
-            }
-            out << result.green_path[i];
-        }
-        out << "],";
-        out << "\"green_crossings\":[";
-        for (std::size_t i = 0; i < result.green_crossings.size(); ++i) {
-            if (i != 0) {
-                out << ",";
-            }
-            const auto& crossing = result.green_crossings[i];
-            out << "{\"from_face\":" << crossing.from_face
-                << ",\"to_face\":" << crossing.to_face
-                << ",\"strand_level\":\"" << json_escape(crossing.strand_level) << "\"}";
-        }
-        out << "]";
-    }
+    out << "\"tested_green_paths\":" << result.tested_green_paths << ",";
+    out << "\"last_path_search_mode\":\"" << json_escape(result.last_path_search_mode) << "\",";
+    out << "\"stopped_by_round_limit\":"
+        << (result.stopped_by_round_limit ? "true" : "false");
     out << "}";
     return out.str();
 }
@@ -137,6 +110,9 @@ __declspec(dllexport)
 char* pdcode_simplify_run_json(
     const char* pd_text,
     int max_paths,
+    int ban_heuristic,
+    int reduction_round,
+    int verbose,
     unsigned long long known_crossingless_components,
     const int* removed_crossings,
     unsigned long long removed_crossing_count) {
@@ -148,6 +124,11 @@ 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;
+        options.verbose = verbose != 0;
+        options.progress = [](const std::string& message) {
+            std::cerr << "[pdcode-simplify] " << message << '\n';
+        };
 
         const pdcode_simplify::PDCode code = pdcode_simplify::parse_pd_code(text);
         std::size_t crossingless = static_cast<std::size_t>(known_crossingless_components);
@@ -167,17 +148,15 @@ char* pdcode_simplify_run_json(
                     code, removed, crossingless);
         }
 
-        const auto pd_simplification = pdcode_simplify::simplify_pd_code(code, crossingless);
-        const auto search_components = pdcode_simplify::analyze_components(
-            pd_simplification.code,
-            pd_simplification.crossingless_components);
-        const auto result = pdcode_simplify::find_simplification(pd_simplification.code, options);
+        const auto result =
+            pdcode_simplify::reduce_pd_code(code, crossingless, options, reduction_round);
+        const auto final_components =
+            pdcode_simplify::analyze_components(result.code, result.crossingless_components);
         return copy_string(result_to_json(
             result,
             input_components,
-            has_removal ? &after_removal_components : nullptr,
-            pd_simplification,
-            search_components));
+            final_components,
+            has_removal ? &after_removal_components : nullptr));
     } catch (const std::exception& error) {
         return copy_string(std::string("{\"error\":\"") + json_escape(error.what()) + "\"}");
     } catch (...) {

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;
@@ -998,18 +1004,30 @@ void reset_weights(DualGraph& graph) {
     }
 }
 
+std::vector<int> heuristic_distances_to_target(
+    const DualGraph& graph,
+    int target,
+    int cutoff);
+
 void collect_simple_paths_dfs(
     const DualGraph& graph,
     int current,
     int target,
     int cutoff,
     int max_paths,
+    int current_weight,
+    const std::vector<int>& distance,
     std::vector<char>& visited,
     std::vector<int>& current_path,
     std::vector<std::vector<int>>& paths) {
+    const int infinity = std::numeric_limits<int>::max() / 4;
     if (static_cast<int>(current_path.size()) - 1 >= cutoff) {
         return;
     }
+    if (current < 0 || current >= static_cast<int>(distance.size()) ||
+        distance[current] == infinity || current_weight + distance[current] >= cutoff) {
+        return;
+    }
 
     for (int edge_index : graph.adjacency[current]) {
         const GraphEdge& edge = graph.edges[edge_index];
@@ -1017,32 +1035,37 @@ void collect_simple_paths_dfs(
         if (visited[next]) {
             continue;
         }
+        const int next_weight = current_weight + edge.weight;
+        if (next_weight >= cutoff) {
+            continue;
+        }
+        if (next < 0 || next >= static_cast<int>(distance.size()) ||
+            distance[next] == infinity || next_weight + distance[next] >= cutoff) {
+            continue;
+        }
 
         current_path.push_back(next);
         visited[next] = true;
 
         if (next == target) {
-            int path_weight = 0;
-            for (std::size_t i = 0; i + 1 < current_path.size(); ++i) {
-                const GraphEdge* path_edge = graph.edge(current_path[i], current_path[i + 1]);
-                if (path_edge == nullptr) {
-                    throw std::logic_error("Missing dual edge while weighing a path");
-                }
-                path_weight += path_edge->weight;
-                if (path_weight >= cutoff) {
-                    break;
-                }
-            }
-            if (path_weight < cutoff) {
-                paths.push_back(current_path);
-            }
+            paths.push_back(current_path);
             if (max_paths != -1 && static_cast<int>(paths.size()) > max_paths) {
                 visited[next] = false;
                 current_path.pop_back();
                 return;
             }
         } else {
-            collect_simple_paths_dfs(graph, next, target, cutoff, max_paths, visited, current_path, paths);
+            collect_simple_paths_dfs(
+                graph,
+                next,
+                target,
+                cutoff,
+                max_paths,
+                next_weight,
+                distance,
+                visited,
+                current_path,
+                paths);
             if (max_paths != -1 && static_cast<int>(paths.size()) > max_paths) {
                 visited[next] = false;
                 current_path.pop_back();
@@ -1071,8 +1094,216 @@ std::vector<std::vector<int>> collect_simple_paths(
 
     std::vector<char> visited(graph.faces.size(), false);
     std::vector<int> current_path{source};
+    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff);
     visited[source] = true;
-    collect_simple_paths_dfs(graph, source, target, cutoff, max_paths, visited, current_path, paths);
+    collect_simple_paths_dfs(
+        graph,
+        source,
+        target,
+        cutoff,
+        max_paths,
+        0,
+        distance,
+        visited,
+        current_path,
+        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;
 }
 
@@ -1243,6 +1474,292 @@ bool do_check(
     return true;
 }
 
+class DisjointSet {
+public:
+    int find(int value) {
+        auto inserted = parent_.insert(std::make_pair(value, value));
+        int parent = inserted.first->second;
+        if (parent != value) {
+            parent = find(parent);
+            parent_[value] = parent;
+        }
+        return parent;
+    }
+
+    void unite(int first, int second) {
+        int first_root = find(first);
+        int second_root = find(second);
+        if (first_root == second_root) {
+            return;
+        }
+        if (second_root < first_root) {
+            std::swap(first_root, second_root);
+        }
+        parent_[second_root] = first_root;
+    }
+
+private:
+    std::map<int, int> parent_;
+};
+
+std::map<std::pair<int, int>, std::string> green_crossing_levels(
+    const SimplificationResult& result) {
+    std::map<std::pair<int, int>, std::string> levels;
+    for (const GreenCrossing& crossing : result.green_crossings) {
+        levels[std::make_pair(crossing.from_face, crossing.to_face)] = crossing.strand_level;
+    }
+    return levels;
+}
+
+void clear_witness(SimplificationResult& result) {
+    result.found = false;
+    result.red_path.clear();
+    result.green_path.clear();
+    result.green_crossings.clear();
+}
+
+}  // namespace
+
+MidSimplificationApplyResult apply_simplification_witness(
+    const PDCode& code,
+    const SimplificationResult& result,
+    std::size_t known_crossingless_components) {
+    if (!result.found) {
+        throw std::invalid_argument("Cannot apply a missing simplification witness");
+    }
+    if (result.red_path.size() < 2) {
+        throw std::invalid_argument("Simplification witness red path is too short");
+    }
+
+    Diagram diagram(code);
+    DualGraph graph(diagram);
+    std::set<int> removed_crossings;
+    std::map<int, int> red_entry_by_crossing;
+    for (std::size_t i = 0; i + 1 < result.red_path.size(); ++i) {
+        removed_crossings.insert(result.red_path[i].crossing);
+        red_entry_by_crossing[result.red_path[i].crossing] = result.red_path[i].strand;
+    }
+    if (removed_crossings.size() != result.red_path.size() - 1) {
+        throw std::invalid_argument("Simplification witness repeats a removed red crossing");
+    }
+    if (removed_crossings.count(result.red_path.back().crossing) != 0) {
+        throw std::invalid_argument("Simplification witness ends inside the removed red arc");
+    }
+
+    const std::map<std::pair<int, int>, std::string> levels = green_crossing_levels(result);
+    DisjointSet dsu;
+    const int endpoint_count = static_cast<int>(code.size() * 4);
+    const int new_crossing_count =
+        result.green_path.empty() ? 0 : static_cast<int>(result.green_path.size()) - 1;
+    const int new_base = endpoint_count;
+
+    auto new_node = [&](int crossing_index, int strand) {
+        return new_base + crossing_index * 4 + strand;
+    };
+    auto is_removed_node = [&](int node) {
+        return node < endpoint_count && removed_crossings.count(node / 4) != 0;
+    };
+    auto is_removed_red_node = [&](int node) {
+        if (!is_removed_node(node)) {
+            return false;
+        }
+        const int crossing = node / 4;
+        const int strand = node % 4;
+        const int red_strand = red_entry_by_crossing.at(crossing);
+        return strand == red_strand || strand == positive_mod(red_strand + 2, 4);
+    };
+
+    std::set<int> crossed_labels;
+    struct CrossedEdge {
+        int interface_from = -1;
+        int interface_to = -1;
+        std::string level;
+    };
+    std::vector<CrossedEdge> crossed_edges;
+    crossed_edges.reserve(new_crossing_count);
+    for (int i = 0; i < new_crossing_count; ++i) {
+        const int from_face = result.green_path[i];
+        const int to_face = result.green_path[i + 1];
+        const GraphEdge* edge = graph.edge(from_face, to_face);
+        if (edge == nullptr) {
+            throw std::invalid_argument("Simplification witness green path crosses a missing dual edge");
+        }
+        const int interface_from = graph.interface_for_face(*edge, from_face);
+        const int interface_to = graph.interface_for_face(*edge, to_face);
+        if (is_removed_red_node(interface_from) || is_removed_red_node(interface_to)) {
+            throw std::invalid_argument("Simplification witness crosses an edge removed with the red arc");
+        }
+        const int label = code[interface_from / 4][interface_from % 4];
+        if (!crossed_labels.insert(label).second) {
+            throw std::invalid_argument("Simplification witness crosses the same PD edge more than once");
+        }
+        const auto level = levels.find(std::make_pair(from_face, to_face));
+        if (level == levels.end()) {
+            throw std::invalid_argument("Simplification witness is missing a green crossing level");
+        }
+        CrossedEdge crossed;
+        crossed.interface_from = interface_from;
+        crossed.interface_to = interface_to;
+        crossed.level = level->second;
+        crossed_edges.push_back(std::move(crossed));
+    }
+
+    std::map<int, std::vector<int>> label_endpoints;
+    for (int crossing_index = 0; crossing_index < static_cast<int>(code.size()); ++crossing_index) {
+        for (int strand = 0; strand < 4; ++strand) {
+            label_endpoints[code[crossing_index][strand]].push_back(crossing_index * 4 + strand);
+        }
+    }
+    for (const auto& item : label_endpoints) {
+        if (item.second.size() != 2) {
+            std::ostringstream message;
+            message << "PD label " << item.first << " appears " << item.second.size() << " times";
+            throw std::invalid_argument(message.str());
+        }
+        if (crossed_labels.count(item.first) == 0) {
+            dsu.unite(item.second[0], item.second[1]);
+        }
+    }
+
+    for (const auto& item : red_entry_by_crossing) {
+        const int crossing = item.first;
+        const int strand = item.second;
+        dsu.unite(crossing * 4 + positive_mod(strand + 1, 4),
+                  crossing * 4 + positive_mod(strand + 3, 4));
+    }
+
+    int green_anchor = endpoint_key(result.red_path.front());
+    for (int i = 0; i < static_cast<int>(crossed_edges.size()); ++i) {
+        const CrossedEdge& crossed = crossed_edges[i];
+        int existing_from_pos = -1;
+        int existing_to_pos = -1;
+        int green_in_pos = -1;
+        int green_out_pos = -1;
+        if (crossed.level == "over") {
+            existing_from_pos = 0;
+            green_in_pos = 1;
+            existing_to_pos = 2;
+            green_out_pos = 3;
+        } else if (crossed.level == "under") {
+            green_in_pos = 0;
+            existing_to_pos = 1;
+            green_out_pos = 2;
+            existing_from_pos = 3;
+        } else {
+            throw std::invalid_argument("Unknown green crossing strand level: " + crossed.level);
+        }
+
+        dsu.unite(crossed.interface_from, new_node(i, existing_from_pos));
+        dsu.unite(crossed.interface_to, new_node(i, existing_to_pos));
+        dsu.unite(green_anchor, new_node(i, green_in_pos));
+        green_anchor = new_node(i, green_out_pos);
+    }
+    dsu.unite(green_anchor, endpoint_key(result.red_path.back()));
+
+    std::vector<int> active_nodes;
+    active_nodes.reserve(endpoint_count + new_crossing_count * 4);
+    for (int node = 0; node < endpoint_count; ++node) {
+        if (!is_removed_node(node)) {
+            active_nodes.push_back(node);
+        }
+    }
+    for (int crossing = 0; crossing < new_crossing_count; ++crossing) {
+        for (int strand = 0; strand < 4; ++strand) {
+            active_nodes.push_back(new_node(crossing, strand));
+        }
+    }
+
+    std::map<int, std::vector<int>> grouped;
+    for (int node : active_nodes) {
+        grouped[dsu.find(node)].push_back(node);
+    }
+
+    std::vector<std::vector<int>> groups;
+    for (auto& item : grouped) {
+        std::sort(item.second.begin(), item.second.end());
+        groups.push_back(item.second);
+    }
+    std::sort(groups.begin(), groups.end(), [](const std::vector<int>& lhs, const std::vector<int>& rhs) {
+        return lhs.front() < rhs.front();
+    });
+
+    std::map<int, int> label_by_node;
+    int next_label = 0;
+    for (const std::vector<int>& nodes : groups) {
+        if (nodes.size() != 2) {
+            std::ostringstream message;
+            message << "Applied simplification produced a non-PD edge with "
+                    << nodes.size() << " active endpoints";
+            throw std::runtime_error(message.str());
+        }
+        for (int node : nodes) {
+            label_by_node[node] = next_label;
+        }
+        ++next_label;
+    }
+
+    PDCode output;
+    output.reserve(code.size() - removed_crossings.size() + static_cast<std::size_t>(new_crossing_count));
+    for (int crossing_index = 0; crossing_index < static_cast<int>(code.size()); ++crossing_index) {
+        if (removed_crossings.count(crossing_index) != 0) {
+            continue;
+        }
+        Crossing crossing{};
+        for (int strand = 0; strand < 4; ++strand) {
+            crossing[strand] = label_by_node.at(crossing_index * 4 + strand);
+        }
+        output.push_back(crossing);
+    }
+    for (int crossing_index = 0; crossing_index < new_crossing_count; ++crossing_index) {
+        Crossing crossing{};
+        for (int strand = 0; strand < 4; ++strand) {
+            crossing[strand] = label_by_node.at(new_node(crossing_index, strand));
+        }
+        output.push_back(crossing);
+    }
+
+    const std::size_t total_components =
+        analyze_components(code, known_crossingless_components).total_components();
+    output = renumber_full_dfs(output);
+    const std::size_t crossing_components = analyze_components(output).components_with_crossings();
+
+    MidSimplificationApplyResult applied;
+    applied.code = std::move(output);
+    applied.crossingless_components =
+        total_components > crossing_components ? total_components - crossing_components : 0;
+    return applied;
+}
+
+namespace {
+
+bool witness_has_applicable_surgery(const PDCode& code, const SimplificationResult& result) {
+    try {
+        (void)apply_simplification_witness(code, result, 0);
+        return true;
+    } catch (const std::exception&) {
+        return false;
+    }
+}
+
+void emit_progress(const SimplifierOptions& options, const std::string& message) {
+    if (!options.verbose) {
+        return;
+    }
+    if (options.progress) {
+        options.progress(message);
+    }
+}
+
+std::string search_mode_for_options(const SimplifierOptions& options) {
+    if (options.max_paths == -1 && !options.ban_heuristic) {
+        return "heuristic";
+    }
+    if (options.max_paths == -1) {
+        return "bruteforce";
+    }
+    return "bounded";
+}
+
 }  // namespace
 
 PDCode parse_pd_code(const std::string& text) {
@@ -1283,13 +1800,13 @@ PDCode parse_pd_code(const std::string& text) {
 
 std::string format_pd_code(const PDCode& code) {
     std::ostringstream out;
-    out << '[';
+    out << "PD[";
     for (std::size_t i = 0; i < code.size(); ++i) {
         if (i != 0) {
-            out << ", ";
+            out << ',';
         }
-        out << '(' << code[i][0] << ", " << code[i][1] << ", "
-            << code[i][2] << ", " << code[i][3] << ')';
+        out << "X[" << code[i][0] << ',' << code[i][1] << ','
+            << code[i][2] << ',' << code[i][3] << ']';
     }
     out << ']';
     return out.str();
@@ -1627,6 +2144,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 +2181,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;
@@ -1671,10 +2200,16 @@ SimplificationResult find_simplification(
                 continue;
             }
             if (do_check(diagram, graph, red_path, green_path, Direction::Left, result)) {
-                return result;
+                if (!options.require_applicable || witness_has_applicable_surgery(code, result)) {
+                    return result;
+                }
+                clear_witness(result);
             }
             if (do_check(diagram, graph, red_path, green_path, Direction::Right, result)) {
-                return result;
+                if (!options.require_applicable || witness_has_applicable_surgery(code, result)) {
+                    return result;
+                }
+                clear_witness(result);
             }
         }
     }
@@ -1682,6 +2217,140 @@ SimplificationResult find_simplification(
     return result;
 }
 
+ReductionResult reduce_pd_code(
+    const PDCode& code,
+    std::size_t known_crossingless_components,
+    const SimplifierOptions& options,
+    int reduction_round) {
+    {
+        std::ostringstream message;
+        message << "start input_crossings=" << code.size()
+                << " known_crossingless_components=" << known_crossingless_components
+                << " reduction_round=" << reduction_round
+                << " max_paths=" << options.max_paths
+                << " heuristic=" << (options.ban_heuristic ? "off" : "on");
+        emit_progress(options, message.str());
+    }
+
+    const PDSimplificationResult prepared = simplify_pd_code(code, known_crossingless_components);
+    ReductionResult output;
+    output.code = prepared.code;
+    output.crossingless_components = prepared.crossingless_components;
+    output.reidemeister_i_moves = prepared.reidemeister_i_moves;
+    output.nugatory_crossing_moves = prepared.nugatory_crossing_moves;
+    {
+        std::ostringstream message;
+        message << "pre_simplify input_crossings=" << code.size()
+                << " output_crossings=" << output.code.size()
+                << " crossingless_components=" << output.crossingless_components
+                << " r1_moves=" << prepared.reidemeister_i_moves
+                << " nugatory_moves=" << prepared.nugatory_crossing_moves;
+        emit_progress(options, message.str());
+    }
+
+    while (reduction_round < 0 || output.mid_simplification_rounds < reduction_round) {
+        SimplifierOptions search_options = options;
+        search_options.require_applicable = true;
+        const int round = output.mid_simplification_rounds + 1;
+        {
+            std::ostringstream message;
+            message << "round " << round
+                    << " search_start crossings=" << output.code.size()
+                    << " mode=" << search_mode_for_options(search_options);
+            emit_progress(options, message.str());
+        }
+        SimplificationResult search = find_simplification(output.code, search_options);
+        output.tested_red_paths += search.tested_red_paths;
+        output.tested_green_paths += search.tested_green_paths;
+        output.last_path_search_mode = search.path_search_mode;
+        {
+            std::ostringstream message;
+            message << "round " << round
+                    << " search_done found=" << (search.found ? "yes" : "no")
+                    << " mode=" << search.path_search_mode
+                    << " tested_red=" << search.tested_red_paths
+                    << " tested_green=" << search.tested_green_paths;
+            emit_progress(options, message.str());
+        }
+
+        if (!search.found && reduction_round < 0 &&
+            options.max_paths == -1 && !options.ban_heuristic) {
+            SimplifierOptions brute_options = options;
+            brute_options.max_paths = -1;
+            brute_options.ban_heuristic = true;
+            brute_options.require_applicable = true;
+            {
+                std::ostringstream message;
+                message << "round " << round
+                        << " brute_fallback_start crossings=" << output.code.size();
+                emit_progress(options, message.str());
+            }
+            SimplificationResult brute = find_simplification(output.code, brute_options);
+            output.tested_red_paths += brute.tested_red_paths;
+            output.tested_green_paths += brute.tested_green_paths;
+            output.last_path_search_mode = brute.path_search_mode;
+            {
+                std::ostringstream message;
+                message << "round " << round
+                        << " brute_fallback_done found=" << (brute.found ? "yes" : "no")
+                        << " tested_red=" << brute.tested_red_paths
+                        << " tested_green=" << brute.tested_green_paths;
+                emit_progress(options, message.str());
+            }
+            if (brute.found) {
+                ++output.heuristic_failover_rounds;
+                search = std::move(brute);
+            }
+        }
+
+        if (!search.found) {
+            {
+                std::ostringstream message;
+                message << "round " << round
+                        << " stop_no_path crossings=" << output.code.size();
+                emit_progress(options, message.str());
+            }
+            break;
+        }
+
+        const std::size_t before_apply_crossings = output.code.size();
+        const MidSimplificationApplyResult applied =
+            apply_simplification_witness(output.code, search, output.crossingless_components);
+        ++output.mid_simplification_rounds;
+        const PDSimplificationResult simplified =
+            simplify_pd_code(applied.code, applied.crossingless_components);
+        output.code = simplified.code;
+        output.crossingless_components = simplified.crossingless_components;
+        output.reidemeister_i_moves += simplified.reidemeister_i_moves;
+        output.nugatory_crossing_moves += simplified.nugatory_crossing_moves;
+        {
+            std::ostringstream message;
+            message << "round " << round
+                    << " applied crossings=" << before_apply_crossings
+                    << " -> " << applied.code.size()
+                    << " -> " << output.code.size()
+                    << " crossingless_components=" << output.crossingless_components
+                    << " r1_moves=" << simplified.reidemeister_i_moves
+                    << " nugatory_moves=" << simplified.nugatory_crossing_moves;
+            emit_progress(options, message.str());
+        }
+    }
+
+    output.stopped_by_round_limit =
+        reduction_round >= 0 && output.mid_simplification_rounds >= reduction_round;
+    {
+        std::ostringstream message;
+        message << "done final_crossings=" << output.code.size()
+                << " crossingless_components=" << output.crossingless_components
+                << " mid_rounds=" << output.mid_simplification_rounds
+                << " heuristic_failover_rounds=" << output.heuristic_failover_rounds
+                << " stopped_by_round_limit="
+                << (output.stopped_by_round_limit ? "yes" : "no");
+        emit_progress(options, message.str());
+    }
+    return output;
+}
+
 std::ostream& operator<<(std::ostream& out, const Endpoint& endpoint) {
     out << format_endpoint(endpoint);
     return out;

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,9 @@ def _load_library() -> ctypes.CDLL:
     library.pdcode_simplify_run_json.argtypes = [
         ctypes.c_char_p,
         ctypes.c_int,
+        ctypes.c_int,
+        ctypes.c_int,
+        ctypes.c_int,
         ctypes.c_ulonglong,
         ctypes.POINTER(ctypes.c_int),
         ctypes.c_ulonglong,
@@ -350,10 +419,15 @@ def _load_library() -> ctypes.CDLL:
 def _run_one(
     pd_text: str,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
+    reduction_round: int = -1,
+    verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> dict[str, Any]:
+    if reduction_round < -1:
+        raise ValueError("reduction_round must be -1 or a non-negative integer")
     library = _load_library()
     removed_count = 0 if remove_crossings is None else len(remove_crossings)
     removed_array = None
@@ -363,6 +437,9 @@ def _run_one(
     pointer = library.pdcode_simplify_run_json(
         pd_text.encode("utf-8"),
         int(max_paths),
+        1 if ban_heuristic else 0,
+        int(reduction_round),
+        1 if verbose else 0,
         int(known_crossingless_components),
         removed_array,
         int(removed_count),
@@ -386,7 +463,10 @@ def _run_one(
 def simplify(
     pd_code: PdInput,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
+    reduction_round: int = -1,
+    verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> dict[str, Any]:
@@ -395,6 +475,9 @@ def simplify(
     return _run_one(
         normalize_pd_code(pd_code),
         max_paths=max_paths,
+        ban_heuristic=ban_heuristic,
+        reduction_round=reduction_round,
+        verbose=verbose,
         known_crossingless_components=known_crossingless_components,
         remove_crossings=remove_crossings,
     )
@@ -403,7 +486,10 @@ def simplify(
 def simplify_many(
     pd_codes: PdManyInput,
     *,
-    max_paths: int = 100,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
+    reduction_round: int = -1,
+    verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
 ) -> list[dict[str, Any]]:
@@ -413,6 +499,9 @@ def simplify_many(
         _run_one(
             pd_text,
             max_paths=max_paths,
+            ban_heuristic=ban_heuristic,
+            reduction_round=reduction_round,
+            verbose=verbose,
             known_crossingless_components=known_crossingless_components,
             remove_crossings=remove_crossings,
         )
@@ -423,47 +512,61 @@ def simplify_many(
 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-code", "-c", dest="pd_code_option", help="literal PD[...] string")
     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("--reduction-round", type=int, default=-1)
+    parser.add_argument("--verbose", 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)
-    if args.pd_file and args.pd_code:
-        parser.error("pass either a positional PD code or --pd-file, not both")
-    if not args.pd_file and not args.pd_code:
-        parser.error("a positional PD code or --pd-file is required")
+    if args.reduction_round < -1:
+        parser.error("--reduction-round must be -1 or a non-negative integer")
+    if args.pd_code and args.pd_code_option:
+        parser.error("pass either a positional PD code or --pd-code, not both")
+    pd_code_text = args.pd_code_option or args.pd_code
+    if args.pd_file and pd_code_text:
+        parser.error("pass either a PD code or --pd-file, not both")
+    if not args.pd_file and not pd_code_text:
+        parser.error("a PD code or --pd-file is required")
     remove_crossings = None
     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,
+                    reduction_round=args.reduction_round,
+                    verbose=args.verbose,
+                    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:
                 exit_code = 2
-                batch_payload.append({"error": str(exc)})
+                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 "",
+            pd_code_text or "",
             max_paths=args.max_paths,
+            ban_heuristic=args.ban_heuristic,
+            reduction_round=args.reduction_round,
+            verbose=args.verbose,
             known_crossingless_components=args.known_crossingless_components,
             remove_crossings=remove_crossings,
         )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpp-pd-code-simplify-interface
-Version: 0.1.1
+Version: 0.1.3
 Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -35,7 +35,7 @@ use, the package compiles a cached local dynamic library through
 compiler compatible with `g++` must be available at runtime.
 
 Calls use the C++ library's default preprocessing pipeline: R1-move removal
-followed by nugatory-crossing removal.
+followed by nugatory-crossing removal, then iterative mid-simplification.
 
 ## Example
 
@@ -44,9 +44,15 @@ import cpp_pd_code_simplify_interface as simplify
 
 pd_code = "PD[X[1,5,2,4],X[3,1,4,6],X[5,3,6,2]]"
 result = simplify.simplify(pd_code)
-print(result["simplification_found"])
+print(result["final_pd_code"])
 ```
 
+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. Use `reduction_round=K` to cap applied
+mid-simplification rounds; the default `-1` runs until stable. Use
+`verbose=True` to forward C++ progress logs to stderr.
+
 Batch use:
 
 ```python
@@ -72,7 +78,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 --verbose
 ```
 
 ## Build And Publish

{cpp_pd_code_simplify_interface-0.1.1.dist-info → cpp_pd_code_simplify_interface-0.1.3.dist-info}/RECORD

@@ -1,11 +1,11 @@
 cpp_pd_code_simplify_interface/__init__.py,sha256=aaNwD--zgQX13xiU1hpuvgXy8vVTFGRk-r5zLm8zIRY,447
 cpp_pd_code_simplify_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
-cpp_pd_code_simplify_interface/main.py,sha256=WzXyd08Fo2zsVxJn0E6lrQD5KMttxIEIKD9TOMO3GzM,16527
+cpp_pd_code_simplify_interface/main.py,sha256=rKI0anvKvOlD4Z81P9IzYD4QyBQOsL_RiTMJ6ICavkQ,20045
 cpp_pd_code_simplify_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cpp_pd_code_simplify_interface-0.1.1.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
-cpp_pd_code_simplify_interface-0.1.1.dist-info/METADATA,sha256=0bCnhEvtBE0usciMtHeewd8Xqc7NTbZPJKiTk-2uAjg,2516
-cpp_pd_code_simplify_interface-0.1.1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=Ei2uKlmPxHrK7-uBiJfJB1zJE_lffmzm4s-qecVdI6k,4015
-cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=_YIi9ZN5-tsKhxCsCwAR3xQ7NL6tCsOnf4oJuQF2qmo,6709
-cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=jNH-678Jg4i3DA-CPcdiShks8EEcXMjtva0NN9L9E3g,58276
-cpp_pd_code_simplify_interface-0.1.1.dist-info/RECORD,,
+cpp_pd_code_simplify_interface-0.1.3.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
+cpp_pd_code_simplify_interface-0.1.3.dist-info/METADATA,sha256=Z-MzZTaFdaI7xDmLWlTv17CYYLVqHtmPo79V3U-71qA,2905
+cpp_pd_code_simplify_interface-0.1.3.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=7j5K9xrycVKXqDCCmeIq2nO9q22MUQSSsmOvfG481Ks,5136
+cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=zVBjjT5RYxBuBtKCCrfzLmyLcsnr6l2z8P5p_rBAj5U,6015
+cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=s3VJNUD_9kAlZpxBDbtObERHEIMZGiKhgmVOIANIjAo,83558
+cpp_pd_code_simplify_interface-0.1.3.dist-info/RECORD,,