WOLFRAM

Wolfram Language & System Documentation Center

LegendreQ[n,z]

gives the Legendre function of the second kind TemplateBox[{n, z}, LegendreQ].

LegendreQ[n,m,z]

gives the associated Legendre function of the second kind TemplateBox[{n, m, z}, LegendreQ3].

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Numerical Evaluation  
Specific Values  
Visualization  
Show More Show More
Function Properties  
Differentiation  
Integration  
Series Expansions  
Function Identities and Simplifications  
Function Representations  
Generalizations & Extensions  
Applications  
Properties & Relations  
See Also
Tech Notes
Related Guides
Related Links
History
Cite this Page

LegendreQ

LegendreQ[n,z]

gives the Legendre function of the second kind TemplateBox[{n, z}, LegendreQ].

LegendreQ[n,m,z]

gives the associated Legendre function of the second kind TemplateBox[{n, m, z}, LegendreQ3].

Details

  • Mathematical function, suitable for both symbolic and numerical manipulation.
  • For integers n and m, explicit formulas are generated.
  • The Legendre functions satisfy the differential equation .
  • LegendreQ[n,m,a,z] gives Legendre functions of type a. The default is type 1.
  • LegendreQ of types 1, 2 and 3 are defined in terms of LegendreP of these types, and have the same branch cut structure and properties described for LegendreP.
  • For certain special arguments, LegendreQ automatically evaluates to exact values.
  • LegendreQ can be evaluated to arbitrary numerical precision.
  • LegendreQ automatically threads over lists.
  • LegendreQ can be used with Interval and CenteredInterval objects. »

Examples

open all close all

Basic Examples  (6)

Evaluate numerically:

Wolfram Language code: LegendreQ[1 / 3, 0.5]

Compute the 5^(th) Legendre function of the second kind:

Wolfram Language code: LegendreQ[5, x]

Plot over a subset of the reals:

Wolfram Language code: Plot[ LegendreQ[1 / 5, x], {x, -1, 1}]

Plot over a subset of the complexes:

Wolfram Language code: ComplexPlot3D[LegendreQ[1 / 2, z], {z, -2 - 2I, 2 + 2I}, PlotLegends -> Automatic]

Series expansion at the origin:

Wolfram Language code: Series[LegendreQ[1 / 2, x], {x, 0, 2}]

Asymptotic expansion at Infinity:

Wolfram Language code: Series[LegendreQ[1 / 2, x], {x, ∞, 3}]//Normal//FullSimplify

Scope  (42)

Numerical Evaluation  (6)

Evaluate numerically at fixed points:

Wolfram Language code: {LegendreQ[2, 0.5], LegendreQ[2, 2, 0.5], LegendreQ[1 / 2, 0.5]}

Evaluate to high precision:

Wolfram Language code: N[LegendreQ[3 / 2, 1 / 2], 50]

The precision of the output tracks the precision of the input:

Wolfram Language code: LegendreQ[3 / 2, 0.5000000000000000000000000000]

Evaluate for complex arguments:

Wolfram Language code: LegendreQ[1 - I, 2 + I, 0.5]

Evaluate LegendreQ efficiently at high precision:

Wolfram Language code: LegendreQ[3 / 2, 0.5`300]//Timing
Wolfram Language code: LegendreQ[3 / 2, 0.5`1000];//Timing

Compute worst-case guaranteed intervals using Interval and CenteredInterval objects:

Wolfram Language code: LegendreQ[1 / 2, 2 / 3, Interval[{0.4, 0.5}]]
Wolfram Language code: LegendreQ[1 / 2, CenteredInterval[2, 1 / 100]]
Wolfram Language code: LegendreQ[1 / 2, 2 / 3, CenteredInterval[3 / 4, 1 / 100]]

Or compute average-case statistical intervals using Around:

Wolfram Language code: LegendreQ[2, Around[1 / 3, 0.5]]

Compute the elementwise values of an array:

Wolfram Language code: LegendreQ[1, {{5 / 6, 0}, {1 / 2, -1 / 3}}]

Or compute the matrix LegendreQ function using MatrixFunction:

Wolfram Language code: MatrixFunction[LegendreQ[2, #]&, {{5 / 6, 0}, {1 / 2, -1 / 3}}]

Specific Values  (5)

Legendre function for :

Wolfram Language code: LegendreQ[n, 0]//FunctionExpand

Legendre function for fixed :

Wolfram Language code: LegendreQ[0, x]

Find a local maximum as a root of (dTemplateBox[{5, x}, LegendreP])/(dx)=0:

Wolfram Language code: xmax = NSolve[D[LegendreQ[5, x], x] == 0 && 0.2 < x < 0.7, x][[1, 1, 2]]
Wolfram Language code: Plot[LegendreQ[5, x], {x, -1, 1}, Epilog -> Style[Point[{xmax, LegendreQ[5, xmax]}], PointSize[Large], Red]]

Compute the associated Legendre function of the second kind TemplateBox[{3, 1, x}, LegendreQ3]:

Wolfram Language code: LegendreQ[3, 1, x]//FullSimplify

Different LegendreQ types give different symbolic forms:

Wolfram Language code: Table[LegendreQ[1, 1, a, z], {a, 1, 3}]//FunctionExpand//FullSimplify

Visualization  (3)

Plot the LegendreQ function for various degrees:

Wolfram Language code: Plot[{LegendreQ[1, x], LegendreQ[2, x], LegendreQ[3, x], LegendreQ[4, x]}, {x, -1, 1}]

Plot the real part of TemplateBox[{4, z}, LegendreQ]:

Wolfram Language code: ComplexContourPlot[Re[LegendreQ[4, z]], {z, -1 - I, 1 + I}, IconizedObject[«PlotOptions»]]

Plot the imaginary part of TemplateBox[{4, z}, LegendreQ]:

Wolfram Language code: ComplexContourPlot[Im[LegendreQ[4, z]], {z, -1 - I, 1 + I}, IconizedObject[«PlotOptions»]]

Type 2 and 3 Legendre functions have different branch cut structures:

Wolfram Language code: Plot3D[Im[LegendreQ[1, 1, 2, x - I y]], {x, -1.5, 1.5}, {y, -1.5, 1.5}, Exclusions -> {{y == 0, Abs[x] > 1}}]
Wolfram Language code: Plot3D[Im[LegendreQ[1, 1, 3, x - I y]], {x, -1.5, 1.5}, {y, -1.5, 1.5}, Exclusions -> {{y == 0, Abs[x] < 1}}]

Function Properties  (12)

TemplateBox[{m, z}, LegendreQ] is defined for as long as is not a negative integer:

Wolfram Language code: FunctionDomain[LegendreQ[m, z], z]

In the complex plane, it is defined for as long as is not a negative integer:

Wolfram Language code: FunctionDomain[LegendreQ[m, z], z, Complexes]

The range for Legendre functions of integer order:

Wolfram Language code: {FunctionRange[LegendreQ[1, x], x, y], FunctionRange[LegendreQ[2, x], x, y]}

A Legendre function of an odd order is even:

Wolfram Language code: LegendreQ[3, -x] == LegendreQ[3, x]//Simplify

A Legendre function of an even order is odd:

Wolfram Language code: LegendreQ[4, -x] == -LegendreQ[4, x]//Simplify

Legendre function has the mirror property TemplateBox[{n, TemplateBox[{z}, Conjugate, SyntaxForm -> SuperscriptBox]}, LegendreQ]=TemplateBox[{TemplateBox[{n, z}, LegendreQ]}, Conjugate]:

Wolfram Language code: FullSimplify[LegendreQ[2, Conjugate[z]] == Conjugate[LegendreQ[2, z]], -1 < z < 1]

LegendreQ is not an analytic function:

Wolfram Language code: FunctionAnalytic[LegendreQ[2, x], x]

Nor is it meromorphic:

Wolfram Language code: FunctionMeromorphic[LegendreQ[2, x], x]

TemplateBox[{m, x}, LegendreQ] is neither non-decreasing nor non-increasing in for positive integer :

Wolfram Language code: Table[FunctionMonotonicity[{LegendreQ[m, x], -1 < x < 1}, x], {m, 4}]

For and noninteger , it is increasing:

Wolfram Language code: Table[FunctionMonotonicity[{LegendreQ[m, x], -1 < x < 1}, x, StrictInequalities -> True], {m, {0, 1 / 2}}]

TemplateBox[{m, x}, LegendreQ] is not injective in for positive integer :

Wolfram Language code: Table[FunctionInjective[{LegendreQ[m, x], -1 < x < 1}, x], {m, 4}]

For and noninteger , it is injective:

Wolfram Language code: Table[FunctionInjective[{LegendreQ[m, x], -1 < x < 1}, x], {m, {0, 1 / 2}}]
Wolfram Language code: Plot[{LegendreQ[0, x], LegendreQ[1, x], LegendreQ[2, x], .5}, {x, -1, 1}]

TemplateBox[{m, x}, LegendreQ] is surjective in for non-negative even :

Wolfram Language code: Table[FunctionSurjective[{LegendreQ[m, x], -1 < x < 1}, x], {m, 0, 6, 2}]

It is not surjective for other values of :

Wolfram Language code: Table[FunctionSurjective[{LegendreQ[m, x], -1 < x < 1}, x], {m, {1 / 2, 1, 3 / 2, 3}}]
Wolfram Language code: Plot[{LegendreQ[0, x], LegendreQ[2, x], LegendreQ[1 / 2, x], LegendreQ[1, x], -3}, {x, -1, 1}, PlotRange -> 5]

LegendreQ is neither non-negative nor non-positive:

Wolfram Language code: FunctionSign[LegendreQ[2, x], x]

LegendreQ has both singularity and discontinuity in (-∞,-1] and [1,∞):

Wolfram Language code: FunctionSingularities[LegendreQ[2, x], x]
Wolfram Language code: FunctionDiscontinuities[LegendreQ[2, x], x]

TemplateBox[{m, x}, LegendreQ] is neither convex nor concave for most values of :

Wolfram Language code: Table[FunctionConvexity[{LegendreQ[m, x], -1 < x < 1}, x], {m, 5}]

Differentiation  (3)

First derivative:

Wolfram Language code: D[LegendreQ[n, x], x]

Higher derivatives:

Wolfram Language code: derivs = Table[D[LegendreQ[n, x], {x, l}], {l, 1, 4}]//FullSimplify

Plot higher derivatives for :

Wolfram Language code: Plot[Evaluate[derivs /. n -> 5], {x, -1, 1}, PlotRange -> {-110, 110}, PlotLegends -> {"First Derivative", "Second Derivative", "Third Derivative", "Fourth Derivative"}]

Formula for the ^(th) derivative:

Wolfram Language code: D[LegendreQ[n, x], {x, l}]

Integration  (3)

Indefinite integral of TemplateBox[{1, x}, LegendreQ]:

Wolfram Language code: Integrate[LegendreQ[1, x], x]//FullSimplify

Definite integral of the odd integrand TemplateBox[{2, x}, LegendreQ] over the interval centered at the origin is 0:

Wolfram Language code: Integrate[LegendreQ[2, x], {x, -1, 1}]

Definite integral of the even integrand TemplateBox[{3, x}, LegendreQ] over the interval centered at the origin:

Wolfram Language code: Integrate[LegendreQ[3, x], {x, -1, 1}]

This is twice the integral over half the interval:

Wolfram Language code: Integrate[LegendreQ[3, x], {x, 0, 1}]

Series Expansions  (4)

Taylor expansion for TemplateBox[{n, x}, LegendreQ]:

Wolfram Language code: Series[LegendreQ[n, x], {x, 0, 3}]//FullSimplify

Plot the first three approximations for TemplateBox[{6, x}, LegendreQ] at :

Wolfram Language code: terms = Normal@Table[Series[LegendreQ[6, x], {x, 0, m}], {m, 1, 5, 2}]; Plot[{LegendreQ[6, x], terms}, {x, -1, 1}, PlotRange -> {-2, 2}]

General term in the series expansion of TemplateBox[{n, x}, LegendreQ]:

Wolfram Language code: SeriesCoefficient[LegendreQ[n, x], {x, 0, l}]

Taylor expansion for the associated Legendre function TemplateBox[{n, m, x}, LegendreQ3]:

Wolfram Language code: Series[LegendreQ[n, m, x], {x, 0, 1}]//FullSimplify

LegendreQ can be applied to a power series:

Wolfram Language code: LegendreQ[0, Cos[x] + O[x] ^ 6]

Function Identities and Simplifications  (2)

Expand LegendreQ of integer or half-integer parameters into simpler functions:

Wolfram Language code: FunctionExpand[LegendreQ[3, 1, 3, x]]//FullSimplify
Wolfram Language code: FunctionExpand[LegendreQ[3 / 2, 1 / 2, 3, x]]//FullSimplify

Recurrence relation:

Wolfram Language code: (n + 1) LegendreQ[n, z] == (2 n + 3) z LegendreQ[n + 1, z] - (n + 2) LegendreQ[n + 2, z]//FullSimplify

Function Representations  (4)

LegendreQ can be expressed as a DifferentialRoot:

Wolfram Language code: DifferentialRootReduce[LegendreQ[n, x], x]

Associated Legendre function in terms of the angular spheroidal function:

Wolfram Language code: SpheroidalQS[n, m, 0, z]//FullSimplify

Associated Legendre function in terms of Legendre function of type :

Wolfram Language code: LegendreQ[n, m, z] == LegendreQ[n, m, 2, z]//FullSimplify

TraditionalForm formatting:

Wolfram Language code: LegendreQ[n, x]//TraditionalForm
Wolfram Language code: LegendreQ[n, m, x]//TraditionalForm

Generalizations & Extensions  (2)

Different LegendreQ types give different symbolic forms:

Wolfram Language code: LegendreQ[1, 1, 1, z]
Wolfram Language code: LegendreQ[1, 1, 2, z]//FunctionExpand
Wolfram Language code: LegendreQ[1, 1, 3, z]//FunctionExpand

Types 2 and 3 have different branch cut structures:

Wolfram Language code: Plot3D[Im[LegendreQ[1, 1, 2, x - I y]], {x, -1.5, 1.5}, {y, -1.5, 1.5}, Exclusions -> {{y == 0, Abs[x] > 1}}]
Wolfram Language code: Plot3D[Im[LegendreQ[1, 1, 3, x - I y]], {x, -1.5, 1.5}, {y, -1.5, 1.5}, Exclusions -> {{y == 0, Abs[x] < 1}}]

Applications  (4)

Angular momentum eigenfunctions:

Wolfram Language code: DSolve[Sin[θ] D[Sin[θ] f'[θ], θ] - m^2f[θ] == -λ(λ + 1)Sin[θ]^2f[θ], f[θ], θ]

Solve a recurrence equation:

Wolfram Language code: RSolve[ (n + m)f[n - 1] + (n - m + 1)f[n + 1] == (n + 1 / 2)f[n], f[n], n]

The Pöschl–Teller potential is a special class of potentials for which the one-dimensional Schrödinger equation can be solved in terms of special functions.

Find quantum eigenfunctions for the modified Pöschl–Teller potential:

Wolfram Language code: DSolve[-f''[x] - j(j + 1) / Cosh[x] ^ 2 f[x] == -n ^ 2 f[x], f[x], x]

An n-point Gaussian quadrature rule is based on the roots of the n^(th) order Legendre polynomial. Compute the nodes and weights of an n-point Gaussian quadrature rule:

Wolfram Language code: n = 5; lp[x_] = LegendreP[n, x]; gaussNodes = x /. NSolve[lp[x], x]
Wolfram Language code: w1 = x |-> (2/n LegendreP[n - 1, x]lp'[x]); gaussWeights = w1[gaussNodes]

Use the n-point Gaussian quadrature rule to numerically evaluate an integral:

Wolfram Language code: fun[x_] := (1/1 / 100  + (x - 3 / 10)^2) + (1/1 / 25  + (x - 9 / 10)^2) - 6
Wolfram Language code: a = 1 / 2;b = 1; est1 = ((b - a/2)gaussWeights).Map[fun, Rescale[gaussNodes, {-1, 1}, {a, b}]]

The Kronrod extension of a Gaussian quadrature rule adds n+1 points and reuses the n nodes from Gaussian quadrature, resulting in an integration rule with 2n+1 points. The additional n+1 nodes can be obtained as the roots of a polynomial constructed from the asymptotic expansion of the Legendre function of the second kind (the Stieltjes polynomial):

Wolfram Language code: sp[x_] = Normal[Quiet[Series[(4^n Beta[n + 1, n + 1]/LegendreQ[n, 0, 3, x]), {x, ∞, 0}], Series::sbyc]]

Compute the Gauss–Kronrod nodes and weights:

Wolfram Language code: kronrodNodes = x /. NSolve[sp[x], x]; gkNodes = Riffle[kronrodNodes, gaussNodes]
Wolfram Language code: w2 = x |-> (2^2n + 1n!^2/(2n + 1)!)(1/lp[x]sp'[x]); w3 = x |-> (2^2n + 1n!^2/(2n + 1)!)(1/lp'[x]sp[x]); gkWeights = Riffle[w2[kronrodNodes], gaussWeights + w3[gaussNodes]]

Use the (2n+1)-point Gauss–Kronrod rule to numerically evaluate an integral:

Wolfram Language code: est2 = ((b - a/2)gkWeights).Map[fun, Rescale[gkNodes, {-1, 1}, {a, b}]]

The difference between the results of the Gauss–Kronrod rule and the Gaussian rule can be used as an error estimate:

Wolfram Language code: est2 - est1

Compare the result of the Gauss–Kronrod rule with the result from NIntegrate:

Wolfram Language code: est2 - NIntegrate[fun[x], {x, a, b}]

Properties & Relations  (2)

LegendreQ can be expressed as a DifferenceRoot:

Wolfram Language code: DifferenceRootReduce[LegendreQ[k, y], k]
Wolfram Language code: DifferenceRootReduce[LegendreQ[k, y, z], k]

The generating function for LegendreQ:

Wolfram Language code: GeneratingFunction[LegendreQ[n, k], n, x]
Wolfram Research (1988), LegendreQ, Wolfram Language function, https://reference.wolfram.com/language/ref/LegendreQ.html (updated 2022).

Text

Wolfram Research (1988), LegendreQ, Wolfram Language function, https://reference.wolfram.com/language/ref/LegendreQ.html (updated 2022).

CMS

Wolfram Language. 1988. "LegendreQ." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2022. https://reference.wolfram.com/language/ref/LegendreQ.html.

APA

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

BibTeX

@misc{reference.wolfram_2026_legendreq, author="Wolfram Research", title="{LegendreQ}", year="2022", howpublished="\url{https://reference.wolfram.com/language/ref/LegendreQ.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_legendreq, organization={Wolfram Research}, title={LegendreQ}, year={2022}, url={https://reference.wolfram.com/language/ref/LegendreQ.html}, note=[Accessed: 13-June-2026]}