Wolfram Language & System Documentation Center

PoissonProcess

PoissonProcess[μ]

represents a Poisson process with rate μ.

Details

PoissonProcess is a continuous-time and discrete-state random process.
PoissonProcess at time t is the number of events in the interval 0 to t.
The number of events in the interval 0 to t follows PoissonDistribution[μ t].
The times between events are independent and follow ExponentialDistribution[μ].
PoissonProcess allows μ to be any positive real number.
PoissonProcess can be used with such functions as Mean, PDF, Probability, and RandomFunction.

Examples

open all close all

Basic Examples (3)

Simulate a Poisson process:

Wolfram Language code: data = RandomFunction[PoissonProcess[1.3], {0, 15}]

Wolfram Language code: ListStepPlot[data, Filling -> Axis]

Mean and variance functions:

Wolfram Language code: Mean[PoissonProcess[μ][t]]

Wolfram Language code: Variance[PoissonProcess[μ][t]]

Covariance function:

Wolfram Language code: CovarianceFunction[PoissonProcess[μ], s, t]

Wolfram Language code:

Plot3D[CovarianceFunction[PoissonProcess[2], s, t], {s, 1, 10}, {t, 1, 10}, ColorFunction -> "Rainbow", AxesLabel -> Automatic]

Scope (12)

Basic Uses (6)

Simulate an ensemble of paths:

Wolfram Language code: data = RandomFunction[PoissonProcess[2.7], {0, 15}, 4]

Wolfram Language code: ListStepPlot[data, Filling -> Axis]

Simulate with arbitrary precision:

Wolfram Language code: RandomFunction[PoissonProcess[3], {2}, WorkingPrecision -> 20]["Path"]

Compare paths for different values of process parameter:

Wolfram Language code: sample[μ_] := (SeedRandom[3];RandomFunction[PoissonProcess[μ], {0, 20}])

Wolfram Language code: pars = {.6, 1, 3.5};

