# System Reliability Basics

For the pdf version, click here.

Almost everything we use every day can be thought of as a system built from components. Our lungs form a system. A string of lights forms a system. A manufacturing process, and a data center are also systems that are more complicated. Every system is built from **components**, and components are either *functional* or *failed*.

**Remark:** We can get more advanced and consider components in states of varying health and age, but we’re going to consider only the binary states of functional and failed.

Suppose a given system has *n* components. Each component will be either on or off. We call these binary states **component states** and give them a nice, natural mathematical definition.

**Definition (Component states). **

**Definition (Component states).**

The **state** of component *i* is denoted x_{i} and is defined by

Now, depending on how these components interact, the entire system is either functional or failed. We can write these component states in a vector called the **system state vector**:

**Definition (System State Vector).**

For *n* components in a system, each with state x_{i}, the system state is defined by \mathbf{x} = (x_{1},\ldots,x_{n}).

The system state vector is a combination of 1’s and 0’s corresponding to which components are functioning or failing. It is not always true that a single component failure (where its component state is 0) will result in a system failure. For example, you can still type with 8 fingers instead of 10, so two fingers in a splint will not keep you from your office duties. We can define a **structure function** that takes a system state vector as an input and tells us if the entire system is functioning or failed. So for example, the structure function of “typing with fingers” should return a 1 (functional) for any system state vector with two 0’s adjacent (since a split binds two fingers together). For example if we let \phi(\mathbf{x}) be the structure function of the act of typing with fingers, \phi(1,0,0,1,1,1,1,1,1,1) will return a 1, because we can still type with only 8 functioning fingers. Formally,

**Definition (Structure Function)**

The **structure function** of a system \phi : \mathbf{x} \to \{0,1\} is defined as

\phi(\mathbf{x}):= \left\{\begin{array}{lr}1, & \text{ the system is functioning when the state vector is x}\\0, &\text{the system has failed when the state vector is x}\end{array}\right.

**Remark: ***For a system with n components, there are 2^n possible system state vectors. To see this, remember that if each component state has two possibilities, and there are n states, then there are 2\cdot2\cdots2 = 2^n system state vectors*

Each system has a* topology*, i.e. its component arrangement. Here, we are concerned with the *reliability topology*, which tells us what combinations of components are needed to function in order for our system to be working. We use a tool called **block diagrams** to represent these.

### Example (Series System)

One of the simplest types of systems is the series system. In this example, if one component fails, the whole system goes down.

The block diagram shows us in a clear visual way if the system is functioning. The goal is to be able to move from left to right in the diagram. If a component is functioning, we may move through that node. If not, that “path” is closed. In the series system, there is only one possible path from left to right through every single component. If I cannot find a path from left to right, the system is not functioning when the given set of components is out. Thus, for the series system, removing even one component removes the only path I have to a functioning system.

The structure function for a series system is given by

\phi_{\text{series}}(\mathbf{x}) = \prod_{i=1}^{n}x_{i}

Here, we can see that if any state vector is 0, the whole product is 0, which means the system fails. Conversely, the only way \phi(\mathbf{x}) can be 1 is if x_{i} = 1 for every *i*.

**Remark: **The Christmas lights happen to physically match that reliability topology given in above. This isn’t always the case. The physical arrangement doesn’t necessarily correspond to the reliability toplogy. For example, we can view a simple computer as a processor, a motherboard, a hard drive, and a power supply. These are not physically arranged in a line inside your computer case, but if any one of these components fails, your computer is useless.