text:
The System.Threading.Channels namespace provides a set of synchronization data structures for passing data between producers and consumers asynchronously. The library targets .NET Standard and works on all .NET implementations.

This library is available in the System.Threading.Channels NuGet package (or included when targeting .NET Core 2.1+).

## Producer/consumer conceptual programming model

Channels are an implementation of the producer/consumer conceptual programming model. In this programming model, producers asynchronously produce data, and consumers asynchronously consume that data. In other words, this model hands off data from one party to another. Try to think of channels as you would any other common generic collection type, such as a List<T>. The primary difference is that this collection manages synchronization and provides various consumption models through factory creation options. These options control the behavior of the channels, such as how many elements they're allowed to store and what happens if that limit is reached, or whether the channel may be accessed by multiple producers or multiple consumers concurrently.

## Bounding strategies

Depending on how a Channel<T> is created, its reader and writer will behave differently.

To create a channel that specifies a maximum capacity, call Channel.CreateBounded. To create a channel that can be used by any number of readers and writers concurrently, call Channel.CreateUnbounded. Each bounding strategy exposes various creator-defined options, either BoundedChannelOptions or UnboundedChannelOptions respectively.

Note

Regardless of the bounding strategy, a channel will always throw a ChannelClosedException when it's used after it's been closed.

### Unbounded channels

To create an unbounded channel, call one of the Channel.CreateUnbounded overloads:

var channel = Channel.CreateUnbounded<T>();

When you create an unbounded channel, by default, the channel can be used by any number of readers and writers concurrently. Alternatively, you can specify non-default behavior when creating an unbounded channel by providing an UnboundedChannelOptions instance. The channel's capacity is unbounded and all writes are performed synchronously. For additional examples, see Unbounded creation patterns.

### Bounded channels

To create a bounded channel, call one of the Channel.CreateBounded overloads:

var channel = Channel.CreateBounded<T>(7);

The preceding code creates a channel that has a maximum capacity of 7 items. When you create a bounded channel, the channel is bound to a maximum capacity. When the bound is reached, the default behavior is that the channel will asynchronously block the producer until space becomes available. You can configure this behavior by specifying an option when you create the channel. Bounded channels can be created with any capacity value greater than zero. For additional examples, see Bounded creation patterns.

#### Full mode behavior

When using a bounded channel, you can specify the behavior the channel will adhere to when the configured bound is reached. The following table lists the full mode behaviors for each BoundedChannelFullMode value:

Value Behavior
BoundedChannelFullMode.Wait This is the default value. When calling WriteAsync, waits for space to be available in order to complete the write operation. When calling TryWrite, returns false immediately.
BoundedChannelFullMode.DropNewest Removes and ignores the newest item in the channel in order to make room for the item being written.
BoundedChannelFullMode.DropOldest Removes and ignores the oldest item in the channel in order to make room for the item being written.
BoundedChannelFullMode.DropWrite Drops the item being written.

Important

## Producer APIs

The producer functionality is exposed on the Channel<TWrite,TRead>.Writer. The producer APIs and expected behavior are detailed in the following table:

API Expected behavior
ChannelWriter<T>.Complete Marks the channel as being complete, meaning no more items will be written to it.
ChannelWriter<T>.TryComplete Attempts to mark the channel as being completed, meaning no more data will be written to it.
ChannelWriter<T>.TryWrite Attempts to write the specified item to the channel. When used with an unbounded channel, this always returns true unless the channel's writer signals completion with either ChannelWriter<T>.Complete, or ChannelWriter<T>.TryComplete.
ChannelWriter<T>.WaitToWriteAsync Returns a ValueTask<TResult> that will complete when space is available to write an item.
ChannelWriter<T>.WriteAsync Asynchronously writes an item to the channel.

## Consumer APIs

The consumer functionality is exposed on the Channel<TWrite,TRead>.Reader. The consumer APIs and expected behavior are detailed in the following table:

API Expected behavior
ChannelReader<T>.TryPeek Attempts to peek at an item from the channel.

## Common usage patterns

There are several usage patterns for channels. The API is designed to be simple, consistent, and as flexible as possible. All of the asynchronous methods return a ValueTask (or ValueTask<bool>) that represents a lightweight asynchronous operation that can avoid allocating if the operation completes synchronously and potentially even asynchronously. Additionally, the API is designed to be composable, in that the creator of a channel makes promises about its intended usage. When a channel is created with certain parameters, the internal implementation can operate more efficiently knowing these promises.

### Creation patterns

Imagine that you're creating a producer/consumer solution for a global position system (GPS). You want to track the coordinates of a device over time. A sample coordinates object might look like this:

/// <summary>
/// A representation of a device's coordinates,
/// which includes latitude and longitude.
/// </summary>
/// <param name="DeviceId">A unique device identifier.</param>
/// <param name="Latitude">The latitude of the device.</param>
/// <param name="Longitude">The longitude of the device.</param>
Guid DeviceId,
double Latitude,
double Longitude);

#### Unbounded creation patterns

One common usage pattern is to create a default unbounded channel:

var channel = Channel.CreateUnbounded<Coordinates>();

But instead, let's imagine that you want to create an unbounded channel with multiple producers and consumers:

var channel = Channel.CreateUnbounded<Coordinates>(
new UnboundedChannelOptions
{
SingleWriter = false,
AllowSynchronousContinuations = true
});

In this case, all writes are synchronous, even the WriteAsync. This is because an unbounded channel always has available room for a write effectively immediately. However, with AllowSynchronousContinuations set to true, the writes may end up doing work associated with a reader by executing their continuations. This doesn't affect the synchronicity of the operation.

#### Bounded creation patterns

When working with bounded channels, the configurability of the channel should be known to the consumer to help ensure proper consumption. That is, the consumer should know what behavior the channel will exhibit when the configured bound is reached. Let's explore some of the common bounded creation patterns.

The simplest way to create a bounded channel is to specify a capacity:

var channel = Channel.CreateBounded<Coordinates>(1);

The preceding code creates a bounded channel with a max capacity of 1. Additional options are available, some options are the same as an unbounded channel, while others are specific to unbounded channels:

var channel = Channel.CreateBounded<Coordinates>(
new BoundedChannelOptions(1_000)
{
SingleWriter = true,
AllowSynchronousContinuations = false,
FullMode = BoundedChannelFullMode.DropWrite
});

In the preceding code, the channel is created as a bounded channel that's limited to 1,000 items, with a single writer but many readers. Its full mode behavior is defined as DropWrite, which means that it will drop the item being written if the channel is full.

When using a bounded channel, to observe items that are dropped register an itemDropped callback:

var channel = Channel.CreateBounded(
new BoundedChannelOptions(10)
{
AllowSynchronousContinuations = true,
FullMode = BoundedChannelFullMode.DropOldest
},
static void (Coordinates dropped) =>
Console.WriteLine(\$"Coordinates dropped: {dropped}"));

Whenever the channel is full and a new item is added, the itemDropped callback will be invoked. In this example, the provided callback writes the item to the console, but you're free to take any other action you want.

### Producer patterns

Imagine that the producer in this scenario is writing new coordinates to the channel. The producer can do this by calling TryWrite:

static void ProduceWithWhileAndTryWrite(
ChannelWriter<Coordinates> writer, Coordinates coordinates)
{
while (coordinates is { Latitude: < 90, Longitude: < 180 })
{
var tempCoordinates = coordinates with
{
Latitude = coordinates.Latitude + .5,
Longitude = coordinates.Longitude + 1
};

if (writer.TryWrite(item: tempCoordinates))
{
coordinates = tempCoordinates;
}
}
}

The preceding producer code:

• Accepts the Channel<Coordinates>.Writer (ChannelWriter<Coordinates>) as an argument, along with the initial Coordinates.
• Defines a conditional while loop that attempts to move the coordinates using TryWrite.

An alternative producer might use the WriteAsync method:

static async ValueTask ProduceWithWhileWriteAsync(
ChannelWriter<Coordinates> writer, Coordinates coordinates)
{
while (coordinates is { Latitude: < 90, Longitude: < 180 })
{
await writer.WriteAsync(
item: coordinates = coordinates with
{
Latitude = coordinates.Latitude + .5,
Longitude = coordinates.Longitude + 1
});
}

writer.Complete();
}

Again, the Channel<Coordinates>.Writer is used within a while loop. But this time, the WriteAsync method is called. The method will continue only after the coordinates have been written. When the while loop exits, a call to Complete is made, which signals that no more data will be written to the channel.

Another producer pattern is to use the WaitToWriteAsync method, consider the following code:

static async ValueTask ProduceWithWaitToWriteAsync(
ChannelWriter<Coordinates> writer, Coordinates coordinates)
{
while (coordinates is { Latitude: < 90, Longitude: < 180 } &&
await writer.WaitToWriteAsync())
{
var tempCoordinates = coordinates with
{
Latitude = coordinates.Latitude + .5,
Longitude = coordinates.Longitude + 1
};

if (writer.TryWrite(item: tempCoordinates))
{
coordinates = tempCoordinates;
}

}

writer.Complete();
}

As part of the conditional while, the result of the WaitToWriteAsync call is used to determine whether to continue the loop.

### Consumer patterns

There are several common channel consumer patterns. When a channel is never ending, meaning it will infinitely produce data, the consumer could use a while (true) loop, and read data as it becomes available:

