Chapter 20 Synthetic Data and Maximum Entropy Bootstrap

Chapter 19 described how recursive partitions adapt estimation bandwidth to local data. This chapter turns to synthetic realizations for studying the sensitivity of those estimates, forecasts, and the directional thresholds developed in Chapters 16–17. The central distinction is between designing useful scenarios and reproducing the sampling distribution of a specified statistic; each requires its own validation.

In many practical situations, however, analysts require not only statistical summaries of existing data but also synthetic data generation. Synthetic data can be used for simulation, risk analysis, forecasting evaluation, and Monte Carlo experiments.

A common approach for generating synthetic datasets is bootstrap resampling, which repeatedly samples from the observed data. While useful, classical bootstrap procedures assume independence or rely on model-based adjustments to accommodate dependence.

Time-series data present a particular challenge because temporal dependence must be preserved for synthetic samples to remain realistic.

The maximum entropy bootstrap (ME bootstrap) provides a framework for generating synthetic series from order statistics and their temporal ordering. The NNS adaptation adds explicit control over residual dependence and drift. These controls retain selected features of the observed series or vary them deliberately; they do not guarantee preservation of its entire marginal and joint distribution.

The NNS implementation, NNS.meboot, extends the original meboot algorithm in several important directions: it allows the user to specify an arbitrary target rank correlation between the original and resampled series, supports multiple dependence metrics native to the NNS framework, provides fine-grained control over the trend component of synthetic series, and enables a richer class of Monte Carlo simulations than classical iid resampling permits.

This chapter introduces bootstrap methods, explains the theory of the maximum entropy bootstrap, and demonstrates how synthetic time series can be generated and customized using NNS.meboot.


20.1 Bootstrap Methods

The bootstrap is a general method for estimating sampling distributions by resampling from observed data.

Suppose a dataset consists of observations

\[ x_1, x_2, \dots, x_n . \]

A bootstrap sample is obtained by drawing observations with replacement from this set, producing

\[ x_1^*, x_2^*, \dots, x_n^* . \]

Repeating this procedure many times produces an ensemble of synthetic datasets. Any statistic \(T(X)\) can then be evaluated across the bootstrap samples to approximate its sampling distribution.

Bootstrap procedures are widely used to estimate standard errors, confidence intervals, and bias corrections.

However, classical bootstrap resampling assumes that observations are independent and identically distributed (i.i.d.).

For time-series data this assumption fails because observations exhibit serial dependence. Simple resampling destroys the temporal ordering and therefore eliminates the structure that generated the data.


20.2 Limitations of Classical Bootstrap for Time Series

Several modifications of the bootstrap have been proposed to address dependence.

20.2.1 Block Bootstrap

The block bootstrap resamples contiguous blocks of observations rather than individual values. This partially preserves local dependence but introduces new design choices: block length, overlap structure, and edge effects. Choosing block parameters can strongly influence results.

20.2.2 Model-Based Bootstrap

Another approach fits a parametric time-series model such as ARIMA and then simulates synthetic data from the estimated model. This method inherits the limitations of the assumed model: specification risk, distributional assumptions, and sensitivity to parameter estimation.

Both approaches therefore require tuning choices or parametric assumptions.

20.2.3 The iid Correlation Constraint

Independent resampling usually produces correlations near zero with the fixed original ordering. The spread depends on sample size, ties and the empirical distribution: under regular iid conditions its scale is approximately \(1/\sqrt{n-1}\). A range near \([-0.3,0.3]\) is a description of many draws in the \(n=100\) illustration below, not a universal bound. IID resampling reproduces the observed marginal tails in expectation but cannot create values beyond the observed extrema. Deliberately correlated or anticorrelated paths answer a different question: how results behave under a chosen dependence scenario.

The maximum entropy bootstrap draws on information-theoretic principles to generate values between and beyond observed order statistics. NNS adds a target dependence parameter so an analyst can vary selected aspects of the path without specifying a complete parametric time-series model.


20.3 Maximum Entropy Principle

The maximum entropy principle originates from information theory.

Given incomplete information about a system, the probability distribution that best represents the current state of knowledge is the one that maximizes entropy subject to known constraints.

For a discrete distribution with probabilities \(p_i\), entropy is

\[ H = -\sum_i p_i \log p_i . \]

Maximizing entropy selects a distribution relative to the specified support, reference measure and constraints. Those choices remain modeling assumptions; the observed data do not determine them uniquely.

In bootstrap applications the constraints are motivated by empirical properties of the observed series. The principle motivates a family of synthetic distributions; a maximum-entropy construction is not by itself a guarantee of frequentist bias correction or interval coverage.


20.4 Maximum Entropy Bootstrap for Time Series

The maximum entropy bootstrap constructs synthetic time-series samples through a sequence of steps that preserve essential features of the observed data.

Let the observed series be

\[ x_1, x_2, \dots, x_n . \]

The ME bootstrap algorithm proceeds conceptually as follows.

20.4.1 Step 1: Order Statistics

Sort the observations to obtain the ordered sample

\[ x_{(1)} \le x_{(2)} \le \dots \le x_{(n)} . \]

The ordering allows construction of piecewise intervals between adjacent values.

20.4.2 Step 2: Interval Construction

Define intervals between successive order statistics and extend them at the boundaries. These intervals represent regions in which synthetic observations may occur.

20.4.3 Step 3: Maximum Entropy Density

The original ME-bootstrap construction uses interval means following the Theil–Laitinen weighting scheme: \(0.25\) on each neighbor and \(0.50\) on the central value for interior points, with boundary adjustments at the extremes. In the current NNS.meboot.part implementation, interior draws instead use type-7 empirical-quantile interpolation. The Theil–Laitinen means adjust the tails and enter the optional scale calculation. Thus the current interior draw rule should not be described as enforcing every original interval-mean constraint.

20.4.4 Step 4: Random Sampling

Random values are drawn using this interpolation and tail-adjustment rule, followed by the selected ordering and scale adjustments.

20.4.5 Step 5: Time Ordering

The sampled values are reordered to match the rank structure of the original series, restoring temporal dependence.

The resulting dataset has the requested sample size and selected rank or dependence characteristics. Its marginal scale and tails also depend on interpolation, mixing, symmetry and scale options. The method avoids a fixed parametric family; that does not make its inference assumptions unnecessary.


20.5 Dependence-Preserving Resampling

The key innovation of the maximum entropy bootstrap is the preservation of rank dependence.

Let

\[ R_t = \text{rank}(x_t) \]

denote the rank of observation \(x_t\) within the sample. After synthetic values are generated, they are assigned to time indices according to the same rank ordering:

\[ x_t^* = y_{(R_t)} \]

where \(y_{(i)}\) denotes the \(i\)-th ordered synthetic value.

In the fully aligned case this mapping preserves the relative ordering of observations over time (subject to ties). It preserves rank-based temporal features of that ordering, but not every Pearson autocovariance or higher-order dependence feature. It needs no block-length tuning; the ordering itself is a substantive design choice.

20.5.1 Theoretical Basis for Rank Matching

The theoretical justification for perfect rank matching was formalized by Joag-dev (1984), who showed that if one requires strong dependence between the original series \(x_t\) and any resampled series \(x_t^*\) without imposing parametric constraints, the order statistics of both series must conform with each other. This distribution-free measure of strong dependence corresponds to a Spearman rank correlation of unity.

The NNS implementation relaxes full alignment by targeting a chosen rank correlation in \([-1,1]\), as described next.


20.6 Arbitrary Spearman Rank Correlation: The rho Parameter

A major extension of NNS.meboot relative to the original meboot package is the ability to specify an arbitrary Spearman rank correlation \(\rho \in [-1, 1]\) between the original series and each bootstrap replicate. This is controlled by the rho argument.

The standard rank-reordering step aligns resamples with the original ordering; with distinct values this gives Spearman correlation \(\rho=1\). For stress testing, scenario analysis or Monte Carlo experiments, the analyst may instead request weak, zero or negative rank correlation. Zero rank correlation does not imply independence, just as the NNS dependence chapters emphasize.

20.6.1 How Rank Targeting Works

