({{, (RefLink[PoissonProcess, paclet:ref/PoissonProcess])[μ] 
represents a Poisson process with rate μ.}})

OpenersNotesSection(Spacer1)Details

(RefLink[PoissonProcess, paclet:ref/PoissonProcess]) is a continuous-time and discrete-state random process.

(RefLink[PoissonProcess, paclet:ref/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 (RefLink[PoissonDistribution, paclet:ref/PoissonDistribution])[μ t].

The times between events are independent and follow (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])[μ].

(RefLink[PoissonProcess, paclet:ref/PoissonProcess]) allows μ to be any positive real number.

(RefLink[PoissonProcess, paclet:ref/PoissonProcess]) can be used with such functions as (RefLink[Mean, paclet:ref/Mean]), (RefLink[PDF, paclet:ref/PDF]), (RefLink[Probability, paclet:ref/Probability]), and (RefLink[RandomFunction, paclet:ref/RandomFunction]).

OpenersPrimaryExamplesSection(Spacer1)Examples  (40)

OpenersExampleSection0(Spacer1)Basic Examples  (3)

Simulate a Poisson process:

data=RandomFunction[PoissonProcess[1.3],{0,15}]

ListStepPlot[data,Filling->Axis]

Mean and variance functions:

Mean[PoissonProcess[μ][t]]

Variance[PoissonProcess[μ][t]]

Covariance function:

CovarianceFunction[PoissonProcess[μ],s,t]

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

OpenersExampleSection1(Spacer1)Scope  (12)

OpenersExampleSubsection0(Spacer1)Basic Uses  (6)

Simulate an ensemble of paths:

data=RandomFunction[PoissonProcess[2.7],{0,15},4]

ListStepPlot[data,Filling->Axis]

Simulate with arbitrary precision:

RandomFunction[PoissonProcess[3],{2},WorkingPrecision->20]["Path"]

Compare paths for different values of process parameter:

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

pars={.6,1,3.5};

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

Process parameter estimation:

sample=RandomFunction[PoissonProcess[.3],{0,10^3}];

Estimate the distribution parameter from sample data:

EstimatedProcess[sample, PoissonProcess[p]]

Estimate from the times of jumps:

times=Accumulate@RandomVariate[ExponentialDistribution[.4],200];

EstimatedProcess[times, PoissonProcess[p]]

Correlation function:

CorrelationFunction[PoissonProcess[μ],s,t]

Absolute correlation function:

AbsoluteCorrelationFunction[PoissonProcess[μ],s,t]

OpenersExampleSubsection1(Spacer1)Process Slice Properties  (6)

Univariate (RefLink[SliceDistribution, paclet:ref/SliceDistribution]):

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

PoissonProcess[μ][t]

Univariate probability density:

PDF[PoissonProcess[μ][t],x]

Compare to the probability density of a Poisson distribution:

PDF[PoissonDistribution[μ t],x]

%-%%//Simplify

Multi-time slice distribution:

SliceDistribution[PoissonProcess[μ],{1,3,7}]//Mean

Higher-order (RefLink[PDF, paclet:ref/PDF]):

PDF[PoissonProcess[μ][{1,3,7}],{x,y,z}]

Compute the expectation of an event:

Expectation[x^2+x+3E^(-x),x\[Distributed]PoissonProcess[μ][t]]

Calculate the probability of an event:

Probability[x[t]^2+x[t]<34,x\[Distributed]PoissonProcess[μ]]

Skewness is positive:

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

Skewness[PoissonProcess[μ][t]]

The limiting values:

Limit[Skewness[PoissonProcess[μ][t]],t->∞,Assumptions->μ>0]

Limit[Skewness[PoissonProcess[μ][t]],t->0,Assumptions->μ>0]

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

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

Kurtosis[PoissonProcess[μ][t]]

The limiting values:

Limit[Kurtosis[PoissonProcess[μ][t]],t->∞,Assumptions->μ>0]

Limit[Kurtosis[PoissonProcess[μ][t]],t->0,Assumptions->μ>0]

(RefLink[Moment, paclet:ref/Moment]):

Moment[PoissonProcess[μ][t],r]

Generating functions:

CharacteristicFunction[PoissonProcess[μ][t],w]

MomentGeneratingFunction[PoissonProcess[μ][t],w]

(RefLink[CentralMoment, paclet:ref/CentralMoment]) has no closed form for symbolic order:

CentralMoment[PoissonProcess[μ][t],r]

CentralMoment[PoissonProcess[μ][t],4]

CentralMomentGeneratingFunction[PoissonProcess[μ][t],w]

(RefLink[FactorialMoment, paclet:ref/FactorialMoment]) and its generating function:

FactorialMoment[PoissonProcess[μ][t],r]

FactorialMomentGeneratingFunction[PoissonProcess[μ][t],w]

(RefLink[Cumulant, paclet:ref/Cumulant]) and its generating function:

Cumulant[PoissonProcess[μ][t],r]

CumulantGeneratingFunction[PoissonProcess[μ][t],w]

OpenersExampleSection3(Spacer1)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:

arrivalProcess=PoissonProcess[4];

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

Probability[x[1/2]==1,x\[Distributed]arrivalProcess]

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:

λ=15/60;

arrivalProcess=PoissonProcess[λ];

Probability that three inquiries arrive during the first 10 seconds:

p1=NProbability[x[10]==3,x\[Distributed]arrivalProcess]

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

p2=NProbability[x[15]==2,x\[Distributed]arrivalProcess]

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

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:

claimsProcess=PoissonProcess[9];

NProbability[x[1]<2,x\[Distributed]claimsProcess]

Simulate the accumulation of total claims over the month:

monthClaims=RandomFunction[claimsProcess,{0,30}]

ListPlot[monthClaims,Filling->Axis]

Find the number of daily claims for the month:

claimsDaily=monthClaims["SliceData",Range[30]]//First

Differences[claimsDaily]

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:

arrivalProcess=PoissonProcess[10];

Probability of no queries arriving in 20 seconds:

Probability[x[1/3]==0,x\[Distributed]arrivalProcess]

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:

emailProcess=PoissonProcess[0.2];

Probability of finding one message:

NProbability[x[1]==1,x\[Distributed]emailProcess]

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

NProbability[x[24]==0, x\[Distributed]emailProcess]

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

emissionProcess=PoissonProcess[Log[5]];

Probability of an emission during one hour:

NProbability[x[1]>0,x\[Distributed]emissionProcess]

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

NProbability[x[1]>0,x\[Distributed]emissionProcess]^5

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

1-NProbability[x[1]>0,x\[Distributed]emissionProcess]^5

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

callServiceProcess=PoissonProcess[2];

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

NProbability[x[30]<56,x\[Distributed]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:

breakdownProcess=PoissonProcess[1/4];

Probability that the third failure occurs after eight hours:

NProbability[x[8]<3,x\[Distributed]breakdownProcess]

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

breakdownProcess=PoissonProcess[1];

Probability of at least one failure during one week:

Probability[x[1]>0,x\[Distributed]breakdownProcess]

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

Probability[x[1]>0,x\[Distributed]breakdownProcess]^2

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:

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

ListStepPlot[RandomFunction[arrivalProcess,{0,50},3]]

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

traveler𝒟=ParameterMixtureDistribution[arrivalProcess[μ t],t\[Distributed]ExponentialDistribution[1/15]]

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

Mean and variance for the number of passengers:

{Mean[traveler𝒟],Variance[traveler𝒟]}//N

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

traveler𝒟=ParameterMixtureDistribution[PoissonProcess[μ][t],t\[Distributed]UniformDistribution[{0,20}]];

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

{Mean[traveler𝒟],Variance[traveler𝒟]}//N

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

NExpectation[Min[x[15],20],x\[Distributed]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(^2), the probability of no flaws is 0.91. Using the same process, another mirror with an area of 17.50 cm(^2) is fabricated. Find the probability of no flaws on the larger mirror:

flawProcess=PoissonProcess[λ];

Find the Poisson parameter using information about the smaller mirror:

flawProcess = (flawProcess/.Solve[Probability[x[8.54]==0,x\[Distributed]flawProcess]==0.91,λ][[1]])//Quiet

Probability that there are no flaws on the larger mirror:

Probability[x[17.50]==0,x\[Distributed]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:

λ=1/200+1/100;

bulbReplacementProcess=PoissonProcess[λ];

Simulate the number of days until replacement:

ListStepPlot[RandomFunction[bulbReplacementProcess,{0,300}]]

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

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:

circulationProcess=PoissonProcess[2];

Simulate the number of cars:

sampleQueue=RandomFunction[circulationProcess,{0,70}]

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

averageLength=(0.6*5+0.3*10+0.1*20);

Calculate the length of the simulated queue:

sampleQueueLength=averageLength*sampleQueue

ListStepPlot[sampleQueueLength]

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

queueLength=averageLength*x[t];

t/.FindRoot[Probability[queueLength>1000,x\[Distributed]circulationProcess]==1/10,{t,70}][[1]]

Define the square of a Poisson process:

𝒫=TransformedProcess[p[t]^2,p\[Distributed]PoissonProcess[1],t];

Simulate the process:

data=RandomFunction[𝒫,{0,30,1},3];

ListStepPlot[data]

Covariance and correlation functions for the process:

CovarianceFunction[𝒫,s,t]

CorrelationFunction[𝒫,s,t]

OpenersExampleSection4(Spacer1)Properties & Relations  (10)

(RefLink[PoissonProcess, paclet:ref/PoissonProcess]) is a jump process:

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

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

Poisson process is not weakly stationary:

WeakStationarity[PoissonProcess[μ]]

Poisson process has independent increments:

proc=PoissonProcess[μ];

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

Compare to the product of expectations:

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

%===%%

The time between events in a Poisson process follows an (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution]):

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

Calculate times between changes:

times=Differences[PPsample["Times"]];

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

Fit an exponential distribution:

edist=EstimatedDistribution[times,ExponentialDistribution[λ]]

Compare the data histogram to the estimated probability density function:

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

Check goodness of fit:

DistributionFitTest[times,edist,"TestConclusion"]

Transition probability:

Table[DiscretePlot[Probability[(x[12]==(Subscript[x, 2]))\[Conditioned](x[7]==(Subscript[x, 1])),x\[Distributed]PoissonProcess[.6]],{(Subscript[x, 2]),0,14},ExtentSize->1/2,PlotLabel->StringJoin["(Subscript[x, 1]) = ",ToString[(Subscript[x, 1])]]],{(Subscript[x, 1]),{1,3,5,7}}]

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

(RefLink[RenewalProcess, paclet:ref/RenewalProcess]) is a generalization of (RefLink[PoissonProcess, paclet:ref/PoissonProcess]):

renewal[λ_]:=RenewalProcess[ExponentialDistribution[λ]]

Univariate slice distributions:

{renewal[λ][t], PoissonProcess[λ][t]}

Compare covariance functions:

{CovarianceFunction[renewal[λ],s,t],CovarianceFunction[PoissonProcess[λ],s,t]}

(RefLink[CompoundPoissonProcess, paclet:ref/CompoundPoissonProcess]) is a generalization of (RefLink[PoissonProcess, paclet:ref/PoissonProcess]):

compound[λ_]:=CompoundPoissonProcess[λ,BernoulliDistribution[1]]

Univariate slice distributions:

{compound[λ][t], PoissonProcess[λ][t]}

(RefLink[TelegraphProcess, paclet:ref/TelegraphProcess]) is a transformation of a (RefLink[PoissonProcess, paclet:ref/PoissonProcess]):

proc=TransformedProcess[(((-1))^(x[t])),x\[Distributed]PoissonProcess[3],t];

Simulate the process:

data=RandomFunction[proc,{0,20}];

ListStepPlot[data]

Probability density function for a time slice of the process:

PDF[proc[t],x]

Compare with the (RefLink[PDF, paclet:ref/PDF]) for (RefLink[TelegraphProcess, paclet:ref/TelegraphProcess]):

PDF[TelegraphProcess[3][t],x]

%==%%

Compare (RefLink[CovarianceFunction, paclet:ref/CovarianceFunction]):

CovarianceFunction[proc,s,t]

CovarianceFunction[TelegraphProcess[3],s,t]

%==%%

(RefLink[InhomogeneousPoissonProcess, paclet:ref/InhomogeneousPoissonProcess]) with constant intensity is a Poisson process:

ipp=InhomogeneousPoissonProcess[λ,t];

pp=PoissonProcess[λ];

Compare univariate slice distributions:

Mean/@{ipp[t],pp[t]}

Variance/@{ipp[t],pp[t]}

PDF[#,x]&/@{ipp[t],pp[t]}

Multi-slice properties:

CovarianceFunction[#,s,t]&/@{ipp,pp}

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

Parameter mixture distribution of a slice distribution follows (RefLink[GeometricDistribution, paclet:ref/GeometricDistribution])::

ParameterMixtureDistribution[PoissonProcess[μ][t],t\[Distributed]ExponentialDistribution[m]]

OpenersExampleSection5(Spacer1)Neat Examples  (1)

Simulate paths from a Poisson process:

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

Take a slice at 50 and visualize its distribution:

sd=data["SliceData",50];

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:

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}}]

({{DocumentationFooterIconsRelatedFunction.png, ({{See Also}, {(RefLink[CompoundPoissonProcess, paclet:ref/CompoundPoissonProcess])  ▪  (RefLink[InhomogeneousPoissonProcess, paclet:ref/InhomogeneousPoissonProcess])  ▪  (RefLink[RenewalProcess, paclet:ref/RenewalProcess])  ▪  (RefLink[CompoundRenewalProcess, paclet:ref/CompoundRenewalProcess])  ▪  (RefLink[TelegraphProcess, paclet:ref/TelegraphProcess])  ▪  (RefLink[BinomialProcess, paclet:ref/BinomialProcess])  ▪  (RefLink[PoissonDistribution, paclet:ref/PoissonDistribution])  ▪  (RefLink[ExponentialDistribution, paclet:ref/ExponentialDistribution])  ▪  (RefLink[CompoundPoissonDistribution, paclet:ref/CompoundPoissonDistribution])}})}})

({{DocumentationFooterIconsRelatedGuide.png, ({{Related Guides}, {▪(RefLinkPlain[Probability & Statistics, paclet:guide/ProbabilityAndStatistics])}, {▪(RefLinkPlain[Parametric Random Processes, paclet:guide/ParametricRandomProcesses])}, {▪(RefLinkPlain[Queueing Processes, paclet:guide/QueueingProcesses])}, {▪(RefLinkPlain[Finite Markov Processes, paclet:guide/MarkovProcesses])}, {▪(RefLinkPlain[Random Processes, paclet:guide/RandomProcesses])}})}})