static async ValueTask ConsumeWithWhileAsync(
{
while (true)
{
// May throw ChannelClosedException if
// the parent channel's writer signals complete.
Console.WriteLine(coordinates);
}
}

Note

This code will throw an exception if the channel is closed.

An alternative consumer could avoid this concern by using a nested while loop, as shown in the following code:

static async ValueTask ConsumeWithNestedWhileAsync(
{
{
{
Console.WriteLine(coordinates);
}
}
}

In the preceding code, the consumer waits to read data. Once the data is available, the consumer tries to read it. These loops will continue to evaluate until the producer of the channel signals that it no longer has data to be read. With that said, when a producer is known to have a finite number of items it will produce and it signals completion, the consumer can use await foreach semantics to iterate over the items:

static async ValueTask ConsumeWithAwaitForeachAsync(

format: plain


text:
## M. S. Child

Print publication date: 2014

Print ISBN-13: 9780199672981

Published to Oxford Scholarship Online: October 2014

DOI: 10.1093/acprof:oso/9780199672981.001.0001

Show Summary Details
Page of

PRINTED FROM OXFORD SCHOLARSHIP ONLINE (www.oxfordscholarship.com). (c) Copyright Oxford University Press, 2017. All Rights Reserved. Under the terms of the licence agreement, an individual user may print out a PDF of a single chapter of a monograph in OSO for personal use (for details see http://www.oxfordscholarship.com/page/privacy-policy). Subscriber: null; date: 25 February 2017

# (p.344) Appendix C Transformations in classical and quantum mechanics

Source:
Semiclassical Mechanics with Molecular Applications
Publisher:
Oxford University Press

This appendix concerns the connection between classical canonical transformations and the corresponding unitary transformations in quantum mechanics, with particular emphasis on the role of the classical generator. The ideas, which stem from Van Vleck (1928), were later reviewed by Fock (1959) and Van der Waerden (1967), and most recently expounded in an elegant review by Miller (1974) . The main ideas are introduced in Section C.1 and illustrated by reference to angle–action and energy–time systems in Section C.2, which includes certain results required elsewhere in the text. Section C.3 covers the theory of dynamical transformations along the lines of Miller’s path integral approach to classical S matrix theory. Section C.4 applies similar ideas to the semiclassical Green’s function. Finally, Section C.5 uses the theory to obtain uniform approximations to the Wigner 3j and 6j symbols, in a way that underlines their geometrical significance.

# C.1 Classical and semiclassical transformations

A transformation $(q,p)→(q˜,p˜)$ is termed canonical in classica1 mechanics if the value of the Hamiltonian is preserved,

(C.1)
$Display mathematics$

in such a way that Hamilton’s equations apply in both systems:

(C.2)
$Display mathematics$

conditions that are readily verified to require a unit Jacobian,

(C.3)
$Display mathematics$

The systematic theory of such transformations (Goldstein 1980; Percival and Richards 1982) is developed in terms of one or other of four possible generating functions $F1(q,q˜),$ $F2(q,p˜),$ $F3(p,q˜)$ and $F4(p,p˜)$, each dependent on one old and one new (p.345) variable, and with the remaining variables generated by the following partial derivative relations:

(C.4a)
$Display mathematics$
(C.4b)
$Display mathematics$
(C.4c)
$Display mathematics$
(C.4d)
$Display mathematics$

The equality between the mixed second derivatives of any of the Fi then automatically ensures the validity of (C.3), but the equations carry the awkward complication that, for example, (C.4a) yields mixed functions $p(q,q˜)$ and $p˜(q,q˜)$ that must be inverted in order to express $(q˜,p˜)$ in terms of $(q,p)$ or vice versa. The choice between the Fi in any context may be made for physical or mathematical convenience, because any one of the following interrelated set yields an equivalent transformation, as is readily confirmed by use of eqns (C.4a)–(C.4d):

(C.5a)
$Display mathematics$
(C.5b)
$Display mathematics$
(C.5c)
$Display mathematics$

For example, according to (C.4b) and (C.5a),

(C.7)
$Display mathematics$

which reduce to the identities

(C.7)
$Display mathematics$

after substitution from (C.4a) for the terms in F1.

Equations (C.4a)–(C.4d) and (C.5a )–(C.5c) are the ingredients of classical canonical transformation theory. The next step is to show that the classical generators Fi may also provide foundations for the corresponding quantum mechanical unitary transformation functions Ui, at least in a semiclassical sense. Consider for example the transformation

(C.8)
$Display mathematics$

where $U1(q,q˜)$ must be defined in such a way that (C.8) relates corresponding eigenfunctions of $H(q,−iℏ∂/∂q)$ and $H˜(q˜,−iℏ∂/∂q˜)$. (Note that if $q˜$ were an angle variable the operator $−iℏ∂/∂q˜$ would be modified by addition of a Maslov term, as in eqn (4.23)). Put in mathematical terms this requires that

(C.9)
$Display mathematics$

(p.346) which is the quantum mechanical analogue of (C.1). In other words, in the light of (C.8), $U1(q,q˜)$ must satisfy

(C.10)
$Display mathematics$

It is shown below that a solution to order $ℏ0$ may be expressed in the form

(C.11)
$Display mathematics$

where $F1(q,q˜)$ is the corresponding classical generator . To see this, note first, by virtue of (C.1), (C.4a) and (C.11), that, to order $ℏ0$,

(C.12)
$Display mathematics$

Secondly, provided the integrand takes the same value at both integration limits, it follows from (C.8), by repeated partial integration on the right-hand side of the equation below (again to order $ℏ0$), that

(C.13)
$Display mathematics$

which establishes the validity of (C.9).

Finally, the unitarity condition

(C.14)
$Display mathematics$

may be used to express the pre-exponent in $A1(q,q˜)$ in (C.11) in terms of partial derivatives of $F1(q,q˜)$. The existence of the delta function is well understood in the normal semiclassical sense that rapid oscillations in the full integrand will lead to complete cancellation except when $q′=q$; thus

(C.15)
$Display mathematics$

All that remains is to fix the magnitude of $A1(q,q˜)$ by approximating

(C.16)
$Display mathematics$

and writing

(C.17)
$Display mathematics$

(p.347) as specified by (C.4a). The effect, provided that p varies monotonically with $q˜$, is that (C.15) may be expressed as

(C.18)
$Display mathematics$

It follows, by comparison with the standard form (Dirac 1958)

(C.19)
$Display mathematics$

that

(C.20)
$Display mathematics$

Taken together with what will prove a convenient phase convention (Miller 1974), this means that the semiclassical unitary transform is given in terms of the corresponding classical generator by the equation

(C.21)
$Display mathematics$

This assumes that $p(q,q˜)$ is a monotonic function of $q˜$ at all values of q; otherwise one must sum over the various contributing branches.

Equation (C.21) applies to the transformation from one coordinate representation to another, but it is readily seen that the general structure is preserved even when one or both of the representations is a momentum one. To see this recall that $ψ˜(q˜)$ is related to its momentum representative, $ϕ˜(p˜)$, by the Fourier transformation (Dirac 1958)

(C.22)
$Display mathematics$

so that on substitution in (C.8)

(C.23)
$Display mathematics$

where

(C.24)
$Display mathematics$

Stationary phase reduction of the final integral now yields the analogue of (C.21), because by virtue of (C.4a) the stationarity condition

(C.25)
$Display mathematics$

(p.348) yields a point $q˜(q,p˜)$ consistent with the transformation previously generated by $F1(q,q˜)$. Moreover, the stationary value of the exponent

(C.26)
$Display mathematics$

conforms exactly to the classical expression in (C.5a). Finally, on applying the standard quadratic approximation about $q˜(q,p˜)$,

(C.27)
$Display mathematics$

where

(C.28)
$Display mathematics$

Equations (C.4a) and (C.4b) are required for this final reduction.

Similar analysis may be applied for any desired form of transformation, the general semiclassical result being that the unitary transform $Ui(x,y˜)$, where x and y denote q or p, is related to the corresponding classical generator $Fi(x,y˜)$ in the form

(C.29)
$Display mathematics$

where the sign in the pre-exponent is positive for $i=2$, 3 and negative for $i=1,4$ (Miller 1974). The generalization to f degrees of freedom takes the form

(C.30)
$Display mathematics$

where $∥∂2Fi/∂x∂y˜∥$ denotes the Van Vleck or Hessian determinant of the second derivative matrix.

# C.2 Energy–time and angle–action representations

An illuminating, yet simple, illustration of the theory is provided by the transformation between Cartesian $(P,R)$ and energy–time $(E,t)$ descriptions of free motion. The starting point is the exact coordinate representation of the flux normalized state,

(C.31)
$Display mathematics$

(p.349) which is transformed to the energy–time picture by an $F1(R,t)$ generator, which is itself obtained from an intermediate $F2(R,E)$ generator determined by the Hamilton–Jacobi equation

(C.32)
$Display mathematics$

The solution

(C.33)
$Display mathematics$

shows correctly that

(C.34)
$Display mathematics$

The corresponding $F1(R,t)$ generator is given according to (C.5a) by

(C.35)
$Display mathematics$

after some rearrangement in the light of (C.34). The required semiclassical unitary transform is therefore given by

(C.36)
$Display mathematics$

Consequently $ψ(R)$ transforms to

(C.37)
$Display mathematics$

which reduces at the stationary phase level to

(C.38)
$Display mathematics$

where $E=P2/2m$.

The resultant form is exact in this simple case. It is also evident that the form for $φ(t)$ in (C.38) must apply to any system with one degree of freedom; hence it is relatively uninformative as it stands. However, the reverse transformation

(C.39)
$Display mathematics$

offers a convenient classically based integral representation for $ψ(R)$ in certain contexts. The harmonic oscillator representation given below is an angle–action (rather than energy–time ) version of this idea and similar energy–time forms for the harmonic oscillator and for quadratic barrier passage may be found in Feynman and Hibbs (1965), where they are derived by path integral methods.

(p.350) It is also useful to extend the above argument, for the free-motion case, to situations in which there is an additional internal degree of freedom, with Hamiltonian $H0(I)$, because the resulting analogue of (C.38 ) is required in Chapter 10. One might, for example, start with the mixed representation

(C.40)
$Display mathematics$

which describes a state with unit translational flux and a particular action I0C.2corresponding to the quantum number

(C.41)
$Display mathematics$

where δ is the usual Maslov index. Since the action operator is given by $Iˆ=−iℏ(∂/∂α)+δℏ$ (see Sections 3.1 and 4.1), the Hamilton–Jacobi equation for the generator $F2(R,α;$ $E,I)$ takes the form

(C.42)
$Display mathematics$

and the solution is readily found to be

(C.43)
$Display mathematics$

where

(C.44)
$Display mathematics$

Notice, on applying (C.5a), that the variables conjugate to E and I in the transformed representation take the interesting forms

(C.45)
$Display mathematics$

where $ω$ is the frequency of the internal motion. The conjugate to E is of course the time (now denoted $τ$ for later convenience), but the conjugate to I is no longer α but the modified variable $αˉ$, which is a constant of the motion in this non-interacting picture because, by construction, α varies with time as $α=ωτ+$ constant (see Section 4.1). The remaining step in the transformation of (C.40) is to define the mixed generator $F(R,I;τ,αˉ)$ which may be reduced with the help of (C.45) to

(C.46)
$Display mathematics$

The form of the associated unitary transform,

(C.47)
$Display mathematics$

(p.351) then implies, after some manipulation, that

(C.48)
$Display mathematics$

which is the result employed (as eqn (10.24)) in Chapter 10.

The scaled harmonic oscillator, with Hamiltonian

(C.49)
$Display mathematics$

offers further insights into the scope of the transformation theory. Here the quantum number n rather than the action, $I=n+12$, is conveniently taken as the variable conjugate to the angle α, because according to eqn (4.23) its operator equivalent,

(C.50)
$Display mathematics$

has the form assumed in eqns (C.9)–(C.13) ($ℏ=1$ in the present units).

Following the above Hamilton–Jacobi route (eqns (C.33)– (C.35)) one readily finds that

(C.51)
$Display mathematics$

Hence, following (C.4a),

(C.52)
$Display mathematics$

which rearrange to the canonical form (see (4.21))

(C.53)
$Display mathematics$

The analogue of eqns (C.8) and (C.10) therefore suggests a representation for the Cartesian wavefunction $ψn(q)$ of the form

(C.54)
$Display mathematics$

where

(C.55)
$Display mathematics$

and, according to (4.25),

(C.56)
$Display mathematics$

(p.352) The integration limits in (C.54) will be chosen later. Turning to the function $A1(q,α)$, the semiclassical form,

(C.57)
$Display mathematics$

cannot be exact because $ψn(q)$ must be either even or odd in q, for even or odd values of n. One can, however, obtain an exact representation in this special case because eqn (C.12), which takes the form

(C.58)
$Display mathematics$

can be solved exactly by substitution from (C.55) to yield

(C.59)
$Display mathematics$

Two fundamental solutions may be recognized:

(C.60)
$Display mathematics$

other forms involving higher powers of q may be reduced to these by integration by parts in (C.54). One interesting feature is that the coefficient choices

(C.61)
$Display mathematics$

bring (C.60) into coincidence with (C.57) (apart from a phase factor) in the semiclassical sense that q and α are related by (C.53).

The following integral representations are therefore suggested for $ψn(q)$:

(C.62a)
$Display mathematics$

for n even, and

(C.62b)
$Display mathematics$

for n odd. Here the integration limits have been chosen to ensure that $ψn(q)$ is real (as may be verified by the substitution $α′=−α$) and such that $sec1/2α$ is real over the integration range.

(p.353) Equations (C.62a) and (C.62b) have been expressed in this form to emphasize their semiclassical origin, and also because the as yet undetermined factors Cn are close to unity. To see the latter note that the standard form

(C.63)
$Display mathematics$

for even n may be shown to take the following value at $q=0$:

(C.64)
$Display mathematics$

where $Γ(x)$ is the gamma function (Abramowitz and Stegun 1965), while the integral in (C.62a) at $q=0$ gives (Gradsteyn and Ryyzhik 1980)

(C.65)
$Display mathematics$

It follows by use of the gamma function duplication formula (Abramowitz and Stegun 1965) that

(C.66a)
$Display mathematics$

with the numerical values $C0=1.0623,C2=1.0046,C4=1.0015$ and $Cn→1$ as $n→∞$. A similar comparison for $ψn′(0)$ leads to

(C.66b)
$Display mathematics$

!! with the values $C1=0.9885,C3=0.9976,C5=0.9980$, etc.

This classically based integral representation has close analogies with forms given by Feynman and Hibbs (1965), Ovchinnikova (1974) and Boyer and Wolf (1975). It also provides a direct route to the harmonic uniform approximation discussed in Section B.4.

# C.3 Dynamical transformations and the classical S matrix

Miller (1974) and coworkers have made elegant use of the foregoing theory in deriving semiclassical transition amplitudes, or S matrix elements, from the classical limit of the Feynman propagator (Feynman and Hibbs 1965). The underlying idea is that passage from a phase point $(p1,q1)$ at time t1 to $(p2,q2)$ at t2 constitutes a dynamical transformation whose classical generator determines the quantum mechanical propagator .

The simplest illustration applies to the case of free motion, for which it is readily verified that the generator

(C.67)
$Display mathematics$

(p.354) yields the correct momenta:

(C.68)
$Display mathematics$

The corresponding unitary transform, denoted for consistency with what follows by

(C.69)
$Display mathematics$

may be confirmed to propagate the wavefunction from time t1 to t2 in the sense that (Feynman and Hibbs 1965)

(C.70)
$Display mathematics$

To see this, note that the exact initial free-motion wavefunction, at energy $E=p2/2m$, is

(C.71)
$Display mathematics$

so that on using the standard integral

(C.72)
$Display mathematics$

(C.70) yields an identical form to (C.71) except that the subscript 2 appears in place of 1. Equations (C.67)–(C.71) are exact for this simple case.

The corresponding exact propagator in more general situations may be expressed as a path integral (Feynman and Hibbs 1965),

(C.73)
$Display mathematics$

where S is the action along a particular path,

(C.74)
$Display mathematics$

and the integral in (C.73) is taken over all possible phase space paths with end points q1 at t1 and q2 at t2. A convenient way to approximate S for a given path is to break it into short time segments of length $Δti$ along which the momentum $pi$ consistent with H at a given energy may be taken as constant; hence, following (C.67)–(C.68) the ith action increment becomes

(C.75)
$Display mathematics$

where $mΔqi=piΔti$.

(p.355) Such expedients are, however, unnecessary in the semiclassical treatment of small isolated species, because the fluctuations in $S[q(t)]$ from one path to another may be assumed to be so large that constructive interference occurs only around the paths of minimum action, which are by Hamilton’s principle those traced out by the classical trajectories from q1 at t1 to q2 at t2 (Goldstein 1980; Percival and Richards 1982) . Hence in the semiclassical limit (Feynman and Hibbs 1965)

(C.76)
$Display mathematics$

where

(C.77)
$Display mathematics$

with the integral taken along a classical trajectory. Note that the pre-exponent in (C.76), which includes contributions from the immediately neighbouring paths, is fixed by unitarity (compare eqns (C.14)–(C.20)). The sum of terms of the Cartesian form in eqn (C.76), taken over all ‘root trajectories’ from $q1$ to q2 in time $t2−t1,$ is known is the Van Vleck (1928) propagator .

Henceforth it is assumed that the system is conservative (i.e. that H contains no explicit time dependence), in which case terms in H (or E) may be factored out of the multidimensional analogue of (C.76) in the form

(C.78)
$Display mathematics$

where

(C.79)
$Display mathematics$

with the integral taken along a trajectory from $q1$ to $q2$. This reduced propagator governs the evolution of the spatial part of the wavefunction in the form

(C.80)
$Display mathematics$

Since the trajectory used to determine $κ(q1;q2)$ assumedly depends on $q1$ and $q2$, the initial and final momenta, generated by the equations

(C.81)
$Display mathematics$

are also strictly dependent on $q2$ and $q1$. Note also that the double-ended nature of the boundary conditions may allow more than one classical path from $q1$ to $q2$, in which case (C.78) must be replaced by an appropriate sum.

(p.356) We turn now to the relation between the propagator and the scattering matrix in collisional applications of the theory. Miller (1974) argues that an observable transition from one quantum state $n1$ to another $n2$ involves not a coordinate change, but a change of action from $I1$ to . Hence the S matrix depends on a propagator $κ(I2;I1)$ in an angle–action representation. Not surprisingly, if the transformations are followed through at the stationary phase level, the result is the primitive semiclassical approximation of eqn (9.37). Here, however, the aim is to obtain the integral representation of eqn (9.28), from which other results are deduced in Section 10.2.

It is assumed for simplicity that the system involves translational variables $(P,R)$ and a single set of internal variables given in either angle–action $(I,α)$ or Cartesian $(p,x)$ form. It is also useful to remember, according to the discussion in Section C.2, that the semiclassical conjugate to α is not I but

(C.82)
$Display mathematics$

where δ is the Maslov index and n the quantum number.

Before proceeding to the details, it is important to establish the dependence of these variables upon one another. For example, in considering a trajectory from asymptotic variables (P1, R1, N1, $α1$) to (P2, R2, N2, $α2$) the final quantities $P2$ and N2 are dependent on the choice of all four initial variables, R2 may be chosen arbitrarily, and $α2$ depends on $R2$ as well as the initial set, because (see eqn (4.5))

(C.83)
$Display mathematics$

where $ω(Ni)=∂H0/∂Ni$, and a different value of R2 implies a different final time. Closer inspection shows that $P2$ and N2 are also interdependent because

(C.84)
$Display mathematics$

and the same is true of P1 and N1 if the energy E is taken as an independent variable. Finally, it is convenient to accommodate the interdependence of $αi$ and Ri by defining the modified angle

(C.85)
$Display mathematics$

which is in effect the constant in eqn (C.83). The upshot is that the variables $(N,αˉ,E,τ)$, which were introduced earlier in eqns (C.42)–(C.48), are the most convenient for conceptual purposes, because E is fixed and the outcome of the trajectory is independent of the $τi$, provided the motion starts and ends in an asymptotic region. The essential dependence is therefore either $(N2,αˉ2)$ on $(N1,αˉ1)$, or $(N1,N2)$ on $(αˉ1,αˉ2)$, or vice versa. The aim of what follows is to transform from the physically convenient practical variables, used to determine the trajectory, to the conceptual $(E,τ,N,αˉ)$ system, and then to relate the S matrix to the propagator $κ(αˉ2;αˉ1)$. The necessary transformation steps will be followed via the classical generators.

(p.357) Two possibilities are considered, according to whether the motion is followed in the (P, R, N, α) or (P, R, p, x) system. In the first case the dynamical transformation itself is induced by the $F1$ type generator

(C.86)
$Display mathematics$

and in the second case

(C.87)
$Display mathematics$

with the integrals taken along classical trajectories.

The easiest route to the corresponding $(τ1,αˉ1)$ to $(τ2,αˉ2)$ generator involves an intermediate transformation to the $(N,R)$ representation, using as the generator either

(C.88)
$Display mathematics$

or

(C.89)
$Display mathematics$

(p.358) where $F2(x,N)$ is the type 2 generator from $(p,x)$ to $(N,α)$, given according to eqn (4.12) by

(C.91)
$Display mathematics$

It is readily verified from (C.89) that

(C.91)
$Display mathematics$

and similarly for $p˜$ because by construction

(C.92)
$Display mathematics$

The next step is to transform to the $(αˉ,τ)$ representation with the help of eqns (C.42)–(C.48). The resulting generator takes the form

(C.93)
$Display mathematics$

where

(C.94)
$Display mathematics$

alternatively, $ρ˜(N2R2;N1R1)$ may be employed in place of $ρ(N2R2;N1R1)$. Finally, (C.93) may be cast into a more appealing form by noting that the variables $αi$ and Pi,

(C.95)
$Display mathematics$

implied by (C.94) are necessarily consistent with those given by (C.91). Hence, on combining (C.83) with (C.88)–(C.95),

(C.96)
$Display mathematics$

Note that although the Ni and Pi are dependent on the $αˉi$, the function $λ(αˉ2τ2;αˉ1τ1)$ generates the proper conjugates to $αˉi$ and $τi$ in the form

(C.97)
$Display mathematics$

because, by virtue of (C.84) and (C.95), the terms in $∂Ni/∂αˉj$ cancel exactly with those in $∂Pi/∂αˉj$.

This function $λ(αˉ2τ2;αˉ1τ1)$ plays the role of $W(q2;q1)$ in (C.79); hence the semiclassical propagator takes the form

(C.98)
$Display mathematics$

Moreover, it is clear from the energy dependences of $iλ(αˉ2τ2;αˉ1τ1)$ and of the typical asymptotic wavefunction given by (C.48)

(C.99)
$Display mathematics$

that propagation with respect to $τ$ is purely multiplicative, as one might expect by analogy with (C.74). The propagation equation is therefore

(C.100)
$Display mathematics$

where the superscript on the left-hand side implies propagation of $ψn1$. It follows, by analogy with (C.76), that

(C.101)
$Display mathematics$

(p.359) The relation between $κ(αˉ2τ2;αˉ1τ1)$ and the S matrix is now readily established by noting that $ψ(n1)(αˉ2τ2)$ must decompose as

(C.102)
$Display mathematics$

so that on projecting out the $n20$th term from (C.100)

(C.103)
$Display mathematics$

where

(C.104)
$Display mathematics$

Note that, for ease of comparison with (9.29), Ni and Pi have been replaced by

(C.105)
$Display mathematics$

that the quantum numbers $ni0$ have been given the superscript to distinguish them from the ni which are functions of the $αˉi$ (as are the ki), and that the mixed second derivative of $λ$ in (C.101) has been evaluated with the help of (C.97).

Equation (C.104) is the most general integral form for the S matrix but it assumes knowledge of the trajectories from all initial to all final angles $αˉ$ at the energy of interest. The following simpler form,

(C.106)
$Display mathematics$

where

(C.107)
$Display mathematics$

may be obtained by stationary phase integration with the help of the identity

(C.108)
$Display mathematics$

where n2, k2 and $αˉ1$ are now to be taken as functions of $n10$ and $αˉ2$, while k1 is of course determined by E and $n10$. Reversal of the functional dependence of $αˉ1$ on $αˉ2$ transforms (C.106) to the form

(C.109)
$Display mathematics$

(p.360) which is identical with the initial value representation of eqn (9.28). This closes the present analysis except to note that eqns (C.104) and (C.107) employ expressions for $Λn10n20$ and $Δn10n20$ derived from $W(α2R2;α1R1)$ on the assumption that the trajectory is followed in the $(N,α,P,R)$ system. It is readily verified by comparison between (C.88) and (C.89) that $W(x2,R2;x1R1)$ would yield an equivalent expression, obtained by substituting

(C.110)
$Display mathematics$

in eqn (C.107), which is applicable in situations where the internal motion is most conveniently followed in Cartesian variables.

# C.4 The semiclassical Green’s function

The semiclassical Green’s function is given by Gutzwiller (1990) as a half Fourier transform of the Van Vleck (1928) propagator in eqn (C.76):

(C.111)
$Display mathematics$

where the subscript on the pre-exponent is a reminder that the derivatives are taken at fixed t. Moreover, $∂S/∂t=−E(q′′,q′,t)$—the negative of the energy of the trajectory from $q′$ to $q′′$ in time t. The exponent is therefore stationary at times t such that $E(q′′,q′,t)$ coincides with the target energy E. Subsequent manipulations are simplified by the Legendre transformation

(C.112)
$Display mathematics$

where the reduced classical action integral

(C.113)
$Display mathematics$

is the stationary value of the exponent in (C.111). Consequently the stationary phase approximation to $G(q′′q′;E)$ is given by

(C.114)
$Display mathematics$

(p.361) where the sum is taken over all trajectories from $q′$ to $q′′$ at energy E, and the Maslov index μ counts the number of sign changes of the determinant at the so-called conjugate points along the trajectory (Gutzwiller 1990).

Significant simplifications of eqn (C.114) may be obtained by recognizing that $∂W/∂E=t(E)$. In the first place it follows that $∂2S/∂t2=−∂E/∂t=−∂t/∂E−1=−∂2W/∂E2−1$. Secondly, following Gutzwiller (1990), eqn (C.112) may be used to express the Van Vleck determinant in terms of $det∂2W/∂q′′∂q′$. As a preliminary, note that

(C.115)
$Display mathematics$

from which it follows that

(C.116)
$Display mathematics$

Terms like $∂2E/∂qj′′∂qi′$ vanish because $E=H(p′,q′)$ is independent of $q′′$. When expressed in terms of determinants, this means that

(C.117)
$Display mathematics$

where the coordinate derivatives of W are taken at constant E.

The determinant on the right must, however, be evaluated with care (Gutzwiller 1990), because $det(∂2W/∂q′′∂q′)=0$. To see this note by the Hamilton–Jacobi equation that

(C.118)
$Display mathematics$

Hence, on differentiating with respect to $qi′$,

(C.119)
$Display mathematics$

which implies that the matrix $(∂2W/∂q′′∂q′)$ is singular. Moreover, the nature of the singularity may be understood by adopting a coordinate system such that $q1$ runs along a particular classical trajectory, and that $q2,q3,…,qf$ are perpendicular to it. Consequently $q˙=(q˙1,0,...,0)$, which means that $∂2W/∂qj′′∂qi′=0$ whenever (p.362) $i=1$ or $j=1$. It also follows, by differentiating (C.118) with respect to E, that $q˙1∂2W/∂q1∂E=1$. Consequently

(C.120)
$Display mathematics$

in which $(∂2W/∂q˜′′∂q˜′)$ denotes the reduced Hessian matrix with indices i or j restricted to $(2,3,…,f)$.

Taken in conjunction with eqn (C.114) this means that

(C.121)
$Display mathematics$

In conclusion it should be noted that eqns (C.115)–(C.117) may be extended to imaginary time propagation, with $t=−iτ$, as required, for example in the instanton theory of chemical reactions in Section 11.4. The difference is that eqn (C.112) is replaced by

(C.122)
$Display mathematics$

in which $pˉ$ is the momentum on the upturned potential energy surface, $Vˉq=−V(q)$ and $τ(E)=−∂Wˉ/∂E$. Thus

(C.123)
$Display mathematics$

or in the context of eqn (11.64)

(C.124)
$Display mathematics$

# C.5 Angular momentum coupling coefficients

The angular momentum vector coupling coefficients relate to transformations between one angular momentum coupling scheme and another. Semiclassical approximations for them have been obtained in a variety of ways (Racah 1951; Beidenharn 1953; Adler et al. 1956; Brussard and Tolhoek 1957; Ponzano and Regge 1968; Miller 1974; Schulten and Gordon 1975) . Following Miller (1974), they are here derived by use of classical generators, in a way that also borrows illuminating geometrical insights from Ponzano and Regge (1968) and Schulten and Gordon (1975).

(p.363) To start with the simplest case, the 3j symbol is a symmetrical version of the Clebsch–Gordan coefficient, which relates the uncoupled states $|j2m2⟩|j3m3⟩$ to the coupled states $|(j2j3)j1−m1⟩$ by the equations (Brink and Satchler 1968; Zare 1988)

(C.125)
$Display mathematics$

where the elements $Tj1m2$ define the unitary transformation

(C.126)
$Display mathematics$

subject to

(C.127)
$Display mathematics$

Note, for future reference, that the sum over m2 in (C.126 ) could be more symmetrically regarded as a sum over $m2−m3$ at fixed $m1$.

Fig. C.1 A graphical representation of eqn (C.125). The lower panel shows $|Tj1m2|2$ for $j1=120$, as given by (C.146) (curves) and by exact recursion relations (points). Wigner’s (1959) estimate is $[(2j1+1)/4πA]$, where A is the area of the projected triangle. (Reprinted with permission from (Schulten and Gordon 1975). Copyright 1975, AIP Publishing LLP.)

The derivation that follows makes use of the classical analogue of eqn (C.126) depicted in Fig. C.1, in which the $Ji$ have fixed magnitudes $ji+12$ (in units of $ℏ$) with $J1$ fixed and $J2$ and $J3$ free to rotate around it, subject to the triangular constraint

(C.128)
$Display mathematics$

consistent with (C.127). This choice of the senses of the $Ji$ ensures the known symmetry of the 3j symbol (Brink and Satchler 1968; Zare 1988) under cyclic permutation of the indices. Seen in relation to the above equations, the triangle with a fixed edge $J1$ represents the left-hand side of (C.126), and the freedom of rotation about $J1$ corresponds to the uncertainty in $m2−m3$ represented by the sum over m2 on the right, all other actions being fixed by $|J1|,m1$ and $m2−m3$. The method of derivation involves constructing a semiclassical unitary transform equivalent to $Tj1m2$ in terms of an F4 type generator between the magnitude $J1=j1+12$, on one hand, and the difference $m2−m3$ on the other, subject to the geometrical constraints in Fig. C.1. One vital observation, which may be confirmed by reference to Fig. 4.3, is that the angle $α1$, measured around the vector $J1$, constitutes the conjugate variable to the magnitude J1. Similarly, the azimuthal angles $βi$ in the component representation

(C.129)
$Display mathematics$

where

(C.130)
$Display mathematics$

are the angles conjugate to the z components mi. Hence, bearing in mind the known symmetry of the 3j symbol under permutation of the indices, the natural choice for F4 (obtained by setting $F3=0$ in (C.5b)) may be written

(C.131)
$Display mathematics$

(p.364) where the angles $αi$ and $βi$ are geometrically determined functions of the Ji and mi. Moreover, the absolute orientation about the z axis is irrelevant, which makes it convenient to transform temporarily to new conjugate variables ${Li,ηi}$ defined by the equations

(C.132)
$Display mathematics$

(p.365) a construction that also later aids extension of the theory to 6j symbols; note also that $Tj1m2$, which determines the transformation between J1 and the difference $m2−m3$, relates more symmetrically to a transformation from J1 to L1 at fixed $L1+L2+L3$.

In these new variables (C.131) transforms to

(C.133)
$Display mathematics$

which is the desired form for the F4 generator, because the angles $αi$ and $ηi$ are determined, in terms of the Ji and mi, by the following geometrical identities (Ponzano and Regge 1968):

(C.134)
$Display mathematics$

and

(C.135)
$Display mathematics$

where $F(J1,J2,J3)$ and $A(P1,P2,P3)$ are respectively the areas of the triangle $(J1,J2,J3)$ and its projection $(P1,P2,P3)$ in the xy plane:

(C.136)
$Display mathematics$

Similar expressions for $(α2,η2)$ and $(α3,η3)$ are obtained from (C.134) and (C.135) by cyclic permutation of the indices. It is also evident by inspection of Fig. C.1 that any angular momentum set ${Ji,mi}$ is equally consistent with a mirror-image geometry (obtained by reflection in the $(J1,z)$ plane), in which the signs of the $αi$ and $ηi$ are reversed.

The validity of $Ω(3)$ as an F4 generator, such that

(C.137)
$Display mathematics$

is most simply confirmed by direct but lengthy differentiation, while a more elegant but more abstract proof is outlined by Schulten and Gordon (1975). The important consequence is that the analogue of (C.29) yields the desired unitary transform

(p.366)

(C.138)
$Display mathematics$

where the sum that leads to the cosine is taken over the two equivalent orientations of the triangle, and the term $π/4$ arises because

(C.139)
$Display mathematics$

for the orientation specified by (C.134)–(C.135).

The final result for the semiclassical 3j symbol, obtained by substituting $U4(3)$ for $Tj1m2$ in (C.125), is therefore

(C.140)
$Display mathematics$

where $Ω(3)$ is most conveniently expressed for computational purposes in the following form derived from (C.127), (C.131) and (C.132):

(C.141)
$Display mathematics$

Here $Ji=ji+12$, the angles $αi$ and $ηi$ are determined by (C.134) and (C.135) plus their cyclic permutations, and the area $A(P1,P2,P3)$ is given by (C.130) and (C.136). The phase term σ may be determined by comparison between (C.142) and the identity (Brink and Satchler 1968)

(C.142)
$Display mathematics$

from which it may be verified that

(C.143)
$Display mathematics$

Equation (C.140) was first given by Miller (1974). If two of the ji are much larger than the other, say $j2≃j3≫j1$, it is simpler to employ the 3j equivalent of the earlier result of Brussard and Tolhoek (1957), namely

(C.144)
$Display mathematics$

where $Dμνj(0,θ,0)$ is the rotation matrix (Brink and Satchler 1968) and

(C.145)
$Display mathematics$

Schulten and Gordon (1975) obtained eqn (C.140) (albeit with an apparent sign error in the expression for $cosα1$) by the interesting device of converting the 3j symbol recurrence relations to JWKB-type differential equations. This approach has (p.367) the added benefit that it also covers the non-classical range of ${ji,mi}$ combinations for which the area $A(P1,P2,P3)$ is imaginary and for which the angles given by eqns (C.134) and (C.135) are complex. The following uniform approximations cover both real and complex situations and, as usual, smooth out the spurious singularities at the boundaries (Schulten and Gordon 1975):

(C.146)
$Display mathematics$

Fig. C.2 Semiclassical (curves) and exact (points) 3j symbols, (a) $j10060−1060−50$ and (b) $1206070−10m10−m$. (Reprinted with permission from (Schulten and Gordon 1975). Copyright 1975, AIP Publishing LLP.)

where the Airy functions $Ai(−z)$ and $Bi(−z)$ (Abramowitz and Stegun 1965) have argument

(C.147)
$Display mathematics$

with the positive and negative signs taken in the real and complex cases respectively. Finally,

(C.148)
$Display mathematics$

$αi0$ and $ηi0$ being the angles on the nearest boundary:

(C.149)
$Display mathematics$

It is evident from Fig. C.2 that this uniform result provides an excellent approximation to the exact 3j symbol, regarded as a function of j1 at fixed m2 or vice versa. One also clearly sees the familiar oscillatory patterns in the bright classical ranges flanked by exponential decay into the shadow regions.

The theory of the $6j$ symbol follows similar lines. In this case

(C.150)
$Display mathematics$

where the transformation elements $Tj1l1$ connect states with common internal labels, $l2,l3$ and $j3$, and a common resultant $j2$ but with different intermediate coupling schemes. In the $j1$ set, labelled $|(l2,l3)j1,j3;j2⟩,l2$ and $l3$ have a resultant $j1$, which couples to $j3$ to form $j2$, while in the $l1$ set, labelled $|(l2,j3)l1,l3;j2⟩$, the initial coupling is between $l2$ and $j3$ to form $l1$, which then combines with $l3$ to reach the same resultant $j2$. Thus $Tj1l1$ defined by the equation

(C.151)
$Display mathematics$

(p.368) (p.369) The corresponding classical situation is illustrated in Fig. C.3, in which $Ji=ji+12$ and $Li=li+12$. Thus, in geometrical terms, the left-hand side of (C.151) corresponds to the fixed triangles $(J1,L2,L3)$ and $(J1,J2,J3)$ with a common edge J1, while variation of the arbitrary dihedral angle $α˜1$ about J1 gives rise to a range of $L1$ values, consistent with the triangles $(L1,L2,J3)$ and $(L1,J2,L3)$, which is the classical analogue of the uncertainty in l1 implied by the sum on the right-hand side of (C.151).

This geometrical picture also shows that the choice of the symbol Li in eqns (C.128)–(C.143) was far from accidental because, as underlined by Ponzano and Regge (1968), the 3j symbol may be regarded as a large li approximation to its 6j counterpart;

Fig. C.3 A graphical representation of eqn (C.151). The lower panel shows $|Tj1l1|2$ for $l1=190$, as given by (C.161) (curves) and by exact recursion relations (points). Wigner’s (1959) estimate is $[(2l1+1)/4πV]$, where V is the volume of the tetrahedron. (Reprinted with permission from (Schulten and Gordon 1975). Copyright 1975, AIP Publishing LLP.)

(C.152)
$Display mathematics$

where

(C.153)
$Display mathematics$

The geometrical analogue is that the edges Li of the 6j tetrahedron in Fig. C.3 go over, as $Li→∞$, to those of a vertical prism, with an upper triangular face $(J1,J2,J3)$, as in Fig. C.3, and a mean height R. Not surprisingly, therefore, the dihedral angles $α˜i$ and $η˜i$ in Fig. C.3 play precisely the same role in the 6j context as that played by $αi$ and $ηi$ in the theory of the 3j symbol. In particular the function

(C.154)
$Display mathematics$

again acts as the proper F4 type generator, in the sense that

(C.155)
$Display mathematics$

but the expressions for $α˜i$ and $η˜i$ in terms of Ji and Li are much more complicated, namely (Ponzano and Regge 1968; Schulten and Gordon 1975):

(C.156)
$Display mathematics$

(p.370) (p.371) Here the various area terms $F(J1J2J3)$ etc. are given by (C.136) and V is the volume of the tetrahedron, which is conveniently calculated from the Caley determinant

(C.157)
$Display mathematics$

Similar expressions for the remaining $α˜i$ and $η˜i$ are again obtained by cyclic permutation. Furthermore each angular momentum set ${Ji,Li}$ is again realizable in two ways, one given by (C.156) and the other in which the signs of all the angles are reversed. The validity of (C.155) may be verified by direct differentiation, or by the more abstract argument outlined by Ponzano and Regge (1968).

The final step in the primitive semiclassical argument is to note, by virtue of (C.155) and (C.156), that

(C.158)
$Display mathematics$

so that the semiclassical unitary transform analogous to (C.142) becomes

(C.159)
$Display mathematics$

Fig. C.4 Semiclassical (curves) and exact (points) 6j symbols ${j80150190230120}$. (Reprinted with permission from (Schulten and Gordon 1975). Copyright 1975, AIP Publishing LLP.)

Alternatively, on replacing $Tj1l1$ in (C.150) by $U4(J1,L1)$,

(C.160)
$Display mathematics$

where $Ω(6)$ and V are defined by (C.154)–(C.157) with $Ji=ji+12$ and $Li=li+12$ .

Equation (C.160) was first suggested on heuristic grounds by Ponzano and Regge (1968)

and later derived from the recurrence relations by Schulten and Gordon (1975). The latter also give the following uniform Airy approximations which extend the approximation to angular momentum combinations for which the volume V is negative and the angles $α˜i$ and $η˜i$ complex:

(C.161)
$Display mathematics$

where

(C.162)
$Display mathematics$

(p.372) (p.373) with $α˜i0$ and $η˜i0$ given by the analogues of (C.148), and

(C.163)
$Display mathematics$

As usual the upper and lower signs in (C.163) apply in the classical and non-classical cases respectively.

The comparison in Fig. C.4 shows that eqn (C.161 ) gives an excellent approximation, at least for moderately large quantum numbers, and the numerical accuracy is found to be equally good for integer and half-integer quantum numbers (Schulten and Gordon 1975). Further information on the accuracy of the approximation in relation to the magnitudes of the angular momenta is contained in Tables C.1 and C.2, which are taken from scaling tests by Schulten and Gordon (1975) . It is evident that the errors are typically of order 10 per cent or less even for quite small quantum numbers.

Table C.1 Quantum mechanical and semiclassical 6j symbols$a$ taken from (Schulten and Gordon 1975)!!.

j1

$λ=1$

$λ=4$

$λ=6$

$λ=32$

1

QM

0.2789(00)

0.9692(−01)

0.0977(−01)

0.0806(−02)

SC

0.3034(00)

0.9520(−01)

0.0926(−01)

0.0758(−02)

2

QM

− 0.9535(−01)

0.0457(−01)

0.1288(−01)

0.0297(−02)

SC

− 0.9303(−01)

0.0523(−01)

0.1285(−01)

0.0285(−02)

3

QM

− 0.6742(−01)

− 0.0141(−01)

0.1378(−01)

0.6773(−02)

SC

− 0.6975(−01)

− 0.0143(−01)

0.1378(−01)

0.6773(−02)

4

QM

0.1533(00)

− 0.2083(−01)

− 0.0825(−01)

− 0.0275(−02)

SC

0.1558(00)

− 0.2158(−01)

− 0.0823(−01)

− 0.0281(−02)

5

QM

− 0.1564(00)

0.5313(−01)

0.1021(−01)

− 0.4379(−02)

SC

− 0.1566(00)

0.5315(−01)

0.1023(−01)

− 0.4376(−02)

6

QM

0.1099(00)

0.1711(−01)

0.4149(−03)

0.8876(−05)

SC

0.1090(00)

0.1704(−01)

0.4145(−03)

0.8870(−05)

7

QM

− 0.5536(−01)

0.9524(−03)

0.3496(−08)

0.6071(−15)

SC

− 0.5441(−01)

0.9452(−03)

0.3488(−08)

0.6064(−15)

8

QM

0.1800(−01)

0.4072(−05)

0.1804(−18)

0.6568(−36)

SC

0.1727(−01)

0.3915(−05)

0.1738(−18)

0.6332(−36)

$aj1λ4.5λ3.5λλ−3.5λ2.5λ$

Table C.2 Quantum mechanical and semiclassical 6j symbols$b$ taken from (Schulten and Gordon 1975)!!.

j1

$λ=1$

$λ=4$

$λ=8$

$λ=16$

1

QM

0.3491(−01)

0.3226(−02)

0.0513(−02)

0.0302(−03)

SC

0.3482(−01)

0.3155(−02)

0.0499(−02)

0.0292(−03)

3

QM

0.1891(−01)

0.0185(−02)

− 0.1458(−02)

0.2156(−03)

SC

0.1905(−01)

0.0180(−02)

− 0.1458(−02)

0.2157(−03)

5

QM

− 0.2359(−01)

0.2973(−02)

0.0887(−02)

0.1358(−03)

SC

− 0.2382(−01)

0.2982(−02)

0.0889(−02)

0.1362(−03)

7

QM

0.0129(−01)

0.1603(−02)

− 0.0698(−02)

0.0315(−03)

SC

0.0152(−01)

0.1569(−02)

− 0.0699(−02)

0.0315(−03)

9

QM

0.1677(−01)

− 0.2800(−02)

0.0854(−02)

0.0697(−03)

SC

0.1671(−01)

− 0.2800(−02)

0.0854(−02)

0.0696(−03)

11

QM

− 0.2135(−01)

0.2264(−02)

− 0.0020(−02)

− 0.3562(−03)

SC

− 0.2147(−01)

0.2259(−02)

0.0022(−02)

− 0.3561(−03)

13

QM

− 0.2521(−01)

0.1724(−02)

0.1184(−02)

0.4040(−03)

SC

0.2527(−01)

0.1731(−02)

− 0.1183(−02)

0.4039(−03)

15

QM

0.0271(−01)

0.1171(−06)

0.5415(−12)

0.2293(−22)

SC

0.0257(−01)

0.1095(−06)

0.5051(−12)

0.2136(−22)

$bj1λ8λ7λ6.5λ7.5λ7.5λ$


text:
Definition:Group of Units/Ring

Definition

Let $\struct {R, +, \circ}$ be a ring with unity.

Then the set $U_R$ of units of $\struct {R, +, \circ}$ is called the group of units of $\struct {R, +, \circ}$.

This can be denoted explicitly as $\struct {U_R, \circ}$.

Also denoted as

The group of units of a ring with unity $R$ is also seen denoted as $R^\times$, or explicitly as $\struct {R^\times, \circ}$.


text:
# If p, q be two A.M.'s and G be one G.M. between two numbers,

Question:

If pq be two A.M.'s and G be one G.M. between two numbers, then G2 =

(a) (2p − q) (p − 2q)

(b) (2p − q) (2q − p)

(c) (2p − q) (p + 2q)

(d) none of these

Solution:

(a) $(2 p-q)(p-2 q)$

Let the two numbers be $a$ and $b$.

$a, p, q$ and $b$ are in A.P.

$\therefore p-a=q-p=b-q$

$\Rightarrow p-a=q-p$ and $q-p=b-q$

$\Rightarrow a=2 p-q$ and $b=2 q-p$   ...(i)

Also, $a, G$ and $b$ are in G.P.

$\therefore G^{2}=a b$

$\Rightarrow G^{2}=(2 p-q)(2 q-p)$


text:
# City/Nation Builder - Unlocking game elements over time

Current Git (Needs more documentation)

Current working prototype to play with (Git code is after a BIG refactor)

Background: I'm making a javascript text city/nation builder along the lines of A Dark Room or Candy Box. This is going to be the player managing a city but be able to vassalise other cities (Ala Europa Universalis), giving you a tribute of their income but no specific control over it like your own one.

Each city has a tree of things in it, including buildings, resources, tools/machines and intermediate crafting items. These types each have their own object constructors and can easily have a complex object of about 5-50 keys depending on the item just from a few lines of code. Each tree starts at the top, a category for sorting on the UI/namespace, and then inside that is the actual object itself. So whenever referencing an item in a crafting recipe or production chain there's a "resource.material.wood" or "buildingHouse.tent.small" or such.

The player or "empire" can own multiple cities, but only directly control one in the city view screen (You can tell your city exactly how to be managed, but all other cities you've taken over live their own life, but you can send them requests and investments to boost specific things). Because the item trees are so expansive (170 items in the prototype on my website) I need an easy way to hide things away that aren't unlocked yet. Decided to go with the Civ 5 tech tree route.

Current problem: In the prototype I had the tech tree and items bound to the window instead of to the city. This meant there was only ever a single instance of everything and to unlock something in the UI I could just go (simplified) foreach (unlockedItem) {item.unlocked = true}. I can't do this as easily in the multiple city model because the tech system is player specific, not city specific, and so if you take over a new city they should retroactively build the city's tech level from that player's tech level. I'm not sure how I want to handle inheriting resources/buildings from a more advanced civ yet either.

Relevant code pulled from the Git as an example: pastebin.com/DbbUXbaL

As far as I can tell, there's a not so easy way I can work around this.

Flip the way I unlock things. The item is then bound to a tech that unlocks it instead of a tech being bound to multiple items. In my head I prefer the latter way because it means I can group like items together (The resource with the building that produces it) and it's easier to list the items that the tech unlocks when you're in the research menu. It's also much easier in the code to see what a tech unlocks at a glance, instead of going from class to class. The problem with the latter way though is that it's hard to retroactively unlock things in a newly unlocked city.

The question to Gamedev: Those of you with more experience than I, how would you go about designing a technology system for an entity heavy game like the Anno series or Civ if each tech unlocked 5+ things? Do I have the right idea binding the item to the tech or is there a much simpler way of doing it I'm just not seeing?

• Hi, and welcome to the site. Your question is quite detailed and includes a working prototype and a clear problem description. That's awesome. Welcome! (+1) – ashes999 Aug 6 '14 at 9:56

Here is my suggestions

Dealing with Trees You can do any tree by using tables. It can serve as dependency counter for what ever tree you are doing. Already tested by me some time ago were skill tree, knowledge tree and my favorite, item tree.

For this example we are going to use "Item" tree.

Each item will be a record for the table name ItemTree. They will be composed of the following fields:

id
itemName
Status
itemCaller
itemDependencyCounter
itemDependencyTotal
etc...

Status field indicates if item is locked or unlocked. It can have 0 or 1 value. 0 for locked and 1 for unlocked.

itemCaller are string typed field consisting of other item "id"s with separator (a comma) in which the content can be like so...

id, id, id, id...

itemDependencyCounter indicates how much times a dependency of that item has been unlocked.

itemDependencyTotal indicates the total dependency of that item before that item is unlocked.

How to use: Whenever an item is unlocked your program should read itemCaller and update the rest of the items indicated on it to increment their itemDependencyCounter. Then another loop on the table should check if there are new items where itemDependencyCounter is equal to their itemDependencyTotal. if there is, it will unlock that item and do the loop again until there are no more items needed to be unlocked.

Note that the number of items are dependent on certain amount of item plus numbers of scenarios/events (which again can be tabled in the same way).

Example item1 has 5 itemDependencyTotal but there are only 2 item calling(unlocking) it. This is possible because certain scenarios/events might hold the other 3 triggers missing in order to unlock that item.

All together it create this kind of logic example:

item=pike
dependencies=array(item=wood,item=Ore,knowledge=bronze,time>2000BC,etc...)
unlocks=array(unit=phalanx,item=spear,etc...)

You see the benefit here is prominent because you do NOT have to declare the actual dependencies. Only the unlocks are stated on the table. No Redundancy.

Again as I've mentioned scenarios/events even skills, knowledge and other game parameters for your cities or your character can be tabularized the same way.

This behaves like a tree but is much simplified in some way.

2 Dimensional Array You can also use 2 dimensional array that acts the same logic as table above. Problem here is you have to memorize the sequence which parameter gives status, itemDependencyCount and itemDependencyTotal. Another problem might be memory size but everything can be managed upto a certain degree.

Dealing with Multiple Cities. Using the solution above all you need is another field named "City". You can add a whole batch of item specific for that city that is currently locked and few unlocked items to begin.

Next you need to create an AI that randomly unlocks per item or per scenario/events. Then when your program does the checking for unlock, it should be included since they are one table.

Random Events and/or AI Randomly choosing things to do can have parameters that increase over time.

Example: Initially the AI (because of limited resources,items,knowledge,etc) can only do 5 things at one time but eventually increases as more parameters are unlocked. Therefore you can assign it like so...

 AITodo = Random(n)

where n is the number of things the AI can do.

How many tables should I put?. It depends on your games. Essentially if the table listed applies to your game tree, you can put it.

1.)Item  runned
2.)Skills
3.)Knowledge(like in Civ)
4.)Milestone/prizes
5.)Map Areas
6.)Resources
7.)Enemies

