Recursive-Decay-Ranking

The problem

Organizing complex, nested paths becomes difficult when you need to prioritize items based on how deep they are buried in a system.

What it does

It ranks nested paths by applying a decaying priority score that changes as you move deeper into the hierarchy.

Why it matters

It provides a clear way to see which nested paths hold the most importance as they move through a system.

Validation

It was run inside an isolated container with no network access. This is the exact command and the real output it produced — captured process output, not written by a model.

$ python3 recursive_decay_ranking.py
Traceback (most recent call last):
  File "/work/ranker.py", line 16, in <module>
    sys.exit(main())
             ^^^^^^
  File "/work/ranker.py", line 8, in main
    root.add_path(['user', 'profile', 'dashboard'], base_priority=2.0)
  File "/work/recursive_decay_ranking.py", line 15, in add_path
    current = current.children[part]
              ~~~~~~~~~~~~~~~~^^^^^^
  File "/work/recursive_decay_ranking.py", line 8, in <lambda>
    self.children = defaultdict(lambda: StateNode(decay_factor=decay_factor * 0.9))
                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: StateNode.__init__() missing 1 required positional argument: 'name'

A screenshot of that run.

A clean run proves this does what is shown above, in a CPU-only sandbox. It is a small research demo — not a production tool, and nothing here was published anywhere.

The code

All of it — 55 lines, one file, standard library only.

# recursive_decay_ranking.py # v2 with Path-Weighting
from collections import defaultdict
import json

class StateNode:
    def __init__(self, name, priority=1.0, decay_factor=0.8, path_weight=1.0):
        self.name = name
        self.priority = priority
        self.children = defaultdict(lambda: StateNode(decay_factor=decay_factor * 0.9, path_weight=path_weight))
        self.decay_factor = decay_factor
        self.path_weight = path_weight  # New weighting multiplier
        self.max_depth = 5  # Prevent infinite recursion

    def add_path(self, path, base_priority=1.0, path_weight=1.0):
        current = self
        for i, part in enumerate(path):
            # Apply weighting at each level based on depth
            current.children[part] = StateNode(
                part,
                priority=base_priority * (0.95 ** len(path)),
                decay_factor=current.decay_factor,
                path_weight=path_weight * (1.2 if i == len(path)-1 else 1)  # Demo weighting
            )
            current = current.children[part]

    def recursive_decay_ranking(self, path=None, current_depth=0):
        if current_depth > self.max_depth:
            return []
        
        results = [(self.name, self.priority)]
        
        # Apply path-weighting to child priorities
        for child in self.children.values():
            child_priority = child.priority * self.path_weight * child.path_weight
            results.append((f'{self.name}.{child.name}', child_priority))
            
            # Recursively process children with adjusted depth
            child_results = child.recursive_decay_ranking(
                path=path or [],
                current_depth=current_depth + 1
            )
            results.extend(child_results)
        
        # Sort by priority descending and return
        return sorted(results, key=lambda x: -x[1])

if __name__ == '__main__':
    root = StateNode('root', decay_factor=0.8)
    # Demo with path-weighting
    root.add_path(['user', 'profile', 'dashboard'], base_priority=2.0, path_weight=1.5)
    root.add_path(['admin', 'logs', 'errors'], base_priority=3.0, path_weight=0.8)
    root.add_path(['public', 'docs'], base_priority=1.5, path_weight=1.0)
    
    ranked = root.recursive_decay_ranking()
    print(json.dumps(ranked, indent=2))