({{, (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution])[bexpr,{{(Subscript[x, 1]),(Subscript[dist, 1])},{(Subscript[x, 2]),(Subscript[dist, 2])},…}] 
represents the reliability distribution for a system with components (Subscript[x, i]) having reliability distribution (Subscript[dist, i]), where the whole system is working when the Boolean expression bexpr is (RefLink[True, paclet:ref/True]), and component (Subscript[x, i]) is working when (Subscript[x, i]) is (RefLink[True, paclet:ref/True]).}})

OpenersNotesSection(Spacer1)Details

(RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution])[bexpr,…] corresponds to a reliability block diagram specification.

The Boolean expression bexpr is also known as the structure function for the system.

Typical structure functions include:

The structure function bexpr can be any positive unate Boolean function.

(RefLink[UnateQ, paclet:ref/UnateQ])[bexpr] can be used to test whether a Boolean expression is positive unate.

The component reliability distributions (Subscript[dist, i]) need to be univariate with (RefLink[PDF, paclet:ref/PDF])[(Subscript[dist, i]),t] zero for t≤0.

For (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution])[bexpr,…] with component indicator variables (Subscript[x, i]):

The survival function at time t for (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution])[bexpr,{{(Subscript[x, 1]),(Subscript[dist, 1])},…}] is given by (RefLink[Probability, paclet:ref/Probability])[bexpr/.{(Subscript[x, 1])->(Subscript[t, 1])>t,…},{(Subscript[t, 1])\[Distributed](Subscript[dist, i]),…}].

(RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) can be used with such functions as (RefLink[Mean, paclet:ref/Mean]), (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]), (RefLink[HazardFunction, paclet:ref/HazardFunction]), and (RefLink[RandomVariate, paclet:ref/RandomVariate]).

OpenersPrimaryExamplesSection(Spacer1)Examples  (60)

OpenersExampleSection0(Spacer1)Basic Examples  (3)

A series-connected system:

ℛ=ReliabilityDistribution[x∧y,{{x,ExponentialDistribution[(Subscript[λ, 1])]},{y,ExponentialDistribution[(Subscript[λ, 2])]}}]

Mean time to failure:

Mean[ℛ]

A parallel-connected system:

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[(Subscript[λ, 1])]},{y,ExponentialDistribution[(Subscript[λ, 2])]}}];

Mean time to failure:

Mean[ℛ]

One component in series with two parallel components:

ℛ=ReliabilityDistribution[x∧(y∨z),{{x,ExponentialDistribution[3]},{y,ExponentialDistribution[1]},{z,ExponentialDistribution[2]}}];

Distribution functions:

Table[Plot[df[ℛ,t],{t,0,2},PlotLabel->df,PlotRange->All],{df,{SurvivalFunction,HazardFunction,PDF,CDF}}]

Mean and median time to failure:

{Mean[ℛ],Median[ℛ]}

N[%]

The probability that the system fails before time t==1/2:

Probability[t<0.5,t\[Distributed]ℛ]

OpenersExampleSection1(Spacer1)Scope  (26)

OpenersExampleSubsection0(Spacer1)Basic Uses  (4)

Find the mean time to failure for a parallel system with two components:

ℛ=ReliabilityDistribution[x∨y,{{x,WeibullDistribution[1,β]},{y,ExponentialDistribution[2]}}];

Mean[ℛ]

Plot[%,{β,0,1}]

Find the (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]) of a system that needs two out of three components to work:

{𝒟1,𝒟2,𝒟3}={ExponentialDistribution[1],ExponentialDistribution[2],ExponentialDistribution[3]};

ℛ=ReliabilityDistribution[BooleanCountingFunction[{2,3},{x,y,z}],{{x,𝒟1},{y,𝒟2},{z,𝒟3}}];

SurvivalFunction[ℛ,t]

Plot[%,{t,0,2},Filling->Axis,PlotRange->All]

Find the mean time to failure (MTTF) for a serial system with one standby component:

{𝒟1,𝒟2}={StandbyDistribution[ExponentialDistribution[1/10],{ExponentialDistribution[1/5]}],WeibullDistribution[1,7]};

ℛ=ReliabilityDistribution[x∧y,{{x,𝒟1},{y,𝒟2}}];

NExpectation[t,t\[Distributed]ℛ]

Generate random numbers for a serially connected system:

ℛ=ReliabilityDistribution[x∧y,{{x,ExponentialDistribution[1]},{y,WeibullDistribution[2,3]}}];

data=RandomVariate[ℛ,10^4];

Compare the histogram to the PDF:

Show[
Histogram[data,{0,4,1/3},"PDF"],
Plot[Evaluate[PDF[ℛ,x]],{x,0,4},PlotStyle->Thick],PlotRange->All]

OpenersExampleSubsection1(Spacer1)Structure Functions  (7)

A system with two components in series with two in parallel:

ℛ=ReliabilityDistribution[(x∧y)∧(z∨w),{{x,ExponentialDistribution[1]},{y,ExponentialDistribution[1]},{z,ExponentialDistribution[1]},{w,ExponentialDistribution[1]}}];

SurvivalFunction[ℛ,t]

A system with three components and a voting gate:

ℛ=ReliabilityDistribution[Majority[x,y,z],{{x,ExponentialDistribution[1]},{y,ExponentialDistribution[1]},{z,ExponentialDistribution[1]}}];

SurvivalFunction[ℛ,t]

A system that works if at least three out of four components work:

(Subscript[𝒟, c])=ExponentialDistribution[1];

ℛ=ReliabilityDistribution[BooleanCountingFunction[{3,4},{x,y,z,v}],{{x,(Subscript[𝒟, c])},{y,(Subscript[𝒟, c])},{z,(Subscript[𝒟, c])},{v,(Subscript[𝒟, c])}}];

SurvivalFunction[ℛ,t]

Any positive unate Boolean expression can be used as a structure function:

ℛ=ReliabilityDistribution[¬x⊽¬y,{{x,WeibullDistribution[α,β]},{y,ErlangDistribution[k,λ]}}];

CDF[ℛ,t]

Use (RefLink[UnateQ, paclet:ref/UnateQ]) to test whether a Boolean expression is positive unate:

