Recursive-Task-Decomposition-Complexity

The problem

Large, complex projects are often difficult to manage because they are broken down into tasks that are either too vague or not detailed enough.

What it does

It analyzes a multi-step instruction and calculates a score based on how deeply and thoroughly the work has been broken down into smaller pieces.

Why it matters

It provides a clear metric to measure how well a complex goal has been organized into actionable steps.

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_task_decomposition_scorer.py
Recursive Task Decomposition Complexity Score: 44

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 — 41 lines, one file, standard library only.

# Recursive Task Decomposition Complexity Scorer

class Task:
    def __init__(self, description, subtasks=None):
        self.description = description
        self.subtasks = subtasks if subtasks else []

def calculate_decomposition_complexity(root_task):
    def _traverse(task):
        if not task.subtasks:
            return 1, 1  # depth, coverage
        total_coverage = len(task.subtasks)
        max_depth = 0
        for subtask in task.subtasks:
            depth, coverage = _traverse(subtask)
            total_coverage += coverage
            max_depth = max(max_depth, depth)
        return max_depth + 1, total_coverage

    max_depth, total_coverage = _traverse(root_task)
    complexity_score = max_depth * total_coverage
    return complexity_score

# Example Usage
if __name__ == "__main__":
    # Create a sample task hierarchy
    root_task = Task("Main Objective", [
        Task("Subtask A", [
            Task("Subtask A.1"),
            Task("Subtask A.2")
        ]),
        Task("Subtask B", [
            Task("Subtask B.1", [
                Task("Subtask B.1.1")
            ])
        ]),
        Task("Subtask C")
    ])

    score = calculate_decomposition_complexity(root_task)
    print(f"Recursive Task Decomposition Complexity Score: {score}")