Sign Gradient Descent Algorithms for Accelerated Kinetostatic Protein Folding in Nanorobotics Design

Abstract

Numerical simulations of protein folding enable the design of protein-based nanomachines and nanorobots by predicting folded three-dimensional protein structures with high accuracy and revealing the protein conformation transitions during folding and unfolding. In the kinetostatic compliance method (KCM) for folding simulations, protein molecules are represented as ensembles of rigid nano-linkages connected by chemical bonds, and the folding process is driven by the kinetostatic influence of nonlinear interatomic force fields until the system converges to a free-energy minimum of the protein. Despite its strengths, the conventional KCM framework demands an excessive number of iterations to reach folded protein conformations, with each iteration requiring costly computations of interatomic force fields. To address these limitations, this work introduces a family of sign gradient descent (SGD) algorithms for predicting folded protein structures. Unlike the heuristic-based iterations of the conventional KCM framework, the proposed SGD algorithms rely on the sign of the free-energy gradient to guide the kinetostatic folding process. Owing to their faster and more robust convergence, the proposed SGD-based algorithms reduce the computational burden of interatomic force field evaluations required to reach folded conformations. Their effectiveness is demonstrated through numerical simulations of KCM-based folding of protein backbone chains.

1. Introduction

Protein-based nanorobotic devices are capable of exerting precise forces, manipulating microscopic objects, and transducing nanoscale information into measurable signals [1,2,3,4]. Nanorobots can be built by assembling distinct protein-based components into integrated devices that operate with multiple degrees of freedom. In these systems, proteins and DNA molecules function as joints, motors, transmission elements, and sensors, enabling precise, repeatable forces, motions, and signals. For example, viral protein linear motors produce consistent motion patterns in response to controlled changes in the pH of the environment [5,6]. As another example, modular DNA-origami nanocompartments can serve as programmable chambers that actively unfold proteins, with the folding state functioning as their key regulatory signal [7]. Another promising application of nanomotors lies in the design of probes for precision imaging (see, e.g., [8]).

1.1. Protein Folding Simulations in Nanorobotics

In designing protein-based nanorobots, protein folding numerical simulations play a central role in predicting final folded structures and capturing transient conformations during folding and unfolding. Beyond structural determination, such simulations can quantitatively assess the mobility of protein-based nano-mechanisms. As demonstrated in [9], numerical simulations can characterize the range and patterns of motion of protein-based bio-springs within a class of parallel nano-mechanisms with upward and backward movements regulated by linear myosin actuators. Protein folding simulations have also been utilized to simulate the motion of cyclic protein-based mechanisms under external electric field perturbations [10,11,12,13].

Beyond estimating the range of motion of protein-based nanodevices, interactive molecular simulations such as ligand–protein docking [14] and human-guided protein/RNA folding simulators [15] rely on accurate protein folding simulations. Enhanced by virtual reality (VR) technology, these platforms allow researchers to design and characterize both individual nanorobotic components and complex assemblies through immersive 3D visualization and haptic force feedback. Haptic devices, in particular, provide operators with a tactile sense of molecular forces during flexible ligand–protein docking and RNA/protein folding [16]. In addition to visual and tactile interaction, the incorporation of sonification and spatial perception of simulation data offers a further sensory dimension to the VR-based protein folding experience [17,18].

1.2. Knowledge-Based and Physics-Based Algorithms for Protein Folding

Knowledge-based algorithms are among the most common methods for protein folding simulations. Relying on pattern recognition and machine learning, these methods leverage amino acid sequences together with extensive databases of known structures to deduce 3D protein conformations. Artificial intelligence-based tools, with Google’s AlphaFold 2 as the leading example [19], have achieved remarkable success in identifying the most probable folded configurations of proteins. However, knowledge-based approaches face important limitations: they cannot adequately capture protein–nucleic acid interactions, account for molecular stability, or incorporate the kinetics of the folding process. Moreover, although highly effective at predicting final structures, these techniques provide little insight into the folding pathway itself [20].

Unlike knowledge-based approaches, physics-based methods constitute a distinct class of techniques that rely on fundamental physical principles to simulate the folding process and compute both transient and folded three-dimensional (3D) protein structures [21,22]. To improve the accuracy of these simulations, physics-based numerical methods can be coupled with advanced optimization techniques, including those derived from optimal control theory [23] and homotopy methods [24]. Although such approaches provide reliable insights into intermediate structural states during folding, they are computationally intensive and demand specialized hardware and considerable processing time [25].

1.3. Kinetostatic Compliance Method for Protein Folding

To mitigate the computational demands of physics-based algorithms, the kinetostatic compliance method (KCM) was introduced for protein folding simulations [26,27,28,29]. KCM treats proteins as nanomechanical systems composed of rigid peptide plane linkages (Figure 1). Instead of relying on computationally prohibitive all-atom molecular dynamics, it kinetostatically adjusts protein dihedral angles. These angles, which determine the relative orientations of peptide planes, are iteratively modulated under nonlinear interatomic force fields and guided toward a folded conformation with an energetically favorable state.

KCM for protein folding simulations has been employed for designing peptide-based nanorobots [10,11,12]. Notably, the KCM framework can be leveraged to simulate the movement range of closed-loop cyclic nanorobots under external electric fields [12].

Although the KCM is computationally advantageous for the design of protein-based nanorobots, it has so far relied on iterative kinetostatic fold compliance [26,27]. In this approach, structural updates of the protein molecule are obtained through heuristic-based iteration rules. However, the conventional method typically demands significantly more iterations, which involve intensive computations of interatomic force fields.

In this paper, to overcome the shortcomings of the conventional KCM iteration, we propose a family of sign gradient descent (SGD) iterative algorithms for kinetostatic protein folding as a substitute for the established method in KCM literature. In our proposed SGD-based framework, the sign of the free energy gradient in the protein configuration space becomes key in guiding the kinetostatic folding of protein molecules. Characterized by their reliance on gradient sign information, SGD algorithms represent a class of first-order optimization techniques originally conceived for training artificial neural networks [30,31]. These algorithms are known for their numerical stability as well as solid convergence attributes [32,33]. Consequently, the presented SGD algorithms in this paper enjoy formal guarantees of convergence and robustness. Monte Carlo methods provide a powerful approach for exploring the conformational energy landscape through probabilistic sampling. Their stochastic nature enables broad and unbiased exploration, which can capture diverse configurations of disordered proteins and escaping local minima in complex energy landscapes (see, e.g., [34]). In contrast, the proposed SGD-based kinetostatic framework complements these methods by performing a deterministic, gradient-driven descent toward a minimum-energy conformation using the sign of the free-energy gradient.

1.4. Contributions of the Paper

This work introduces a novel class of sign gradient descent (SGD) algorithms for kinetostatic protein folding simulations. Our proposed algorithms diverge from the established practice in kinetostatic folding simulations of using a heuristic fold compliance scheme with no formal guarantees of convergence [26]. Thanks to the strengths of SGD algorithms, our proposed kinetostatic protein folding iterations enjoy formal guarantees of robust convergence to minimum energy configurations (i.e., the folded protein molecule conformations). Because of their convergence and stability features, our SGD-based algorithms require a lesser number of iterations for convergence and hence ease the computational burden resulting from the interatomic force field calculations. Furthermore, owing to the structural similarity between protein kinematics in the KCM framework and robotic manipulators (Figure 1), our approach is naturally applicable to robotics problems that employ gradient-based methods such as task-oriented robot control [35], collaborative 3D localization [36], and gradient-informed path smoothing [37], among others.

