5D Library › Computational Aesthetics, Visual Saliency Maps and Cognitive Ergonomics in User Interface Design · 中文

Chapter 2 Deciding and Pointing: the Hick–Hyman Law and Fitts’s Law

To complete one action in an interface a user must do at least two things: decide which of several options to take, and move the pointer or finger onto it. Psychology offers an empirical law for each of these times, both written in the language of information theory: the Hick–Hyman law for choice reaction time and Fitts’s law for aimed movement. Both date from the 1950s and both are measured in bits, so they are often set side by side and even added directly into a “total time equation”. This chapter checks the original forms of the two laws and then asks under what conditions the optimisation problem formed by adding them makes sense.

Hick and Hyman: two ways of writing it

Hick 1952: log(n + 1)

In 1952 Hick placed participants in front of up to ten lamps, each with a matching key, and asked them to press the matching key when a lamp lit. He found that choice reaction time rose roughly logarithmically with the number of alternatives nn, and fitted it with RT=blog⁡(n+1)RT = b\log(n+1) (Hick 1952). The +1+1 has a definite meaning: participants must judge not only “which one” but also “whether there is a signal”, so the actual uncertainty includes an extra “no signal” alternative (Proctor and Schneider 2018). The commoner later form is RT=a+blog⁡2nRT = a + b\log_2 n, with a separate intercept.

Hyman 1953: information entropy

Hyman (1953) took the question a step further: if the alternatives occur with unequal probabilities, does reaction time still rise linearly with “information”? Manipulating the number of alternatives, their probabilities and sequential dependencies, he found that each participant’s reaction time was linear in the information HH conveyed by the stimulus (Hyman 1953):

RT=a+bH,H=∑i=1npilog⁡21pi.RT = a + bH,\qquad H = \sum_{i=1}^{n} p_i\log_2\frac{1}{p_i}.

With equal probabilities H=log⁡2nH = \log_2 n. This is the “Hick–Hyman law”: reaction time is linear in the uncertainty (entropy) of the choice. Card, Moran and Newell’s The Psychology of Human-Computer Interaction (1983) built it into the “Model Human Processor”, writing log⁡2(n+1)\log_2(n+1) for equally likely alternatives (Card et al. 1983).

The expression in the author’s framework

The author’s framework writes

RT=a+b∑ipilog⁡2(1pi+1).RT = a + b\sum_{i} p_i\log_2\!\left(\frac{1}{p_i} + 1\right).

In this round of searching it turned up in some university lecture notes (without a source), but it is neither Hick’s nor Hyman’s. It is easy to check: with equal probabilities pi=1/np_i = 1/n it equals log⁡2(n+1)\log_2(n+1), the same as Hick’s form; with unequal probabilities it equals neither log⁡2(n+1)\log_2(n+1) nor Hyman’s entropy. The program below compares the three forms on 8 menus (A) and then fits each form to simulated data generated by Hyman’s law (B).

Calculation

# Three ways of writing the "decision entropy" in the Hick-Hyman law RT = a + b H.
#   Hick (1952):   H = log2(n + 1)           (+1: the extra "no signal" alternative)
#   Hyman (1953):  H = sum p_i log2(1/p_i)   (Shannon entropy, no +1)
#   framework:     H = sum p_i log2(1/p_i + 1)
# A: the three on uniform and skewed menus. B: synthetic choice-RT data generated by
# Hyman's law (a = 200 ms, b = 150 ms/bit, noise sd 20 ms; illustrative values), fitted
# by least squares with each measure as predictor.
import math, random, statistics

def hick(p):  return math.log2(len(p) + 1)
def hyman(p): return sum(q * math.log2(1 / q) for q in p if q > 0)
def frame(p): return sum(q * math.log2(1 / q + 1) for q in p if q > 0)

def zipf(n, s=1.0):
    w = [1 / (k + 1) ** s for k in range(n)]; t = sum(w)
    return [x / t for x in w]