Wolfram Language code: ListStepPlot[sample[#], Filling -> Axis, PlotLabel -> StringJoin["λ = ", ToString[#]]]& /@ pars

Process parameter estimation:

Wolfram Language code: sample = RandomFunction[PoissonProcess[.3], {0, 10 ^ 3}];

Estimate the distribution parameter from sample data:

Wolfram Language code: EstimatedProcess[sample, PoissonProcess[p]]

Estimate from the times of jumps:

Wolfram Language code: times = Accumulate@RandomVariate[ExponentialDistribution[.4], 200];

Wolfram Language code: EstimatedProcess[times, PoissonProcess[p]]

Correlation function:

Wolfram Language code: CorrelationFunction[PoissonProcess[μ], s, t]

Absolute correlation function:

Wolfram Language code: AbsoluteCorrelationFunction[PoissonProcess[μ], s, t]

Process Slice Properties (6)

Univariate SliceDistribution:

Wolfram Language code:

DiscretePlot[Evaluate@Table[PDF[PoissonProcess[4][t], x], {t, times = {1, 4, 8}}], {x, 0, 40}, PlotLegends -> (StringJoin["t = ", ToString[#]]& /@ times)]

Wolfram Language code: PoissonProcess[μ][t]

Univariate probability density:

Wolfram Language code: PDF[PoissonProcess[μ][t], x]

Compare to the probability density of a Poisson distribution:

Wolfram Language code: PDF[PoissonDistribution[μ t], x]

Wolfram Language code: % - %%//Simplify

Multi-time slice distribution:

Wolfram Language code: SliceDistribution[PoissonProcess[μ], {1, 3, 7}]//Mean

Higher-order PDF:

Wolfram Language code: PDF[PoissonProcess[μ][{1, 3, 7}], {x, y, z}]

Compute the expectation of an event:

Wolfram Language code: Expectation[x ^ 2 + x + 3E ^ (-x), xPoissonProcess[μ][t]]

Calculate the probability of an event:

Wolfram Language code: Probability[x[t] ^ 2 + x[t] < 34, xPoissonProcess[μ]]

Skewness is positive:

Wolfram Language code:

Plot[Evaluate@Table[Skewness[PoissonProcess[μ][t]], {μ, pars = {.2, .5, 2}}], {t, 0, 2}, PlotLegends -> (StringJoin["μ = ", ToString[#]]& /@ pars)]

Wolfram Language code: Skewness[PoissonProcess[μ][t]]

The limiting values:

Wolfram Language code: Limit[Skewness[PoissonProcess[μ][t]], t -> ∞, Assumptions -> μ > 0]

Wolfram Language code: Limit[Skewness[PoissonProcess[μ][t]], t -> 0, Assumptions -> μ > 0]

Kurtosis is greater than 3 and hence slices of the Poisson process are leptokurtic:

Wolfram Language code:

Plot[Evaluate@Table[Kurtosis[PoissonProcess[μ][t]], {μ, pars = {.2, .5, 2}}], {t, 0, 2}, PlotLegends -> (StringJoin["μ = ", ToString[#]]& /@ pars)]

Wolfram Language code: Kurtosis[PoissonProcess[μ][t]]

The limiting values:

Wolfram Language code: Limit[Kurtosis[PoissonProcess[μ][t]], t -> ∞, Assumptions -> μ > 0]

Wolfram Language code: Limit[Kurtosis[PoissonProcess[μ][t]], t -> 0, Assumptions -> μ > 0]

Moment:

Wolfram Language code: Moment[PoissonProcess[μ][t], r]

Generating functions:

Wolfram Language code: CharacteristicFunction[PoissonProcess[μ][t], w]

Wolfram Language code: MomentGeneratingFunction[PoissonProcess[μ][t], w]

CentralMoment has no closed form for symbolic order:

Wolfram Language code: CentralMoment[PoissonProcess[μ][t], r]

Wolfram Language code: CentralMoment[PoissonProcess[μ][t], 4]

Wolfram Language code: CentralMomentGeneratingFunction[PoissonProcess[μ][t], w]

FactorialMoment and its generating function:

Wolfram Language code: FactorialMoment[PoissonProcess[μ][t], r]

Wolfram Language code: FactorialMomentGeneratingFunction[PoissonProcess[μ][t], w]

Cumulant and its generating function:

Wolfram Language code: Cumulant[PoissonProcess[μ][t], r]

Wolfram Language code: CumulantGeneratingFunction[PoissonProcess[μ][t], w]

Applications (14)

Customers arrive at a store according to a Poisson rate of four per hour. Given that the store opens at 9am, find the probability that exactly one customer has arrived by 9:30am:

Wolfram Language code: arrivalProcess = PoissonProcess[4];

The probability of exactly one arrival by 9:30am:

Wolfram Language code: Probability[x[1 / 2] == 1, xarrivalProcess]

Wolfram Language code: N[%]

Inquiries arrive at a recorded messaging device according to a Poisson process rate of 15 inquiries per minute. Find the probability that in a one-minute period, three inquiries arrive during the first 10 seconds and two inquiries arrive during the last 15 seconds:

Wolfram Language code: λ = 15 / 60;

Wolfram Language code: arrivalProcess = PoissonProcess[λ];

Probability that three inquiries arrive during the first 10 seconds:

Wolfram Language code: p1 = NProbability[x[10] == 3, xarrivalProcess]

Since events are independent, the last 15 seconds behave as the first 15:

Wolfram Language code: p2 = NProbability[x[15] == 2, xarrivalProcess]

Hence the required probability, using independence, is given as the product:

Wolfram Language code: p1 p2

An insurance company has two types of policies, A and B. Total claims from the company arrive according to a Poisson process at the rate of nine per day. Find the probability that the total claims from the company will be fewer than two on a given day:

Wolfram Language code: claimsProcess = PoissonProcess[9];

Wolfram Language code: NProbability[x[1] < 2, xclaimsProcess]

Simulate the accumulation of total claims over the month:

Wolfram Language code: monthClaims = RandomFunction[claimsProcess, {0, 30}]

Wolfram Language code: ListPlot[monthClaims, Filling -> Axis]

Find the number of daily claims for the month:

Wolfram Language code: claimsDaily = monthClaims["SliceData", Range[30]]//First

Wolfram Language code: Differences[claimsDaily]

Wolfram Language code: ListPlot[%, Filling -> Axis]

A server handles queries that arrive according to a Poisson process with a rate of 10 queries per minute. Find the probability that no queries go unanswered if the server is unavailable for 20 seconds:

Wolfram Language code: arrivalProcess = PoissonProcess[10];

Probability of no queries arriving in 20 seconds:

Wolfram Language code: Probability[x[1 / 3] == 0, xarrivalProcess]

Wolfram Language code: N[%]

You get email according to a Poisson process at an average rate of 0.2 messages per hour. You check your email every hour. Compute the probability of finding one message:

Wolfram Language code: emailProcess = PoissonProcess[0.2];

Probability of finding one message:

Wolfram Language code: NProbability[x[1] == 1, xemailProcess]

Probability of no messages on a day when you do not check your email:

Wolfram Language code: NProbability[x[24] == 0, xemailProcess]

Particles are emitted by a radioactive source according to a Poisson process at the rate of per hour. Find the probability that no particle is emitted during at least one of five consecutive hours:

Wolfram Language code: emissionProcess = PoissonProcess[Log[5]];

Probability of an emission during one hour:

Wolfram Language code: NProbability[x[1] > 0, xemissionProcess]

Probability of an emission during each one of five consecutive hours:

Wolfram Language code: NProbability[x[1] > 0, xemissionProcess] ^ 5

Probability of no emission during at least one of five consecutive hours:

Wolfram Language code: 1 - NProbability[x[1] > 0, xemissionProcess] ^ 5

You call a hotline and you are told that you are the 56 person in line, excluding the person currently being served. Callers depart according to a Poisson process with a rate of 2 per minute:

Wolfram Language code: callServiceProcess = PoissonProcess[2];

Find the probability that you will have to wait for more than 30 minutes:

Wolfram Language code: NProbability[x[30] < 56, xPoissonProcess[2]]

The number of failures that occur in a computer network follow a Poisson process. On average, there is a failure after every four hours. Find the probability that the third failure occurs after eight hours:

Wolfram Language code: breakdownProcess = PoissonProcess[1 / 4];

Probability that the third failure occurs after eight hours:

Wolfram Language code: NProbability[x[8] < 3, xbreakdownProcess]

The failures of a certain machine occur according to a Poisson process with a rate of per week. Find the probability that the machine will have at least one failure during each of the first two weeks considered:

Wolfram Language code: breakdownProcess = PoissonProcess[1];

Probability of at least one failure during one week:

Wolfram Language code: Probability[x[1] > 0, xbreakdownProcess]

Probability of at least one failure during each of the first two weeks is given by the product:

Wolfram Language code: Probability[x[1] > 0, xbreakdownProcess] ^ 2

Wolfram Language code: N[%]

Travelers arrive at a bus station starting at 6am, according to a Poisson process with a rate of one per two minutes. Find the mean and variance for the number of passengers on the first bus to leave after 6am if the bus departures follow an exponential distribution with a mean of 15 minutes:

Wolfram Language code:

μ = 1 / 2;
arrivalProcess = PoissonProcess[μ];

Wolfram Language code: ListStepPlot[RandomFunction[arrivalProcess, {0, 50}, 3]]

The number of passengers on the bus is distributed as follows:

Wolfram Language code: traveler𝒟 = ParameterMixtureDistribution[arrivalProcess[μ t], tExponentialDistribution[1 / 15]]

Wolfram Language code: DiscretePlot[PDF[traveler𝒟, x], {x, 0, 20}, PlotMarkers -> Automatic]

Mean and variance for the number of passengers:

Wolfram Language code: {Mean[traveler𝒟], Variance[traveler𝒟]}//N

Mean and variance if the departures are uniformly distributed between 6am and 6:20am:

Wolfram Language code: traveler𝒟 = ParameterMixtureDistribution[PoissonProcess[μ][t], tUniformDistribution[{0, 20}]];

Wolfram Language code: DiscretePlot[Evaluate@PDF[traveler𝒟, x], {x, 0, 20}, PlotMarkers -> Automatic]

Wolfram Language code: {Mean[traveler𝒟], Variance[traveler𝒟]}//N

Average number of passengers on a 20-seater bus that leaves at 6:15am:

Wolfram Language code: NExpectation[Min[x[15], 20], xPoissonProcess[μ]]

The number of flaws appearing on a polished mirror surface is a Poisson random variable. For a mirror with an area of 8.54 cm, the probability of no flaws is 0.91. Using the same process, another mirror with an area of 17.50 cm is fabricated. Find the probability of no flaws on the larger mirror:

Wolfram Language code: flawProcess = PoissonProcess[λ];

Find the Poisson parameter using information about the smaller mirror:

Wolfram Language code: flawProcess = (flawProcess /. Solve[Probability[x[8.54] == 0, xflawProcess] == 0.91, λ][[1]])//Quiet

Probability that there are no flaws on the larger mirror:

Wolfram Language code: Probability[x[17.50] == 0, xflawProcess]

A light bulb has a lifetime that is exponential with a mean of 200 days. When it burns out, a janitor replaces it immediately. In addition, there is a handyman who comes at times with a Poisson rate of 0.01 and replaces the light bulb as a part of preventive maintenance. Find the mean number of days after which the light bulb is replaced:

Wolfram Language code: λ = 1 / 200 + 1 / 100;

Wolfram Language code: bulbReplacementProcess = PoissonProcess[λ];

Simulate the number of days until replacement:

Wolfram Language code: ListStepPlot[RandomFunction[bulbReplacementProcess, {0, 300}]]

Mean number of days after which the light bulb is replaced:

Wolfram Language code: 1 / λ//Round

At night, vehicles circulate on a certain highway with separate roadways according to a Poisson process with rate 2 per minute in each direction. Due to an accident, traffic must be stopped in one direction. Suppose that 60% of the vehicles are cars, 30% are trucks, and 10% are semitrailers. Suppose also that the length of a car is equal to 5 meters, that of a truck is equal to 10 meters, and that of a semitrailer is 20 meters. Find the time at which there is a 10% probability that the length of the queue is greater than 1 km:

Wolfram Language code: circulationProcess = PoissonProcess[2];

Simulate the number of cars:

Wolfram Language code: sampleQueue = RandomFunction[circulationProcess, {0, 70}]

Length of the queue if vehicles have been stopped in the first seconds:

Wolfram Language code: averageLength = (0.6 * 5 + 0.3 * 10 + 0.1 * 20);

Calculate the length of the simulated queue:

Wolfram Language code: sampleQueueLength = averageLength * sampleQueue

Wolfram Language code: ListStepPlot[sampleQueueLength]

Time at which the probability of queue length more than 1 km is 10%:

Wolfram Language code: queueLength = averageLength * x[t];

Wolfram Language code: t /. FindRoot[Probability[queueLength > 1000, xcirculationProcess] == 1 / 10, {t, 70}][[1]]

Define the square of a Poisson process:

Wolfram Language code: 𝒫 = TransformedProcess[p[t] ^ 2, pPoissonProcess[1], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[𝒫, {0, 30, 1}, 3];

Wolfram Language code: ListStepPlot[data]

Covariance and correlation functions for the process:

Wolfram Language code: CovarianceFunction[𝒫, s, t]

Wolfram Language code: CorrelationFunction[𝒫, s, t]

Properties & Relations (11)

PoissonProcess is a jump process:

Wolfram Language code:

path = RandomFunction[PoissonProcess[2], {0, 10}];
f = path["PathFunction"];
jumps = path["Times"];

Wolfram Language code: Plot[f[t], {t, 0, 10}, Exclusions -> jumps, ExclusionsStyle -> Red]

Poisson process is not weakly stationary:

Wolfram Language code: WeakStationarity[PoissonProcess[μ]]

Poisson process has independent increments:

Wolfram Language code: proc = PoissonProcess[μ];

Wolfram Language code: Expectation[(x[t2] - x[t1])(x[t4] - x[t3]), xproc, Assumptions -> 0 < t1 < t2 < t3 < t4]//Simplify

Compare to the product of expectations:

Wolfram Language code:

Expectation[(x[t2] - x[t1]), xproc, Assumptions -> 0 < t1 < t2] * Expectation[(x[t4] - x[t3]), xproc, Assumptions -> 0 < t3 < t4]//Simplify

Wolfram Language code: % === %%

The time between events in a Poisson process follows an ExponentialDistribution:

Wolfram Language code: Probability[p[t] == 0, pPoissonProcess[λ]]

Wolfram Language code: SurvivalFunction[ExponentialDistribution[λ], t]//Refine[#, t > 0]&

Wolfram Language code: % - %%

Mean interarrival time:

Wolfram Language code: Mean[ExponentialDistribution[λ]]

Fit a parametric distribution to interarrival times:

Wolfram Language code: PPsample = RandomFunction[PoissonProcess[1 / 3], {10 ^ 4}];

Calculate times between events:

Wolfram Language code: times = Differences[PPsample["Times"]];

Wolfram Language code: h = Histogram[times, {0, Max[times] + .5, .5}, "PDF"]

Fit an exponential distribution:

Wolfram Language code: edist = EstimatedDistribution[times, ExponentialDistribution[λ]]

Compare the data histogram to the estimated probability density function:

Wolfram Language code: Show[h, Plot[PDF[edist, x], {x, 0, Max[times]}, PlotStyle -> Thick, PlotRange -> All]]

Check goodness of fit:

Wolfram Language code: DistributionFitTest[times, edist, "TestConclusion"]

Transition probability:

Wolfram Language code:

Table[DiscretePlot[Probability[(x[12] == Subscript[x, 2])(x[7] == Subscript[x, 1]), xPoissonProcess[.6]], {Subscript[x, 2], 0, 14}, ExtentSize -> 1 / 2, PlotLabel -> StringJoin["SubscriptBox[x, 1] = ", ToString[Subscript[x, 1]]]], {Subscript[x, 1], {1, 3, 5, 7}}]

Wolfram Language code:

Probability[(x[Subscript[t, 2]] == Subscript[x, 2])(x[Subscript[t, 1]] == Subscript[x, 1]), xPoissonProcess[p], Assumptions -> 0 < Subscript[t, 1] < Subscript[t, 2] && 0 ≤ Subscript[x, 1]]//Simplify[#, 0 ≤ Subscript[x, 1] && 0 ≤ Subscript[x, 2]]&

RenewalProcess is a generalization of PoissonProcess:

Wolfram Language code: renewal[λ_] := RenewalProcess[ExponentialDistribution[λ]]

Univariate slice distributions:

Wolfram Language code: {renewal[λ][t], PoissonProcess[λ][t]}

Compare covariance functions:

Wolfram Language code: {CovarianceFunction[renewal[λ], s, t], CovarianceFunction[PoissonProcess[λ], s, t]}

CompoundPoissonProcess is a generalization of PoissonProcess:

Wolfram Language code: compound[λ_] := CompoundPoissonProcess[λ, BernoulliDistribution[1]]

Univariate slice distributions:

Wolfram Language code: {compound[λ][t], PoissonProcess[λ][t]}

TelegraphProcess is a transformation of a PoissonProcess:

Wolfram Language code: proc = TransformedProcess[(-1)^x[t], xPoissonProcess[3], t];

Simulate the process:

Wolfram Language code: data = RandomFunction[proc, {0, 20}];

Wolfram Language code: ListStepPlot[data]

Probability density function for a time slice of the process:

Wolfram Language code: PDF[proc[t], x]

Compare with the PDF for TelegraphProcess:

Wolfram Language code: PDF[TelegraphProcess[3][t], x]

Wolfram Language code: % == %%

Compare CovarianceFunction:

Wolfram Language code: CovarianceFunction[proc, s, t]

Wolfram Language code: CovarianceFunction[TelegraphProcess[3], s, t]

Wolfram Language code: % == %%

InhomogeneousPoissonProcess with constant intensity is a Poisson process:

Wolfram Language code: ipp = InhomogeneousPoissonProcess[λ, t];

Wolfram Language code: pp = PoissonProcess[λ];

Compare univariate slice distributions:

Wolfram Language code: Mean /@ {ipp[t], pp[t]}

Wolfram Language code: Variance /@ {ipp[t], pp[t]}

Wolfram Language code: PDF[#, x]& /@ {ipp[t], pp[t]}

Multi-slice properties:

Wolfram Language code: CovarianceFunction[#, s, t]& /@ {ipp, pp}

Wolfram Language code: PDF[#, {x, y}]& /@ {ipp[{s, t}], pp[{s, t}]}

Parameter mixture distribution of a slice distribution follows GeometricDistribution::

Wolfram Language code: ParameterMixtureDistribution[PoissonProcess[μ][t], tExponentialDistribution[m]]

Neat Examples (1)

Simulate paths from a Poisson process:

Wolfram Language code:

SeedRandom[34];
data = RandomFunction[PoissonProcess[3], {50}, 300];

Take a slice at 50 and visualize its distribution:

Wolfram Language code: sd = data["SliceData", 50];

Wolfram Language code:

cf = ColorData["Rainbow"];
sliced = BarChart[Last[#], Axes -> False, BarOrigin -> Left, AspectRatio -> 4, ChartStyle -> (cf /@ Rescale[MovingAverage[First[#], 2], {Min[sd], Max[sd]}, {0, 1}]), ImageSize -> 29]&[HistogramList[sd, {Range[Min[sd], Max[sd], (Max[sd] - Min[sd]) / 20]}]];

Plot paths and histogram distribution of the slice distribution at 50:

Wolfram Language code:

ListLinePlot[data, ImageSize -> 400, PlotRange -> All, 
	AspectRatio -> 3 / 4, Epilog -> Inset[sliced, {50.5, 150}, {0, 10.5}], PlotStyle -> (cf /@ Rescale[sd]), BaseStyle -> Thin, PlotRangePadding -> {{0, 20}, {.5, 7}}]

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

PoissonProcess

Details

Examples

Basic Examples (3)

Scope (12)

Basic Uses (6)

Process Slice Properties (6)

Applications (14)

Properties & Relations (11)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

PoissonProcess

Details

Examples

Basic Examples (3)

Scope (12)

Basic Uses (6)

Process Slice Properties (6)

Applications (14)

Properties & Relations (11)

Neat Examples (1)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX