Algorithmic Structure in Subset Sum: Deterministic In-Bound Navigation and the Counting Complexity Divide

TL;DR

This paper introduces a deterministic, input-robust algorithm for exploring the solution space of the Subset Sum Problem, highlighting its structural properties, limitations, and potential generalizations to other NP-complete problems.

Contribution

It presents a novel deterministic algorithm that adaptively explores the solution space of Subset Sum, with insights into its performance and implications for complexity theory.

Findings

Algorithm effectively narrows solution space exploration.

Performance affected by false positives in in-bound space.

Implications for P vs NP and counting complexity.

Abstract

This paper presents a deterministic algorithmic approach of exploring the solution space of the Subset Sum Problem. The algorithm presented is input-robust and structurally adaptive. Exploration is guided and narrows into areas in the solution space where solutions are possible, referred to as in-bound solution space, skipping all areas where solutions are impossible. Unfortunately, this can lead to false positives: paths that are hinted to potential have solutions but ultimately realized to not lead to solutions. The in-bound solution space navigated can therefore be filled with only false positives, only true solutions or a mix of the two, affecting the algorithm's performance in different ways. We then detail the challenges of exploring the in-bound solution space for different instances. Further, we show how this algorithm may practically generalize to other NP/NP-complete problems with appropriate adaptation. An introductory discussion is done on this generalization to k-SAT and general CNF-SAT, deferring extensive detail to a follow-up paper. This paper does not satisfy P vs NP proof requirements and does not claim to resolve the problem. However, it has implications for the P vs NP and offers a practical lens through the algorithm of what is feasible with it. The feasibility bounds of the algorithm reveal a nontrivial relationship between decision and counting complexity. To facilitate easy reproducibility, we include in the paper a full C++ implementation of the algorithm.