An explicit numerical algorithm to the solution of Volterra integral equation of the second kind

John van der Hoek; Leanne Dong

REVIEW 3 major objections 4 minor 14 references

An explicit numerical algorithm to the solution of Volterra integral equation of the second kind

T0 review · 3 major / 4 minor · reviewed 2026-08-14 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read For a step-function kernel, a Volterra integral equation of the second kind has an exact solution given by an explicit series, and approximating a general kernel by steps gives a certified error bound controlled by the kernel's $L^1$ norm.

desk verdict The paper's central explicit solution formula truncates the convolution series incorrectly, making the main algorithmic claim false, despite some correct and neat algebraic machinery. read the letter →

arxiv 1908.02862 v1 pith:ICCTQJUF submitted 2019-08-07 math.NA cs.NA

Leanne Dong , John van der Hoek This is my paper · ORCID

classification math.NAcs.NA MSC 45D0565R2045E10

keywords VolterraintegralequationsecondkindconvolutionkernelpiecewiseconstantapproximationexplicitalgorithmHawkesprocessNeumannserieserrorbounds

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper considers the Volterra equation $y(t)=f(t)+\int_0^t g(t-\tau)y(\tau)\,d\tau$, the linear integral equation that underlies self-exciting point-process models. Its aim is to replace numerical quadrature or iterative solution by an explicit algorithm: approximate the memory kernel $g$ by a piecewise-constant step function $g_\delta$, for which the fundamental solution $h$ of $h=g+h*g$ is shown to have an exact closed form. The main results are the explicit double-series formula for $h$ in Theorem 2.7, a scaling identity that reuses one unit-step computation at any step size $\delta$, and error bounds showing that $\|h-h_\delta\|$ is at most $(1-k)^{-2}\|g-g_\delta\|$ in $L^1$ and supremum norm when $k=\|g\|_1<1$. A sympathetic reader cares because the method turns a class of integral equations into a finite, explicit computation whose accuracy can be certified before the computation starts, at the price of choosing a step size.

What carries the argument

The machinery is a small algebra of operators on $L^1_+(\mathbb{R})$: the unit shift $L$ with $(Lf)(t)=f(t-1)$, the difference $\Delta=I-L$, the integration operator $J$, and the scaling operator $S_\delta$ with $(S_\delta f)(t)=\frac{1}{\delta}f(t/\delta)$. The step kernel is written $g=A\,\mathrm{rect}$ with the operator series $A=\sum a_j L^j$, and the $n$-fold convolution becomes $g^{*n}=A^n\gamma_n$, because the Laplace transform of $\mathrm{rect}$ factors as $(\widehat{J})(\widehat{\Delta})$; $\gamma_n$ is the explicit piecewise-polynomial function from (2.15), and $\beta_r^{(n)}$ are the coefficients of $A(z)^n$. The scaling identity $L_\delta=S_\delta L S_\delta^{-1}$ transports the whole construction from unit steps to steps of size $\delta$, while the error bounds (1.6)-(1.7) are derived in the appendix from the Neumann series and the convolution norm inequality, using the assumption that both kernels have $L^1$ norm $k<1$.

What would settle it

Take the Rayleigh kernel $g(t)=\frac{k t}{\sigma^2}e^{-t^2/(2\sigma^2)}$ with, say, $k=0.99$ and $\sigma=1$, approximate it by step functions of width $\delta$ using the paper's sampled coefficients, and compare $\|h-h_\delta\|_1$ computed from Theorem 2.7 (via the scaling identity) against a high-accuracy direct solve of the Volterra equation; inequality (1.6) predicts the error stays below $(1-k)^{-2}\|g-g_\delta\|_1$, so any violation at some $\delta$ refutes the bound. A sharper check: for the step kernel with $g(t)=1$ on $[0,1)$ and $0$ elsewhere, $k=1$, the series in Theorem 2.7 diverges term by term, so the theorem's conclusion should fail exactly at the boundary.

Watch

Extended reading notes

Core claim

