cpp-pd-code-simplify-interface 0.1.17__tar.gz → 0.1.19__tar.gz

{cpp_pd_code_simplify_interface-0.1.17 → cpp_pd_code_simplify_interface-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpp-pd-code-simplify-interface
-Version: 0.1.17
+Version: 0.1.19
 Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -79,7 +79,8 @@ the C++ backend for that phase. The backend call runs in a helper process, so
 `Ctrl+C` can terminate active C++ work and its worker threads cleanly.
 Use `show_step_pd=True`, or CLI flag `--show-step-pd`, to print
 `step_pd_code[ROUND]: PD[...]` to stdout after each mid-simplification witness
-is applied and before that round's automatic R1/nugatory cleanup.
+is applied and canonicalized, before that round's automatic R1/nugatory
+cleanup.
 
 Batch use:
 

{cpp_pd_code_simplify_interface-0.1.17 → cpp_pd_code_simplify_interface-0.1.19}/README.md

@@ -59,7 +59,8 @@ the C++ backend for that phase. The backend call runs in a helper process, so
 `Ctrl+C` can terminate active C++ work and its worker threads cleanly.
 Use `show_step_pd=True`, or CLI flag `--show-step-pd`, to print
 `step_pd_code[ROUND]: PD[...]` to stdout after each mid-simplification witness
-is applied and before that round's automatic R1/nugatory cleanup.
+is applied and canonicalized, before that round's automatic R1/nugatory
+cleanup.
 
 Batch use:
 

{cpp_pd_code_simplify_interface-0.1.17 → cpp_pd_code_simplify_interface-0.1.19}/cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp

@@ -68,6 +68,8 @@ struct CrossingState {
 
 using LabelMap = std::unordered_map<int, std::vector<Endpoint>>;
 
+PDCode canonical_output_code(const PDCode& code);
+
 LabelMap build_label_map(const PDCode& code) {
     LabelMap labels;
     for (int c = 0; c < static_cast<int>(code.size()); ++c) {
@@ -227,6 +229,7 @@ PDCode erase_r1_moves(PDCode code, std::size_t& crossingless_components, int& mo
             }
 
             crossingless_components = after_removal.crossingless_components;
+            code = canonical_output_code(code);
             ++moves;
             changed = true;
             break;
@@ -237,7 +240,7 @@ PDCode erase_r1_moves(PDCode code, std::size_t& crossingless_components, int& mo
         }
     }
 
-    return renumber_r1_order(code);
+    return canonical_output_code(renumber_r1_order(code));
 }
 
 std::map<int, std::set<int>> base_pd_graph(const PDCode& code) {
@@ -457,7 +460,7 @@ PDCode erase_one_nugatory_crossing(
     code = replace_arc_value(code, dx, bx);
     crossingless_components = after_removal.crossingless_components;
     ++moves;
-    return renumber_full_dfs(code);
+    return canonical_output_code(renumber_full_dfs(code));
 }
 
 std::vector<std::vector<int>> raw_faces_from_pd_code(const PDCode& code) {
@@ -1320,7 +1323,9 @@ bool do_check(
     const std::vector<Endpoint>& red_path,
     const std::vector<int>& green_path,
     Direction direction,
-    SimplificationResult& result) {
+    SimplificationResult& result,
+    const SimplifierOptions& options) {
+    check_timeout(options);
     std::vector<int> green_left_cross;
     green_left_cross.reserve(green_path.size());
 
@@ -1375,14 +1380,24 @@ bool do_check(
 
     bool good_path = true;
     while (!to_check.empty() && good_path) {
+        check_timeout(options);
         const int start_key = to_check.back();
         to_check.pop_back();
         queued.erase(start_key);
         Endpoint cross_strand = endpoint_from_key(start_key);
+        std::unordered_set<long long> trace_seen;
 
         while (true) {
+            check_timeout(options);
             const int cross_key = endpoint_key(cross_strand);
             const Level current_level = check_result.at(cross_key);
+            const long long trace_key =
+                (static_cast<long long>(cross_key) << 1) ^
+                static_cast<int>(current_level);
+            if (!trace_seen.insert(trace_key).second) {
+                good_path = false;
+                break;
+            }
             const Endpoint opposite = diagram.opposite(cross_strand);
             const int opposite_key = endpoint_key(opposite);
             const auto opposite_result = check_result.find(opposite_key);
@@ -1842,14 +1857,6 @@ void emit_step_pd(const SimplifierOptions& options, int round, const PDCode& cod
     }
 }
 
-std::string no_path_restart_signature(
-    const PDCode& code,
-    std::size_t crossingless_components) {
-    std::ostringstream out;
-    out << crossingless_components << ':' << format_final_pd_code(code);
-    return out.str();
-}
-
 PDCode canonical_output_code(const PDCode& code) {
     return parse_pd_code(format_final_pd_code(code));
 }
@@ -2199,7 +2206,7 @@ PDSimplificationResult simplify_pd_code(
     const PDCode& code,
     std::size_t known_crossingless_components) {
     PDSimplificationResult result;
-    result.code = code;
+    result.code = canonical_output_code(code);
     result.crossingless_components = known_crossingless_components;
 
     result.code = erase_r1_moves(
@@ -2350,7 +2357,14 @@ RedPathSearchOutcome search_single_red_path(
         if (green_path.size() >= red_path.size()) {
             continue;
         }
-        if (do_check(diagram, graph, red_path, green_path, Direction::Left, outcome.witness)) {
+        if (do_check(
+                diagram,
+                graph,
+                red_path,
+                green_path,
+                Direction::Left,
+                outcome.witness,
+                options)) {
             if (!options.require_applicable || witness_has_applicable_surgery(code, outcome.witness)) {
                 outcome.found = true;
                 outcome.completed = true;
@@ -2359,7 +2373,14 @@ RedPathSearchOutcome search_single_red_path(
             }
             clear_witness(outcome.witness);
         }
-        if (do_check(diagram, graph, red_path, green_path, Direction::Right, outcome.witness)) {
+        if (do_check(
+                diagram,
+                graph,
+                red_path,
+                green_path,
+                Direction::Right,
+                outcome.witness,
+                options)) {
             if (!options.require_applicable || witness_has_applicable_surgery(code, outcome.witness)) {
                 outcome.found = true;
                 outcome.completed = true;
@@ -2550,7 +2571,6 @@ ReductionResult reduce_pd_code(
     ReductionResult output;
     output.code = code;
     output.crossingless_components = known_crossingless_components;
-    std::set<std::string> exhausted_no_path_signatures;
 
     try {
         check_timeout(run_options);
@@ -2568,7 +2588,7 @@ ReductionResult reduce_pd_code(
 
         const PDSimplificationResult prepared =
             simplify_pd_code(code, known_crossingless_components);
-        output.code = prepared.code;
+        output.code = canonical_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;
@@ -2643,45 +2663,6 @@ ReductionResult reduce_pd_code(
             }
 
             if (!search.found) {
-                if (run_options.max_paths == -1) {
-                    check_timeout(run_options);
-                    const std::string signature = no_path_restart_signature(
-                        output.code, output.crossingless_components);
-                    if (exhausted_no_path_signatures.insert(signature).second) {
-                        const std::size_t before_restart_crossings = output.code.size();
-                        const std::size_t before_restart_crossingless =
-                            output.crossingless_components;
-                        const PDSimplificationResult restarted =
-                            simplify_pd_code(
-                                canonical_output_code(output.code),
-                                output.crossingless_components);
-                        const bool changed =
-                            restarted.code != output.code ||
-                            restarted.crossingless_components != output.crossingless_components;
-                        output.code = restarted.code;
-                        output.crossingless_components = restarted.crossingless_components;
-                        output.reidemeister_i_moves += restarted.reidemeister_i_moves;
-                        output.nugatory_crossing_moves += restarted.nugatory_crossing_moves;
-                        {
-                            std::ostringstream message;
-                            message << "round " << round
-                                    << " canonical_restart changed="
-                                    << (changed ? "yes" : "no")
-                                    << " crossings=" << before_restart_crossings
-                                    << " -> " << output.code.size()
-                                    << " crossingless_components="
-                                    << before_restart_crossingless
-                                    << " -> " << output.crossingless_components
-                                    << " r1_moves=" << restarted.reidemeister_i_moves
-                                    << " nugatory_moves="
-                                    << restarted.nugatory_crossing_moves;
-                            emit_progress(run_options, message.str());
-                        }
-                        if (changed) {
-                            continue;
-                        }
-                    }
-                }
                 {
                     std::ostringstream message;
                     message << "round " << round
@@ -2695,14 +2676,15 @@ ReductionResult reduce_pd_code(
             check_timeout(run_options);
             const MidSimplificationApplyResult applied =
                 apply_simplification_witness(output.code, search, output.crossingless_components);
+            const PDCode applied_code = canonical_output_code(applied.code);
             ++output.mid_simplification_rounds;
-            emit_step_pd(run_options, round, applied.code);
-            output.code = applied.code;
+            emit_step_pd(run_options, round, applied_code);
+            output.code = applied_code;
             output.crossingless_components = applied.crossingless_components;
             check_timeout(run_options);
             const PDSimplificationResult simplified =
                 simplify_pd_code(output.code, output.crossingless_components);
-            output.code = simplified.code;
+            output.code = canonical_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;

{cpp_pd_code_simplify_interface-0.1.17 → cpp_pd_code_simplify_interface-0.1.19}/pyproject.toml

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