MENUS = [("uniform n = 2", [.5, .5]), ("uniform n = 4", [.25] * 4),
         ("uniform n = 8", [.125] * 8), ("8 items, Zipf s = 1", zipf(8)),
         ("8 items, Zipf s = 2", zipf(8, 2)), ("8 items, one at 0.93", [.93] + [.01] * 7),
         ("2 items, 0.99 / 0.01", [.99, .01]), ("1 item", [1.0])]

def fit(x, y):
    mx, my = statistics.fmean(x), statistics.fmean(y)
    b = sum((u - mx) * (v - my) for u, v in zip(x, y)) / sum((u - mx) ** 2 for u in x)
    a = my - b * mx; ss = sum((v - a - b * u) ** 2 for u, v in zip(x, y))
    return a, b, 1 - ss / sum((v - my) ** 2 for v in y)

if __name__ == "__main__":
    print("A. bits                       Hick log2(n+1)  Hyman H  framework  frame - H")
    for name, p in MENUS:
        print(f"   {name:24s} {hick(p):14.3f} {hyman(p):8.3f} {frame(p):10.3f}"
              f" {frame(p) - hyman(p):10.3f}")
    rng = random.Random(1953); x = {"hick": [], "hyman": [], "frame": []}; y = []
    for name, p in MENUS:
        for _ in range(200):
            y.append(200 + 150 * hyman(p) + rng.gauss(0, 20))
            for k, f in (("hick", hick), ("hyman", hyman), ("frame", frame)):
                x[k].append(f(p))
    print("B. fits to data generated by Hyman's law (1,600 trials, 8 menus)")
    for k, lab in (("hyman", "Hyman H"), ("frame", "framework"),
                   ("hick", "Hick log2(n+1)")):
        a, b, r2 = fit(x[k], y)
        print(f"   {lab:15s} a = {a:6.1f} ms  b = {b:6.1f} ms/bit  R^2 = {r2:.3f}")
# A. bits                       Hick log2(n+1)  Hyman H  framework  frame - H
#    uniform n = 2                     1.585    1.000      1.585      0.585
#    uniform n = 4                     2.322    2.000      2.322      0.322
#    uniform n = 8                     3.170    3.000      3.170      0.170
#    8 items, Zipf s = 1               3.170    2.620      2.883      0.263
#    8 items, Zipf s = 2               3.170    1.685      2.208      0.523
#    8 items, one at 0.93              3.170    0.562      1.446      0.883
#    2 items, 0.99 / 0.01              1.585    0.081      1.064      0.983
#    1 item                            1.000    0.000      1.000      1.000
# B. fits to data generated by Hyman's law (1,600 trials, 8 menus)
#    Hyman H         a =  200.0 ms  b =  149.7 ms/bit  R^2 = 0.985
#    framework       a =   -3.5 ms  b =  208.4 ms/bit  R^2 = 0.979
#    Hick log2(n+1)  a =   84.8 ms  b =  133.6 ms/bit  R^2 = 0.491

In Part A, for 2, 4 and 8 equally likely options the framework’s form equals Hick’s exactly (1.585, 2.322 and 3.170 bits), 0.585, 0.322 and 0.170 bits more than Hyman’s entropy. With unequal probabilities the differences grow: among 8 options with one at probability 0.93, the entropy is only 0.562 bits and the framework’s form 1.446 bits; with two options at 0.99 and 0.01, the entropy is 0.081 bits and the framework’s form 1.064 bits; with one option, the entropy is 0 and both the framework’s and Hick’s forms give 1 bit. In other words, the +1+1 adds the uncertainty of “is there a signal?” to every option, even when the choice itself has no uncertainty left.