A preliminary version of this work was presented in the conference publication [38]. The present paper substantially extends those results in three major directions. First, it introduces an adaptive, conformation-dependent SGD algorithm in which the step size is dynamically adapted to the current protein conformation, in contrast to the earlier version that adjusted step size only with iteration count. This improvement yields a hybrid gradient descent law that preserves both the sign and magnitude information of the folding torque vector. Second, the paper offers a more comprehensive analysis of convergence and robustness, which was only partially addressed in the earlier conference work. The results in this paper provide sufficient conditions under which the SGD-based iterations are guaranteed to reach folded states. Third, this paper provides more extensive numerical validation by presenting larger and more systematic simulation studies that demonstrate the computational efficiency and scalability of the proposed algorithms.

The proposed framework achieves faster convergence and enhanced stability, making it especially well-suited for capturing the complex motions that characterize peptide-based nano-robotic devices. In particular, it can directly contribute to the active line of research in nanorobotics led by Ilieş and Kazerounian (see, e.g., [12,13]). One noteworthy example is the development of 7-R closed-loop one-degree-of-freedom spatial mechanisms based on cyclic peptides. Unlike macro-scale robots that rely on traditional prismatic or revolute actuators, these nanoscale kinematic chains exploit molecular geometry to achieve controlled, repeatable motion through predictable dihedral-angle variations. The SGD-based folding framework introduced in this work provides an efficient computational tool for predicting and refining the equilibrium configurations of such nano-actuators by modeling the influence of external stimuli, such as perturbations in electric force fields.

The remainder of this paper is structured as follows. Section 2 introduces the nano-kinematic representation of protein molecules and outlines the foundations of the KCM framework for simulating their kinetostatic folding. Section 3 and Section 4 present the core algorithms and their convergence analysis, respectively. Section 5 presents the numerical simulations, and Section 6 concludes with a discussion of future research directions.

2. Background

In this section, we briefly review the KCM framework. To avoid ambiguity, we clarify the terminology: in biochemistry, the term “conformation” is conventionally used to describe the spatial arrangement of a protein’s kinematic structure, whereas in robot kinematics the term “configuration” is more common. Throughout this work, “conformation” and “configuration” are treated as interchangeable.

2.1. The Protein Backbone Nano-Kinematics

Proteins are macromolecules distinguished by their structural complexity and dynamic behavior. They consist of extended chains of peptide planes connected through chemical bonds. A protein’s functionality is inherently tied to its 3D conformation, which is dictated by the linear arrangement of polypeptide chain amino acids. For clarity and focus, the present discussion is restricted to the protein backbone.

Figure 1 depicts the protein polypeptide backbone. As shown, each peptide plane comprises six covalently bonded atoms that lie within a single plane. The assumption of coplanarity is strongly supported by X-ray crystallography [39]. This structural property provides the basis for modeling proteins as complex nano-mechanisms with many degrees of freedom [26,29]. In this view, peptide planes act as the rigid building blocks of the kinematic chain and serve as nanoscale linkages in the molecular nano-mechanism.

The rotations of nano-linkages within the protein kinematic chain are enabled by the central carbon atoms, denoted ${\mathrm{C}}_{\alpha }$ and commonly referred to as alpha-carbons (Figure 1). These ${\mathrm{C}}_{\alpha }$ atoms act as hinges, connecting adjacent peptide planes. At the termini of the chain, the ${\mathrm{C}}_{\alpha }$ atoms are linked to an N-terminus at one end and a C-terminus at the other.

The nano-kinematic architecture of a peptide backbone consisting of $N-1$ peptide planes/nano-linkages is fully characterized by the length of its chemical bonds together with the associated pairs of dihedral angles. For the i^th peptide plane, there exist two distinct rotational degrees of freedom. The first corresponds to torsional motion about the covalent bond connecting the amide nitrogen atom (N) to the central alpha carbon atom ($\mathrm{C}\alpha$), and this degree of freedom is represented by the dihedral angle ${\mathit{\theta }}_{2i+1}$. The second arises from rotation about the covalent bond linking the central alpha carbon atom ($\mathrm{C}\alpha$) to the carbonyl carbon atom (C), which is similarly characterized by the dihedral angle ${\mathit{\theta }}_{2i+2}$. Together, these two rotational axes capture the essential kinematic variability of the peptide plane, as illustrated in Figure 1. Collecting all such variables defines the vector

$$\mathit{\theta }:={\left[{\mathit{\theta }}_1,\cdots ,{\mathit{\theta }}_{2N}\right]}^{\top }\in \mathcal{Q}:={\mathcal{S}}^1\times \cdots \times {\mathcal{S}}^1,$$

(1)

which specifies the full configuration of the backbone chain. The configuration space $\mathcal{Q}$ is a torus formed by the Cartesian product of $2N$ unit circles ${\mathcal{S}}^1$.

Each dihedral angle ${\mathit{\theta }}_i$ in the configuration vector $\mathit{\theta }$ given by (1) corresponds to one degree of freedom (DOF). It is possible to define a unit vector ${\mathbf{u}}_j$, $1\le j\le 2N$ for each DOF. Each unit vector aligns with the axis of its corresponding rotational motion. Figure 1 illustrates the unit vectors ${\mathbf{u}}_{2i}$ and ${\mathbf{u}}_{2i+1}$ within the ith peptide plane (Figure 1). These vectors capture the directions of the bonds connecting the alpha carbon to the carbonyl carbon and to the nitrogen atom, respectively. These vectors define the primary axes of rotation for each segment of the backbone chain. Finally, the vectors ${\mathbf{u}}_1$ and ${\mathbf{u}}_{2N}$ are reserved to represent the special unit directions associated with the termini of the backbone chain. Specifically, ${\mathbf{u}}_1$ corresponds to the orientation at N-terminus, which marks the starting end of the polypeptide chain. In contrast, ${\mathbf{u}}_{2N}$ designates the orientation at C-terminus, which defines the terminating end of the chain.

While the dihedral angles specify the rotational DOFs along the kinematic chain, they are not by themselves sufficient to compute the rigid peptide linkage orientations. To capture this missing geometric information, the relative spatial arrangement of the coplanar atoms are represented using the body vectors within each peptide plane, denoted by ${\mathbf{b}}_j$ for $1\le j\le 2N$. Using these body vectors, the position of any atom in a given plane can be expressed relative to another atom of the same plane through a linear combination of the form ${\ell }_{1m}{\mathbf{b}}_{2i}+{\ell }_{2m}{\mathbf{b}}_{2i+1}$, where the coefficients ${\ell }_{1m}$ and ${\ell }_{2m}$, for $1\le m\le 4$, are fixed atom-specific constants that remain consistent throughout the peptide chain [26,27]. Taken together, the body vectors ${\mathbf{b}}_j$ and the unit vectors ${\mathbf{u}}_j$ yield a complete mathematical representation of the protein’s conformation, expressed entirely in terms of the underlying dihedral angle variables.

