Products
  • Wolfram|One

    The definitive Wolfram Language and notebook experience

  • Mathematica

    The original technical computing environment

  • System Modeler

    Multidomain modeling and simulation of complex systems

  • Compute ServicesUse with Mathematica and Wolfram|One
  • AI AccessUse with Mathematica and Wolfram|One
  • Finance Platform
  • Wolfram|Alpha Notebook Edition
  • Application Server
  • Enterprise Private Cloud
  • Wolfram Engine
  • Wolfram Player
  • Wolfram Cloud App
  • Wolfram Player App

More mobile apps

Wolfram|Alpha

  • Wolfram|Alpha Website
  • Wolfram|Alpha APIs

AI Products

  • Wolfram AI Ecosystem
  • Wolfram Foundation Tool
  • Wolfram Cloud MCP
  • Wolfram Local MCP
  • Agent One API
  • CAG Component APIs

Core Technologies of Wolfram Products

  • Wolfram Language
  • Computable Data
  • Wolfram Notebooks
  • Linguistic Understanding

Additional Deployment Options

  • Wolfram Cloud
  • Wolfram Web Engine
  • wolframscript
  • WSTPServer
  • Group & Organizational Licensing
  • All Products
Consulting & Solutions

We deliver solutions for the AI era—combining symbolic computation, data-driven insights and deep technical expertise

Wolfram Consulting

Data Science, Finance & Business

  • Artificial Intelligence
  • Data Science
  • Healthcare
  • Real Estate

Engineering

  • Civil Engineering
  • Automotive Engineering
  • Sustainable Energy

Science & Technology

  • AgTech
  • Biosciences
  • Environmental Science
  • Food Science
  • Quantum Computation
  • Social and Behavioral Sciences

More Wolfram Solutions

Technology for Education

  • Research Universities
  • Colleges & Teaching Universities
  • High Schools
  • Resources for Students

Education Initiatives

  • Next-Gen EdTech
  • Computer-Based Math

More Solutions for Education

  • Contact Us
Learning & Support

Get Started

  • Wolfram Language Introduction
  • Fast Intro for Programmers
  • Fast Intro for Math Students
  • Wolfram Language Documentation

More Learning

  • Highlighted Core Areas
  • Demonstrations
  • YouTube
  • Daily Study Groups
  • Wolfram Schools and Programs
  • Books

Grow Your Skills

  • Wolfram U

    Courses in computing, science, life and more

  • Community

    Learn, solve problems and share ideas.

  • Blog

    News, views and insights from Wolfram

  • Resources for

    Software Developers

Tech Support

  • Contact Us
  • Support FAQs
  • Support FAQs
  • Contact Us
Company
  • About Wolfram
  • Career Center
  • All Sites & Resources
  • Connect & Follow
  • Contact Us

Work with Us

  • Student Ambassador Initiative
  • Wolfram for Startups
  • Student Opportunities
  • Jobs Using Wolfram Language

Educational Programs for Adults

  • Summer School
  • Winter School

Educational Programs for Youth

  • Middle School Camp
  • High School Research Program
  • Computational Adventures

Read

  • Stephen Wolfram's Writings
  • Wolfram Blog
  • Wolfram Tech | Books
  • Wolfram Media
  • Complex Systems

Educational Resources

  • Wolfram MathWorld
  • Wolfram in STEM
  • Wolfram Challenges
  • Wolfram Problem Generator

Wolfram Initiatives

  • Wolfram Science
  • Wolfram Foundation
  • History of Mathematics Project

Events

  • Stephen Wolfram Livestreams
  • Online & In-Person Events
  • Contact Us
  • Connect & Follow
