syntropy-phi-c 0.1.0__py3-none-any.whl

phi_c/__init__.py

@@ -0,0 +1,9 @@
+from .topology import compute_simplicial_nerve
+from .motifs import compute_motif_discrimination
+from .pacemaker import find_pacemaker
+
+__all__ = [
+    'compute_simplicial_nerve',
+    'compute_motif_discrimination',
+    'find_pacemaker'
+]

phi_c/motifs.py

@@ -0,0 +1,33 @@
+import networkx as nx
+
+def compute_motif_discrimination(G: nx.DiGraph) -> dict:
+    """
+    The 'Cerebellum Filter'.
+    Identifies strict rhythmic feedback loops (A <-> B) and penalizes 
+    nodes that only participate in dense feed-forward structures.
+    
+    Returns:
+        dict: Mapping of node to its Motif Reciprocity Multiplier (0.0 to 1.0+).
+    """
+    reciprocity_scores = {}
+    
+    for node in G.nodes():
+        out_edges = set(G.successors(node))
+        in_edges = set(G.predecessors(node))
+        
+        # Reciprocal edges: where A -> B and B -> A
+        reciprocal = out_edges.intersection(in_edges)
+        total_connections = len(out_edges.union(in_edges))
+        
+        if total_connections == 0:
+            reciprocity_scores[node] = 0.0
+        else:
+            # Ratio of purely bidirectional edges over all edges
+            # A true pacemaker has high bidirectionality (rhythmic feedback)
+            ratio = len(reciprocal) / total_connections
+            
+            # Penalize pure feed-forward (ratio near 0)
+            # Boost high feedback (ratio > 0.5)
+            reciprocity_scores[node] = ratio ** 2
+            
+    return reciprocity_scores

phi_c/pacemaker.py

@@ -0,0 +1,31 @@
+import networkx as nx
+from .topology import compute_simplicial_nerve
+from .motifs import compute_motif_discrimination
+
+def find_pacemaker(G: nx.DiGraph, top_k: int = 5) -> list:
+    """
+    The main Phi_C algorithm.
+    Crosses raw structural density (Simplicial Nerve) with the 
+    directional feedback filter (Motif Discriminator) to output
+    the absolute Central Pattern Generator (CPG) hot-spots.
+    
+    Args:
+        G (nx.DiGraph): The connectome graph.
+        top_k (int): Number of top pacemaker candidate nodes to return.
+        
+    Returns:
+        list: Top K nodes sorted by final Phi_C pacemaker score.
+    """
+    raw_density = compute_simplicial_nerve(G)
+    motif_multiplier = compute_motif_discrimination(G)
+    
+    final_scores = {}
+    for node in G.nodes():
+        # The Final Phi_C metric: 
+        # High Density * High Reciprocity = True Pacemaker
+        # High Density * Low Reciprocity (Cerebellum trap) = Dropped to 0
+        final_scores[node] = raw_density[node] * motif_multiplier[node]
+        
+    # Sort by score descending
+    ranked_nodes = sorted(final_scores.items(), key=lambda item: item[1], reverse=True)
+    return ranked_nodes[:top_k]

phi_c/topology.py

@@ -0,0 +1,34 @@
+import networkx as nx
+import numpy as np
+
+def compute_simplicial_nerve(G: nx.DiGraph) -> dict:
+    """
+    Computes the fast O(N) structural simplicial nerve density (Phi_C proxy) 
+    for each node in a Directed Graph.
+    
+    Instead of calculating exact O(2^N) Integration Information (Phi), 
+    we measure the local graph density (clique-like structures) and 
+    eigenvector centrality to act as a topological pre-filter.
+    
+    Returns:
+        dict: Mapping of node to its raw structural density score.
+    """
+    # Use undirected version for pure structural density
+    G_undirected = G.to_undirected()
+    
+    # 1. Local Clustering Coefficient (measure of local simplices/triangles)
+    clustering = nx.clustering(G_undirected)
+    
+    # 2. Eigenvector Centrality (measure of global network influence)
+    try:
+        centrality = nx.eigenvector_centrality_numpy(G)
+    except Exception:
+        # Fallback if matrix is perfectly un-diagonalizable
+        centrality = nx.degree_centrality(G)
+        
+    scores = {}
+    for node in G.nodes():
+        # The topological heuristic Phi_C raw
+        scores[node] = clustering[node] * centrality[node] * 1000
+        
+    return scores

syntropy_phi_c-0.1.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: syntropy-phi-c
+Version: 0.1.0
+Summary: A Fast Topological Heuristic for Connectome Pacemakers
+Author: Syntropy Project (Alex Lopes da Silva)
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: networkx>=2.5
+Dynamic: author
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

syntropy_phi_c-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+phi_c/__init__.py,sha256=S1eYFp7AEcdmCjokf-EuXfuRO3RA3hRG_TyZp3FIJPA,238
+phi_c/motifs.py,sha256=CkcGD11cE4jYOtkAaYXjqaroogBxHWoDKWlLD7oUt1o,1193
+phi_c/pacemaker.py,sha256=P_P4q7g2gtIPE-HUWCytwS8SZ7g7X2T5GnCwk4GiZVs,1187
+phi_c/topology.py,sha256=OHdwQQKCXHyp1bbnZKhMzb7a-84jGFFQ_2BaKsJ5rmU,1201
+syntropy_phi_c-0.1.0.dist-info/licenses/LICENSE,sha256=HiGEABO2XU-NCZW0p2cBXyiFvXh57aGErJ9YzzwMQdo,2963
+syntropy_phi_c-0.1.0.dist-info/METADATA,sha256=K-FFr1dItTnsaN86VsxOj9sjmGeACBk7Ydsztvwmbtw,681
+syntropy_phi_c-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+syntropy_phi_c-0.1.0.dist-info/top_level.txt,sha256=ouZQrnAz7ELdGdYsoQM4RXL2L1GLaWxTEYYD99QXvEE,6
+syntropy_phi_c-0.1.0.dist-info/RECORD,,

syntropy_phi_c-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

syntropy_phi_c-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,59 @@
+Copyright (C) 2026 Syntropy Project (Alex Lopes da Silva) e Colaboradores.
+
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.

syntropy_phi_c-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+phi_c