Rotation matrices can be used to map the conformation vector $\mathit{\theta }$ to the 3D configuration of the protein’s kinematic structure [26]. Specifically, a reference configuration, given by $\mathit{\theta }=\mathbf{0}$, together with the corresponding reference unit vectors ${\mathbf{u}}_j^0$ and reference body vectors ${\mathbf{b}}_j^0$ for $1\le j\le 2N$, are used in

$${\mathbf{u}}_j\left(\mathit{\theta }\right)=\left\{\prod _{r=1}^j\mathbf{R}({\mathit{\theta }}_j,{\mathbf{u}}_j^0)\right\}{\mathbf{u}}_j^0,{\mathbf{b}}_j\left(\mathit{\theta }\right)=\left\{\prod _{r=1}^j\mathbf{R}({\mathit{\theta }}_j,{\mathbf{u}}_j^0)\right\}{\mathbf{b}}_j^0,$$

(2)

where $\mathbf{R}({\mathit{\theta }}_j,{\mathbf{u}}_j^0)$, $1\le j\le 2N$, is the rotation matrix about the reference axis ${\mathbf{u}}_j^0$.

To compute the peptide atom Cartesian positions, the N-terminal atom is anchored at the origin and the body vectors ${\mathbf{b}}_j\left(\mathit{\theta }\right)$ from (2) are utilized in the following way. Letting $i=2k-1$ and $i=2k$ correspond to the nitrogen and ${\mathrm{C}}_{\alpha }$ atoms of the kth peptide plane, the position vectors are given by

$${\mathbf{p}}_i\left(\mathit{\theta }\right)={\mathbf{b}}_1\left(\mathit{\theta }\right)+\cdots +{\mathbf{b}}_i\left(\mathit{\theta }\right),1\le i\le 2N-1.$$

(3)

2.2. Kinetostatic Compliance Folding

The KCM framework builds on the well-established experimental observation that protein folding dynamics can be effectively captured while neglecting inertial forces (see, e.g., [23]). The protein chain in KCM is represented as a collection of kinematic linkages that deform in response to the kinetostatic effects of nonlinear force fields (Figure 1).

Consider a peptide chain composed of $N_a$ atoms arranged into $N-1$ peptide planes. The conformational state of this chain is fully described by the dihedral angle vector $\mathit{\theta }$, introduced in Equation (1). For any two atoms, $a_i$ and $a_j$, their Cartesian coordinate vectors are denoted by $p_i\left(\mathit{\theta }\right)$ and $p_j\left(\mathit{\theta }\right)$, respectively. The Euclidean distance between them is given by $p_{ij}\left(\mathit{\theta }\right):={|p_i\left(\mathit{\theta }\right)-p_j\left(\mathit{\theta }\right)|}_2$. The physical parameters necessary for evaluating the interatomic forces are atomic charges, van der Waals radii, equilibrium bond lengths, potential well depths, and interaction weight factors. The value of these parameters is detailed in [27] and related references.

In KCM, the total free energy governing protein folding, denoted $\mathcal{E}\left(\mathit{\theta }\right)$, is expressed as the sum of electrostatic and van der Waals contributions:

$$\mathcal{E}\left(\mathit{\theta }\right):={\mathcal{E}}^{\mathrm{elec}}\left(\mathit{\theta }\right)+{\mathcal{E}}^{\mathrm{vdw}}\left(\mathit{\theta }\right),$$

(4)

where ${\mathcal{E}}^{\mathrm{elec}}\left(\mathit{\theta }\right)$ is the electrostatic potential energy, and ${\mathcal{E}}^{\mathrm{vdw}}\left(\mathit{\theta }\right)$ is the van der Waals interaction energy (see, e.g., [26]). The forces on each atom $a_i$, $1\le i\le N_{\mathrm{a}}$, which are induced by ${\mathcal{E}}^{\mathrm{elec}}\left(\mathit{\theta }\right)$ and ${\mathcal{E}}^{\mathrm{vdw}}\left(\mathit{\theta }\right)$, are equal to the negative gradients of the corresponding energy terms: $F_i^{\mathrm{elec}}\left(\mathit{\theta }\right)=-{\nabla }_{{\mathbf{p}}_i}{\mathcal{E}}^{\mathrm{elec}}$ and $F_i^{\mathrm{vdw}}\left(\mathit{\theta }\right)=-{\nabla }_{{\mathbf{p}}_i}{\mathcal{E}}^{\mathrm{vdw}}$.

Within the KCM framework, the first step involves evaluating the net forces and torques exerted on each of the $N-1$ peptide planes of the protein molecule [26]. These contributions are collected into a $6N$-dimensional vector $\mathcal{G}\left(\mathit{\theta }\right)$, referred to as the generalized force vector, which encapsulates the overall influence driving the folding process. In order for these forces to induce conformational changes, the generalized force vector $\mathcal{G}\left(\mathit{\theta }\right)$ is projected onto an equivalent $2N$-dimensional torque vector $\mathit{\tau }\left(\mathit{\theta }\right)$. This projection effectively converts the generalized forces into torsional actions on the dihedral angles, which are the primary variables controlling kinetostatic protein folding.

The kinetostatic folding torque vector is given by

$$\mathit{\tau }\left(\mathit{\theta }\right)={\mathcal{T}}^{\top }\left(\mathit{\theta }\right)\mathcal{G}\left(\mathit{\theta }\right),$$

(5)

where $\mathcal{T}\left(\mathit{\theta }\right)\in {\mathbb{R}}^{6N\times 2N}$ is the molecular chain Jacobian at conformation $\mathit{\theta }$. As described in [26], the matrix $\mathcal{T}\left(\mathit{\theta }\right)$ functions as the intermediary between the generalized forces and the torsional dynamics of the protein. Specifically, it maps the $6N$-dimensional generalized force vector onto the reduced $2N$-dimensional space of dihedral torques.

The conformational changes in dihedral angles occur under the influence of $\mathit{\tau }\left(\mathit{\theta }\right)$, which aligns with the steepest-descent direction of the total free energy $\mathcal{E}\left(\mathit{\theta }\right)$. This folding torque vector thus guides the backbone through the conformational landscape.

3. SGD-Based Kinetostatic Protein Folding Iteration Algorithms

In this section, we present the main SGD-based algorithms of the paper. To set the stage, we first review the conventional KCM iteration in Section 3.1. We then introduce two novel SGD-based kinetostatic fold compliance algorithms, each employing a distinct step-size update rule, in Section 3.2 and Section 3.3. Finally, in Section 4, we analyze the convergence and robustness properties of these SGD-based algorithms.

3.1. Conventional KCM Iteration Algorithm

Each local minimum ${\mathit{\theta }}^{*}$ of the protein total free energy function $\mathcal{E}\left(\mathit{\theta }\right)$ given by (4) is characterized by a torque vector that vanishes at the folded conformation, i.e., $\mathit{\tau }\left({\mathit{\theta }}^{*}\right)=0$. This condition represents a state of kinetostatic equilibrium: at a folded conformation, the absence of net torque signifies that the internal molecular forces are perfectly balanced. Moreover, the folding torque vector is directed along the steepest descent of the free energy gradient within the conformational landscape.

