Multipolar Task Processing Graph

• Multipolar Task Processing Graph (MTPG) is a directed acyclic graph framework that organizes task decomposition, processing, and fusion in multi-agent and parallel systems.
• It employs hierarchical divergence and convergence poles to manage uncertainty, iterative error correction, and rule-based feedback in task execution.
• MTPG constrains parallelism by modeling task conflicts and optimizing multitasking throughput while balancing learning efficiency with processing capacity.

A Multipolar Task Processing Graph (MTPG) is a directed acyclic graph framework that encodes the decomposition, processing, and fusion of tasks within multi-agent and parallel processing systems, with “poles” governing divergent and convergent multi-stream reasoning. MTPGs play a central role in advanced multi-agent cooperation (MA) frameworks for handling uncertainty, dynamic planning, and the tradeoff between learning/generalization versus processing efficiency. Two rigorous interpretations of MTPG have emerged: as the hierarchical controller structure in multi-agent cooperative reasoning (Yang et al., 12 Sep 2025), and as the task-interaction/conflict graph constraining multitasking throughput in parallel architectures (Petri et al., 2017).

1. Formal Structure and Definition

MTPG is formally defined as a DAG $\mathcal{G}=(\mathcal{V},\mathcal{E})$:

• $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$,
  • $T$: root/original task node (“divergent pole”).
  • $T_i$: subtask nodes (“intermediate poles”).
  • $F$: fusion node (“convergent pole”).
• $\mathcal{E} = \{(T,T_i)\} \cup \{(T_i,F)\}$; that is, edges from $T$ to each $T_i$ (divergence) and from each $T_i$ to $F$ (convergence).

Polarity assignment (“multipolarity”) is implicit: $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$0 triggers SIMO (single-input multiple-output) branching, $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$1 embodies MISO (multiple-input single-output) fusion. Subtasks $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$2 may themselves be recursively decomposed, yielding a hierarchical, dynamically evolving DAG. The construction, traversals, and updates of $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$3 are runtime-driven, modified by rule-based feedback to accommodate task uncertainty and agent interaction (Yang et al., 12 Sep 2025).

A related formalism (Petri et al., 2017) defines the MTPG as a “conflict graph” $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$4 over tasks/poles, where edges represent resource or representational conflicts detected via bipartite task-structure graphs. In this view, each node is a task/pole, and edges encode incompatibilities forbidding simultaneous execution.

2. Algorithmic Operation and Dynamics

The canonical algorithm over MTPG, as in the XAgents framework (Yang et al., 12 Sep 2025), consists of three principal phases:

1. Graph Construction The Planner Agent (PA) takes an uncertain input task $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$5, builds $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$6 with appropriate task/subtask/fusion nodes and initial edges.
2. Graph Execution (Task Decomposition, Processing, Fusion)
   • For each subtask node $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$7, a Domain Adaptor Agent (DAA) generates domain-specific IF-THEN rules, which are then executed by subagents.
   • Subtask outputs are aggregated by FEA_sub via majority voting plus membership scoring, forming tentative answers.
   • A global rule checks fusion/alignment with global objectives. Subtasks with insufficient membership (confidence) are reprocessed with adapted rules, possibly iteratively.
3. Autonomous Path (Re)construction If repeated failures occur (i.e., subtasks that do not align with global goals after several iterations), PA may prune the failing subgraph or further decompose broad ambiguous subtasks, thereby extending or reshaping $\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$8.

Pseudocode provided in (Yang et al., 12 Sep 2025) specifies subroutine interfaces (BuildMTPG, ExecuteMTPG, MaybeReconstructPath), with explicit invocation of rule construction, composition, and evaluation—including fuzzy membership calculations.

3. Uncertainty Management and Fusion in MTPG

MTPG facilitates complex task processing under uncertainty through:

• SIMO/MISO polarity at task divergence ($\mathcal{V} = \{T, T_1, \ldots, T_N, F\}$9) and fusion ($T$0), allowing multi-perspective exploration and robust answer integration.
• Membership evaluation: IF-part of each rule computes a membership degree $T$1. After subtask fusion, global membership $T$2 determines acceptance or the need for subgraph refinement.
• Adversarial fusion and voting: Two-layered conflict resolution—majority vote over conflicting outputs; ties broken by highest membership—achieves robustness without gradient-based end-to-end training.
• Rule-based feedback: Subtasks with membership below “ML” threshold are reprocessed or decomposed, supporting iterative reduction of output uncertainty and recovery from initial error or hallucination.

Empirical analysis (e.g., Table 8 (Yang et al., 12 Sep 2025)) shows the complexity of $T$3 (number of nodes/rules) grows linearly with task decomposition depth, and runtime remains competitive with alternative architectures.

4. MTPG as a Topological Constraint on Parallelism

In parallel processing literature, MTPG formalizes the limits of multitasking capacity in architectures with shared representations (Petri et al., 2017). The key elements are:

• Each node (“pole”) is a unique task, with edges marking cross-talk conflicts—either from shared input/output features (structural interference) or indirect functional dependencies.
• The set of tasks executable simultaneously is precisely the Maximum Independent Set (MIS) of the conflict graph:

$T$4

• In ideal wiring, $T$5 (all tasks independent, full parallelism). For nontrivial sharing, the expected maximal parallelism is

$T$6

• The functional implication is a core tradeoff: increasing representational overlap (to accelerate learning and generalization) lowers $T$7, reducing parallel throughput.

Empirical and statistical-mechanical analyses yield explicit power-law and logarithmic bounds for $T$8 in random and structured networks, capturing the “meta-control” tension inherent in adaptive, multipolar architectures (Petri et al., 2017).

5. Concrete Example and Illustrative Workflow

A demonstrative case (Yang et al., 12 Sep 2025) involves generating a high-quality email reply (e.g., about Katharine Hepburn):

1. Planner Agent constructs $T$9, with edges forming the canonical MTPG structure.
2. For $T_i$0 (“second Oscar movie?”), DAA produces domain rules in Entertainment, History, Biology; these generate parallel answers with membership scores.
3. IF-THEN fusion and majority voting propose a preliminary answer (e.g., “Guess Who’s Coming to Dinner (1967)”).
4. The global rule evaluates objective alignment (e.g., “discuss Hepburn’s career”); low fusion membership triggers subtask-level regeneration—possibly up to three cycles.
5. Overly broad or failing subtasks (e.g., $T_i$1) are decomposed into finer-grained subtasks ($T_i$2, $T_i$3, $T_i$4), added to the evolving graph.
6. Once all leaves meet membership thresholds, FEA_final fuses outputs, yielding a robust, contextually consistent email response.

Graph evolution—including rule re-generation, node removal, and branching—is made explicit in Figure 1 (Yang et al., 12 Sep 2025), graphically demonstrating how the MTPG supports dynamic strategy and error correction.

6. Theoretical and Practical Significance

MTPG provides a formal scaffold for multi-agent dynamic planning, evidence fusion, and iterative error recovery in cooperative LLM systems (Yang et al., 12 Sep 2025). It also quantifies, via conflict graphs, the inherent limitations on task concurrency that arise from shared representations in neural and AI architectures (Petri et al., 2017). The MTPG paradigm thus offers both a practical blueprint for dynamic, rule-constrained multiagent systems and a quantitative topological tool for reasoning about parallelism, interference, and processing limits in large-scale intelligent systems.

Table: Summary of MTPG Roles in Two Domains

Context	Node/Edge Semantics	Central Performance Limit
Cooperative multi-agent reasoning (Yang et al., 12 Sep 2025)	Tasks/subtasks, fusion; DAG edge = dependency	Accuracy/confidence via fusion rules
Parallel architectures (Petri et al., 2017)	Task-poles, edge = cross-talk/conflict	Parallel throughput $T_i$5

A plausible implication is that advances in MTPG-aware design may enable both more robust multiagent planning under uncertainty and systematic optimization of multitask throughput in neural and hardware-accelerated systems, but fundamental trade-offs between learning speed, generalization, and parallel task capacity persist.