For AIs
  • Your Account
  • User Portal
  • Wolfram Cloud
  • Products
    • Wolfram|One
    • Mathematica
    • System Modeler
    • Compute ServicesUse with Mathematica and Wolfram|One
    • AI AccessUse with Mathematica and Wolfram|One
    • Finance Platform
    • Wolfram|Alpha Notebook Edition
    • Application Server
    • Enterprise Private Cloud
    • Wolfram Engine
    • Wolfram Player
    • Wolfram Cloud App
    • Wolfram Player App

    More mobile apps

    • Wolfram|Alpha
      • Wolfram|Alpha Website
      • Wolfram|Alpha APIs
    • AI Products
      • Wolfram AI Ecosystem
      • Wolfram Foundation Tool
      • Wolfram Cloud MCP
      • Wolfram Local MCP
      • Agent One API
      • CAG Component APIs
    • Core Technologies
      • Wolfram Language
      • Computable Data
      • Wolfram Notebooks
      • Linguistic Understanding
    • Additional Deployment Options
      • Wolfram Cloud
      • Wolfram Web Engine
      • wolframscript
      • WSTPServer
    • Group & Organizational Licensing
    • All Products
  • Consulting & Solutions
    • Wolfram Consulting

    Data Science, Finance & Business

    • Artificial Intelligence
    • Data Science
    • Healthcare
    • Real Estate

    Engineering

    • Civil Engineering
    • Automotive Engineering
    • Sustainable Energy

    Science & Technology

    • AgTech
    • Biosciences
    • Environmental Science
    • Food Science
    • Quantum Computation
    • Social and Behavioral Sciences

    More Wolfram Solutions

    Technology for Education

    • Research Universities
    • Colleges & Teaching Universities
    • High Schools
    • Resources for Students

    Education Initiatives

    • Next-Gen EdTech
    • Computer-Based Math

    More Solutions for Education

    • Contact Us
  • Learning & Support

    Get Started

    • Wolfram Language Introduction
    • Fast Intro for Programmers
    • Fast Intro for Math Students
    • Wolfram Language Documentation

    Grow Your Skills

    • Wolfram U

      Courses in computing, science, life and more

    • Community

      Learn, solve problems and share ideas.

    • Blog

      News, views and insights from Wolfram

    • Resources for

      Software Developers
    • Tech Support
      • Contact Us
      • Support FAQs
    • More Learning
      • Highlighted Core Areas
      • Demonstrations
      • YouTube
      • Daily Study Groups
      • Wolfram Schools and Programs
      • Books
    • Support FAQs
    • Contact Us
  • Company
    • About Wolfram
    • Career Center
    • All Sites & Resources
    • Connect & Follow
    • Contact Us

    Work with Us

    • Student Ambassador Initiative
    • Wolfram for Startups
    • Student Opportunities
    • Jobs Using Wolfram Language

    Educational Programs for Adults

    • Summer School
    • Winter School

    Educational Programs for Youth

    • Middle School Camp
    • High School Research Program
    • Computational Adventures

    Read

    • Stephen Wolfram's Writings
    • Wolfram Blog
    • Wolfram Tech | Books
    • Wolfram Media
    • Complex Systems
    • Educational Resources
      • Wolfram MathWorld
      • Wolfram in STEM
      • Wolfram Challenges
      • Wolfram Problem Generator
    • Wolfram Initiatives
      • Wolfram Science
      • Wolfram Foundation
      • History of Mathematics Project
    • Events
      • Stephen Wolfram Livestreams
      • Online & In-Person Events
    • Contact Us
    • Connect & Follow
  • For AIs
  • Wolfram Cloud
  • Your Account
  • User Portal
Wolfram Language & System Documentation Center
ItoProcess
  • See Also
    • WienerProcess
    • OrnsteinUhlenbeckProcess
    • GeometricBrownianMotionProcess
    • StratonovichProcess
    • TransformedProcess
    • AffineStateSpaceModel
  • Related Guides
    • Stochastic Differential Equation Processes
    • Financial Computation
    • Probability & Statistics
    • Random Processes
    • Finite Markov Processes
    • Scientific Models
    • See Also
      • WienerProcess
      • OrnsteinUhlenbeckProcess
      • GeometricBrownianMotionProcess
      • StratonovichProcess
      • TransformedProcess
      • AffineStateSpaceModel
    • Related Guides
      • Stochastic Differential Equation Processes
      • Financial Computation
      • Probability & Statistics
      • Random Processes
      • Finite Markov Processes
      • Scientific Models

ItoProcess[{a,b},x,t]

represents an Ito process , where .

ItoProcess[{a,b,c},x,t]

represents an Ito process , where .

ItoProcess[…,{x,x0},{t,t0}]

uses initial condition .

ItoProcess[…,…,…,Σ]

uses a Wiener process , with covariance Σ.

ItoProcess[proc]

converts proc to a standard Ito process whenever possible.

ItoProcess[sdeqns,expr,x,t,wdproc]

represents an Ito process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Basic Uses  
Process Properties Extraction  
Special Ito Processes  
Process Slice Properties  
Applications  
Computing Properties  
Martingales  
Modeling  
Ito Process Representations  
Properties & Relations  
Possible Issues  
See Also
Related Guides
History
Cite this Page
BUILT-IN SYMBOL
  • See Also
    • WienerProcess
    • OrnsteinUhlenbeckProcess
    • GeometricBrownianMotionProcess
    • StratonovichProcess
    • TransformedProcess
    • AffineStateSpaceModel
  • Related Guides
    • Stochastic Differential Equation Processes
    • Financial Computation
    • Probability & Statistics
    • Random Processes
    • Finite Markov Processes
    • Scientific Models
    • See Also
      • WienerProcess
      • OrnsteinUhlenbeckProcess
      • GeometricBrownianMotionProcess
      • StratonovichProcess
      • TransformedProcess
      • AffineStateSpaceModel
    • Related Guides
      • Stochastic Differential Equation Processes
      • Financial Computation
      • Probability & Statistics
      • Random Processes
      • Finite Markov Processes
      • Scientific Models

ItoProcess

ItoProcess[{a,b},x,t]

represents an Ito process , where .

ItoProcess[{a,b,c},x,t]