For each replicate, the algorithm constructs two extreme orderings:

  • Aligned: synthetic values sorted to match the rank order of the original residuals (corresponds to \(\rho = +1\)).
  • Anti-aligned: synthetic values sorted in the reverse rank order of the original residuals (corresponds to \(\rho = -1\)).

A convex combination of these two extremes is optimized to approach the target correlation \(\rho\) with the original residuals. Optimization is performed replicate by replicate in residual space. Finite-sample ranks and ties limit attainable values, and interior mixtures can change the marginal distribution. A chosen grid of targets is therefore a scenario design, not an estimated probability law over future dependence.

20.6.2 Dependence Metric Options

The type argument controls which dependence measure is targeted:

type Measure used
"spearman" Spearman rank correlation (default)
"pearson" Pearson linear correlation
"NNScor" NNS nonlinear correlation
"NNSdep" NNS nonlinear dependence

The "NNScor" and "NNSdep" options integrate the NNS co-partial-moment framework into targeting. Their interpretation follows Chapter 10: "NNScor" is a signed correlation measure, while "NNSdep" measures unsigned dependence. For the latter, meaningful targets are in \([0,1]\) and should be checked with NNS.dep rather than with a signed rank or Pearson correlation.

20.6.3 Simulation Evidence

Vinod and Viole (2020) demonstrate through simulation that for OLS inference on nonstationary I(1) data, meboot-based confidence intervals with \(\rho \ge 0.6\) outperform traditional OLS confidence intervals. When \(\rho = 1\), the average absolute deviation from the nominal rejection rate is approximately \(0.037\), far smaller than the OLS analog of approximately \(0.423\).

In the reported random-walk experiments, some low-rho settings led the ADF test to reject a unit-root null. This is evidence about those simulations and test settings. Finite-sample rejection is not a proof of stationarity, and neither \(\rho<0.5\) nor any other fixed cutoff is a general transformation from I(1) to I(0), especially when an estimated trend is restored.


20.7 Trend Decomposition and Drift Control

The NNS.meboot implementation operates on residuals rather than raw levels. Specifically:

  1. A linear trend is estimated from the original series via ordinary least squares.
  2. The ME bootstrap resampling is applied to the residuals.
  3. Reconstructed synthetic series are formed as \(\text{baseline}_t + \text{resampled residual}_t\), where the baseline is the fitted linear trend evaluated at each time point.

This decomposition separates the dependence-targeting step from the chosen trend. It permits controlled residual and drift scenarios without asserting that all residual distributional properties survive the subsequent mixing and scaling.

20.7.1 Drift Arguments

Four arguments govern the trend component:

  • drift = TRUE (default): the original series’ estimated linear drift is preserved in all replicates.
  • drift = FALSE: the trend is removed; replicates are centered around a flat baseline.
  • target_drift: specifies an explicit drift value (e.g., a risk-free rate of return) to impose on all replicates.
  • target_drift_scale: multiplies the estimated drift by a scalar, allowing proportional adjustments.

These options are particularly useful in financial applications where synthetic return paths should reflect a specific expected return or be drift-neutral for risk attribution purposes.


20.8 Scenario Scales and Sampling Uncertainty

Three separate controls matter for scale. expand.residual.sd = TRUE retains the historical expansion of resampled residual standard deviations before trend reconstruction. expand.sd controls a later expansion in level space; it is skipped when the original drift is replaced. Set expand.residual.sd = FALSE to disable the first operation explicitly. Disabling expand.sd alone has never disabled the residual expansion.

force.clt = TRUE spreads replicate means on an iid normal-reference scale, using \(s/\sqrt{n}\) from the relevant baseline-plus-residual series. It is a scenario adjustment, not a theorem that the generated paths satisfy a sampling central limit theorem. For a covariance-stationary series with autocovariances \(\gamma_k\), the finite-sample variance of the mean is

\[ \operatorname{Var}(\bar X_n) =\frac{1}{n}\left[\gamma_0+2\sum_{k=1}^{n-1}\left(1-\frac{k}{n}\right)\gamma_k\right]. \]

