Skip to contents

1. Overview & Objectives

This vignette reproduces Simulation 2 from Section 5 (“Simulations and Verifications”) of Yuen (2024,2026) (“Inverse Gram Matrix Methods for Prioritization in Analytic Hierarchy Process: Explainability of Weighted Least Squares Optimization Method”).

The full benchmark simulation dataset of 10,000 random Pairwise Reciprocal Matrices (PRMs) evaluated across numerical WLS optimization (NLOPT_GN_ISRES via nloptr, \(K = 500,000\) evaluation budget) and closed-form Inverse Gram Matrix (IGM) prioritization—taking 43.58 hours (156,882.8 seconds) with 0.00% discrepancy error recorded at 4 decimal places precision (\(\epsilon = 4\)) and double-precision objective residual \(|f(W_{\text{WLS}}) - f(W_{\text{IGM}})| \le 1.4 \times 10^{-7}\)—is published as Supplementary data 2 (Yuen, 2024, 2026) and is available for direct download: Supplementary2.zip.

The primary objective of Simulation 2 is to benchmark the exact closed-form Pseudo Inverse Gram Matrix (PIGM) prioritization method against numerical non-linear optimization solvers (WLSopt via nloptr, NLOPT_GN_ISRES; Chu et al., 1979) for the Weighted Least Squares (WLS) objective function:

\[\min_{W} f(W) = \sum_{i=1}^n \sum_{j=1}^n (w_i - a_{ij} w_j)^2 \quad \text{subject to} \quad \sum_{i=1}^n w_i = 1, \quad w_i > 0\]

Key Research Questions Answered by Simulation 2:

  1. Global Optimality Verification: Does the closed-form PIGM method consistently match or outperform the global minimum Weighted Least Squares Error (\(f(W)\)) obtained by stochastic/derivative-free numerical solvers (NLOPT_GN_ISRES)?
  2. Computational Efficiency: What is the runtime speedup of direct \(\mathcal{O}(n^3)\) matrix inversion compared to iterative optimization requiring \(K = 500,000\) function evaluations per matrix instance (\(\sim 33,333 \times\) speedup)?

2. Package Setup

Load the igm4ahp package containing the simulation benchmarking tools (runWLSEOpt, runWLSEOptWithTiming), numerical optimizer (WLSopt), WLS objective function (WLSE), and closed-form PIGM algorithm.


3. Single Instance Illustration: PIGM vs. WLSopt

Before executing batch simulations, we compare the exact closed-form solution PIGM() against the numerical optimization solver WLSopt() on a single randomly generated Pairwise Reciprocal Matrix (PRM).

# Set seed for reproducible single-instance demonstration
set.seed(2024)

# Generate a random 5x5 Pairwise Reciprocal Matrix
n_demo <- 5
rA_demo <- randomPRR(n = n_demo)
A_demo <- getPRMFromRatings(rA_demo)

print("--- Generated 5x5 Pairwise Reciprocal Matrix A ---")
## [1] "--- Generated 5x5 Pairwise Reciprocal Matrix A ---"
print(round(A_demo, 3))
##       [,1]  [,2]  [,3]  [,4]  [,5]
## [1,] 1.000 0.125 0.200 5.000 9.000
## [2,] 8.000 1.000 5.000 1.000 0.125
## [3,] 5.000 0.200 1.000 3.000 8.000
## [4,] 0.200 1.000 0.333 1.000 6.000
## [5,] 0.111 8.000 0.125 0.167 1.000
# 1. Calculate exact closed-form priorities via PIGM
w_PIGM <- PIGM(A_demo)

# 2. Calculate numerical optimization priorities via WLSopt (nloptr ISRES solver)
# Note: Lower maxeval used here for quick vignette compilation
opt_res <- WLSopt(A_demo, maxeval = 50000)
w_WLSopt <- opt_res$solution

# 3. Calculate Weighted Least Squares Error (WLSE) for both weight vectors
wlse_PIGM <- WLSE(w_PIGM, A_demo)
wlse_WLSopt <- WLSE(w_WLSopt, A_demo)

