Pauli Algebra

An element of Pauli algebra consists of a complex scalar, say , and a three-dimensional complex vector , denoted , which thus has eight real dimensions. In effect, this is a generalization of quaternion algebra, but with complex instead of real components. In this article, we call these elements “spinors.”

A product of two spinors is a spinor defined by

(1)

where and are the dot and cross products, respectively. Note that this multiplication is associative, implying that we do not need parentheses when multiplying three or more spinors. But multiplication is not commutative (the result depends on the order of factors).

There are two important unary (single-argument) operations on spinors: the first is called a reflection (denoted ), which changes the sign of the vector part, that is, ; the second takes the complex conjugate of and of each component of ; it is denoted . Finally, just for convenience, we let denote the combination of both of these, that is, Note that

(2)

which are quite easy to verify.

The corresponding Mathematica routines look and work like this.

From now on we consider a three-dimensional vector to be a special case of a spinor, meaning that is shorthand for . We can easily compute various functions of spinors (and of three-dimensional vectors, as a special case). Thus, for example, assuming that is a three-dimensional vector with real components, we find

(3)

where is the length of and is a unit vector in the same direction.

Similarly, for a three-dimensional vector with pure imaginary components (which we express in the form to keep the elements of real), the same kind of expansion yields

(4)

again where is the length of and is a unit vector in the same direction.

This can be easily extended to a complex-vector argument, as follows.

Special Relativity

The basic idea of Einstein’s theory is to unite space and time into a single entity of spacetime, whose “points” (or events) can then be represented by real spinors of type . The separation between any two such events constitutes a so-called 4-vector that, when multiplied (in the spinor sense) by its own reflection, yields a pure scalar . It is now postulated that this quantity must be invariant (having the same value) in all inertial coordinate systems (i.e. those that differ from each other by a fixed rotation and/or a boost—a motion at constant velocity). For simplicity, our choice of units sets the speed of light (which must be the same in all inertial systems) equal to 1.

The question is: how do we transform 4-vectors from one inertial frame to another, while maintaining this invariance? The answer is provided by

(5)

where and represent a 4-vector in the old and new frame of reference, respectively, and is a spinor such that . It is obvious that remains real whenever is real, and that

(6)

where (the scalar invariant of ). This shows that has the same value in all inertial frames of reference. Requiring reflection to be a frame-independent operation (meaning that for every 4-vector) leads to

(7)

From this, we can see that transforms differently from , being an example of a four-dimensional covector (a -vector, in our notation). Another important example of a -vector is the operator, where stands for the usual three-dimensional (spatial) gradient (the collection of , , and partial derivatives).

One can show that if and only if , where is a “pure” vector (i.e. three dimensional, but potentially complex valued). This is a fully general but rather inconvenient form of ; fortunately, one can prove that any such can be expressed as a product of an ordinary three-dimensional rotation and a boost , where and are real-valued vectors. To see that results in an ordinary rotation of the vector part of (where the magnitude of specifies the angle and the direction of defines the axis of rotation), consider

(8)

where is the decomposition of into components parallel and perpendicular to , respectively. Note that commutes with (and any function thereof); consequently, it remains unchanged by this transformation. On the other hand, and anticommute (i.e. ), implying

(9)

and, consequently, the rest of (8). One can thus see that this transformation leaves the scalar part of a 4-vector intact, and rotates the vector part using and as the axis and angle of rotation (of the old frame, with respect to the new one), respectively.

Similarly, using , we get

(10)

Here, can be replaced by , where and represent the unit direction and the magnitude of a three-dimensional vector (a velocity of the old frame with respect to the new one), respectively. This leads to the following simplified (and physically more meaningful) result of such a boost, applied to :

(11)

Electromagnetic Fields

A 4-vector field of central significance is the electromagnetic potential , where and each component of are real-valued functions of a spacetime location (i.e. of , , , and ). Now comes an important point: within the current framework, it is physically meaningless to multiply two 4-vectors (we would not know how to transform such a product from one inertial frame to another), but it is possible to multiply a -vector by a 4-vector, creating what we call a mixed vector. It is thus quite legitimate to do

(12)

creating a mixed vector, which has its own new way of transforming (shown shortly).

To physically interpret the right-hand side of (12), we first impose the so-called Lorenz condition (often misattributed to the more famous Lorentz) of (we prove shortly that this condition is frame invariant), and identify with , where and are the resulting (real-valued) electric and magnetic fields, respectively.

One can now show rather easily that will simply rotate the two fields. On the other hand, a boost results in

(13)

since transforming a mixed vector is done by . In both cases (rotation and boost), the scalar part remains equal to zero, thus proving invariance of the Lorenz condition.

Unlike 4-vectors, mixed vectors can be multiplied, yielding a new mixed vector (in terms of its transformation properties). Thus, for example,

(14)

tells us that both and are invariant scalar fields.

Similarly, multiplying a 4-vector by a mixed vector returns a 4-vector; for example,

(15)

This time, the result must equal the charge/current density (yet another basic 4-vector of the theory); this results in a compact, Dirac-algebra formulation of the usual Maxwell equations. As an example, the following program computes the electromagnetic field of a point-like massive particle of a unit charge, moving at a uniform speed along the axis; it also verifies that the result satisfies Maxwell’s equations.

Dynamics of a Point-Like Charged Particle

We choose units in which both the rest mass and the charge of the particle equal 1. Its instantaneous location is denoted , where the three components of are functions of . To make the subsequent equations frame independent (having the same form in all inertial frames), we now need to introduce the particle’s so-called proper time by

(16)

We already know that transforms as a 4-vector; , thus and, consequently, are relativistically invariant (the dot over implies differentiation with respect to ). Proper time is then computed by the corresponding integral, namely

(17)

which, being a “sum” of invariant quantities, is an invariant scalar as well. This implies that

(18)

transforms as a 4-vector (we call it the 4-momentum of the moving particle).

The motion of the charged particle in a given electromagnetic field can now be established by solving

(19)

where the right-hand side is the so-called Lorentz force, and “” takes the real part of its argument (also a 4-vector). Note that “” applied to a 4-vector remains a 4-vector (since the complex conjugate of a 4-vector transforms as a 4-vector, as one can readily verify).

Based on (18), the right-hand side of (19) equals

(20)

For a particle with a negative unit charge, the sign of this 4-vector would be reversed.

One way of solving the resulting 4-vector equation is to expand the left-hand side of (19):

(21)

which has to equal (20). Canceling the scalar factor of , we get

(22)

Finally, the first (scalar part) of these four equations can be obtained by taking the dot product of the remaining three equations (the vector part) and , and is therefore redundant. All we need to solve in the end is

(23)

or, equivalently (by solving for ),

(24)

the correctness of which can be easily verified by substituting this into the left-hand side of (23) and obtaining the right-hand side. These equations can, in general, be solved only numerically. The resulting will be a three-component function of a frame-dependent time (proper time was used only as an intermediate tool to assure agreement between inertial frames of reference; our solution remains correct in any other such frame, after the corresponding transformation). The following program finds the motion of a negatively charged particle (chosen because an attractive force makes the resulting path somehow more interesting, compared to the same-charge repulsion) in the field of the previous section.

The originally stationary unit-mass particle has been “captured” by the moving massive particle (which is assumed to be so heavy that its own motion remains unaffected), and will continue orbiting it (while following its uniform motion). It is important to realize that this formulation of the problem has ignored the fact that a moving particle generates (and radiates) an electromagnetic field of its own, which would further modify its motion. More importantly, we also know that, at an atomic level, the world is governed by quantum mechanics, ultimately resulting in a totally different description of an orbiting particle. This is the reason why the last solution is only of mathematical interest. Under a wide range of initial conditions, the light particle would be drawn to collide with the heavy one.

Motion in a Constant Electromagnetic Field

Things become easier when and are both constant fields (in space and time). One can then express as , where is the initial value of the particle’s 4-momentum, and is a spinor analogous to that (instead of transforming 4-vectors between inertial frames) advances to its current location. This time we find it more convenient to make both and functions of proper time . Also, one must not forget to meet the condition, which is then automatically maintained by at all future times.

Expanding the right-hand side of (19) yields

(25)

This should equal the left-hand side of (19), namely

(26)

which implies that

(27)

having the obvious solution

(28)

a function of a mixed vector transforms as a mixed vector. After computing and, consequently, , all we need to do is to integrate this last expression in terms of to get a solution for . A simple example follows.

In this example, we have been able to obtain an explicit analytic solution.

In most textbooks (e.g., [1], [2]), the treatment we have described is done using conventional tensor analysis, with covariant and contravariant vectors. It is always illuminating, however, to obtain the same results using a completely different approach, such as the one favored by Hestenes [3]. We have shown that Mathematica is capable of handling computations in any of several formalisms.

References

About the Author

Jan Vrbik
Department of Mathematics, Brock University
500 Glenridge Ave., St. Catharines
Ontario, Canada, L2S 3A1
jvrbik@brocku.ca

Introduction: Ordinary Differential Equations and Population Dynamics

The ordinary differential equations with which students are most familiar are the equations for exponential and logistic population growth (see [1], for example). Historically, Thomas Malthus initiated the mathematical treatment of population dynamics [2]. His investigations into the consequences of exponential growth in human populations coupled with linear growth in agricultural production led him to a pessimistic view of the eventual fate of humankind, involving misery and starvation.

Pierre-Francois Verhulst and others considered how to model factors that might retard exponential growth, among which the roles of disease and famine had been suggested already by Malthus. In his 1838 paper [3], Verhulst transformed the discussion into a mathematical model by writing

(1)

Here corresponds to exponential growth and the term corresponds to the effect of obstacles that slow the growth rate and that depend on the population size . A simple form for the obstacle term is , and setting yields the factored form

(2)

the form we use in this article. Verhulst solved this equation; showed how it led, in the long run, to a bounded population size; and used actual population data to calculate the size of the limiting population for Belgium according to the model. He termed the graph of the solution the logistic curve: the word logistic has its origins in the Greek “logistikē”—the art of calculating—and Verhulst was the first to be able to calculate the effects of obstacles on the growth of human populations.

The logistic equation is especially useful for introducing ideas involving the qualitative behavior of solutions, in particular the notion of a stable equilibrium. We now write the relevant ODE as

(3)

In the logistic model, is the population size at time . Using the terminology of population dynamics, the parameters in this model are the growth constant, , which controls the rate of population growth near ; the carrying capacity, , which limits the eventual size of the population; and the initial population size . DSolve gives an explicit formula for the solution to the corresponding initial value problem.

The usual textbook formula for the solution divides both numerator and denominator by to obtain . From this simplified formula it is easy to check that and that for .

The built-in Mathematica function Manipulate lets you vary the parameters , , and interactively to see the effect of varying those parameters graphically. Equilibrium solutions for the model (values of for which ) occur at and . The carrying capacity is indicated by the dashed horizontal line (slope zero) in the figure, while the solution curve is purple. The initial value is the height of the curve at its intersection with the axis. How would you describe the effect of varying the growth constant ?

The equilibrium solution is stable, since whenever , . (However, for some time only if , and hence for all times .) Since solution curves starting near do not satisfy , this equilibrium solution is not stable. This information can be captured in a “phase diagram,” shown in the next section. The diagram visually condenses the claims just made: solution curves diverge away from and converge toward . Use the sliders above to verify these claims, based on the plots of the various solution curves. Since this article is primarily concerned with the shapes of solution curves for the differential equations models we study, graphs do not include units on the axes.

A Key Concept: The Time Evolution of a Spatial Profile Curve

Now consider the case of a population that is spread out along a narrow strip of land or sea, which we will think of as a line. An initial study of the population might result in a function giving the size of the population at location along the strip. But population size is a dynamic quantity, so we should really employ a function of two variables, time and location, in our attempt to model its evolution. Thus, the population size at time and location is with recording the observed initial population distribution.

We model the time evolution of the population using the partial differential equation

(4)

This is just a modification of the logistic equation in which the carrying capacity now depends on location . This allows the new model to account for environmental conditions that vary from place to place. The function is now the unknown function that solves the PDE. In this setting, the role of the initial value, formerly played by the number , is being played by the function . Essentially, what we have is a separate initial value problem at each location.

We will call the graph of the initial profile curve. Think of for a given value of as the profile curve for the population at time . Its graph shows how the total population is distributed along the line. The left-hand side of our PDE gives the time rate of change of the function , and we will interpret the right-hand side as the rule governing the time evolution of the initial profile curve . This idea, the time evolution of a profile curve, is crucial to what follows.

Here is an example that illustrates this point of view. The location-dependent carrying capacity is given by the function , and the growth constant is . Plots of and are shown below.

We might predict that the initial population will evolve toward the carrying capacity. To see whether this prediction is accurate, we use Manipulate to show the evolving profile curve as increases. Use the “Reset and Play” button to show the time evolution.

Here is a thought experiment: suppose we were to change the initial population curve, leaving the carrying capacity at each location the same; would you expect the new initial profile curve to evolve to ? Can you explain why this is so?

Another thought experiment: what would be the effect of a larger value of on the time it takes for the initial population to approach equilibrium?

Once again, we can summarize the investigation with a “phase diagram.”

As before, the diagram indicates the equilibrium solutions, which are the curves along which is zero at every point. These are graphs of the functions and . The arrows indicate that if at every location , then , so that can be termed a stable equilibrium for this PDE.

A final note: another variation of logistic growth is given by , where the carrying capacity is constant, but the growth constant , that is, the speed with which the initial population approaches the equilibrium population, depends on location.

Migrating Populations

In the previous example, the time evolution of the profile curve was governed by a right-hand side that involved only the values of the function . The next PDE we consider has the time evolution at location governed by the slope of the profile curve at . The simplest equation of this type has the time rate of change of proportional to its slope, , with .

We can interpret the solution to this PDE in terms of a migratory population with the parameter controlling the speed of the migration as shown in the output from Manipulate displayed below (use the “speed” buttons to vary ). Data for the migration of gray whales along the California coastline would provide a real-life example of the phenomenon we are modeling. In the graphic, it is best to use the “Reset” button before changing the speed.

DSolve gives the following formula for the solution to the PDE , which we might call the migration equation. As usual, the initial population profile is .

You may have seen in previous courses how changing to changes the graph. Consider the value on the graph of ; this same value occurs on the graph of , but now it occurs at , since . Likewise, you see that , so that the same value, , that occurred at along the graph of will occur along the graph of at input value . Since this relationship holds for every , we conclude that the graph of is a horizontal translation of the graph of to the right by units. In our setting, gives a graph that is the graph of displaced to the right by units. Note how displacement speed time.

An application of the chain rule shows that satisfies the migration equation for any initial population distribution . This model also applies to the familiar stadium wave and is commonly referred to as the traveling wave equation. Jean le Rond d’Alembert first introduced PDEs for waves and methods for solving them in his study of vibrating strings [4]. In fluid dynamics, is a simplified version of the transport equation that models how dissolved solids travel along with a current.

Seasonal Migration

The migration of gray whales is seasonal, ranging from the southern Baja peninsula near the Tropic of Cancer to the Chukchi Sea north of the Arctic Circle [5]. To model the periodic nature of the whales’ migration, we can translate the initial graph using a periodic function to obtain . Now satisfies the periodic migration equation

(5)

with as the initial profile curve. You can see how the factor comes from the chain rule. The parameter still governs the speed of the migration; can you predict the feature of the graph that is related to the parameter ?

Dispersion

In response to overcrowding in one location, a population may disperse over a wider area. A model is provided by making the time evolution of the population graph proportional to the concavity of the graph. To see why this works, recall that a local maximum is characterized via the second derivative test as occurring where the tangent line is horizontal and the graph is concave down (negative second derivative). Thus, the model stipulates that near a local maximum, the future population will decrease. We write the dispersion equation as

(6)

and refer to the proportionality constant as the dispersion coefficient. The graph of the so-called fundamental solution to this equation,

(7)

is a bell-shaped curve whose standard deviation increases as time moves forward, starting from some time .

This verifies that this function solves the dispersion equation.

The larger the dispersion coefficient, the faster the dispersion takes place; use the buttons for the dispersion coefficient and the plus and minus buttons for time to show that the graph with dispersion coefficient 5 at time 20 is identical to the graph with dispersion coefficient 20 at time 5.

In these graphs, the total population is represented by the area under the curve and does not change. As time moves forward, the dispersion process leads to a population that is, for practical purposes, uniformly distributed. In chemistry, our dispersion equation is called the diffusion equation: the concentration of dye in a liquid diffuses toward a uniform concentration over time. The origins of this equation are in the study of how heat dissipates from a source. Joseph Fourier began circulating results on the mathematics of heat conduction in 1807, when the heat equation was born. He published a treatise on the subject in 1822 [6].

Combined Models

For a population that disperses as it migrates, we can combine the two previous models via the advection-dispersion equation

(8)

As you might expect, a fundamental solution involves replacing by :

(9)

Use the “Reset and Play” button to see how the initial data evolves.

A more interesting combined model can be employed in the study of invasive species. The figure below shows data related to the spread of gypsy moths in Wisconsin over a ten-year period from 1996 to 2006 [7].

The darkest regions on the maps represent 11 or more moths per trapping area, which we will take as the statewide carrying capacity. We let represent the distance from the Mississippi River on the western edge of the state, with the total distance to Lake Michigan roughly 180 miles. We combine dispersion with logistic growth to obtain the PDE

(10)

This equation is solved numerically (think of applying Euler’s method to the entire profile curve), and the time evolution of the initial profile curve is plotted below.

You can see that the model does not fit the data precisely: the “edges” of the gypsy moth population shown on the two maps are not as uniformly sharp as the model would predict. Biological systems are complicated, particularly because an element of randomness may come into play. Still, the concept of a model that includes dispersion and logistic growth, a variant of the Fisher-Kolmogorov equation, seems to capture most of the essential features of the gypsy moth data.

Finally, note that the total gypsy moth population is not constant, as it would be under a dispersion-only model. Here the growth term on the right-hand side of the equation overcomes dispersion, and as time moves forward, the population spreads across the whole state, while its size approaches the carrying capacity at each location.

Summary

Using DSolve and Manipulate, we have illustrated three basic partial differential equations and interpreted the equations via a profile curve (a function of at a specific time ) that evolves with time, according to a rule that depends on function value, slope, or concavity. In terms of population dynamics, these equations were used to model location-dependent carrying capacity, migration, and dispersion. Combinations of the basic models were used to capture more complicated phenomena in a conceptually simple way that is suitable for students in a multivariate calculus class and that takes advantage of their previous experience with ODEs. A beginning textbook for PDEs is [8]. Further applications to population dynamics appear in [9].

References

About the Author

Michael Kerckhove is an associate professor of mathematics at the University of Richmond. This article grew out of a desire to introduce PDEs, particularly the diffusion equation, in the context of cell signaling early in the second semester of our Integrated Quantitative Science course, iqscience.richmond.edu.

Michael Kerckhove
Department of Mathematics
University of Richmond
28 Westhampton Way
Richmond, VA 23173
mkerckho@richmond.edu

Introduction and Review

Following [1], we study methods to develop asymptotic estimates for a system of ordinary differential equations given in the form

(1)

where is an matrix (with elements depending on ) and is a column matrix whose elements are unknown functions. We suppose that has analytic coefficients near infinity and can be written as a series (convergent for large ) for constant matrices , where is nontrivial. Such a singularity at finite may be turned into a singularity at infinity by a change of variables. This type of singularity for is called a singularity of the second kind, also known as an “irregular” singularity [2].

Differential equations of the form , with the bounded for large and , can also be written in the above general matrix form by setting

(2)

where the have zero elements except: has diagonal elements , , , ; has ones on the diagonal above the main diagonal; the last row of consists of the block matrix . Here, solutions and their first derivatives are given by the respective components of as , .

Asymptotic Procedures

Consider a system of the form , where the elements of are analytic (near infinity) and (formal series) where is a diagonal matrix of distinct complex numbers . Then, there are constant matrices , , , and , , so that the columns of

(3)

are each asymptotic series for some solution of (1). Here the matrices , are diagonal, may be taken as the identity matrix, and may be taken to equal ; denotes the matrix exponential and . This is a special case of theorems 2.1 and 4.1 of [1, Chapter 5]. In fact, this method produces exact solutions in cases not treated here; see [1, Chapter 4]. We do not repeat the entire proof of this result here, but we elaborate on the construction of the and . By methods which amount to a matrix version of the dominant balance method, the matrices , , , and satisfy

For , let denote the same matrix as above, but with zeros on its main diagonal. For our objectives, we need only to solve for the corresponding to proceed. We obtain

(4)

By , we mean that diagonal matrix whose elements match those of the argument along the main diagonal; this is not the same as the Mathematica built-in function Diagonal. Then for each (provided ), we may recursively compute the , , and by

(5)

(6)

(7)

Example System of Equations

We begin with an example involving rational functions of . Such examples suffice in our general setting by our hypothesis on . Consider the case , , , and

(8)

We only need terms of order and for accuracy up to in the first factor of (3). We follow equation (4) to solve and and equation (7) to solve . We denote , , by P0, P1, P2 in input, and so on for other variables.

Asymptotic solutions up to first derivatives are given by the columns of the matrix .

We find that there are two linearly independent solution vectors and satisfying

We compare our result with the exact solution of an initial value problem of the following asymptotically equivalent [3] system:

Routine calculations, involving hypergeometric functions, show that for a constant .

Instability

A natural way to check our results is to compute numerical results via NDSolve. Here, we compare our dominant asymptotic calculations from to numerical results of the original equation (via Interpolation). Below we expect our graphs to have horizontal asymptotes; instead, we find the calculations to be unstable for .

Modification

We can apply these asymptotic estimates to produce stable solutions from NDSolve for large . We replace by and by to produce a solution with less drastic decay rates.

The solutions seem to be tending to limiting values for near 600: all with no call to any special calculation options.

It is beyond the scope of this article to compare and contrast numerical schemes, since our objective is to predict theoretically the growth behavior of solutions as demonstrated using default options of NDSolve. Our method, we note, may serve to improve stability and reduce stiffness, yet we do not quantify such results. We do, however, note that widely varying exponential growth/decay of solutions is known to produce instability similar to what we see in the literature. References [4, 5, 6] and the NDSolve documentation [7], among many others, introduce rigorous methods regarding such issues.

Application to a Third-Order Ordinary Differential Equation

We now study asymptotic behavior of solutions to (for ) for the operator . Following (2) we study the system , which we can write as

(9)

We choose this example so as to force a diagonalization step before applying the procedure to produce estimates (3), after which we identify , (with ).

We proceed with the diagonalization step.

Here and are obvious and, using (4) and (5), we compute and .

Using (6) and (7) we compute and .

We are ready to compute asymptotic solutions after a change of basis.

We multiply rows of the solution matrix by various powers of to produce the various asymptotic estimates of solutions to , which we can read off from the columns of Soln.

We find three different types of behavior for asymptotic solutions: rapid decay, rapid growth, and a constant solution. We can check that any constant function is indeed a solution, so the constant behavior is precise and not just asymptotic in this case. Moreover, any solution is majorized by .

Graphical Results

We check our results using two approaches. First we simply graph ratios with numerical solutions . Let us consider this using a nonconstant solution arising from the initial values . The analysis for initial values is similar, and we invite the reader to check.

We are able to produce graphs using default options of NDSolve only for moderate domains of . For our second approach, we modify the operator by substituting , thereby theoretically guaranteeing bounded solutions on intervals away from the origin

We find instability as we calculate relative errors over large intervals (see [8]), as in the previous section. Alternatively, we use a modified operator along with a linear change of variable to calculate solutions on intervals for large . We apply the transformation after applying the modification procedure above; then the initial value problem applied near for the new problem is equivalent to solving the original near for large . We find that in this way we can accurately compute solutions on large intervals in .

The advantage here is that the end result is of the form for large where is computed with considerable accuracy and the other terms are known exactly.

Conclusion

The classical techniques of asymptotics can be calculated symbolically and in an automated way via simple matrix manipulations. These estimates can serve to check accuracy of numerical solutions both for scalar equations and for systems of equations of the types studied. Moreover, these estimates may serve to transform differential equations to certain modified versions that admit solutions bounded as ; as solutions of modified problems can be computed with accuracy and stability, with the transformation in elementary form, accuracy in our calculations is improved overall.

Acknowledgments

The author would like to thank the members of Madison Area Science and Technology for their discussions of Mathematica programming and various applications.

References

About the Author

Christopher Winfield holds a Ph.D. in mathematics/real analysis from UCLA (1996) and an M.S. in physics from UW-Madison (1989). He has publications in partial differential equations, quantum scattering theory, and cosmology/Einstein’s equation. He currently works as a consultant with the Madison Area Science and Technology group based in Madison, Wisconsin.

Christopher Winfield
3783 US Hwy. 45
Conover, WI 54519
cjwinfield@madscitech.org

Probability of Winning the Game

We assume that the probability of winning a single round of this game is , which is usually close, but not necessarily equal, to . Thus, for example, when betting $1 on black in the game of roulette, with 18 black, 18 red, and 1 green, all with equally likely outcomes, is equal to . We also assume that our player and his adversary start with dollars and dollars, respectively, and that they are both determined to continue playing until one of them goes broke.

Our first objective is to find the probability that our player wins the game, ending up with dollars. To do this, we have to imagine that the game has been going on for some time, and the player has reached the point of having exactly dollars in his pocket, so that his opponent has . Given that, we denote our player’s probability of winning the game by . If one more round is played, one can see that

(1)

depending on whether the player wins (the first term) or loses (the second one) the next round [1]. The end conditions are (the game is already won) and (the game is lost). We thus have linear equations for the corresponding probabilities, where . The equations are of a rather special type, as each of them involves only three consecutive values of , so rather than using the usual LinearSolve procedure, it is more appropriate to switch to RSolve.

When , the solution is indeterminate, but we get the correct answer in the limit.

All we have to do now is to evaluate using . To this end, we build the following function.

We apply the function to the cases discussed so far.

From these examples we can see that when both players start with the same amount of money and the coin is fair, each of them can win with the same probability of 50%. But as soon as the coin is slightly biased, the probability of the disadvantaged player winning decreases; this disparity becomes more pronounced as the initial capital of both players increases.

In practice, things are even worse than that: the casino starts with practically unlimited resources, which implies that a disadvantaged player does not stand any chance of winning whenever . Should be slightly higher than though, his chances to continue winning indefinitely are computed by taking the limit of as , resulting in

(2)

Distribution of the Game’s Duration

To find the distribution of the random number of rounds it takes to complete a game with two players, each with finite resources, given that currently the first player has dollars in his pocket, we introduce the corresponding probability generating function . Similarly to how we solved for , we can now set up the equations

(3)

where the multiplication by is necessary to account for the extra round played. We also know that (a probability generating function of 1 indicates that there are no more rounds to be played).

We now solve these equations.

Substituting for yields the corresponding result.

Using this function, we can now easily find and display the corresponding distribution of the game’s duration.

One can see that these games can easily last hundreds of rounds (things get worse when approaches ).

Sometimes it is sufficient to know only the mean and variance of this distribution.

The correctness of these formulas can be verified by recalling that the mean of a distribution is given by evaluated at , and its variance similarly by .

The two formulas can be extended to the case of by taking the corresponding limit.

These impose the following.

The Case of an Infinitely Rich Adversary

By analyzing the local variables and in the definition of , we can see that and , for any . As , we thus get

(4)

When , the probability that the game finishes in finite time is , according to (2). The conditional probability generating function of the total number of rounds, given that the game does not continue indefinitely, is thus

(5)

The more interesting case is when , which implies that the game cannot continue indefinitely. Expanding (4) in powers of would enable us to plot the corresponding distribution, as was done at the beginning of this section; we leave this as an exercise. Here is the mean and variance of the total number of rounds.

Brownian Motion

In this last section, we explore yet another interesting limit of the gambler’s ruin problem. First we assume that the game is happening in “real time” and that rounds are played during each hour (or any other unit of time). We also assume that

(6)

where and are two constants, and that dollars are bet in each round instead of the original $1. In the limit as , this results in a new process called Brownian motion that runs in real (i.e. continuous) time and whose values constitute a continuous, even though nowhere differentiable, function of [2].

To visualize its possible course, we take , 2, and and display a random realization of the process; that is, we display its current values—the amount of money in the gambler’s pocket—as a function of during the next 50 hours, taking the initial value to be $100.

Assuming the gambler can borrow money and continue playing even when the value of the process (his current worth) is negative, it is easy to see that this value at time is a normally distributed random variable with mean and variance , where is the initial value, and and (introduced earlier) are the so-called drift and diffusion coefficients, respectively. This assertion can be proved by realizing that the moment-generating function of the net win (equal to 1 with probability and to with probability ) in one round of the original game is . To adjust this to the new game (winning or losing dollars, instead of $1), replace each of the last expression by . To get the moment-generating function of the total win (or loss, when negative) accumulated during a time interval of length , we have to add the results of independent rounds, which corresponds to raising to the power of . Finally, we need to take the limit as .

This is the moment-generating function of a normal distribution with expected value (the exponent’s coefficient of ) and variance of (the coefficient of ). Since it represents only the total net winnings up to time , we have to add the initial value of to get the distribution of the gambler’s net worth at time ; this will increase the expected value to .

Inverse Gaussian Distribution

We now establish the distribution of , the first passage time through the value of zero, which is the time at which the gambler has to stop playing, since he has lost all his money. We assume that he starts with the amount and that ; reaching the value of zero in finite time is thus guaranteed.

We proceed similarly to deriving the distribution of his net worth: we first find the moment-generating function of in terms of the old game, with rounds played every hour, and then take the limit as .

To get the moment-generating function of the number of rounds of the old game needed to go broke, we simply replace in (4) by , and by , the initial amount expressed in the new monetary units. To convert the result into hours, each consisting of rounds, we need to replace by .

The resulting moment-generating function can be rewritten in the following simple form, using only two parameters: and (since , both are positive):

(7)

The corresponding probability density function is

(8)

for and otherwise. To prove this, we compute the moment-generating function of (8), which agrees with (7).

The corresponding distribution is called the inverse Gaussian; it has mean and variance .

Its distribution function of cumulative probabilities can be expressed in terms of the distribution function of the standard normal distribution (denoted ) as:

(9)

We verify this, getting an expression that agrees with (8).

Applying the inverse Gaussian distribution to our previous example (, , and ), we now display the distribution of time it takes the corresponding Brownian motion to reach zero for the first time.

One last issue: to find the probability density function of when , we need to take the limit of (8) as .

This distribution has an infinite mean and variance.

Conclusion

The study of first passage times and their distributions is an important area of research. The author hopes that this article has provided a useful introduction to the topic.

References

About the Author

Jan Vrbik
Department of Mathematics, Brock University
500 Glenridge Ave., St. Catharines
Ontario, Canada, L2S 3A1
jvrbik@brocku.ca

Introduction

Using the built-in Mathematica command NDSolve to solve partial differential equations is very simple to do, but it can hide what is really going on. You can always consult references about using Mathematica for differential equations [1, 2]. Exploring various programming methods also lets you create your own procedures that can be incorporated into NDSolve [1]. I chose the diffusion equation as the main example because there is so much material available for it and because of its high level of interest [3, 4, 5]. In this article I am using Mathematica 8.

Begin with a model of diffusion, in this case, the diffusion equation. The continuity equation is

where is the density, is time, and is the component of velocity. We can assume the rate of diffusion is constant and write the diffusion equation,

(1)

For complete generality, we can write

where is a positive-definite matrix of diffusion coefficients that may or may not depend on position and time; this is the diffusion tensor.

Building Up Your Program Idea in Small Steps

First, try built-in functions to see if they can solve your problem right away. The plan here is to use DSolve and then, when it likely fails to solve the PDE, try NDSolve. We are solving for a ring, so we will use only one spatial dimension. We begin by writing our diffusion equation.

Now we try DSolve.

DSolve is unable to reach a solution to the naively formulated problem. We next provide a set of initial conditions.

We incorporate the initial value and try again.

Again it fails; we could play with the initial conditions until we found a set that worked, or we could try NDSolve. Let us say that we want to investigate the diffusion in a tube of gas. We consider this tube to be one dimensional to keep things simple. We assume our ring has a fixed length 1. We then “unwrap” the ring, making it a line, which lets us plot results. We will solve the equation for 10 units of time. We also specify the rate of diffusion.

Let us try changing the initial density value to 0.

We put all of these elements together into NDSolve and get a solution in the form of an interpolating function.

We can plot this function.

Figure 1. Solution to the diffusion equation with initial density of 0 in empty space.

Let us try another initial value, say a sinusoidal density wave.

Now we try a solution.

We can plot this.

Figure 2. Solution to the diffusion equation with initial density based on a sine function. We have not determined the rate of diffusion.

This does not seem realistic, as the density drops to zero immediately. Now we need to determine what is, say 1.

Here is the plot.

Figure 3. Solution to the diffusion equation with sinusoidal boundary conditions.

This seems more realistic than Figure 2, but the boundary conditions do not match up. If we think of this as a circle (wrapping the line to form a ring), we suddenly get a discontinuity when we go from to . We can repair our ring solution by using periodic boundary conditions.

