Published February 13, 2026 | Version 9
Publication Open

A Generic Low-Level Solver for NP-Hard Instances (N=63) on Commodity 64-Bit Silicon Breaking the Tractability Barrier:

Description

⚠️ Author’s Note (Language and Tooling Disclosure)

The author is a native Spanish speaker. A Large Language Model (LLM) was used exclusively for academic translation, grammar, and formatting, with the sole purpose of communicating the results clearly and efficiently to the international research community.
All algorithmic design, implementation, experimental methodology, and results are entirely human-derived and original.

Abstract / Description

This work presents and validates a silicon-native computational architecture for addressing NP-Hard optimization problems, with a specific focus on the Hamiltonian Path Problem on directed (unilateral) graphs, which constitute one of the most restrictive and computationally demanding problem classes due to asymmetric edge constraints and reduced combinatorial symmetry.

Unlike conventional approaches that treat the CPU as a high-level software execution platform, the proposed system models the processor as a physical substrate of logic gates, leveraging strictly bitwise operations and hardware-level nondeterminism arising from real silicon behavior.

Key Results

Execution Performance
Directed Hamiltonian Path instances with N = 63
(search space ≈ 10⁸⁷) were solved in 0.116 seconds on a standard commercial mobile processor.

Algorithmic Mechanism
The method incorporates hardware race conditions, capacitive noise, and L1 cache timing jitter as controlled entropy sources to facilitate escape from local optima, effectively exploiting non-ideal physical characteristics of silicon rather than abstract randomness.

Problem Class
All reported results correspond to directed (unilateral) graphs, which are strictly harder than undirected variants due to directionality constraints and reduced path equivalence.

Implementation and Portability
The implementation is written in pure C / C-style C++, requires zero dynamic memory allocation, and is suitable for deployment on bare-metal microcontrollers, embedded platforms, and DSP architectures with limited memory availability.

Reproducibility and Review

The author welcomes independent verification, critical review, and replication attempts.
All feedback is appreciated.

✉️ Contact: lctrnc1@gmail.com

 

Notes

DOI: https://doi.org/10.5281/zenodo.18636822

IMPORTANT NOTICE — LICENSE, VERSIONING, AND INTELLECTUAL PROPERTY

This record is released under the PolyForm Noncommercial License 1.0.0.

Readers are strongly encouraged to review the following files included in the repository, which together define the complete legal and algorithmic scope of this work:

  • LICENSE.txt
  • ALGORITHMIC-SCOPE_DERIVATIVE_WORKS.txt
  • HEADER.txt
  • README.md

These documents collectively establish the protection framework covering:

A Generic Low-Level Solver for NP-Hard Instances (N = 63) on Commodity 64-Bit Silicon Breaking the Tractability Barrier

including its underlying methods, implementation logic, performance characteristics, and all derivative works, across all programming languages, platforms, and hardware substrates.

Versioning Policy

This Zenodo record may contain multiple versions of the associated paper and/or source code. Versioning is a standard and accepted practice in academic publishing and open-source development, reflecting the iterative nature of scientific research, peer feedback, and continuous refinement.

Updates to the paper — including corrections, clarifications, expanded discussion, additional experimental results, or structural revisions — do not invalidate, alter, or supersede:

  • the algorithmic contributions
  • the associated source code
  • the license terms

attached to any prior or current version of this record.

Algorithmic invariance

The algorithmic core — including prime-factor node classification, bitwise structural pruning, thermodynamic entropy harvesting, and the register-only execution model — remains unchanged across all versions.

Scope of revisions

Paper revisions address presentation, terminology, clarity, and experimental validation, not the underlying algorithm.

Authoritative license terms

The license and algorithmic scope documents included in this record represent the most current and authoritative statement of the intellectual property terms governing this work.

License Scope

The PolyForm Noncommercial License 1.0.0, together with the accompanying
ALGORITHMIC-SCOPE_DERIVATIVE_WORKS.txt document, applies to:

Implementations

  • The HFP algorithm in all forms and implementations
  • Any reimplementation in any programming language, including but not limited to:
    C, C++, Python, Rust, Go, Java, JavaScript, Julia, MATLAB, Fortran, Assembly, or any future language

Hardware realizations

  • Any hardware implementation, including but not limited to:
    Verilog, VHDL, SystemVerilog, FPGA bitstreams, ASIC designs, or any future hardware description language

