Replication Experiment Design: Verifying

Claims in "Geometric Hyperplane

Intersection Solver"
This document outlines a detailed experimental protocol designed to replicate and
verify the key empirical claims presented in the paper "Geometric Hyperplane
Intersection Solver: A Matrix-Inversion-Free Framework with Quantum-
Neuroevolutionary Enhancements" by Tawfiq Jallad and Ma’mon Abu Hammad. The
objective is to independently assess the probability of the reported results and provide
a robust framework for future validation.

1. Introduction

The paper "Geometric Hyperplane Intersection Solver: A Matrix-Inversion-Free

Framework with Quantum-Neuroevolutionary Enhancements" proposes a novel
approach to solving linear systems, integrating geometric algebra, neuroevolution,
and quantum computing. It claims significant improvements in speed, accuracy, and
energy efficiency over traditional methods. Given the ambitious nature of these claims
and the identified concerns regarding author credibility, an independent replication
experiment is essential to verify the reported results and assess their probability.

This experimental design aims to provide a clear, step-by-step protocol for replicating
the core empirical findings of the original paper. By adhering to the specified
hardware, software, and methodological details, this replication study will seek to
answer whether the claimed performance benefits of GHIS can be consistently
reproduced under controlled conditions.

2. Experimental Setup

To ensure the closest possible replication of the original study, the experimental setup
will adhere strictly to the specifications provided in the paper [1].
2.1. Hardware Configuration

The replication experiment will require access to a high-performance computing

environment with the following hardware components:

GPUs: Eight NVIDIA A100 GPUs, each with 40 GB of VRAM. These GPUs are crucial
for replicating the GPU-accelerated linear solves and batched operations
described in the GHIS framework.

CPU: An Intel Xeon Platinum 8380 processor with 32 cores. This CPU will serve as
the host processor for managing computations and running CPU-bound baseline
comparisons.

Quantum Annealer: A D-Wave Advantage 4.1 system, possessing 5000+ qubits.

This is a critical component for replicating the quantum Hodge dual computation
and assessing the claimed quantum speedups. Access to such a system is
paramount for a faithful replication of the hybrid quantum-GPU workflow.

2.2. Software Environment

The software environment will be configured to match the versions used in the original
study to minimize discrepancies arising from software updates or changes in libraries.
The following software will be installed and configured:

Deep Learning Framework: PyTorch 2.0.1. This will be used for implementing
the Graph Neural Networks (GNNs) within the neuroevolutionary co-design
component.

CUDA Toolkit: CUDA 12.2. Essential for leveraging the NVIDIA GPUs for
accelerated computations.

Quantum SDK: D-Wave Ocean 6.4. This SDK provides the necessary tools and
libraries for interacting with the D-Wave quantum annealer and implementing
the quantum annealing algorithms.

Numerical Libraries: PETSc 3.18.5. This library will be used for implementing
and running the PETSc GMRES baseline.

Mathematical Software: MATLAB R2023a. This will be used for generating

synthetic datasets (using gallery(\'randsvd\') ) and potentially for some
baseline comparisons (e.g., LAPACK-based LU decomposition).
2.3. Environment Configuration

Operating System: A Linux-based operating system (e.g., Ubuntu 22.04 LTS) will
be used to ensure compatibility with the specified software stack.

Python Environment: A dedicated Python 3.x environment will be set up to

manage dependencies and ensure consistent execution of scripts.

Network Connectivity: Stable and high-bandwidth network connectivity will be

required for communication with the D-Wave quantum annealer and for
downloading necessary libraries and datasets.

By meticulously replicating this hardware and software environment, the experiment

aims to create a controlled setting that closely mirrors the conditions under which the
original results were obtained, thereby enhancing the validity of the replication
findings.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]

3. Data Generation and Preparation

The replication study will utilize both synthetic and real-world datasets, mirroring the
approach of the original paper to ensure comprehensive testing across various
problem characteristics [1].

3.1. Synthetic Datasets

Synthetic matrices will be generated to systematically evaluate GHIS and baselines

under controlled conditions, particularly focusing on the impact of matrix condition
number. The generation process will be as follows:

Method: MATLAB’s gallery(\'randsvd\') function will be used to generate

square matrices (A) with specified singular values, allowing precise control over
the condition number (κ(A)).

Condition Numbers: Matrices will be generated with condition numbers ranging

from well-conditioned to ill-conditioned: κ(A) ∈ {10^2, 10^4, 10^6, 10^8}. This
 range covers the scenarios where numerical stability is a critical factor.

Dimensions (n): Experiments will be conducted for various matrix dimensions

(n), including those up to 10^4 and 10^6, as mentioned in the original paper, to
assess scalability and complexity claims. Specific dimensions will be chosen to
align with the original paper's reported results (e.g., n=10^4 for speed
comparisons).

Right-Hand Side Vector (b): For each generated matrix A, a corresponding right-
hand side vector b will be constructed such that the true solution x_true is
known. This allows for accurate calculation of relative error. For instance, b can
be generated by A * x_true , where x_true is a randomly generated vector.

Number of Trials: For each combination of n and κ(A) , 100 trials will be
conducted, as per the original paper, with a fixed random seed (e.g., seed = 42
for MATLAB generation) to ensure reproducibility of the synthetic data generation
process.

3.2. Real-World Datasets

Two real-world datasets will be used to evaluate the practical applicability and
performance of GHIS in more realistic scenarios:

UCI Housing Dataset:

Source: The UCI Machine Learning Repository [Link to UCI Housing Dataset
if available online].

Preparation: The dataset will be preprocessed by mean-centering and unit-

variance scaling, as described in the original paper. This standardization
helps in numerical stability and ensures comparability.

Problem Formulation: The dataset will be used to formulate a linear

regression problem, where the features form the matrix A and the target
variable forms the vector b.

Dimensions: The dataset has n = 506 samples and m = 13 features,

resulting in a system of equations with these dimensions.

2D Poisson PDE Discretization:

Method: A 2D Poisson Partial Differential Equation (PDE) will be discretized

using the FEniCS 2019.2.0 framework. This will generate a large, sparse
 linear system.

Mesh Size: A mesh size of 1024×1024 will be used, resulting in a system

with approximately n = 10^6 non-zero elements and 95% sparsity. This is
crucial for testing GHIS on large, sparse problems.

Problem Formulation: The discretized PDE will yield a sparse matrix A and
a vector b, representing the boundary conditions and source terms.

All data generation and preparation scripts will be made publicly available to facilitate
independent verification and future research.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]

4. Implementation Details

To ensure a faithful replication, the implementation of GHIS and all baseline methods
will closely follow the descriptions and algorithms provided in the original paper [1].
Where specific libraries or versions are mentioned, those will be prioritized.

4.1. Geometric Hyperplane Intersection Solver (GHIS)

The implementation of GHIS will be modular, reflecting its three core components:

Hodge-Theoretic Formulation: This component will involve the geometric

interpretation of linear systems, utilizing wedge products and Hodge duality for
solution direction determination. The core mathematical operations will be
implemented in Python, leveraging libraries like NumPy for efficient array
operations. Special attention will be paid to the error bounds and precision
requirements (FP64).

Neuroevolutionary Co-Design:
Graph Representation: The matrix A will be encoded as a directed graph
G=(V,E) as described in Section III-A of the paper. Node features (column
norms, condition numbers, non-zeros) will be extracted.
 GNN Implementation: A 4-layer GNN with GATv2 attention will be
implemented using PyTorch. This GNN will process the graph to generate
node embeddings, capturing column interactions and sparsity patterns.

Genetic Algorithm (GA): A GA will be implemented to evolve the optimal