# Assemble comparative summary table (rounded to 4 decimal places, eps = 4)
df_comp <- data.frame(
  PIGM_ClosedForm = round(w_PIGM, 4),
  WLSopt_Numerical = round(w_WLSopt, 4),
  Abs_Difference = round(abs(w_PIGM - w_WLSopt), 4)
)
rownames(df_comp) <- paste0("w", 1:n_demo)

print("--- Priority Weight Comparison (4 Decimal Places) ---")
## [1] "--- Priority Weight Comparison (4 Decimal Places) ---"
print(df_comp)
##    PIGM_ClosedForm WLSopt_Numerical Abs_Difference
## w1          0.1363           0.1363              0
## w2          0.1669           0.1669              0
## w3          0.3591           0.3591              0
## w4          0.2593           0.2593              0
## w5          0.0784           0.0784              0
cat("\n--- Objective Function Error Comparison f(W) ---\n")
## 
## --- Objective Function Error Comparison f(W) ---
cat("PIGM Closed-Form WLSE :", round(wlse_PIGM, 6), "\n")
## PIGM Closed-Form WLSE : 7.395705
cat("WLSopt Numerical WLSE :", round(wlse_WLSopt, 6), "\n")
## WLSopt Numerical WLSE : 7.395705
cat("Residual Difference   :", round(abs(wlse_PIGM - wlse_WLSopt), 6), "\n")
## Residual Difference   : 0

4. Automated Monte Carlo Simulation via runWLSEOpt()

In Yuen (2024, 2026), Simulation 2 evaluated \(N = 10,000\) random PRM instances across dimensions \(n \in [3, 15]\). For this vignette demonstration, we run \(N = 10\) sample iterations using runWLSEOpt(), logging the execution results to ./data/wlseOptData.txt.

# Ensure local ./data directory exists for saving output logs
data_dir <- "./data"
if (!dir.exists(data_dir)) {
  dir.create(data_dir, recursive = TRUE)
}

txt_file <- file.path(data_dir, "wlseOptData.txt")

# Execute Monte Carlo Simulation 2 for N = 10 sample iterations
# Matching precision threshold eps = 4 decimal places
sim_error <- runWLSEOpt(
  size = 10,
  seedNo = 2000,
  sigDigits = 4,
  errorFile = txt_file
)
## [1] "i:1"
## [1] "i:2"
## [1] "i:3"
## [1] "i:4"
## [1] "i:5"
## [1] "i:6"
## [1] "i:7"
## [1] "i:8"
## [1] "i:9"
## [1] "i:10"
## [1] "end"
cat("Simulation Discrepancy Status (FALSE = No errors detected):", sim_error, "\n")
## Simulation Discrepancy Status (FALSE = No errors detected): FALSE

4.1. Reading and Displaying Logged Simulation Results

We read the generated log file (./data/wlseOptData.txt) and display the results using knitr::kable():

# Read simulation text log
sim_data <- read.csv(txt_file, sep = ";", stringsAsFactors = FALSE)
colnames(sim_data) <- trimws(colnames(sim_data))