For a kernel of the form $g(t)=\sum_{j\ge 0} a_j\,\mathrm{rect}(t-j)$ with $\mathrm{rect}(t)=1$ on $[0,1)$ and $0$ elsewhere, the paper proves that the solution of $h(t)=g(t)+\int_0^t g(t-\tau)h(\tau)\,d\tau$ is $$h(t)=\sum_{n\ge 1}\sum_{r=0}^{n-1}\$beta_r^{{(n)}}$\,\gamma_n(t-r),$$ where $\gamma_n$ is the $n$-fold convolution of $\mathrm{rect}$ with itself, given explicitly by $\gamma_n(t)=\sum_{r=0}^n (-1)^r\binom{n}{r}\frac{(t-r)_+^{n-1}}{(n-1)!}$, and $\beta_r^{(n)}$ are the coefficients of $(\sum_j a_j z^j)^n$ obtained from the recurrence (2.22)-(2.23). The paper then shows that if $g_\delta$ is the width-$\delta$ step approximation built from samples $g(j\delta)$, its solution obeys $h_\delta(t)=\frac{1}{\delta}h(t/\delta)$, so a single unit-step computation serves every $\delta$. If $\|g\|_1\le k<1$ and $\|g_\delta\|_1\le k<1$, the error is bounded by $(1-k)^{-2}\|g-g_\delta\|$ in both $L^1$ and supremum norms, and the same factor controls the error in the convolutions $h*f$ that give the solution $y$ for general inputs $f$.

Load-bearing premise

The whole method depends on the kernel's $L^1$ norm being strictly smaller than 1, since that is what makes the Neumann series converge and what keeps the factor $1/(1-k)^2$ in the error bounds finite.

Editorial extensions

If this is right

For inputs $f$ that are a finite Dirac comb plus a locally integrable part, the solution is assembled directly as $y(t)=f(t)+\sum_i w_i h(t_i)+(h*f_1)(t)$ using the explicit $h$, so no quadrature near the impulses is needed.
For a kernel with Lipschitz constant $L_g$, choosing $\delta$ makes the supremum error at most $\frac{L_g\,\delta}{(1-k)^2}$, giving an a priori recipe: pick $\delta$ to meet a tolerance, then compute the series once.
Because $\gamma_n(t)=0$ for $t\ge n$, only finitely many terms of the double series contribute on $[0,T]$, so the algorithm terminates after a finite number of arithmetic operations.
The scaling lemma means the unit-step solution $h$ is a reusable table: recomputing for a different step size $\delta$ costs only a rescaling of the input and output.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The algebra of the coefficients $\beta_r^{(n)}$ never uses positivity of the $a_j$, so the same explicit series and error bounds should hold for sign-changing kernels with $\|g\|_1<1$; the paper's nonnegative examples, like the Rayleigh kernel, are a special case.
The functions $\gamma_n$ are the probability densities of sums of $n$ independent uniform random variables, so the series for $h$ can be read as an infinite mixture of such densities; this points toward probabilistic interpretations and possibly renewal-theoretic proofs of the convergence.
The constant $(1-k)^{-2}$ is derived by a crude contraction argument; a natural testable conjecture is that for monotone nonnegative kernels the factor improves to $(1-k)^{-1}$, which a comparison against direct numerical solutions can decide.
The condition $k<1$ is exactly the subcritical regime of the self-exciting point process that motivates the equation, so the algorithm covers the stable branch of the application space; extending to $k\ge1$ would require a different representation and is left open by the paper.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

You can skip the heavy math unless you work on Hawkes processes or Volterra numerics, but if you do, the punchline is that the central explicit formula (Theorem 2.7) is wrong. The paper truncates the series for g^{*n} = A^n γ_n = ∑_{r≥0} β_r^{(n)} L^r γ_n at r = n−1. That is not justified. The support condition is that γ_n(s) is zero outside (0,n), so L^r γ_n(t) = γ_n(t−r) is nonzero whenever 0 < t−r < n, i.e. r ∈ (t−n, t). That includes r ≥ n as soon as t > n. The remark after (4.7) has the implication reversed: γ_n(t)=0 for t≥n does not imply L^rγ_n(t)=0 for r≥n.

Concrete failure: take g = a0 rect + a1 L rect with a0, a1 > 0 and a0+a1 < 1. For n=2, the convolution g^{*2} includes a1^2 L^2 γ_2. At t=5/2, that term contributes a1^2/2. Direct convolution gives g^{*2}(5/2)=a0a1 + a1^2/2, while the truncated formula (2.26) omits the a1^2/2. So the algorithm is not a correct solution method for even a two-step kernel.

