# The IRT Procedure

### FACTOR Statement

Subsections:
• FACTOR factor-variables-relation <, factor-variables-relation …>;

where each factor-variables-relation is defined as factor right-arrow var-list < = parameter-spec> where factor is a name that represents an intended factor; right-arrow is `===>`, `--->`, `==>`, `-->`, `=>`, `->`, or `>`; var-list is a list of variables that have nonzero slopes associated with the factor; and parameter-spec represents the specifications of parameter name and values (fixed or initial).

You use the FACTOR statement to specify the pattern of relationships between variables and factors in confirmatory models. You do not need to use the FACTOR statement if you are fitting an exploratory model. To complete the specification of a confirmatory model, you might need to use the VARIANCE and COV statements to specify the variance and covariance parameters in the model, as shown in the following syntax:

• FACTOR factor-variable-relation <, factor-variables-relation …>;

• VARIANCE variance-parameters;

• COV covariance-parameters;

The specifications in the FACTOR statement concern the pattern in the slope matrix. More details follow after a brief description of the VARIANCE and COV statements.

By default, the factor variances are fix parameters with a value of 1 in the confirmatory factor model. However, you can override these default parameters by specifying them explicitly in the VARIANCE statement. For example, in some confirmatory factor models, you might want to free some of these factor variances, or you might want to set equality constraints by using the same parameter name at different parameter locations in your model. Note that if you free some of the factor variances, you need to fix some slope parameters to identify the model.

By default, factor covariances are free parameters in the confirmatory model. However, you can override these default covariance parameters by specifying them explicitly in the COV statement.

Because the default parameterization of the confirmatory model already covers most commonly used parameters, the specifications in the VARIANCE and COV statements are secondary to the specifications in the FACTOR statement, which specifies the pattern of the slope matrix. The following example statement illustrate the syntax of the confirmatory FACTOR statement. Suppose there are nine variables, `V1``V9`, in your sample and you want to fit a confirmatory IRT model with four factors, as follows:

```factor
g_factor   ===>   V1-V9 ,
factor_a   ===>   V1-V3 ,
factor_b   ===>   V4-V6 ,
factor_c   ===>   V7-V9 ;
```

In this factor model, you assume a general factor, `g_factor`, and three group factors, `factor_a`, `factor_b`, and `factor_c`. The general factor, `g_factor`, is related to all variables in the sample, whereas each group factor is related to only three variables. This example fits the following pattern of the slope matrix:

```            g_factor   factor_a   factor_b   factor_c

V1         x         x
V2         x         x
V3         x         x
V4         x                    x
V5         x                    x
V6         x                    x
V7         x                               x
V8         x                               x
V9         x                               x
```

Here an `x` represents an unnamed free parameter, and all other cells that are blank are fixed zeros.

You can specify the following five types of parameters (parameter-spec) at the end of each factor-variables-relation:

• an unnamed free parameter

• an initial value

• a fixed value

• a free parameter with a name provided

• a free parameter with a name and initial value provided

To illustrate these different types of parameter specifications, consider the following pattern of slopes:

```            g_factor   factor_a   factor_b   factor_c

```

Here an `x` represents an unnamed free parameter, a constant 1 represents a fixed value, and each name in a cell represents a name for a free parameter. You can specify this pattern by using the following FACTOR statement:

```factor
factor_a   ===>   V1-V3    = 1. (.7  .8),
factor_c   ===>   V7-V9    = 1. 2*load_c ;
```

In the first entry of the FACTOR statement, you specify that the slopes of `V1``V9` on `g_factor` are the free parameters `g_load1``g_load9`, all of which are given an initial estimate of 0.6. The syntax `9*0.6` means that `0.6` is repeated nine times. Because they are enclosed in parentheses, all these values are treated as initial estimates but not as fixed values.

You can split the second entry of the FACTOR statement into the following specification:

```   factor_a   ===>   V1    = 1.  ,
factor_a   ===>   V2    = (.7),
factor_a   ===>   V3    = (.8),
```

This means that the first slope is a fixed value of 1 and that the other slopes are unnamed free parameters that have initial estimates of 0.7 and 0.8, respectively.

You can split the third entry of the FACTOR statement into the following specification:

```   factor_b   ===>   V4    = 1.  ,
factor_b   ===>   V5    = load_a (.9),
```

This means that the first slope is a fixed value of 1, the second slope is a free parameter named `load_a` with an initial estimate of 0.9, and the third slope is a free parameter named `load_b` without an initial estimate. PROC IRT generates the initial value of this free parameter.

The fourth entry of the FACTOR statement states that the first slope is a fixed 1 and the remaining two slopes are free parameters named `load_c`. No initial estimate is given. But because the two slopes have the same parameter name, they are constrained to be equal in the estimation.

Notice that an initial value that follows a parameter name is associated with the free parameter. For example, in the third entry of the FACTOR statement, the specification `(.9)` after `load_a` is interpreted as the initial value of the parameter `load_a`, but not as the initial estimate of the next slope of `V6`.

However, if you indeed want to specify that `load_a` is a free parameter without an initial value and `(0.9)` is an initial estimate for the slope of `V6`, you can use a null initial value specification for the parameter `load_a`, as shown in the following specification:

```   factor_b   ===>   V4-V6    = 1. load_a() (.9),
```

This way, 0.9 becomes the initial estimate of the slope of `V6`. Because a parameter list that contains mixed parameter types might be confusing, you can split the specification into separate entries to remove ambiguities. For example, you can use the following equivalent specification:

```   factor_b   ===>   V4    = 1.,
factor_b   ===>   V6    = (.9),
```

#### Shorter and Longer Parameter Lists

If you provide fewer parameters than the number of slopes that are specified in the corresponding factor-variable-relation, all the remaining parameters are treated as unnamed free parameters. For example, the following statement assigns a fixed value of 1.0 to the first slope, while treating the remaining two slopes as unnamed free parameters:

```factor
factor_a   ===>   V1-V3    = 1.;
```

This statement is equivalent to the following statement:

```factor
factor_a   ===>   V1     = 1.,
factor_a   ===>   V2 V3      ;
```

If you intend to fill up all values with the last parameter specification in the list, you can use the continuation syntax `[...]`, `[..]`, or `[.]`, as shown in the following example:

```factor
g_factor   ===>   V1-V30    = 1.  (.5) [...];
```

This means that the slope of `V1` on `g_factor` is a fixed value of 1.0 and that the remaining 29 slopes are unnamed free parameters, all of which are given an initial estimate of 0.5.

However, you must be careful not to provide too many parameters. For example, the following statement results in an error:

```factor
The parameter list has six parameters for three slopes. Parameters after `load3` are excessive.