Example of Game Logic:

SetInitialScenario >> UserInteraction >> CoreLogic >> TerminatorChecks >>
Render >> BackToUserInteraction

Inside Core Logic:

AIInput >> UserAIValidation >> TableProcess >> OtherLogicYouLike >>
EnemyAIInput >> TableProcess >> OtherLogicYouLike >> ExitCoreLogic

where TableProcess is the "How to Use" as indicated above.

Task/Timer Organization You can put a single time-counter that checks the time based tasked. Again every time a task is expected to happen (after user interaction), tasked should be inserted to the table. The records of this task are index in time the task is suppose to finish.

Next is on your program logic you can add a TaskMonitor function that whenever a task is expired (current time >= timeToExpire) it will be deleted on the table and the desired changes are applied to the game. This function can be run Asynchronously or dependent on User activity.

Data Structures I could explain this to you or I can do this instead.

City1
City2
|_____Resources
|        |______Wood
|        |______Gold
|        |______etc...
|
|_____Production(Rates)
|        |______Wood
|        |______Gold
|        |______etc
|
|_____Building
|        |______Factories
|        |         |_______Smerlters
|        |         |_______ etc...
|        |______Homes
|        |______etc
|
|_____Tools
|_____Machines
|_____Item
|_____Research
City3
etc...

Do not confuse your data structures with game logic and functions. You need a way to associate the dependencies of your structure as tree... that is different. You need a function that monitors task... again that is different. You need an AI for the other Cities management... again different. You need an Enemy-AI that will randomly attack or give a challenge to your game... again it is a different function.

Try separating the logic for your user interaction versus the logic that happens behind the scene with or without user interaction.

Will it create an Overload the beauty of databases/tables is you do not need to store them on memory therefore your game will not be a resource hog. Overload may also be prevented by choosing a proper PL.

Programming Language Although it can be done in JavaScript there are better PLs out there that gives best results. Some favorites are C++, Java, even C#.net can be used to make games for XBOX. Note Rendering and actual game logic programming may use different applications.

Finally Do not overshoot your design. Make one and move on. Research some stuff then apply it to your next project.

• I'm not sure I follow. Are you saying to set up the unlocked status to watch each requirement that can unlock it (in my case, researching a technology or a random event) and have it cycle through those requirements each time something changes? Wouldn't that create a lot of overhead? Sorry for not understanding, JS was the first language I learnt and it's only been about 8-12 months of tinkering with it since I started. Usually I can BS my way through figuring out the intention of something but most of that flew over my head. – LastElf Aug 6 '14 at 13:32
• I'ĺl try to be more specific and will provide more example. I'm currently editing and adding stuff since you got lots of item up there. – Ace Caserya Aug 6 '14 at 13:35
• Ok done. Thanks for waiting. The key is there are always structures and functionality behind the scene. How a good game is appreciated is actually designing these key aspects cleverly and deploying them in-game for players to worry upon. – Ace Caserya Aug 7 '14 at 0:42
• Thanks Alvin. Sorry for taking so long to reply, saw all of that and went "This is going to take a while to digest." I do very much appreciate the detailed post you made, and if I were to do it again from scratch it makes sense to do it that way, but my reasons for making it in JS is to be platform independent and this style of game suits browsers better (Tribal Wars, Candy Box, Cookie Clicker to an extent). It's basically a "Facebook game" without the friends or the 8+ hour time constraints and a lot more combat depth. – LastElf Aug 11 '14 at 2:10
• I understand this makes it harder on myself, but JS is the language I'm wanting to learn (For other business reasons as well) so I'll stick with it. I did start to understand the post a lot better when it was finished though, and I'll probably be applying some of the things in there to it. As far as my question goes, you've given me an alternate way of doing it if I were to rewrite the architecture from scratch (a third time), but I'm still interested in finding a way around the problem without setting up a server-side DB for data lookups. – LastElf Aug 11 '14 at 2:13