Application domains

Any application derivative, including (non-exhaustively):

  • VLSI / EDA
  • Logistics
  • Network routing
  • Scheduling
  • Drug discovery
  • Any NP-hard problem reducible to Longest Path or Hamiltonian Path

Functional equivalence

Protection applies to any mathematically or computationally equivalent formulation intended to reproduce the same:

  • functionality
  • behavior
  • performance characteristics
  • computational advantages

The scope of protection is defined by the algorithmic contributions described in
ALGORITHMIC-SCOPE_DERIVATIVE_WORKS.txt, not by the title or naming of the work.

Protection applies regardless of whether the work is referenced by its full title, abbreviation (“HFP”), or any other designation.

No De Minimis Exception

There is no minimum size threshold for license applicability.

The PolyForm Noncommercial License 1.0.0 imposes no exemptions based on:

  • number of lines of code
  • fragment size
  • proportion of reuse
  • level of abstraction

Any use — whether involving a single instruction, a structural idea, or the full implementation — is governed by the license.

Applicability is determined by the nature and purpose of the use, not by quantitative measures.

Anti-Circumvention and Anti-Snippet-Laundering

The following actions shall be considered derivative use under the license:

  • Extracting or reusing minimal code fragments (“snippets”)
  • Refactoring, translating, or paraphrasing implementation logic
  • Reimplementing functionality after exposure to the source code or documentation
  • Expressing the same algorithm in a different programming language or paradigm
  • Embedding isolated components within a larger system
  • Claiming independent creation while materially benefiting from this work

Attempts to evade license restrictions through technical, structural, or semantic modification do not limit or negate license applicability.

Presumption of Derivation

Any software, system, or implementation that exhibits substantial functional, structural, or behavioral similarity to this work, and whose author had prior access, exposure, or reasonable opportunity to become aware of it, shall be presumed to be a derivative work.

The burden of proof rests entirely on the alleged infringing party to demonstrate independent creation with clear and convincing evidence.

Differences in programming language, coding style, abstraction level, or optimization are insufficient to rebut this presumption where material functional similarity exists.

Knowledge Contamination and Non-Clean-Room Use

Any individual or entity that has reviewed, studied, tested, or otherwise been exposed to the source code, documentation, datasets, or technical descriptions shall be considered knowledge-contaminated.

Accordingly:

  • Subsequent implementations shall not be considered clean-room
  • Claims of independent development after exposure are invalid
  • Memory-based reconstruction or functional emulation constitutes derivative use
  • Internal reassignment or post hoc clean-room claims do not negate contamination unless supported by contemporaneous, auditable evidence of prior independent creation

Commercial Use Restriction

Any commercial, corporate, governmental, financial, military, or revenue-generating use of this algorithm — in whole or in part, in any form, on any platform — is strictly prohibited without explicit written authorization from the author.

Contact Information

Author
Andrés Sebastián Pirolo
Independent Researcher — Buenos Aires, Argentina
ORCID: 0009-0004-3899-1222
✉️ apirolo@abc.gob.ar
✉️ andrespirolo@gmail.com

Project Engineer
✉️ dev88mel@gmail.com

Independent Verification and Feedback
✉️ lctrnc1@gmail.com

For commercial licensing inquiries, please contact the author directly.

Feedback and independent verification are welcome. Thank you.

 

Technical info

HFP FINAL VALIDATION PROTOCOL (Safe Mode)

Threads: 2

Primary Implementation: C / C-style C++

Cross-check Implementation: Julia (Google Colab — Free tier)

Validation Level (Easy) | D = 0.8

✔ Result: Execution completed successfully in 0.1395 s

Warm-Up Level (Intermediate) | D = 0.5

✔ Result: Execution completed successfully in 0.0008 s

✔ Sub-millisecond execution achieved

Note: Minor technical limitations were encountered in the Julia implementation related to density-sweep execution, which affected extended parameter exploration but did not impact result correctness.

Files

PiroloHFP_Generic_Solver_2026_v9.pdf

Files (390.7 kB)

Name Size Download all
md5:1887a4630adab486706663de32ce4cf5
376.6 kB Preview Download
md5:e3cee7c6b27675d1d1dfc01bf39a8ae5
14.2 kB Preview Download

Additional details

Software

Repository URL
https://zenodo.org/uploads/18627662
Programming language
C , C++