The iid reference omits the nonzero-lag terms. Positive and negative serial dependence can therefore require quite different scales. Nonstationary series and other statistics require their own analysis. Increasing reps improves simulation resolution; it does not supply missing sampling assumptions.

To inspect the dependence target directly, use individual residual paths. With the trend suppressed and later scale adjustments disabled, this R example compares each replicate to the original detrended residuals:

boots <- NNS.meboot(AirPassengers, reps = 100, rho = 0, drift = FALSE,
                    expand.sd = FALSE, force.clt = FALSE)
original_residuals <- residuals(lm(as.numeric(AirPassengers) ~ seq_along(AirPassengers)))
apply(boots["replicates", ]$replicates, 2, function(z)
  cor(z, original_residuals, method = "spearman"))

An ensemble mean is a central summary, so its correlation is a different diagnostic. Neither zero rank correlation nor a matching marginal variance establishes independence or uncertainty calibration for every statistic.


20.9 Synthetic Time-Series Generation with NNS.meboot

The NNS package provides NNS.meboot for generating synthetic samples with specified residual dependence and drift controls.

20.9.1 Basic Usage

library(NNS)

# Generate 100 bootstrap replicates of AirPassengers
boots <- NNS.meboot(AirPassengers, reps = 100, rho = 1, xmin = 0)

# Describe the ensemble level path (this does not verify the residual rho target)
cor(boots["ensemble", ]$ensemble, AirPassengers, method = "spearman")

# Plot all replicates
matplot(boots["replicates", ]$replicates, type = "l")

# Overlay ensemble mean
lines(boots["ensemble", ]$ensemble, lwd = 3)

# Overlay original
lines(1:length(AirPassengers), AirPassengers, lwd = 3, col = "red")

In Python, nns_meboot returns a dictionary with the same named elements (replicates, ensemble, …). The AirPassengers series can be loaded through statsmodels:

import numpy as np
from scipy.stats import spearmanr
from statsmodels.datasets import get_rdataset
from nns import nns_meboot

air = get_rdataset("AirPassengers").data["value"].to_numpy()

# Generate 100 bootstrap replicates of AirPassengers
boots = nns_meboot(air, reps=100, rho=1, xmin=0)

# Describe the ensemble level path (this does not verify the residual rho target)
spearmanr(boots["ensemble"], air).statistic

boots["replicates"]   # (len(air) x 100) matrix of bootstrap paths
Figure 20.1. NNS.meboot replicates with ensemble mean (black) and original series (red), illustrating dependence-preserving bootstrap paths.
Figure 20.1. NNS.meboot replicates with ensemble mean (black) and original series (red), illustrating dependence-preserving bootstrap paths.

20.9.2 Return Object

NNS.meboot exposes the following named components; vectorized R calls arrange them in a list-valued matrix, one column per target:

Element Description
x Original input data
replicates Matrix of bootstrap replicates (rows = time, cols = replicates)
ensemble Row mean across all replicates
xx Sorted order statistics of residuals
z Class interval limits
dv Absolute consecutive deviations
dvtrim Trimmed mean of dv (used for tail extension)
xmin Lower residual draw limit
xmax Upper residual draw limit
desintxb Desired interval means (Theil–Laitinen)
ordxx Rank ordering of original residuals
kappa Scale adjustment factor (if scl.adjustment = TRUE)

20.9.3 Vectorized rho

The rho argument is vectorized, enabling a single call to produce replicates at multiple target correlations simultaneously:

# Three target residual rank correlations: zero, one-half, and one
boots <- NNS.meboot(AirPassengers, reps = 10, rho = c(0, 0.5, 1), xmin = 0)

matplot(do.call(cbind, boots["replicates", ]), type = "l")
lines(1:length(AirPassengers), AirPassengers, lwd = 3, col = "red")

With a vectorized rho, the Python function returns one result dictionary per correlation level:

# Three target residual rank correlations: zero, one-half, and one
boots = nns_meboot(air, reps=10, rho=[0, 0.5, 1], xmin=0)

Z = np.hstack([b["replicates"] for b in boots])

For Monte Carlo workflows, the package also provides NNS.MC() as a convenience wrapper around this NNS.meboot-based simulation pipeline (nns_mc in Python).

