Metis 0.3.1 Documentation

1.1 Provenance labels

A value being Metis-calculated does not mean it is a new statistical method. It means that the formula is implemented in Metis instead of being returned directly by an upstream package. Where Metis implements an extension, the relevant methodological source and the exact source-level behaviour are stated.

1.2 Current source scope

The current backend identifies SEMinR as its statistical engine. At the time of this documentation update, CRAN lists SEMinR 2.5.0 (25 May 2026), and seminrExtras is used as the supplementary analysis package.

1.3 Important distinction: methodology versus software parity

Metis is designed to follow established PLS-SEM methodology, but numerical equality with another program is not guaranteed simply because two programs use the same visible settings. Resampling, random-number generators, fold allocation, missing-data handling and implementation details can produce small numerical differences.

2.2 Analysis provenance map

2.3 End-to-end research workflow

The current public workflow can be read as the following technical chain:

Install Metis
   ↓
Create/open .metisws workspace
   ↓
Import CSV/XLS/XLSX dataset
   ↓
Inspect headers, numeric values and missing cells
   ↓
Draw measurement and structural model
   ↓
Choose PLS/HOC
   ↓
Run PLS-SEM
   ↓
Run follow-up inference/prediction/advanced analysis as required
   ├── Bootstrap
   ├── PLSpredict + optional CVPAT
   ├── IPMA / NCA / cIPMA
   ├── MICOM
   └── MGA
   ↓
Inspect settings + execution log + tables/charts
   ↓
Save results
   ↓
Export tables/HTML/R reproduction code or assemble Tark report

This order is methodological rather than merely navigational. For example, advanced IPMA/NCA/cIPMA are follow-up analyses of a fitted PLS model; MICOM is relevant before substantive multi-group interpretation; and PLSpredict evaluates out-of-sample prediction rather than replacing ordinary measurement/structural-model assessment.

2.4 Calculation progress and the optional Metis Game

While an analysis is running, Metis displays a calculation modal with the current phase, progress feedback and controls to hide or stop the calculation. The calculation continues independently of the interface shown inside that modal.

Metis can also show a small 2048-style puzzle during the wait. The Metis Game setting is off by default. To turn it on, open Preferences, find Metis Game under the general settings and enable it. The puzzle appears only in the calculating modal, and its interface state is separate from the analysis request.

3.1 Supported analysis data

The current backend reads CSV/TXT and Excel (.xlsx, .xls) data. Before estimation, Metis validates that the dataset is tabular, contains rows and columns.

Metis analyses run locally. Dataset paths are restricted to trusted Metis/workspace locations.

3.2 Missing-value markers

When a dataset is imported, Metis lets the user identify the representation used for missing observations. The preset choices are Empty cells / NA, -99, -999, 999, -1 and None (all valid). A researcher can also enter a custom marker and save it for reuse.

The selected custom missing-value marker is stored with the dataset and is used by the import preview and Data View missing-value navigator to count, locate and highlight matching cells. None (all valid) disables marker-based missing-cell detection for that dataset.

3.3 Missing-data treatments

3.4 Missing-value discovery in Data View

The Data View missing-value navigator is not a statistical imputation method. It identifies cells matching supported missing markers, moves the virtualised grid to each location and highlights the row/column intersection. Navigation does not silently replace values but helps you to identify the missing values paths.

4.1 Structural paths

Each directed arrow on the model canvas is translated to a SEMinR structural relationship. For a path from construct \(X\) to construct \(Y\), Metis eventually generates the equivalent of:

seminr::paths(from = "X", to = "Y")

and combines paths through seminr::relationships().

4.2 Reflective/composite Mode A measurement

For standard PLS, a regular reflective construct in the visual interface is represented in SEMinR as a Mode A composite:

seminr::composite(name, items, weights = seminr::mode_A)

In SEMinR, Mode A outer-weight updates are based on correlations between indicators and the current construct score. Conceptually, for indicator matrix \(X_j\) and current construct score \(\hat\eta\), the next Mode A weight vector is proportional to the indicator–construct correlations:

\[ \mathbf{w}_A \propto \operatorname{cor}(\mathbf{X}_j,\hat\eta). \]

The term “reflective” in the Metis canvas therefore describes the conceptual measurement direction presented to the researcher, while standard PLS computation uses SEMinR’s Mode A composite representation. This distinction matters when comparing standard PLS with PLSc.

4.3 Formative/composite Mode B measurement

A formative construct is represented by:

seminr::composite(name, items, weights = seminr::mode_B)

SEMinR’s Mode B update is regression-like. For standardized indicator block \(X\), the weight vector is proportional to:

\[ \mathbf{w}_B = \mathbf{R}_{XX}^{-1}\mathbf{r}_{X\eta}, \]

where \(\mathbf{R}_{XX}\) is the indicator correlation matrix and \(\mathbf{r}_{X\eta}\) is the vector of correlations between indicators and the current construct score.

For formative specifications, indicator collinearity and the relevance/significance of outer weights are generally more important than internal-consistency measures intended for reflective constructs.

4.4 Single-item constructs

For a single-item construct, Metis uses SEMinR’s single_item() specification inside the appropriate composite/reflective wrapper. Reliability metrics returned by SEMinR for single-item constructs may be fixed to 1 by the package’s reliability functions; this is a computational convention and should not be interpreted as empirical proof of perfect reliability.

4.5 Consistent PLS (PLSc)

When the user selects Consistent PLS (PLSc), Metis represents reflective/common-factor constructs with seminr::reflective() rather than Mode A composite(). SEMinR then applies its consistent PLS treatment to reflective factor models. PLSc was developed to correct consistency problems that arise when common-factor models are estimated with traditional PLS path modelling; see Dijkstra and Henseler (2015).

Formative constructs remain Mode B composites because PLSc correction is not a formative-measurement operation.

4.6 Temporary model copies

From a model’s context menu in Workspace Home, Temporary Copy opens an in-memory experimental copy. The copy can be edited and analysed without changing the source model or writing the temporary model to the workspace.

Temporary copies do not autosave, and ordinary Save is disabled. Save As promotes the copy to a permanent model. Analysis results remain transient until Save Results is selected; Metis then asks for the permanent model destination and saves the linked result. Returning home removes the temporary session without a discard prompt.

5.1 Inner weighting

Metis exposes path, factor and centroid labels in the preferences interface.

path_centroid <- function(smMatrix, construct_scores, dependant, paths_matrix) {
  adj <- paths_matrix + t(paths_matrix)
  sign(stats::cor(construct_scores, construct_scores)) * adj
}

5.2 Initial outer weights

The Preferences interface exposes uniform, Lohmöller and random initial-weight labels. The current SEMinR estimation call used by Metis does not expose a public initial-weight argument. Metis therefore records the requested value but uses SEMinR’s default initialisation.

5.3 Maximum iterations

The maximum iteration count is passed to seminr::estimate_pls() as maxIt.

5.4 Stop criterion

The UI displays thresholds such as 1e-7. SEMinR expresses its convergence criterion as a power-of-ten integer, so Metis converts:

1e-7 → 7
1e-8 → 8

before passing the value as stopCriterion.

5.5 Syntax assessment

If requested, assess_syntax is passed to SEMinR. It affects SEMinR’s syntax checking rather than the statistical definition of a correctly specified model.

5.6 What seminr::estimate_pls() actually does

Metis does not contain a separate hidden PLS estimator for ordinary PLS-SEM. After Metis has translated the visual model into SEMinR measurement and structural objects, the ordinary estimation route calls seminr::estimate_pls(). The current SEMinR implementation preprocesses the model, prepares HOCs/interactions where applicable and then calls seminr::simplePLS() for the iterative PLS estimation. The general PLS-PM algorithm follows the iterative component-score logic described in the PLS literature (e.g., Tenenhaus et al., 2005); the details below document the current SEMinR source implementation used by Metis.

Metis visual model
      ↓
build SEMinR measurement + structural specifications
      ↓
apply missing-data treatment
      ↓
standardise manifest variables
      ↓
initialise measurement weights = 1 on specified relations
      ↓
XW → standardised construct scores
      ↓
inner weighting
  ├── path weighting: correlations + incoming OLS betas
  ├── factor weighting: connected construct correlations
  └── centroid weighting: signs of connected construct correlations
      ↓
inner proxy scores → standardise
      ↓
update outer weights
  ├── Mode A: indicator–proxy covariance
  └── Mode B: regression/correlation inverse
      ↓
standardise outer weights
      ↓
check Σ|new weight − old weight| < 10^-c
      ├── no → iterate
      └── yes
           ↓
final construct scores + outer loadings
           ↓
OLS structural path coefficients + R²
           ↓
PLSc correction where `reflective()` was specified
           ↓
SEMinR model object → Metis result extraction

6.1 Outer loadings

Outer loadings are obtained from the SEMinR estimated model/summary. A loading represents the association between an indicator and its construct score in the estimated measurement representation.

For standard reporting, a high loading means that a large share of the indicator’s variance is associated with its construct. A commonly cited practical benchmark is approximately 0.708 because \(0.708^2\approx0.50\), but thresholds should be applied in context rather than as automatic deletion rules (Hair et al., 2019).

6.2 Outer weights

Outer weights are SEMinR-native. They define the contribution of each indicator to the composite score. Their role is especially central for formative/composite Mode B specifications.

Bootstrap inference should be used when the research question requires testing whether a weight is statistically distinguishable from zero.

6.3 Cronbach’s alpha

SEMinR calculates Cronbach’s alpha from the indicator correlation matrix. For \(k\) indicators with correlation matrix \(\mathbf R\), the current package implementation is equivalent to:

\[ \alpha = \frac{k}{k-1} \left( 1-\frac{\operatorname{tr}(\mathbf R)}{\sum_{i=1}^k\sum_{j=1}^k R_{ij}} \right). \]

Because \(\operatorname{tr}(\mathbf R)=k\) for a correlation matrix, this is a standardized-alpha calculation. SEMinR sets the value to 1 for single-item constructs.

6.4 Composite reliability \(\rho_C\)

For standardized outer loadings \(\lambda_j\), SEMinR computes Dillon–Goldstein/composite reliability as:

\[ \rho_C = \frac{\left(\sum_j \lambda_j\right)^2} {\left(\sum_j \lambda_j\right)^2 + \sum_j(1-\lambda_j^2)}. \]

Single-item constructs are returned as 1 by the package.

6.5 Average variance extracted (AVE)

SEMinR computes:

\[ AVE = \frac{1}{m}\sum_{j=1}^{m}\lambda_j^2. \]

The classic convergent-validity discussion originates with Fornell and Larcker (1981). An AVE of 0.50 is often used as a descriptive benchmark because it indicates that the construct accounts for at least half of the variance of its indicators on average.

6.6 Dijkstra–Henseler’s \(\rho_A\)

SEMinR calculates \(\rho_A\) using the estimated outer weights and empirical indicator covariance structure, following the consistent PLS reliability framework of Dijkstra and Henseler (2015).