text:
# NumPy Tensors, Slicing, and Images¶

Here's a more detailed example of how to interpret images as NumPy tensors.

(D = ndim)

# Images and Videos: 2D, 3D, 4D, 5D¶

Image type Coordinates
2D grayscale image (row, col)
2D color image (eg. RGB) (row, col, channel)
3D grayscale image (plane, row, col)
3D color image (plane, row, col, channel)
Video type Coordinates
2D color video (time, row, col, ch)
3D multichannel video (time, plane, row, col, ch)

# A simple 3D tensor¶

In [ ]:
import numpy as np

t = np.array([[
[1, -1, 11, -11],
[2, -2, 22, -22]
],

[
[3, -3, 33, -33],
[4, -4, 44, -44]
],

[
[5, -5, 55, -55],
[6, -6, 66, -66]
]])
t

In [ ]:
t.ndim # how many dimensions

In [ ]:
t.shape # what the dimensions are

### Tensor Lego¶

Here's a Lego representation of our tensor.

• Each 8-peg Lego brick represents one element.
• There are 3 major blocks
• Each major block contains 2 levels, each level has 4 elements.
• The flat gray piece will be our "slicer"

### Terminology and Rules¶

• By array, we refer to NumPy arrays (np.array), which can be multi-dimensional.

• Given an array of N dimensions, a slice always returns an array of N-1 dimensions.