variable index k for dimensionality reduction. The GA will follow Algorithm
1 from the paper, including population size (200), generations (50),
mutation rate (15%), fitness function (balancing column norm and
submatrix conditioning), and selection (elite selection).

Hybrid Quantum–GPU Workflow:

GPU-Accelerated Solve: The reduced system (A_k x_k = b_k) will be solved
on NVIDIA A100 GPUs. This will involve implementing batched GMRES solver
(restart = 30) with Jacobi preconditioning using CUDA and cuSOLVER. FP64
precision will be used for computational kernels, with FP16 for non-
essential residuals.

Quantum Hodge Dual Computation: The directional vector d will be

computed on the D-Wave Advantage 4.1 system. This will involve scaling the
nullspace vector to [-1,1], discretizing into 8-bit variables, and mapping the
nullspace minimization problem to a QUBO (Quadratic Unconstrained
Binary Optimization) problem. The QUBO will be embedded in D-Wave’s
Pegasus topology using the Ocean SDK, with specified annealing
parameters (anneal time: 20µs, 1000 samples, chain strength: 2.0). Post-
processing will involve majority vote and gradient descent refinement as
per Algorithm 2.

Chaos-Driven Stabilization: The implementation will follow Algorithm 3,

including residual dynamics assessment, Lyapunov exponent determination, and
adaptive regularization of the Tikhonov parameter λ. This will involve embedding
residuals into a phase space and adjusting λ based on the maximum Lyapunov
exponent Λ.

All components will be integrated into a single pipeline as described in Algorithm 4 of

the paper, ensuring proper data transfer and control flow between classical and
quantum computing elements.

4.2. Baselines

The following baselines will be implemented or utilized for comparison:

 LU Decomposition (LAPACK): A standard LU decomposition will be performed
using a highly optimized LAPACK implementation (e.g., via SciPy or MATLAB).
This will serve as a classical direct solver benchmark.

PETSc GMRES: The Generalized Minimal Residual (GMRES) method with a restart
value of 30 will be implemented using PETSc 3.18.5. This is a widely used iterative
solver for large sparse linear systems.

SuiteSparse QR: The SuiteSparse QR factorization (v7.4.3) will be used for sparse
matrix problems. This will be particularly relevant for comparing performance on
the 2D Poisson PDE dataset.

Simulated QLSA: A simulated Quantum Linear System Algorithm (QLSA) will be

implemented using Qiskit 0.41.1. This will provide a benchmark for quantum
algorithms without requiring access to a universal quantum computer, allowing
comparison with the paper's reported simulated QLSA results.

All implementations will prioritize using the exact versions of libraries and software
specified in the original paper to minimize variations due to different algorithmic
implementations or optimizations.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]

5. Experimental Procedures for Claim Replication

This section details the specific experimental procedures designed to replicate and
verify the key empirical claims made in the original paper [1]. Each experiment will be
conducted under controlled conditions, with multiple trials and fixed random seeds to
ensure statistical robustness.

5.1. Claim 1: O(n^2) Complexity and FP64 Precision

Original Claim: GHIS achieves O(n^2) complexity and FP64 precision (1.2×10^-14) for
n ≤ 10^6.

Procedure:
 1. Synthetic Data Generation: Generate synthetic matrices A and vectors b using
gallery(\'randsvd\') in MATLAB for varying dimensions n (e.g., 100, 500,
1000, 5000, 10000, 50000, 100000, 500000, 10^6) and a fixed condition number
(e.g., κ(A) = 10^2). Ensure x_true is known for relative error calculation.

2. Execution: For each n , execute GHIS 100 times with a fixed random seed (e.g.,
seed = 42 for PyTorch and D-Wave Ocean). Record the execution time and the
relative error ||x_computed - x_true|| / ||x_true|| for each run.

3. Baselines: Run LU decomposition (LAPACK) and PETSc GMRES for the same set
of n values and record their execution times and relative errors.