In the conventional KCM framework [26], the evolution of dihedral angles is governed kinetostatically by the folding torque vector induced by interatomic force fields. Starting from an initial unfolded conformation ${\mathit{\theta }}_0$, the kinetostatic compliance method prescribes a numerical update law that relates the applied torques to incremental changes in dihedral angles [26]. Given a conformation $\mathit{\theta }$ of a protein molecule, one can compute the folding torque vector $\mathit{\tau }\left(\mathit{\theta }\right)$ in the direction of steepest descent on the free energy landscape. However, as established in the KCM literature [26], replacing this vector with its normalized counterpart leads to better performance. In particular, one can utilize the difference equation

$${\mathit{\theta }}_{k+1}={\mathit{\theta }}_k+{\kappa }_0{\displaystyle \frac{\mathit{\tau }\left({\mathit{\theta }}_k\right)}{{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }}},k\in {\mathbb{Z}}_{0+},$$

(6)

where ${\mathbb{Z}}_{0+}$ represents the set of non-negative integers, the ∞-norm of the torque vector is defined as ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }:=\underset{1\le i\le 2N}{max}\left|{\mathit{\tau }}_i\left({\mathit{\theta }}_k\right)\right|$, and the torque itself is computed from Equation (5).

Algorithm 1 summarizes the successive kinetostatic folding iteration. At each protein conformation, the most computationally demanding step corresponds to the evaluation of electrostatic and van der Waals forces. When exact interatomic force calculations are required, the complexity of this step for a molecule with $N_a$ atoms scales quadratically, i.e., $O\left(N_a^2\right)$ [26]. Faster convergence rates to the protein folded conformation result in a smaller number of required interatomic force field calculations. Accordingly, devising efficient numerical algorithms for computing the variation of dihedral angles can reduce the required number of such intensive calculations.

Algorithm 1 Conventional Kinetostatic Folding Iteration Algorithm

1: Input: Initial dihedral angle vector ${\mathit{\theta }}_0$, step size ${\kappa }_0>0$, convergence tolerance ${\epsilon }_{\mathrm{tol}}$, max iterations $K_{max}$   2: Output: Foldedconformation dihedral angle vector ${\mathit{\theta }}^{*}$   3: $k\leftarrow 0$   4: while$|\mathit{\tau }\left({\mathit{\theta }}_k\right){|}_2<{\epsilon }_{\mathrm{tol}}$ and $k<K_{max}$ do   5:    Compute the generalized force vector $\mathcal{G}\left({\mathit{\theta }}_k\right)$.   6:    Compute the protein chain Jacobian $\mathcal{T}\left({\mathit{\theta }}_k\right)$.   7:    Compute the folding torque vector $\mathit{\tau }\left({\mathit{\theta }}_k\right)\leftarrow \mathcal{T}{\left({\mathit{\theta }}_k\right)}^{\top }\mathcal{G}\left({\mathit{\theta }}_k\right)$.   8:    Update the protein conformation using the difference equation in (6): ${\mathit{\theta }}_{k+1}\leftarrow {\mathit{\theta }}_k+{\kappa }_0{\displaystyle \frac{\mathit{\tau }\left({\mathit{\theta }}_k\right)}{{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }}}$.   9:    $k\leftarrow k+1$ 10: end while 11: return${\mathit{\theta }}^{*}\leftarrow {\mathit{\theta }}_k$

In Algorithm 1, the normalized torque vector $\frac{\mathit{\tau }\left({\mathit{\theta }}_k\right)}{{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }}$ governs the incremental updates at each conformation ${\mathit{\theta }}_k$ according to the difference equation in (6). The heuristically optimized positive constant ${\kappa }_0$ is chosen sufficiently small to prevent extensive angle variations. As can be seen from Algorithm 1, the iterative scheme described in (6) is carried out until the total free energy reaches the vicinity of a local minimum on the underlying free-energy landscape. In practical implementations, this condition of convergence is assessed not by monitoring the energy directly, but rather by examining the magnitude of the kinetostatic folding torque vector. Specifically, the iteration converges when the Euclidean norm of $\mathit{\tau }\left({\mathit{\theta }}_k\right)$ falls below a desired tolerance threshold ${\epsilon }_{\mathrm{tol}}>0$, that is, when ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2<{\epsilon }_{\mathrm{tol}}$ (see Section 4 for further details).

3.2. SGD-Based Algorithm with Conformation-Independent Step Size Update Rule

As can be seen from Algorithm 1, the normalized kinetostatic folding torque vector is obtained by dividing each element of $\mathit{\tau }\left(\mathit{\theta }\right)$ by the vector’s infinity norm ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }:=\underset{1\le i\le 2N}{max}\left|{\mathit{\tau }}_i\left({\mathit{\theta }}_k\right)\right|$, i.e.,

$${\displaystyle \frac{\mathit{\tau }\left(\mathit{\theta }\right)}{{\left|\mathit{\tau }\left(\mathit{\theta }\right)\right|}_{\infty }}}:={\left[{\displaystyle \frac{{\mathit{\tau }}_1\left(\mathit{\theta }\right)}{{\left|\mathit{\tau }\left(\mathit{\theta }\right)\right|}_{\infty }}},\dots ,{\displaystyle \frac{{\mathit{\tau }}_{2N}\left(\mathit{\theta }\right)}{{\left|\mathit{\tau }\left(\mathit{\theta }\right)\right|}_{\infty }}}\right]}^{\top }.$$

(7)

Using this normalized vector for iteratively updating the protein molecule’s conformation improves both stability and convergence rate compared to the original torque vector. Indeed, normalizing the torque vector confines each normalized torque component within the interval $[-1,1]$, namely, ${\displaystyle \frac{{\mathit{\tau }}_i\left({\mathit{\theta }}_k\right)}{{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }}}\in [-1,1]$ for $1\le i\le 2N$.

A key insight from  (7) is that the kinetostatic fold compliance difference equation in (6), which is used in Algorithm 1, does not depend on the magnitude of the torque vector. Motivated by this observation, we propose an alternative to the heuristic strategy in Algorithm 1. Specifically, drawing on the established literature on sign gradient descent optimization [32], we introduce a novel SGD-based successive kinetostatic fold compliance algorithm, which exploits only the directional information encoded in the sign of the torque vector components.

In particular, we propose the following SGD-based difference equation

$${\mathit{\theta }}_{k+1}={\mathit{\theta }}_k+{\kappa }_k\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right),k\in {\mathbb{Z}}_{0+},$$

(8)

where ${\kappa }_k$ is a step size that gets updated in every iteration and

$$\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right):={\left[\mathrm{sgn}\left({\mathit{\tau }}_1\left(\mathbf{x}\right)\right),\cdots ,\mathrm{sgn}\left({\mathit{\tau }}_{2N}\left(\mathbf{x}\right)\right)\right]}^{\top }.$$

Note that the sign function for a scalar x, denoted as $\mathrm{sgn}\left(x\right)$, is defined according to $\mathrm{sgn}\left(x\right)=-1$ if $x<0$, $\mathrm{sgn}\left(x\right)=0$ if $x=0$, and $\mathrm{sgn}\left(x\right)=1$ if $x>0$. This ensures that the sign operator compactly encodes the directional information of each torque component, while ignoring its exact magnitude, thereby guiding the iterative update process in a directionally consistent manner.

Remark 1.