What is actually good: the Neumann-series splitting E=δ+h, the operator A = ∑ a_j L^j, and the recurrence (2.22)-(2.23) are correct and neat. Theorem 2.6 is fine. The scaling lemma (3.2) and the L1/sup error bounds in the appendix are standard and correctly derived. The aim—an explicit, implementable series with controlled accuracy—is sensible.

The bigger soft spot beyond the bug is that there is no implementation or numerical experiment. That is unusual for a paper calling itself an explicit numerical algorithm, and a simple sanity check would have exposed the error. The contraction assumption ||g||_1 < 1 is clearly stated and fine for the intended Hawkes application.

The reader's report gave soundness 7 and a conditional recommendation; I disagree. The error is load-bearing. Theorem 2.7 and Corollary (4.5) are false as written. The paper might be repairable by keeping the full sum over r and truncating based on t, but until that is done and demonstrated, the contribution is not usable. I would not send this to peer review in its current form; a desk reject with a clear explanation is the right call. If the authors fix the series and add one numerical test, it becomes a reasonable short computational note.

Referee Report

3 major / 4 minor

Summary. The manuscript proposes an explicit numerical algorithm for the Volterra integral equation of the second kind, y(t)=f(t)+∫_0^t g(t−τ)y(τ)dτ, with emphasis on the case f=δ, where the fundamental solution is E=δ+h and h satisfies h=g+h∗g. The main idea is to approximate a general kernel g by a piecewise constant step kernel, write the step kernel as g=A rect with A=Σ a_j L^j, and express the n-fold convolution as g^{∗n}=A^n γ_n. The paper claims an explicit closed form for h, proves a scaling lemma to handle arbitrary step size δ, and gives L1 and L∞ stability bounds (1.6) and (1.7) showing that approximating g by a step kernel produces a controlled error. Applications to Hawkes processes and expressions for y=f+h∗f are also discussed.

Significance. If the explicit formula for h were correct, the paper would supply a practical, non-Monte-Carlo method for evaluating Hawkes-type intensity solutions with delta inputs, and the stability estimates (1.6) and (1.7) are useful and broadly standard. The paper also provides a self-contained derivation of the identity h=Σ g^{∗n} and a scaling argument for step size reduction. However, the central explicit formula in Theorem 2.7 is false as stated, and the error propagates into the numerical algorithm and the claimed finite termination of the series. The underlying idea is repairable, but the manuscript in its current form does not deliver the promised exact algorithm.

major comments (3)

[§2, Theorem 2.7 and eq. (2.26)] The truncation of the inner sum at r=n−1 is invalid. By Theorem 2.6, g^{∗n}=Σ_{r=0}^∞ β_r^{(n)} L^r γ_n, and L^rγ_n(t)=γ_n(t−r). The support condition is r<t<r+n, so terms with r≥n are nonzero whenever t>n. The remark after (4.7), which argues that γ_n(t)=0 for t≥n implies only r≤n−1 is needed, reverses the support condition. A concrete failure is obtained by taking g=a0 rect + a1 L rect with a0,a1>0 and a0+a1<1. For n=2, A^2=a0^2 I+2a0a1 L+a1^2 L^2. At t=5/2, direct convolution gives g^{∗2}(5/2)=a0a1+a1^2/2, whereas the right-hand side of (2.26) gives only a0a1 because the r=2 term a1^2γ_2(1/2) is omitted. Thus (2.26) is false, and the algorithm built on it is not an exact solution method.
[§2, Lemma 2.5 and eq. (2.23)] The recurrence for β_r^{(n+1)} sums l only from 0 to n+1, but A=Σ_{j=0}^∞ a_j L^j has infinitely many nonzero coefficients in general. The coefficient of L^r in A^{n+1} is Σ_{l=0}^{r} a_l β_{r−l}^{(n)} (with β_{negative}=0), not a sum truncated at n+1. For example, β_3^{(2)} from A^2 includes the term a_0a_3, which is omitted by the stated upper limit. If the corrected full series for h is used, this recurrence must be corrected accordingly.
[§7, Numerical Implementation] The claim that for 0≤t≤T only finitely many terms of the series are nonzero is false. For fixed t>0, γ_n(t)>0 for all n>t, so the outer series over n has infinitely many nonzero terms. The correct statement is that the tail can be made small using the bound Σ_{n>N} ‖g^{∗n}‖_1 ≤ k^{N+1}/(1−k), which introduces a tolerance rather than exact finite termination. Section 7's assertion of 'no approximation' therefore needs to be replaced by an explicit tail-estimate argument.

minor comments (4)

[§2, Theorem 2.7] The outer summation in (2.26) starts at n=0, but h is defined as Σ_{n=1}^∞ g^{∗n}; the n=0 term is undefined and should be removed or the index changed to n≥1.
[§10, sup-norm proof] In the displayed inequality leading to (8), the term arising from g2∗(h1−h2) is printed with ‖g1−g2‖_t in the second summand; it should be ‖h1−h2‖_t. As printed, the displayed estimate does not close the argument.
[§6, Example 2, eq. (6.2)] Applying (1.7) to the estimate (6.1) yields ‖h−hδ‖∞ ≤ kθ(1+θ)δ/(1−k)^2, not kθ(1+θ)δ/(1−k); the displayed bound misses one factor of (1−k)^{-1}.
[§8, Future Outlook] The paper is titled as a numerical algorithm but contains no numerical experiments or implementation; Section 8 states that implementation is future work. A small computed example illustrating the corrected formula would substantially strengthen the manuscript.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the solution formula is derived from Neumann series and Laplace transforms, with no fitted parameters and no load-bearing self-citations.

full rationale

The paper's central derivation is self-contained and non-circular. The solution h is defined by the Volterra equation (1.3) and represented as the Neumann series h = sum_n g^{*n} in (1.4), which is standard operator/convolution theory. For piecewise constant kernels, the explicit formula in Theorem 2.7 is obtained by taking Laplace transforms of g = A rect, using rect convolution powers gamma_n, and applying the shift operator L^r; the calculations in Lemmas 2.1-2.5 and Theorem 2.6 are analytic derivations rather than assumptions of the desired result. The delta-discretization parameter delta is an algorithmic grid parameter, not a fitted value: the approximation g_delta = S_delta g is defined explicitly, and the error bounds (1.6)-(1.7), proved in the appendix, compare the true solution to the step-kernel solution with coefficient 1/(1-k)^2. No parameter is fitted to data and then renamed a prediction. The paper cites external references only for Hawkes-process motivation and neural ODE context; no load-bearing self-citation or imported uniqueness theorem is used. The assumption ||g||_1 < 1 is an explicit hypothesis used to guarantee Neumann-series convergence and to bound errors; it is a limitation of scope, not circularity. Even the possible truncation issue raised about Theorem 2.7 concerns mathematical correctness, not equivalence of the output to the input by construction. Therefore the appropriate circularity score is 0.

Assumptions & free parameters 1 free parameters · 3 assumptions · 0 invented entities

The central claim rests on the contraction assumption k<1, standard distribution theory, and Laplace transform facts. The only user-chosen parameter is the step size δ; no data fitting occurs.

free parameters (1)

step size δ
Discretization step chosen by the user to trade accuracy against cost; the error bounds (6.2)-(6.3) scale linearly with δ. It is not fitted to data.

assumptions (3)

domain assumption The kernel g satisfies ||g||_1 = k < 1
Used throughout to ensure convergence of the Neumann series h = Σ g^{*n} and to derive the error bounds (1.6) and (1.7). Stated in (1.9) and the Hawkes setup.
standard math The fundamental solution has the form E = δ + h with h ∈ L1
Invoked in Section 1 using Schwartz distribution theory; standard for Volterra equations with integrable kernels under the contraction condition.
standard math Laplace transform identities for L1_loc functions, including the multiplier representation L^r
Used in Lemmas 2.2-2.4 and 4.5 to derive explicit formulas; standard integral transform results.

how reviews work

0 comments

Cite this review

Pith. "Pith review of An explicit numerical algorithm to the solution of Volterra integral equation of the second kind." pith.science (2026). https://pith.science/paper/ICCTQJUF

@misc{pith2026190802862,
  author       = {Pith},
  title        = {Pith review of: An explicit numerical algorithm to the solution of Volterra integral equation of the second kind},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ICCTQJUF}},
  note         = {Machine review of arXiv:1908.02862}
}

abstract