Similarly, target_drift is vectorized across drift levels while holding rho fixed:

# Replicates with two different target drift rates, rho fixed at 0
boots <- NNS.meboot(AirPassengers, reps = 10, rho = 0, xmin = 0,
                    target_drift = c(1, 7))
matplot(do.call(cbind, boots["replicates", ]), type = "l")
lines(1:length(AirPassengers), AirPassengers, lwd = 3, col = "red")
# Replicates with two different target drift rates, rho fixed at 0
boots_d1 = nns_meboot(air, reps=10, rho=0, xmin=0, target_drift=1)
boots_d7 = nns_meboot(air, reps=10, rho=0, xmin=0, target_drift=7)

20.10 Improved Monte Carlo Simulation

20.10.1 The Limitation of Standard iid MCS

The iid Monte Carlo illustration generates paths by sampling with replacement from the observed series. Its paths reflect that independence assumption.

In the following \(n=100\) illustration, correlations from 10,000 resamples concentrate near zero, with most between roughly \(-0.3\) and \(0.3\). This spread changes with the sample size and empirical distribution; it is not a restriction that applies to all iid simulations.

set.seed(12345)
xt <- rnorm(1:100, mean = 9, sd = 12)

# Standard iid MCS: 10,000 replicates
X <- matrix(NA, nrow = 100, ncol = 10000)
for (i in 1:10000) {
  X[, i] <- sample(xt, 100, replace = TRUE)
}

hist(cor(X, xt),
     main = "Standard iid Monte Carlo Simulation\n10,000 Iterations",
     xlab = "Correlation")
import numpy as np

rng = np.random.default_rng(12345)
xt = rng.normal(loc=9, scale=12, size=100)

# Standard iid MCS: 10,000 replicates
X = xt[rng.integers(0, xt.size, size=(100, 10_000))]

correlations = [np.corrcoef(X[:, i], xt)[0, 1] for i in range(X.shape[1])]
Figure 20.2. Standard iid Monte Carlo correlation histogram (cor(X, x_t)), typically concentrated near zero.
Figure 20.2. Standard iid Monte Carlo correlation histogram (cor(X, x_t)), typically concentrated near zero.

The histogram is centered near zero. Strongly correlated or anticorrelated paths are unlikely under this iid design, rather than impossible; a targeted scenario generator deliberately changes that design.

20.10.2 Expanded Simulation via Vectorized rho

The NNS.meboot approach spans the full correlation range \([-1, 1]\) by generating one replicate per target \(\rho\) value across a fine grid, then expanding each to a set of standard meboot replicates:

library(NNS)
set.seed(12345)
xt <- rnorm(1:100, mean = 9, sd = 12)

# Step 1: Generate one replicate per rho across [-1, 1]
boots_grid <- NNS.meboot(xt, reps = 1,
                          rho = seq(-1, 1, 0.01),
                          drift = FALSE)

Z <- do.call(cbind, boots_grid["replicates", ])

# Step 2: Expand each to 50 standard meboot replicates
new_MCS <- list()
for (i in 1:dim(Z)[2]) {
  new_MCS[[i]] <- NNS.meboot(Z[, i], reps = 50, rho = 1,
                             drift = FALSE)["replicates", ]$replicates
}

hist(cor(do.call(cbind, new_MCS), xt),
     main = "NNS.meboot Simulation\n10,000 Iterations",
     xlab = "Correlation")
from nns import nns_meboot

# Step 1: Generate one replicate per rho across [-1, 1]
boots_grid = nns_meboot(xt, reps=1, rho=np.arange(-1, 1.01, 0.01), drift=False)

Z = np.hstack([b["replicates"] for b in boots_grid])

# Step 2: Expand each to 50 standard meboot replicates
new_mcs = [
    nns_meboot(Z[:, i], reps=50, rho=1, drift=False)["replicates"]
    for i in range(Z.shape[1])
]