Analyzing the two kinetostatic fold compliance difference equations given by (6) and (8) reveals a key distinction: while the conventional approach in (6) leverages the normalized torque vector, i.e., $\frac{\mathit{\tau }\left({\mathit{\theta }}_k\right)}{{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_{\infty }}$, the proposed SGD-based difference equation in (8) utilizes the function $\mathit{sgn}(·)$. This function operates solely on the torque vector’s sign, i.e., $\mathit{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)$. Furthermore, the step size ${\kappa }_0$ in (6) remains fixed, whereas the SGD-based difference equation employs a dynamically changing step size ${\kappa }_k$ as discussed in what follows.

There are a variety of conventional methods for updating the step size ${\kappa }_k$ at each iteration of SGD-based kinetostatic folding. Specifically, according to the SGD optimization literature [32], the step size ${\kappa }_k$ at each step of the iteration can be adjusted according to

$${\kappa }_{k+1}=h\left({\kappa }_k\right),k\in {\mathbb{Z}}_{0+},$$

(9)

where the inequality $h\left({\kappa }_k\right)<{\kappa }_k$ should hold for every positive ${\kappa }_k$. The choice of the step size mapping $h(·)$ in (9) offers significant flexibility. Several established methods can be employed for this purpose, including the step size adaptation rule proposed by Moulay et al. [32]. Specifically, the following step size update rule

$$h\left({\kappa }_k\right)={\gamma }_0{\kappa }_k,k\in {\mathbb{Z}}_{0+},$$

(10)

where ${\gamma }_0\in (0,1)$ is a positive constant, leads to the step size sequence

$${\left\{{\kappa }_k\right\}}_{k\in {\mathbb{Z}}_{0+}}={\left\{{\kappa }_0·{\left({\gamma }_0\right)}^k\right\}}_{k\in {\mathbb{Z}}_{0+}}.$$

(11)

Notably, when ${\gamma }_0=0.5$, this rule coincides with the well-known DICHO algorithm [32].

Using the difference equation given by (8) and the step size update rule in (10), we arrive at Algorithm 2, which relies on the directional information of each component in the folding torque vector. According to the SGD optimization literature (see, e.g., [32]), the parameter ${\kappa }_0$ in the step size update rule given by (10) governs the size of the explored protein conformation landscape for finding folded structures. A larger ${\kappa }_0$ value expands the investigated conformation landscape without significantly affecting the convergence rate of the SGD folding iteration. Additionally, the parameter ${\gamma }_0$ determines the precision by which the protein conformation landscape will be explored. Moreover, the closer ${\gamma }_0$ to 1, the faster the speed of convergence to folded protein conformations.

The SGD step size update rule in Algorithm 2 does not utilize the information contained within the protein molecule conformation for varying the step sizes in each iteration. In the next section, we present an adaptive SGD-based algorithm, which utilizes a conformation-dependent step size update rule.

Algorithm 2 SGD-Based Kinetostatic Folding Iteration Algorithm with Conformation-Independent Step Size Update Rule

1: Input: Initial dihedral angle vector ${\mathit{\theta }}_0$, initial step size ${\kappa }_0>0$, ${\gamma }_0\in (0,1)$, convergence tolerance ${\epsilon }_{\mathrm{tol}}$, max iterations $K_{max}$   2: Output: Folded conformation dihedral angle vector ${\mathit{\theta }}^{*}$   3: $k\leftarrow 0$   4: while$|\mathit{\tau }\left({\mathit{\theta }}_k\right){|}_2<{\epsilon }_{\mathrm{tol}}$ and $k<K_{max}$ do   5:    Compute the generalized force vector $\mathcal{G}\left({\mathit{\theta }}_k\right)$.   6:    Compute the protein chain Jacobian $\mathcal{T}\left({\mathit{\theta }}_k\right)$.   7:    Compute the folding torque vector $\mathit{\tau }\left({\mathit{\theta }}_k\right)\leftarrow \mathcal{T}{\left({\mathit{\theta }}_k\right)}^{\top }\mathcal{G}\left({\mathit{\theta }}_k\right)$.   8:    Update the protein conformation using the difference equation in (8): ${\mathit{\theta }}_{k+1}\leftarrow {\mathit{\theta }}_k+{\kappa }_k\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)$.   9:    Update the step size ${\kappa }_{k+1}\leftarrow {\kappa }_0·{\left({\gamma }_0\right)}^k$. 10:    $k\leftarrow k+1$ 11: end while 12: return${\mathit{\theta }}^{*}\leftarrow {\mathit{\theta }}_k$

3.3. SGD-Based Kinetostatic Folding Iteration Algorithm with Conformation-Dependent Step Size Update Rule

To encode the protein molecule conformation within the step sizes, we consider the following kinetostatic folding difference equation

$${\mathit{\theta }}_{k+1}={\mathit{\theta }}_k+{\kappa }_k\left({\mathit{\theta }}_k\right)\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right),k\in {\mathbb{Z}}_{0+},$$

(12)

where ${\kappa }_k\left({\mathit{\theta }}_k\right)$ is the conformation-dependent step size in the kth iteration.

Following the SGD optimization literature (see, e.g., [32]), we propose the conformation-dependent step size update rule

$${\kappa }_k\left({\mathit{\theta }}_k\right)={\kappa }_{k,1}{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2+{\kappa }_{k,2},k\in {\mathbb{Z}}_{0+},$$

(13)

where ${\kappa }_{k,1}\ge 0$, ${\kappa }_{k,2}>0$ are design parameters (to be discussed later in this section), and ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2$ is the Euclidean norm of the kinetostatic folding torque vector at conformation ${\mathit{\theta }}_k$.

To update the parameter ${\kappa }_{k,1}$, which modulates ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2$ at each iteration of kinetostatic folding, it is possible to choose a positive constant value, namely, ${\kappa }_{k,1}={\zeta }_0$. Furthermore, similar to (10), the parameter ${\kappa }_{k,2}$ can be updated according to the rule ${\kappa }_{k+1,2}=h\left({\kappa }_{k,2}\right)$, in which the discrete-time mapping $h(·)$ is given by

$$h({\kappa }_{k,2})={\gamma }_0{\kappa }_{k,2},k\in {\mathbb{Z}}_{0+},$$

(14)

where ${\gamma }_0\in (0,1)$ is a positive constant. Using these choices for the design parameters ${\kappa }_{k,1}$ and ${\kappa }_{k,2}$, we arrive at the conformation-dependent step size update rule

$${\kappa }_k\left({\mathit{\theta }}_k\right)={\zeta }_0{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2+{\kappa }_{0,2}{\gamma }_0^k,k\in {\mathbb{Z}}_{0+}.$$

(15)

The SGD-based scheme in Algorithm 3 under the adaptive step-size update rule (15) takes the form of a hybrid gradient descent law, where both the kinetostatic folding torque vector and its sign simultaneously govern the evolution of the dihedral angle vector at each iteration. In particular, we have the identity $\mathit{\tau }\left({\mathit{\theta }}_k\right)={\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)$. Using this identity along with (15) in (12), we arrive at the following difference equation

$${\mathit{\theta }}_{k+1}={\mathit{\theta }}_k+{\zeta }_0\mathit{\tau }\left({\mathit{\theta }}_k\right)+{\kappa }_{0,2}{\gamma }_0^k\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right),k\in {\mathbb{Z}}_{0+}.$$

(16)

Remark 2.

An intriguing feature of adopting the conformation-dependent step size update rule (15) is the resulting iteration in (16), where the kinetostatic folding torque vector plays a direct role in governing the dihedral angle evolution. Thanks to the conformation-dependent step size update rule (15), the information contained in ${\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2$ will be preserved. This is in direct contrast with the conventional KCM difference equation in (6) and the conformation-independent SGD difference equation in (8), where the information about the magnitude of the folding torque vector is lost.

Using the difference equation given by (12) and the adaptive step-size update rule in (15), we arrive at Algorithm 3, which relies on the directional information of each component in the folding torque vector. In contrast to (9), the step size mapping given by (15) not only depends on the iteration number (i.e., k) but also on the conformation of the protein molecule at each iteration (i.e., ${\mathit{\theta }}_k$). When ${\kappa }_{k,1}=0$ in (13), Algorithm 2 will be retrieved. In other words, the step size mapping given by (9) can be considered as a special case of (13), where the protein conformation does not affect the step size in each iteration. In the next section, we discuss the convergence properties of Algorithms 2 and 3.

Algorithm 3 SGD-Based Kinetostatic Folding Iteration Algorithm with Conformation-Dependent Step Size Update Rule

1: Input: Initial dihedral angle vector ${\mathit{\theta }}_0$, initial step size adaptation parameters ${\gamma }_0\in (0,1)$, ${\zeta }_0>0$, and ${\kappa }_{0,2}>0$, convergence tolerance ${\epsilon }_{\mathrm{tol}}$, max iterations $K_{max}$   2: Output: Folded conformation dihedral angle vector ${\mathit{\theta }}^{*}$   3: $k\leftarrow 0$   4: while$|\mathit{\tau }\left({\mathit{\theta }}_k\right){|}_2<{\epsilon }_{\mathrm{tol}}$ and $k<K_{max}$ do   5:    Compute the generalized force vector $\mathcal{G}\left({\mathit{\theta }}_k\right)$.   6:    Compute the protein chain Jacobian $\mathcal{T}\left({\mathit{\theta }}_k\right)$.   7:    Compute the folding torque vector $\mathit{\tau }\left({\mathit{\theta }}_k\right)\leftarrow \mathcal{T}{\left({\mathit{\theta }}_k\right)}^{\top }\mathcal{G}\left({\mathit{\theta }}_k\right)$.   8:    Adapt the step size ${\kappa }_k\left({\mathit{\theta }}_k\right)\leftarrow {\zeta }_0{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2+{\kappa }_{0,2}{\gamma }_0^k$.   9:    Update the protein conformation using the difference equation in (12): ${\mathit{\theta }}_{k+1}\leftarrow {\mathit{\theta }}_k+{\kappa }_k\left({\mathit{\theta }}_k\right)\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)$. 10:    $k\leftarrow k+1$ 11: end while 12: return${\mathit{\theta }}^{*}\leftarrow {\mathit{\theta }}_k$

4. Convergence Properties of the SGD-Based Kinetostatic Folding Iteration Algorithms

In this section, we analyze the convergence and robustness properties of Algorithms 2 and 3 presented in the previous section. We remark that although the conventional method given in Algorithm 1 has long dominated the KCM literature [26], it lacks formal convergence guarantees.

4.1. Convergence Formalization

We begin by formalizing the notion of convergence to a folded conformation. As specified in Equation (5), the kinetostatic torque vector $\mathit{\tau }\left(\mathit{\theta }\right)$ is aligned with the steepest-descent direction of the free-energy gradient within the protein’s conformational landscape. Given an initial unfolded configuration ${\mathit{\theta }}_0$ located in a neighborhood of the native folded state ${\mathit{\theta }}^{*}$, we say that the difference equations in (8) and (12) converge if

$$\underset{k\to \infty }{lim}{\mathit{\theta }}_k={\mathit{\theta }}^{*}.$$

(17)

The convergence condition in (17) can be expressed in terms of folding torque vectors as follows. At any folded conformation ${\mathit{\theta }}^{*}$, the kinetostatic folding torque vector necessarily vanishes, i.e., $\mathit{\tau }\left({\mathit{\theta }}^{*}\right)=\mathbf{0}$. Accordingly, convergence of the two difference equations given by (8) and (12) can be checked numerically when the Euclidean norm of the kinetostatic folding torque vector falls below a predefined tolerance ${\epsilon }_{\mathrm{tol}}>0$, i.e., when the criterion

$${\left|\mathit{\tau }\left({\mathit{\theta }}_{k^{*}}\right)\right|}_2<{\epsilon }_{\mathrm{tol}},$$

(18)

is met for some positive integer $k^{*}$. This criterion underlies the stopping conditions in SGD-based Algorithms 2 and 3. Smaller values of $k^{*}$ correspond to faster convergence toward the folded protein conformation. The integer $k^{*}$ also specifies the number of interatomic force-field evaluations required to achieve convergence. Since the most computationally demanding aspect of protein folding simulations lies in computing electrostatic and van der Waals interactions, kinetostatic iterations with faster convergence (i.e., smaller $k^{*}$) impose a significantly lighter computational burden.

4.2. Conditions for Convergence of SGD-Based Algorithms

The convergence of the iterative SGD-based schemes in Algorithms 2 and 3 (i.e., the guarantee that $\underset{k\to \infty }{lim}{\mathit{\theta }}_k={\mathit{\theta }}^{*}$) can be understood by noting that, in the vicinity of folded conformations, the free energy landscape of protein molecules is well approximated by quadratic energy functions of the type used in simple elastic network models (see, e.g., [40,41]). In this regime, the aggregate free energy $\mathcal{E}\left(\mathit{\theta }\right)$ given in (4) effectively reduces to a quadratic function of the dihedral angle configuration vector around a minimum-energy folded state.

By approximating the free energy of a protein molecule with a quadratic function in a neighborhood of a folded conformation ${\mathit{\theta }}^{*}$, one can directly invoke a convergence result from the SGD literature. In particular, ref. [32] (Theorem 1) guarantees asymptotic convergence to folded conformations, provided that ${\mathit{\theta }}^{*}$ is an isolated local minimum of $\mathcal{E}\left(\mathit{\theta }\right)$ and that the positivity condition ${({\mathit{\theta }}^{*}-{\mathit{\theta }}_k)}^{\top }\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)>0$ is satisfied within an open neighborhood of ${\mathit{\theta }}^{*}$. Under the stated positivity condition, asymptotic convergence of Algorithms 2 and 3 is guaranteed if the following conditions are satisfied:

C1

$0<{\kappa }_k<2{({\mathit{\theta }}^{*}-{\mathit{\theta }}_k)}^{\top }\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)$ for all $k\in {\mathbb{Z}}_{0+}$;

C2

${\kappa }_k{({\mathit{\theta }}^{*}-{\mathit{\theta }}_k)}^{\top }\mathrm{sgn}\left(\mathit{\tau }\left({\mathit{\theta }}_k\right)\right)\ge c{|{\mathit{\theta }}^{*}-{\mathit{\theta }}_k|}_2^{\alpha }$ for some positive $\alpha$ and c for all $k\in {\mathbb{Z}}_{0+}$; and,