In Part B the data are generated by Hyman’s law (intercept 200 ms, slope 150 ms per bit). Fitting with the entropy recovers 200.0 ms and 149.7 ms per bit, R2=0.985R^2 = 0.985; fitting with the framework’s form also gives R2=0.979R^2 = 0.979, but the intercept becomes −3.5 ms and the slope 208.4 ms per bit; fitting with log⁡2(n+1)\log_2(n+1) gives R2R^2 of only 0.491, because it cannot see differences in probability. So the framework’s form may “look fine” in goodness of fit, but the parameters it estimates have no direct interpretation. Figure 2 (left) plots the three forms against the probability of the most common option.

Note

When the +1+1 makes sense. If the task really includes the possibility of “no response” (for example, sometimes no target appears), counting that alternative in the uncertainty is reasonable; but the right way is to give it its own probability inside the entropy, not to add 1 to every term. Many choices in an interface have no such alternative: the user has already decided to click something.

Where the law applies

The Hick–Hyman law is robust in the laboratory, but its slope is not a constant. Proctor and Schneider’s 2018 review summarises several important qualifications (Proctor and Schneider 2018): the slope falls with practice (the figures that follow are as reported in the review; the original studies were not checked for this book: in Hale’s 1968 data, the difference between eight and two choices fell from nearly 500 ms in the first session to a little over 300 ms in the fifth; after extensive practice in Seibel’s 1963 study, 1,023 alternatives were only 20–30 ms slower than 31); the more natural the mapping between stimulus and response (“compatibility”), the smaller the slope, and some highly compatible tasks show almost no set-size effect; for saccades directly to the target location, the set-size effect can vanish or even reverse. For interface design this means that “more options, slower” may be weak when users are practised and mappings are natural.

There is a more basic qualification. Hick’s law describes the time to decide among alternatives when the target is known, not the time to search a list of unfamiliar labels for it. The claim that “more menu items are slower, so keep options few” is often attributed to Hick’s law, but finding an unfamiliar command in a randomly ordered menu requires scanning item by item, with time rising linearly with the number of items, and Hick’s law does not apply (Cockburn et al. 2007).

Fitts’s law: original and Shannon forms

Fitts (1954) asked participants to tap with a stylus alternately on two metal plates of width WW whose centres were a distance DD apart, and found that movement time was linear in log⁡2(2D/W)\log_2(2D/W) (Fitts 1954):

MT=a+b⋅ID,IDFitts=log⁡22DW.MT = a + b\cdot ID,\qquad ID_{\text{Fitts}} = \log_2\frac{2D}{W}.

MacKenzie (1989) proposed the Shannon form ID=log⁡2(D/W+1)ID = \log_2(D/W + 1), on the grounds that it matches the form of Shannon’s channel-capacity theorem (Theorem 17) and that the index of difficulty can never be negative (MacKenzie 1989); his 1992 review argued the case systematically (MacKenzie 1992). Re-analysing Fitts’s data, he found that the Shannon form (with an effective width computed from the spread of end points) had the highest correlation and the lowest standard error, while noting that the improvement in prediction was small and that its main advantage was theoretical consistency. Book 43 treated the difference between the two forms and the optimised-submovement model of Meyer and colleagues; here we add only the point that matters most for interfaces: when a target is wide and close, the original form gives a negative difficulty.

Calculation

# Fitts (1954) ID = log2(2D/W) against the Shannon form log2(D/W + 1) (MacKenzie 1992),
# and a "search - decide - point" chain for a toolbar of n buttons (the author's model).
# Strip of length L = 600 px at distance D = 400 px from the cursor; click probabilities
# p_i (Zipf); widths W_i with sum W_i = L. Expected pointing time a + b sum p_i ID_i.
# With log2(D/W) (large D/W) the minimum is W_i = p_i L, and then the expected ID equals
# log2(D/L) + H(p), a constant plus Hyman's entropy (the "identity" column checks this
# algebra; optimality follows from Gibbs' inequality). D/W >= 2.7 here, so the
# long-distance form is only an approximation. With the Shannon form the optimum
# (Lagrange: W_i (D + W_i) = c p_i, with sum W_i = L) is found by bisection. Illustrative
# constants: Fitts a = 100 ms, b = 150 ms/bit; Hick a = 200 ms, b = 150 ms/bit;
# novice serial reading 300 ms per label.
import math

