Biomimetic model for computing missing data imputation and inconsistency reduction in pairwise comparisons matrices

TL;DR

This paper introduces a biomimetic model that fills in missing data and reduces inconsistencies in pairwise comparison matrices, inspired by biological processes.

Contribution

The novelty lies in using a biomimetic approach with three biological-inspired phases for imputation and inconsistency reduction.

Findings

The biomimetic model reliably converges to a consistent solution.

The method effectively identifies and repairs inconsistencies in pairwise comparisons.

The algorithm successfully fills in missing data through an iterative process.

Abstract

A biomimetic model is presented to compute missing data imputation and reduce inconsistencies in pairwise comparisons matrices. The proposed regeneration method emulates three primary phases of a biological process: identifying the most damaged areas (by identifying inconsistencies in the pairwise comparison matrix), cell proliferation (filling in missing data), and stabilization (optimization of global consistency). An iterative algorithm is employed to correct inconsistencies and compute missing data imputations within the pairwise comparison matrix. The results demonstrate that the biomimetic approach is robust and reliably converges to a consistent solution.

Figures

Inconsistency concept for a triad (2, 5, 3).

Equations

Full text

1 Introduction

Nature has inspired numerous researchers to develop materials, structures, tools, mechanisms, processes, algorithms, and methods.

Self-healing approaches are presented in [1]. A review of inspiration by nature for the potential development of biomimicry appeared in [2]. The pairwise comparison method (PC or PCs, depending on the context) plays a significant role in assessments, subjective measurements, and decision-making. In various applied sciences, such as engineering, physics, and medicine, physical measurements-like length, weight, area, volume, and temperature are of fundamental importance. However, many researchers who rely on these physical measurements may not realize how frequently subjective measurements are utilized in practice. In fact, subjective measures can often be applied to a broader range of entities than objective measures. For example, evaluating student performance is necessary to award academic degrees, which are crucial to our civilization. Most academic exams rely on rating scales, and pairwise comparisons can enhance these scales used to assess the learning process. The most important challenges to address for the pairwise comparison method include the following:

reduction of inconsistency (not necessarily to zero),finding the nearest consistent PC matrix by optimization,computing the imputation of missing data, known as the regeneration problem.

The importance of reducing inconsistency in pairwise comparisons (PC) matrices has led to a search for methods to measure and locate it. The inconsistency concept is illustrated by Fig 1.

Inconsistency concept for a triad (2, 5, 3).

Traditionally, values of pairwise comparisons are stored in square PC matrices (see [3]). PC matrices have all strictly positive real elements. Each element of a matrix represents a ratio between two entities. Entities may be physical objects (e.g., volumes of river rocks) or abstract concepts (software attributes). More often than not, PCs are used for decision-making. The quality of decisions can be compromised by two main issues: inconsistency in the evaluations and missing PC matrix elements:

inconsistency in a triad (i,j,k) is quantified by the index

$$[eqn]$$

which measures the deviation from the consistency condition $[eqn]$ . Its value is non-zero, when appropriate assessments within a PC matrix are intransitive. For example, if aij = 2 and ajk = 3, then the element aik should be $[eqn]$ . If aik differs from this value, inconsistency arises.missing data imputation when some elements of the PC matrix are unknown.

The pairwise comparisons method tolerates or even utilizes inconsistency in assessments. By analyzing inconsistency, we may improve data acquisition or replace the least probable value in a triad by assuming that it is missing and using the proposed missing data imputation approach.

Inconsistency is related to the number of comparisons. For a PC matrix M of the size n, it is $[eqn]$ in the upper triangle while the minimum number of comparisons is n–1 (for details, see [4]). When there is more data than the required minimum, inconsistency may occur. This principle was addressed in [4] and it is illustrated here in Fig 1. Values 2, 5, and 3 are labels for the arrows between entities. It shows our (subjective) assessment of the entity A area when compared with B as 2. Value 3 shows that the area of B is three times bigger than C. If the ratios between A and B and C were accurate, the ratio of areas A and C should be $[eqn]$ . However, our assessment is 5 and illustrates inconsistency. It is necessary to note the use of the conditional phrase "If the ratios between A and B and C were accurate" in the above text. We do not assume that any of the ratios A/B, B/C or even A/C are accurate. This is why ratio estimations can be inconsistent, and we need to compute the inconsistency.

