---
title: "Descriptions of the EFA and BIFACTOR methods"
author: "Brian O'Connor"
date: "`r Sys.Date()`"
output:
  rmarkdown::html_vignette:
    toc: true
    toc_depth: 3
    number_sections: false
vignette: >
  %\VignetteIndexEntry{Descriptions of the EFA and BIFACTOR methods}
  %\VignetteEngine{knitr::rmarkdown}
  \usepackage[utf8]{inputenc}
---


```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

```{r, include = FALSE}
knitr::opts_chunk$set(
  collapse = FALSE,
  comment = "",
  fig.width = 7,
  fig.align = "center",
  background='#FFFFFF'
)
```

<!-- ```{css echo=FALSE} -->

<!-- .custom-inline { -->

<!--   color: red; -->

<!--   font-weight: 700 -->

<!-- } -->

<!-- ``` -->

```{css, echo=FALSE}
h1 {
  font-size: 30px;
  color: black !important;
}
h2 {
  font-size: 20px;
  color: blue !important;
}

#TOC {
  position: fixed;
  left: 10px;
  top: 10px;
  width: 200px;
  height: 100%;
  overflow:auto;
}

#TOC::before {
  content: "";
}

#TOC li {
  list-style-type: none;
}

body {
  max-width: 800px;
  margin: auto;
  margin-left:230px;
  line-height: 20px;
}
```

# EFA extraction methods:

## alpha

alpha factor analysis (afa) is a specialized common factor extraction method that focuses on psychometric inference rather than statistical inference. Instead of generalizing from a sample of people to a population of people, alpha factor analysis treats the human participants as fixed and assumes that the variables (items) are a random sample drawn from a massive universe of potential items. Its goal is to extract factors that have the maximum possible internal consistency reliability (specifically cronbach’s alpha) in that universe of content. In standard factor extraction (like maximum likelihood), the objective is to model population parameters from a person-sample. Alpha factor analysis flips this psychometrically: It seeks to discover latent dimensions that would stay completely stable even if the entire questionnaire was replaced with a brand-new set of random items measuring the same domains. Alpha factor analysis operates strictly within the metric of the common (communality) parts of the variables. Alpha factor analysis is unaffected by the scaling of the data. If a variable's score was multiplied by a constant, the final factor solution remains structurally unchanged. alpha features a mathematically hardcoded boundary for deciding how many factors to keep. It only extracts factors that possess a positive cronbach's alpha reliability. Kaiser's famous "eigenvalues greater than one" rule was derived from this math. For a factor to achieve a positive cronbach's alpha, it is a mathematical requirement that its eigenvalue extracted from the correlation matrix must be greater than 1.

## gls

gls (for generalized weighted least squares) factor analysis operates under the common factor model and aims to minimize the discrepancy between the data's actual correlation matrix and the correlation matrix reproduced by the extracted factors. It achieves this by applying a specific weighting strategy that prioritizes the most reliable variables. In simpler least squares approaches (like unweighted least squares or minres), the algorithm treats all variables equally when trying to fit the model. If the model miscalculates a relationship by 0.10, that penalty is identical across all variables. In contrast, gls introduces an intelligent weighting matrix: It weights the discrepancy function by the inverse of the observed variance-covariance (or correlation) matrix. Variables with high unique variance or massive error/noise are heavily "de-weighted" or penalized. Variables that share a clean, high amount of common variance are given much heavier leverage. This ensures that the algorithm prioritizes perfectly fitting the cleanest, most reliable data points, rather than letting noisy variables distort the overall factor structure. In large samples, gls parameter estimates are highly efficient and produce accurate standard errors. Like maximum likelihood (ml) and alpha factoring, gls is scale-free.  Mathematically, gls behaves almost identically to maximum likelihood (ml) extraction. The primary distinction is that while ml requires a strict assumption of multivariate normality to calculate its fit function, gls achieves a nearly identical fit using matrix algebra that is slightly more forgiving of minor distributional deviations.


## image

image (for image factor analysis) is a specialized common factor extraction method. "image" in this context is a psychometric term. It defines the "image" of a variable as the portion of its variance that can be perfectly predicted by all the other variables in the dataset using multiple regression. In the standard common factor model, a variable's total variance is split into two hypothetical, unobservable parts: Common variance (driven by latent traits) and unique variance (reliable but unshared variance and error variance). Guttman argued that instead of relying on purely hypothetical latent variables, the common variance should be defined using actual data. Image factor analysis splits each observed variable into two concrete parts: The image (the common part), calculated by running a multiple linear regression where the current variable is predicted by all other variables in the matrix. And the anti-image (unique part), which is the residual error left over from that regression equation, representing the variance unique to that variable that cannot be explained by the rest of the testing variables. Instead of factoring the raw correlation matrix, image factor analysis performs an eigenvalue decomposition strictly on the "image covariance matrix". A notorious issue in maximum likelihood or principal axis factoring is the "Heywood case," where the computer calculates an impossible, nonsensical "negative unique variance" (a communality greater than 1.0). Heywood cases are mathematically impossible in image factor analysis because the variance bounds are locked deterministically by the regression equations. Methods like paf must run an iterative, repeating loop to guess and recalculate communalities until they converge. image requires no guessing: the initial communalities are fixed directly from the data's squared multiple correlations.

## minres

minres (for minimum residual) factor analysis is an ordinary least squares common factor extraction method designed to fit the common factor model by minimizing the squared differences between the observed and reproduced correlations. In modern psychometrics, minres is widely considered one of the best default extraction methods. When factors are extracted from a dataset, the model creates a "reproduced correlation matrix" based on the factor loadings. Subtracting this reproduced matrix from the real, observed correlation matrix leaves a residual correlation matrix. minres targets this residual matrix with a specific strategic constraint: It ignores the main diagonal (the variances) of the matrix and minimizes the off-diagonals. It searches for a solution that drives the sum of the squared values in the off-diagonal cells (the covariances/correlations between different variables) as close to absolute zero as possible. By focusing strictly on cleaning up the correlations between variables, minres uncovers the underlying factor structure without needing to guess or iteratively adjust initial communality estimates like paf does. minres has achieved popularity because it bridges the gap between maximum likelihood (ml) and principal axis factoring (paf). On clean, well-behaved data, the factor loadings generated by a minres extraction are nearly identical to a maximum likelihood solution. Unlike maximum likelihood, which relies on a strict assumption of multivariate normality, minres is an ols method. It does not require normal distributions to operate cleanly. If the data features highly skewed items, zero-variance cells, or minor statistical anomalies, maximum likelihood will often fail to converge or crash. Minres is stable and will find a mathematically sound solution even on problematic matrices. Minres is also significantly less prone to calculating impossible "negative unique variances" (communalities exceeding 1.0) than standard ml extraction routines.

## ml

ml (for maximum likelihood) factor analysis is a statistical factor extraction method operating under the common factor model. It estimates factor loadings by finding the parameter values that maximize the probability (the likelihood) of observing the specific sample correlation matrix, assuming the data come from a multivariate normal population. Unlike ordinary least squares methods (like minres) which minimize mathematical geometric distance, ml treats the data as a random sample from a broader population and uses probability theory to infer the underlying structure. The goal of maximum likelihood estimation is to find a factor loading matrix and a unique variance matrix that make the reproduced population covariance matrix as similar to the sample covariance matrix as possible. The algorithm runs through iterative optimization loops until it finds the exact factor structure most likely to have generated the real-world data. ml factor extraction is scale-free. While highly powerful, maximum likelihood is strict compared to other common factor methods. It assumes that the observed variables follow a strict multivariate normal distribution. If the items are highly skewed, kurtotic, or categorical (like 3-point likert scales), ml will generate biased parameter estimates and artificially distort the fit indices. And if the sample size is too small or the data are noisy, the ml algorithm will frequently crash, fail to converge, or produce an impossible heywood case (calculating a negative unique variance, meaning an item's communality exceeds 1.0)

## ols

ols (for ordinary least squares) factor analysis is a broad category of common factor extraction methods that fit the common factor model by minimizing the squared differences (residuals) between the observed data and the model's predictions. Unlike parametric approaches like maximum likelihood, ols makes no assumptions about the probability distribution of the data. It is a purely geometric, mathematical optimization technique. The algorithm tries to find a factor loading matrix that can recreate the observed data matrix as closely as possible. It takes every single cell in the residual matrix, squares it (to eliminate negative signs), and sums them up. The algorithm iteratively rotates and tweaks the factor loadings until it finds the configuration that drives this sum of squared residuals to the absolute lowest possible value (minimum residual). ols does not care if the data are skewed, kurtotic, bimodal, or non-normal. Because it relies on simple geometric distance rather than probability density functions, it will not warp the structural findings if the data violate multivariate normality. ols algorithms are robust. While maximum likelihood models may crash or fail to converge on messy, real-world data, ols methods are resilient and almost always reach a stable mathematical solution. If the sample size is small or if there are highly redundant variables that create a singular data matrix, maximum likelihood cannot run because it cannot invert the matrix whereas ols can bypass this potential problem.

## paf

paf, for principal axis factoring, is an iterative, common factor extraction method that assumes that your observed variables are driven by unobservable, hidden variables (latent constructs) plus an element of unique error or noise. paf only analyzes shared (common) variance among variables, discarding unique variance and measurement error. Before running the factor extraction, the algorithm alters your data’s correlation matrix: Instead of keeping standard 1.0 values on the main diagonal (which would imply the data is 100% error-free), paf replaces the diagonal with initial estimates of "communalities". These initial estimates are calculated using the squared multiple correlation value of each variable when regressed on all other variables.
Because the initial communalities are just estimates, paf runs through a repeating optimization loop to find the true factor solution.

Some contrasts between paf and pca (principal component analysis):

The primary goal of paf is to identify latent constructs explaining the correlations, whereas the primary goal of pca is to compress data into fewer summary variables.

paf uses only the shared variance whereas pca uses all of the variance, including unique and error variances.

paf places squared multiple correlations (which are less than 1.0) on the main diagonal, whereas pca keeps the values on the main diagonal locked at 1.0.

In paf, it is assumed that latent factors drive/cause the observed scores whereas, in pca the observed scores are merely combined into components that maximize variance accounted for.

## uls

uls (for unweighted least squares) factor analysis is a classic ordinary least squares common factor extraction method that operates under the common factor model. It fits the structure by finding a factor solution that minimizes the sum of squared differences (residuals) across the entire correlation matrix simultaneously. uls squares every single number in the residual matrix (both the off-diagonal correlations and the main diagonal variances) and runs an optimization loop to drive that total sum as close to absolute zero as possible. The term "unweighted" means that every single cell in the matrix is treated with equal mathematical importance, regardless of how much error or variance that specific item contains. Because uls relies on basic geometric matrix algebra rather than probability density curves, there is no assumption of multivariate normality. It is unaffected by highly skewed or kurtotic data. uls is one of the most robust extraction algorithms. If the data matrix is "singular" or "ill-conditioned" (which happens when there is a small sample size or highly redundant variables), parametric methods like maximum likelihood will crash or fail to invert the matrix. uls can handle these problematic matrices smoothly. uls is highly stable and significantly less likely to produce impossible "heywood cases" (calculating a negative unique variance where an item's communality exceeds 1.0) compared to maximum likelihood.

## wls

wls (for weighted least squares) factor analysis is a non-parametric factor extraction method operating under the common factor model. It estimates factor loadings by minimizing a mathematically weighted discrepancy function between the observed correlation matrix and the matrix reproduced by the factors. Unlike unweighted least squares (uls), which treats every variable equally, wls applies custom weights to account for differences in variable variance and measurement error. wls fits the common factor model by minimizing a weighted discrepancy function. The algorithm squares the residuals and multiplies them by the inverse of the weight matrix. This optimization loop continues until the overall sum of these weighted squared residuals is driven to the absolute lowest possible value. The specific nature of the weight matrix determines whether a standard weighted least squares model is used or its close relative, generalized least squares (gls). In standard wls, the weight matrix is a diagonal matrix containing only the individual variances or initial communalities of the variables. It scales the optimization to accommodate unequal variances but assumes the measurement errors between different variables are uncorrelated. In generalized least squares, the weight matrix is the full, intact sample correlation matrix. This allows the algorithm to adjust for both unequal variances and the complex web of interconnected relationships among the variables simultaneously. Standard uls can easily be biased by variables that have massive variance scales. wls normalizes this by assigning heavier weight to variables with smaller, cleaner variance bounds. Like all least squares methods, wls does not require that the data follow a strict multivariate normal distribution, making it resilient compared to maximum likelihood. In modern psychometrics, a specialized variation called diagonally weighted least squares (dwls) or robust wls (wlsmv) is the gold standard for analyzing categorical, ordinal, or likert-scale data. it uses a weight matrix derived from asymptotic variances to properly estimate relationships without treating 5-point scales as continuous numbers.

<br>

### &nbsp; {-}

# EFA rotation methods:

## bentlerQ
is an oblique rotation based on Bentler's invariant 
pattern simplicity criterion. It is designed for 
standard, non-hierarchical exploratory factor analysis, rather than 
bifactor models. The simplicity criterion maximizes a distinct 
definition of "simple structure" based on the variance of squared loadings. 
It optimizes the matrix so that each variable has a high loading on one 
factor and near-zero loadings on the others. The defining 
benefit is that it is sample-size and scale invariant. 
If the variables are scaled differently (e.g., changing a variable from 
centimeters to inches), the final structural interpretation of the rotated 
factors will remain the same. 

## bentlerT
is an orthogonal rotation based on Bentler's 
invariant pattern simplicity criterion under the constraint that all 
factors remain uncorrelated. The algorithm maximizes the 
variance of the squared factor loadings, pushing the matrix toward 
"simple structure" by driving large loadings higher and small 
loadings down toward zero. bentlerT is scale-invariant. If the scale of the 
data is transformed (e.g., converting a 
measurement from days to hours), the relative geometric structure 
of the rotated factors will not warp or distort. While Varimax maximizes 
the variance of the squared loadings within each factor column individually, 
bentlerT maximizes the pattern simplicity across the entire matrix 
simultaneously. Because it evaluates the matrix globally rather than 
column-by-column, it can sometimes find cleaner, more stable orthogonal 
structures than varimax when dealing with complex, real-world data. 

## entropy
entropy is an orthogonal rotation developed 
by Jennrich (2004). It adopts the thermodynamic and informational 
concept of "entropy" to discover a simple structure in exploratory 
factor analysis. In statistics and information theory, entropy is a 
measure of randomness, uncertainty, or disorder. A matrix with high 
entropy has values spread out evenly and ambiguously (messy cross-loadings). 
A matrix with minimum entropy has maximum claritymeaning values are 
polarized into distinct extremes (either very large or near zero). The 
entropy rotation algorithm works by minimizing the Shannon entropy of the 
squared factor loadings across the matrix. It forces the rotation 
optimization loop to penalize "middle-of-the-road" factor loadings 
(like 0.30 or 0.40). It actively pushes factor loadings to be either 
strongly dominant (close to 1.0) or cleanly absent (close to 0.0), 
reducing the overall informational "noise" of the matrix. It shares 
a similar philosophical goal with quartimax and oblimax. It often 
creates a cleaner, more absolute boundary between factors than 
varimax by being more mathematically aggressive toward minimizing 
small loadings. Like quartimax, it primarily optimizes the simplicity 
of the rows (ensuring an item belongs cleanly to a single factor) 
rather than balancing the columns.
    
## equamax
is an orthogonal rotation from the Crawford-Ferguson 
family. It is designed to find a clean, independent factor structure by 
serving as a direct mathematical compromise between varimax and quartimax. 
varimax focuses entirely on simplifying the columns of the loading 
matrix. It tries to make sure each factor has a few high loadings and 
many zero loadings, spreading the explained variance evenly across 
the factors. quartimax focuses entirely on simplifying the rows of 
the loading matrix. It tries to make sure each variable loads strongly 
on only one factor. This often results in a single "general factor" 
where everything loads highly, leaving subsequent factors with very 
little variance. equamax applies a weighted optimization function that 
simplifies both the rows and the columns simultaneously. It attempts 
to provide the distinct, non-overlapping variables of quartimax while 
maintaining the well-distributed, balanced factors of Varimax. Unlike 
quartimax, equamax heavily penalizes the creation of a massive general 
factor. It forces the total explained variance to be shared more 
democratically among all the extracted factors. 
    
## geominQ
is an oblique rotation method that 
is highly regarded for its ability to find a clean "simple structure" 
even when the data contains highly complex variables (variables that 
naturally load on multiple factors). Most traditional rotation methods 
(like oblimin or quartimin) achieve simple structure by looking at the 
sum of squared loadings. geominQ takes a completely different 
mathematical approach by using the geometric mean (product) of the 
loadings across rows. For every item (row) in the matrix, the algorithm 
multiplies its factor loadings across all columns together. If an item 
loads cleanly onto Factor 1 but has a loading of exactly 0 on Factor 2 and 
Factor 3, the product of that row is 0 (X  0  0 = 0). The algorithm's 
goal is to minimize this total product sum across the whole matrix. 
Because a loading of exactly absolute zero creates a flat mathematical 
surface where computer algorithms can get stuck or fail to calculate 
derivatives, a tiny constant called delta (typically ranging from 0.01 to 0.5) 
is added to the calculation. This acts as a stabilizer to keep the 
optimization running smoothly. By focusing on making at least one 
loading per row near-zero, geominQ is  very flexible. It doesn't 
care if an item has moderate cross-loadings elsewhere, as long as it 
achieves a near-zero loading on at least one factor in the row. 
It is widely considered superior to oblimin when dealing with complex 
traits where items rarely load perfectly onto just one factor.

## geominT
is an orthogonal rotation that 
combines the strict geometric constraint of uncorrelated factors with 
Brownes flexible, product-based geomin complexity criterion. geominT 
simplifies the factor matrix by minimizing the geometric mean 
(the product) of the factor loadings across each row. For every item (row) 
in the dataset, the algorithm multiplies its factor loadings across all 
columns together. If an item loads cleanly on Factor 1 but has a loading 
of exactly 0 on Factor 2, the product for that row becomes zero (X  0 = 0). 
The algorithm actively tries to minimize the sum of these products 
across the entire matrix. Because hitting a loading of absolute zero 
creates a flat mathematical surface where computer optimization algorithms 
can get stuck, a tiny constant called delta (defaulting to 0.01) is added 
under the radical. This serves as a mathematical stabilizer to ensure smooth 
convergence. While varimax is the default orthogonal rotation in most 
software, geominT handles a specific type of data structure much more 
effectively. varimax simplifies columns and focuses on spreading variance 
evenly across the factors. It can struggle or distort the matrix if the 
data naturally contains a few "complex items" that genuinely belong to 
multiple factors. geominT simplifies rows, and because it uses 
multiplication rather than addition, it only cares that each item drops to 
near-zero on at least one factor. It is highly tolerant of complex 
cross-loadings on other factors, allowing it to find a cleaner, more 
realistic orthogonal structure when dealing with messy or cross-loading variables. 
    
## oblimax
is an oblique rotation method that maximizes 
the number of very high and very low (near-zero) factor loadings 
across the matrix. It is primarily categorized as an oblique rotation 
method, though it has an orthogonal counterpart. oblimax maximizes the 
kurtosis (the "peakedness" or extremity) of the squared factor loadings. 
Think of it as a statistical filter that actively hates 
"middle-of-the-road" cross-loadings. By maximizing the variance of the 
squared loadings globally, it pushes high loadings up 
toward 1.0 and coaxes weak loadings down toward 0. When restricted to 
be orthogonal, oblimax is mathematically identical to quartimax. 
It simplifies the rows of the matrix, often leading to one large general 
factor and several smaller, highly specific factors. When allowed to be 
oblique, it becomes true oblimax. It is effective with highly polarized 
data: structural theory dictates that items should either be extremely 
relevant to a factor or completely irrelevant, with almost no gray area 
in between. oblimax is helpful when oblimin results in too many ambiguous 
middle-tier loadings (e.g., loadings around 0.30 or 0.40) and a 
cleaner "all-or-nothing" look at the primary indicators is desired. 
    
## oblimin
(sometimes called direct oblimin) is a 
widely-used oblique rotation. It works by minimizing a mathematical 
function that measures the covariance between the squared factor loadings 
across columns. It allows the factors to correlate freely to achieve 
the simplest possible loading structure. 
    
## promax
is a two-stage oblique rotation method. 
Unlike "analytic" rotations (such as Oblimin or Geomin) which use complex 
gradient optimization loops to find simple structure, Promax uses a clever 
algebraic shortcut. Promax calculates its oblique structure sequentially 
using a Procrustes target matrix. The algorithm performs a standard, 
independent Varimax rotation. This yields uncorrelated factors with a 
relatively clean base structure. The algorithm then takes the factor loadings 
from the Varimax solution and raises them to a specific mathematical 
power (k), typically preserving the original positive or negative sign. 
This creates a "target matrix". The original factors are then rotated 
obliquely to fit this target as closely as possible. The tuning parameter k 
controls how oblique (correlated) the final factors can become. Higher 
values of k drive small loadings down toward zero much faster, simplifying 
the pattern matrix. However, this comes at the cost of significantly 
higher correlations between the factors. The default value is almost universally 
set to k = 4, though k = 3 or k = 2 are sometimes preferred for normalized data. 
Because it relies on simple matrix algebra rather than iterative optimization 
algorithms, it converges instantly. It never suffers from the "local minima" 
convergence traps common to geomin or oblimin.
    
## quartimax
is an orthogonal rotation 
designed to find an independent factor structure by simplifying the 
rows of the factor loading matrix. Its primary goal is to ensure that 
each individual variable loads strongly on only one factor and near-zero 
on all other factors. It achieves its simple structure by maximizing the 
sum of the fourth powers (hence "quartimax") of the factor loadings across 
the matrix. Raising loadings to the fourth power heavily weights large 
numbers and minimizes tiny numbers. This optimization forces a stark 
contrast within each row of the data, pushing a variable's primary factor 
loading higher while driving its remaining cross-loadings down toward 
absolute zero. Because quartimax evaluates row simplicity without putting 
any constraints on the columns, it tends to produce a single, massive general 
factor.  The remaining factors are left with very small amounts of variance, 
acting as highly specific, minor sub-facets. quartimax simplifies the 
rows, making sure items belong to a single dimension. varimax simplifies 
the columns, making sure factors are distinct and well-balanced. It 
deliberately spreads the explained variance evenly across the factors, 
actively preventing a single general factor from dominating. 
    
## quartimin
is an oblique rotation designed 
to simplify the structure of the matrix by minimizing the sum of the 
cross-products of squared factor loadings across columns. It is a specific 
case of the oblimin family. quartimin focuses on simplifying the rows of 
the loading matrix, attempting to ensure that each individual variable 
loads strongly on only one factor and has near-zero loadings on all 
other factors.
    
## simplimax
is an oblique rotation developed by
Henk Kiers (1994) to recover complex or messy "simple structures" 
where traditional continuous methods like oblimin or geomin fail. Unlike 
most rotation methods that apply a continuous mathematical formula across 
all factor loadings equally, simplimax uses a semi-confirmatory, 
target-based approach dynamically. A factor structure is considered 
"optimal" if a specific number of elements in the pattern matrix are 
exactly zero. By focusing strictly on making the "negligible" loadings 
small and completely ignoring how large the "major" loadings get, it 
can unearth clean structures in data with highly complex cross-loadings. 
However, because the target matrix shifts dynamically based on which 
elements happen to be smallest at any given moment, the optimization 
landscape for simplimax is notoriously jagged and complex. While 
oblimin might converge onto the exact same solution all of the time, 
simplimax is prone to getting trapped in "local minima". Running simplimax 
with a single default start is highly risky and often yields an unstable 
factor structure. 
    
## varimax
is the most widely used orthogonal 
rotation and it is the near-universal default choice in 
statistical software. The name varimax stands for variance maximization. 
It works by maximizing the variance of the squared factor loadings within 
each individual factor column. It drives large loadings up 
toward 1.0 (or -1.0) and coaxes small loadings down toward 0.0. Because 
it optimizes each column individually, it spreads the total explained 
variance as evenly as possible across the factors. This results in a 
clean, highly interpretable "simple structure" where each factor has a 
distinct group of items that load strongly on it, and almost no items 
loading ambiguously in the middle. Because varimax actively forces the 
explained variance to be shared democratically among the factors, it 
explicitly prevents the creation of a single, massive "general factor" 
that dominates the entire dataset.

### &nbsp; {-}

# Bifactor methods:

## SL
The SL option, conducted using the schmid function from the psych 
package, performs the Schmid-Leiman
(S-L) transformation. It transforms a hierarchical, oblique factor
solution into a bifactor structure, allowing researchers to evaluate
the influence of a general factor alongside independent, localized
group factors. There are three broad steps: 

(1) initial extraction: Factors are extracted from the original 
data and rotated to an oblique solution to determine the factor correlations.

(2) higher-order factor: The lower-level group factors are then 
factored again to extract a single, higher-order general factor.

(3) residualization: The algorithm partials out the variance of 
the general factor from the group factors, leaving orthogonalized group factors.

## SLiD
"The SLiD algorithm is based on the flexibility of the target rotation 
to approximate factor solutions with a pre-defined pattern model. 
Once a target matrix following a bi-factor pattern is found, a final 
solution is obtained by rotating a factor loading matrix (of the same 
dimensions as the bi-factor model) toward the bi-factor target matrix.

More specifically, the SLiD algorithm:

a) estimates a partially specified target matrix in which elements 
expected to be negligible in the final rotated solution are given 
a target value of zero, so the final value of the correspondent 
loading is minimized during the rotation step. The remaining elements 
are not constrained (i.e., not considered when performing the rotation); 

b) loadings to be minimized are identified by estimating an appropriate 
empirical cutoff point for each group factor separately. The cutoff 
aims to avoid wrongly setting to zero a target element when a relevant 
cross-loading is present; and

c) SLiD improves the obtained solution using an iterative refinement 
of the target matrix." (Garcia-Garzon et al., 2021)

## DSL
The DSl option, conducted using the directSL function from the psych 
package, provides a direct Schmid-Leiman transformation of an 
oblique factor solution, based on Waller (2018).
It produces general and group factor
loadings without executing a multi-step hierarchical factor
analysis. It takes an oblique
factor loading matrix and rotates it to a
Schmid-Leiman-like orthogonal solution.

## bifactorT
The bifactorT analyses are conducted using the bifactorT function from 
the GPArotation package.
It is an orthogonal bifactor rotation for
when a complete independent structural breakdown of the data is desired. 
It is designed for 
situations where a single, overarching global dimension is expected
alongside separate sub-domains, and when all factors should be 
uncorrelated. The algorithm splits the data structure into two distinct 
levels. It treats the first extracted column as a general factor (capturing 
global variance shared by all items) and all subsequent columns as group 
(specific) factors (capturing unique variance unique to specific clusters 
of items). The general factor is uncorrelated with the group factors, and 
the group factors are completely uncorrelated with each other. The algorithm 
applies a modified quartimin simplicity criterion. It alters the math to 
completely ignore column 1 (the general factor) so every item can load 
there as highly as it wants. It then minimizes the sum of squared 
cross-products strictly across columns 2 through M to force the remaining 
group factors to be as clean, distinct, and isolated as possible.

bifactorT and bigeominT are both orthogonal bifactor rotations and choosing 
between them depends on the data structure. bifactorT is excellent at cleaning 
up cross-loadings. However, it can be structurally rigid. If an item naturally 
measures two different specific sub-domains, bifactorT may struggle to find a 
stable solution or fail to converge. bigeominT uses a row-multiplying penalty 
and a tuning parameter (delta) and it is much more forgiving of complex items 
that cross-load on multiple group factors.
    
## bifactorQ
The bifactorQ analyses are conducted using the bifactorQ function from 
the GPArotation package.
This is an oblique bifactor rotation originally introduced by 
Jennrich and Bentler (2011) under the name biquartimin. 
It is designed for when a strong, overarching global dimension is expected
alongside separate 
sub-domains that are allowed to correlate with each other. The algorithm 
structures the loading matrix hierarchically. It isolates the first 
extracted column as a general factor and assigns all subsequent columns 
as group (specific) factors. The specific group factors are allowed to 
correlate with one another, whereas the general factor remains strictly 
uncorrelated (orthogonal) to the group factors. Unlike bigeominQ 
(which uses a product-based geomin penalty), bifactorQ applies a quartimin 
simplicity criterion. It ignores column 1 (the general factor) to let items 
load there freely. It then minimizes the sum of squared cross-products 
strictly across columns 2 through M to force the remaining group factors 
into a clean, simple structure. 

Although bifactorQ vs. bigeominQ are both 
oblique bifactor rotations, their mathematical approaches to finding 
"simple structure" among the group factors are distinct. bifactorQ evaluates 
complexity by summing the products of squared loadings between pairs of group 
factors. It is highly effective at minimizing cross-loadings, but it can 
struggle or fail to converge if the data features highly complex variables 
that naturally load onto multiple group factors. bigeominQ evaluates 
complexity by multiplying the loadings across all group factors. Because it 
relies on a tuning parameter (delta), it is much more tolerant of complex 
variables and often converges more easily on messy psychometric data. 

## bigeominT
The bigeominT analyses are conducted using the bigeominT function from 
the GPArotation package.
It is an orthogonal bifactor rotation method designed for 
exploratory bifactor analysis. Unlike standard 
geomin rotations, which look for simple structure across equal factors, 
bigeominT forces a hierarchical, structural split on the data. The first 
column of the factor loading matrix acts as a general factor and the 
remaining columns are evaluated as distinct group (specific) factors. 
The general factor and all group factors are constrained to be uncorrelated 
with each other (their correlations are fixed at 0). The geomin complexity 
minimization is applied to the specific factors. It tries to ensure that 
once the general factor's variance is pulled out, each item loads 
onto only one specific group factor. 
    
## bigeominQ
The bigeominQ analyses are conducted using the bigeominQ function from 
the GPArotation package.
It is an oblique bifactor rotation designed for 
exploratory bifactor analysis where there is a broad, overarching factor 
alongside sub-domains that are allowed to overlap. The algorithm structures 
the data into two tiers. It treats the first extracted column as a general 
factor (capturing shared global variance) and all subsequent columns as 
group (specific) factors (capturing specialized facet variance). The 
group factors are allowed to correlate with each other. However, the 
general factor is constrained to be uncorrelated with (orthogonal to) 
the group factors. The algorithm applies the geomin minimization penalty 
strictly to the group factors. This forces the group factors to maintain 
a clean "simple structure" (items load strongly on one group factor and 
near-zero on the others) while leaving the general factor free to absorb 
global variance. The result is a particular blend: A clean, independent 
global dimension, while realistically acknowledging that specific 
subscales (e.g., verbal ability and quantitative ability group factors) 
likely share some residual real-world overlap. 

### &nbsp; {-}

# References / Sources

Bernaards, C. A., & Jennrich, R. I. (2005). Gradient Projection Algorithms and Software for Arbitrary 
	  	Rotation Criteria in Factor Analysis. Educational and Psychological Measurement, 65(5), 676-696. 
	  	https://doi.org/10.1177/0013164404272507
	  	
Bernaards, C. A., & Jennrich, R. I. (2026). GPArotation: Gradient Projection Factor Rotation. 
	R package version 2026.4-1, https://CRAN.R-project.org/package=GPArotation

Jennrich, R. I. (2018). Rotation. In P. Irwing, T. Booth, & D. J. Hughes (Eds.), The Wiley handbook 
 	of psychometric testing: A multidisciplinary reference on survey, scale and test development (pp. 279304). 
 	Wiley Blackwell. https://doi.org/10.1002/9781118489772.ch10

Mulaik, S. A. (2010). Foundations of factor analysis (2nd ed.). Boca Raton, FL: Chapman 
	and Hall/CRC Press, Taylor & Francis Group.

Revelle, W. (2026). psych: Procedures for Psychological, Psychometric, and Personality Research. 
	R package version 2.6.5, https://CRAN.R-project.org/package=psych

Waller, N. G. (2018) Direct Schmid-Leiman Transformations and Rank-Deficient 
  Loadings Matrices. Psychometrika, 83(4), 858870.
  
  