represents an Ito process , where .

ItoProcess[…,{x,x0},{t,t0}]

uses initial condition .

ItoProcess[…,…,…,Σ]

uses a Wiener process , with covariance Σ.

ItoProcess[proc]

converts proc to a standard Ito process whenever possible.

ItoProcess[sdeqns,expr,x,t,wdproc]

represents an Ito process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc.

Details and Options

  • ItoProcess is also known as Ito diffusion or stochastic differential equation (SDE).
  • ItoProcess is a continuous-time and continuous-state random process.
  • If the drift a is an -dimensional vector and the diffusion b an ×-dimensional matrix, the process is -dimensional and driven by an -dimensional WienerProcess.
  • Common specifications for coefficients a and b include:
  • a scalar, b scalar
    a scalar, b vector
    a vector, b vector
    a vector, b matrix
  • A stochastic differential equation is sometimes written as an integral equation .
  • The default initial time t0 is taken to be zero, and the default initial state x0 is zero.
  • The default covariance Σ is the identity matrix.
  • For a general covariance Σ, ItoProcess canonicalizes the process by converting the diffusion matrix b to b.Σ1/2, with Σ1/2 the lower Cholesky factor of Σ when possible. »
  • A standard Ito process has output , consisting of a subset of differential states .
  • Processes proc that can be converted to standard ItoProcess form include OrnsteinUhlenbeckProcess, GeometricBrownianMotionProcess, StratonovichProcess, and ItoProcess.
  • Converting an ItoProcess to standard form automatically makes use of Ito's lemma.
  • The stochastic differential equations in sdeqns can be of the form , where is \[DifferentialD], which can be input using dd. The differentials and are taken to be Ito differentials.
  • The output expression expr can be any expression involving x[t] and t.
  • The driving process dproc can be any process that can be converted to a standard Ito process.
  • Properties related to ItoProcess include:
  • "Drift"drift term
    "Diffusion"diffusion matrix
    "Output"output state
    "TimeVariable"time variable
    "TimeOrigin"origin of time variable
    "StateVariables"state variables
    "InitialState"initial state values
    "KolmogorovForwardEquation"Kolmogorov forward equation (Fokker-Planck equation)
    "KolmogorovBackwardEquation"Kolmogorov backward equation
    "Derivative"Ito derivative
    "FeynmanKacFormula"PDE obtained from Feynman-Kac formula
  • Method settings in RandomFunction specific to ItoProcess include: »
  • "EulerMaruyama"Euler–Maruyama (order 1/2, default)
    "KloedenPlatenSchurz"Kloeden–Platen–Schurz (order 3/2)
    "Milstein"Milstein (order 1)
    "StochasticRungeKutta"3‐stage Rossler SRK scheme (order 1)
    "StochasticRungeKuttaScalarNoise"3‐stage Rossler SRK scheme for scalar noise (order 3/2)
  • ItoProcess can be used with such functions as RandomFunction, CovarianceFunction, PDF, and Expectation.

Examples

open all close all

Basic Examples  (1)

Define a process by its stochastic differential equation:

Wolfram Language code: proc = ItoProcess[ⅆx[t] == -x[t]ⅆt + Sqrt[1 + x[t] ^ 2]ⅆw[t], x[t], {x, 1}, t, wWienerProcess[]]

Simulate the process:

Wolfram Language code: RandomFunction[proc, {0., 5., 0.01}]
Wolfram Language code: ListLinePlot[%, Filling -> Axis]

Compute mean function:

Wolfram Language code: Mean[proc[t]]

Compute covariance function:

Wolfram Language code: CovarianceFunction[proc, s, t]
Wolfram Language code: Plot3D[%, {s, 0, 5}, {t, 0, 5}, ColorFunction -> "Rainbow"]

Scope  (19)

Basic Uses  (10)

Define a Wiener process with drift and diffusion from the stochastic differential equation (SDE) :

Wolfram Language code: ItoProcess[{μ, σ}, {x, 0}, t]

Directly convert from the parametric process:

Wolfram Language code: ItoProcess[WienerProcess[μ, σ]]

Define a process , where :

Wolfram Language code: ItoProcess[{μ, σ, c[x[t]]}, {x, 0}, t]

Use differential notation to define the same process:

Wolfram Language code: ItoProcess[ⅆx[t] == μ ⅆt + σ ⅆw[t], c[x[t]], {x, 0}, t, wWienerProcess[]]

Define a vector process with output :

Wolfram Language code: ItoProcess[{{v, -x}, {0, 1}, x}, {{x, v}, {x0, v0}}, {t, 0}]

Using differential notation:

Wolfram Language code: ItoProcess[{ⅆx[t] == v[t] ⅆt, ⅆv[t] == -x[t]ⅆt + ⅆw[t]}, x[t], {{x, v}, {x0, v0}}, t, wWienerProcess[]]

Define a vector process , where :

Wolfram Language code: ItoProcess[{μ, σ, {x, x ^ 2}}, {x, 0}, t]