def id_fitts(D, W):   return math.log2(2 * D / W)
def id_shannon(D, W): return math.log2(D / W + 1)

def zipf(n, s=1.0):
    w = [1 / (k + 1) ** s for k in range(n)]; t = sum(w)
    return [x / t for x in w]

def shannon_opt(p, D, L):            # W_i = (sqrt(D^2 + 4 c p_i) - D)/2, bisect on c
    w = lambda c: [(math.sqrt(D * D + 4 * c * q) - D) / 2 for q in p]
    lo, hi = 0.0, 1e12
    for _ in range(200):
        c = (lo + hi) / 2
        lo, hi = (lo, c) if sum(w(c)) > L else (c, hi)
    return w(lo)

def ept(p, W, D, f):
    return sum(q * f(D, w) for q, w in zip(p, W))

if __name__ == "__main__":
    print("A. index of difficulty (bits)  D/W:  0.25    0.5      1      4     16     64")
    for lab, f in (("Fitts log2(2D/W)", id_fitts), ("Shannon log2(D/W+1)", id_shannon)):
        row = "".join(f"{f(r, 1):7.2f}" for r in (.25, .5, 1, 4, 16, 64))
        print(f"   {lab:30s}{row}")
    D, L = 400.0, 600.0
    print("B. toolbar, expected pointing ID (bits); H = Hyman entropy of the clicks")
    print("   n  Zipf  H(p)  equal W  W = pL  identity  Shannon opt  rarest item ID")
    for n, s in ((4, 1.0), (8, 1.0), (16, 1.0), (16, 2.0)):
        p = zipf(n, s); H = -sum(q * math.log2(q) for q in p)
        eq = [L / n] * n; pr = [q * L for q in p]; so = shannon_opt(p, D, L)
        chk = ept(p, pr, D, lambda d, w: math.log2(d / w)) - math.log2(D / L)
        print(f"  {n:2d}  {s:4.1f} {H:5.2f} {ept(p, eq, D, id_shannon):8.2f}"
              f" {ept(p, pr, D, id_shannon):7.2f} {chk:9.2f}"
              f" {ept(p, so, D, id_shannon):12.2f}"
              f"  {id_shannon(D, eq[-1]):5.2f} -> {id_shannon(D, so[-1]):5.2f}")
    print("C. chain time for n buttons, equal widths (ms): search + decide + point")
    print("    n   expert (Hyman)  novice (serial)")
    for n in (2, 4, 8, 16, 32):
        point = 100 + 150 * id_shannon(D, L / n)
        expert = 200 + 150 * math.log2(n) + point
        novice = 300 * (n + 1) / 2 + point
        print(f"   {n:2d} {expert:15.0f} {novice:17.0f}")
# A. index of difficulty (bits)  D/W:  0.25    0.5      1      4     16     64
#    Fitts log2(2D/W)                -1.00   0.00   1.00   3.00   5.00   7.00
#    Shannon log2(D/W+1)              0.32   0.58   1.00   2.32   4.09   6.02
# B. toolbar, expected pointing ID (bits); H = Hyman entropy of the clicks
#    n  Zipf  H(p)  equal W  W = pL  identity  Shannon opt  rarest item ID
#    4   1.0  1.79     1.87    1.77      1.79         1.76   1.87 ->  2.50
#    8   1.0  2.62     2.66    2.41      2.62         2.40   2.66 ->  3.74
#   16   1.0  3.40     3.54    3.08      3.40         3.07   3.54 ->  5.03
#   16   2.0  1.95     3.54    2.04      1.95         2.01   3.54 ->  7.52
# C. chain time for n buttons, equal widths (ms): search + decide + point
#     n   expert (Hyman)  novice (serial)
#     2             633               733
#     4             881              1131
#     8            1149              1849
#    16            1432              3182
#    32            1722              5722

