Wolfram Language & System Documentation Center

BooleanConsecutiveFunction

represents a Boolean function of n variables that gives True if k consecutive variables are True.

treats the variable list as cyclic.

BooleanConsecutiveFunction[{k₁,k₂,…,k_d},{n₁,n₂,…,n_d}]

represents a Boolean function of n₁ n₂ ⋯ n_d variables that gives True if all variables in a block of the variable array are True.

BooleanConsecutiveFunction[{{k₁,k₂,…,k_d},{c₁,c₂,…,c_d}},{n₁,n₂,…,n_d}]

treats the i level of the variable array as cyclic if c_i is True.

BooleanConsecutiveFunction[spec,{a₁,a₂,…}]

gives the Boolean expression in variables a_i corresponding to the Boolean consecutive function specified by spec.

BooleanConsecutiveFunction[spec,{a₁,a₂,…},form]

gives the Boolean expression in the form specified by form.

BooleanConsecutiveFunction

BooleanConsecutiveFunction[k,n]

represents a Boolean function of n variables that gives True if k consecutive variables are True.

BooleanConsecutiveFunction[{k,True},n]

treats the variable list as cyclic.

BooleanConsecutiveFunction[{k₁,k₂,…,k_d},{n₁,n₂,…,n_d}]

represents a Boolean function of n₁ n₂ ⋯ n_d variables that gives True if all variables in a block of the variable array are True.

BooleanConsecutiveFunction[{{k₁,k₂,…,k_d},{c₁,c₂,…,c_d}},{n₁,n₂,…,n_d}]

treats the i level of the variable array as cyclic if c_i is True.

BooleanConsecutiveFunction[spec,{a₁,a₂,…}]

gives the Boolean expression in variables a_i corresponding to the Boolean consecutive function specified by spec.

BooleanConsecutiveFunction[spec,{a₁,a₂,…},form]

gives the Boolean expression in the form specified by form.

Details

BooleanConsecutiveFunction[k,n] is also known as linear consecutive-k-out-of-n:F.
BooleanConsecutiveFunction[{k,True},n] is also known as circular consecutive-k-out-of-n:F.
BooleanConsecutiveFunction[{k,False},n] is equivalent to BooleanConsecutiveFunction[k,n].
BooleanConsecutiveFunction[{{k₁,k₂,…,k_d},c},{n₁,n₂,…,n_d}] is equivalent to BooleanConsecutiveFunction[{{k₁,k₂,…,k_d},{c,c,…,c}},{n₁,n₂,…,n_d}].
BooleanConsecutiveFunction[spec] gives a Boolean function object that works like Function.
BooleanConsecutiveFunction[spec][a₁,a₂,…] gives an implicit representation equivalent to the explicit Boolean expression BooleanConsecutiveFunction[spec,{a₁,a₂,…}].
In BooleanConsecutiveFunction[…,{n₁,n₂,…,n_d},…][vars], vars can be either an array of dimension-{n₁,n₂,…,n_d} variables, or a list of n₁ n₂ ⋯ n_d variables.
In BooleanConsecutiveFunction[{k₁,k₂,…,k_d},vars], vars needs to be a depth-d array of variables.
BooleanConvert converts BooleanConsecutiveFunction[spec][vars] to an explicit Boolean expression.
In BooleanConsecutiveFunction[spec,vars,form], the possible forms are as given for BooleanConvert.
BooleanConsecutiveFunction[spec,vars] by default gives an expression in disjunctive normal form (DNF).

Examples

open all close all

Basic Examples (3)

Create a consecutive-2-out-of-3 Boolean function:

Wolfram Language code: BooleanConsecutiveFunction[2, 3][Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]]

Convert to explicit form:

Wolfram Language code: BooleanConvert[%]

Use BooleanConsecutiveFunction in ReliabilityDistribution:

Wolfram Language code: {Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = Table[ExponentialDistribution[Subscript[λ, i]], {i, 3}];

Wolfram Language code:

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

Compute the survival function:

Wolfram Language code: SurvivalFunction[ℛ, t]//Simplify

Use BooleanConsecutiveFunction in FailureDistribution:

Wolfram Language code: {Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = Table[ExponentialDistribution[Subscript[λ, i]], {i, 3}];

Wolfram Language code:

ℱ = FailureDistribution[BooleanConsecutiveFunction[2, 3][x, y, z], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}}];

Compute the survival function:

Wolfram Language code: SurvivalFunction[ℱ, t]//Simplify

Scope (10)

Linear Model (4)

BooleanConsecutiveFunction stays unevaluated:

Wolfram Language code: BooleanConsecutiveFunction[2, 4][x, y, z, v]

Use BooleanConvert to expand it:

Wolfram Language code: BooleanConvert[%]

Construct the function as an expression in the conjunctive normal form:

Wolfram Language code: BooleanConsecutiveFunction[2, {x, y, z, v}, "CNF"]