Even when assessments are fully consistent, there is no guarantee that the resulting priority vector will be accurate. For example, a PC matrix filled entirely with 1s is completely consistent, but it does not provide useful prioritization information. To address this, recent research has introduced the concept of entropy of the priority vector to measure the information content of inconsistent PC matrices (see [5]). This approach demonstrates that the entropy of priority vectors for consistent matrices follows a normal distribution.

According to [6]:

biomimetic, also known as biomimicry, is defined as the imitation of biological processes or models from nature aiming to solve various complex biological problems, such as drug production in biomedical applications and the characterization of nanostructurated biohybrid materials.

In practical terms, the use of pairs in biology is substantial. It is not only applicable to sex but also to legs, hands, eyes, ears, and more. For this reason, we may consider the pairwise comparisons method as a crown example of biomimicry. The pairwise comparisons method has much to learn from biomimetics. This article serves as a call to action. Using biomimetics in pairwise comparisons method is highly advisable.

We propose a model inspired by the process of biological tissue regeneration, in which an organism repairs its damaged tissues. Tissue engineering (see, [7–18]) aims to regenerate or replace damaged tissues with new cells. A crucial component of this process is the scaffold. It is a three-dimensional structure that provides support for cells by mimicking the extracellular matrix (ECM) (see [19]). The biomimetic approach in scaffold design enhances cellular integration, often inspired by biological mechanisms (see [20]) designed to achieve controlled interactions, as seen in nanoparticle uptake models (see [13]). These scaffolds and biomimetic devices address challenges in tissue repair and inflammation control, as explored in the selective cytopheretic device for sepsis (see [12]). The application of these design principles emphasizes collaborative efforts aimed at optimizing tissue regeneration and scaffold-based therapies.

Several studies have addressed inconsistency reduction and missing data imputation in PC matrices. Numerous methods (e.g., scaling techniques [21], inconsistency minimization algorithms [22], or traditional statistical approaches [23]) focus on correcting inconsistencies but do not simultaneously handle missing data imputation. Some recent approaches, such as those based on non-linear optimization [24] and weighted least squares models [25], estimate missing data imputation by minimizing inconsistency. However, they do not integrate biological principles for a dynamic interaction between the two problems. Furthermore, classifications such as in [23] list categories of methods for PC matrices (e.g. scaling methods, statistical methods) but do not include biomimetic approaches.

Our approach differs from other approaches. It is inspired by the process of tissue regeneration, which allows us to address inconsistencies and missing data imputation simultaneously and iteratively, ensuring convergence towards consistent solutions.

Recent advances in missing data imputation have explored diverse domains and methodologies. In the clinical setting, the DACMI Challenge [26] has demonstrated the effectiveness of machine learning approaches such as:

gradient boosting, LightGBM - (https://github.com/microsoft/LightGBM), documentation available on https://lightgbm.readthedocs.io/en/stable/.statistical techniques (e.g., MICE, see [27], available as an R package at https://cran.r-project.org/web/packages/mice/index.html).

They handle incomplete temporal data.

Missing data imputation methodologies, such as multiple imputation, MI, see as reference [28], and maximum likelihood estimation, have been applied in numerous disciplines to fill numerical and categorical gaps [29]. However, these approaches prioritize statistical plausibility and scalability and do not address the specific challenges of PC matrices, where logical consistency is critical despite missing or conflicting entries.

The proposed biomimetic regeneration model fills this gap by using iterative inconsistency correction, inspired by biological repair mechanisms, and through dimensionality reduction approaches (such as PCA, see Appendix B), ensures consistency in PC matrices entries, a requirement not satisfied by existing methods [30].

2 Tissue regeneration model for PC matrices

According to [31], regeneration, in biology, is the process by which some organisms replace or restore lost or amputated body parts.

Biological concepts of regeneration

Tissue regeneration involves the following three main phases:

identification of the damaged area: the body identifies the damaged or missing areas of the tissue,cell proliferation: cells proliferate to replace damaged cells, following a controlled growth process,remodelling and stabilization of the new tissue integrates with the existing one, stabilizing and restoring the original functionality.

Mathematical transposition into an algorithm for PC matrices

Transposing the above-mentioned process into a mathematical context requires the following iterative algorithm.

Algorithm: regeneration of a PC Matrix

1. Identify damaged areas in the matrix (inconsistencies),
2. Proliferate new values for missing entries,
3. Reshape and stabilize the matrix reducing global inconsistency.

Tissue regeneration algorithm for PC matrices

Input: Pairwise comparison matrix A of size $[eqn]$ , with missing and/or inconsistent entries.

1. Step 1 (Identification of damaged areas): The inconsistent triads, representing the "damaged" regions that need correction, are identified.
2. Proliferate new values for missing entries,
3. Reshape and stabilize the matrix reducing global inconsistency.
4. Step 2 (Cellular proliferation): The missing data imputation aij are initialized with the geometric mean of the involved triads (e.g., $[eqn]$ ). Subsequently, they are iteratively updated by the formula $[eqn]$ until the value tends to stabilize.
5. Step 3 (Matrix Stabilization): The gradient method is applied to minimize $[eqn]$ . The algorithm continues to iterate until the overall inconsistency drops below a predefined threshold or a maximum number of iterations is reached, ensuring convergence to a more consistent matrix. For Kii, the 1/3 threshold is proposed as reasonable for most applications. Similarly to p–value in statistics, it is an arbitrary value often found by experimental research. Output: Pairwise comparisons matrix $[eqn]$ , consistent and complete. The inconsistency in the PC matrix and the previous three steps are discussed in the following.

Step 1: Identification of damaged areas

Computing of inconsistency index Kii**_ijk: For each triad of elements (i,j,k) in matrix A, the inconsistency index Kiiijk_ is computed as:

$$[eqn]$$

or the equivalent exponential Koczkodaj-Szwarc formula (see, [32]):

$$[eqn]$$

This index quantifies the deviation from the ideal consistency condition $[eqn]$ .Identification of inconsistent triads: Identify the triads (i ,j ,k ) with the maximum value of Kiiijk, defining these areas as the most inconsistent in the matrix. These triads correspond to the "damaged zones" to be corrected.

Step 2: Cell proliferation

Initialization of missing entries: For each missing value aij, initialize the value $[eqn]$ using an estimate based on existing values. A possible estimate is the geometric mean of the products of known pairs:

$$[eqn]$$

This is done for each triad with a missing value. Finally, a geometric mean of the values obtained is computed and inserted in place of the missing value. This is analogous to the cell proliferation that fills the void created by the injury.Iterative update: for each iteration t, update the values of missing entries and inconsistent triads to reduce inconsistency:

$$[eqn]$$

where $[eqn]$ is a learning parameter controlling the update speed. This step is similar to the controlled growth of new tissue to repair damage.

Step 3: Iteration and stabilization

Consistency optimization: The next step is to optimize the PC matrix to minimize global inconsistency. An optimization algorithm, such as the gradient method, is used to minimize the sum of the squares of the inconsistency indices:

$$[eqn]$$

Calculating the gradient with respect to each element aij:

$$[eqn]$$

It updates the values of aij accordingly.Stabilization: The algorithm continues iterating until the overall inconsistency $[eqn]$ falls below a predefined threshold $[eqn]$ or a maximum number of iterations is reached. This step corresponds to the regenerated tissue, integrating it with the pre-existing tissue.

3 Analysis of the convergence and robustness of the algorithm

Consider a matrix $[eqn]$ , whose elements aij represent pairwise comparisons between entities i and j. The goal of the algorithm is to correct the inconsistency in the matrix A. We define the local inconsistency of a triad (i,j,k) by the index Kijk, as:

$$[eqn]$$

The global inconsistency I(A) is then the sum of the local inconsistencies for all triads in the matrix:

$$[eqn]$$

We reduce I(A) for each iteration until the inconsistency is acceptable, i.e., $[eqn]$ , where $[eqn]$ is a stopping threshold.

The elements aij of the PC matrix are iteratively updated according to this rule:

$$[eqn]$$

where $[eqn]$ represents a correction based on the local inconsistency and $[eqn]$ is a positive learning rate that controls the magnitude of the update. The term $[eqn]$ can be expressed as:

$$[eqn]$$

The goal of this update rule is to correct the elements of the PC matrix that contribute the most to inconsistency, iteratively reducing I(A).

To demonstrate that the algorithm converges, we need to show that the function I(A) is non-increasing, meaning that at each step the global inconsistency decreases:

$$[eqn]$$

In order to reduce I(A) at each iteration, the update of the matrix elements follows the gradient descent method. The gradient of I(A) with respect to aij is given by:

$$[eqn]$$

The update of aij is done in the direction opposite to the gradient:

$$[eqn]$$

This ensures that the global inconsistency I(A) decreases as the update rule modifies aij in the direction that reduces I(A) as quickly as possible.

In order for the algorithm to converge, the variation $[eqn]$ cannot be too large. If $[eqn]$ is too large, we might overshoot the minimum of the function I(A) in a single step, causing instability or divergence.

Let us consider a second-order approximation for I(A) in terms of aij:

$$[eqn]$$

Substituting the update rule $[eqn]$ , we get:

$$[eqn]$$

In order for $[eqn]$ , the second term must be negative and dominate the third term. This leads us to the condition:

$$[eqn]$$

where $[eqn]$ represents the second derivative of the function, specifically indicating how quickly the gradient of I(A) changes as a function of the matrix elements aij. The second derivative provides insight into the local behaviour of the function and helps determine how to update the matrix to reduce inconsistency. The second derivative of the function I(A) with respect to aij is:

$$[eqn]$$

This expression represents how the rate of change (the gradient) of the global inconsistency function I(A) itself changes as we adjust aij. In simpler terms, it tells us how sharply or smoothly the function changes in response to variations in the matrix element aij.

Interpretation of the Second Derivative:

– If $[eqn]$ , the function is locally increasing (convex behaviour), and a small change in aij will cause the function to increase in that direction.– If $[eqn]$ , the function is locally decreasing (concave behaviour), and a change in aij will cause the function to decrease.

The condition $[eqn]$ ensures that the update step is approximately sized to avoid overshooting the minimum or causing oscillations. This guarantees that each step of the algorithm moves in a controlled way toward minimizing the inconsistency function I(A).

Since $[eqn]$ is chosen to satisfy the above condition, the term $[eqn]$ dominates the second-order term. Therefore:

$$[eqn]$$

which proves that the global inconsistency decreases or remains constant at each step.

The algorithm is robust to small perturbations in the initial values and parameters. Small variations in the initial values $[eqn]$ lead to only small variations in the final behaviour of the algorithm, as successive corrections gradually reduce the inconsistency until a stable solution is reached.

The proposed algorithm converges under the conditions established for $[eqn]$ , ensuring a continuous reduction of the global inconsistency I(A) at each iteration. The parameter $[eqn]$ must be chosen based on the maximum curvature of the inconsistency function I(A) to ensure stability and avoid oscillations.

The convergence properties of the algorithm are not only mathematically proven but also have direct implications for real-world applications. In decision-making systems where consistency is critical (e.g., medical diagnostics or engineering safety assessments), the guaranteed convergence ensures that the algorithm does not indefinitely oscillate between inconsistent states. For instance, in a robotic control system requiring real-time adjustments of priorities (as in [33]), the bounded global inconsistency I(A) guarantees stable operational parameters even in dynamic environments.

The learning rate $[eqn]$ plays a dual role in balancing convergence speed and numerical stability:

Low $[eqn]$ (e.g., $[eqn]$ ): Ensures smooth, stable updates but may require more iterations, suitable for scenarios where precision is prioritized over speed (e.g., clinical decision-making).High $[eqn]$ (e.g., $[eqn]$ ): Accelerates convergence but risks overshooting optimal values, acceptable in non-critical applications (e.g., inventory prioritization) where computational efficiency is paramount.

In applications, $[eqn]$ must be calibrated based on the problem’s sensitivity to noise. For example, in the medical example cited in [12], where tissue-regeneration-inspired matrices are used to prioritize treatments, a conservative $[eqn]$ prevents destabilizing fluctuations in critical thresholds.

The lower bound of inconsistency

The global inconsistency I(A) is a sum of non-negative terms. It is bounded below by zero:

$$[eqn]$$

Therefore, there exists a lower bound $[eqn]$ (fixed at will), such that I(A) cannot fall below this threshold. If the algorithm continues to reduce inconsistency but cannot drop below $[eqn]$ , it must stop once I(A) approaches this value.

Convergence to a stable solution

To prove that the algorithm will converge to a stable solution, consider the sequence $[eqn]$ . We have already shown that this sequence is non-increasing and bounded below by $[eqn]$ . By the convergence theorem of a bounded and monotonic sequence, {I(A^(t)^)} will converge to a limit value I .

The algorithm follows the gradient descent that minimizes I(A). We can conclude that the algorithm converges to a PC matrix A  with an inconsistency level I , which can be zero or an arbitrary acceptable value:

$$[eqn]$$

If the algorithm approaches I  by a small arbitrary value, we consider A  as a consistent or nearly consistent matrix, resolving the inconsistency reduction problem.

The “arbitrary level” for inconsistency is similar to the concept of “p-value” in statistics. We are aware that it is not an ideal solution, but it follows the “good enough is perfect” approach proposed by Herbert A. Simon. It is a part of his bounded rationality principle that was a major contribution to earning him both Turing and Nobel prizes.

Even if the initial estimates of the missing data imputation may not be perfect, the biomimetic approach is robust and tends to correct them by regeneration. The initial inaccuracy is improved through iteration and optimization. It mimics the tissue regeneration of how an organism corrects initial mistakes during tissue repair.

Computational complexity

The computational complexity of the proposed method is $[eqn]$ , where n represents the dimension of the matrix (i.e., the number of elements being compared). It is determined by:

the algorithm computes inconsistencies for every triad in a PC matrix indexed by (i,j,k); the number of all possible triads in an $[eqn]$ PC matrix is $[eqn]$ , which is $[eqn]$ ,during each iteration, the values of the inconsistent elements in the matrix are updated to reduce the global inconsistency. The number of elements in a matrix is $[eqn]$ , and in each iteration, these values must be computed and updated.

Step 1 dominates the computational complexity, since each triad is evaluated in every iteration. However, no other mathematically correct method can avoid processing all triads since the number of all triads grows with $[eqn]$ . Fortunately, the PC matrix size is small (not exceeding 8 in most methodologies based on PC method).

The number of iterations required for convergence depends on the initial level of inconsistency in the matrix and the threshold value $[eqn]$ chosen for acceptable inconsistency. A very small threshold requires more iterations, increasing.

For PC matrices, the elements below the main diagonal are the reciprocals of the elements above the diagonal. Consequently, we can compute and update only the upper half of the matrix, leading to savings in both computational time and memory usage. Furthermore, for large matrices, optimization techniques based on approximation methods, such as iterative methods (e.g., gradient descent with momentum), low-rank approximations (e.g., singular value decomposition or matrix factorization), can be applied to accelerate convergence, or principal component analysis (PCA) for dimensionality reduction.

While the proposed biomimetic algorithm exhibits $[eqn]$ complexity due to triad evaluation, this aligns with other specialized methods for PC matrix inconsistency reduction and imputation. For example, nonlinear optimization approaches (e.g., [24]) and weighted least squares models (e.g., [25]) also require $[eqn]$ operations due to matrix inversion or gradient-based steps. However, our iterative update rule avoids full matrix inversion, offering practical efficiency gains for small-to-medium-sized PC matrices ( $[eqn]$ ).

For large matrices (n>10), our method’s complexity can be reduced (via PCA, see Appendix B), comparable to low-rank approximation techniques. In contrast, general-purpose imputation methods like MICE [30] or LightGBM [26], while offering $[eqn]$ asymptotic efficiency, fail to enforce PC matrix consistency constraints, a critical limitation for decision-making applications. Table 1 summarizes the theoretical and practical trade-offs between methods, highlighting the unique capability of our approach to simultaneously address inconsistency reduction and missing data imputation without sacrificing scalability through dimensionality reduction.

Table 1: Comparison of methods for inconsistency reduction and missing data imputation in pairwise comparison matrices.

The presented biomimetic approach simultaneously computes inconsistencies and missing data imputation. We are unaware of any other method capable to do it this way.

4 A more comprehensive real-life example

There are two practical challenges associated with real-life examples of PC solutions.

Non-trivial problems, such as selecting a site for nuclear waste disposal, often take several years to resolve and can easily cost millions of dollars.These problems are highly specialized, making them understandable only to a small group of domain experts.

For these reasons, we have used an example from [34]. It pertains to a crucial and urgent research topic: autism in children, which aligns with the scope of PLOS ONE.

4.1 Method

To avoid self-plagiarism (by copying the same example here), we use different values. However, it is just a matter of the labels of rows and columns of the PC matrix that make it a real-life example. Therefore, this research does not contain any studies on human participants or animals conducted by the authors.

4.2 Example

Let us optimize an incomplete PC matrix A of the size 5 by 5 by estimating the missing data imputation (based on the geometric means of the triads), and subsequently by applying the iterative algorithm to minimize the inconsistency.

Consider the following 5x5 PC matrix with two missing data imputation, a14 and a25:

$$[eqn]$$

A missing value is in three triads with the missing value a14 and three triads with a25). The missing data imputation will be estimated using the geometric mean of each triad.