4. Data Collection: Store execution times and relative errors for all methods and n
values.

5.2. Claim 2: Neuroevolutionary Co-Design Memory Savings and

Preconditioner Outperformance

Original Claim: Neuroevolutionary co-design yields 86% memory savings, and the
automatic preconditioner outperforms human-tuned alternatives in 78% of test cases.

Procedure:

1. Synthetic Data Generation: Generate synthetic matrices A and vectors b for

various n and κ(A) values. Focus on problem sizes where memory savings would
be significant.

2. Memory Usage Measurement: During the neuroevolutionary co-design phase of

GHIS, monitor and record the peak memory usage (e.g., using nvidia-smi for
GPU memory and system tools for CPU memory) for the GNN and GA
components. Compare this to a theoretical or simulated baseline without the co-
design for memory savings calculation.

3. Preconditioner Performance:
Human-Tuned Alternatives: Implement several commonly used human-
tuned preconditioners (e.g., Jacobi, incomplete LU, algebraic multigrid) for
the GPU-accelerated GMRES solver.

Comparison: For a diverse set of test cases (matrices with varying

properties), run the GHIS with its automatic preconditioner and each
human-tuned alternative. Record the number of GMRES iterations required
for convergence to a specified tolerance, and the total solution time.
 Test Cases: Use a mix of synthetic and real-world datasets (e.g., UCI
Housing, 2D Poisson PDE) to create a comprehensive set of test cases.

4. Data Collection: Record memory usage, GMRES iterations, and solution times for
all runs.

5.3. Claim 3: Hybrid Quantum–GPU Workflow Speedup

Original Claim: The hybrid quantum–GPU workflow delivers a 4.2× speedup for n ≤
10^4.

Procedure:

1. Synthetic Data Generation: Generate synthetic matrices A and vectors b for n

values up to 10^4 (e.g., 100, 500, 1000, 5000, 10000) and varying condition
numbers.

2. Execution: Execute GHIS, specifically measuring the time taken for the quantum
Hodge dual computation and the GPU-accelerated solve components. The D-
Wave Advantage 4.1 system must be used for the quantum component.

3. Baselines: Run the classical GPU-only equivalent of the nullspace computation

(if a direct classical method exists and is feasible for comparison) and the full
classical LU decomposition and PETSc GMRES for the same n values.

4. Speedup Calculation: Calculate the speedup as Time_Classical / Time_GHIS .

5. Data Collection: Record execution times for all components and baselines.

5.4. Claim 4: Chaos-Driven Stabilization and Error Reduction

Original Claim: GHIS with chaos regularization yields over 63% less relative error than
LU decomposition for 2D Poisson PDEs (p<0.01) and maintains stability for κ(A) ≥
10^8.

Procedure:

1. Data Generation: Generate 2D Poisson PDE problems using FEniCS 2019.2.0 with
a mesh size of 1024×1024. Also, generate synthetic matrices with κ(A) ≥ 10^8.

2. Execution: Run GHIS with and without chaos regularization (if the
implementation allows for disabling it) and LU decomposition on these
problems. Record the relative error for each run.
 3. Statistical Validation: Perform Wilcoxon signed-rank tests to compare the
relative errors of GHIS and LU decomposition, as per the original paper, to check
for statistical significance (p < 0.01).

4. Stability Assessment: For matrices with κ(A) ≥ 10^8, monitor the relative error
of GHIS over multiple iterations or trials to confirm its stability and compare it to
the error propagation in LU decomposition.

5. Data Collection: Record relative errors and statistical test results.

5.5. Claim 5: Energy Efficiency

Original Claim: GHIS is 18% energy efficient compared to CPU baselines.

Procedure:

1. Data Generation: Use a representative set of synthetic and real-world problems

(e.g., 2D Poisson PDE).

2. Energy Measurement: During the execution of GHIS and CPU baselines (e.g., LU
decomposition, PETSc GMRES running on CPU cores only), use tools like nvidia-
smi (for GPU energy) and Intel RAPL (for CPU energy) to measure and record
energy consumption (in Joules or kJ).

