Home / Shared Math Details / DOE / Aliasing and Resolution
Aliasing and Resolution¶
A fractional two-level design runs fewer combinations than it has terms, so some of its terms share a column and cannot be told apart. This page defines the algebra that describes which terms those are: the generators that build the design, the defining relation they close into, the length of a word, the resolution taken from it, the alias table the design sheet prints, what blocking adds, and what a fold removes.
Where each quantity comes from. All of it is Quantum XL's own code. Two things about its origin matter before any of the arithmetic below, and both are easy to misread:
- The generators are a fixed table, not a calculation. There is no formula that produces the generator for a given number of factors and runs. The product carries one stored entry per combination and reads it out.
- Resolution reaches the reader from three unrelated places. The Roman numeral in the design selection grid is read from a table written into the dialog code, indexed by the grid's own row and column. The numeral in the design description at the top of the design sheet is the number stored beside the generators. The Resolution line inside the sheet's aliasing block is neither of those: it is computed from the finished design's own columns. The blocked resolution follows the same three routes. The two stored tables were checked against each other cell by cell and agree on all 49 cells the grid offers, so the two numbers a reader sees before the design exists are the same number; but nothing in the code ties the three sources together.
What this page does not repeat. The design sheet and the design selection grid each print a fixed sentence describing what a given resolution aliases with what. Those sentences are reproduced, word for word, on Two Level Factorial Designs. This page explains the arithmetic that produces the number in front of them.
Notation¶
| Term | Description |
|---|---|
| \(k\) | the number of factors in the design |
| \(F\) | the number of runs of the base design, before replicates and centre points |
| \(g\) | the number of design generators, \(g = k - \log_2 F\) |
| \(b\) | the number of block generators |
| \(A\), \(B\), \(C\), ... | the product's coded factor names, one letter per factor; a run of letters such as \(ABD\) names the product of those factors' columns |
| \(x_A\), \(x_B\), \(x_D\) | the coded column of a factor, one entry per run, each entry \(+1\) or \(-1\) |
| \(\odot\) | entrywise multiplication of two columns, run by run |
| \(I\) | the identity column, whose every entry is \(+1\) |
| \(W\), \(\lvert W \rvert\) | a word, that is a product of factor letters, and its length in letters |
| \(L\) | the length of the word under discussion, \(L = \lvert W \rvert\) |
| \(n\) | the number of factors in an interaction, in the two searches for a smallest such interaction below; it is not a count of runs, which is \(F\) here |
| \(R\) | the resolution reported in the design sheet's aliasing block |
| \(R_b\) | the blocked resolution reported in the same block |
Generators¶
A two-level design codes every factor as a column of \(+1\) and \(-1\), one entry per run. A full factorial on \(k\) factors needs \(2^k\) runs, because that is how many distinct combinations of \(+1\) and \(-1\) there are. A fractional design has fewer runs than that, so some factors cannot be given a column of their own.
Quantum XL builds a fractional design in two steps. The factors that do get their own column, \(\log_2 F\) of them for a design of \(F\) runs, are laid out as a full factorial: their columns carry every combination of \(+1\) and \(-1\) exactly once, which fills all \(F\) rows. Each of the remaining
factors is then given the entrywise product of two or more of those columns. The equation naming that product is the factor's generator. Written the way the source writes it, a generator reads \(D = AB\), which means
where \(\odot\) is entrywise multiplication: run by run, \(x_D\) is the product of the entries of \(x_A\) and \(x_B\) in that run. Two entries of \(\pm 1\) multiply to \(\pm 1\), so the new column is a legal two-level column.
The consequence is immediate, and it is the source of every alias in the design. The column belonging to factor D and the column belonging to the interaction AB are not merely similar, they are the same list of numbers. Nothing computed from the design can separate them.
The generators are looked up, not calculated. A reader expecting a formula that produces them will not find one. Quantum XL carries a fixed table with one entry per combination of factor count and run count: the code selects first on the number of factors, from 2 to 15, then on the number of runs, from 4 to 128, and each case assigns literal lists of factor positions. There are 49 such combinations, 214 stored design generators among them, and a further 338 stored block generators for the blocked cases. Nothing about a generator is derived while a design is being built. It is read out of that table.
A resolution number is stored beside each entry of that table, and a blocked resolution beside each block count within it. Those stored numbers are what the design description at the top of the design sheet reports: the stored resolution when the design is not blocked, the stored blocked resolution when it is. The Roman numeral in the design selection grid is stored too, but in a second table of its own, written into the dialog code and indexed by the grid's row and column rather than by anything the generators carry. Neither of those is the number in the sheet's aliasing block. That one is computed from the design's own columns after the design exists, and the section below says how.
The coding that turns a factor's settings into the \(+1\) and \(-1\) of a column is described on Design Coding.
The defining relation¶
Every generator can be rewritten as a statement about the identity column \(I\), the column whose every entry is \(+1\). Multiply both sides of \(D = AB\) by \(x_D\):
The left side is \(I\), because every entry of \(x_D\) is \(+1\) or \(-1\) and both square to \(+1\). So
and the generator has become a word: a product of factor letters whose column is the identity column. Quantum XL forms one such word from each generator by taking the generator's own letters and adding the letter of the factor that generator defines.
The words multiply, and their products are words as well. If \(I = ABD\) and \(I = ACE\) then
because \(x_A \odot x_A = I\) removes the repeated letter. Multiplication of two words is therefore performed by writing their letters together and then deleting every letter that appears an even number of times, keeping one copy of every letter that appears an odd number of times.
The defining relation is the closure of the generator words under that multiplication. With \(g\) generators, Quantum XL forms the \(g\) words first, then multiplies out every subset of two or more of them, which gives
words in all. The relation is then sorted, shortest word first. The identity itself is not one of the listed words. It is the thing they are all equal to.
The design sheet prints the relation under the heading Identity, as a single line that begins with
the label const and lists the words separated by equals signs, for example const=ABD=ACE=BCDE. The
printed line is not read back from the generator table. It is found by scanning the finished design:
every product of factor columns up to the size limit described under the alias table is formed, and any
product whose column holds the same value in every run is collected onto that line. A design in which no
product is constant prints no Identity line at all.
The length of a word¶
The length of a word \(W\), written \(\lvert W \rvert\), is the number of letters it holds after the cancelling described above. Because a letter that appears twice is removed outright, a reduced word never repeats a letter, so its length is a count of distinct factors: \(ABD\) has length 3 and \(BCDE\) has length 4. Quantum XL stores a word as a sorted list of factor positions and takes the length from the size of that list, so the length is read after every cancellation has already happened, never before.
Word length is what connects the defining relation to the aliases. Take a word \(W\) with \(\lvert W \rvert = L\) and multiply it by one of its own letters, say \(A\):
and \(A \odot W\) has \(A\) cancelled out of it, so it is an interaction of the other \(L - 1\) letters of \(W\). A main effect is therefore aliased with an interaction of \(L - 1\) factors for every word of length \(L\) that contains it. The same arithmetic runs from any term, not only from a main effect: multiplying any term by any word gives the term it is aliased with, and that term is written with the letters the two do not have in common, every shared letter having cancelled.
So the shortest word in the defining relation fixes the closest pairing the design contains, and the longer words describe pairings that are further apart.
Resolution¶
The resolution reported on the design sheet is
that is, one more than the number of factors in the smallest interaction that any main effect is aliased with. Quantum XL does not read this off the words. It pairs terms first, by comparing columns in the way the alias table section describes, and records for each pair it finds the two term sizes involved. It then looks for the smallest \(n\) for which the pair (main effect, \(n\)-factor interaction) was recorded, and reports \(n + 1\).
The two routes give the same number. A word of length \(L\) that contains a main effect makes that main effect aliased with an interaction of \(L - 1\) factors, and no shorter pairing can exist, so
the length of the shortest word in the defining relation. Reading resolution as a shortest word length and reading it as one more than the closest aliased pair are two descriptions of the same design.
\(R\) is written as a Roman numeral wherever it is displayed. Three cases sit outside the ordinary numbering:
- No aliasing at all. No product of columns matches any other and none of them is constant, so no pair is ever recorded. A full factorial with no blocking is this case. The sheet still writes the Aliasing information title, and prints All terms are free from aliasing. under it instead of the resolution, identity and alias table headings.
- Aliasing that does not touch a main effect. If no pair involves a main effect but some pair involves two interactions, no Roman numeral is produced. The line names the smallest such pair directly, as Some m-ways are aliased with n-ways.
- Resolution II. The arithmetic allows \(n = 1\), one main effect aliased with another, which gives \(R = 2\).
The search has a ceiling, and that ceiling decides the largest resolution that can be reported. Products are formed up to 7 factors when the design has 15 factors or fewer, and up to 3 factors when it has more than 15, which the larger Taguchi arrays reach. A main effect aliased with a 7-factor interaction is the deepest pairing the search can see, so resolution VIII is the largest number the design sheet can report.
The six sentences the product prints beside the Roman numeral, and the shorter form of the same line that goes onto the design sheet, are listed on Two Level Factorial Designs.
The alias table¶
A line of the alias table is a list of terms that share one column of the design, printed with equals
signs between them, for example A=BD=CE. Every term on the line has the identical list of \(+1\) and \(-1\)
values down the runs, so the design carries one column of information for all of them and no fit can tell
them apart.
The lines are built by comparison, not by algebra. Quantum XL forms every main effect and every interaction up to the size ceiling given above, turns each one into a column by multiplying its factors' columns entrywise, and then compares columns:
- Two terms go on the same line when their columns agree entry by entry, within a tolerance of \(10^{-7}\) on each entry.
- They also go on the same line when the columns agree after one of them is multiplied by \(-1\). The term
is then printed with a leading minus sign, as in
A=-BD, which says the two columns carry the same information with opposite signs.
Two kinds of term never reach the table. A term whose column is constant down every run belongs to the defining relation and is collected onto the Identity line instead. A term whose column is constant within every block is confounded with a block and is collected onto a blocking line instead. Each term is placed once and once only, so a term on the Identity line or on a blocking line does not appear again among the alias table lines.
A line can hold a single term. That is what the table prints for a term the comparison matched with nothing, and it means that term is aliased with nothing.
Within a line the terms are ordered by length first, shortest leading, and by factor position among terms of equal length. The lines are then sorted against each other by comparing their leading terms the same way. Terms are written with one letter per factor, A for the first factor and onward, and in a design of more than 26 factors as F1, F2 and onward instead.
The regression sheet carries no alias table. It prints the alias inside the term's own name instead: the
term reads A=BC, and where the line holds more than two terms the name ends in =....
Blocking and blocked resolution¶
Blocking in the design uses block generators, which are words in exactly the sense above and come from the same fixed table, indexed by factor count, run count and block count. They are not design generators and they do not add factors. They choose which runs go in which block.
With \(b\) block generators the block column is built one run at a time. Each generator word is evaluated on the run, giving \(+1\) or \(-1\); each result becomes a bit, \(1\) for a positive product and \(0\) for a result of zero or less; the \(b\) bits are read as a binary number, and the run's block is that number plus one. That gives \(2^b\) blocks.
Quantum XL does also carry the block generators through the defining relation symbolically. It takes each generator word, and each product of two or more of them, which is
words, and multiplies each of them through the relation, giving one line per word. That construction never reaches the design sheet. Its only use is internal: the terms those lines name are struck out of the list of interactions the model is allowed to carry, so that a term the blocks have taken is not offered as a model term as well.
The blocking lines the sheet prints are found by scanning the design's columns, exactly as the
Identity line is. A term is confounded with a block when its column takes one value throughout each block
level, so that its pattern of signs follows the blocks; every term matching a given block pattern is
collected onto that pattern's line. The lines are written as the first lines of the alias table, each
beginning with the label block and its number, for example block1=CF=EG. There is one line per block
column, which is one fewer than the number of blocks. For a design blocked this way that count is also
\(2^b - 1\), so the two routes produce the same number of lines by arriving at it separately.
The blocked resolution is
reported as Resolution n. Blocks are aliased with terms., where the terms are named as main factors when the smallest confounded term is a main effect and as n-ways otherwise.
Blocking does not change the resolution. The reason is the order the two searches run in. A term found confounded with a block is set aside at that moment, before any term to term pairing is attempted for it, and the record \(R\) is later read from is written only when two terms are matched against each other. A block finding therefore cannot enter the resolution's search at all. Neither can it break a pairing in half: terms on one line share a column exactly, so if one of them holds a single value throughout every block then all of them do, and an alias group leaves the table whole or stays whole. What is left for the resolution search to read is the same set of pairings the design would give with no blocks, so \(R\) is the same number and the blocks report their own number beside it. A design with no aliasing of its own can still report a blocked resolution.
Blocking on replicates is a different mechanism and uses none of this. No block generators are read, no blocking lines are produced and no blocked resolution is reported.
Where the blocking lines sit on the sheet, how the block column is read back when a design is analysed, and what blocking does to the ANOVA table are described on Blocking.
Folding¶
A fold appends a second copy of the design below the first, so the run count doubles. The copy holds the same columns with some of them negated:
- Fold on all factors negates every factor column in the copy.
- Fold on one factor negates that factor's column in the copy and leaves every other column as it was.
What that does to the aliasing follows from how a word's column is formed. The column of a word of length \(L\) is the product of \(L\) factor columns, so the word's column in the copied half is multiplied by \(-1\) once for every one of its factors that the fold negates.
- Under a fold on all factors, all \(L\) of them are negated, so the word's column is multiplied by \((-1)^L\) and is negated exactly when \(L\) is odd. An odd-length word is then \(+1\) through the first half and \(-1\) through the second, which is not the identity column any more, so the word is no longer part of the defining relation. Even-length words are unchanged and stay.
- Under a fold on one factor, a word that contains that factor has exactly one of its factors negated and a word that does not contain it has none, so exactly the words containing the folded factor drop out and the rest stay.
Quantum XL applies that rule to the words of the defining relation before it builds anything, and asks whether any word drops out. If none does, the fold would double the run count and change no alias, so the design is not built and the message is Cannot fold this design.
Two consequences of the doubling are worth stating plainly. The fold is applied before replicates and centre points are added, so a folded and replicated design carries both multipliers. And the list of interactions the model can hold is not derived from the shortened relation: once the columns are doubled, Quantum XL rebuilds the alias table from the folded columns themselves and takes the model terms from that, so a term the fold has freed appears because the new columns no longer match, not because a word was struck off a list.
The dialog controls that set a fold, and the two cases in which it is refused, are described on Folding.
See Also¶
References¶
- Montgomery, D. C. (2013). Design and Analysis of Experiments, 8th edition. Wiley.
- Box, G. E. P., Hunter, J. S., and Hunter, W. G. (2005). Statistics for Experimenters, 2nd edition. Wiley.