This paper considers a numeric algorithm to solve the equation \begin{align*} y(t)=f(t)+\int^t_0 g(t-\tau)y(\tau)\,d\tau \end{align*} with a kernel $g$ and input $f$ for $y$. In some applications we have a smooth integrable kernel but the input $f$ could be a generalised function, which could involve the Dirac distribution. We call the case when $f=\delta$, the Dirac distribution centred at 0, the fundamental solution $E$, and show that $E=\delta+h$ where $h$ is integrable and solve \begin{align*} h(t)=g(t)+\int^t_0 g(t-\tau)h(\tau)\,d\tau \end{align*} The solution of the general case is then \begin{align*} y(t)=f(t)+(h*f)(t) \end{align*} which involves the convolution of $h$ and $f$. We can approximate $g$ to desired accuracy with piecewise constant kernel for which the solution $h$ is known explicitly. We supply an algorithm for the solution of the integral equation with specified accuracy.

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

14 extracted references · 14 canonical work pages

[1]

An explicit numerical algorithm to the solution of Volterra integral equation of the second kind

V/O.small/L.small/T.small/E.small/R.small/R.small/A.small I/N.small/T.small/E.small/G.small/R.small/A.small/L.small E/Q.small/U.small/A.small/T.small/I.small/O.small/N.small /O.small/F.small /T.small/H.small/E.small S/E.small/C.small/O.small/N.small/D.small K/I.small/N.small/D.small Applications of Hawkes process in various grounds, such as in quantitativ...

work page Pith review arXiv 2019
[2]

0 and γ“/n.math´ 1. J/n.math/f.mathp/t.mathq“ ż /t.math 0 p/t.math´τq/n.math´1 p/n.math´ 1q! /f.mathpτq/d.mathτ (2.17) If we select /f.math

P/A.small/R.small/T.small I :Special Case We study the case /g.mathp/t.mathq“ # α/j.math/comma.mathif /j.mathď/t.mathă/j.math` 1 0/comma.math /t.mathă 0 (2.1) and then derive the case in (1.9) from it. Deﬁne rectp/t.mathq“ # 1/comma.math0ď/t.mathă 1 0/comma.math /t.mathě 1/comma.math/t.mathă 0 (2.2) pL/f.mathqp/t.mathq“ /f.mathp/t.math´ 1q (2.3) when /f.m...

work page
[3]