C3

$\underset{k\to \infty }{lim}{\kappa }_k=0$.

The first condition (i.e., C1) ensures that the step size ${\kappa }_k$ is positive but not excessively large, so that each update moves the protein configuration toward the folded conformation without overshooting the stable region. The second condition (i.e., C2) imposes a lower bound on the effective progress made in each iteration, guaranteeing that updates are strong enough to reduce the distance of the protein configuration to the folded conformation in each iteration. Finally, the last condition (i.e., C3) requires the step size to vanish asymptotically, which prevents oscillations around the equilibrium and ensures convergence to the precise minimum-energy conformation.

4.3. Robustness of Convergence of SGD-Based Kinetostatic Iteration Algorithms

In practical implementations, the protein conformation vector ${\mathit{\theta }}_k$ may be subject to various sources of uncertainty arising from numerical or modeling approximations. These uncertainties include finite-precision numerical errors accumulated during iterative updates, approximation errors in force-field evaluation (e.g., truncated van der Waals or electrostatic interaction cutoffs), and stochastic perturbations or deviations in dihedral angles introduced by coarse-grained molecular representations or experimentally reconstructed initial structures (such as those derived from cryo-EM or NMR data).

The iterative SGD-based schemes in Algorithms 2 and 3 also demonstrate robustness to uncertainties beyond their formal convergence guarantees. In particular, even when the conformation vector ${\mathit{\theta }}_k$ at iteration k is perturbed by an uncertainty term ${\mathit{ϵ}}_k$ both algorithms still converge reliably to the folded conformations.

Consider the case where the protein conformation at the kth iteration is affected by an additive uncertainty, that is, when it is updated as ${\mathit{\theta }}_k\leftarrow {\mathit{\theta }}_k+{\mathit{ϵ}}_k$. Accordingly, the difference equation in Algorithm 2 under this uncertainty takes the form

$${\mathit{\theta }}_{k+1}={\mathit{\theta }}_k+{\mathit{ϵ}}_k+{\kappa }_k\mathrm{sgn}\left(\mathit{\tau }({\mathit{\theta }}_k+{\mathit{ϵ}}_k)\right),k\in {\mathbb{Z}}_{0+}.$$

(19)

As demonstrated in ([32], Theorem 2), the perturbed SGD difference equation in (19) still converges to the folded conformation ${\mathit{\theta }}^{*}$ under very mild conditions on the uncertainty vector ${\mathit{ϵ}}_k$. A similar robustness result can be stated for Algorithm 3 with conformation-dependent step size update rule. The robustness property of the proposed SGD-based algorithms ensures convergence to the folded conformation even in the presence of such perturbations, provided that the uncertainty sequence ${\left\{{\mathit{ϵ}}_k\right\}}_{k\in {\mathbb{Z}}_{0+}}$ remains bounded. Specifically, bounded uncertainties do not compromise the asymptotic stability of the kinetostatic folding process since the iterates in (19) continue to approach the minimum-energy state.

5. Numerical Simulations

In this section we present numerical simulations conducted to evaluate the effectiveness of the proposed SGD-based kinetostatic folding algorithms (Algorithms 2 and 3). Their performance is further compared against the conventional kinetostatic folding algorithm (Algorithm 1). The simulations are carried out according to the principles of Protofold I [27].

In our simulations, we focus on two fundamental secondary structure motifs—$\alpha$, namely, helices and $\beta$-pleated sheets, and evaluate the performance of the proposed SGD-based algorithms in driving convergence from unfolded conformations to these structures. The $\alpha$-helix (Figure 2) is one of the most common motifs in proteins, formed by a tightly coiled amino acid chain that adopts a right-handed helical conformation [39]. Likewise, the $\beta$-pleated sheet (Figure 2) represents another essential structural element, playing a key role in protein folding and stability through its ability to induce significant polypeptide chain reorientation [42].

5.1. Simulations for Convergence to $\alpha$-Helix Structures

Our simulations for convergence to $\alpha$-helix structures (Figure 2) were conducted on two protein backbone chains with 20-dimensional and 40-dimensional dihedral angle spaces, respectively. The numerical simulations were performed using the conventional kinetostatic folding algorithm (Algorithm 1) alongside the two SGD-based alternative schemes (Algorithms 2 and 3). The corresponding parameter values are summarized in

Table 1. Parameters for $\alpha$-helix kinetostatic folding simulations.

Folding Algorithm	N (Num. Peptide Planes)	${\mathit{\kappa }}_0\left({\mathit{\kappa }}_{0,2}\right)$	${\mathit{\gamma }}_0$	${\mathit{\zeta }}_0$
Algorithm 1	10	$2\times {10}^{-3}$	–	–
Algorithm 2	10	$2\times {10}^{-3}$	0.995	–
Algorithm 3	10	$2\times {10}^{-3}$	0.995	$1\times {10}^{-4}$
Algorithm 1	20	$4\times {10}^{-3}$	–	–
Algorithm 2	20	$4\times {10}^{-3}$	0.995	–
Algorithm 3	20	$4\times {10}^{-3}$	0.995	$0.5\times {10}^{-4}$

. To ensure a fair comparison, the fixed step size ${\kappa }_0$ in the conventional algorithm was chosen to match the initial step size ${\kappa }_0$ in Algorithm 2 and the parameter ${\kappa }_{0,2}$ in the adaptive, conformation-dependent SGD algorithm (Algorithm 3). Similarly, the step size update weight ${\gamma }_0$ in Algorithm 2 was set equal to the parameter ${\gamma }_0$ used in Algorithm 3.

To ensure consistent initial conditions across the three algorithms, all simulations began with the same pre-coiled backbone chain, positioned near an $\alpha$-helix configuration. Figure 3 and Figure 4 depict the free energy evolution of the peptide backbone under the conventional kinetostatic folding algorithm (Algorithm 1), the SGD-based algorithm with a conformation-independent step size update rule (Algorithm 2), and the SGD-based algorithm with a conformation-dependent step size update rule (Algorithm 3), each starting from this identical conformation (also shown in the figures). The figures further illustrate the protein configurations obtained at the 30th, 60th, 180th, and 540th iterations.

As can be seen from Figure 3 and Figure 4, the conventional kinetostatic folding algorithm achieve a slower convergence rate to the folded $\alpha$-helix configuration. Slower convergence rates as discussed earlier necessitate increased iterations for convergence to minima of the free energy of protein molecules implying an increased computational burden on folding simulations. Remarkably, the slower convergence becomes more nuanced as the number of the peptide planes start increasing. Finally, we remark that unlike the conference version of this paper [38], which used a fixed decay factor for the step size optimized only for $\alpha$-helix convergence, the present work employs an adaptive, conformation-dependent step-size rule (Algorithm 3) with a stopping criterion tied to the torque norm threshold (${\left|\mathit{\tau }\left(\mathit{\theta }\right)\right|}_2<{\epsilon }_{\mathrm{tol}}$). This modification results in smoother convergence with fewer oscillations and naturally leads to different iteration counts across structures.

Table 2. Runtime and convergence comparison for $\alpha$-helix folding simulations.