UnateQ[¬x⊽¬y]

Construct a multi-stage system, where each component is a k-out-of-n system:

𝒟=ExponentialDistribution[1];

ℛinner=ReliabilityDistribution[BooleanCountingFunction[{2,3},{x,y,z}],{{x,𝒟},{y,𝒟},{z,𝒟}}];

ℛouter=ReliabilityDistribution[BooleanCountingFunction[{2,3},{v,w,a}],{{v,ℛinner},{w,ℛinner},{a,ℛinner}}];

SurvivalFunction[ℛouter,t]

A redundant consecutive k-out-of-n with redundancy in each consecutive structure component:

𝒟=ExponentialDistribution[1];

ℛcomponent=ReliabilityDistribution[x∨y,{{x,𝒟},{y,𝒟}}];

ℛ=ReliabilityDistribution[BooleanConsecutiveFunction[2,3][z,v,w],{{z,ℛcomponent},{v,ℛcomponent},{w,ℛcomponent}}];

SurvivalFunction[ℛ,t]

Series of consecutive k-out-of-n systems:

𝒟=ExponentialDistribution[1];

ℛ1=ReliabilityDistribution[BooleanConsecutiveFunction[2,3][z,v,w],{{z,𝒟},{v,𝒟},{w,𝒟}}];
ℛ2=ReliabilityDistribution[BooleanConsecutiveFunction[{2,True},3][z,v,w],{{z,𝒟},{v,𝒟},{w,𝒟}}];

ℛ=ReliabilityDistribution[x∧y,{{x,ℛ1},{y,ℛ2}}];

SurvivalFunction[ℛ,t]

OpenersExampleSubsection2(Spacer1)Parametric Lifetime Distributions  (5)

A system with an increasing and decreasing failure rate:

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[1]},{y,ExponentialDistribution[7]}}];

Plot[HazardFunction[ℛ,t],{t,0,1},Filling->Axis,PlotRange->All]

Use any parametric lifetime distribution including (RefLink[LogNormalDistribution, paclet:ref/LogNormalDistribution]):

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[1]},{y,LogNormalDistribution[1,2]}}];

Numerically compute the mean time to failure:

NExpectation[t,t\[Distributed]ℛ]

Compute the mean time to failure as a function of distribution parameters:

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[λ]},{y,GammaDistribution[2,β]}}];

μ=Mean[ℛ]

Plot3D[μ,{λ,1/2,4},{β,0,2}]

When one component has a substantially longer lifetime, it determines the system lifetime:

Limit[μ,λ->∞]==Mean[GammaDistribution[2,β]]

Define two distributions with the same mean time to failure:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={WeibullDistribution[2,β],ExponentialDistribution[1/((Sqrt[π]) β/2)]};

Mean/@{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}

Define a parallel and serial system with these distributions:

{(Subscript[ℛ, P]),(Subscript[ℛ, S])}=Map[ReliabilityDistribution[#[x,y],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}]&,{Or,And}];

Show how the different mean times to failure vary with β:

Plot[Evaluate[Mean/@{(Subscript[ℛ, P]),(Subscript[𝒟, 1]),(Subscript[ℛ, S])}],{β,0,10},PlotLegends->{"(Subscript[ℛ, P])","(Subscript[𝒟, 1])","(Subscript[ℛ, S])"}]

Discrete lifetime distributions can be used:

{(Subscript[𝒟, 1])=PoissonDistribution[10],(Subscript[𝒟, 2])=PoissonDistribution[11]};

ℛ=ReliabilityDistribution[x∧y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

Calculate the mean time to failure:

NExpectation[t,t\[Distributed]ℛ]

Plot the (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]):

DiscretePlot[SurvivalFunction[ℛ,t],{t,0,10}]

OpenersExampleSubsection3(Spacer1)Nonparametric Lifetime Distributions  (3)

Model airplane glass strength using (RefLink[SmoothKernelDistribution, paclet:ref/SmoothKernelDistribution]):

data=ExampleData[{"Statistics","AirplaneGlass"}]

𝒟=TruncatedDistribution[{0,∞},SmoothKernelDistribution[data]]

Consider a series-connected system with one component being airplane glass:

ℛ=ReliabilityDistribution[x∧y,{{x,𝒟},{y,ExponentialDistribution[1/30]}}];

SurvivalFunction[ℛ,t]

Plot[SurvivalFunction[ℛ,x],{x,0,50}]

Model components with a (RefLink[HistogramDistribution, paclet:ref/HistogramDistribution]):

hd=HistogramDistribution[RandomVariate[WeibullDistribution[1,2],1000]];

Plot the survival function for a serial system with two and three components:

ℛ=ReliabilityDistribution[x∧y,{{x,hd},{y,ExponentialDistribution[1/30]}}]

{(Subscript[𝒟, two]),(Subscript[𝒟, three])}={ReliabilityDistribution[x∧y,{{x,hd},{y,hd}}],
ReliabilityDistribution[x∧y∧z,{{x,hd},{y,hd},{z,hd}}]};

Plot[{SurvivalFunction[(Subscript[𝒟, two]),t],SurvivalFunction[(Subscript[𝒟, three]),t]},{t,0,5},Filling->Axis,Exclusions->None,PlotPoints->200,PlotLegends->{"(Subscript[𝒟, two])","(Subscript[𝒟, three])"}]

Model components directly from data with (RefLink[EmpiricalDistribution, paclet:ref/EmpiricalDistribution]):

data=ExampleData[{"Statistics","AirplaneGlass"}];

Histogram[data]

ℰ=EmpiricalDistribution[data]

Plot[SurvivalFunction[ℰ,t],{t,0,50},PlotPoints->100]

Plot the survival function for a parallel system with two components:

ℛ=ReliabilityDistribution[x∧y,{{x,ℰ},{y,GeometricDistribution[1/30]}}];

Plot[SurvivalFunction[ℛ,x],{x,0,50}]

OpenersExampleSubsection4(Spacer1)Derived Lifetime Distributions  (7)

Model a component with a (RefLink[StandbyDistribution, paclet:ref/StandbyDistribution]):

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={ExponentialDistribution[1/10],ExponentialDistribution[2/5]};

𝒮=StandbyDistribution[(Subscript[𝒟, 1]),{(Subscript[𝒟, 2]),(Subscript[𝒟, 2])}];

ℛ=ReliabilityDistribution[x∨y,{{x,(Subscript[𝒟, 1])},{y,𝒮}}];

Calculate the mean time to failure:

NExpectation[t,t\[Distributed]ℛ]

Plot the (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]):

Plot[SurvivalFunction[ℛ,t]//Evaluate,{t,0,40}]

Complex systems can be modeled in steps:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])],ExponentialDistribution[(Subscript[λ, 3])]};