We are forcing an initial uniform density of 1, despite the sinusoidal boundary conditions in time, which would give us values of 0 density at the origin, and we do not want that. We get the solution, along with a warning message about inconsistent boundary and initial value conditions. Please ignore that in this case.

We can plot this.

Figure 4. A fairly good model of diffusion on a ring with sinusoidal boundary conditions.

This looks reasonable. The boundary conditions are now periodic, as on a ring. How do we write a program to do this?

Procedural Programming of Diffusion

Those of you who have programmed in languages like FORTRAN, C++, or Java are familiar with the idea of procedural programming. Procedures are executed in looping structures. We implement a finite-difference scheme to solve our equation. NDSolve is able to use finite differences as a specific method [1].

Begin by converting the diffusion equation to its finite-difference equivalent,

(2)

Here a ring is divided into cells for time steps. Specify a given cell’s density by considering the cell for the time step. So extends from 0 to , and time extends from 0 to . For any specific time step,

The stability condition [2] is

(3)

If this ratio is greater than 1/2, the solution becomes unstable in time. Write

(4)

If 0 is some set of initial conditions for , in the next time step we can use this equation to get a set of values for . We can then relabel these as the new 0 values and continue the calculation. We have to establish the initial conditions and use the procedural iterator to produce this result.

Choose this for positions 0 to 6.

We then develop the current time step as the initial conditions. This specifies the part of the list considered, using .

Here are the periodic boundary conditions.

This completes the initialization step, establishing the initial conditions.

We now construct a single time step by rewriting to include the boundary conditions, using .

We test this.

Define a time step, again using Table to generate the list.

We check this.

We now construct the solution in time, using Table.

This completes the model development.

Now we need to display the results. I make a test called run1.

Here is the plot of these results.

Figure 5. A jumbled mess of a solution for diffusion, not much like Figure 4.

This distorts and gets noisy very fast; of course we violated the stability condition with our choice of , so let us try it again. We know from (3) that . We need to reinitialize 0.

Then we construct run using the correct value for .

This produces the result.

Figure 6. A better solution that looks like Figure 4.

That looks better. This looks like the result we got from NDSolve, with some extra noise. We could use a finer grid and a better difference scheme if we wanted to get more precise and accurate. That is, however, the subject for another article.

Functional Programming

Another style of programming uses as the application of to . So we start by establishing a function in the traditional way, using . Here we use the notation # to represent a formal argument.

We could write this in short form without the word Function, but then we need an ampersand following the function statement so that Mathematica knows that the function statement is complete.

We write #1 and #2 for two arguments.

Or again we can write this in short form.

We can apply a function to each element of a list by the use of the command.

We could also use the short form .

This is equivalent.

Say we want to program the diffusion equation using functional programming. We begin by defining the list of cells in the ring. We use to produce a list from 1 to .

We decide we want to go from 1 to 6.

We now define the initial conditions.

For our choice of initial conditions, we have 1 everywhere, so we just say to divide by itself at each location.

Now we specify the diffusion equation. Since we have periodic boundary conditions and a list, we can just rotate the list right and left.

We can test this. First, clear the procedural definition of from the previous section.

We now need to impose our boundary conditions. Here we are replacing the end parts with the boundary conditions, using .

We will test these.

So we construct a single step.

Let us try it.

We can construct a table to produce the result.

We can try this.

We can plot this result.

Figure 7. Another solution that looks like Figure 4.

We have obtained the same result as with procedural programming.

Rule-Based Programming and Pattern-Matching

Another style of programming uses the symbolic nature of Mathematica to transform expressions. Rule-based programming uses the notion of transformation rules, which rewrite expressions based on their form. Take the expression and apply a transformation rule to it.

Here is a more complicated example.

Coming back to the diffusion equation, we begin with the initial conditions.

Then we execute it.

Then we have the diffusion equation. Here the double underscore __ following the 0 signifies a list.

For our example, define t1.

Define the boundary conditions.

Test this for the first time step.

We can test this again.

We need to include an intermediate function that specifies the values for our model for the FoldList command.

We can then produce our model runt1.

We can plot this.

Figure 8. Yet another solution that looks like Figure 4.

Scoping Constructs

A scoping construct makes symbols local so that they do not create or redefine global values. We can make local object names using the command . We can temporarily assign values to variables with the command . I will demonstrate the use of the Module command.

We can build a module for what we have been doing.

We can run this and plot the result.

Figure 9. Yet again another solution that looks like Figure 4.

Conclusion

We have seen that we can apply the canonical programming paradigms of Mathematica to the problem of diffusion. I have only scratched the surface of the diffusion problem. The methods I have presented could easily form the template for new methods for NDSolve, whose implementation is documented [1]. This flexibility in being able to introduce new methods into the existing structure of a Mathematica function is extremely powerful. Of course, the most powerful programming methods merge the paradigms.

References

About the Author

George Hrabovsky is the president and founder of Madison Area Science and Technology, a nonprofit scientific research and education organization. He has been a Mathematica user and programmer for more than 20 years. He does research into theoretical physics, atmospheric science, and computational physics.

George E. Hrabovsky
105 Alhambra Place #2
Madison, WI 53713
george@madscitech.org

Background

Perimetric complexity is a measure of the complexity of binary pictures. It is defined as the sum of inside and outside perimeters of the foreground, squared, divided by the foreground area, divided by . The concept of perimetric complexity was first introduced (and called dispersion) by Attneave and Arnoult [1] in an effort to explain the apparent perceptual complexity of visual shapes. In the field of image processing, the concept appears as its inverse, compactness [2, 3, 4]. The concept was given new life (and a new name) in 2006 by Pelli et al., who showed that the efficiency of letter identification was nearly proportional to perimetric complexity [5]. It has since become a popular metric in a variety of shape analysis applications, including human letter identification [5, 6, 7], handwriting recognition [8], evolution of graphical symbols [9], and design of graphical anti-spam technologies [10, 11, 12].

In this article we develop Mathematica functions to compute perimetric complexity of binary digital images and illustrate their application. The code is compatible with Version 8 of Mathematica.

Although the concept of perimetric complexity is clear when applied to continuous plane shapes, complications arise when the concept is extended to binary digital images. We discuss these complications and suggest suitable solutions. We also introduce the concept of visual perimetric complexity, which takes into account the blurring action of the human visual system.

We begin by illustrating the application of the function PerimetricComplexity to a binary image.

The output is a list containing the perimeter (in pixels), the area (in square pixels), and the complexity. In the following sections we describe the derivation of this function, as well as the options that may be used to control its operation.

Perimetric Complexity of Geometric Shapes

Perimetric complexity is a measure of the complexity of binary pictures. In a binary picture, one or several regions of the same color (white) are defined as foreground, and the remainder (black) as background. Perimetric complexity is defined here as the sum of the inside and outside perimeters of the foreground , squared, divided by the foreground area , divided by :

(1)

In the remainder of this article, unless otherwise noted, we use the term complexity as synonymous with perimetric complexity.

We begin with the example of a circular disk with unit radius.

Here the perimeter is and the area is , so the complexity is

(2)

It can be shown that the disk is the shape with the lowest complexity. The normalizing constant in the definition leads to a unit value for this most simple shape. As a consequence, any other value of complexity is easily compared to that of the circular disk. Pelli et al. [5] suggest that complexity is closely related to the number of visual features in a shape. In that sense, we could say that the circular disk has only a single feature.

Our next example is a square with unit sides.

The perimeter here is 4, and the area is 1, so the perimetric complexity is

(3)

If we add a square hole in the center with side length 1/2, there is an interior perimeter as well, as shown here.

Now the total perimeter is the sum of inner and outer perimeters and the area is the difference in areas of the squares, so

(4)

So according to this measure, the square with a hole is about three times as complex as the square.

Some important observations about complexity are: (1) it is dimensionless; (2) it is independent of scale or orientation; and (3) it is additive. By additive we mean that the complexity of a pair of shapes, considered as a single shape, is equal to the sum of their complexities computed separately.

Perimetric Complexity of Plane Curves

Although it is beyond the scope of this article, we note for reference that if a shape is defined by a closed parametric curve, its exact complexity can be obtained using calculus methods [13]. Specifically, if over an interval the functions and and their derivatives and are continuous, then the curve described has a length

(5)

and an area

(6)

Perimetric Complexity of Binary Digital Images

A digital image is defined here as a rectangular array of square pixels. A binary digital image contains pixel values of 1 (white) and 0 (black) only. The foreground consists of the white pixels.

The original definition of complexity relies upon the notion of a perimeter, which has no unique analog in the context of digital images. However, two definitions of perimeter are available, as described below.

Using “PerimeterLength”

The first definition we consider is the most straightforward. Consider a binary image consisting of a single white pixel.

It seems natural to define the perimeter of this shape as 4 (pixels), and the area as 1 (), so , the same as the square discussed earlier.

Now consider this shape consisting of 3 white pixels.

Here the perimeter, consisting of the exposed pixel faces, is 8, and the area is 3, so .

Extending this idea, we can define the perimeter as the sum of the exposed faces of pixels in the foreground.

Version 8 of Mathematica includes a set of functions from the discipline of mathematical morphology. These can be used to easily calculate perimetric complexity. To illustrate this we begin with a binary image with several separated parts.

The MorphologicalComponents function finds connected regions and labels them with integers. The Colorize function visualizes these regions by assigning colors to each label. The option ensures that only 4-connected neighborhoods are considered.

The ComponentMeasurements function returns a selected set of measurements about each region. In this case we are interested in the area and the perimeter length. The results are returned as a set of rules, showing the results for each region.

We can combine the perimeters and areas of the several regions, and then compute complexity in the usual way.

The preceding calculations are implemented in the function PerimetricComplexity, defined in the Appendix. We can obtain the previous result.

A list is returned, containing the perimeter, the area, and the complexity. The option ensures that we use the definition of perimeter described above. The option is explained later.

For future reference, to distinguish it from variants that we consider, we call this the “raw” perimetric complexity. Thus the same result can be obtained with the option .

Using “PolygonalLength”

The second definition of the perimeter of a connected region in a binary digital image is to consider the perimeter pixel centers as points on a lattice, and to define the length as the sum of the sides of the polygon defined by those points. This estimate of the perimeter is obtained from ComponentMeasurements by using the measurement "PolygonalLength".

Note that the measures of perimeter length are smaller than before.

And again complexity can be easily computed.

This variant of perimetric complexity is implemented with the following options.

Or, since is the default, the input can be simplified.

Approximating Complexity of Continuous Shapes

We introduced the concept of perimetric complexity with a few continuous shapes, such as a square and a circle. In these cases, complexity is easily calculated, because we have simple formulas for the area and perimeter. It might be imagined that complexity of the continuous shape could be approximated by computing the complexity of a discrete sampled image, rendered from the shape. As we shall see, this assumption is not strictly correct.

Consider the circular disk. As noted at the beginning, it has .

We set the foreground color to white, as is our convention. Now we consider an image rendered from the continuous shape. We render it into a certain size image.

If we compute the complexity, we find that it is 62% too large relative to the continuous shape.