### Slicing along the first dimension¶

The first dimension views our tensor this way:

t = np.array([
first_level_array0,  # [[  1,  -1,  11, -11],
#  [  2,  -2,  22, -22]]  <-- note the double square brackets
surrounding each chunk [[ ]]

first_level_array1,  # [[  3,  -3,  33, -33],
#  [  4,  -4,  44, -44]]

first_level_array2   # [[  5,  -5,  55, -55],
#  [  6,  -6,  66, -66]]
])

Therefore, a slice along the first dimension will cut in between the chunks:

Slice 0 along the first dimension returns the first big "chunk".

In [ ]:
t[0, :, :]

Slice 1 along the first dimension returns the next big "chunk".

In [ ]:
t[1, :, :]

### Slicing along the second dimension¶

The second dimension views our tensor this way:

t = np.array([[
second_level_array0,  # [  1,  -1,  11, -11],
second_level_array1   # [  2,  -2,  22, -22]   <-- note the single square brackets
surrounding each second level array [ ]
],

[
second_level_array0,  # [  3,  -3,  33, -33],
second_level_array1   # [  4,  -4,  44, -44]
],

[
second_level_array0,  # [  5,  -5,  55, -55],
second_level_array1   # [  6,  -6,  66, -66]
]])

Because this is a slice, each second-level array is actually composed of 3 vectors:

second_level_array[0]: [[  1,  -1,  11, -11], [  3,  -3,  33, -33], [  5,  -5,  55, -55]]

second_level_array[1]: [[  2,  -2,  22, -22], [  4,  -4,  44, -44], [  6,  -6,  66, -66]]

A slice along the second dimension will "slice the cake" horizontally:

Slice 0 along the 2nd dimension:

In [ ]:
t[:, 0, :]

Slice 1 along the 2nd dimension:

In [ ]:
t[:, 1, :]

### Slicing along the third dimension¶

The third dimension is the hardest to visualize, because we need to look at each element in the deepest nested array.

t = np.array([[
[element0, element1, element2, element3],  # [  1,  -1,  11, -11],
[element0, element1, element2, element3]   # [  2,  -2,  22, -22]
],

[
[element0, element1, element2, element3],  # [  3,  -3,  33, -33],
[element0, element1, element2, element3]   # [  4,  -4,  44, -44]
],

[
[element0, element1, element2, element3],  # [  5,  -5,  55, -55],
[element0, element1, element2, element3]   # [  6,  -6,  66, -66]
]])

In other words:

• the 0th slice on the third dimension creates an array that "collects" all the element0s
• the 1st slice "collects" all the element1s,
• and so on