3. Calculation: Calculate the total energy consumed for each method and
determine the percentage energy savings.

4. Data Collection: Record energy consumption values.

Each of these experimental procedures will be repeated for 100 trials with fixed
random seeds, and warm-up iterations will be excluded from timing measurements, as
specified in the original paper.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]
6. Data Collection Methods

Accurate and systematic data collection is paramount for the validity and
reproducibility of the replication experiment. For each experimental run, the following
data points will be collected and stored in a structured format (e.g., CSV, JSON, or a
database) for subsequent analysis:

Execution Time (seconds): For each method (GHIS, LU Decomposition, PETSc

GMRES, SuiteSparse QR, Simulated QLSA), the wall-clock time taken to solve the
linear system will be recorded. This will be measured from the start of the solver
routine to its completion, excluding any warm-up iterations as specified in the
original paper. High-resolution timers (e.g., Python's time.perf_counter() ,
MATLAB's tic / toc ) will be used.

Relative Error: The relative error will be calculated as ||x_computed -

x_true|| / ||x_true|| , where x_computed is the solution obtained by the
solver and x_true is the known true solution. This metric will be crucial for
assessing the accuracy and numerical stability claims.

Memory Usage (GB): Peak memory consumption for both CPU and GPU will be
monitored and recorded. For GPU memory, nvidia-smi will be used. For CPU
memory, system-level tools (e.g., psutil in Python, top / htop on Linux) will be
employed. This will be particularly important for verifying the memory savings
claim of the neuroevolutionary co-design.

Energy Consumption (Joules or kJ): Energy consumption will be measured

using nvidia-smi for NVIDIA GPUs and Intel RAPL for Intel CPUs. These tools
provide real-time power draw and cumulative energy consumption, allowing for
the calculation of total energy expended during the solution process.

GMRES Iterations: For iterative solvers like PETSc GMRES and the GHIS GPU-
accelerated GMRES component, the number of iterations required for
convergence to the specified tolerance will be recorded. This provides insight
into the efficiency of the preconditioner and the convergence behavior.

Problem Parameters: For each experiment, the relevant problem parameters

will be recorded, including:
Matrix dimension ( n )

Condition number ( κ(A) ) for synthetic matrices

Sparsity level (for PDE problems)

 Dataset name (e.g., UCI Housing, 2D Poisson PDE)

Random Seeds: The specific random seeds used for data generation (e.g.,
MATLAB gallery(\'randsvd\') ) and solver execution (e.g., PyTorch, D-Wave
Ocean) will be meticulously recorded to ensure full reproducibility of the
experimental runs.

Trial Number: Each of the 100 trials for each configuration will be uniquely
identified.

All collected data will be timestamped and organized in a clear, machine-readable

format to facilitate subsequent statistical analysis and visualization. Data integrity
checks will be performed to ensure accuracy and completeness.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]

7. Performance Metrics and Statistical Analysis

This section outlines the specific performance metrics that will be collected and the
statistical analysis methods that will be applied to evaluate the claims made in the
original paper [1]. The goal is to provide a rigorous framework for determining the
success of the replication and the statistical significance of any observed differences.

7.1. Performance Metrics

For each claim, the following metrics will be primarily used:

Execution Time (seconds): Measured for all methods (GHIS, LU, GMRES, QR,
QLSA) to assess speed and speedup claims. Lower values indicate better
performance.

Relative Error: Calculated as ||x_computed - x_true|| / ||x_true|| . This

metric quantifies the accuracy of the solution. Lower values indicate higher
accuracy and better numerical stability.

Memory Usage (GB): Peak memory consumption (CPU and GPU) will be
recorded to verify memory savings claims. Lower values indicate better memory
 efficiency.

Energy Consumption (Joules or kJ): Total energy consumed during execution

will be measured to assess energy efficiency claims. Lower values indicate better
energy efficiency.

GMRES Iterations: For iterative solvers, the number of iterations to convergence

will be recorded to evaluate preconditioner effectiveness and convergence rate.

7.2. Statistical Analysis

Given that the original paper uses a Wilcoxon signed-rank test and Cohen’s d for
statistical validation, the replication study will primarily employ these methods, along
with other appropriate statistical tests, to assess the significance of the findings.

For Speedup, Relative Error, Memory Usage, and Energy Consumption

Claims:

Wilcoxon Signed-Rank Test: This non-parametric test will be used to

compare the performance of GHIS against baselines across the 100 trials. It
is suitable for paired data (each trial comparing GHIS to a baseline on the
same problem instance) and does not assume a normal distribution of the
differences. A p-value < 0.01 (as used in the original paper) will indicate
statistical significance.

Cohen’s d: This metric will be calculated to quantify the effect size of the
observed differences. A Cohen’s d > 1.8 (as reported in the original paper
for energy savings) indicates a large effect size, suggesting a practically
significant difference.

Percentage Difference: Simple percentage differences will be calculated to

directly compare the magnitude of improvements (e.g., speedup
percentage, error reduction percentage, memory savings percentage,
energy efficiency percentage) as claimed in the paper.

For Preconditioner Outperformance Claim:

Proportion Test: A proportion test (e.g., chi-squared test) will be used to

compare the proportion of test cases where the automatic preconditioner
outperforms human-tuned alternatives against the claimed 78%.
7.3. Criteria for Successful Replication

A claim will be considered successfully replicated if the following criteria are met:

Statistical Significance: The statistical tests (primarily Wilcoxon signed-rank

test) yield p-values below the significance threshold (p < 0.01) for the claimed
improvements (e.g., GHIS being faster, more accurate, more energy-efficient).

Effect Size: The calculated effect sizes (Cohen’s d) are comparable to or exceed
those reported in the original paper, indicating a similar magnitude of
improvement.

Quantitative Agreement: The measured percentage differences (e.g., speedup,

error reduction, memory savings, energy efficiency) are within a reasonable
margin of error (e.g., ±5-10%) of the values reported in the original paper. Exact
numerical matches are not expected due to variations in hardware and software
environments, but the trends and approximate magnitudes should align.

Qualitative Agreement: For claims related to stability (e.g., GHIS maintaining

stability for high κ(A)), the qualitative behavior observed in the replication (e.g.,
flat error curve for GHIS vs. rising error for LU) should match the original paper.

Failure to meet these criteria for a specific claim will indicate that the claim could not
be replicated under the specified experimental conditions, prompting further
investigation into potential discrepancies or limitations.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]

8. Conclusion

This replication experiment design provides a comprehensive and rigorous protocol

for independently verifying the empirical claims made in the paper "Geometric
Hyperplane Intersection Solver: A Matrix-Inversion-Free Framework with Quantum-
Neuroevolutionary Enhancements." By meticulously detailing the experimental setup,
data generation, implementation specifics, experimental procedures, and analytical
methods, this design aims to minimize sources of variability and maximize the
reproducibility of the study.

The successful replication of the claimed performance benefits (speedups, accuracy,

memory savings, energy efficiency) would significantly bolster the credibility of the
original work. Conversely, a failure to replicate, or the identification of discrepancies,
would highlight areas requiring further investigation and potentially challenge the
validity of the original findings. Regardless of the outcome, this independent
verification process is crucial for advancing scientific understanding and ensuring the
integrity of research in the rapidly evolving fields of numerical linear algebra, quantum
computing, and neuroevolution.

References:

[1] Jallad, T., & Hammad, M. A. (n.d.). Geometric Hyperplane Intersection Solver: A
Matrix-Inversion-Free Framework with Quantum-Neuroevolutionary Enhancements.
[Original Paper]