Using differential notation:

Wolfram Language code: ItoProcess[ⅆx[t] == μⅆt + σ ⅆw[t], {x[t], x[t] ^ 2}, {x, 0}, t, wWienerProcess[]]

Define a vector process where :

Wolfram Language code: ItoProcess[{{y, -x}, {{1, 0}, {0, 1}}}, {{x, y}, {0, 0}}, t]

Using differential notation:

Wolfram Language code: ItoProcess[{ⅆx[t] == y[t]ⅆt + ⅆw1[t], ⅆy[t] == -x[t]ⅆt + ⅆw2[t]}, {x[t], y[t]}, {{x, y}, {0, 0}}, t, {w1WienerProcess[], w2WienerProcess[]}]

Define a process driven by two correlated Wiener processes:

Wolfram Language code: Σ = {{1, 3 / 5}, {3 / 5, 1}};
Wolfram Language code: b = {{Subscript[σ, 1], Subscript[σ, 2]}}; proc = ItoProcess[{{1 - x[t]}, b, x[t]}, {{x}, {1 / 2}}, {t, 0}, Σ]

The canonicalized process has diffusion matrix equal to , with the diffusion matrix before canonicalization:

Wolfram Language code: bnew = proc[[1, 2]]
Wolfram Language code: bnew == b.CholeskyDecomposition[Σ]

Define a scalar process corresponding to the SDE :

Wolfram Language code: ItoProcess[ⅆx[t] == Subscript[w, 1][t]ⅆSubscript[w, 2][t], x[t], {x, 0}, t, {Subscript[w, 1]WienerProcess[], Subscript[w, 2]WienerProcess[]}]

Define vector process and corresponding to the SDE and :

Wolfram Language code: ItoProcess[{ⅆx[t] == Subscript[w, 1][t]ⅆSubscript[w, 2][t], ⅆy[t] == Subscript[w, 1][t]ⅆSubscript[w, 1][t]}, {x[t], y[t]}, {{x, y}, {0, 0}}, t, {Subscript[w, 1]WienerProcess[], Subscript[w, 2]WienerProcess[]}]

Define a process corresponding to the 2D correlated Wiener process:

Wolfram Language code: noise𝒫[σ1_, σ2_, ρ_] = Refine[ItoProcess[{{0, 0}, {{σ1, 0}, {0, σ2}}}, {{w1, w2}, {0, 0}}, t, {{1, ρ}, {ρ, 1}}], -1 < ρ < 1];

Define vector process driven by correlated 2D Wiener process:

Wolfram Language code: ItoProcess[{ⅆs[t] == μ s[t]ⅆt + Sqrt[r[t]]s[t]ⅆn1[t], ⅆr[t] == θ(μ - r[t])ⅆt + Sqrt[r[t]]ⅆn2[t] }, {s[t], r[t]}, {{s, r}, {s0, r0}}, t, {n1, n2}noise𝒫[Subscript[σ, 1], Subscript[σ, 2], ρ]]

Simulate ItoProcess paths using different methods:

Wolfram Language code: proc = ItoProcess[{ⅆx[t] == v[t]ⅆt, ⅆv[t] == -x[t]ⅆt + ⅆn[t]}, x[t], {{x, v}, {1, 0}}, t, nWienerProcess[]]

Simulation methods and their corresponding orders:

Wolfram Language code: methods = {"EulerMaruyama", "Milstein", "StochasticRungeKutta", "KloedenPlatenSchurz", "StochasticRungeKuttaScalarNoise"};
Wolfram Language code: orders = {"order 1/2", "order 1", "order 1", "order 3/2", "order 3/2"};

Specify the simulation method as an option in RandomFunction:

Wolfram Language code: paths = Table[RandomFunction[proc, {0., 2. Pi, 0.05}, 6, Method -> m], {m, methods}];
Wolfram Language code: Grid[Partition[MapThread[ListLinePlot[#1, PlotLabel -> Column[{#2, #3}], ImageSize -> 160]& , {paths, methods, orders}], UpTo[3]], Spacings -> 2]

Process Properties Extraction  (2)

Define an Ito process by its stochastic differential equation:

Wolfram Language code: proc = ItoProcess[ⅆx[t] == (μ - x[t])ⅆt + Sqrt[1 + x[t] ^ 2]ⅆw[t], x[t], {x, 1}, t, wWienerProcess[]]

Available Ito process properties:

Wolfram Language code: proc["Properties"]

Drift and diffusion of the process:

Wolfram Language code: proc /@ {"Drift", "Diffusion"}

Kolmogorov forward equation:

Wolfram Language code: proc["KolmogorovForwardEquation"]//TraditionalForm

Inactive is used here to avoid expanding the partial derivatives; use Activate to expand the expression:

Wolfram Language code: Activate[%]//TraditionalForm

Kolmogorov backward equation:

Wolfram Language code: proc["KolmogorovBackwardEquation"]//TraditionalForm

Compute the Ito derivative of a function . The output is a list consisting of drift and diffusion terms:

Wolfram Language code: {mu, sig} = proc["Derivative", f[x[t], t]];
Wolfram Language code: TraditionalForm[mu]
Wolfram Language code: TraditionalForm[sig]

The property "FeynmanKacFormula" gives a PDE whose solution satisfies the conditional expectation and terminal condition :

Wolfram Language code: proc["FeynmanKacFormula"]//TraditionalForm

Additional arguments can be provided for the generalized situations. With an additional argument , the property "FeynmanKacFormula" gives a PDE whose solution satisfies the conditional expectation and the same terminal condition:

Wolfram Language code: proc["FeynmanKacFormula", α[x, t]]//TraditionalForm

With a third argument , the property "FeynmanKacFormula" gives a PDE whose solution satisfies the conditional expectation and the same terminal condition:

Wolfram Language code: proc["FeynmanKacFormula", α[x, t], β[x, t]]//TraditionalForm

Define Heston model with ItoProcess:

Wolfram Language code: heston = ItoProcess[{{μ S[t], κ(θ - ν[t])}, {{ν[t]^1 / 2S[t], 0}, {0, σ ν[t]^1 / 2}}}, {{S, ν}, {Subscript[S, 0], Subscript[ν, 0]}}, t, {{1, 1 / 2}, {1 / 2, 1}}]

Drift:

Wolfram Language code: heston["Drift"]

Diffusion matrix (after canonicalization):

Wolfram Language code: heston["Diffusion"]

Kolmogorov forward equation:

Wolfram Language code: heston["KolmogorovForwardEquation"]//TraditionalForm

Kolmogorov backward equation:

Wolfram Language code: heston["KolmogorovBackwardEquation"]//TraditionalForm

Ito derivative formula:

Wolfram Language code: {mu, sig} = heston["Derivative", f[S[t], ν[t], t]];
Wolfram Language code: mu//TraditionalForm
Wolfram Language code: sig//TraditionalForm

Special Ito Processes  (5)

An Ito process corresponding to the WienerProcess:

Wolfram Language code: ItoProcess[WienerProcess[μ, σ]]

An Ito process corresponding to the GeometricBrownianMotionProcess:

Wolfram Language code: ItoProcess[GeometricBrownianMotionProcess[μ, σ, x0]]

An Ito process corresponding to the BrownianBridgeProcess:

Wolfram Language code: ItoProcess[BrownianBridgeProcess[σ, {Subscript[t, 1], a}, {Subscript[t, 2], b}]]

An Ito process corresponding to the OrnsteinUhlenbeckProcess:

Wolfram Language code: ItoProcess[OrnsteinUhlenbeckProcess[μ, σ, θ, x0]]

An Ito process corresponding to the CoxIngersollRossProcess:

Wolfram Language code: ItoProcess[CoxIngersollRossProcess[μ, σ, θ, x0]]

Process Slice Properties  (2)

Define Jacobi diffusion process:

Wolfram Language code: Jacobi𝒫[x0_] := ItoProcess[ⅆx[t] == (1 / 2 - x[t])ⅆt + Sqrt[x[t](1 - x[t])]ⅆw[t], x[t], {x, x0}, t, wWienerProcess[]]

Compute low-order cumulants of time‐slice distribution:

Wolfram Language code: Table[Cumulant[Jacobi𝒫[x0][t], r], {r, 1, 4}]

Find the limit of infinite time horizon:

Wolfram Language code: Limit[%, t -> ∞]

Compare with cumulants of the uniform distribution:

Wolfram Language code: Table[Cumulant[UniformDistribution[], r], {r, 1, 4}]

Define a vector process given by a system of linear SDEs:

Wolfram Language code: proc[{σ1_, σ2_}, {x0_, y0_}] = ItoProcess[ⅆx[t] == -(x[t] + y[t])ⅆt + σ1 ⅆw[t] && ⅆy[t] == -2x[t]ⅆt + σ2ⅆw[t], {x[t], y[t]}, {{x, y}, {x0, y0}}, t, wWienerProcess[]]

Find the probability density function of the time‐slice distribution:

Wolfram Language code: PDF[proc[{1, -1}, {1 / 2, -1 / 4}][t], {x, y}]

Compute cross‐covariance of and :

Wolfram Language code: cov = Covariance[proc[{Subscript[σ, 1], Subscript[σ, 2]}, {x0, y0}][t], 1, 2]

Infinite time horizon limit exists only if :

Wolfram Language code: Collect[cov, E ^ _, Simplify]

Applications  (11)

Computing Properties  (3)

Compute cross-covariance of the Ornstein–Uhlenbeck process and its underlying Wiener process :

Wolfram Language code: joint𝒫 = ItoProcess[ⅆx[t] == θ(μ - x[t])ⅆt + σ ⅆw[t], {x[t], w[t]}, {x, x0}, t, wWienerProcess[]]
Wolfram Language code: Covariance[joint𝒫[t], 1, 2]

Compute moments of the process , where is the standard Wiener process:

Wolfram Language code: ItoProcess[ⅆx[t] == w[t] ^ 2ⅆt, x[t], {x, 0}, t, wWienerProcess[]]
Wolfram Language code: Table[Moment[%[t], r], {r, 0, 8}]

Vector Ito process driven by scalar noise (1D oscillator driven by white noise):

Wolfram Language code: proc = ItoProcess[{ⅆx[t] == v[t]ⅆt, ⅆv[t] == -x[t]ⅆt + ⅆn[t]}, x[t], {{x, v}, {1, 0}}, t, nWienerProcess[]]

Simulate process paths:

Wolfram Language code: path = RandomFunction[proc, {0., 2. Pi, 0.05}, 12, Method -> "StochasticRungeKutta"];
Wolfram Language code: ListLinePlot[path]

Compute mean and variance functions:

Wolfram Language code: mf[t_] = Mean[proc[t]]
Wolfram Language code: vf[t_] = Simplify[Variance[proc[t]]]

Plot mean function and the standard deviation band, together with generated paths:

Wolfram Language code: Show[Plot[{mf[t] - Sqrt[vf[t]], mf[t] + Sqrt[vf[t]], mf[t]}, {t, 0, 2Pi}, Filling -> {1 -> {2}}], ListLinePlot[path], PlotRange -> All]

Martingales  (3)

Determine values of and for which the process is a martingale, where is the standard Wiener process:

Wolfram Language code: x𝒫 = ItoProcess[{0, 1, Exp[α w[t] + β t]}, {w, 0}, t]

Convert to the standard form:

Wolfram Language code: st𝒫 = ItoProcess[x𝒫]

Zero drift coefficient of the standard form is a necessary condition for to be a martingale:

Wolfram Language code: Reduce[st𝒫[[1, 1]] == 0, {α, β}]

Scalar Ito process driven by vector Wiener process:

Wolfram Language code: ItoProcess[{0, {1, 1, 1}}, {x, 0}, {t, 0}]

Define the same process via a stochastic equation:

Wolfram Language code: ItoProcess[ⅆx[t] == ⅆw1[t] + ⅆw2[t] + ⅆw3[t], x[t], {x, 0}, t, {w1WienerProcess[], w2WienerProcess[], w3WienerProcess[]}]

Construct a scalar process driven by two Wiener processes:

Wolfram Language code: proc1 = ItoProcess[ⅆx[t] == (w1[t]/Sqrt[w1[t]^2 + w2[t]^2])ⅆw1[t] + (w2[t]/Sqrt[w1[t]^2 + w2[t]^2])ⅆw2[t], x[t], {x, x0}, t, {w1WienerProcess[], w2WienerProcess[]}]

Quadratic variation of :

Wolfram Language code: Integrate[Simplify[#.#&[proc1["Derivative", x[t]][[2, 1]]]], {t, 0, t}]

By Lévy characterization, is a Brownian motion. The mean of the process is the same as the initial state:

Wolfram Language code: Mean[proc1[t]]

Modeling  (2)

The dynamics of a free particle under the effect of thermal fluctuation can be modeled by the Langevin equation of motion, , where is the standard WienerProcess and is the strength of the thermal noise. Here it is assumed that can only depend on and focus on the equation of velocity. There are two common ways to integrate the equation of motion: Ito formulation and Stratonovich formulation. They can be defined via:

Wolfram Language code: ito = ItoProcess[ⅆv[t] == -v[t]ⅆt + σ[v[t]]ⅆb[t], v[t], {v, vi}, t, bWienerProcess[]];
Wolfram Language code: str = StratonovichProcess[ⅆv[t] == -v[t]ⅆt + σ[v[t]]ⅆb[t], v[t], {v, vs}, t, bWienerProcess[]];

When is a constant, the two formulations are identical and lead to the same stationary distribution as :

Wolfram Language code: Limit[PDF[ito[t] /. {σ[v[t]] -> Sqrt[2]σ1}, v]//Simplify, t -> Infinity]
Wolfram Language code: Limit[PDF[str[t] /. {σ[v[t]] -> Sqrt[2]σ1}, v]//Simplify, t -> Infinity]

If is velocity dependent, then due to the nature of the WienerProcess, has nonzero quadratic variation and the two formulations lead to different results. Convert Stratonovich formulation to the equivalent Ito formulation:

Wolfram Language code: istr = ItoProcess[str]

The drift under Stratonovich formulation is different from the drift under Ito formulation:

Wolfram Language code: ito["Drift"]
Wolfram Language code: istr["Drift"]

The Gompertz curve is typically used in the modeling of a growth process, such as tumor growth. By assuming Gaussian noise in the logarithm of the growth process, you can write the model as a stochastic differential equation:

Wolfram Language code: proc = ItoProcess[ⅆX[t] == -α Exp[-α t]Log[X0 / K]X[t]ⅆt + σ X[t]ⅆW[t], X[t], {X, X0}, t, WWienerProcess[]]

Mean of the process is the usual Gompertz curve:

Wolfram Language code: Mean[proc[t]]

Slice distribution of the process at time obeys LogNormalDistribution:

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

Simulate the process with , and from to :

Wolfram Language code: proc1 = proc /. {X0 -> 1, K -> 2, σ -> 0.1, α -> 0.3};
Wolfram Language code: sample = RandomFunction[proc1, {0, 10, 0.01}];

Visualize the sampled path:

Wolfram Language code: ListLinePlot[sample, Filling -> Axis]

Generate a thousand samples with the same conditions, then visualize the paths and slice data at :

Wolfram Language code: samples = RandomFunction[proc1, {0, 10, 0.1}, 1000];
Wolfram Language code: GraphicsRow[{ListLinePlot[samples, ImageSize -> 250, PlotRange -> All, AspectRatio -> 3 / 4, BaseStyle -> Directive[Thin, Opacity[0.5]], PlotRangePadding -> {{0, .25}, {.5, .5}}], Histogram[samples["SliceData", 10], Automatic, "PDF"]}]

Ito Process Representations  (3)

Use ItoProcess to represent the standard WienerProcess:

Wolfram Language code: wiener = ItoProcess[ⅆB[t] == ⅆw[t], B[t], {B, 0}, t, wWienerProcess[]]

is a martingale. Use Ito lemma to compute the derivative of :

Wolfram Language code: M = Exp[t / 2]Sin[B[t]]; {drift, diffusion} = wiener["Derivative", M]

Create a CoxIngersollRossProcess and represent it with ItoProcess:

Wolfram Language code: cir = CoxIngersollRossProcess[5, 1, 1 / 2, 10]; proc = ItoProcess[cir]

Obtain Kolmogorov forward equation:

Wolfram Language code: forward = Activate[proc["KolmogorovForwardEquation"]] /. { -> x,  -> t,  -> p}

Solve the equation numerically in with a localized initial condition at and Dirichlet boundary conditions:

Wolfram Language code: f[x_] = Exp[-100 (x - 10) ^ 2]Sqrt[200 / (2Pi)]; Plot[f[x], {x, 0, 30}, PlotRange -> All]//Quiet
Wolfram Language code: sol = p /. First[NDSolve[{forward, p[0, t] == p[30, t] == 0, p[x, 0] == f[x]}, p, {x, 0, 30}, {t, 0, 1}, Method -> {"MethodOfLines", "SpatialDiscretization" -> {"TensorProductGrid", "DifferenceOrder" -> "Pseudospectral"}}]]

Plot the solution of Kolmogorov forward equation at and compare it with the closed-form density function:

Wolfram Language code: Plot[{sol[x, 1], PDF[cir[1], x]}, {x, 0, 30}, PlotRange -> All]

Visualize the dynamic of the solution with Animate:

Wolfram Language code: Animate[Plot[sol[x, t], {x, 0, 30}, PlotRange -> {0, 0.3}], {t, 0, 1}, AnimationRunning -> False, TrackedSymbols :> t, SaveDefinitions -> True]

Represent a GeometricBrownianMotionProcess with ItoProcess, where represents the risk-free interest rate and is the volatility:

Wolfram Language code: proc = ItoProcess[GeometricBrownianMotionProcess[r, σ, x0]] /. { -> x,  -> t}

Compute Ito differential for a discounted process :

Wolfram Language code: {drift, diffusion} = proc["Derivative", Exp[-r t]V[x[t], t]]

The classical Black–Scholes equation can be obtained by equating the drift to 0 with some simplifications:

Wolfram Language code: (First[drift]Exp[r t] /. {x[t] -> x}//Simplify) == 0

The equation can be also obtained directly from the Feynman–Kac formula:

Wolfram Language code: bs = proc["FeynmanKacFormula", r] /. { -> V}

Solve the Black–Scholes equation symbolically with DSolve:

Wolfram Language code: DSolve[{bs, V[x, T] == H[x]}, V[x, t], {x, t}]

Properties & Relations  (2)

Convert StratonovichProcess to ItoProcess:

Wolfram Language code: StratonovichProcess[ⅆx[t] == a[t, x[t]]ⅆt + b[t, x[t]]ⅆw[t], x[t], {x, x0}, t, wWienerProcess[]]
Wolfram Language code: ItoProcess[%]

Convert back:

Wolfram Language code: StratonovichProcess[%]

Transformed Wiener processes are related to ItoProcess:

Wolfram Language code: 𝒫1 = TransformedProcess[b[t] ^ 2, bWienerProcess[], t]; 𝒫2 = ItoProcess[{0, 1, b[t] ^ 2}, b, t];

Mean and variance functions agree:

Wolfram Language code: {Mean[𝒫1[t]] == Mean[𝒫2[t]], Variance[𝒫1[t]] == Variance[𝒫2[t]]}

Possible Issues  (2)

ItoProcess does not support random initial conditions, so cannot be represented:

Wolfram Language code: ItoProcess[OrnsteinUhlenbeckProcess[μ, σ, θ]]
Wolfram Language code: ItoProcess[ⅆx[t] == aⅆt + b x[t]ⅆy[t], x[t], {x, x0}, t, yOrnsteinUhlenbeckProcess[μ, σ, θ]]

But it supports processes with fixed initial condition:

Wolfram Language code: ItoProcess[OrnsteinUhlenbeckProcess[μ, σ, θ, Subscript[x, 0]]]
Wolfram Language code: ItoProcess[ⅆx[t] == aⅆt + b x[t]ⅆy[t], x[t], {x, x0}, t, yOrnsteinUhlenbeckProcess[μ, σ, θ, x0]]

Initial time of the driven process needs to match with ItoProcess:

Wolfram Language code: ItoProcess[ⅆx[t] == -x[t] ⅆt + ⅆw[t], x[t], {x, 1}, {t, 3}, wOrnsteinUhlenbeckProcess[0, 1, 1, 1]]//ProcessParameterQ

With matching initial time, this can be represented:

Wolfram Language code: ItoProcess[ⅆx[t] == -x[t] ⅆt + ⅆw[t], x[t], {x, 1}, {t, 0}, wOrnsteinUhlenbeckProcess[0, 1, 1, 1]]//ProcessParameterQ

See Also

WienerProcess  OrnsteinUhlenbeckProcess  GeometricBrownianMotionProcess  StratonovichProcess  TransformedProcess  AffineStateSpaceModel

Related Guides

    ▪
  • Stochastic Differential Equation Processes
  • ▪
  • Financial Computation
  • ▪
  • Probability & Statistics
  • ▪
  • Random Processes
  • ▪
  • Finite Markov Processes
  • ▪
  • Scientific Models

History

Introduced in 2012 (9.0) | Updated in 2016 (11.0)

Wolfram Research (2012), ItoProcess, Wolfram Language function, https://reference.wolfram.com/language/ref/ItoProcess.html (updated 2016).

Text

Wolfram Research (2012), ItoProcess, Wolfram Language function, https://reference.wolfram.com/language/ref/ItoProcess.html (updated 2016).

CMS

Wolfram Language. 2012. "ItoProcess." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2016. https://reference.wolfram.com/language/ref/ItoProcess.html.

APA

Wolfram Language. (2012). ItoProcess. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ItoProcess.html

BibTeX

@misc{reference.wolfram_2026_itoprocess, author="Wolfram Research", title="{ItoProcess}", year="2016", howpublished="\url{https://reference.wolfram.com/language/ref/ItoProcess.html}", note=[Accessed: 01-September-2026]}

BibLaTeX

@online{reference.wolfram_2026_itoprocess, organization={Wolfram Research}, title={ItoProcess}, year={2016}, url={https://reference.wolfram.com/language/ref/ItoProcess.html}, note=[Accessed: 01-September-2026]}

Top
Introduction for Programmers
Introductory Book
Wolfram Function Repository | Wolfram Data Repository | Wolfram Data Drop | Wolfram Language Products
Top
  • Products
  • Wolfram|One
  • Mathematica
  • AI Access
  • Compute Services
  • System Modeler

  • Wolfram|Alpha Notebook Edition
  • Wolfram|Alpha Pro
  • Mobile Apps

  • Wolfram Engine
  • Wolfram Player

  • Volume & Site Licensing
  • Server Deployment Options
  • Consulting
  • Wolfram Consulting
  • Repositories
  • Data Repository
  • Function Repository
  • Community Paclet Repository
  • Neural Net Repository
  • Prompt Repository

  • Wolfram Language Example Repository
  • Notebook Archive
  • Wolfram GitHub
  • Learning
  • Wolfram U
  • Wolfram Language Documentation
  • Webinars & Training
  • Educational Programs

  • Wolfram Language Introduction
  • Fast Introduction for Programmers
  • Fast Introduction for Math Students
  • Books

  • Wolfram Community
  • Wolfram Blog
  • Public Resources
  • Wolfram|Alpha
  • Wolfram Problem Generator
  • Wolfram Challenges

  • Computer-Based Math
  • Computational Thinking
  • Computational Adventures

  • Demonstrations Project
  • Wolfram Data Drop
  • MathWorld
  • Wolfram Science
  • Wolfram Media Publishing
  • Customer Resources
  • Store
  • Product Downloads
  • User Portal
  • Your Account
  • Organization Access

  • Support FAQ
  • Contact Support
  • Company
  • About Wolfram
  • Careers
  • Contact
  • Events
Wolfram Community Wolfram Blog
Legal & Privacy Policy
WolframAlpha.com | WolframCloud.com
© 2026 Wolfram
© 2026 Wolfram | Legal & Privacy Policy |
English