sim = np.hstack(new_mcs)
correlations = [np.corrcoef(sim[:, i], xt)[0, 1] for i in range(sim.shape[1])]
Figure 20.3. NNS.meboot Monte Carlo correlation histogram after vectorized dependence targeting, spanning a wider [-1,1] range.
Figure 20.3. NNS.meboot Monte Carlo correlation histogram after vectorized dependence targeting, spanning a wider \([-1,1]\) range.

The chosen grid produces a broader range of dependence scenarios. A uniform grid of rank targets need not yield a uniform histogram of Pearson correlations after reconstruction, and neither distribution is automatically the probability distribution of future market states.


20.11 Applications in Forecasting and Risk Analysis

20.11.1 Financial Risk Management: Value at Risk and Expected Shortfall

The richer simulation produced by NNS.meboot is especially valuable in financial risk management, where tail behavior drives key risk metrics.

Vinod and Viole (2020) demonstrate this using ten years of daily S&P 500 returns (1998–2007) to generate simulations, then evaluating out-of-sample performance against the 2008 financial crisis. The simulation exercise generates approximately 2.5 million observations from each method to estimate the 1% Value at Risk (VaR), expected shortfall (ES), and minimum simulated return.

Metric Actual 2008 Standard MCS NNS.meboot
99% VaR −8.77% −2.94% −3.10%
Expected Shortfall −8.92% −3.66% −3.91%
Minimum Value −9.03% −6.80% −15.68%

The reported NNS scenario minimum extends beyond the historical support, illustrating a stress-testing use. A more extreme minimum alone does not establish a calibrated tail probability or a better VaR forecast; the table also shows substantial differences between both simulated VaR estimates and the 2008 realized tail. The table reports the cited study, not an exact output guarantee for the current illustrative code.

The sym = TRUE argument symmetrizes the residual order statistics about their mean before drawing. That is an optional scenario assumption: financial return tails need not be symmetric, and symmetrization is not automatically conservative. The example below deliberately includes symmetric residual scenarios. Its training returns end in December 2007, strictly before the 2008 evaluation period:

library(quantmod)
library(NNS)

getSymbols("^GSPC", from = "1998-01-01", to = "2009-01-01")
SPX_returns <- dailyReturn(GSPC)
SPX_train <- as.numeric(SPX_returns["1998-01::2007-12"])
SPX_test  <- as.numeric(SPX_returns["2008"])

# Generate paths across the full rho range
SPX_boots <- NNS.meboot(SPX_train, reps = 1,
                         rho = seq(-1, 1, 0.01),
                         drift = FALSE)

SPX_meboot_grid <- do.call(cbind, SPX_boots["replicates", ])

# Expand each path to 5 replicates with symmetric ME density
new_SPX <- list()
for (i in 1:dim(SPX_meboot_grid)[2]) {
  new_SPX[[i]] <- NNS.meboot(SPX_meboot_grid[, i], reps = 5,
                               rho = 1, drift = FALSE,
                               sym = TRUE)["replicates", ]$replicates
}

all_returns <- unlist(new_SPX)

# Risk metrics
quantile(all_returns, 0.01)   # 99% VaR
mean(all_returns[all_returns <= quantile(all_returns, 0.01)])  # ES
min(all_returns)              # Minimum simulated return

The Python analog sources the daily returns with yfinance in place of quantmod:

import numpy as np
import yfinance as yf
from nns import nns_meboot

gspc = yf.download("^GSPC", start="1998-01-01", end="2009-01-01")["Close"]
returns = gspc.pct_change().dropna()
spx_train = returns.loc["1998-01":"2007-12"].to_numpy().ravel()
spx_test = returns.loc["2008"].to_numpy().ravel()

# Generate paths across the full rho range
spx_boots = nns_meboot(spx_train, reps=1, rho=np.arange(-1, 1.01, 0.01), drift=False)

spx_meboot_grid = np.hstack([b["replicates"] for b in spx_boots])

# Expand each path to 5 replicates with symmetric ME density
new_spx = [
    nns_meboot(spx_meboot_grid[:, i], reps=5, rho=1, drift=False, sym=True)["replicates"]
    for i in range(spx_meboot_grid.shape[1])
]

all_returns = np.hstack(new_spx).ravel()