The reason is that the sampled image is actually more complex than the continuous shape. Its contour is jagged, while that of the continuous shape is smooth. It might be imagined that this could be remedied by increasing the resolution of the rendering. Here we show that belief is misplaced. We render at several sizes and plot the results. Size has little effect, and the complexity never approaches the value of 1 corresponding to the continuous shape.

This problem can be somewhat ameliorated by using the PolygonalLength measure of perimeter length. Rather than the pure approach of measuring the exposed face of each foreground pixel, this measures the length of the contour that travels between the centers of those pixels.

Now the difference is reduced to 9%. Here again, the reader might think that this difference could be reduced to zero by enlarging the resolution (number of pixels) in the rendered image, but this is not so. We leave that as an exercise for the reader. The error can never be zero, because the path between pixel centers must always be vertical, horizontal, or diagonal, so it can never smoothly follow the true circular contour. Put another way, it has a higher fractal dimension than the circle, and thus greater length.

Pelli Algorithm

Pelli et al. [2] proposed a method for computing complexity that we quote here in full:

This method can be implemented using the Dilation function, as we show here. With , it shows two images: the perimeter in red and the thickened perimeter. It returns the length of the perimeter, the area, and the complexity.

We apply this to the three-component Chinese character.

The raw method gives the following.

We see that the perimeter is substantially underestimated by the Pelli method in this case. This method has other limitations. It effectively assumes regions that are large in pixel dimensions. For example, consider the case of a single pixel object. As noted above, it has . But the Pelli method yields a complexity value more than three times too large.

Visual Perimetric Complexity

Much of the motivation for the use of perimetric complexity is the hope that it might provide an approximate measure of the visually perceived complexity of shapes. But this only makes sense if the shape is actually visible. Consider the difference between the continuous circular disk and its sampled image, as discussed above. They have different perimetric complexities, no matter how high the resolution of the sampled version. But of course, at a certain viewing distance, they are indistinguishable.

Filtering

Here we propose an approach to dealing with this problem. The idea is to first blur the image, in a manner consistent with visual blur, and then compute perimetric complexity. To make things simple, we use Gaussian blur, although this is not an accurate description of human visual blur. Later we show a more accurate form of blur. We begin with the example of a Chinese character jun ().

We pad the image slightly, so that the blur is contained, and then magnify, to allow greater flexibility in the filtering. Then we blur the image, in this case by a Gaussian filter with a radius of 8 pixels.

Then we binarize the image. Unfortunately, this requires some method of setting the threshold. Here we use a fixed threshold of 0.5. We use ImageAdjust to ensure that the filtered image is amplified to fill the grayscale range before thresholding.

And because we imagine that the image is viewed at such a distance that the pixels are not resolved, we use the (default) PolygonalLength method.

We can compare this to the unfiltered raw complexity.

The filtered version has substantially lower complexity, as we expect.

Visual Filtering Using a Gaussian

For the filtering to approximate visual blur, it must be based on the size of the original image and its distance from the viewer. Obviously, as the shape becomes smaller or farther from the observer, its details are more blurred, less visible, and contribute less to the visual complexity.

The challenge is to determine the appropriate value of the Gaussian filter radius for a given viewing distance. From measurements of visual sensitivity, we know that visual Gaussian blur has a standard deviation of about degrees of visual angle [11]. But we need to convert this into a radius in pixels. Recall that the image may be magnified by before filtering. If we express the viewing distance in terms of pixels (before magnification), then the size of each pixel (after magnification) is approximately

(7)

The constant 57.3 is an approximation to .

By default, the radius is twice the standard deviation. So the filter radius should be

(8)

Consider an example. Suppose that our Chinese character image is displayed on a typical computer screen with a resolution of 72 pixels/inch, and viewed at a distance of 48 inches.

Recall the value of B.

Suppose further that the magnification is 4.

Then we know R.

We now proceed with the steps outlined above for filtering.

The preceding steps of padding, magnification, and filtering are built into the function PerimetricComplexity, as shown below. With , the function also shows the original, the filtered version, the binarized version, and the original (in red) with the perimeter of the filtered version (in white within the original and aqua outside the original).

The Gaussian is parameterized by a scale in degrees of visual angle. The default value is 2.33/60 degrees. The user can experiment with different values via the option GaussianScale.

Accurate Visual Filtering with Sech

Visual blur is more accurately represented with filters other than a Gaussian. In one simple form, the kernel is a sech (hyperbolic secant) function [14, 15]. This filter can be selected with an option (, the default) in the function PerimetricComplexity.

The hyperbolic secant is parameterized by a scale in degrees of visual angle. The default value is 2.16/60 degrees [14, 15]. The user can experiment with different values via the option SechScale.

Accurate Visual Filtering with an Arbitrary Point Spread Function

In real human eyes, blur results not only from low-order aberrations such as defocus and astigmatism, but also from higher-order aberrations. In this example, we use a blur function defined by an array of values representing the filter kernel. This example is an actual estimate of the point spread function for an individual human observer, as measured using a device called a wavefront aberrometer that includes both low-order and high-order aberrations [16].

We can use this blur kernel by supplying it directly to the Filter option.

In the above calculation we used a magnification of 2. We do not address this topic in detail, but when a kernel is supplied, the pixels of the kernel and of the magnified image must be of the same size, in degrees of visual angle, for the filter to be accurate. The size of the magnified pixels in degrees depends upon the viewing distance and the magnification, as described above.

Magnification Parameter

The Magnification parameter should be set with a value that ensures that a filter kernel, if present, has enough pixels in it to adequately represent the filter. For the Sech filter, we generally want a width of least three times the scale, and at least 8 pixels. This means that for the magnification,

(9)

This rule is effectively implemented by the default option.

Binarization

After applying visual blur, it is necessary to binarize the image before calculating the perimetric complexity. There are many ways to binarize an image and Mathematica offers many of them as options. The simplest is to use a fixed threshold. Since our images are initially defined as 0 or 1, a natural choice of threshold is 0.5. One drawback of this choice is that as images become severely blurred, no pixels may remain that exceed the threshold. From a perceptual point of view, the mean might appear a reasonable choice. As the image blurs, all pixels revert towards the mean, but some always remain above the mean until a uniform image is reached. A drawback of the mean is that it is influenced by the area of the background. For this reason, we adopt the fixed value of 0.5 as the default threshold for binarization.

We should acknowledge that a more valid visual thresholding scheme might be devised that better reflects our perceptual segregation of areas into light and dark. This is a topic for future research.

It should also be acknowledged that for severely blurred images, considerable grayscale information remains that is lost in binarization. Thus we should question whether perimetric complexity is an appropriate measure for such images.

To illustrate that problem, we show an example of a character viewed at 10 feet on a display with 100 pixels/inch. Note that the blurred image displays internal grayscale structure that is not conveyed by the binarized version.

Viewing Distance

For a given shape, complexity declines with viewing distance as a result of visual blur. Here we illustrate this effect with an example Chinese character. First we find the raw complexity.

Now we compute complexity for viewing distances ranging from 3 inches to 10 feet, assuming a display with a resolution of 100 pixels/inch. For reference, we show as red lines the raw complexity and the theoretical limit of 1 (a circular disk). As it should, the visual complexity proceeds from one of these limits to the other as distance increases.

At very small viewing distances (in pixels) the blur has little effect on each pixel, so the visual complexity approaches the raw value. As a rule of thumb, this asymptote is approached when the size of each pixel exceeds 1/4 degree.

It is reassuring to know that the algorithm does approach the correct asymptote as distance increases. Here we show the intermediate images for a case of extreme blur (distance = 30 feet).

But a note of caution is warranted. Consider the effect of distance on our other example character yi (). We show it here along with the previous plot. Note that the curves cross, so that at large distances (large blurs) the “simpler” character becomes the more complex of the two.

This makes sense, since the densely packed features of the “complex” character blur onto each other, while the more widely separated features of the “simple” character remain distinct. This is illustrated in the following, which shows the intermediate images for the two characters when highly blurred (distance = 10 feet).

But the conclusion we must draw is that even the relative complexity of different shapes cannot be known without specifying the viewing distance.

We use the quantity as a default value. This corresponds to a visual resolution of 48 pixels/degree. It is a commonly encountered resolution, about that achieved by a display with 100 pixels/inch viewed from 27 inches. But in actual use, it is advised to use the actual viewing distance rather than relying on this default.

Here is a Manipulate that lets you experiment with different viewing distances. The complexity and the diagnostic images are shown.

Recommended Practice

In general, we recommend using the function with default parameters, shown here as a reminder.

The only option that should be specified for the typical use of this function is ViewingDistance. This specifies the distance from the eye to the image in pixels. The default is , consistent with a display having 96 pixels/inch viewed at 28.65 inches (equal to a display with 48 pixels/degree of visual angle).

It is difficult to imagine a case in which vision, in some form, would not be used to view the shape in question. If such a case arises, however, the “raw” complexity can be measured with the following options.

This is also an appropriate measure when the pixels are very large (larger than 1/4 degree).

When trying to approximate the raw complexity of a continuous shape by means of a sampled representation (e.g., a circle via an image of a circle), the following options yield the lowest error. But as noted above, the error is still significant.

Examples

We conclude with two examples of the application of PerimetricComplexity.

The first example is a set of three binary images. Below each image we print the complexity.

The second example is an array of characters. This array was created as part of an experiment on the effect of complexity on visual acuity [6]. The first row is the Sloan letters, a well-known set of letter acuity targets [5]. The remaining six rows are sets of Chinese characters selected so as to be of equal complexity within a row, but increasing in complexity from row to row [6]. The metric of complexity used for selection was different from that developed in this article.

We first apply the function to each character and plot the results, with a different curve for each set.

The plot shows that there is considerable variation in each set. If we take the mean of each set we see a progression in complexity, except for the last three sets. In the next graphic we show at the bottom an exemplar from each set.

Conclusion

We have illustrated several different methods for computing the perimetric complexity of binary digital images. These methods differ in how they compute the perimeter and in whether the image is blurred and binarized before the complexity calculation. We have introduced the concept of visual perimetric complexity and argued that in general it requires blur for a sensible estimate. We have described several methods of implementing visual blur.

The computed value of visual perimetric complexity depends somewhat upon details of the calculation, such as the presumed magnitude and nature of visual blur, and the binarization threshold. In this regard, we have proposed a set of standard default settings and procedures for calculation of visual perimetric complexity.

We have also made the observation that visual perimetric complexity cannot be estimated without specifying the resolution of the display and the viewing distance. As a general rule, the visual perimetric complexity approaches the raw complexity when the width of a pixel exceeds 1/4 degree of visual angle.

Appendix

Functions

Here we define several functions based on the derivations presented above.

PerimetricComplexity

Here is an example.

PerimeterLength

Here is an example.

PixelPathLength

Here is an example.

PixelBorderLength

Here is an example.

SechKernel2D

Here is an example.

Perimeter

Initializations

The next closed cell contains the definition of psf, a 64×64 array of numbers.

psf

characters

Computing Complexity without Using Mathematica’s Morphological Operators

Some readers may wish to write programs in other languages to compute complexity. For that reason we provide an explanation here of how to compute complexity without using 3×3 morphological operators. This amounts to finding alternate methods for computing the perimeter. These are incorporated in the function PerimeterLength, defined above, and derived below. These functions can be exercised from within PerimetricComplexity by selecting the option . This is useful mainly for testing.