(Subscript[ℛ, 1])=ReliabilityDistribution[x∨y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

ℛ=ReliabilityDistribution[z∧v,{{z,(Subscript[ℛ, 1])},{v,(Subscript[𝒟, 3])}}];

Find the mean time to failure:

Mean[ℛ]

This is equivalent to modeling the whole system at once:

Mean[ReliabilityDistribution[(x∨y)∧v,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{v,(Subscript[𝒟, 3])}}]]

FullSimplify[%%-%]

Model a component with a (RefLink[StandbyDistribution, paclet:ref/StandbyDistribution]):

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={StandbyDistribution[ExponentialDistribution[1],{ExponentialDistribution[2]}],ExponentialDistribution[3]};

Both components need to work for the system to work:

ℛ=ReliabilityDistribution[x∧y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

Plot the survival function and compare with only the standby component:

Plot[Evaluate[SurvivalFunction[#,t]&/@{(Subscript[𝒟, 1]),ℛ}],{t,0,4},Filling->Axis,PlotLegends->{"(Subscript[𝒟, 1])","ℛ"}]

A system with a (RefLink[ParameterMixtureDistribution, paclet:ref/ParameterMixtureDistribution]):

𝒟=ParameterMixtureDistribution[GammaDistribution[2,β],β\[Distributed]UniformDistribution[{1,2}]];

ℛ=ReliabilityDistribution[x∨y,{{x,𝒟},{y,ExponentialDistribution[λ]}}];

SurvivalFunction[ℛ,t]

Model a two-component cold standby system with a (RefLink[MixtureDistribution, paclet:ref/MixtureDistribution]):

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])],WeibullDistribution[α,β]};

ℳ=MixtureDistribution[{p,1-p},{TransformedDistribution[x+y,{x\[Distributed](Subscript[𝒟, 1]),y\[Distributed](Subscript[𝒟, 2])}],(Subscript[𝒟, 1])}];

Use it in (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) and compute the survival function:

ℛ=ReliabilityDistribution[x∨y,{{x,ℳ},{y,(Subscript[𝒟, 3])}}];

SurvivalFunction[ℛ,t]

Show equivalence with (RefLink[StandbyDistribution, paclet:ref/StandbyDistribution]):

SurvivalFunction[ReliabilityDistribution[x∨y,{{x,StandbyDistribution[(Subscript[𝒟, 1]),{(Subscript[𝒟, 2])},p]},{y,(Subscript[𝒟, 3])}}],t]

FullSimplify[%%-%]

(RefLink[OrderDistribution, paclet:ref/OrderDistribution]) can be used to model component lifetimes:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={OrderDistribution[{ExponentialDistribution[3],5},3],WeibullDistribution[1/10,2]};

ℛ=ReliabilityDistribution[x∨y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

sf=SurvivalFunction[ℛ,t]

Plot the (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]):

Plot[sf,{t,0,2}]

(RefLink[MarginalDistribution, paclet:ref/MarginalDistribution]) can be used to model component lifetimes:

𝒟=ProbabilityDistribution[6 x^2 y,{x,0,1},{y,0,1}];

ℳ1=MarginalDistribution[𝒟,1];

ℛ=ReliabilityDistribution[x∨y,{{x,ℳ1},{y,ExponentialDistribution[1]}}];

SurvivalFunction[ℛ,t]

Plot the (RefLink[SurvivalFunction, paclet:ref/SurvivalFunction]):

Plot[%,{t,0,3}]

OpenersExampleSection3(Spacer1)Applications  (12)

Model the launch of an aircraft. The hangar door can be opened electronically or manually:

hangarDoor=power∨manual;

Two fuel pumps require power to run:

fuelTransferA2=power∧pumpA2;

fuelTransferB2=power∧pumpB2;

Two more pumps run on reliable batteries, giving the following fuel transfer structure:

fuelTransfer=(pumpA1∧(pumpB1∨fuelTransferB2))∨(fuelTransferA2∧(pumpB1∨fuelTransferB2));

Also needed is deicing of the aircraft and a fuel storage tank:

launch=fuelStorage∧fuelTransfer∧hangarDoor∧deicing;

Define distributions with failure rates per hour. Let the failure rate of the power supply be variable:

vars={deicing,fuelStorage,manual,power,pumpA1,pumpB1,pumpA2,pumpB2};

lifetimes=ExponentialDistribution/@{(10^(-7)),(10^(-8)),(10^(-3)),λ,5×(10^(-4)),5×(10^(-4)),5×(10^(-4)),5×(10^(-4))};

dists=Transpose[{vars,lifetimes}];

ℛ=ReliabilityDistribution[launch,dists];

Compute the survival function and the mean:

sf=SurvivalFunction[ℛ,t];

μ=Mean[ℛ];

Study how the reliability varies when the failure rate λ is decreased from 2×(10^(-4))/hour:

Plot[Evaluate[Table[Legended[sf/.λ->f,TraditionalForm[λ==f]],{f,{2×(10^(-4)),1×(10^(-4)),1/2×(10^(-4))}}]],{t,0,5000}]

Table[μ/.λ->f,{f,{2×(10^(-4)),1×(10^(-4)),1/2×(10^(-4))}}]//N

A vacuum system in a small electron accelerator contains 20 vacuum bulbs arranged in a circle. The vacuum system fails if at least three adjacent vacuum bulbs fail:

n=20;k=3;