Define a two-dimensional function, shaped as a grid:

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{2, 2}, {3, 3}][Array[Subscript[x, #1, #2]&, {3, 3}]]]

Variables can also be given in a flat list:

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{2, 2}, {3, 3}][Array[Subscript[x, #]&, 9]]]

A system works if at least three out of four consecutive components on a line work:

Wolfram Language code: 𝒟 = ExponentialDistribution[λ];

Wolfram Language code:

ℛ = ReliabilityDistribution[BooleanConsecutiveFunction[3, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℛ, t]

BooleanConsecutiveFunction can be used in a structure:

Wolfram Language code:

ℛ2 = ReliabilityDistribution[w∨BooleanConsecutiveFunction[3, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℛ2, t]

A system fails if at least three out of four consecutive components on a line fail:

Wolfram Language code: 𝒟 = ExponentialDistribution[λ];

Wolfram Language code: ℱ = FailureDistribution[BooleanConsecutiveFunction[3, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℱ, t]

BooleanConsecutiveFunction can be used in a structure:

Wolfram Language code:

ℱ2 = FailureDistribution[w∨BooleanConsecutiveFunction[3, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℱ2, t]

Circular Model (4)

BooleanConsecutiveFunction stays unevaluated:

Wolfram Language code: BooleanConsecutiveFunction[{2, True}, 3][x, y, z]

Use BooleanConvert to expand it:

Wolfram Language code: BooleanConvert[%]

Construct the function as an expression in the algebraic normal form:

Wolfram Language code: BooleanConsecutiveFunction[{2, True}, {x, y, z}, "ANF"]

Define a two-dimensional function, in the shape of a torus:

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{{2, 2}, True}, {3, 3}][Array[Subscript[x, #1, #2]&, {3, 3}]]]

Variables can also be given in a flat list:

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{{2, 2}, True}, {3, 3}][Array[Subscript[x, #]&, 9]]]

A system fails if at least three out of four consecutive components in a circle fail:

Wolfram Language code: 𝒟 = ExponentialDistribution[λ];

Wolfram Language code:

ℛ = FailureDistribution[BooleanConsecutiveFunction[{3, True}, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℛ, t]//PiecewiseExpand

BooleanConsecutiveFunction can be used in a structure:

Wolfram Language code:

ℛ2 = FailureDistribution[w∨BooleanConsecutiveFunction[{3, True}, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℛ2, t]//PiecewiseExpand

A system works if at least three out of four consecutive components in a circle work:

Wolfram Language code: 𝒟 = ExponentialDistribution[λ];

Wolfram Language code:

ℱ = ReliabilityDistribution[BooleanConsecutiveFunction[{3, True}, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℱ, t]//PiecewiseExpand

BooleanConsecutiveFunction can be used in a structure:

Wolfram Language code:

ℱ2 = ReliabilityDistribution[w∨BooleanConsecutiveFunction[{3, True}, 4][x, y, z, v], {{x, 𝒟}, {y, 𝒟}, {z, 𝒟}, {v, 𝒟}, {w, 𝒟}}];

Wolfram Language code: SurvivalFunction[ℱ2, t]//PiecewiseExpand

Mixed Model (2)

Wrapping can be different in different dimensions. Define a cylinder:

Wolfram Language code: BooleanConsecutiveFunction[{{2, 2}, {True, False}}, {3, 3}][Array[Subscript[x, #1, #2]&, {3, 3}]]

Use BooleanConvert to expand it:

Wolfram Language code: BooleanConvert[%]

Construct the function as an expression in the conjunctive normal form:

Wolfram Language code: BooleanConsecutiveFunction[{{2, 2}, {True, False}}, Array[Subscript[x, #1, #2]&, {3, 3}], "CNF"]

Connected cylinders stacked inside each other:

Wolfram Language code:

BooleanConsecutiveFunction[{{2, 3, 3}, {False, False, True}}, {3, 3, 3}][Flatten[Array[Subscript[x, #1, #2, #3]&, {3, 3, 3}]]];

Use BooleanConvert to expand it:

Wolfram Language code: BooleanConvert[%]

Applications (2)

A chain of 10 radio towers fails if two neighboring towers fail:

Wolfram Language code: structure = BooleanConsecutiveFunction[2, 10][Array[Subscript[x, #]&, 10]]

Each tower has an exponential lifetime distribution with an expected lifetime of 10 years:

Wolfram Language code: 𝒟tower = ExponentialDistribution[1 / 10];

The survival function for communication from one end of the tower chain to the other:

Wolfram Language code: ℱ = FailureDistribution[structure, Array[{Subscript[x, #], 𝒟tower}&, 10]];

Wolfram Language code: Plot[Evaluate@SurvivalFunction[ℱ, t], {t, 0, 10}, Filling -> Axis]

The probability of functioning communication after five years without maintenance:

Wolfram Language code: Probability[t > 5, tℱ]//N

Cameras are arranged in an overlapping grid. All areas are covered until a 2×2 grid fails:

Wolfram Language code: structure = BooleanConsecutiveFunction[{2, 2}, {4, 4}][Array[Subscript[x, #1, #2]&, {4, 4}]];

Each camera has an expected lifetime of six years:

Wolfram Language code: 𝒟camera = ExponentialDistribution[1 / 6];

The lifetime distribution of a complete camera system is modeled with FailureDistribution:

Wolfram Language code: ℱ = FailureDistribution[structure, Join@@Array[{Subscript[x, #1, #2], 𝒟camera}&, {4, 4}]];

To cover the same area with minimal overlap, four cameras are needed:

Wolfram Language code:

ℱnooverlap = FailureDistribution[Subscript[x, 1] || Subscript[x, 2] || Subscript[x, 3] || Subscript[x, 4], {{Subscript[x, 1], 𝒟camera}, {Subscript[x, 2], 𝒟camera}, {Subscript[x, 3], 𝒟camera}, {Subscript[x, 4], 𝒟camera}}];

The overlapping structure has a higher reliability, but uses more cameras:

Wolfram Language code: Plot[Evaluate@{SurvivalFunction[ℱ, t], SurvivalFunction[ℱnooverlap, t]}, {t, 0, 15}, Filling -> Axis]

Use the same amount of cameras in standby mode instead:

Wolfram Language code: 𝒟standby = StandbyDistribution[𝒟camera, {𝒟camera, 𝒟camera, 𝒟camera}, 0.9];

Wolfram Language code:

ℱstandby = FailureDistribution[Subscript[x, 1] || Subscript[x, 2] || Subscript[x, 3] || Subscript[x, 4], {{Subscript[x, 1], 𝒟standby}, {Subscript[x, 2], 𝒟standby}, {Subscript[x, 3], 𝒟standby}, {Subscript[x, 4], 𝒟standby}}];

Depending on mission time, a standby setup has higher reliability than an overlapping grid:

Wolfram Language code: Plot[Evaluate@{SurvivalFunction[ℱ, t], SurvivalFunction[ℱstandby, t]}, {t, 0, 15}, Filling -> Axis]

Properties & Relations (2)

Lower dimensions are special cases of higher dimensions:

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{3, True}, 4][Array[Subscript[x, 1, #]&, 4]]]

Wolfram Language code: BooleanConvert[BooleanConsecutiveFunction[{{1, 3}, True}, {1, 4}][Array[Subscript[x, #1, #2]&, {1, 4}]]]

Wolfram Language code: Equivalent[%%, %]//TautologyQ

A ReliabilityDistribution with a BooleanConsecutiveFunction is equal to the negated corresponding Boolean expression in a FailureDistribution:

Wolfram Language code: {Subscript[𝒟, 1], Subscript[𝒟, 2], Subscript[𝒟, 3]} = Table[ExponentialDistribution[Subscript[λ, i]], {i, 3}];

Wolfram Language code:

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

Wolfram Language code:

ℱ = FailureDistribution[¬BooleanConsecutiveFunction[2, 3][¬x, ¬y, ¬z], {{x, Subscript[𝒟, 1]}, {y, Subscript[𝒟, 2]}, {z, Subscript[𝒟, 3]}}];

Wolfram Language code: CDF[ℛ, t] - CDF[ℱ, t]

Neat Examples (1)

Simulate a linear consecutive-k-out-of-n system:

Wolfram Language code: meaning[False] = "working";meaning[True] = "failed";

Wolfram Language code:

simulate[k_, n_, λ_ : 1 / 2] := Block[{failed = False, deaths, t = -1, res = {}}, 
	deaths = RandomVariate[ExponentialDistribution[λ], n];
	While[!failed, 
	t++;
	tab = Table[Style[Subscript[x, i], If[deaths[[i]] < t, Red, Green]], {i, n}];
	failed = BooleanConvert@BooleanConsecutiveFunction[k, n][Map[t > #&, deaths]];
	AppendTo[res, Graph[tab, Table[Subscript[x, j]Subscript[x, j + 1], {j, n - 1}], VertexSize -> Large, PlotLabel -> "t = " <> ToString[t] <> ", system " <> meaning[failed]]];
	];
	res//Column]

When requiring four out of 10 components to fail for the system to fail, with failure rate :

Wolfram Language code: simulate[4, 10, 1 / 3]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

BooleanConsecutiveFunction

Details

Examples

Basic Examples (3)

Scope (10)

Linear Model (4)

Circular Model (4)

Mixed Model (2)

Applications (2)

Properties & Relations (2)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

BooleanConsecutiveFunction

Details

Examples

Basic Examples (3)

Scope (10)

Linear Model (4)

Circular Model (4)

Mixed Model (2)

Applications (2)

Properties & Relations (2)

Neat Examples (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX