bubbleCalc: Dependency-Driven Resolution with Context Accumulation for Variable Networks

bubbleCalc is a formal execution model for dependency-dominant variable networks: directed computational structures in which values are resolved through dependencies rather than in isolation. The paper positions bubbleCalc for a broad application class including enterprise planning, financial consolidation, bill-of-materials propagation, risk aggregation, feedforward inference, and other dynamic decision or control systems in which local change should not force global recomputation. bubbleCalc combines dependency-driven resolution, persistent context accumulation, and affected-subgraph-sensitive incremental recomputation into one execution framework, while developing the theory for an analytically tractable scalar edge-parameter specialization with node-local intrinsic state. At the architectural level, this specialization is presented as compatible with a broader variable-network design disclosed in EP3896579A1, in which variable references may carry richer local rule information; under that broader reading, dynamically reconfigurable ANN-style computation graphs are one admissible application class. Empirical studies are planned to quantify the expected performance and scalability advantages on representative workloads.Abstract:A broad and practically important class of computational workloads can be modeled as the resolution of variable networks: directed graphs in which each node’s value depends on the resolved values of its predecessors. This structure arises in enterprise planning, financial consolidation, bill-of-materials propagation, risk aggregation, and feedforward inference. Existing approaches address important parts of this problem, but not the full combination required here. Recursive evaluation is straightforward but operationally fragile in deep networks and awkward under incremental updates. Batch-iterative graph frameworks such as Pregel offer scalable generality, but impose superstep-driven execution overhead independent of actual dependency readiness. Domain-specific recalculation engines such as spreadsheets and rule systems solve narrower instances of the same problem, yet do not provide a single formal model for dependency networks with persistent accumulated context and explicit edge-local determination information. This paper presents bubbleCalc, a dependency-driven execution model for variable networks. bubbleCalc resolves a node when its predecessors make it resolvable, materializes the resulting accumulated context as first-class backpack state, and supports incremen- tal recomputation by re-evaluating only the affected subgraph after input changes. The contribution is not a claim of novelty for any single primitive, but a formal integration of topological evaluation, dependency-triggered firing, persistent context accumulation, and incremental propagation into one execution framework. The formal development is stated for scalar edge-local parameters and node-local intrinsic state, while remaining compatible with broader variable-network architectures in which variable references may carry richer local rule information. Under that broader reading, dynamically reconfigurable ANN-style computation graphs are one admissible application class rather than the sole intended inter- pretation. We define the backpack algebra precisely, state semantic compatibility conditions, and analyze the DAG, cyclic, and incremental cases separately. For DAGs with bounded-size backpacks and constant-time edge operations, bubbleCalc performs asymptotically optimal O(V + E) work. For localized updates, it performs O(V affected + E affected) work, giving it an affected-subgraph-sensitive cost profile. Section 7 specifies an empirical evaluation against four baselines on synthetic and domain-representative datasets, reporting not only wall-clock time but also node evaluations, affected-subgraph size, and peak memory consumption; benchmark placeholders are retained pending final measurement insertion.