bexpr=And@@Map[Or@@#&,Partition[Array[(Subscript[x, #])&,n],k,1,{-1,-1}]];

dists=Array[{(Subscript[x, #]),ExponentialDistribution[1]}&,n];

ℛ=ReliabilityDistribution[bexpr,dists];

Plot the survival function:

Plot[SurvivalFunction[ℛ,t]//Evaluate,{t,0,1}]

Compute the mean time to failure:

Mean[ℛ]//N

A satellite needs power from its battery, which is recharged by solar panels. Calculate the number of load cycles the system can stand:

𝒟Battery=ExponentialDistribution[1/300];
𝒟Solarpanels=ExponentialDistribution[1/1000];

The battery has a standby battery:

𝒮battery=StandbyDistribution[𝒟Battery,{𝒟Battery}];

ℛsatellite=ReliabilityDistribution[solarpanel∧battery,{{solarpanel,𝒟Solarpanels},{battery,𝒮battery}}];

μ=NExpectation[t,t\[Distributed]ℛsatellite]

Plot[SurvivalFunction[ℛsatellite,t],{t,0,600},Filling->Axis]

Simulate the number of load cycles the satellite can manage:

ListPlot[{RandomVariate[ℛsatellite,100],{{0,μ},{100,μ}}},Joined->{False,True},Filling->Axis,AxesOrigin->{0,0}]

Consider a skateboard with a ball bearing in each of its wheels. Find out the lifetime of such a skateboard:

ExampleData[{"Statistics","FatigueLifeFailures"},"LongDescription"]

data=ExampleData[{"Statistics","FatigueLifeFailures"}];

Model the ball bearings with a known distribution:

d=EstimatedDistribution[data,ErlangDistribution[α,β]]

Assume the skateboard can be used when at least three out of four wheels are functioning:

ℛ=ReliabilityDistribution[BooleanCountingFunction[{3,4},{x,y,z,v}],{{x,d},{y,d},{z,d},{v,d}}];

Plot the survival function:

Plot[SurvivalFunction[ℛ,t]//Evaluate,{t,0,100}]

A car has four tires that are all needed to drive. Given the lifetime distribution of a tire as (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])[0.0004], calculate the failure rate and mean time to failure (MTTF) of the car with respect to the tires:

𝒟=ExponentialDistribution[0.0004];

ℛcar=ReliabilityDistribution[x∧y∧z∧v,{{x,𝒟},{y,𝒟},{z,𝒟},{v,𝒟}}];

HazardFunction[ℛcar,t]

Mean[ℛcar]

Simulate the lifetime of the car:

ListPlot[{RandomVariate[ℛcar,100],{{0,Mean[ℛcar]},{100,Mean[ℛcar]}}},Joined->{False,True},Filling->Axis,AxesOrigin->{0,0}]

In order to fly, an airplane needs both wings, one engine out of two on each wing, and the air control system operating. Model the engine system:

{𝒟Motor,𝒟Fuel,𝒟Cooling,𝒟Propeller}={WeibullDistribution[1.58,4830],WeibullDistribution[1.44,5130],WeibullDistribution[1.60,4190],WeibullDistribution[1.63,3740]};

ℛSingleEngine=ReliabilityDistribution[motor∧fuel∧cooling∧propeller,{{motor,𝒟Motor},{fuel,𝒟Fuel},{cooling,𝒟Cooling},{propeller,𝒟Propeller}}];

ℛEngines=ReliabilityDistribution[(engine1∨engine2)∧(engine3∨engine4),{{engine1,ℛSingleEngine},{engine2,ℛSingleEngine},{engine3,ℛSingleEngine},{engine4,ℛSingleEngine}}];

Model the air control system:

parameters={{1.85,1.57,2.25,0.95,0.73,1.14,0.92,1.65},{4729.02,4718.22,5843.58,3956,2672.1,3977.39,2895.62,3994.78}};

{𝒟Directional,𝒟Longitudinal,𝒟Lateral,𝒟Flaps,𝒟Trim,𝒟Hydraulic,𝒟LandingGear,𝒟Steering}=Flatten[Transpose[{MapThread[WeibullDistribution,parameters]}]];

ℛACS=ReliabilityDistribution[x1∧x2∧x3∧x4∧x5∧x6∧x7∧x8,{{x1,𝒟Directional},{x2,𝒟Longitudinal},{x3,𝒟Lateral},{x4,𝒟Flaps},{x5,𝒟Trim},{x6,𝒟Hydraulic},{x7,𝒟LandingGear},{x8,𝒟Steering}}];

Put it all together:

𝒟Wing=WeibullDistribution[1.79,4250];

ℛAirplane=ReliabilityDistribution[enginesystem∧wing1∧wing2∧acs,{{enginesystem,ℛEngines},{wing1,𝒟Wing},{wing2,𝒟Wing},{acs,ℛACS}}];

Calculate the mean time to failure for the airplane:

NExpectation[t,t\[Distributed]ℛAirplane]

Calculate the probability that a six-hour flight will be successful:

NProbability[t≥6,t\[Distributed]ℛAirplane]

Find the probability that an airplane working after 300 hours still works after an additional 200 hours:

NProbability[t≥500\[Conditioned]t≥300,t\[Distributed]ℛAirplane]

Plot the survival function:

Plot[SurvivalFunction[ℛAirplane,t]//Evaluate,{t,0,2000},Filling->Axis]

Simulate the lifetime of the airplane:

ListPlot[{RandomVariate[ℛAirplane,100],{{0,NExpectation[t,t\[Distributed]ℛAirplane]},{100,NExpectation[t,t\[Distributed]ℛAirplane]}}},Joined->{False,True},Filling->Axis,AxesOrigin->{0,0}]

A data center needs 20 servers to work, one power supply, one cooling system, and one network connection. The power supply has a standby component. The network connection consists of two parallel connections. Model the server:

ℛhdd=ReliabilityDistribution[BooleanCountingFunction[{2,3},{x,y,z}],{{x,WeibullDistribution[4,1.25 (10^6)]},{y,WeibullDistribution[4,1.25 (10^6)]},{z,WeibullDistribution[4,1.25 (10^6)]}}];

𝒟cpu=ExponentialDistribution[1/30000];
𝒟ram=WeibullDistribution[.82,2500];

ℛServer=ReliabilityDistribution[hdd∧cpu∧ram,{{hdd,ℛhdd},{cpu,𝒟cpu},{ram,𝒟ram}}];

Model the power supply with (RefLink[StandbyDistribution, paclet:ref/StandbyDistribution]):

𝒮PowerSupply=StandbyDistribution[ExponentialDistribution[1/5000],{ExponentialDistribution[1/2000]}];

Model the data center:

𝒟Network=ParetoDistribution[1500,10];
𝒟Cooling=ExponentialDistribution[1/5000];

servervars=Table[(Subscript[s, i]),{i,20}];
serverdists=Table[{i,ℛServer},{i,servervars}];
ℛDatacenter=ReliabilityDistribution[(And@@servervars)∧power∧(net1∨net2)∧cooling,Join[serverdists,{{power,𝒮PowerSupply},{net1,𝒟Network},{net2,𝒟Network},{cooling,𝒟Cooling}}]];

Calculate the mean time to failure (MTTF):

NExpectation[t,t\[Distributed]ℛDatacenter]

Simulate the uptime of the data center:

ListPlot[{RandomVariate[ℛDatacenter,100],{{0,NExpectation[t,t\[Distributed]ℛDatacenter]},{100,NExpectation[t,t\[Distributed]ℛDatacenter]}}},Joined->{False,True},Filling->Axis,AxesOrigin->{0,0}]

Find the component that is most important to improve in a single server:

bi=ImprovementImportance[ℛServer,t];

Plot[MapThread[Legended,{bi,{hdd,cpu,ram}}]//Evaluate,{t,0,20}]

A system has the following structure and lifetime distribution:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3]),(Subscript[𝒟, 4])}={ExponentialDistribution[λ],WeibullDistribution[5,6],ErlangDistribution[3,1],WeibullDistribution[4,4]};

ℛ=ReliabilityDistribution[x∨BooleanCountingFunction[{2,3},{y,z,v}],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{z,(Subscript[𝒟, 3])},{v,(Subscript[𝒟, 4])}}];

Find the requirement on the failure rate λ to survive a mission of five days with a probability of 0.9995:

Reduce[SurvivalFunction[ℛ,5]≥0.9995,λ,Reals]

A solar panel consists of arrays of photovoltaic cells. Each array has 10 cells:

dists=Table[{(Subscript[x, i]),WeibullDistribution[5.87,50]},{i,10}];
bexpr=And@@Table[(Subscript[x, i]),{i,10}];
𝒟=ReliabilityDistribution[bexpr,dists];

The solar panel requires three out of five arrays and an inverter to work:

ℛSolarGrid=ReliabilityDistribution[BooleanCountingFunction[{3,5},{x,y,z,v,w}]∧inverter,{{x,𝒟},{y,𝒟},{z,𝒟},{v,𝒟},{w,𝒟},{inverter,ExponentialDistribution[1/170]}}];

Find the mean time to failure in years:

NExpectation[t,t\[Distributed]ℛSolarGrid]

Simulate the lifetimes of solar panels:

ListPlot[{RandomVariate[ℛSolarGrid,100],{{0,NExpectation[t,t\[Distributed]ℛSolarGrid]},{100,NExpectation[t,t\[Distributed]ℛSolarGrid]}}},Joined->{False,True},Filling->Axis,AxesOrigin->{0,0}]

A company that sells solar panels gives a 10-year warranty. An additional 10 years can be added. Find out how the company should price this extended warranty:

Probability[10<t≤20,t\[Distributed]ℛSolarGrid]*meanCostOfRepair+profit

A logistics company uses trucks, a ship, and a train to deliver goods to customers. Two out of three trucks and clear roads are needed for road transport. A working ship and calm weather conditions are needed for the ship, and a functioning train and tracks are needed for the train. Model the road transport:

{𝒟truck,𝒟road}={ExponentialDistribution[1/400],ExponentialDistribution[1/365]};
ℛroad=ReliabilityDistribution[BooleanCountingFunction[{2,3},{truck1,truck2,truck3}]∧roads,{{truck1,𝒟truck},{truck2,𝒟truck},{truck3,𝒟truck},{roads,𝒟road}}];

Model the sea transport:

{𝒟ship,𝒟sea}={ExponentialDistribution[1/400],ExponentialDistribution[1/200]};
ℛmarine=ReliabilityDistribution[ship∧sea,{{ship,𝒟ship},{sea,𝒟sea}}];

Model the train transport:

{𝒟train,𝒟railroad}={WeibullDistribution[1/2,150],ExponentialDistribution[1/200]};
ℛrailroad=ReliabilityDistribution[train∧railroad,{{train,𝒟train},{railroad,𝒟railroad}}];

Put the system together:

ℛsupplychain=ReliabilityDistribution[roadtransport∨marine∨railroad,{{roadtransport,ℛroad},{marine,ℛmarine},{railroad,ℛrailroad}}];

Calculate the expected number of days before the system fails to deliver to the customers:

NExpectation[t,t\[Distributed]ℛsupplychain]

The company is considering leasing an airplane to improve the reliability of delivery. Calculate how much this airplane would improve the mean time to failure:

{𝒟airplane,𝒟airport}={WeibullDistribution[1.06,517],ExponentialDistribution[1/400]};
ℛflight=ReliabilityDistribution[airplane∧airport,{{airplane,𝒟airplane},{airport,𝒟airport}}];

ℛnewsupplychain=ReliabilityDistribution[oldsupplychain∨flight,{{oldsupplychain,ℛsupplychain},{flight,ℛflight}}];

NExpectation[t,t\[Distributed]ℛnewsupplychain]

Compare the two systems:

Plot[{SurvivalFunction[ℛsupplychain,t],SurvivalFunction[ℛnewsupplychain,t]},{t,0,800},Filling->Axis,PlotLegends->{"ℛsupplychain","ℛnewsupplychain"}]

Assume that Charles Lindbergh had the option to select a one-engine or a two-engine aircraft for his flight between New York and Paris. Investigate which configuration of engines gives the highest reliability:

𝒟=ExponentialDistribution[1/200];

ℛSingleEngine=ReliabilityDistribution[x,{{x,𝒟}}];
ℛSerialEngines=ReliabilityDistribution[x∧y,{{x,𝒟},{y,𝒟}}];
ℛParallelEngines=ReliabilityDistribution[x∨y,{{x,𝒟},{y,𝒟}}];

Plot the survival functions for these different configurations:

Plot[{Legended[SurvivalFunction[ℛSingleEngine,t],"One engine"],Legended[SurvivalFunction[ℛSerialEngines,t],"Serial engines"],Legended[SurvivalFunction[ℛParallelEngines,t],"Parallel engines"]},{t,0,1200},Filling->Axis]

It is clear that the best choice was two engines in parallel, which at the time was not available, and Lindbergh therefore chose one engine. Calculate the probability that one engine survives a 33.5-hour flight:

Probability[t>33.5,t\[Distributed]ℛSingleEngine]

Model a launch into space in three phases: a ground check, a launch phase, and in orbit. Define the lifetime distributions for operating and inactive modes:

{(Subscript[𝒟, oGuidance]),(Subscript[𝒟, iGuidance]),(Subscript[𝒟, oIgnition]),(Subscript[𝒟, iIgnition]),(Subscript[𝒟, oSeparation]),(Subscript[𝒟, iSeparation]),(Subscript[𝒟, oPower]),(Subscript[𝒟, oCom]),(Subscript[𝒟, iCom]),(Subscript[𝒟, oInstrument]),(Subscript[𝒟, iInstrument]),(Subscript[𝒟, oPropulsion]),(Subscript[𝒟, structure])}=ExponentialDistribution[k #/1000]&/@{0.01,0.0001,0.1,0.001,0.01,0.0001,0.02,0.05,0.0005,0.01,0.0005,0.05,0.001};

For the ground phase, an environmental accelerator of 5 is used:

ground=guidance1∧guidance2∧ignition1A∧ignition1B∧ignition2A∧ignition2B∧separation1∧separation2∧powerA∧powerB∧comA∧comB∧instrumentA∧instrumentB∧structure;

(Subscript[ℛ, ground])=ReliabilityDistribution[ground,{{guidance1,(Subscript[𝒟, iGuidance])},{guidance2,(Subscript[𝒟, iGuidance])},{ignition1A,(Subscript[𝒟, iIgnition])},{ignition1B,(Subscript[𝒟, iIgnition])},{ignition2A,(Subscript[𝒟, iIgnition])},{ignition2B,(Subscript[𝒟, iIgnition])},{separation1,(Subscript[𝒟, iSeparation])},{separation2,(Subscript[𝒟, iSeparation])},{powerA,(Subscript[𝒟, oPower])},{powerB,(Subscript[𝒟, oPower])},{comA,(Subscript[𝒟, iCom])},{comB,(Subscript[𝒟, iCom])},{instrumentA,(Subscript[𝒟, iInstrument])},{instrumentB,(Subscript[𝒟, oInstrument])},{structure,(Subscript[𝒟, structure])}}/.k->5];

The launch phase presents a harsher environment, with the environmental factor 400:

launch=guidance1∧guidance2∧(ignition1A∨ignition1B)∧propulsion1∧separation1∧(ignition2A∨ignition2B)∧propulsion2∧separation2∧(powerA∨powerB)∧(comA∨comB)∧instrumentA∧instrumentB∧structure;

(Subscript[ℛ, launch])=ReliabilityDistribution[launch,{{guidance1,(Subscript[𝒟, oGuidance])},{guidance2,(Subscript[𝒟, iGuidance])},{ignition1A,(Subscript[𝒟, oIgnition])},{ignition1B,(Subscript[𝒟, oIgnition])},{ignition2A,(Subscript[𝒟, oIgnition])},{ignition2B,(Subscript[𝒟, oIgnition])},{separation1,(Subscript[𝒟, oSeparation])},{separation2,(Subscript[𝒟, oSeparation])},{powerA,(Subscript[𝒟, oPower])},{powerB,(Subscript[𝒟, oPower])},{comA,(Subscript[𝒟, oCom])},{comB,(Subscript[𝒟, oCom])},{instrumentA,(Subscript[𝒟, oInstrument])},{instrumentB,(Subscript[𝒟, iInstrument])},{structure,(Subscript[𝒟, structure])},{propulsion1,(Subscript[𝒟, oPropulsion])},{propulsion2,(Subscript[𝒟, oPropulsion])}}/.k->400];

The environment in orbit is not very harsh, so a factor 1 is used:

orbit=guidance2∧(powerA∨powerB)∧(comA∨comB)∧instrumentB∧structure;

(Subscript[ℛ, orbit])=ReliabilityDistribution[orbit,{{guidance2,(Subscript[𝒟, oGuidance])},{powerA,(Subscript[𝒟, oPower])},{powerB,(Subscript[𝒟, oPower])},{comA,(Subscript[𝒟, oCom])},{comB,(Subscript[𝒟, oCom])},{instrumentB,(Subscript[𝒟, oInstrument])},{structure,(Subscript[𝒟, structure])}}/.k->1];

If the ground check takes 24 hours, the launch 0.1 hours, and the orbit phase 100 days, find the probability of success:

SurvivalFunction[(Subscript[ℛ, ground]),24]*SurvivalFunction[(Subscript[ℛ, launch]),0.1]*SurvivalFunction[(Subscript[ℛ, orbit]),100*24]

OpenersExampleSection4(Spacer1)Properties & Relations  (14)

(RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) uses local names for variables in the input:

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[(Subscript[λ, 1])]},{y,ExponentialDistribution[(Subscript[λ, 2])]}}]

Hence, subsequent computations can be done with the original variable name:

SurvivalFunction[ℛ,x]

The probability that two components both have a lifetime greater than τ:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])]};