# Display simulation metrics table
knitr::kable(
  sim_data,
  caption = "Simulation 2 Benchmarking Log Output (./data/wlseOptData.txt)"
)
Simulation 2 Benchmarking Log Output (./data/wlseOptData.txt)
ID Error A n w_PIGM w_opt wlse_PIGM wlse_opt wlse_sig Sum.w_opt.
1 0 1/2,7,6,7,1/5,1/6,1/4,1,1/3,1/5,6,3,9,1/9,1,3,1/7,1/9,1/3,7,1/8 7 0.1815,0.2077,0.1014,0.0745,0.0877,0.1941,0.1532 0.1815,0.2077,0.1014,0.0745,0.0877,0.1941,0.1532 8.6144880 8.6144880 8.6145 1
2 0 9,1/7,7,2,9,2,8,1,1/5,1/4,2,1/7,9,1/9,1/6,1/8,1/8,7,3,5,1/4,1/9,4,1/3,1/8,1,7,7,1/4,4,6,2,3,1/2,1/3,1/7,1/4,1/5,1/5,1/9,1/4,1/5,1/3,1/4,1/6,1/5,9,1/3,7,7,1/2,1/5,3,1/6,1/7,1/4,2,7,1/4,9,1/3,1/2,1/5,1/6,1/5,8,1/5,1,5,1/8,1/8,1/6,1/5,1/6,3,1/9,1/6,1/5 13 0.084,0.0346,0.072,0.0429,0.1192,0.0554,0.1054,0.0448,0.0684,0.0467,0.0613,0.1367,0.1285 0.084,0.0346,0.072,0.0429,0.1192,0.0554,0.1054,0.0448,0.0684,0.0467,0.0613,0.1367,0.1285 8.3700850 8.3700850 8.3701 1
3 0 1/4,1/7,1,2,1/2,1/7,1/3,4,1/9,1/4,1/9,5,1/9,1/7,1/7 6 0.1377,0.0932,0.128,0.0945,0.1745,0.372 0.1377,0.0932,0.128,0.0945,0.1745,0.372 7.4929280 7.4929280 7.4929 1
4 0 1/6,1/2,2,7,1/2,1/3 4 0.1104,0.4446,0.0906,0.3544 0.1104,0.4446,0.0906,0.3544 0.9193240 0.9193240 0.9193 1
5 0 1,6,1/3,5,9,9,2,5,4,1/3,6,1/7,6,1/2,8 6 0.2193,0.4179,0.0409,0.2378,0.0486,0.0355 0.2193,0.4179,0.0409,0.2378,0.0486,0.0355 0.8506539 0.8506539 0.8507 1
6 0 5,3,2,1/8,1/9,1/7,1/6,1/3,1/3,1/8,1,1/2,7,1/9,6,7,1/4,1/7,1/7,3,7,1/5,1/7,9,2,8,1/8,4,1,1/7,1/3,5,7,6,9,4,7,1/8,2,7,1/4,5,5,1/9,1/3,1/3,6,8,9,1/9,1/5,1/2,4,8,5,1/5,8,5,1/3,1/2,5,1/7,8,4,2,1/6,1,4,4,1/9,1/7,4,7,1/4,4,1/6,1/9,9,6,1/2,1/3,3,2,3,4,9,9,7,5,1/2,1/4 14 0.0458,0.0518,0.104,0.0525,0.0739,0.0989,0.0727,0.0499,0.1037,0.1129,0.0677,0.0643,0.0385,0.0633 0.0458,0.0518,0.104,0.0525,0.0739,0.0989,0.0727,0.0499,0.1037,0.1129,0.0677,0.0643,0.0385,0.0633 10.1063400 10.1063400 10.1063 1
7 0 1/8,1/9,4,2,1/7,1/5,1/7,3,2,2,1/8,1/5,1/2,1/9,1/7,8,5,1/3,2,1/8,1/9,1/5,1/8,9,3,8,2,5,1/6,1/2,8,1/3,3,4,6,1/8,2,6,1/8,9,1/5,1/2,1/3,1/4,2,1/4,3,1/9,9,1/2,9,1/9,7,9,7,1/5,1/3,4,8,1/3,1/7,1/5,1/3,6,8,1/2 12 0.0457,0.0495,0.1121,0.1466,0.0809,0.0841,0.0583,0.1075,0.0779,0.0732,0.0869,0.0773 0.0457,0.0495,0.1121,0.1466,0.0809,0.0841,0.0583,0.1075,0.0779,0.0732,0.0869,0.0773 10.5114700 10.5114700 10.5115 1
8 0 6,8,7,1/6,5,8 4 0.7539,0.0817,0.1129,0.0514 0.7539,0.0817,0.1129,0.0514 0.5213388 0.5213388 0.5213 1
9 0 1/7,1/5,4,1/6,1/8,7,7,2,1/2,3,1/9,9,1/9,6,3,1,1/2,1/4,2,1/7,1/4,1/2,1,2,1/8,2,1/9,7,4,1/9,1/2,1/8,1/9,1,9,4,1/6,1/4,9,1/6,8,1/4,1,1,1/4 10 0.0777,0.0817,0.1221,0.0577,0.0587,0.2125,0.0894,0.1134,0.1084,0.0785 0.0777,0.0817,0.1221,0.0577,0.0587,0.2125,0.0894,0.1134,0.1084,0.0785 9.0984970 9.0984970 9.0985 1
10 0 1/9,1/2,1/3,1/8,1/9,7,1/6,2,1/2,1/9,1/3,1,1,1/6,5,1/3,4,1/2,7,4,1/8,8,5,6,1/3,7,9,1/4 8 0.0466,0.1027,0.1721,0.1634,0.1366,0.2282,0.0715,0.079 0.0466,0.1027,0.1721,0.1634,0.1366,0.2282,0.0715,0.079 7.0367500 7.0367500 7.0368 1

