link-rep-to-pd-code 0.0.1__tar.gz

link_rep_to_pd_code-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TopologicalKnotIndexer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

link_rep_to_pd_code-0.0.1/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: link-rep-to-pd-code
+Version: 0.0.1
+Summary: given a link-rep, output its pd_code for the composite link or knot.
+License: MIT
+License-File: LICENSE
+Author: GGN_2015
+Author-email: neko@jlulug.org
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: link_rep
+Requires-Dist: pd_code_components
+Requires-Dist: pd_code_connected_sum
+Requires-Dist: pd_code_sanity
+Description-Content-Type: text/markdown
+
+# link_rep_to_pd_code
+given a link-rep, output its pd_code for the composite link or knot.
+

link_rep_to_pd_code-0.0.1/README.md

@@ -0,0 +1,2 @@
+# link_rep_to_pd_code
+given a link-rep, output its pd_code for the composite link or knot.

link_rep_to_pd_code-0.0.1/link_rep_to_pd_code/__init__.py

@@ -0,0 +1,5 @@
+from .main import link_rep_to_pd_code
+
+__all__ = [
+    "link_rep_to_pd_code"
+]

link_rep_to_pd_code-0.0.1/link_rep_to_pd_code/main.py

@@ -0,0 +1,162 @@
+import pd_code_sanity
+import link_rep
+import pd_code_components
+import pd_code_connected_sum
+
+# 内置 packages
+import json
+
+def link_components(pd_code_list:list[list[list]], link_method:link_rep.LinkMethod):
+    if not isinstance(link_method, link_rep.LinkMethod):
+        raise TypeError()
+
+    # 构建一个未进行连接的所有扭结的映射
+    # 每当一个 link 被连接到其他分量了，就将 link_dict 中对应位置设为 None
+    link_dict = {}
+    for i in range(len(pd_code_list)):
+        link_dict[i] = pd_code_list[i]
+
+    # 记录每一个连通分支的代表元
+    # 代表元的编号实时变化
+    components_rep_dict = {}
+    for i in range(len(pd_code_list)):
+        all_components = pd_code_components.get_components_from_pd_code(pd_code_list[i])
+        all_reps = sorted([ # 第一个元素作为代表元
+            component[0]
+            for component in all_components
+        ])
+        components_rep_dict[i] = [ # (i, item) 表示这个代表元在第 i 个链环上
+            (i, item)              # 随着合并进程，i 和 item 值可能发生改变
+            for item in all_reps
+        ]
+
+    # 给所有编号减一
+    def sub_one(lis:list[int]) -> list[int]:
+        return [
+            item - 1
+            for item in lis]
+
+    for link_term in link_method.component_list:
+        a_id, a_rep_idx = sub_one(link_term.component_list[0])
+        b_id, b_rep_idx = sub_one(link_term.component_list[1])
+
+        # 计算他们现在所在的位置
+        now_a_id, now_a_rep_idx = components_rep_dict[a_id][a_rep_idx]
+        now_b_id, now_b_rep_idx = components_rep_dict[b_id][b_rep_idx]
+
+        if now_a_id == now_b_id: # 不能反复连接已经连接到一起的扭结
+            raise AssertionError()
+        
+        # 两个 pd_code
+        old_pd_code_a, link_dict[now_a_id] = link_dict[now_a_id], None
+        old_pd_code_b, link_dict[now_b_id] = link_dict[now_b_id], None
+
+        if old_pd_code_a is None:
+            raise AssertionError()
+        
+        if old_pd_code_b is None:
+            raise AssertionError()
+
+        # 获得新的扭结 pd_code 以及编号映射规则
+        new_pd_code, num_map = pd_code_connected_sum.connected_sum(
+            old_pd_code_a,
+            old_pd_code_b,
+            now_a_rep_idx,
+            now_b_rep_idx
+        )
+
+        # 占据前者的连通分支
+        link_dict[now_a_id] = new_pd_code
+
+        # 重新编写代表元编号
+        for i in range(len(components_rep_dict[a_id])):
+            _, old_a_rep = components_rep_dict[a_id][i]
+            components_rep_dict[a_id][i] = (now_a_id, num_map["a_" + str(old_a_rep)])
+
+        for i in range(len(components_rep_dict[b_id])):
+            _, old_b_rep = components_rep_dict[b_id][i]
+            components_rep_dict[b_id][i] = (now_a_id, num_map["b_" + str(old_b_rep)])
+
+    # 确保合并到最后恰好只剩下一个连通分支
+    not_none_list = []
+    for num in link_dict:
+        if link_dict[num] is not None:
+            not_none_list.append(link_dict[num])
+
+    if len(not_none_list) != 1: # 有 N 个连通分支，则会连接 N - 1 次
+        raise AssertionError()
+    
+    return not_none_list[0]
+
+def link_rep_to_pd_code(link_rep_str:str) -> list[list]:
+    link_rep_item = link_rep.LinkRep()
+    link_rep_item.deserialize(link_rep_str)
+
+    # 记录扭结名称到 pd_code 的映射
+    var_map = link_rep_item.var_def.var_map
+    name_map_to_pd_code = dict()
+
+    # 检查 PD_CODE 和 扭结名称类型
+    for var_link_id, var_pd_code in var_map:
+        if not pd_code_sanity.sanity(var_pd_code):
+            raise TypeError()
+        if not isinstance(var_link_id, link_rep.LinkId):
+            raise TypeError()
+        
+    # 记录变量名到 pd_code 的映射
+    for var_link_id, var_pd_code in var_map:
+        name_map_to_pd_code[var_link_id.serialize()] = var_pd_code
+
+    # 依次获取所有 link 素分量的 pd_code
+    pd_code_list = []
+    for item in link_rep_item.link_set.var_list:
+        var_name_now = item.serialize()
+        if name_map_to_pd_code.get(var_name_now) is None: # 没有找到相关的错误
+            raise ValueError()
+        pd_code_list.append(name_map_to_pd_code[var_name_now])
+
+    # 只有一个素分量的情况
+    if len(pd_code_list) == 1:
+        return pd_code_list[0]
+    
+    # 返回一个相对复杂的连接过程
+    return link_components(pd_code_list, link_rep_item.link_method)
+
+def _test():
+    import com_link_gen_10 # 除了测试部分外，不依赖这个包
+    import random
+    
+    # 随机生成的一组测试数据
+    TEST_DATA = json.loads(r'{"3": "// automatically generated by com-link-gen-10 (version:0.0.3)\n// - command: com_link_gen(10, 3)\nmL2a1: [[4, 2, 3, 1], [2, 4, 1, 3]]\nmK3a1: [[1, 4, 2, 5], [3, 6, 4, 1], [5, 2, 6, 3]]\nmL4a1: [[6, 2, 7, 1], [8, 4, 5, 3], [2, 6, 3, 5], [4, 8, 1, 7]]\n[mL2a1, mK3a1, mL4a1]\nL[1, 1]#L[2, 1]\nL[1, 1]#L[3, 1]\n", "1": "// automatically generated by com-link-gen-10 (version:0.0.3)\n// - command: com_link_gen(10, 3)\nK8a8: [[1, 7, 2, 6], [3, 12, 4, 13], [5, 9, 6, 8], [7, 3, 8, 2], [9, 16, 10, 1], [11, 14, 12, 15], [13, 4, 14, 5], [15, 10, 16, 11]]\n[K8a8]\n", "2": "// automatically generated by com-link-gen-10 (version:0.0.3)\n// - command: com_link_gen(10, 3)\nmK3a1: [[1, 4, 2, 5], [3, 6, 4, 1], [5, 2, 6, 3]]\nmK7a1: [[1, 8, 2, 9], [3, 10, 4, 11], [5, 12, 6, 13], [7, 14, 8, 1], [9, 2, 10, 3], [11, 4, 12, 5], [13, 6, 14, 7]]\n[mK3a1, mK7a1]\nL[1, 1]#L[2, 1]\n"}')
+    TEST_DATA_1 = TEST_DATA["1"]
+    TEST_DATA_2 = TEST_DATA["2"]
+    TEST_DATA_3 = TEST_DATA["3"]
+
+    # 生成一个基础测试
+    K3a1_K3a1 = """
+// this test case is manually configaured.
+K3a1: [[1, 5, 2, 4], [3, 1, 4, 6], [5, 3, 6, 2]]
+[K3a1, K3a1, K3a1]
+L[1, 1]#L[2, 1]
+L[1, 1]#L[3, 1]
+""".lstrip()
+
+    # 随机生成的测试数据
+    def random_test_data() -> dict[str, str]:
+        prime_cnt_to_obj = dict()
+        sequence = com_link_gen_10.com_link_gen(10, 3)
+        random.shuffle(sequence)
+
+        for link_rep_str in sequence:
+            link_rep_item = link_rep.LinkRep()
+            link_rep_item.deserialize(link_rep_str)
+
+            prime_cnt = len(link_rep_item.link_set.var_list)
+            if prime_cnt_to_obj.get(prime_cnt) is None:
+                prime_cnt_to_obj[prime_cnt] = link_rep_str
+        return prime_cnt_to_obj
+
+    print(link_rep_to_pd_code(K3a1_K3a1))
+
+if __name__ == "__main__":
+    _test()

link_rep_to_pd_code-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "link-rep-to-pd-code"
+version = "0.0.1"
+description = "given a link-rep, output its pd_code for the composite link or knot."
+authors = [
+    {name = "GGN_2015",email = "neko@jlulug.org"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pd_code_sanity",
+    "link_rep",
+    "pd_code_components",
+    "pd_code_connected_sum"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"