Probability[τ<(Subscript[t, 1])∧τ<(Subscript[t, 2]),{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2])}]//PiecewiseExpand

Probability[τ<Min[(Subscript[t, 1]),(Subscript[t, 2])],{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2])}]//PiecewiseExpand

This corresponds to a series connection:

SurvivalFunction[ReliabilityDistribution[x∧y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}],τ]

FullSimplify[%%-%]

The probability that at least one component has a lifetime greater than τ:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])]};

Probability[τ<(Subscript[t, 1])∨τ<(Subscript[t, 2]),{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2])}]//PiecewiseExpand

Probability[τ<Max[(Subscript[t, 1]),(Subscript[t, 2])],{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2])}]//PiecewiseExpand

This corresponds to a parallel connection:

SurvivalFunction[ReliabilityDistribution[x∨y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}],τ]

FullSimplify[%%-%]

The probability that at least two components have a lifetime greater than τ:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])],ExponentialDistribution[(Subscript[λ, 3])]};

Probability[BooleanCountingFunction[{2,3},{τ<(Subscript[t, 1]),τ<(Subscript[t, 2]),τ<(Subscript[t, 3])}],{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2]),(Subscript[t, 3])\[Distributed](Subscript[𝒟, 3])}]//PiecewiseExpand

Probability[τ<RankedMin[{(Subscript[t, 1]),(Subscript[t, 2]),(Subscript[t, 3])},2],{(Subscript[t, 1])\[Distributed](Subscript[𝒟, 1]),(Subscript[t, 2])\[Distributed](Subscript[𝒟, 2]),(Subscript[t, 3])\[Distributed](Subscript[𝒟, 3])}]//PiecewiseExpand