The estimation of a14 involved triads:

Triad (1, 2, 4): $[eqn]$ Triad (1, 3, 4): $[eqn]$ Triad (1, 5, 4): $[eqn]$

Taking the geometric mean of the three estimated values:

$$[eqn]$$

The estimation of a25 involved the following three triads:

Triad (2, 4, 5): $[eqn]$ Triad (2, 3, 5): $[eqn]$ Triad (1, 2, 5): $[eqn]$

Taking the geometric mean of the three estimated values:

$$[eqn]$$

After estimating the missing data imputation, the updated matrix $[eqn]$ becomes:

$$[eqn]$$

The iterative algorithm is executed to minimize the global inconsistency of the matrix, progressively updating each element aij of the matrix.

The update of each element is performed according to the formula:

$$[eqn]$$

where:

– $[eqn]$ is the learning rate, set to $[eqn]$ .– The sum is computed for all $[eqn]$ , representing the correction based on the triads involving aij.

The pseudocode for the iterative algorithm, which refers to python cod 1# in https://doi.org/10.5281/zenodo.15267213, is the following, while the explicit calculations of the inconsistencies obtained following this algorithm are present in Appendix A:

Algorithm 1. Biomimetic PCM optimization (pseudocode).

Input:

1: $[eqn]$ : Initial PC matrix with missing/inconsistent

entries

2: $[eqn]$ : Learning rate

3: ε: Convergence threshold

4: $[eqn]$ : Maximum iterations

Output:

5: $[eqn]$ : Optimized PC matrix

6: procedure BIOMIMETICREGENERATION ( $[eqn]$ )

7:   Initialize missing aij using geometric means of valid

triads:

$$[eqn]$$

8:   $[eqn]$

9:   $[eqn]$

10:   while $[eqn]$ do

11:    $[eqn]$

12:    for i from 0 to n–1 do

13:     for j from i + 1 to n–1 do

14:      $[eqn]$

15:      for k from 0 to n–1 do

16:       if $[eqn]$ then

17:        $[eqn]$

18:       end if

19:      end for

20:      $[eqn]$

21:      Update aij and enforce reciprocity:

$$[eqn]$$ $$[eqn]$$

22:     end for

23:    end for

24:    Compute difference between iterations:

$$[eqn]$$

25:    if $[eqn]$ then

26:     return $[eqn]$

27:    end if

28:    $[eqn]$

29:    $[eqn]$

30:   end while

31:   return $[eqn]$

32: end procedure

4.3 The final PC matrix and its global inconsistency

The final matrix, obtained at the end of the minimization process (discussed in subsection A.1, see Appendix A), using the python code 2# (present in https://doi.org/10.5281/zenodo.15267213), is the following:

$$[eqn]$$

The global inconsistency I(A) converges to the value $[eqn]$ .

The algorithm has significantly improved the global inconsistency with respect to the matrix $[eqn]$ .

In fact, the inconsistencies of the triads of the matrix $[eqn]$ are:

$[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ;

$[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ;   $[eqn]$ ,

obtaining $[eqn]$ .

5 Conclusions and future research

The proposed biomimetic model for PCs represents a mathematically rigorous method for computing inconsistencies and missing data (elements) PC matrices. By integrating biological principles of tissue regeneration with numerical optimization techniques, the proposed algorithm reduces inconsistencies in PC matrices, thereby enhancing the reliability of decisions made based on them.

In future research, we plan to analyze the use of orthogonalization [21] as observed in biological systems such as the orthogonal positioning of plants. We will also explore adding a rating scale to our biomimetic model presented in [35]. Furthermore, we intend to investigate the application of tensors to simplify the computation of multidimensional relationships within PC matrices. This could lead to substantial changes in the traditional approach of comparing only two elements at a time. By using tensors, we can model multiple dimensions, such as the comparisons between three or more parameters of a biomimetic system, which may include biological, mechanical, and environmental properties. The application of tensors would also simplify computations needed to reduce inconsistency at multiple levels and variables.

In general, solving complex human problems through a biomimetic approach is of considerable importance for our civilization. Our future research will focus on exploring the origins of reasoning by leveraging biomimetic principles, as suggested in our previous work [36].

Appendix A

1. Matrix update: At each iteration, the update-matrix function is called to compute the new PC matrix $[eqn]$ .

2. Difference checking: The difference between the current PC matrix and the updated PC matrix is computed using the matrix-difference function. If this difference is less than the convergence threshold $[eqn]$ , the cycle stops (the matrix is considered converged).

3. Current PC matrix updating: If convergence is not reached, the updated PC matrix $[eqn]$ becomes the new current matrix A, and the iteration loop repeats.

4. Iteration increment: In each iteration loop, the iteration counter increases by 1. If the maximum number of iterations (max-iterations) is reached, the cycle stops regardless of the computed difference.

After nine iterations, the values of inconsistency Kii drop to a very low level of inconsistency. The final result of the matrix is as follows:

$$[eqn]$$

Triad (1,2,3):

$$[eqn]$$ $$[eqn]$$

Triad (1,2,4):

$$[eqn]$$ $$[eqn]$$

Triad (1,2,5):

$$[eqn]$$ $$[eqn]$$

Triad (1,3,4):

$$[eqn]$$ $$[eqn]$$

Triad (1,3,5):

$$[eqn]$$ $$[eqn]$$

Triad (1,4,5):

$$[eqn]$$ $$[eqn]$$

Triad (2,3,4):

$$[eqn]$$ $$[eqn]$$

Triad (2,3,5):

$$[eqn]$$ $$[eqn]$$

Triad (2,4,5):

$$[eqn]$$ $$[eqn]$$

Triad (3,4,5):

$$[eqn]$$ $$[eqn]$$

The iterative algorithm has significantly reduced the local inconsistency of the matrix after a limited number of iterations. The limit of inconsistency was analyzed in [22] and the number of iterations in [37].

A.1 Minimization of I(A) using gradient descent

We proceed with minimizing I(A) using gradient descent, applying this procedure until the global inconsistency, I(A), drops to the threshold of approximately 0.3.

The update of each aij follows this rule:

$$[eqn]$$

where $[eqn]$ is the derivative of I(A) with respect to aij, obtained by summing the contributions of all triads involving aij.

Below is the pseudocode (which refers to the Python code 2# in https://doi.org/10.5281/zenodo.15267213), for global inconsistency minimization I(A):

Algorithm 2. Global inconsistency minimization (pseudocode).

Input: Initial PC matrix $[eqn]$ , learning rate $[eqn]$ , maximum

iterations $[eqn]$ , stopping threshold $[eqn]$

Output: Optimized PC matrix $[eqn]$ with $[eqn]$

1: Initialization:

2: $[eqn]$

3: $[eqn]$

4: while $[eqn]$ do

5:   $[eqn]$

6:   for i from 0 to n–1 do

7:    for j from i + 1 to n–1 do

8:     $[eqn]$

9:     for k from 0 to n–1 do

10:      if $[eqn]$ then

11:       $[eqn]$

12:       $[eqn]$

13:      end if

14:     end for

15:     Compute correction term:

$$[eqn]$$

16:     Update aij:

17:     $[eqn]$

18:     Enforce reciprocity:

19:     $[eqn]$

20:    end for

21:   end for

22:   Compute $[eqn]$

23:   if $[eqn]$ then

24:    return $[eqn]$ , $[eqn]$

25:   end if

26:   $[eqn]$

27:   $[eqn]$

28: end while

29: Compute $[eqn]$

30: return $[eqn]$ , $[eqn]$

Appendix B: Dimensionality reduction with PCA for large pairwise comparison matrices

This appendix demonstrates how Principal Component Analysis (PCA) can be used to reduce the size of a large pairwise comparison (PC) matrix while preserving its essential structure. The reduced matrix is then stabilized using the biomimetic algorithm described in the paper, achieving low inconsistency (I(A)) in fewer iterations.

B.1 PCA-based reduction

The objective is reduce a $[eqn]$ PC matrix to a smaller $[eqn]$ matrix (k<n) while retaining key priorities.

The steps are:

1. Symmetrize the matrix:

$$[eqn]$$

This ensures the matrix is symmetric, a requirement for PCA.2. Apply PCA: Extract k principal components to capture the most variance in the data.3. Cluster components: Use k-means clustering to group the original elements into k clusters.4. Form Reduced Matrix: For each pair of clusters (i,j), compute the geometric mean of all pairwise comparisons between elements in clusters i and j.

B.2 Biomimetic algorithm on reduced matrix

The reduced $[eqn]$ matrix is stabilized using the algorithm from the paper:

1. Update rule:

$$[eqn]$$

where $[eqn]$ is the learning rate (set to 0.1), and n is the matrix size.2. Stopping condition: The algorithm stops when the difference between consecutive matrices falls below $[eqn]$ or after $[eqn]$ .

B.3 Example with a 5×5 matrix from section Example of the paper

Original Matrix:

$$[eqn]$$

Using the following pseudocode, Algorithm 3, (referring to the Python 3# code, present in https://doi.org/10.5281/zenodo.15267213), which involves the reduction of dimensionality with PCA, the stabilization of the PC matrix through the iterative algorithm and finally the minimization of the global inconsistency I(A), we obtain:

Reduced Matrix (3x3):

$$[eqn]$$

with initial I(A) (3x3): 0.31Stabilization and minimization Process:

$$[eqn]$$

with final I(A): 0.002 (after 4 iterations).

Algorithm 3. PCA-Based dimensionality reduction for PC matrices (pseudocode).

Input: Original PC matrix $[eqn]$ , target dimension k, learning rate

$[eqn]$ , stopping threshold $[eqn]$ , maximum iterations $[eqn]$

Output: Stabilized PC matrix $[eqn]$ , Final global inconsistency

$[eqn]$

1: Symmetrize the matrix: $[eqn]$

2: Compute top k eigenvectors of $[eqn]$ , project to get transformed

$[eqn]$

3: Apply K-means clustering to $[eqn]$ , obtaining $[eqn]$

4: Initialize $[eqn]$ as empty lists

5: for p from 0 to n–1 do

6:   $[eqn]$

7:   Add p to $[eqn]$

8: end for

9: Initialize $[eqn]$ as $[eqn]$ matrix with diagonal entries 1

10: for i from 0 to k–1 do

11:   for j from i + 1 to k–1 do

12:    Collect elements $[eqn]$ from

original A

13:    if elements non-empty then

14:     $[eqn]$

15:     $[eqn]$

16:     $[eqn]$

17:    else

18:     $[eqn]$ , $[eqn]$

19:    end if

20:   end for

21: end for

22: $[eqn]$

23: $[eqn]$

24: while $[eqn]$ do

25:   $[eqn]$

26:   for i from 0 to k–1 do

27    for j from i + 1 to k–1 do

28:     $[eqn]$

29:     $[eqn]$

30:     $[eqn]$

31:     Enforce reciprocity: $[eqn]$

32:    end for

33:   end for

34:   Compute $[eqn]$

35:   if $[eqn]$ then

36:    $[eqn]$

37:    break

38:   end if

39:   $[eqn]$

40:   $[eqn]$

41: end while

42: Compute $[eqn]$

43: return $[eqn]$ , $[eqn]$

B.5 Discussion

PCA-based dimensionality reduction is a viable strategy for large PC matrices. The biomimetic algorithm efficiently stabilizes the reduced matrix, preserving the main priorities while reducing the computational burden, in fact after only 4 iterations the matrix reaches an inconsistency of 0.002. The Computational complexity has been reduced from O(5^3^) = 125 to O(3^3^) = 27, that is, from a cost of 1125 necessary operations (as seen in the Section Example) to only 108.