For a construct weight vector \(\mathbf w\), standardized indicator covariance matrix \(\mathbf S\) with its diagonal removed, and \(\mathbf A_{off}=\mathbf w\mathbf w'\) with the diagonal removed, the current SEMinR source computes the matrix expression:

\[ \rho_A = (\mathbf w'\mathbf w)^2 \left[ \frac{\mathbf w'\mathbf S\mathbf w} {\mathbf w'\mathbf A_{off}\mathbf w} \right]. \]

SEMinR assigns \(\rho_A=1\) for formative constructs, single-item constructs and interaction constructs. This should be understood as package behaviour rather than evidence that a formative block possesses internal consistency.

6.7 Fornell–Larcker criterion

The Fornell–Larcker table is taken from SEMinR. The conventional comparison places \(\sqrt{AVE}\) on the diagonal and inter-construct correlations off the diagonal. Under the classical rule, a construct’s square root of AVE should exceed its correlations with other constructs (Fornell and Larcker, 1981).

Because discriminant-validity assessment has advanced beyond relying solely on Fornell–Larcker, Metis also reports HTMT where available.

6.8 HTMT

HTMT values are SEMinR-native. The heterotrait–monotrait ratio compares average correlations across constructs with correlations among indicators of the same constructs. In simplified form for constructs \(a\) and \(b\):

\[ HTMT_{ab} = \frac{ \text{mean}(|r_{ij}|: i\in a,j\in b) } { \sqrt{ \text{mean}(|r_{ii'}|: i\neq i', i,i'\in a) \text{mean}(|r_{jj'}|: j\neq j', j,j'\in b) } }. \]

HTMT was introduced as a more sensitive discriminant-validity criterion by Henseler, Ringle and Sarstedt (2015). Values below 0.85 or 0.90 are common reference points, but the appropriate criterion depends on conceptual similarity and the chosen inference approach.

6.9 Cross-loadings

Cross-loadings are obtained from the SEMinR summary. Metis displays the matrix but does not use a separate custom cross-loading estimator.

6.10 VIF

7.1 Path coefficients

Path coefficients are SEMinR-native, extracted from model$path_coef. After construct scores have been estimated, each endogenous construct is modelled as a linear function of its specified antecedents.

For endogenous construct \(\eta_j\):

\[ \eta_j = \sum_{h\in A_j}\beta_{hj}\eta_h + \zeta_j, \]

where \(A_j\) is the set of antecedents, \(\beta_{hj}\) are path coefficients and \(\zeta_j\) is the residual term.

7.2 Coefficient of determination \(R^2\)

Metis normally reports the value supplied through the SEMinR summary. The standard identity is:

\[ R^2 = 1-\frac{\sum_i(y_i-\hat y_i)^2}{\sum_i(y_i-\bar y)^2}. \]

The value describes the proportion of variance in an endogenous construct score explained by its antecedents in the fitted model. It is an explanatory/in-sample criterion and should not be treated as a substitute for out-of-sample predictive assessment.

7.3 Adjusted \(R^2\)

If SEMinR exposes adjusted \(R^2\), Metis reports it. If not, Metis can calculate:

\[ R^2_{adj}=1-(1-R^2)\frac{n-1}{n-k-1}, \]

where \(n\) is the number of observations and \(k\) is the number of unique incoming predictors of the endogenous construct.

7.4 Effect size \(f^2\)

Normal f² output comes from the SEMinR summary. The standard effect-size definition is:

\[ f^2=\frac{R^2_{included}-R^2_{excluded}}{1-R^2_{included}}. \]

The Metis backend contains a defensive wrapper around SEMinR’s fSquared function. If SEMinR throws an indexing error for a problematic interaction-model configuration, the wrapper returns NA rather than crashing the whole summary. An NA should therefore be interpreted as unavailable, not as a zero effect.

7.5 Direct, indirect and total effects

Let \(\mathbf B\) be the path-coefficient matrix of an acyclic structural model. SEMinR obtains total effects from path products across all admissible chains. In matrix notation:

\[ \mathbf T=\mathbf B+\mathbf B^2+\mathbf B^3+\cdots, \]

with the series terminating in an acyclic finite model when higher powers contain no additional paths.

Total indirect effects are:

\[ \mathbf T_{indirect}=\mathbf T-\mathbf B. \]

Specific indirect effects correspond to particular mediated chains such as:

\[ X\rightarrow M\rightarrow Y, \qquad IE_{XMY}=\beta_{XM}\beta_{MY}. \]

For mediation inference, Metis relies on bootstrap distributions. A useful methodological reference is Nitzl, Roldán and Cepeda (2016).

7.6 Information criteria

Metis returns SEMinR’s information-theoretic criteria (it_criteria) when available. The current SEMinR implementation calculates an error sum of squares for each endogenous construct:

\[ SS_{err,k}=(1-R_k^2)\operatorname{Var}(\eta_k)(N-1), \]

then:

\[ AIC_k = 2(p_k+1)+N\log\left(\frac{SS_{err,k}}{N}\right), \]

\[ BIC_k = N\log\left(\frac{SS_{err,k}}{N}\right)+(p_k+1)\log(N), \]

where \(p_k\) is the number of antecedents of construct \(k\). These are the current SEMinR package formulas used by the backend, which is more precise than assuming a generic likelihood-based implementation from another SEM package.

8.1 Provenance warning

The current model-fit block in Metis is Metis-calculated from SEMinR scores, loadings and path coefficients. It is not a direct call to a SEMinR, SmartPLS or cSEM fit function. These values should therefore be described as Metis fit diagnostics rather than assumed to be bit-for-bit equivalents of another software package’s fit output.

General discussion of approximate fit in PLS/composite modelling can be found in Henseler, Hubona and Ray (2016). Conventional CB-SEM cut-offs should not be transferred mechanically to PLS-SEM diagnostics.

8.2 Observed indicator correlation matrix

Metis first computes the observed correlation matrix \(\mathbf R\) from the manifest indicators, using pairwise-complete observations.

8.3 Saturated construct correlation matrix

For the saturated representation, Metis computes correlations among SEMinR construct scores:

\[ \mathbf \Phi_{sat}=\operatorname{cor}(\hat\eta). \]

8.4 Estimated construct correlation matrix

For the estimated structural representation, Metis uses the path coefficient matrix \(\mathbf B\), observed exogenous construct correlations and residual variances derived from \(1-R^2\).

A residual covariance/variance matrix \(\mathbf\Psi\) is formed such that:

• exogenous construct covariance entries are taken from observed construct-score correlations;
• each endogenous construct receives residual variance approximately \(\max(1-R^2,10^{-8})\).

Metis then constructs:

\[ \mathbf A=(\mathbf I-\mathbf B')^{-1}, \]

\[ \mathbf\Sigma_{construct}=\mathbf A\mathbf\Psi\mathbf A'. \]

This covariance matrix is converted to a correlation matrix.

8.5 Implied indicator correlation matrix

Using SEMinR’s outer-loading matrix \(\mathbf\Lambda\), Metis constructs:

\[ \hat{\mathbf R}=\mathbf\Lambda\mathbf\Phi\mathbf\Lambda', \]

then fixes the diagonal to 1 and sanitises the matrix to a valid correlation range.

8.6 SRMR

For residual matrix:

\[ \mathbf E=\mathbf R-\hat{\mathbf R}, \]

Metis takes the lower triangle including the diagonal and computes:

\[ SRMR_{Metis}=\sqrt{\operatorname{mean}(E_{ij}^2)}. \]

This is a Metis reconstruction using its selected residual elements.

8.7 \(d_{ULS}\)

Metis computes:

\[ d_{ULS}=\sum E_{ij}^2 \]

for the same lower-triangular residual vector.

8.8 NFI

A null implied matrix equal to the identity is used. If \(d_{ULS,null}>0\), Metis calculates:

\[ NFI_{Metis}=1-\frac{d_{ULS}}{d_{ULS,null}}. \]

8.9 \(d_G\)

Observed and implied correlation matrices are repaired to positive-definite correlation matrices where required using Matrix::nearPD(). Metis then obtains positive eigenvalues \(\lambda_q\) of:

\[ \hat{\mathbf R}^{-1}\mathbf R \]

and computes:

\[ d_G=\sqrt{\sum_q[\log(\lambda_q)]^2}. \]

8.10 Which fit block is displayed?

Metis calculates saturated and estimated versions where possible. The current Results View presents one value per metric and prefers the saturated block when available, while the estimated block is retained in the backend response for possible future expansion.

9.1 Ordinary SEMinR bootstrap

For ordinary models, Repeated Indicators HOCs and Disjoint Two-stage HOCs, Metis calls:

seminr::bootstrap_model(
  seminr_model = model,
  nboot = nboot,
  cores = resolved_cores
)

The bootstrap model is summarised by SEMinR at the requested confidence level. Metis returns path coefficients, total effects, indirect effects, outer loadings, outer weights and available HTMT confidence intervals.

9.2 Number of subsamples

The route default is currently 500 if no request value is supplied. The user can request more subject to configured resource ceilings.

9.3 Percentile intervals

For a bootstrap distribution \(\theta_1^*,\ldots,\theta_B^*\) and significance level \(\alpha\), a percentile interval uses empirical quantiles:

\[ CI_{perc}= \left[ Q_{\alpha/2}(\theta^*), Q_{1-\alpha/2}(\theta^*) \right]. \]

9.4 Bias-corrected (BC) interval

The BC interval measures median bias in the bootstrap distribution relative to the original estimate. Metis calculates:

\[ \hat z_0=\Phi^{-1}\left(\frac{\#\{\theta^*<\hat\theta\}}{B}\right), \]

then uses:

\[ p_L=\Phi(2\hat z_0+z_L), \qquad p_U=\Phi(2\hat z_0+z_U), \]

and reports the corresponding empirical bootstrap quantiles.

9.5 Bias-corrected and accelerated (BCa) interval

Metis now implements a full Bias-Corrected and Accelerated (BCa) interval. In addition to the bias-correction parameter \(\hat z_0\), it calculates the acceleration parameter \(a\) through non-parametric leave-one-out jackknife estimation:

\[ \hat\theta_{(i)}=\text{PLS estimate with observation }i\text{ removed}, \]

\[ \bar\theta_{(\cdot)}=\frac{1}{n}\sum_{i=1}^{n}\hat\theta_{(i)}, \]

\[ a=\frac{\sum_{i=1}^{n}\left(\bar\theta_{(\cdot)}-\hat\theta_{(i)}\right)^3}{6\left[\sum_{i=1}^{n}\left(\bar\theta_{(\cdot)}-\hat\theta_{(i)}\right)^2\right]^{3/2}}. \]

The adjusted BCa probabilities are:

\[ p_L=\Phi\left(\hat z_0+\frac{\hat z_0+z_L}{1-a(\hat z_0+z_L)}\right), \]

\[ p_U=\Phi\left(\hat z_0+\frac{\hat z_0+z_U}{1-a(\hat z_0+z_U)}\right). \]

When \(a=0\), the BCa interval simplifies to the BC interval. This ordinary-model route adds the selected interval to paths, loadings, weights and total effects. Embedded two-stage HOC bootstrap retains its custom percentile and BC interval route.

9.6 Current sign-change boundary

PLS-SEM bootstrap scores can be sign-indeterminate across resamples. The current backend contains a construct-labelled correction branch that compares original and bootstrap outgoing path-coefficient vectors and flips relevant path rows or columns when their signs oppose. It does not correlate original and bootstrap construct scores.

The visible individual-level setting does not yet have a distinct backend branch. Researchers should therefore not report individual-level sign correction as applied in the current release.

9.7 Current bootstrap execution route

For ordinary models, the selected Percentile, BC or BCa confidence-interval type reaches the post-processing route. For BCa, Metis computes jackknife acceleration matrices for paths, loadings, weights and total effects and applies the adjusted intervals to the corresponding tables.

The visible resampling option is not consumed by this route. The current desktop fields for tails and sign changes also do not match the field names read by the execution branch, so those visible selections should not be reported as applied without confirming the execution payload. The t-statistic interval choice is not a distinct implemented interval route.

10.1 HOC terminology

• HOC — higher-order construct.
• LOC — lower-order construct/dimension.
• Repeated indicators — the HOC is assigned the leaf manifest indicators of its LOCs.
• Embedded two-stage — Stage 1 obtains scores from a repeated-indicator hierarchical model; Stage 2 uses those scores in a new model.
• Disjoint two-stage — uses SEMinR’s higher-composite/two-stage route.

10.2 Repeated Indicators — Metis-built, SEMinR-estimated

For each HOC, Metis recursively collects all leaf indicators belonging to its LOC dimensions. The HOC is then represented as a SEMinR composite using:

• Mode A when the HOC is reflective;
• Mode B when the HOC is formative.

Metis preserves the original nomological structural paths and adds direction-aware HOC–LOC paths:

Reflective HOC: HOC → LOC
Formative HOC:  LOC → HOC

This allows the hierarchical relation itself to be represented during estimation rather than reducing the HOC to a detached score-only construct.

10.3 Embedded Two-stage — Metis-orchestrated

Embedded estimation is a distinct Metis workflow.

10.4 Disjoint Two-stage — SEMinR route

Metis calls SEMinR’s higher-composite/two-stage representation for the Disjoint route.

10.5 Embedded HOC bootstrap

A two-stage score model must not hold the Stage-1 scores fixed during resampling if the goal is to propagate Stage-1 estimation uncertainty. Therefore, Embedded bootstrap in Metis operates as:

for each bootstrap resample b:
    resample original observations with replacement
    rerun Embedded Stage 1
    extract new Stage-1 scores
    rerun Embedded Stage 2
    save paths, loadings, weights and derived effects

Metis then constructs bootstrap distributions for direct paths, total effects, total indirect effects, specific indirect effects, loadings and weights.

For an observed parameter \(\hat\theta\) and bootstrap values \(\theta_b^*\), Metis reports the bootstrap mean and standard deviation. Its custom embedded t statistic is:

\[ t=\frac{\hat\theta}{SD(\theta^*)}. \]

The custom two-sided bootstrap p-value is:

\[ p=2\min\left[P(\theta^*\le0),P(\theta^*>0)\right]. \]

Percentile and Metis BC intervals are also returned.

10.6 Specific indirect paths and current limit boundary

The Embedded custom path enumerator can recognise long mediated chains beyond the ordinary SEMinR helper’s current cutoff. This does not mean that Metis globally removes all mediator-count limitations. Repeated Indicators and Disjoint bootstrap use SEMinR’s ordinary specific-effect helper and therefore inherit its current limitations.

10.7 HOC support matrix

11.1 Interaction construction

Metis currently creates interaction terms using:

seminr::interaction_term(
  iv = X,
  moderator = M,
  method = seminr::two_stage
)

The same IV×moderator pair is created only once even if it moderates more than one outcome. The corresponding interaction construct can then have multiple structural paths.

11.2 Moderator main effect

If the moderator → outcome main effect is missing, Metis adds it to the estimation payload. This protects SEMinR’s two-stage interaction estimation and also follows the hierarchical principle that the interaction should normally be interpreted with its component main effects represented.

11.3 Joint model

The Joint model is the actual structural model containing all selected interaction terms simultaneously. Its path coefficients, bootstrap confidence intervals and significance results are the inferential moderation results for that fitted model.

11.4 Isolated moderation diagnostic

Metis also provides an Isolated comparison mode as a diagnostic. It is not a substitute for the joint model’s coefficient inference.

For each interaction:

1. Metis fits a baseline model with all interaction terms removed.
2. It fits another model with only the focal interaction restored.
3. It extracts \(R^2\) for the interaction’s outcome.
4. It calculates:

\[ \Delta R^2=R^2_{with}-R^2_{without}, \]

\[ f^2_{interaction}=\frac{\Delta R^2}{1-R^2_{with}}. \]

Metis labels the diagnostic as:

• \(f^2\ge0.35\): large;
• \(0.15\le f^2<0.35\): medium;
• \(0.02\le f^2<0.15\): small;
• \(f^2<0.02\): negligible.

These labels are descriptive conventions. The joint interaction coefficient and its bootstrap inference remain the primary evidence for moderation.

11.5 Simple slopes and slope chart

The Results View includes interaction summaries, simple-slope tables and a slope plot. These are presentation/interpretation layers derived from the fitted interaction model. Researchers should report the underlying interaction coefficient and inferential interval together with any slope visualisation.

12.1 Core execution — SEMinR-native predictions

Metis calls:

seminr::predict_pls(
  model = fitted_model,
  technique = predict_DA_or_EA,
  noFolds = folds_or_NULL_for_LOOCV,
  reps = repetitions,
  cores = NULL
)

Before the call, Metis sets the requested prediction seed.

Current Metis defaults are:

12.2 Direct Antecedents (DA)

SEMinR’s predict_DA uses the immediate/direct antecedent construct scores when generating an endogenous construct prediction. At the construct-score matrix level, the current package computes the structural projection and restores exogenous scores.

For a simple chain:

A → B → C → D

DA predicts \(D\) from its immediate antecedent \(C\) (and any other direct predecessors of \(D\)).

12.3 Earliest Antecedents (EA)

SEMinR explicitly defines EA as Earliest Antecedents. The current package zeroes endogenous positions, retains exogenous/earliest construct information and propagates predicted scores through the structural ordering.

For:

A → B → C → D

EA conceptually follows:

A → predicted B → predicted C → predicted D

12.4 Current UI terminology

The current UI and backend use the canonical label Earliest antecedents (EA). Legacy stored values labelled Entire antecedents are normalised for compatibility.

12.5 K-fold cross-validation

For \(K\)-fold validation, observations are partitioned into \(K\) subsets. Each fold is held out once while the model is fitted on the remaining folds. Predictions for all held-out cases are then combined.

SEMinR’s current prediction source shuffles the data once and creates folds with a deterministic cut() over the shuffled order. Metis reconstructs this mapping using the same R sample()/cut() pattern so that its benchmark calculations align with SEMinR’s prediction rows.

12.6 Leave-one-out cross-validation (LOOCV)

When validation mode is LOOCV, SEMinR is called with noFolds = NULL, which makes the number of folds equal to the number of usable observations. Each observation is therefore held out once.

12.7 Repetitions: current SEMinR implementation detail

The current SEMinR predict_pls() source shuffles the data once before the repetitions loop. If reps > 1, the same ordered data are passed repeatedly to the fold-building function, which deterministically reconstructs the same folds. Item-level PLS and LM predictions are averaged across those repetitions.

This is one reason that other softwares and Metis can be methodologically aligned yet differ by small amounts under apparently identical visible settings.

12.8 Normalised Metis prediction object

Raw SEMinR prediction output is converted into one aligned internal object. Metis aligns common row identifiers across:

• item actual values;
• PLS out-of-sample item predictions;
• PLS out-of-sample residuals;
• LM out-of-sample item predictions;
• LM residuals;
• construct out-of-sample predictions;
• construct reference/actual scores (actuals_star).

This object becomes the single source for the main PLSpredict summaries and MV CVPAT.

12.9 Linear-model (LM) benchmark

LM predictions are produced by SEMinR as part of predict_pls(). Metis does not independently refit the normal LM benchmark used in the MV summary; it reads SEMinR’s LM out-of-sample predictions and residuals.

Under DA and EA, SEMinR selects benchmark predictor items according to its prediction technique. Because this is package-controlled, the exact LM predictor construction should be attributed to the installed SEMinR version.

12.10 Indicator Average (IA) benchmark — Metis-calculated

For each held-out case \(i\) and endogenous indicator \(j\), Metis reconstructs the training fold \(T_i\) and calculates the training-set mean:

\[ \hat y^{IA}_{ij} =\frac{1}{|T_i|}\sum_{k\in T_i}y_{kj}. \]

The IA residual is:

\[ e^{IA}_{ij}=y_{ij}-\hat y^{IA}_{ij}. \]

For LOOCV, \(T_i\) is every usable observation except \(i\).

This avoids data leakage: the held-out observation does not contribute to its own benchmark prediction.

12.11 Construct-level IA benchmark

For endogenous construct \(c\), Metis uses SEMinR’s held-out reference construct scores \(\xi_{ic}^*\). The training-fold construct mean is:

\[ \hat\xi^{IA}_{ic} =\frac{1}{|T_i|}\sum_{k\in T_i}\xi_{kc}^*, \]

and:

\[ e^{IA}_{ic}=\xi_{ic}^*-\hat\xi^{IA}_{ic}. \]

12.12 RMSE

For prediction errors \(e_i\):

\[ RMSE=\sqrt{\frac{1}{n}\sum_{i=1}^{n}e_i^2}. \]

RMSE penalises large errors more strongly because errors are squared.

12.13 MAE

\[ MAE=\frac{1}{n}\sum_{i=1}^{n}|e_i|. \]

MAE has a linear error penalty and is therefore less dominated by very large residuals than RMSE.

12.14 Manifest-variable Q²predict

Metis calculates Q²predict using PLS and IA errors for the same finite observations:

\[ Q^2_{predict,j} =1- \frac{ \sum_{i\in V_j}(e^{PLS}_{ij})^2 } { \sum_{i\in V_j}(e^{IA}_{ij})^2 }, \]

where:

\[ V_j=\{i:e^{PLS}_{ij}\text{ and }e^{IA}_{ij}\text{ are finite}\}. \]

Interpretation is direct:

• \(Q^2_{predict}>0\): PLS-SEM has smaller squared prediction error than the IA benchmark over those cases;
• \(Q^2_{predict}=0\): equal squared-error performance;
• \(Q^2_{predict}<0\): IA performs better.

12.15 Construct-level Q²predict

Construct Q²predict is not obtained by averaging indicator Q²predict values. Metis calculates it directly from held-out construct-score residuals:

\[ Q^2_{predict,c} =1- \frac{ \sum_{i\in V_c}(e^{PLS}_{ic})^2 } { \sum_{i\in V_c}(e^{IA}_{ic})^2 }. \]

This distinction is important: an average of indicator Q² values is not mathematically equivalent to a Q² calculated from construct-score prediction errors.

12.16 PLSpredict result panels

The current predictive summary panels are:

1. PLSpredict MV Summary — Indicator, Q²predict, PLS RMSE/MAE, LM RMSE/MAE, IA RMSE/MAE.
2. PLSpredict LV Summary — Construct, Q²predict, PLS RMSE/MAE.
3. CVPAT MV Summary — PLS vs IA and PLS vs LM.
4. CVPAT LV Summary — construct/overall CVPAT output from seminrExtras.

Diagnostic panels preserve case-level MV/LV predictions and errors plus PLS error histograms.

12.17 PLSpredict with interactions

Current SEMinR prediction source contains method-specific prediction paths for two-stage, product-indicator and orthogonal interaction models. Metis currently creates its own model interactions with SEMinR’s two-stage interaction method, so the relevant native prediction branch is the SEMinR two-stage interaction route.

12.18 PLSpredict with HOCs

SEMinR’s native predict_pls() returns no prediction for models carrying a native HOC flag because there is no published general HOC PLSpredict solution in the package.

Metis supports Repeated Indicators HOCs only through a constrained internal alias strategy:

1. duplicated repeated-indicator columns are copied to unique internal names;
2. the measurement specification is rewritten only for those duplicate aliases;
3. an equivalent SEMinR model is re-estimated;
4. Metis verifies that path coefficients and construct scores match the original model within tolerance \(10^{-10}\);
5. prediction proceeds only if equivalence is preserved.

Embedded and Disjoint two-stage HOCs are explicitly rejected for PLSpredict in the current release.

13.1 General principle

For the same held-out case \(i\), define loss under PLS and a benchmark model:

\[ L_i^{PLS},\qquad L_i^{B}. \]

CVPAT is fundamentally a paired comparison because both losses refer to the same prediction case.

With squared-error loss:

\[ L_i=e_i^2. \]

Metis displays average-loss difference as:

\[ Diff=\overline{L}^{PLS}-\overline{L}^{B}. \]

Therefore:

• Diff < 0 means PLS has lower average loss and is better;
• Diff > 0 means the benchmark has lower average loss.

13.2 LV CVPAT — seminrExtras-native

Construct-level CVPAT is obtained from:

seminrExtras::assess_cvpat(
  seminr_model = model,
  testtype = "two.sided",
  nboot = ...,
  seed = prediction_seed,
  technique = predict_DA_or_EA,
  noFolds = ...,
  reps = ...,
  cores = 1
)

Metis reads the package’s:

• CVPAT_compare_IA
• CVPAT_compare_LM

and normalises them into two result sections. The Boot T value and Boot P Value are taken from seminrExtras. Metis does not replace the production LV CVPAT test with its MV extension.

13.3 MV CVPAT — Metis extension

SEMinR supplies case-wise item prediction errors. Metis squares those residuals:

\[ L_{ij}^{PLS}=(e_{ij}^{PLS})^2, \]

\[ L_{ij}^{IA}=(e_{ij}^{IA})^2, \]

\[ L_{ij}^{LM}=(e_{ij}^{LM})^2. \]

For a complete finite sample, the average squared loss identity is:

\[ \overline L^{PLS}_j=(RMSE^{PLS}_j)^2, \]

and similarly for IA and LM.

13.4 Paired-valid observation masks

For PLS versus IA:

\[ V_{IA,j}=\{i:L_{ij}^{PLS},L_{ij}^{IA}\text{ both finite}\}. \]

Metis reports:

\[ \overline L^{PLS}_{IA,j} =\frac{1}{|V_{IA,j}|}\sum_{i\in V_{IA,j}}L_{ij}^{PLS}, \]

\[ \overline L^{IA}_{j} =\frac{1}{|V_{IA,j}|}\sum_{i\in V_{IA,j}}L_{ij}^{IA}. \]

For PLS versus LM, an independent paired mask is used:

\[ V_{LM,j}=\{i:L_{ij}^{PLS},L_{ij}^{LM}\text{ both finite}\}. \]

This is deliberate. If IA and LM are missing for different cases, the PLS mean displayed in the two comparison sections can legitimately differ because each comparison refers to a different valid paired sample.

If fewer than two finite pairs are available, Metis returns NA for the descriptive and inferential comparison.

13.5 seminrExtras bootstrap authority

When the internal seminrExtras::bootstrap_cvpat() function is available, Metis calls it for MV inferential statistics. The wrapper first applies the paired finite mask and then passes the aligned vectors to seminrExtras.

This is a Metis robustness step: seminrExtras assumes that its two loss vectors are already aligned and usable.

13.6 Fallback CVPAT bootstrap

If the seminrExtras internal bootstrap helper is unavailable/fails, Metis uses a fallback reproducing its centered-difference logic.

Define:

\[ D_i=L_i^B-L_i^{PLS}, \qquad \bar D=\frac1N\sum_iD_i. \]

Center the differences under the null:

\[ D_{0i}=D_i-\bar D. \]

For each bootstrap replication \(b\), resample \(D_0\) with replacement and compute bootstrap mean \(\bar D_b^*\). Then:

\[ SE_{boot}=SD(\bar D_1^*,\ldots,\bar D_B^*), \]

\[ t=\frac{\bar D}{SE_{boot}}. \]

The current fallback uses the two-sided t-distribution p-value:

\[ p=2F_t(-|t|;df=N-1). \]

If the bootstrap standard deviation is zero or non-finite, Metis returns NA for both t and p rather than manufacturing a zero test statistic.

14.1 Current execution — seminrExtras-native

The current backend calls:

seminrExtras::assess_ipma(
  seminr_model = model,
  target = target_construct,
  scale_min = 1,
  scale_max = 7,
  seed = 123
)

The IPMA inferential/score calculations are therefore attributed to seminrExtras.

14.2 Importance

In IPMA, importance is based on the total effect of an antecedent on the selected target, allowing direct and mediated influence to contribute.

For antecedent \(X\) and target \(Y\):

\[ Importance_{X\to Y}=TotalEffect_{X\to Y}. \]

seminrExtras performs the rescaling/standardisation details used by its implementation.

14.3 Performance

Performance is transformed to a 0–100 scale according to the assumed raw indicator scale limits. In broad form:

\[ Performance=100\times\frac{Score-Min}{Max-Min}. \]

The package constructs performance from the measurement information and selected scale range.

14.4 Current scale-setting boundary

Although the Preferences interface displays an IPMA scale-range control, the current backend call is hard-coded to 1–7. Therefore a current Metis IPMA result should be documented as using scale minimum 1 and maximum 7 unless the backend is changed in a later release.

15.1 Current execution — seminrExtras-native

Metis calls:

seminrExtras::assess_nca(
  seminr_model = model,
  target = target_construct,
  predictors = selected_predecessors,
  test.rep = run_depth,
  steps = bottleneck_step,
  seed = 123
)

The NCA effect-size, significance and bottleneck data supplied by the package remain the statistical authority.

15.2 Predecessor scope

Metis chooses predictors from the structural graph.

15.3 Effect size \(d\)

NCA’s effect size quantifies the size of the empty ceiling zone relative to the empirical scope. Conceptually:

\[ d=\frac{Ceiling\ Zone}{Scope}. \]

Metis does not recalculate the package’s inferential \(d\) table. For display classification, it applies:

15.4 Necessity status in Metis

Metis marks a condition as necessary if the package identifies it as necessary or when the normalised result has \(p<.05\) and \(d>0\). It labels a result borderline when \(p<.10\) or \(d\ge.10\), otherwise not_supported.

These are Metis display classifications layered on the underlying seminrExtras values.

15.5 Bottleneck table

The bottleneck table is normalised from seminrExtras output. It indicates the minimum predictor level required to make a selected target-outcome level possible under the fitted ceiling relation.

15.6 Ceiling-line chart

The inferential NCA table and the Metis ceiling chart should not be confused.

For the chart only, Metis builds display series from construct scores:

• CE-FDH display frontier: at each unique \(X\), take the maximum observed \(Y\), order by \(X\), then apply cumulative maximum;
• CR-FDH display line: identify frontier peers, fit a straight regression through those peer points and bound the displayed line to the observed \(Y\) range.

The chart is a Metis visualisation aid. The statistical NCA effect sizes and p-values come from seminrExtras.

15.7 Current NCA-settings boundary

The Preferences interface contains controls for ceiling methods and a random seed. The current backend advanced-analysis route uses seed 123 and cIPMA uses CE-FDH + CR-FDH. Researchers should report the actual backend settings recorded in the result rather than assuming every Preferences label changes execution.

16.1 Current execution — seminrExtras-native

Metis calls:

seminrExtras::assess_cipma(
  seminr_model = model,
  target = target_construct,
  scale_min = 1,
  scale_max = 7,
  nca = run_nca,
  nca_ceilings = c("ce_fdh", "cr_fdh"),
  nca_test.rep = run_depth,
  nca_steps = bottleneck_step,
  seed = 123
)

If cIPMA has already run its integrated NCA component, Metis reuses that NCA output instead of launching a second NCA run.

16.2 Interpretation

cIPMA combines three questions:

1. Importance: If this antecedent changes, how strongly can the target change?
2. Performance: How well is the antecedent currently performing on the rescaled score?
3. Necessity: Is a minimum level of the antecedent required for high target performance to be possible?

The combination can change management/research priorities compared with classic IPMA alone because a condition can be necessary even when its sufficiency effect is not the largest.

17.1 Current HOC restriction

MICOM is currently not available for models containing higher-order constructs.

17.2 Step 1: configural invariance

Metis checks that the two selected groups can be compared under the same modelling setup. The current checks include:

• same fitted SEMinR model object used as the rerun template;
• both selected groups contain at least two observations;
• required indicators/score inputs are available;
• construct specification is retained;
• SEMinR model settings are reused;
• the same supplied data-treatment context is applied.

If Step 1 fails, MICOM stops before the permutation test.

17.3 Step 2: compositional invariance

17.4 Step 3: equality of composite means and variances

Metis uses the pooled fitted model’s construct scores. Unlike Step 2, Step 3 permutes group allocation of these fixed scores rather than re-estimating the model in every permutation.

17.5 Relationship to cSEM validation

The current MICOM comments record that sign alignment, inadmissible-permutation dropping and strict Step-3 p-values were hardened against cSEM’s MICOM behaviour. This should be described as an implementation-validation choice, not as a claim that every internal cSEM computation has been copied.

18.1 Group-specific estimation

The selected data are split into Group A and Group B. Each group receives its own PLS estimation under the selected model/HOC method. This avoids reusing pooled HOC Stage-1 scores for the two groups.

For Embedded HOCs, Stage 1 and Stage 2 are rebuilt independently within each group and within each group bootstrap resample.

18.2 Parameters compared

Metis can construct comparisons for:

• structural path coefficients;
• outer loadings;
• outer weights;
• total effects;
• total indirect effects;
• specific indirect effects.

The interface focuses most visibly on path, loading and weight comparison panels while group-specific result trees expose the broader model outputs.

18.3 Difference orientation

For an estimate \(\hat\theta\):

\[ \Delta\theta=\hat\theta_A-\hat\theta_B. \]

A positive difference means Group A’s estimate is larger; a negative difference means Group B’s estimate is larger.

18.4 Bias-corrected confidence-interval comparison

Metis calculates a BC interval separately from each group’s bootstrap distribution using the same Metis BC function described in the Bootstrap section.

If the two intervals do not overlap, the comparison is labelled significant in this result family.

This is a confidence-interval heuristic and should not be conflated with the probability calculation used by Henseler PLS-MGA.

18.5 Henseler PLS-MGA probability

Metis recentres the two group bootstrap distributions around their original estimates and computes the probability that one group distribution exceeds the other, including half-weight for exact ties.

If the resulting probability \(p_{MGA}\) satisfies:

\[ p_{MGA}<\alpha \quad\text{or}\quad p_{MGA}>1-\alpha, \]

Metis labels the difference significant.

This reproduces the two-tail decision logic of the non-parametric PLS-MGA family.

18.6 Parametric comparison — current Metis implementation

Metis also reports a two-sided result labelled Parametric Test. Let \(s_A\) and \(s_B\) be the standard deviations of the two group-specific bootstrap parameter distributions. The current source code uses:

\[ df=n_A+n_B-2, \]

\[ V_p= \frac{(n_A-1)^2}{df}s_A^2+ \frac{(n_B-1)^2}{df}s_B^2, \]

\[ SE_{Metis,p}=\sqrt{V_p}\sqrt{\frac1{n_A}+\frac1{n_B}}, \]

and

\[ t=\frac{\hat\theta_A-\hat\theta_B}{SE_{Metis,p}}, \qquad p=2F_t(-|t|;df). \]

This section deliberately calls the formula the current Metis parametric implementation rather than presenting it as the generic textbook pooled-variance independent-samples t test. In particular, the code contains squared \((n_g-1)^2\) factors around the bootstrap-distribution variances. That detail should remain visible in open-source documentation and should be independently methodology-validated before Metis claims exact identity with a specific published parametric MGA formula.

18.7 Welch-labelled comparison — current Metis implementation

For the result labelled Welch Test, Metis defines:

\[ A=\frac{n_A-1}{n_A}s_A^2, \qquad B=\frac{n_B-1}{n_B}s_B^2, \]

\[ SE_{Metis,W}=\sqrt{A+B}, \]

and the current source degrees of freedom are:

\[ df= \frac{(A+B)^2} {A^2/(n_A-1)+B^2/(n_B-1)}-2. \]

It then reports:

\[ t=\frac{\hat\theta_A-\hat\theta_B}{SE_{Metis,W}}, \qquad p=2F_t(-|t|;df). \]

As with the parametric route, the documentation reports the implementation exactly as coded. The -2 degrees-of-freedom adjustment and the use of bootstrap-distribution SDs mean that the current result should be described as Metis’s Welch-labelled MGA comparison, not assumed to be numerically identical to every textbook Welch–Satterthwaite test or another software package’s implementation without separate validation.

18.8 MICOM before MGA

Metis does not automatically force a MICOM run before MGA. For ordinary composite models, researchers should assess measurement invariance when substantive group comparisons require it. For HOC models, the current Metis backend explicitly states that MICOM is unavailable, so MGA results are estimated without a Metis MICOM invariance assessment and should be interpreted with that limitation visible.

20.1 PLS-SEM panels

Current categories include:

• path coefficients;
• total indirect effects;
• specific indirect effects;
• total effects;
• outer loadings;
• outer weights;
• reliability/validity;
• discriminant validity;
• cross-loadings;
• R²/adjusted R²;
• f²;
• VIF;
• model fit;
• model-selection criteria;
• latent/construct scores;
• indicator correlations and data diagnostics;
• algorithm settings and execution log.

20.2 Bootstrap panels

Bootstrap separates resampled structural and measurement effects from base-model quality criteria. The base reliability, discriminant-validity, R², f² and VIF panels are reference values from the fitted base model, while bootstrap path/loading/weight/effect tables contain resampling inference.

20.3 PLSpredict panels

The redundant standalone Q²predict and PLS-vs-LM panels were removed from the current panel catalogue. Q²predict and benchmark errors are consolidated into the MV/LV summaries, while CVPAT has dedicated MV/LV summaries.

20.4 Advanced-analysis panels

IPMA/NCA/cIPMA panels include priority map, construct table, necessity check, ceiling lines, bottleneck table and cIPMA priorities.

20.5 MICOM panels

Current MICOM panels expose overview/configural checks, compositional invariance, equality of means, equality of variances, invariance classification, settings and execution log.

20.6 MGA panels

MGA contains an overview, group-comparison panels and full group-specific measurement/structural/model-quality result trees.

20.7 Execution logs

Metis records algorithm settings and execution notes alongside results. These logs are part of the reproducibility contract: they should be used to verify what was actually applied when the visible preference and the current backend capability differ.

21.1 Q² terminology in Tark

The current Tark family description uses the generic label “Q²”. In the supplied backend, the implemented predictive Q² calculation is Q²predict from PLSpredict. No separate Stone–Geisser blindfolding Q² computation route was found in the current backend source used for this documentation. Website/report wording should therefore avoid implying that a blindfolding Q² statistic was computed when the available value is Q²predict.

22.1 Seeds are procedure-specific

A numeric seed controls a particular random process only if that seed is actually passed/set in that procedure. Researchers should not assume there is one universal Metis seed controlling every analysis.

22.2 Multi-core execution

Metis uses a stepped desktop-safe core policy to preserve interface responsiveness. Machines with 13 or more detected logical cores use 12 analysis cores; 11–12 use 10; 9–10 use 8; and 7–8 use 6. On smaller machines, Metis reserves one logical core where possible and uses at least one analysis core.

Large bootstrap, MICOM and MGA operations can therefore use multiple logical cores. Parallel execution should change runtime, not the definition of the requested statistic, although random-stream implementation can affect exact resampling sequences.

22.3 Calculation timeouts

Local analysis HTTP requests and bootstrap execution allow up to 30 minutes by default. This ceiling is a failure boundary, not a runtime estimate: duration depends on model size, observations, resamples, follow-up analyses and available hardware.

22.4 PLS core cache

Metis caches a small number of fitted PLS cores to avoid unnecessary re-estimation when the model, dataset signature and algorithm settings are unchanged. The cache key includes dataset identity/signature, constructs, paths, interactions, algorithm and algorithm settings. Caching does not intentionally alter estimates; it reuses an already fitted equivalent base model.

24.1 What should be matched exactly?

Where the same case-level predictions are available, identities should hold to numerical precision. Examples include:

\[ \overline{L}^{PLS}=RMSE_{PLS}^2 \]

for complete finite squared-error loss samples, and:

\[ Diff=PLS\ Loss-Benchmark\ Loss. \]

Likewise, Metis Q²predict must satisfy its stated SSE identity on the paired PLS/IA sample.

24.2 What may differ slightly?

Small differences can arise when Metis/SEMinR and another application use different:

• random fold assignments;
• repetition semantics;
• random-number generators;
• bootstrap resamples;
• benchmark estimation details;
• missing-value treatments;
• internal standardisation or score orientation.

A difference of a few thousandths is therefore not, by itself, evidence that one implementation is wrong. Validation should examine formula identities, direction, ranking and substantive conclusions as well as absolute numerical distance.

24.3 Recommended validation design

For external validation:

1. use the exact same cleaned dataset and row order;
2. use the exact same model and measurement types;
3. align standard PLS versus PLSc;
4. align HOC method;
5. align prediction technique (DA versus EA);
6. align folds/repetitions as far as the software permits;
7. use fixed seeds where both programs expose them;
8. compare base estimates before bootstrap statistics;
9. compare deterministic identities before stochastic p-values;
10. document any procedure whose random partitions cannot be made identical.

This is a stronger validation strategy than expecting every digit to match without checking whether the two programs actually used the same resamples.

27.1 Standard PLS-SEM

The PLS-SEM model was estimated in Metis, which uses the SEMinR R package as its core estimation engine. Reflective constructs were represented through SEMinR’s Mode A composite specification for standard PLS, while formative constructs used Mode B. The model was estimated using the path weighting scheme and the reported convergence settings.

27.2 PLSc

Reflective common-factor constructs were estimated using Metis’s Consistent PLS option, which translates the reflective specification to SEMinR’s PLSc-capable reflective() model representation (Dijkstra & Henseler, 2015).

27.3 Bootstrap

Statistical inference was assessed by non-parametric bootstrapping through SEMinR’s bootstrap_model() as invoked by Metis. The number of bootstrap subsamples and confidence level are reported with the analysis. Metis additionally reports the selected supported Percentile, BC or BCa interval for ordinary bootstrap tables; the interval type saved with the analysis should be named in the report.

If Embedded HOC was used, replace this with:

For the Embedded two-stage HOC model, Metis resampled the original observations and re-estimated both Stage 1 and Stage 2 in each bootstrap sample so that Stage-1 score estimation was not held fixed across resamples.

27.4 PLSpredict

Out-of-sample predictive assessment was performed using SEMinR’s predict_pls() through Metis, with the reported fold count, repetitions, prediction technique and seed. Metis constructed the Indicator Average benchmark from each held-out case’s training fold and calculated Q²predict, RMSE and MAE from aligned out-of-sample residuals (Shmueli et al., 2019).

27.5 CVPAT

Construct-level CVPAT results were obtained from seminrExtras::assess_cvpat(). Metis additionally reports an indicator-level CVPAT extension based on paired case-wise squared prediction losses and the seminrExtras bootstrap CVPAT procedure (Liengaard et al., 2021; Sharma et al., 2023).

27.6 MICOM

Measurement invariance was assessed using Metis’s MICOM implementation following the three-step procedure of Henseler, Ringle and Sarstedt (2016). The implementation uses SEMinR group re-estimation, permutation-based compositional invariance, deterministic composite-sign alignment and explicit filtering/reporting of inadmissible permutation re-estimations.

27.7 MGA

Group differences were examined using Metis MGA, which estimates the model independently within each group, bootstraps group-specific parameters and reports non-parametric PLS-MGA, confidence-interval, parametric and Welch comparisons. Measurement invariance should be reported separately where applicable (Sarstedt et al., 2011).

Software documentation

• SEMinR CRAN package and reference manual: current package source should be consulted because package-level formulas and prediction behaviour can change between releases.
• seminrExtras CRAN package and reference manual: consult the installed-version documentation for assess_cvpat(), assess_ipma(), assess_nca() and assess_cipma().
• Metis source code: the source repository is the final authority for Metis-specific orchestration and UI/backend integration in a given release.