This corresponds to a 2-out-of-3 system:

SurvivalFunction[ReliabilityDistribution[BooleanCountingFunction[{2,3},{x,y,z}],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{z,(Subscript[𝒟, 3])}}],τ]

FullSimplify[%%-%]

A series connection of identical components corresponds to an (RefLink[OrderDistribution, paclet:ref/OrderDistribution]):

d=ExponentialDistribution[λ];

ℛ=ReliabilityDistribution[x∧y∧z,{{x,d},{y,d},{z,d}}];

SurvivalFunction[ℛ,t]-SurvivalFunction[OrderDistribution[{d,3},1],t]//FullSimplify

A parallel connection of identical components corresponds to an (RefLink[OrderDistribution, paclet:ref/OrderDistribution]):

ℛ=ReliabilityDistribution[x∨y∨z,{{x,d},{y,d},{z,d}}];

SurvivalFunction[ℛ,t]-SurvivalFunction[OrderDistribution[{d,3},3],t]//FullSimplify

The lifetime of a series connected system is the minimum of the component lifetimes:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])]};

ℛ=ReliabilityDistribution[x∧y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

𝒯=TransformedDistribution[Min[t,s],{t\[Distributed](Subscript[𝒟, 1]),s\[Distributed](Subscript[𝒟, 2])}];

SurvivalFunction[𝒯,t]-SurvivalFunction[ℛ,t]//FullSimplify

The lifetime of a parallel connected system is the maximum of the component lifetimes:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])]};