First, deﬁne Lδ(δą 0) pLδ/f.mathqp/t.mathq“ /f.mathp/t.math´δq (3.2) pSδ/f.mathqp/t.mathq“ 1 δ/f.math ˆ/t.math δ ˙ (3.3) S´1 δ “S1{δ (3.4) 8 Lemma 3.1

P/A.small/R.small/T.small II : A/C.small/T.small/U.small/A.small/L.small /C.small/A.small/S.small/E.small /F.small/O.small/R.small P/A.small/R.small/T.small I We now let /g.mathδp/t.mathq“ # β/j.math/comma.math /j.mathδď/t.mathăp/j.math` 1qδ 0/comma.mathotherwise (3.1) Let us now deﬁne some useful operators. First, deﬁne Lδ(δą 0) pLδ/f.mathqp/t.mathq“ /f....

work page
[4]

A/P.small/P.small/L.small/I.small/C.small/A.small/T.small/I.small/O.small/N.small/S.small The solution to equation (1) is /y.mathp/t.mathq“ /f.mathp/t.mathq`p /h.math˚/f.mathqp/t.mathq (4.1) Example 1. Suppose /f.mathp/t.mathq“ Nÿ /i.math“1 /w.math/i.mathδp/t.math´/t.math/i.mathq` /f.math1p/t.mathq (4.2) wheret/w.math1/comma.math¨¨¨ /comma.math/w.mathNu a...

work page
[5]

E/R.small/R.small/O.small/R.small A/N.small/A.small/L.small/Y.small/S.small/I.small/S.small We note that the results in (1.6) and (1.7). If /f.mathPL1pR`q, then 1 }/h.math˚/f.math´/h.mathδ˚/f.math}1ď }/f.math}1 p1´/k.mathq2}/g.math´/g.math/a.math}1 (5.1) }/h.math˚/f.math´/h.mathδ˚/f.math}8ď }/f.math}1 p1´/k.mathq2}/g.math´/g.math/a.math}8 (5.2) 1See proof...

work page
[6]

E/X.small/A.small/M.small/P.small/L.small/E.small/S.small: P/O.small/W.small/E.small/R.small L/A.small/W.small /A.small/N.small/D.small R/A.small/Y.small/L.small/E.small/I.small/G.small/H.small K/E.small/R.small/N.small/E.small/L.small Example 2. Let /g.mathp/t.mathq“ # /k.mathθ/c.mathθ p/c.math`/t.mathq1`θ if /t.mathě 0 0 if /t.mathă 0 We set β/j.math“/g...

work page
[7]

Solve the function γ/n.mathp/t.mathq for each /n.math(MATLAB or C++) so that their values can be called

N/U.small/M.small/E.small/R.small/I.small/C.small/A.small/L.small /I.small/M.small/P.small/L.small/E.small/M.small/E.small/N.small/T.small/A.small/T.small/I.small/O.small/N.small Compute β/n.math /r.mathcoeﬃcients for /r.mathď /n.math´ 1, all rest equal 0 for /n.math“ 1/comma.math2/comma.math¨¨¨ . Solve the function γ/n.mathp/t.mathq for each /n.math(MATL...

work page
[8]

We will also experiment with real-world data by using our generative integral equation model to predict for arbitrary time point

F/U.small/T.small/U.small/R.small/E.small /O.small/U.small/T.small/L.small/O.small/O.small/K.small We will implement our explicit algorithm into software and experiment with its behaviour. We will also experiment with real-world data by using our generative integral equation model to predict for arbitrary time point. (See the ODE version in [1]. This will...

work page

Show all 14 references

[9]

We thank Be- havioral Data Science group, especially Dr Marian-Andrei Rizoiu in facilitating discussions and supporting us with research environment

A/C.small/K.small/N.small/O.small/W.small/L.small/E.small/D.small/G.small/M.small/E.small/N.small/T.small/S.small This material was motivated from a problem in computational social science. We thank Be- havioral Data Science group, especially Dr Marian-Andrei Rizoiu in facilit...
[10]

This implies (1.1) has an unique solution

A/P.small/P.small/E.small/N.small/D.small/I.small/X.small We now prove (1.6) and (1.7) If we write (1.1) as: /h.math/i.math“/g.math/i.math`/g.math/i.math˚/h.math/i.math/comma.math /i.math“ 1/comma.math2 /h.math1´/h.math2“/g.math1´/g.math2`/g.math1˚/h.math1´/g.math2˚/h.math2 “/...
[11]

Ricky T. Q. Chen, Yulia Rubanova, Jesse Bettencourt, and Duvenaud David. Neural ordinary diﬀerential equations. In NIPS 2018 , 2018

2018
[12]

Daley and D

D.J. Daley and D. Vere-Jones. An introduction to the theory of point processes. Vol. I . Probability and its Applications (New York). Springer-Verlag, New York, second edition, 2003

2003
[13]

A dynamic contagion process

Angelos Dassios and Hongbiao Zhao. A dynamic contagion process. Adv. in Appl. Probab. , 43(3):814–846, 09 2011

2011
[14]

Expect- ing to be HIP: Hawkes Intensity Processes for Social Media Popularity

Marian-Andrei Rizoiu, Lexing Xie, Scott Sanner, Manuel Cebrian, Honglin Yu, and Pascal Van Hentenryck. Expect- ing to be HIP: Hawkes Intensity Processes for Social Media Popularity. In World Wide Web 2017, International Conference on , pages 1069–1078, Perth, Australia, 2017. 18

2017

Pith tools

Reviewed August 14, 2026 · model on record in the stance chip above.

[1] [1]

An explicit numerical algorithm to the solution of Volterra integral equation of the second kind

V/O.small/L.small/T.small/E.small/R.small/R.small/A.small I/N.small/T.small/E.small/G.small/R.small/A.small/L.small E/Q.small/U.small/A.small/T.small/I.small/O.small/N.small /O.small/F.small /T.small/H.small/E.small S/E.small/C.small/O.small/N.small/D.small K/I.small/N.small/D.small Applications of Hawkes process in various grounds, such as in quantitativ...

work page Pith review arXiv 2019

[2] [2]

0 and γ“/n.math´ 1. J/n.math/f.mathp/t.mathq“ ż /t.math 0 p/t.math´τq/n.math´1 p/n.math´ 1q! /f.mathpτq/d.mathτ (2.17) If we select /f.math

P/A.small/R.small/T.small I :Special Case We study the case /g.mathp/t.mathq“ # α/j.math/comma.mathif /j.mathď/t.mathă/j.math` 1 0/comma.math /t.mathă 0 (2.1) and then derive the case in (1.9) from it. Deﬁne rectp/t.mathq“ # 1/comma.math0ď/t.mathă 1 0/comma.math /t.mathě 1/comma.math/t.mathă 0 (2.2) pL/f.mathqp/t.mathq“ /f.mathp/t.math´ 1q (2.3) when /f.m...

work page

[3] [3]

First, deﬁne Lδ(δą 0) pLδ/f.mathqp/t.mathq“ /f.mathp/t.math´δq (3.2) pSδ/f.mathqp/t.mathq“ 1 δ/f.math ˆ/t.math δ ˙ (3.3) S´1 δ “S1{δ (3.4) 8 Lemma 3.1

P/A.small/R.small/T.small II : A/C.small/T.small/U.small/A.small/L.small /C.small/A.small/S.small/E.small /F.small/O.small/R.small P/A.small/R.small/T.small I We now let /g.mathδp/t.mathq“ # β/j.math/comma.math /j.mathδď/t.mathăp/j.math` 1qδ 0/comma.mathotherwise (3.1) Let us now deﬁne some useful operators. First, deﬁne Lδ(δą 0) pLδ/f.mathqp/t.mathq“ /f....

work page

[4] [4]

A/P.small/P.small/L.small/I.small/C.small/A.small/T.small/I.small/O.small/N.small/S.small The solution to equation (1) is /y.mathp/t.mathq“ /f.mathp/t.mathq`p /h.math˚/f.mathqp/t.mathq (4.1) Example 1. Suppose /f.mathp/t.mathq“ Nÿ /i.math“1 /w.math/i.mathδp/t.math´/t.math/i.mathq` /f.math1p/t.mathq (4.2) wheret/w.math1/comma.math¨¨¨ /comma.math/w.mathNu a...

work page

[5] [5]

E/R.small/R.small/O.small/R.small A/N.small/A.small/L.small/Y.small/S.small/I.small/S.small We note that the results in (1.6) and (1.7). If /f.mathPL1pR`q, then 1 }/h.math˚/f.math´/h.mathδ˚/f.math}1ď }/f.math}1 p1´/k.mathq2}/g.math´/g.math/a.math}1 (5.1) }/h.math˚/f.math´/h.mathδ˚/f.math}8ď }/f.math}1 p1´/k.mathq2}/g.math´/g.math/a.math}8 (5.2) 1See proof...

work page

[6] [6]

E/X.small/A.small/M.small/P.small/L.small/E.small/S.small: P/O.small/W.small/E.small/R.small L/A.small/W.small /A.small/N.small/D.small R/A.small/Y.small/L.small/E.small/I.small/G.small/H.small K/E.small/R.small/N.small/E.small/L.small Example 2. Let /g.mathp/t.mathq“ # /k.mathθ/c.mathθ p/c.math`/t.mathq1`θ if /t.mathě 0 0 if /t.mathă 0 We set β/j.math“/g...

work page

[7] [7]

Solve the function γ/n.mathp/t.mathq for each /n.math(MATLAB or C++) so that their values can be called

N/U.small/M.small/E.small/R.small/I.small/C.small/A.small/L.small /I.small/M.small/P.small/L.small/E.small/M.small/E.small/N.small/T.small/A.small/T.small/I.small/O.small/N.small Compute β/n.math /r.mathcoeﬃcients for /r.mathď /n.math´ 1, all rest equal 0 for /n.math“ 1/comma.math2/comma.math¨¨¨ . Solve the function γ/n.mathp/t.mathq for each /n.math(MATL...

work page

[8] [8]

We will also experiment with real-world data by using our generative integral equation model to predict for arbitrary time point

F/U.small/T.small/U.small/R.small/E.small /O.small/U.small/T.small/L.small/O.small/O.small/K.small We will implement our explicit algorithm into software and experiment with its behaviour. We will also experiment with real-world data by using our generative integral equation model to predict for arbitrary time point. (See the ODE version in [1]. This will...

work page