In Part A, at D/W=0.25D/W = 0.25 the original form gives −1.00 bit and the Shannon form 0.32; at D/W=0.5D/W = 0.5 the original gives 0 and the Shannon form 0.58; for D/W≥4D/W \ge 4 the two differ by less than 1 bit, with the original always larger. Large buttons and context menus that open next to the pointer often lie in the region D/W<1D/W < 1, where only the Shannon form can be used.

Search–decide–point: when can the total be “minimised”?

The author’s framework proposes combining the two laws into an equation that minimises the total time of the whole “visual search – cognitive disambiguation – click” chain. The idea is valuable, but “minimisation” first needs answers to three questions. What are the variables (button widths, positions, number or hierarchy)? What is the distribution of click probabilities? Is the user a novice searching item by item or an expert who knows where the target is? Different answers give different optima. The menu-performance model of Cockburn, Gutwin and Greenberg (2007) handles exactly this: novice time is governed by visual search, expert time by Hick–Hyman decisions, plus Fitts pointing time and a transition from novice to expert (Cockburn et al. 2007); Seow (2005) compared the two laws from the standpoint of information theory (Seow 2005).

Part B of the program above is a case that can be solved exactly (the author’s model): a toolbar of length L=600L = 600 pixels at distance D=400D = 400 pixels from the pointer, with nn buttons whose click probabilities follow a Zipf distribution and whose widths can vary but must sum to LL. The aim is to minimise the expected pointing time a+b∑ipiIDia + b\sum_i p_i\,ID_i.

With log⁡2(D/W)\log_2(D/W) (the long-distance approximation; here D/WD/W is at least about 2.7, so this is only an approximation, and the exact Shannon-form optimum follows below), Lagrange multipliers give the optimal widths Wi=piLW_i = p_iL at once, and substituting back,

min⁡∑ipilog⁡2DWi=log⁡2DL+∑ipilog⁡21pi=log⁡2DL+H(p).\min\sum_i p_i\log_2\frac{D}{W_i} = \log_2\frac{D}{L} + \sum_i p_i\log_2\frac{1}{p_i} = \log_2\frac{D}{L} + H(p).

In this setting, then, the expected pointing difficulty of the optimal layout equals a constant plus Hyman’s entropy: the “information” of deciding and of pointing merge mathematically. The “identity” column of the program checks this algebraic identity (1.79, 2.62, 3.40 and 1.95 bits, equal to H(p)H(p) by construction); it is not an independent check of optimality, which follows from the Lagrange conditions or Gibbs’ inequality. With the Shannon form the first-order condition becomes Wi(D+Wi)=cpiW_i(D + W_i) = c\,p_i, and the optimal widths must be found numerically.

The results: with 8 buttons and Zipf exponent 1, equal widths give an expected difficulty of 2.66 bits, the Shannon optimum 2.40 bits, and widths proportional to probability (W=pLW = pL) 2.41 bits, almost the same; the price is that the least-used button becomes narrower, its difficulty rising from 2.66 to 3.74 bits. With 16 buttons and Zipf exponent 2 (very concentrated clicks), equal widths give 3.54 bits and the optimum 2.01 bits, while the least-used button rises to 7.52 bits. “Enlarge buttons in proportion to their click probability” therefore helps on average but makes a few actions clearly harder, a trade-off that should be stated.

Part C adds search (equal widths): an expert’s total time rises from 633 ms with 2 buttons to 1,722 ms with 32, roughly logarithmically; a novice who reads each label rises from 733 ms to 5,722 ms, roughly linearly. Figure 2 (right) plots both curves. The same “total time equation” gives completely different optimal numbers of buttons for novices and experts; without stating the type of user, there is nothing to minimise.

Left: in a menu of 8 options, as the probability of the most common option rises from 1/8 to 1, Hick’s \log_2(n+1) stays constant, Hyman’s entropy falls to 0, and the expression in the author’s framework levels off at 1 bit. Right: in the author’s toolbar model, the total “search–decide–point” time for buttons of equal width; for experts (Hick–Hyman decisions) it grows roughly logarithmically, for novices reading each label roughly linearly (illustrative parameters).