Consider the following binary image.

The foreground area is easily obtained, since it is just the sum of all the white pixels.

Using “PerimeterLength”

As noted above, there are two definitions of the perimeter of a binary digital image. The first consists of the sum of the exposed pixel faces. To count the exposed faces we use the function PixelBorderLength. This takes a binary image of dimensions and counts the number of black 4-connected neighbors of the center pixel.

Here is an example.

In this example, the center pixel has only two black neighboring pixels.

The total perimeter can be obtained by applying this function to the neighborhood of every white pixel in the image. Pixels in the interior return a value of 0, so only perimeter pixels contribute.

To implement this idea, we first identify the positions of all the white pixels.

Next we extract all the neighborhoods.

We can look at the first five.

We can also compute the pixel border length of the first five.

In a large complex image, the same neighborhood might occur many times, so we perform a tally.

We can take a look at the tally along with the pixel border length for each type of neighborhood. Note that 850 cases consist of all white, drawn from the interior of the foreground, with 0 border length. Here we just look at the first 10 elements of the tally.

The total perimeter length is the sum of all of the border lengths for all the collected neighborhoods. We use the tallied neighborhoods, so that the pixel border length of each type of neighborhood is computed only once.

This is the complexity.

Using “PolygonalLength”

The second definition of the length of the perimeter is the sum of sides of the polygon defined by the perimeter pixels considered as points in a lattice.

To extract the perimeter, we use a new function Perimeter, defined above. This duplicates a built-in Mathematica function. We verify that they yield the same results.

We identify the positions of all of the pixels in the perimeter.

We extract all of the 3×3 neighborhoods of pixels in the perimeter.

Then we use a new function PixelPathLength, which looks at a 3×3 binary neighborhood, identifies the two closest white pixels not at the center, and finds the distances from their centers to that of the central pixel. That is the path length corresponding to that neighborhood.

We apply this to all the perimeter pixels and add up the results.

We can verify this is the same perimeter length obtained from PerimetricComplexity using Mathematica’s morphological operators.

Acknowledgments

I thank and blame Denis Pelli for introducing me to perimetric complexity [5]. I thank Dr. Cong Yu for providing the Chinese character optotypes [6]. I thank Albert Ahumada and Jeffrey Mulligan for useful discussions. I thank Larry Thibos for providing the wavefront data [16]. This work was supported by NASA Space Human Factors Engineering WBS 466199.

References

About the Author

Andrew B. Watson is the Senior Scientist for Vision Research at NASA. He is editor-in-chief of the Journal of Vision (journalofvision.org). He is the author of over 150 scientific papers and four patents. He is a Fellow of the Optical Society of America, the Association for Research in Vision and Ophthalmology, and the Society for Information Display.

Andrew B. Watson
MS 262-2
NASA Ames Research Center
Moffett Field, CA 94035
andrew.b.watson@nasa.gov

Quaternion Algebra

A quaternion is a four-dimensional quantity consisting of a scalar, say , and a three-dimensional vector , collectively denoted . Addition of two quaternions is component-wise,

(1)

(we do not need to add quaternions in this article). Their multiplication follows the rule

(2)

It is important to note that such multiplication is associative (even though noncommutative). This can be verified by the following.

When the scalar part of a quaternion is zero, it is called a pure quaternion. Since this constitutes an important special case, we will extend our definition of multiplication accordingly.

The operation of conjugation simply changes the sign of the vector part of a quaternion.

Based on the corresponding Taylor expansion, it is possible to evaluate various functions of a quaternion. Of these, the most important is the exponential function, which, in this article, we need only with pure-quaternion arguments.

Rotation

Rotating a 3D vector with respect to an axis through the origin (with a unit direction of ) by an angle can be achieved by

(3)

where (a vector of length and unit direction ), and and are the parallel and perpendicular (to ) parts of , respectively [1]. Note that and commute, while and anticommute.

One can show that a quaternion has the form of if and only if (a pure scalar). Alternately, the same can be parametrized by the three Euler angles (see the next section).

By taking , where is time, we achieve constant rotation with an uniform angular velocity . Note that

(4)

where , and denotes its time derivative.

The previous formula can be generalized to any time-dependent , as can be seen by differentiating , thus

(5)

where is now the instantaneous angular velocity at time , which may change with time. Note that must be a pure quaternion (take the time derivative of to see that). Now, any rotation can be applied to the axes of the original (inertial) system of coordinates, thus creating the corresponding new, rotating (noninertial) frame. Components of any vector can then be expressed in either the old, or (often and more conveniently) the new coordinates; the latter will be given by . The angular velocity , in the new coordinates, will thus have components given by . This becomes an important and helpful tool: even though the laws of physics are normally valid only in inertial coordinates, the resulting equations often simplify when expressed in the rotating frame.

Spinning Top

Let us consider an axially symmetrical body (a “top”) of mass , and parallel and perpendicular (with respect to the body’s symmetry axis) moments of inertia equal to and , respectively. We make it spin around its axis, place the bottom tip of its (usually tilted) axis on a nonslip horizontal plane (a desk), and let it continue its motion subject to the vertical gravity field. Let us also assume that the top’s center of mass is at a distance from its point of contact, that the gravitational acceleration is , and that there is no friction.

To investigate the top’s motion, we introduce an inertial coordinate system with its origin at the point of contact and its direction pointing vertically upward. First we position a motionless top vertically (its symmetry axis aligned with the direction) on the desk’s surface. We then rotate it using a fully general, time-dependent rotation , parametrized by three Euler angles, thus

(6)

where is a rapidly increasing function of time that represents the actual spinning of the top around its symmetry axis (this rotation is applied first), followed by tilting the spinning top by an angle (potentially a slowly varying function of time) around the inertial direction, further followed by slowly rotating the spinning, tilted top around the inertial direction by an angle , thus creating a so-called precession. Also: , (not used in the last formula), and are unit vectors along the , , and directions, respectively, in their pure-quaternion form.

Equations of Motion

We now use the Lagrange technique to find the corresponding equations for the three Euler angles. The kinetic energy of the top equals one-half of the scalar product of its angular velocity with its angular momentum, as its motion is purely rotational. In the rotating frame (this is when it becomes handy), this equals

(7)

where , , are the rotating-frame coordinates of , and (denoted from now on; similarly, will be called ) is the top’s moment of inertia with respect to a line perpendicular to its symmetry axis, and passing through the origin (which is displaced by from its center of mass). Usually (a thin circular disk needs to be bigger than only one-half of its radius to meet this condition), but our results are valid when as well.

Subtracting the potential energy (by the definition of ) yields the resulting Lagrangian.

Since the result is free of and (it contains only their time derivatives), the corresponding and must be constants of motion [2]. The remaining equation is then obtained from

(8)

This yields the following.

The first two expressions are constants of motion, while the last one must be equal to zero.

Introducing a new variable by

(9)

the last three expressions simplify further. It is also important to realize that the transformation (9) replaces only the parameter (the speed of spinning); if we are interested in the behavior of and only (as is usually the case), we get the same solution regardless of whether we use (in the old set of equations) or (in the new one).

So, let us see what the new results look like.

The equations are now much simpler, and the number of parameters has been reduced from three to only one (namely , whose dimension is ).

We can now easily infer a possibility of what we call a “steady” solution, with a constant value of (say ) and

(10)

where and are two constants whose product must be equal to . To relate the precession speed to the actual spinning speed, say , we have to solve (based on (9))

(11)

for , which yields

(12)

where the negative sign corresponds to the usually observed “slow” precession (assuming, from now on, that ), whereas the positive sign yields a hard-to-achieve “fast” precession. When (spherically symmetrical top), we get only the “slow” solution . For a fast-spinning top, the previous formula yields, to a good approximation, ; the precession speed is practically independent of .

Approximate Solution

The actual motion is usually more complicated than a steady solution of the previous section, as may undergo periodic oscillations, called nutation. Assuming that the amplitude of these is small, we can expand the three dependent variables of our equations around the steady-state solution:

(13)

where the first term of each right-hand side is a constant, the second term remains time dependent, and is small. We substitute these into the three equations, neglecting and higher powers of .

Each of the three expressions must be equal to zero.

We solve the first two equations for and and substitute into the last equation.

Solving for (and, subsequently, for and ) is now quite easy. Note that the coefficient of in the last expression is always non-negative.

Also note that will be always positive (assuming “slow” precession), whenever the following condition is met:

(14)

Reversing the above inequality results in so-called looping orbits (in terms of the path of the axis, when displayed on a unit sphere: see below), with periodically changing direction; making the two sides of (14) equal to each other results in cuspidal orbits (when reaches its smallest value, becomes zero).

If desired, one can extend the approximate solution to achieve (and higher) accuracy.

Exact Solution

One can show that the original differential equation for , namely

(15)

has the following constant of motion.

This can be easily verified.

Making and equal to their initial values, we can solve for and and substitute these into (minus its initial value, so that the resulting expression must be equal to zero).

The resulting differential equation can be simplified by the transformation [3].

To simplify the subsequent solution, we have assumed (without loss of generality) that the initial time has been chosen to coincide with reaching its maximum value (and, consequently, ). The above equation can then be solved, using specific initial conditions, which must satisfy (due to (15), since ); here provides the solution for .

This can be easily transformed back to ; one can then find the corresponding and by analytically integrating the expressions for and (if desired) . Finally, the results can be displayed graphically.

One can now compute and display the top’s motion under various initial conditions, check the accuracy of the approximate solution, and so forth. We will leave it for you to explore. Have fun!

References

About the Author

Jan Vrbik
Department of Mathematics, Brock University
500 Glenridge Ave., St. Catharines
Ontario, Canada, L2S 3A1
jvrbik@brocku.ca

Introduction

Computational quantum chemistry makes extensive use of various integrals (and their derivatives) of the general form [1, 2, 3]

(1)

where is an unnormalized Cartesian Gaussian function centered at :

(2)

where is normally taken at the nucleus, is the orbital exponent, and the polynomial represents the angular part, in that the sum of the Cartesian angular momenta corresponds to functions of type , , , , …. When the operator is 1, one simply has the overlap/density integral; otherwise it can be the energy operator for kinetic energy , electron-nuclear attraction , or electron-electron repulsion (which would involve double integrals). Other molecular properties involving external fields (response functions) or transition moments can also be computed from integrals of this form.

Gaussian-Type Functions

Gaussian-type functions are not the most natural choice for expanding the wavefunction. Slater-type functions, where the exponent is instead, can describe atomic systems more realistically. However, complications quickly arise in molecular calculations, which has led to the use of Gaussian functions in the overwhelming majority of current computational programs. Gaussian functions possess several desirable computational properties [4, 5, 6]. (Much credit is due to S. F. Boys for the introduction of the Cartesian Gaussian function into computational chemistry and its early development in a series of 12 papers under the general title “Electronic Wavefunctions,” the first being [5].) A given Slater function can be approximated by a linear combination of several Gaussians.

The first useful property is that the product of two Gaussian functions located at and is another Gaussian located at a point somewhere between and . (The proof of this can be found in [4].) The product of two Gaussians and is:

(3)

with and .

A second desirable property is that a derivative of a Gaussian can be expressed as a sum of Gaussians of lower and higher Cartesian angular values.

Overlap Integrals

The simplest molecular integral is the overlap integral . We first separate the integral into its orthogonal components:

where the notation expresses its functional dependence on the Cartesian angular components. The component, for instance, is:

(4)

Using a binomial expansion in the polynomial part,

yields:

(5)

Odd values of result in odd functions whose integrals vanish. For even values of , a solution [7] for the integrals is given by , and, in those cases:

(6)

We keep in mind that for the summations only terms of even values of survive. We have thus obtained an expression to evaluate the overlap of two Gaussians with arbitrary Cartesian angular factors. Equation (6) should be sufficient for programming or even for manual evaluation with small Cartesian angular values. One can, however, further reduce the number of operations by using a recurrence relation, one of the most useful techniques of computational chemistry. Recurrence relations let us efficiently calculate molecular integrations of higher angular values using previously obtained results with lower angular values. Recurrence relations are used in most computational chemistry programs and their application to other molecular integrations will be shown here.

Recurrence Relations

The derivation of the following relations involves straightforward algebraic manipulations, but is rather lengthy. Its omission does not impede our understanding of the recurrence relation, but helps maintain a reasonable continuity in our discussion. Interested readers can find a detailed derivation in the Appendix.

We start by defining the function

where we have removed the factor from in (6). If we take the derivative of with respect to the nuclear coordinate using the definition of in equation (4),

(7)

and combining the result with the same derivative of , but using the definition of in equation (6) instead,

(8)

we obtain

(9)

The same approach in which we combine the derivatives of (4) and (6) with respect to the nuclear coordinate gives

(10)

For , we have the index recursion relation

(11)

and combining equations (7) and (8) yields the transfer equation

(12)

Starting with the initial values and , the recurrence relation and the transfer equation, we can build up the overlap of functions of higher Cartesian angular values from lower ones. This is particularly useful for contracted Gaussian basis primitives with different functions sharing the same exponent.

Implementation

The function Ov evaluates the overlap integral of two Gaussian functions; here alpha, beta, RA, RB, LA, and LB are , , , , , and as defined earlier.

Examples

The published contracted Gaussian basis sets (see, for example, [8]) are usually not normalized; in our first example, we will calculate the normalization factor of the and Cartesian Gaussian functions that we will need later on. The normalization factor is simply the inverse square root of the overlap integral. Here we calculate the overlap between two functions with the Cartesian angular vector ,

and observe that . The normalization factor for functions is . Similarly, the overlap between two functions () is

where we have analogously used the recurrence relations to obtain and afterward, . Similar results are obtained for and . The normalization factor for the function is then . These results are special cases of the more general formula of the normalization factor

and we note that this value depends only on the orbital exponent and the Cartesian angular values.

In the second example, we will calculate the overlap matrix of the water molecule (, , geometry optimized at the HF/STO-3G level). The molecule lies in the - plane with Cartesian coordinates in atomic units.

In the STO-3G basis set, each atomic orbital is described by a sum of three Gaussians; here are their primitive contraction coefficients and orbital exponents (taken from [8]).

Here are the centers and Cartesian angular values of the orbitals, in the following order: , , , , , , and .

For instance, the atomic orbital of the hydrogen atom 1 is described as

(13)

Similarly, the orbital of the oxygen atom is

(14)

The overlap integral between the two orbitals expands to nine integrals involving the primitives. Using the function Ov, for example, the overlap integral between the first two primitives of equations (13) and (14) is

And the overlap between and is

The overlap matrix for the entire water molecule in the STO-3G basis set can be calculated in a similar manner.

Since the overlap matrix is symmetrical, we need to calculate only the elements above the main diagonal. The basis functions are normalized, as indicated by the unit diagonal elements. We note that equals zero. This is the overlap between the orbital of the first hydrogen atom and the of the oxygen atom. The molecule lies in the - plane, so this overlap vanishes due to symmetry. Similar cases occur in the overlaps between the and orbitals of () and among the orbitals (), etc. The strongest overlaps are those between the hydrogen orbitals and the oxygen orbital.

We next plot the atomic-orbital overlap between of and of ,

in the - plane, superimposing the molecule structure.

We observe a strong distortion of the positive (lower) lobe of the function toward the hydrogen atom. The negative lobe shows less deformation, whereas the node remains precisely at the atomic position. Note that this is simply the orbital overlap between noninteracting atoms, such as in the case of the “promolecule.”

Conclusion

We have provided an introduction to the evaluation of molecular integrals involving Gaussian-type basis functions both analytically and by use of recurrence relations. The results are general and relatively straightforward; the simple algorithm makes it suitable for implementation in a number of programming languages. Together with the kinetic, nuclear-electron attraction, and electron-electron repulsion energies, this is the first step toward the calculation of molecular energies and electronic properties.

Appendix

Here we provide the derivation of equations (7) and (8). Differentiate using equation (5) with respect to :

Consider the derivative term

the first term is simply

and, using the chain rule, the derivative of the second term is

recalling that . Substitute the results into the expression for ,

Writing in the second term inside the bracket, after expanding we have

Comparing the three integrals with the definitions of and we have the desired equation (7).

To derive equation (8), we differentiate with respect to using equation (6) instead,

We make use of the relationship

to reduce the derivative above to

This is equation (8), which is what was needed to prove.

References

About the Authors

Minhhuy Hô received his Ph.D. in theoretical chemistry at Queen’s University, Kingston, Ontario, Canada in 1998. He is currently a professor at the Centro de Investigaciones Químicas at the Universidad Autónoma del Estado de Morelos in Cuernavaca, Morelos, México.

Julio-Manuel Hernández-Pérez obtained his Ph.D. at the Universidad Autónoma del Estado de Morelos in 2008. He has been a professor of chemistry at the Facultad de Ciencias Químicas at the Benemérita Universidad Autónoma de Puebla since 2010.

Minhhuy Hô
Universidad Autónoma del Estado de Morelos
Centro de Investigaciones Químicas
Ave. Universidad, No. 1001, Col. Chamilpa
Cuernavaca, Morelos, Mexico CP 92010
homh@uaem.mx

Julio-Manuel Hernández-Pérez
Benemérita Universidad Autónoma de Puebla
Facultad de Ciencias Químicas
Ciudad Universitaria, Col. San Manuel
Puebla, Puebla, Mexico CP 72570
jumahernandez@gmail.com

Introduction

This is my first column since Version 6 came out a few months ago. Version 6, after being in the works for many years, provides a wealth of new features that are useful in many numeric and symbolic calculations, advanced programs, visualizations, and elsewhere. With so many exciting new possibilities, it was not easy to decide what to discuss in this column. So instead of delving into a new subject, I think the best way to see some of the new features and resulting capabilities of Version 6 is to compare with some corresponding Version 5 results. That is why today I will come back to a subject discussed in earlier columns and demonstrate how to go quite a bit further with Version 6.

In earlier columns, I started discussing the visualization of Riemann surfaces. In this column, I want to come back to this mathematically (and aesthetically) beautiful subject. So far, we discussed the construction of Riemann surfaces of compositions of elementary functions with finitely many branch points (articles IIa to IId [1-4]). With the new 3D graphics system and interactive features of Version 6, new possibilities open up for visualizing Riemann surfaces; the main ones are:

• Specifying vertex normals to obtain smooth-looking surfaces
• Using opacity to get a better look “inside” a Riemann surface (instead of cutting holes in the polygons of the surface)
• Using adaptive refinement of the built-in graphics functions to better resolve branch points
• Using Manipulate to easily view a function as a 3D projection of the hypersurface (where showing and over the complex plane become special cases)
• Using the Exclusions option to avoid branch cuts in Plot3D, ParametricPlot3D, and others

These features offer a fresh look at the topic of Riemann surfaces (so, if numbered, this would be article IIdII, not yet IIe, which will appear later and deal with special functions).

Starting with this column, I will also introduce a formatting change: Mathematica’s default StandardForm is an ideal editing and reading environment for mathematical expressions and very small program snippets (one to two lines). Convenient automatic line breaking, two-dimensional fraction and radical formatting, and other features make writing and reading easy. But for multiline program-like code pieces, the formatted results are frequently less readable than manually formatting the code to avoid unexpected line breaks, alignments, and nonuniform line spacings. A new style in Version 6 (available as -8) is the "Code" style. It is the default style for packages (the canonical place to store a program) and can, of course, also be used in notebooks. It does not automatically break lines, but allows for special characters and inherits the new syntax coloring feature to maximize code readability. So, function definitions are given in "Code" style (easily identifiable in this notebook by its light blue background) and example uses of the defined functions will be in style "Input". In addition to an easier visual discrimination between actual definitions and example uses, this also allows for a quick selection of all definitions (using RIGHT) for immediate use without having to run all (sometimes time-consuming) examples to experiment with further Riemann surfaces.

The Updated Riemann Surface Package

We start with an updated version of the construction discussed in my earlier columns. Let us quickly recap the construction idea: Starting with a given function , a set of coupled nonlinear meromorphic differential equations is derived from and this set is solved on patches of the plane. These patches arise from a tensor product decomposition of the complex plane in a cylindrical coordinate system and are separated by branch points. The system of differential equations is solved numerically and the resulting function values are displayed. If at the same time we calculate , it is possible to construct the normals to obtain a smooth-looking surface. (Calculating the normals of the 3D embedding of can be done easily using the Cauchy-Riemann conditions.) An updated version of the package, based on the code from The Mathematica GuideBook for Numerics [5], is available on the Mathematica GuideBooks website (www.mathematicaguidebooks.org/V6/downloads/RiemannSurfacePlot3D.m).

This is the main function defined in the package.

The first example is displayed as over the complex plane.

The function has a few new options in addition to the built-in 3D graphics options.

Because 3D graphics in Version 6 are typically no longer made from individual polygons, but rather from GraphicsComplex objects that contain polygons and their adjacency information, it is possible to avoid the small gaps that were used in Version 5 between the patches. The function StitchPatches “stitches” the GraphicsComplex objects together along their boundaries. While in static images, the small (typically 1ppm or smaller) gaps are usually not visible; when interactively rotating graphics, such gaps can potentially become more pronounced.

Note that we do not have to specify a domain of the plane over which to plot the function. The domain is chosen automatically in such a way to include all finite branch points of the function.

Here is another example of a Riemann surface plotted with RiemannSurfacePlot3D.

In the next example, we display the imaginary part of over the complex plane and color the surface according to the real part.

Using a transparent surface makes it easier to see the inner parts of more complicated Riemann surfaces.

Here are some more examples.

RiemannSurfacePlot3D stores some intermediate time-consuming results for the function it has just plotted. As a result, once a function is plotted, calls to RiemannSurfacePlot3D with an identical first argument and mostly identical option settings, but a potentially different second argument, are generally quite fast.

Here is a demonstration that allows moving smoothly from the real to the imaginary part.

By parametrizing the three Cartesian coordinates as a linear form of , , , and , we can implement an even more general view of the surface. We do this through a Manipulate object that makes it easy to change any of the 12 parameters that define the actual function value that is plotted.

We give two examples: the first algebraic and the second inverse trigonometric.