N	Algorithm	Iterations to Convergence	Reduction vs. KCM
10	Conventional KCM	420	–
10	SGD	280	33% ↓
10	Adaptive SGD	200	52% ↓
20	Conventional KCM	760	–
20	SGD	400	47% ↓
20	Adaptive SGD	290	62% ↓

summarizes the runtime comparison between the conventional KCM framework and the proposed SGD-based algorithms for $\alpha$-helix folding simulations. Because each iteration entails a complete interatomic force evaluation, the reduction in iteration count leads proportionally to a lower computational cost and shorter overall runtime.

5.2. Simulations for Convergence to $\beta$-Pleated Sheet Structures

To examine convergence toward $\beta$-pleated sheet structures (Figure 2), we performed simulations on a protein backbone chain characterized by a 20-dimensional dihedral angle space (see

Table 3. Parameters for $\beta$-pleated sheet kinetostatic folding simulations.

Folding Algorithm	N (Num. Peptide Planes)	${\mathit{\kappa }}_0\left({\mathit{\kappa }}_{0,2}\right)$	${\mathit{\gamma }}_0$	${\mathit{\zeta }}_0$
Algorithm 1	10	$7.5\times {10}^{-3}$	–	–
Algorithm 2	10	$7.5\times {10}^{-3}$	0.995	–
Algorithm 3	10	$7.5\times {10}^{-3}$	0.995	$1\times {10}^{-4}$

). Interestingly, compact $\beta$-sheet motifs of this type have also been identified in small proteins such as chignolin, which is a synthetic mini-protein consisting of only 10 amino acids. This protein nonetheless exhibits stable $\beta$-hairpin folding (see, e.g., [43]).

To ensure consistent initial conditions across the three algorithms, all simulations began with the same configuration in the proximity of a $\beta$-pleated sheet motif. Figure 3 and Figure 4 depict the free energy evolution of the peptide backbone under the conventional kinetostatic folding algorithm (Algorithm 1), the SGD-based algorithm with a conformation-independent step size update (Algorithm 2), and the SGD-based algorithm with a conformation-dependent step size update (Algorithm 3), each starting from this identical conformation (also shown in the figures). The figures further illustrate the protein configurations obtained at the 30th, 60th, 180th, and 540th iterations for all three algorithms.

Closer scrutiny of Figure 5 reveals a slower convergence rate toward the $\beta$-pleated sheet configuration for the conventional kinetostatic folding algorithm (Algorithm 1) compared to its SGD-based counterparts (Algorithms 2 and 3). As previously discussed, this translates to a requirement for a greater number of iterations to reach the free energy minima of protein molecules, leading to a heightened computational demand for kinetostatic folding simulations. Additionally, as can be seen from Figure 5a, the free energy oscillates noticeably around the folded configuration, further highlighting the inefficiency of the conventional kinetostatic folding algorithm. Conversely, the free energy profiles under the SGD-based algorithms exhibit monotonic convergence towards a lower minimum within a shorter timeframe. As can be seen from the free energy profiles in Figure 5b,c, the SGD-based algorithm with adaptive conformation-dependent step size update rule provides a relatively faster convergence rate.

Table 4. Runtime and convergence comparison for $\beta$-pleated sheet folding simulations.

N	Algorithm	Iterations to Convergence	Reduction vs. KCM
10	Conventional KCM	610	–
10	SGD	390	36% ↓
10	Adaptive SGD	250	59% ↓

summarizes the runtime comparison between the conventional KCM framework and the proposed SGD-based algorithms for $\beta$-hairpin folding simulations. Because each iteration entails a complete interatomic force evaluation, the reduction in iteration count leads proportionally to a lower computational cost and shorter overall runtime.

5.3. Discussion

Building on the simulation results presented in Section 5.1 and Section 5.2, this section discusses how the computational performance of the proposed SGD-based algorithms scales with increasing protein size and discusses the observed trends in iteration count and runtime efficiency.

The computational cost of the proposed SGD-based kinetostatic folding algorithms is dominated by the evaluation of interatomic force fields, including electrostatic and van der Waals interactions. Similar to the conventional KCM formulation, the per-iteration complexity scales as $\mathcal{O}\left(N_a^2\right)$ with respect to the number of atoms $N_a$, since each iteration requires computing all pairwise atom–atom interactions. The key advantage of the SGD-based framework lies in its ability to significantly reduce the number of iterations required to reach convergence. As a result, the total computational complexity improves from $\mathcal{O}\left(K_{\mathrm{conv}}{N}_a^2\right)$ for the conventional algorithm to $\mathcal{O}\left(K_{\mathrm{SGD}}{N}_a^2\right)$ for the proposed approach, where $K_{\mathrm{SGD}}<K_{\mathrm{conv}}$. The runtime and convergence comparisons presented in Table 2 and Table 4 demonstrate a reduction of approximately 34–$63\%$ in the total number of iterations (and hence in force-field evaluations), depending on the protein size. Consequently, the proposed algorithms offer a scalable and computationally efficient framework for simulating larger protein systems without modifying the underlying kinetostatic model.

Finally, we conclude this section by noting that the transient performance gap between Algorithms 2 and 3 arises from the conformation-dependent term ${\zeta }_0{\left|\mathit{\tau }\left({\mathit{\theta }}_k\right)\right|}_2$ in Algorithm 3, which preserves magnitude information during descent. Consequently, Algorithm 3 exhibits a more monotonic convergence behavior compared to the purely sign-based updates of Algorithm 2.

6. Conclusions

With the rapid development of peptide-based nanorobots, the need for fast and accurate numerical folding simulations has become increasingly important. This work departs significantly from conventional successive kinetostatic fold-compliance methods traditionally used in protein folding simulations. In particular, we introduced a novel family of SGD-based kinetostatic folding algorithms as an alternative to the conventional approach. Since each iteration requires a full evaluation of interatomic forces, these improvements directly translate to reduced computational cost, as the observed decrease in iteration count proportionally lowers the overall runtime. Beyond the canonical $\alpha$-helix and $\beta$-sheet motifs studied here, the proposed SGD-based kinetostatic folding framework remains applicable to proteins with mixed or multi-domain topologies. Because the algorithms operate directly in the dihedral-angle configuration space, they can accommodate arbitrarily complex backbone geometries without modification to the underlying update law. The convergence guarantees derived in this paper extend to broader classes of folding problems including topologically constrained or multi-stable protein systems.

We expect the SGD-based successive kinetostatic fold compliance framework to be a powerful tool for investigating KCM-driven protein folding under solvation and entropy constraints. The proposed SGD-based kinetostatic folding framework can also be applied to refine experimentally derived structures such as cryo-EM maps (e.g., Apoferritin) and structures obtained from X-ray crystallography or NMR. Because the method operates directly in dihedral-angle space and performs a deterministic descent on the free-energy landscape, it can be initialized from partially resolved experimental conformations and used to iteratively refine backbone configurations toward a nearby minimum-energy state. This makes the approach suitable for cryo-EM models with uncertain backbone placement or missing loop density, as it requires only an initial conformation and topology, does not rely on full landscape sampling, and can be constrained to refine local dihedral angles while preserving well-resolved structural regions. In addition, its inherent compatibility with stochastic SGD extensions (e.g., [44]) opens the door to designing new stochastic algorithms specifically tailored for kinetostatic folding simulations.