Something like this:

third_dimension_slice[0]: [1, 2], [3, 4]  [5, 6]

third_dimension_slice[1]: [-1, -2], [-3, -4], [-5, -6]

Here's slicing looks like for the 3rd dimension, for the first slice:

In [ ]:
t[:, :, 0]

In [ ]:
t[:, :, 1]

In [ ]:
t[:, :, 2]

In [ ]:
t[:, :, 3]

## Tensor of a 2D image¶

The tensor for a 2D image (3 rows, 2 columns, 3 channels) that in channels last ordering looks like:

### Slicing by row¶

(The 2D image is facing sideways)

### Slicing by column¶

(The 2D image is facing sideways)

### Slicing by channel¶

(The 2D image is facing sideways)

# Slicing a 2D image using NumPy¶

In [ ]:
from PIL import Image
import requests
import matplotlib.pyplot as plt

url = 'https://edoras.sdsu.edu/doc/matlab/toolbox/images/colorcube.jpg'

image = Image.open(requests.get(url, stream=True).raw)

Next, we'll wrap the image in a numpy.array, which converts it to a tensor.

We'll get its shape.

In [ ]:
tensor = np.array(image)

tensor.shape

Let's also check the number of dimensions

In [ ]:
tensor.ndim # number of dimensions

Finally, plot the image

In [ ]:
plt.imshow(image)
plt.axis('off')
plt.show()

Let's get the first 10 rows

In [ ]:
tensor[:10, :, :].shape

In [ ]:
plt.imshow(tensor[:10, :, :])
plt.axis('off')
plt.show()

Let's get the first 100 columns

In [ ]:
tensor[:, :100, :].shape

In [ ]:
plt.imshow(tensor[:, :100, :])
plt.axis('off')
plt.show()

Let's get the middle 10 rows.

That's between (num_rows / 2) - 5 and (num_rows / 2) + 5 rows

In [ ]:
num_rows = tensor.shape[0] # recall shape = (row, column, channel)
num_rows

In [ ]:
# // means divide and get the integer value, for example: 5//2 = 2

middle_ten_rows = tensor[(num_rows//2 - 5):(num_rows//2 + 5):1, :, :]

middle_ten_rows.shape

In [ ]:
plt.imshow(middle_ten_rows)
plt.axis('off')
plt.show()

Let's get the middle 10 columns.

That's between (num_cols / 2) - 5 and (num_cols / 2) + 5 rows

In [ ]:
num_cols = tensor.shape[1]
num_cols

In [ ]:
middle_ten_cols = tensor[:, (num_cols//2 - 5):(num_cols//2 + 5):1, :]

middle_ten_cols.shape

In [ ]:
plt.imshow(middle_ten_cols)
plt.axis('off')
plt.show()

# Slicing to get per-channel data¶

This image has 3 colour channels: red, green, blue. This is known as the RGB colour space, and is the most commonly used.

An alternative colour space is blue, green, red on libraries such as OpenCV. There are converters available to convert between RGB to BGR, and other colour spaces.

Let's see how we can get the first channel (red).

Here's the syntax to get a slice

np.array[slice1, slice2, slice3, ...]

So for our 3-D tensor, we use : to denote the slice for all rows and all columns, and 0 as the index of the first channel.

In [ ]:
# all_rows, all_columns, red_channel

tensor[:, :, 0].shape

In [ ]:
# use grayscale colormap. Otherwise default is 'viridis' (see matplotlib.rcParams)
plt.imshow(tensor[:, :, 0], cmap='gray')
plt.axis('off')
plt.title('Red channel only (black: 0, white: 255)')
plt.show()

In [ ]:
# all_rows, all_columns, green_channel

tensor[:, :, 1].shape

In [ ]:
plt.imshow(tensor[:, :, 1], cmap='gray')
plt.axis('off')
plt.title('Green channel only (black: 0, white: 255)')
plt.show()

In [ ]:
# all_rows, all_columns, blue_channel

tensor[:, :, 2].shape

In [ ]:
plt.imshow(tensor[:, :, 2], cmap='gray')
plt.axis('off')
plt.title('Blue channel only (black: 0, white: 255)')
plt.show()

# Channel-first ordering¶

Our example image is using channels-last dimension ordering.

Some platforms prefer channels-first dimension ordering, where the shape is:

(channels, rows, columns)

Let's see how we can convert an image from channels-last to channels-first ordering.

Note that MatplotLib will only accept images that are channels-last ordering. It will fail to plot an image with channels-first ordering (you'll have to convert it back).

In [ ]:
tensor.shape

In [ ]:
np.moveaxis?

In [ ]:
# np.moveaxis(a, source, destination)

# move the last axis (-1) to become the first axis
np.moveaxis(tensor, -1, 0).shape

# Grayscale images¶

Grayscale images (or black and white images) have only 1 channel. So, they are 2-D tensors.

However, when you download them from the internet, they have 3 channels. This can get confusing.

In [ ]:
url = 'https://upload.wikimedia.org/wikipedia/commons/f/f2/Broadway_tower_grayscale.jpg'

image_gray = Image.open(requests.get(url, stream=True).raw)

# plot the image
plt.imshow(image_gray)
plt.axis('off')
plt.show()

The shape will show 3 channels.

In [ ]:
np.array(image_gray).shape

The values of the 3 channels are all the same.

In [ ]:
gray = np.array(image_gray)

np.testing.assert_array_equal(gray[:, :, 0], gray[:, :, 1]) # no assert means they are equal
np.testing.assert_array_equal(gray[:, :, 0], gray[:, :, 2]) # no assert means they are equal
np.testing.assert_array_equal(gray[:, :, 1], gray[:, :, 2]) # no assert means they are equal

You can pick any one of them without loss of data.

In [ ]:
plt.imshow(gray[:, :, 0], cmap='gray')
plt.axis('off')
plt.show()


text:
# Classification of local and semi-local rings in function fields

Let $C$ be a non-singular algebraic curve over an algebraically closed field $k$, and $F$ a function field of this curve. It is well-known that non-trivial discrete valuation rings of $F$ correspond to points of $C$.

Is there any classification of local and semi-local rings in $F$? What examples of semi-local rings in $F$ do you know?

• Cross-posted: math.stackexchange.com/questions/1283525/… May 17, 2015 at 14:11
• I found some classification of semi-local rings by local rings. A semi-local ring $\neq F$ may be expressed as the intersection of a finite number of local rings, no two of which have a place in common, in one and only one way. See jstor.org/stable/1969773?seq=1#page_scan_tab_contents (Rosenlicht M. Equivalence Relations on Algebraic Curves, theorem 3). May 21, 2015 at 11:26

This isn't a full answer, just a sketch.

Well, presumably you want all the elements of $k$ to be units in your local and semi-local rings (ie $k \subseteq R$)? Otherwise things can get very complicated.

I think such a classification does indeed though exist, here's how I would proceed:

Take $R$ to be a local or semi-local (Noetherian?) ring in $F$ that has all elements of $k$ as units. Consider the normalization $S$ of $R$. This normalization should be semi-local and an intersection of those DVRs. Then you can re-obtain $R$ from $S$ by doing a pullback in the category of rings.

Is there a "geometric" intuition underlying the notion of normal varieties?

and

Obtaining non-normal varieties by pushout

The relevant thing is that you noticed that $S = \bigcap R_i$ where the $R_i$s are DVRs, then you would pick ideal an ideal $I \subseteq S$ (which can just be thought of as picking an ideal in each $R_i$) and forming the pullback of the diagram

$$\{ S = \bigcap R_i \to \prod S/I \leftarrow A \}$$ where $A$ is some subring of the (usually Artinian) ring $S/I$.

• Of course $k \subsetneq R$. For simplicity, let rings be Noetherian. Karl, thank you for the first answer the question. May 21, 2015 at 11:34


text:
# Time-frequency analysis of HD 174936 and HD 174966 using the synchrosqueezed wavelet transform

DOI:
10.3389/fspas.2022.948979
Publication date:
22/07/2022
Main author:
Ramón-Ballesta A.
IAA authors:
Ramón-Ballesta, A.;Pascual-Granado, J.;Garrido, R.
Authors:
Ramón-Ballesta, A.;Pascual-Granado, J.;Garrido, R.
Journal:
Frontiers in Astronomy and Space Sciences
Publication type:
Article
Volume:
9.0
Number:
948979
Abstract:
δ Scuti stars are intermediate-mass pulsators located in the classical Cepheid instability strip with spectral types ranging from A to F. In the last years, some authors found an amplitude and frequency modulation in some of these stars. In our work we have chosen the continuous wavelet transform as the more appropriate tool to perform a time-frequency analysis of the light curves of HD 174936 and HD 174966. We have chosen this tool because, unlike the short time Fourier transform, that uses a fixed windows size, the continuous wavelet transform uses short windows at high frequencies and long windows at low frequencies, making it like an adaptive analysis tool. In order to improve the resolution of the frequencies obtained by the continuous wavelet transform, we have also used the synchrosqueeze algorithm to “focus” the result. Then, we are capable to obtain a measure of the instantaneous frequencies of the signal in a wide range of frequencies. To check our results, we have compared them with the synchrosqueezed continuous wavelet transform of a synthetic signal generated with the frequencies previously obtained by a classical approach. Our results show that some frequencies are stable, at least within the observation run time, although some others show some kind of variation. This is the first time that such variations in the oscillation frequencies of HD 174936 and HD 174966 are reported.
Database:
SCOPUS
Keywords:
asteroseismology | stars:Delta Scuti | stars:pulsations | stars:variable | synchrosqueeze | wavelet analysis | wavelet transform


text:
Propagator for Dirac equation in real space

I'm interested in the retarded propagator for a free massless Dirac fermion, i.e. solutions $ψ$ to the inhomogeneous PDE

$$(∂_t- \nabla·\vec σ) ψ(x,t) = f(x,t)$$

with boundary conditions

$$\quad ψ(x,t) \to 0 \text{ for } t \to -∞$$

where $\vec σ = (σ_1,σ_2,σ_3)^T$ are the three Pauli matrices. (The boundary conditions can be even more restrictive, I just want the solution to decay sufficiently quickly at infinity so that it becomes unique and has a well-defined Fourier transform.)

Now, solving the Dirac equation is a standard exercise in virtually every QFT book, but all the books I've looked at only consider the Fourier transform of the propagator.

However, I am interested in the real space formula for the retarded propagator

Using the retarded propagator for the wave equation in $3+1$ dimensions, we can write

$$ψ(x,t) = (∂_t + \nabla·\vec σ)(∂_t^2 - \nabla^2)^{-1} f(x,t)$$

$$= (∂_t + \nabla·\vec σ) \frac1{4π·\text{something}}∫d^3x'dt' \frac1{|x-x'|}\delta(|x-x'|-|t-t'|) f(x',t')$$

but this formula strikes me as seriously weird: carrying out the differentiation with respect to $x$ and $t$ will differentiate the $\delta$-function in the integral, which means that the solution depends on the derivatives of the function $f$. This goes against my intuition that a linear first-order PDE should depend on the initial values directly, and not on their time and space derivatives!

Is there a reference where I can find a discussion of the retarded propagator of the (massless) Dirac equation in real space?

• You are summing on all $t'$, so your expression does not depends on a value of the time derivative of $f$ at one precise initial time $t_0$, but for all $t'$. – Trimok Oct 17 '13 at 10:50
• @Trimok: We can choose $f(x',t') = g(x')\delta(t'-t_0)$ to model initial conditions at a time $t_0$. In general, the propagator for a driving force $f$ can always be used to construct the propagator for initial conditions $ψ(x,t_0)$. – Greg Graviton Oct 18 '13 at 8:08
• "This goes against my intuition that a linear first-order PDE should depend on the initial values directly, and not on their time and space derivatives!" . In fact, one may always rewrite an expression with explicit first derivatives. Take for instance the differential equation $\frac{d\psi(x)}{dx} = f(x)$. The solution is $\psi(x) = \psi(0)+\int_0^x du f(u)$. However, with an integration by parts, this could be written $\psi(x) = \psi(0)+ xf(x) -\int_0^x du ~u ~f'(u)$, or even $\psi(x) = \psi(0)+ xf(0) + x\int_0^x du ~f'(u) -\int_0^x du ~u ~f'(u)$ – Trimok Oct 26 '13 at 19:01
• Your formula is correct. You may also use an alternative form of the massless scalar retarded propagator, this will give you : $\psi(x) = (\sigma.\partial)\int d^4x' \frac{1}{2 \pi} \delta((x-x')^2)\theta(x_0 - x'_0)f(x')$ – Trimok Oct 29 '13 at 6:58
• @Trimok: Moving the differentiation under the integral sign would mean that the propagator involves the derivative of a delta function, though, which I find odd. You make the argument that you "involving a derivative" is not an invariant property of the propagator, which I can't deny. One way to formalize it is to ask whether the solution changes when we add a constant to the function $f \to f + C$. (But this may be forbidden due to boundary conditions.) – Greg Graviton Oct 29 '13 at 14:15

The real space propagator for the massive Dirac fermion in $3+1$ dimensions is calculated in R. Feynman's book Quantum Electrodynamics (Lecture 17, page 84 in the edition linked to).

The result is very much as indicated in the question: first solve the wave equation, then differentiate the solution with the Dirac operator again. In particular, Feynman calculates the propagator of the Klein-Gordon equation in real space:

$$I_+(t,x) = ∫ \frac{d^4p}{(2π)^4} \frac{\exp[-i(p\cdot x)]}{p^2 - m^2 + i\varepsilon} = -(4π)^{-1} \delta(s^2) + \frac{m}{8πs}H_1^{(2)}(ms)$$

Here, $s = +(t^2-x^2)^{1/2}$ for $t>|x|$ and $s = -i(x^2-t^2)^{1/2}$ for $t < |x|$. Moreover, $\delta(s^2)$ is a delta function and $H^{(2)}_1(ms)$ is a Hankel function. Then, you have to differentiate the delta function, indeed.

However, note that to be physically meaningful, the propagator $G(x_2,t_2;x_1,t_1)$ for the Dirac equation should only take into account the positive energy states for the retarded time frame $t_2 - t_1 > 0$, while the advanced portion $t_2 - t_1 < 0$ should only take into account the negative energy eigenstates (holes).

maybe you already thought about it, but I'll ask anyway: why don't you try to tackle directly the differential operator: $\partial_t -\vec{\sigma}\cdot\nabla$ ? It's a first order PDE so you would get something of the kind: $$\psi(x,t) = \psi_0(x,t) + \int G(x,x',t,t')f(x',t')\, dx'dt' \qquad \text{(1)}$$ Where $\psi_0(x,t)$ is a solution of the homogeneous equation and $G(x,x',t,t')$ is the solution of $$(\partial_t -\vec{\sigma}\cdot\nabla)G(x,x',t,t') = \delta(x-x')\delta(t-t')$$

Now, it can be shown that equation 1 can be cast into the form (see Ref.): $$\psi(x,t) = \psi_0(x,t) + \int dx' \int_{-\infty}^t G_1(x,x',t,t')f(x',t')\, dt' \qquad \text{(2)}$$

where $G_1(x,x',t,t')$ is an object that satisfy: $$(\partial_t -\vec{\sigma}\cdot\nabla)G_1(x,x',t,t') = 0$$

and therefore should be less clumsy to solve.

Reference: Mathematical Method of Classical and Quantum Physics, F. W. Byron and R. W. Fuller. Chapter 7: Time-dependent Green's functions: First Order

• I think there is a problem in your equations. (1) and (2) are exactly the same (just the index $_1$ changes), so they can't be both true. I think you forget the $'$ of $f(x',t')$ in equation (1). – Adam Oct 24 '13 at 14:10
• You're absolutely right for what concerns the primes, you're also right for what concerns the integrals, I should have specified the integration extremes! Please see the Edit – Mattia Oct 24 '13 at 14:13
• Is $G_1(x,x',t,t)=\delta(x-x')$ ? Otherwise, I don't understand how eq. (2) can work... – Adam Oct 24 '13 at 14:22
• More precisely: $\lim_{t'\rightarrow t} G_1(x,x',t,t') = \delta(x-x')$ – Mattia Oct 24 '13 at 14:35
• I understand that, what I'm looking for is an explicit formula for the Greens function $G_1(x,x;t,t')$. I have the impression that it involves the derivative of a $\delta$-function, and I just want to make sure that this is correct by comparing to an explicit reference. (All textbooks that I've looked at only calculate the Fourier transform $G_1(k;t,t')$). – Greg Graviton Oct 25 '13 at 12:39


text:
How to realize DFT6 with 3 DFT2 blocks?

Is it possible to realize DFT of 6 samples by using 3 DFT2 blocks? For example if had 2 * N samples by one step of decimation in frequency or time is possible to reduce DFT(2N) to 2 * DFT(N). So if we had 2 * DFT(N) blocks we could do it that way. What if we had 3N samples and 3 DFT(N) blocks. In my question N equals 2. How would the structure look and what is formula for X(k) element of spectrum?

The basic problem here is how to find different ways to calculate DFT with given blocks and using only additional sum blocks and multiplying with twiddle factors?

• You should define more clearly what you want to do. Also, there's a lot of literature on FFT implementations out there, so what are you basing your question on? – Marcus Müller Feb 1 '16 at 11:30
• Ok. This was question from oral exam in DSP course. – dumpram Feb 1 '16 at 11:53
• I find it very bad style to ask exam/homework/assignment questions on here without giving the info where they come from, and what background the person asked is expected to have. – Marcus Müller Feb 1 '16 at 20:47
• The structure you came up with is basically equivalent to 3 length-2 DFTs followed by 2 length-3 DFTs. That's what you will always get: if you split $N=N_1\cdot N_2$, you can implement a length-$N$ DFT as $N_1$ length-$N_2$ DFTs followed by $N_2$ length-$N_1$ DFTs. Have a look at this blog post for more details. – Matt L. Feb 2 '16 at 8:49
• @MattL. I also consider the edit to not really be part of the question but rather an answer; so I vote to reopen the question, allowing OP to self-answer it, and mark it answered tomorrow. Dumpram, could you still please add a little more background info to the question, and as soon as it is reopened, delete your solution from the question itself and post it as an answer? – Marcus Müller Feb 2 '16 at 11:33

The following is an important paper about FFT algorithms:

Tran-Thong, “Algebraic Formulation of the Fast Fourier Transform,” IEEE Circuits and Systems magazine, vol. 3, no. 2, June 1981, pp. 9-19.

In the above, the author distinguishes 16 basic types of FFT algorithm, characterized by: 1) decimation type (DIT - type T below, or DIF - type F below), 2) input order, 3) output order, and 4) geometry. The author also shows graphs, but they will not be shown here.