Here is the inverse trigonometric function.

For details of the construction, see the package. Within the new package editor of Version 6, it is quite convenient and straightforward to experiment. Input cells are kept in the package and are easily evaluated; comments and examples can be easily embedded, but are invisible when the package is loaded. When developing or investigating package code with the package editor, we do not have to worry about contexts or saving outputs.

RiemannSurfacePlot3D fails for functions with infinitely many branch points. Here is an example.

The construction given next deals with functions having infinitely many branch points.

The New ContourPlot3D

ContourPlot3D, a package function in Version 5, is now a much faster built-in kernel function. This function comes in handy sometimes for polynomials dealing with Riemann surfaces. Here is a simple example that uses ContourPlot3D to display the real part of the functions defined implicitly through a bivariate polynomial.

Eliminating yields a (more complicated) trivariate polynomial that can be plotted.

Using the Exclusions Options

Now we will use new features of Plot3D and ParametricPlot3D to construct a Riemann surface. Using these 3D plotting functions on a function that has branch cuts, we now automatically get cuts along the branch cuts.

Modulo the mesh, in Version 5, we would have gotten a graphic similar to the following, much less appealing (but still correct) image.

We can also obtain descriptions of the excluded cuts using the function VisualizationDiscontinuities from the context Visualization`.

This neat feature of plotting functions that recognize branch cuts can be used to construct Riemann surfaces by finding parametrizations of all sheets and then plotting them. Instead of the steep vertical walls in earlier versions of Mathematica, we now get small cuts between the sheet patches. The analytic continuation of the logarithm and the power function are straightforward to define through adding multiples of and multiplication by .

For the logarithm, with its infinitely many sheets, we restrict ourselves to (typically) three sheets.

This list can be easily extended to elliptic integrals, Bessel functions, polylogarithms, and others.

The function makeSheetList generates a list of the analytically continued sheets of a multivalued function by forming the outer product of all sheets of all the multivalued functions that occur.

Here is an example. The function results in six parametrized sheets: three from the outer logarithm combined with two from the inner square root.

Here is a quick view on the branch cut structure of these six functions.

And here are the real and imaginary parts of the six sheets shown as 3D plots.

Emphasizing the cuts and making the surface transparent gives an even better looking graphic.

As a second example, we use . This time we have five sheets, all arising from the topmost fifth root.

Here is a plot of the real part over the complex plane.

The function RiemannSheetParametricPlot3D combines the sheet generation and plotting results. All sheets are included in the first argument of ParametricPlot3D, instead of making multiple calls to it. This has the advantage of getting better visual results because the optimal plot range will be calculated by taking all sheets into account.

Here are two examples of this function in action: one algebraic and the other a transcendental function containing .

Using RiemannSheetParametricPlot3D, we can now plot the Riemann surface of the function that failed earlier. We emphasize the vertical connection along the branch cuts through red polygons.

And here are four considerably more complicated examples. Because of the infinite number of branch points, the function RiemannSurfacePlot3D cannot handle them.

We generalize RiemannSheetParametricPlot3D to allow for a matrix as its second argument.

In effect, the next graphic shows over the , plane.

To summarize: Using analytically continued sheets and Plot3D/ParametricPlot3D with the Exclusions option lets you plot Riemann surfaces of compositions of elementary functions. This includes cases where the branch points cannot be calculated in closed form or the case of countably many branch points. Two potential disadvantages of this approach are that calculating the exclusions can be potentially very time consuming and the gaps arising from cutting out thin strips along potential branch cuts cannot be made arbitrarily small with reasonable computational effort.

Higher-Order Polynomial Roots

This is not unexpected. The internal function VisualizationDiscontinuities yields no exclusions for the Root object.

The reason is the quite large computational effort needed to determine the cuts for parametrized roots. While the branch points are relatively easy to determine as the common root of the function and its derivative through one resultant calculation, calculating the cuts is more expensive.

Expanding the first of the roots, we see the existence of three second-order branch points.

A discontinuity of a Root object occurs due to a switch in the root numbering. This in turn results from coinciding real parts of different roots. At the point where two roots have a common real part, the real part must have a double root. So carrying out the two resultant calculations gives a sufficient set of algebraic curves along which the roots will exhibit discontinuities.

Even for just a fourth root, evaluating rootExclusions is quite time consuming and the resulting polynomial is large and complex.

Here is a quick overview of the last polynomial.

Once the set of exclusions has been calculated, we can use it as the setting for the Exclusions option.

Life in Four Dimensions

Up to now, we have seen and over the complex plane (we plotted a more general graphic earlier). The most complete information of a function is the set of pairs of complex numbers or the quadruple of real numbers . Imagining the hypersurface in (isomorphic to ), we are naturally led to Banchoff’s tetraview [6] of a complex-valued function. In this section, we implement such a construction. Starting with a plot of the real and imaginary parts of a complex-valued function over the complex plane, we extract the underlying graphic complex, and re-evaluate the function at the , values. (Using the already discretized surface in the form of a GraphicsComplex gives us the advantage of adaptive subdivision.) Because we will use the values of the derivatives of with respect to for calculating the normals, we store the values of the derivatives at the (complex) vertex points in the option setting for VertexNormals.

We define a function RiemannSheetParametricPlots4D that generates a GraphicsComplex with vertex values in . (Here we use the suboption TimeConstraint in the Exclusions option to allow the calculation of more complicated exclusion sets for more complicated functions.) The sheets are generated using the function analyticallyContinue.

Here is an example. The abbreviated output shows that the actual 4D GraphicsComplex is quite large.

In the absence of a direct 4D viewer in Version 6 (or any support for Graphics4D, for that matter—hopefully Version 7 will have at least some), we must project into a 3D subspace to view the surface as a Graphics3D object. For a given projection matrix, this is straightforward for the vertices and not too difficult for the normals. Fortunately, having the information of the embedded hypersurface in 4D allows a projection with normals in 3D using the Cauchy-Riemann conditions, which will result in a smooth-looking surface. Because we will use the final function interactively, we use Compile to carry out the calculation of the 3D vertex coordinates and the 3D normals as efficiently as possible.

The function to3DGraphicsComplex carries out the projection from 4D to 3D.

Putting the last two functions together, we have TetraviewPlot. We give it the option ColorFunction4D, which operates on the unscaled 4D coordinates to easily color a surface.

Here are a few examples of the function TetraviewPlot.

The next example colors the surface of )) according to values of .

A convenient and natural way to parametrize the projection matrix is to use the six rotation angles between the four coordinate planes in .

In the definition for RiemannSheetParametricPlots4D, we used the line

to cache the result of the most time-consuming step inside TetraviewPlot. This allows us to implement a demonstration that interactively changes the 3D subspace selected.

This demonstration gives us a feeling for the 2D hypersurface. Branch point neighborhoods in correspond to flat regions in , and vice versa. As a result, the initial small gaps along the cuts of widen as we look at the 4D surface from different directions.

This ends our short visit into the world of Riemann surface visualizations with Mathematica 6. We will be coming back to this subject in future columns.

References

Michael Trott
Senior Member, Technical Staff
Wolfram Research, Inc.
mtrott@wolfram.com

Fifteen Classic Puzzles

1. If a package has one of 50 random baseball cards, how many packages do you need to buy to get a complete set?
   (demonstrations.wolfram.com/CouponCollectorProblem)
2. A chess king is at one corner of a chessboard. It makes a series of moves that always take it closer to the opposite corner. How many possible paths are there? (demonstrations.wolfram.com/DelannoyPathExhaustionDiagonal)
3. A hallway has 100 lockers, all closed. 100 students are sent down the hall as follows: student 1 opens all the lockers; student 2 closes every other locker, beginning with the second; student 3 changes the state of every third locker, beginning with the third; and so on. After all the students have marched, which lockers remain open?
   (demonstrations.wolfram.com/TheLockerProblem)
4. In the Florida Lotto, a player picks 6 numbers out of 1 to 53. Matching 3, 4, 5, or 6 numbers from the drawing wins a prize. What are the odds of winning? (demonstrations.wolfram.com/UrnProblem)
5. On a grid, plant 10 trees to make 5 lines each containing 4 trees. (demonstrations.wolfram.com/OrchardPlantingProblem)
6. A grid has 25 “on” buttons. Pressing a button changes the state of that button and the surrounding buttons. Can all the buttons be turned “off”? (demonstrations.wolfram.com/LightsOutPuzzle)
7. Can books similar in size be stacked on the edge of a desk so that the top book is not over the desk at all? (demonstrations.wolfram.com/StackingDominoesToTheLimit)
8. McDonald’s once sold Chicken McNuggets in packs of 6, 9, or 20. What is the highest number of McNuggets you cannot buy?
   (demonstrations.wolfram.com/McNuggetProblemAndFrobeniusNum-bers)
9. Thirty people are in a room. What is the probability that two of them share a birthday? (demonstrations.wolfram.com/TheBirthdayProblem)
10. Wheels of radius 30cm and 40cm are 10cm apart. What is the length of a snug belt that goes around both? (demonstrations.wolfram.com/TwoWheelBelt)
11. You have a 3 gallon jug and a 5 gallon jug at a well. How can exactly 1 gallon be measured? (demonstrations.wolfram.com/JugProblem)
12. A 30-foot statue is on a 10-foot pedestal. Where should you stand so that the statue itself looks as big as possible from your point of view? (demonstrations.wolfram.com/TheStatueOfRegiomontanus)
13. As a contestant on Monty Hall’s game show, you are presented with three doors. Behind one door is a new car and behind each of the other two is a goat. You select a door behind which, you hope, is the new car. Monty Hall then opens another door to reveal a goat and asks if you would like to change your selection. Should you switch?
    (demonstrations.wolfram.com/MontyHallProblem)
14. You have 12 coins, labeled with letters M, I, T, F, O, L, K, D, A, N, C, and E. One of the coins is fake, and is heavier or lighter than the others. Can you find the fake coin in 3 weighings?
    (demonstrations.wolfram.com/The12CoinWeighingProblem)
15. A 55-gallon barrel, with a diameter of 22.5 inches, is lying on its side. 10 inches of grain is in the barrel. How much grain does the barrel contain? (demonstrations.wolfram.com/SagittaApothemAndChord)

Discussion—Coupon Collecting

For each of the problems listed above, a link is given to a Wolfram Demonstration that allows for further exploration [1]. For example, the Coupon Collector Demonstration comes with the following explanatory caption:

If a package has one of 50 random baseball cards, how many packages do you need to buy to get a complete set? The expected answer is packages, where is the harmonic number . Switching from baseball cards to coupons gives the coupon collector problem: if there are different kinds of coupons and many of them are distributed randomly, the expected number of purchases necessary for a complete set is .

Code containing a Manipulate is provided for each Demonstration, allowing for exploration of the problem with either Mathematica or Mathematica Player.

All the classic puzzles listed here have been given a similar Demonstration treatment. Is there another classic problem that should be added to The Wolfram Demonstrations Project? If so, please consider adding it at demonstrations.wolfram.com/participate.html. Drop me a line once your new Demonstration has been published.

References

Ed Pegg Jr
Scientific Information Editor
Wolfram Research, Inc.
edp@wolfram.com