# Risk metrics
np.quantile(all_returns, 0.01)                                  # 99% VaR
all_returns[all_returns <= np.quantile(all_returns, 0.01)].mean()  # ES
all_returns.min()                                               # Minimum simulated return

20.11.2 Forecast Model Evaluation

Synthetic time series allow analysts to study forecast stability and model sensitivity. For a predictive distribution, rerun the complete forecasting procedure and validate its coverage against subsequently observed outcomes; scenario variation alone does not provide that calibration.

20.11.3 Stationarity Diagnostics

Changing rho can change unit-root test results in simulated paths. Report the drift setting, sample size and test specification alongside those results. A low dependence target does not establish stationarity or replace assumptions about the data-generating process.


20.12 Relationship to the NNS Framework

The maximum entropy bootstrap fits naturally within the directional statistics framework developed throughout this book.

Directional methods emphasize distributional structure relative to benchmarks. NNS.meboot lets an analyst vary selected aspects of that structure and recompute downstream quantities, including:

  • partial-moment estimation,
  • directional dependence measurement via NNS.dep,
  • distribution comparison via NNS ANOVA,
  • nonparametric forecasting.

The type = "NNScor" and type = "NNSdep" options close this loop explicitly: the bootstrap targeting criterion is itself computed using NNS co-partial moments, so the resampling respects the same nonlinear dependence geometry as the rest of the NNS toolkit.

Combining these scenarios with directional measures gives a nonparametric workflow for sensitivity analysis. Sampling inference additionally requires that the resampling design reproduce the statistic and dependence structure relevant to the inferential question.


20.13 Summary

This chapter introduced synthetic data generation through the maximum entropy bootstrap as implemented in NNS.meboot.

Key points include:

  • Classical bootstrap methods assume independence and may destroy temporal structure.
  • IID resampling reproduces observed marginal tails but concentrates path correlations near zero; dependence-targeted scenarios deliberately explore other orderings.
  • NNS draws on maximum-entropy-bootstrap ideas, with empirical-quantile interior draws, adjusted tails and explicit residual mixing; marginal preservation is not automatic.
  • Full rank alignment preserves the original residual ordering; it does not preserve every temporal dependence feature.
  • NNS.meboot extends the original meboot algorithm with a vectorized rho argument that targets any Spearman rank correlation in \([-1, 1]\), multiple dependence metric options including NNS-native measures, and drift decomposition for precise trend control.
  • The expanded Monte Carlo simulation enabled by vectorized rho spans the full correlation range and provides materially richer risk estimates, as demonstrated in the S&P 500 stress-testing example.
  • Low-rho unit-root-test results are simulation diagnostics, not a general stationarity theorem.

Within the NNS framework, the ME bootstrap supplies flexible scenario generation and forecasting sensitivity analysis. Confidence and prediction statements should also state their sampling assumptions and demonstrate calibration.


20.14 References

  • Joag-Dev, K. (1984). Measures of dependence. In P. K. Krishnaiah & P. K. Sen (Eds.), Handbook of Statistics (Vol. 4, pp. 79–88). North-Holland.
  • Vinod, H. D. (2004). Ranking mutual funds using unconventional utility theory and stochastic dominance. Journal of Empirical Finance, 11(3), 353–377.
  • Vinod, H. D. (2006). Maximum entropy ensembles for time series inference in economics. Journal of Asian Economics, 17(6), 955–978.
  • Vinod, H. D. (2013). Maximum entropy bootstrap algorithm enhancements (SSRN Working Paper 2285041). https://doi.org/10.2139/ssrn.2285041
  • Vinod, H. D., & López-de-Lacalle, J. (2009). Maximum entropy bootstrap for time series: The meboot R package. Journal of Statistical Software, 29(5), 1–19.
  • Vinod, H. D., & Viole, F. (2020). Arbitrary Spearman’s rank correlations in maximum entropy bootstrap and improved Monte Carlo simulations (SSRN Working Paper 3621614). https://doi.org/10.2139/ssrn.3621614
  • Viole, F. (2016). NNS: Nonlinear nonparametric statistics. R package. https://cran.r-project.org/package=NNS