ℛ=ReliabilityDistribution[x∨y,{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])}}];

𝒯=TransformedDistribution[Max[t,s],{t\[Distributed](Subscript[𝒟, 1]),s\[Distributed](Subscript[𝒟, 2])}];

SurvivalFunction[ℛ,t]

SurvivalFunction[𝒯,t]

FullSimplify[%%-%]

A k-out-of-n system corresponds to a (RefLink[TransformedDistribution, paclet:ref/TransformedDistribution]) with a (RefLink[RankedMin, paclet:ref/RankedMin]) function:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3])}={ExponentialDistribution[(Subscript[λ, 1])],WeibullDistribution[1,β],ExponentialDistribution[(Subscript[λ, 3])]};

ℛ=ReliabilityDistribution[BooleanCountingFunction[{2,3},{x,y,z}],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{z,(Subscript[𝒟, 3])}}];

𝒯=TransformedDistribution[RankedMin[{x,y,z},2],{x\[Distributed](Subscript[𝒟, 1]),y\[Distributed](Subscript[𝒟, 2]),z\[Distributed](Subscript[𝒟, 3])}];

Compare the survival functions:

SurvivalFunction[ℛ,t]

SurvivalFunction[𝒯,t]

FullSimplify[%%-%]

A series system of exponentially distributed components is exponential:

(Subscript[𝒟, c])=ExponentialDistribution[λ];

ℛ=ReliabilityDistribution[x∧y∧z,{{x,(Subscript[𝒟, c])},{y,(Subscript[𝒟, c])},{z,(Subscript[𝒟, c])}}];

SurvivalFunction[ℛ,t]

SurvivalFunction[ExponentialDistribution[3λ],t]

A series system of components with a Weibull lifetime distribution is another Weibull:

(Subscript[𝒟, c])=WeibullDistribution[α,β];

ℛ=ReliabilityDistribution[x∧y∧z,{{x,(Subscript[𝒟, c])},{y,(Subscript[𝒟, c])},{z,(Subscript[𝒟, c])}}];

SurvivalFunction[ℛ,t]

SurvivalFunction[WeibullDistribution[α,(3^(-1/α)) ((((β^(-α))))^(-1/α))],t]

FullSimplify[%%-%]

(RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) models that component x or y has to work for the system to work:

ℛ=ReliabilityDistribution[x∨y,{{x,ExponentialDistribution[λ]},{y,ExponentialDistribution[μ]}}];

The corresponding (RefLink[FailureDistribution, paclet:ref/FailureDistribution]) models the events that both x and y fail:

ℱ=FailureDistribution[x∧y,{{x,ExponentialDistribution[λ]},{y,ExponentialDistribution[μ]}}];

Component x or y working is equivalent to the event of both x and y failing:

SurvivalFunction[ℛ,t]==SurvivalFunction[ℱ,t]

Model two out of four components needing to work for the system to work:

{(Subscript[𝒟, 1]),(Subscript[𝒟, 2]),(Subscript[𝒟, 3]),(Subscript[𝒟, 4])}={ExponentialDistribution[(Subscript[λ, 1])],ExponentialDistribution[(Subscript[λ, 2])],ExponentialDistribution[(Subscript[λ, 3])],ExponentialDistribution[(Subscript[λ, 4])]};

ℛ=ReliabilityDistribution[BooleanCountingFunction[{2,4},{x,y,z,v}],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{z,(Subscript[𝒟, 3])},{v,(Subscript[𝒟, 4])}}];