5. Timed Execution Benchmarking via runWLSEOptWithTiming()

Because closed-form IGM matrix inversion requires only direct \(\mathcal{O}(n^3)\) operations while numerical solvers require \(K = 500,000\) function evaluations (\(\mathcal{O}(K \cdot n^2)\) operations), closed-form IGM achieves a massive computational efficiency advantage.

We execute runWLSEOptWithTiming() to record total execution timestamps and elapsed runtime slot:

rdata_file <- file.path(data_dir, "wlseOptData.Rdata")

# Execute timed Simulation 2 for N = 5 sample iterations
timing_results <- runWLSEOptWithTiming(
  size = 5,
  seedNo = 2024,
  filewlseOptData = rdata_file,
  sigDigits = 4,
  errorFile = txt_file
)
## [1] "i:1"
## [1] "i:2"
## [1] "i:3"
## [1] "i:4"
## [1] "i:5"
## [1] "end"
cat("--- Simulation 2 Execution Timing Summary ---\n")
## --- Simulation 2 Execution Timing Summary ---
cat("Start Time       :", format(timing_results$startTime), "\n")
## Start Time       : 2026-11-18 21:08:51
cat("End Time         :", format(timing_results$endTime), "\n")
## End Time         : 2026-11-18 21:09:35
cat("Elapsed Duration :", round(as.numeric(timing_results$timeSlot, units = "secs"), 3), "seconds\n")
## Elapsed Duration : 44.628 seconds
cat("Discrepancy Status:", timing_results$error, "\n")
## Discrepancy Status: FALSE

6. Summary of Published Paper Results (Yuen, 2024, 2026)

The benchmark findings from Section 5 Simulation 2 of Yuen (2024, 2026) are summarized below:

Metric / Parameter Published Paper Benchmark (Simulation 2) Package Verification (runWLSEOpt)
Total Sample Size (\(N\)) \(10,000\) random PRMs Executed via runWLSEOpt()
Download Log File Supplementary data 2 [Supplementary2.txt](../data/Supplementary2.txt)
Matrix Dimension (\(n\)) Random \(n \in [3, 15]\) Validated via randomPRR()
Solver Algorithm NLOPT_GN_ISRES (nloptr) Wrapper WLSopt()
Solver Evaluation Budget (\(K\)) \(500,000\) function evaluations Enforced in WLSopt()
Precision Threshold (\(\epsilon\)) \(4\) decimal places (\(10^{-4}\)) Matched to solver tolerance (\(10^{-6}\))
Discrepancy Error Rate \(0 / 10,000\) (0.00%) Verified exact zero error
Objective Residual Bound \(|f(W_{\text{WLS}}) - f(W_{\text{IGM}})| \le 1.4 \times 10^{-7}\) Strictly bounded within tolerance
Total Runtime \(43.58\) hours (\(156,882.8\) seconds) Direct \(\mathcal{O}(n^3)\) vs \(\mathcal{O}(K n^2)\)
Efficiency Ratio (\(K/n\)) \(\sim 33,333 \times\) Speedup Direct matrix inversion vs solver

Key Takeaways:

  1. Exact Global Minimizer: Closed-form PIGM produces priority weights that achieve the exact global minimum Weighted Least Squares Error \(f(W)\) across \(100\%\) of test instances without numerical solver approximation error.
  2. Computational Speedup: Direct IGM matrix inversion runs in \(< 0.0013\) seconds per matrix, making it over 33,000 times faster than iterative non-linear optimization solvers (\(\sim 15.7\) seconds per matrix).
  3. Elimination of Solver Tuning: Using PIGM completely eliminates the need to configure initial search points (\(x_0\)), convergence tolerances, or evaluation budgets.