The answers to the *Circuit Cellar* 274 Engineering Quotient are now available. The problems and answers are listed below.

**Problem 1—**What is wrong with the name “programmable unijunction transistor?”

**Answer 1—**Unlike the original unijunction transistor—which really does have just a single junction—the programmable unijunction transistor (PUT) is actually a four-layer device that has three junctions, much like a silicon-controlled rectifier (SCR).

**Problem 2—**Given a baseband channel with 3-kHz bandwidth and a 40-dB signal-to-noise ratio (SNR), what is the theoretical capacity of this channel in bits per second?

**Answer 2**—The impulse response of an ideal channel with exactly 3 kHz of bandwidth is a sinc (i.e., sin(x)/x) pulse in the time domain that has nulls that are 1/6,000 s apart. This means you could send a series of impulses through this channel at a 6,000 pulses per second rate. And, if you sampled at exactly the correct instants on the receiving end, you could recover the amplitudes of each of those pulses with no interference from the other pulses on either side of it.

However, a 40-dB signal-to-noise ratio implies that the noise power is 1/10,000 of the maximum signal power. In terms of distinguishing voltage or current levels, this means you can send at most sqrt(10,000) = 100 distinct levels through the channel before they start to overlap, making it impossible to separate one from another at the receiving end.

100 levels translates to log2100 = 6.64 binary bits of information. This means the total channel capacity is 3,9840 bits/s (i.e., 6,000 pulses/s × 6.64 bits/pulse).

This is the basis for the Shannon-Hartley channel capacity theorem.

**Problem 3—**In general, is it possible to determine whether a system is linear and time-invariant (LTI) by simply examining its input and output signals?

**Answer 3—**In general, given an input signal and an output signal, you might be able to definitively state that the system is not linear and time-invariant (LTI), but you’ll never be able to definitively state that it is, only that it might be.

The general technique is to use information in the input signal to see whether the output signal can be composed from the input features. Input signals (e.g., impulses and steps) are easist to analyze, but other signals can also be analyzed.

**Problem 4—**One particular system has this input signal:

The output is given by:

Is this system LTI?

**Answer 4**—In this example, the input is a rectangular pulse that can be analyzed as the superposition of two step functions that are separated in time, one positive-going and the other negative-going. This makes the analysis easy, since you can see the initial response to the first step function then determine whether the response following the second step is a linear combination of two copies of the first part of the response.

In this case, the response to the first step function at t = 0 is that the output starts rising linearly, also at t = 0. The second (negative) input step function occurs at t = 0.5, and if the system is LTI, you would expect the output to also change what it’s doing at that time. In fact, you would expect the output to level off at whatever value it had reached at that time, because the LTI response to the second step should be a negative-going linear ramp, which, when added to the original response, should cancel out.

However, this is not the output signal received, so this system is definitely not LTI.

Regarding Problem 4 of issue 274:

I may be missing something, but I think that unless additional constraints are imposed (like “lumped parameter” components) the behavior described in the problem can actually be realized by an LTI system like the following:

y(t) = int{ x(t) +x(t-0.5) -x(t-1) -x(t-1.5) }

which can be implemented using delay elements, adders/subtractors, and an integrator.

In terms of the system’s impulse response,

y(t) = x(t) * h(t) where h(t) = u(t) +u(t-0.5) -u(t-1) -u(t-1.5)

where * denotes convolution and u(t) is the unit step function.

Best regards,

Alen Docef

In what sense do you consider the “int()” function to be linear?

I did reply to this a while ago, but my reply seems to have disappeared.

By “int{}” I meant integration over time. Integration is a linear operation in the same sense that a system is linear (the “L” in “LTI”):

int{ ax1(t) + bx2(t) } = a int{x1(t)} + b int{x2(t)}