This is equal to three out of four components needing to fail for the system to fail:

ℱ=FailureDistribution[BooleanCountingFunction[{3,4},{x,y,z,v}],{{x,(Subscript[𝒟, 1])},{y,(Subscript[𝒟, 2])},{z,(Subscript[𝒟, 3])},{v,(Subscript[𝒟, 4])}}];

SurvivalFunction[ℛ,t]-SurvivalFunction[ℱ,t]//FullSimplify

(RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution])[f[(Subscript[x, 1]),…],…]==(RefLink[FailureDistribution, paclet:ref/FailureDistribution])[¬f[¬(Subscript[x, 1]),…],…]:

comp={{x,ExponentialDistribution[λ]},{y,ExponentialDistribution[μ]}};

ℛ=ReliabilityDistribution[x∧y,comp];
ℱ=FailureDistribution[¬(¬x∧¬y),comp];

SurvivalFunction[ℛ,t]==SurvivalFunction[ℱ,t]

Retrieve the (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) for a (RefLink[SystemModel, paclet:ref/SystemModel]) with reliability information:

SystemModelReliability[]

OpenersExampleSection5(Spacer1)Possible Issues  (3)

Component distributions need to have a positive domain:

ℛ=ReliabilityDistribution[x∨y,{{x,NormalDistribution[6,2]},{y,ExponentialDistribution[3]}}];

SurvivalFunction[ℛ,x]

Use (RefLink[TruncatedDistribution, paclet:ref/TruncatedDistribution]) to restrict the domain to positive values only:

ℛ=ReliabilityDistribution[x∨y,{{x,TruncatedDistribution[{0,∞},NormalDistribution[6,2]]},{y,ExponentialDistribution[3]}}];

SurvivalFunction[ℛ,t]

Exact or symbolic properties cannot always be computed:

ℛ=ReliabilityDistribution[(x∧y),{{x,ExponentialDistribution[1]},{y,InverseGaussianDistribution[1,3,1/2]}}];

CDF[ℛ,t]

Approximate values can typically still be found:

CDF[ℛ,0.5]

A (RefLink[ReliabilityDistribution, paclet:ref/ReliabilityDistribution]) is only well defined for positive unate structure expressions:

decfn=¬x∨y;

SurvivalFunction[ReliabilityDistribution[decfn,{{x,ExponentialDistribution[3]},{y,ExponentialDistribution[3]}}],t]

Use (RefLink[UnateQ, paclet:ref/UnateQ]) to test whether a Boolean expression is positive unate:

UnateQ[decfn]

incfn=¬x⊽¬y;

UnateQ[incfn]

SurvivalFunction[ReliabilityDistribution[incfn,{{x,ExponentialDistribution[3]},{y,ExponentialDistribution[3]}}],t]

OpenersExampleSection6(Spacer1)Neat Examples  (2)

Show the hazard function for all systems with up to four identical components:

𝒟=ExponentialDistribution[1];

Generate systems:

schemes=Select[Table[BooleanFunction[i,{x,y,z,v}],{i,2^2^4-2}],UnateQ[#]&];

Build list of unique hazard functions:

hf[scheme_,t_]:=HazardFunction[ReliabilityDistribution[scheme,{{x,𝒟},{y,𝒟},{z,𝒟},{v,𝒟}}],t]

hfs=DeleteDuplicates[Table[Legended[hf[expr,t],expr],{expr,schemes}],First[#1]===First[#2]&];

Plot hazard functions and corresponding systems:

Plot[Evaluate[hfs],{t,0,3},PlotStyle->Thin]

Use a (RefLink[Graph, paclet:ref/Graph]) as a reliability block diagram:

visit[g_,x_,e_,trail_]/;(FreeQ[trail,x]):=Block[{newtrail=Append[trail,x]},trailholder[x]=Join[trailholder[x],{newtrail}];If[x=!=e,Do[visit[g,v,e,newtrail],{v,DeleteCases[VertexList[NeighborhoodGraph[g,x]],x]}];];];

graphToBoolean[g_,start_,end_]/;VertexQ[g,start]&&VertexQ[g,end]:=Block[{trailholder},trailholder[_]:={};visit[g,start,end,{}];BooleanMinimize[Or@@(And@@@trailholder[end])]]

Calculate the mean time to failure with the green and red vertices as the start and end vertices:

g=PetersenGraph[8,1,VertexSize->Large,ImageSize->Tiny];

bexpr=graphToBoolean[g,12,16];

{HighlightGraph[g,{Style[12,Green],Style[16,Red]}],Plot[PDF[ReliabilityDistribution[bexpr,Table[{i,ExponentialDistribution[1]},{i,16}]],t]//Evaluate,{t,0,1}]}

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[FailureDistribution, paclet:ref/FailureDistribution])  ▪  (RefLink[StandbyDistribution, paclet:ref/StandbyDistribution])  ▪  (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])  ▪  (RefLink[WeibullDistribution, paclet:ref/WeibullDistribution])  ▪  (RefLink[And, paclet:ref/And])  ▪  (RefLink[Or, paclet:ref/Or])  ▪  (RefLink[BooleanCountingFunction, paclet:ref/BooleanCountingFunction])  ▪  (RefLink[BooleanConsecutiveFunction, paclet:ref/BooleanConsecutiveFunction])  ▪  (RefLink[UnateQ, paclet:ref/UnateQ])  ▪  (RefLink[SystemModelReliability, paclet:ref/SystemModelReliability])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Reliability, paclet:guide/Reliability])}, {▪(RefLinkPlain[Probability & Statistics, paclet:guide/ProbabilityAndStatistics])}, {▪(RefLinkPlain[Derived Statistical Distributions, paclet:guide/DerivedDistributions])}, {▪(RefLinkPlain[Distributions in Reliability Analysis, paclet:guide/DistributionsUsedInReliabilityAnalysis])}, {▪(RefLinkPlain[Systems Modeling, paclet:guide/SystemsModeling])}, {▪(RefLinkPlain[System Model Analytics & Design, paclet:guide/SystemModelAnalyticsDesign])}})}})