Alg.    Input Order Output Order Geometry

T1      bit reverse sequential  in-place
T2      sequential  bit reverse in-place
T3      bit reverse bit reverse same output
T4      sequential  sequential  same output
T5      bit reverse bit reverse same input
T6      sequential  sequential  same input
T7      bit reverse sequential  isogeometric
T8      sequential  bit reverse isogeometric

F1      bit reverse sequential  in-place
F2      sequential  bit reverse in-place
F3      bit reverse bit reverse same output
F4      sequential  sequential  same output
F5      bit reverse bit reverse same input
F6      sequential  sequential  same input
F7      bit reverse sequential  isogeometric
F8      sequential  bit reverse isogeometric

Although many of the algorithms can be attributed to different authors, as stated in the above paper: "The Cooley-Tukey algorithm and its modifications are DIT algorithms. The Gentleman-Sande algorithms and their modifications are DIF algorithms."

There are many more FFT algorithms other than the ones described above, including higher and mixed radix ones. But they also exhibit similar characteristics. For instance, take a look at the 6 point DIT radix-3/radix-2 graph shown on page 13 in the following reference:

http://www.ece.cmu.edu/~ee791/lectures/L18/FFTstructures.pdf

It is two radix-3 butterflies followed by three radix-2 butterflies. It is bit-reversed input and sequential output.

Of course, given that the FFT can be viewed as a matrix transpose, one can also decompose a 6 point FFT into three radix-2 butterflies, followed by two radix-3 butterflies. You can also have DIT or DIT (or mixed decimation). So you have several options to choose from.

Ok, I worked out this and i got this for decimation in time:

And here is how structure looks:

• (comment made after question was edited) Your graph is not an FFT. An FFT relies on minimizing calculations by reusing intermediate results. Compare the total number of operations in your graph to the radix-3/radix-2 FFT shown on p. 13 of the link in my answer, and note the number of unity twiddles in the latter. What you have, in contrast, is a radix-2 stage, followed by a stage of multiply/sum DFT nodes. – user14819 Feb 5 '16 at 7:06


text:
## anonymous one year ago Use Newton's method with initial approximation x1 = 1 to find x2, the second approximation to the root of the equation x4 − x − 8 = 0. I worked it out and got 3.6666667 but it was wrong, please help!

1. jim_thompson5910

Newton's Method $\Large x_{n+1} = x_n - \frac{f(x_n)}{f \ '(x_n)}$

2. jim_thompson5910

If n = 1, then $\Large x_{n+1} = x_n - \frac{f(x_n)}{f \ '(x_n)}$ $\Large x_{1+1} = x_1 - \frac{f(x_1)}{f \ '(x_1)}$ $\Large x_{2} = 1 - \frac{f(1)}{f \ '(1)}$ So you need to compute both f(1) and f ' (1). Do you know how to do that?

3. anonymous

yeah, i worked everything out i got x^4-x-8/4x^3-1 and I plugged in 1 for the x and then got -8/3, then i did 1-(-8/3) and got 3.66667?

4. jim_thompson5910

Yeah I'm getting that too. Maybe they want you to round a very specific way?

5. jim_thompson5910

I doubt they want it as a fraction, but who knows really.

6. anonymous

that's what i was thinking, that maybe they wanted it in fraction form, but it doesn't specify...

7. jim_thompson5910

I've never seen newton's method approximations as fractions. Usually they are in decimal form. Can you post a screenshot of the full problem?

8. anonymous

Use Newton's method with initial approximation x1 = 1 to find x2, the second approximation to the root of the equation x4 − x − 8 = 0. x2 =3.67 Incorrect: Your answer is incorrect.

9. anonymous

That's all of it

10. jim_thompson5910

Hmm so odd and frustrating. It would be nice if they added "round to 5 decimal places" or something.

11. anonymous

exactly! and i only have two tries so im scared to use my last one and get it wrong, since i dont know how im supposed to type the answer

12. jim_thompson5910

The only thing you can do really is look back at previous correct problems to see what the computer wants. Or try to guess it anyway.

13. jim_thompson5910

Or ask the teacher. I would ask for points back if you get it wrong since this problem is unfair.

14. anonymous

yeah I'll try to do that, thanks for checking my answer though!

15. jim_thompson5910

no problem

16. anonymous

it was in fraction form lol

17. jim_thompson5910

so strange, but I guess computers tend to be that way