Hypothesis · not established · The net effect of probability-weighted widths

The author’s hypothesis (not established): in a toolbar that users already know, assigning button widths in proportion to historical click probabilities (total width unchanged) shortens experts’ average click time but clearly raises the time and misclick rate for the least-used buttons, so that overall task time improves by less than 5 %. What result would show it wrong: in a pre-registered within-subject experiment, probability-weighted widths shorten overall task time by more than 5 % (lower confidence limit above 5 %) without raising the misclick rate on the least-used buttons.

Chapter summary

The +1+1 in Hick’s 1952 log⁡(n+1)\log(n+1) stands for the “no signal” alternative; Hyman’s 1953 entropy H=∑pilog⁡2(1/pi)H = \sum p_i\log_2(1/p_i) has no +1+1. The framework’s ∑pilog⁡2(1/pi+1)\sum p_i\log_2(1/p_i + 1) equals log⁡2(n+1)\log_2(n+1) with equal probabilities and is neither law otherwise; Hyman’s entropy should be used instead. The Hick–Hyman law describes deciding when the target is known, not searching among unfamiliar labels, and its slope changes with practice and compatibility. Fitts’s original form is negative for D/W<1/2D/W < 1/2; interfaces need the Shannon form. “Minimising” the sum of search, decision and pointing makes sense only once the variables, the probability distribution and the type of user are stated: with the logarithmic form the optimal widths are proportional to click probabilities and the expected difficulty equals a constant plus Hyman’s entropy; total time for novices is roughly linear and for experts roughly logarithmic, and the two call for different designs.

References

Card, Stuart K., Thomas P. Moran, and Allen Newell. 1983. The Psychology of Human-Computer Interaction. Lawrence Erlbaum Associates.
Cockburn, Andy, Carl Gutwin, and Saul Greenberg. 2007. “A Predictive Model of Menu Performance.” Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI ’07), 627–36. https://doi.org/10.1145/1240624.1240723.
Fitts, Paul M. 1954. “The Information Capacity of the Human Motor System in Controlling the Amplitude of Movement.” Journal of Experimental Psychology 47 (6): 381–91.
Hick, W. E. 1952. “On the Rate of Gain of Information.” Quarterly Journal of Experimental Psychology 4 (1): 11–26. https://doi.org/10.1080/17470215208416600.
Hyman, Ray. 1953. “Stimulus Information as a Determinant of Reaction Time.” Journal of Experimental Psychology 45 (3): 188–96. https://doi.org/10.1037/h0056940.
MacKenzie, I. Scott. 1989. “A Note on the Information-Theoretic Basis for Fitts’ Law.” Journal of Motor Behavior 21 (3): 323–30. https://doi.org/10.1080/00222895.1989.10735486.
MacKenzie, I. Scott. 1992. “Fitts’ Law as a Research and Design Tool in Human-Computer Interaction.” Human-Computer Interaction 7 (1): 91–139. https://doi.org/10.1207/s15327051hci0701_3.
Proctor, Robert W., and Darryl W. Schneider. 2018. “Hick’s Law for Choice Reaction Time: A Review.” Quarterly Journal of Experimental Psychology 71 (6): 1281–99. https://doi.org/10.1080/17470218.2017.1322622.
Seow, Steven C. 2005. “Information Theoretic Models of HCI: A Comparison of the Hick-Hyman Law and Fitts’ Law.” Human-Computer Interaction 20 (3): 315–52.

Fan, Y. (2026). Computational Aesthetics, Visual Saliency Maps and Cognitive Ergonomics in User Interface Design: From the Hick–Hyman Law and Spatial Frequency Channels to Saccadic Trajectory Modelling, Read Beside the Kaogongji and Classical Treatise on Architectural Methods [计算美学、视觉显著性图谱与人机界面认知工程] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23836258 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).