When would you choose Monte Carlo simulation over an exact analytic calculation?
answer
- where does the difficulty actually sit
- easy to code, impossible to integrate
- grid cost explodes with variable count
- you get percentiles, not just a mean
- solve the tractable part exactly, simulate the rest
basics
~20 sSimulate when the system's rules are easy to code but hopeless to integrate, when the problem is high-dimensional, or when the whole output distribution matters rather than a mean. Prefer the closed form when one exists: it is exact, instant and auditable.
solid answer
~50 sSimulation wins on three grounds. First, intractability: path-dependent rules, dependence between components and messy conditional logic often have no closed form even when they are twenty lines of code. Second, dimension: deterministic numerical integration costs grow exponentially with the number of variables, while Monte Carlo error stays proportional to `1/sqrt(n)` whatever the dimension. Third, output shape: a simulation returns the full distribution of outcomes, so tail risk and percentiles come free, whereas an analytic result usually gives one moment. The costs are real too. Every simulated number carries its own noise, precision is bought at four times the compute per halving, results are only reproducible if seeds and versions are recorded, and a clean simulation of a wrong model is more persuasive and more dangerous than a rough calculation. Where a closed form exists, use it, and reserve simulation for the part that resists.
go deeper
Recall the basic contrast: a formula gives the exact answer instantly when one exists, and simulation is what you reach for when the rules are easy to code but the algebra is not.
Explain the dimension argument concretely: grid cost grows exponentially in the number of variables while the simulation error rate stays proportional to one over the square root of the run count.
Show the hybrid instinct. Solve analytically whatever part yields, simulate the residual, and validate the simulation against a special case with a known formula before trusting it.
Own the governance. Require every simulated figure to travel with its run count, margin, seed and validation evidence, and hold the line that model doubt is never answered with more iterations.
## The decision, framed properly The question is not "which is more rigorous". Both are exact in their own sense: a closed form is exact about the model, and a simulation is unbiased for the model with a quantifiable error. The decision is about where the difficulty sits, what the output has to support, and who has to trust the result later. ## Three arguments for simulating **Intractability.** Many real systems are simple to describe step by step and hopeless to integrate. Consider a two-player board-game battle where each round's outcome depends on dice, on the units surviving the previous round, and on a rule that changes once a side drops below half strength. Writing the rules is easy; writing `P(attacker wins)` in closed form is a research project. Playing the battle out a million times answers it in seconds. The same is true for queueing systems with irregular arrivals, for any process with feedback, and for anything with awkward conditional logic. **Dimension.** Deterministic quadrature evaluates an integrand on a grid, and a grid over `d` variables costs a number of points that grows exponentially in `d`. Monte Carlo has the opposite property: its error rate is proportional to `1/sqrt(n)` with a constant set by the integrand's variability, and that rate does not depend on `d` at all. In low dimensions deterministic methods are far more efficient; past a handful of dimensions simulation becomes the only feasible option. State this correctly in an interview: the rate is dimension-free, though the constant may still grow with dimension. **The whole distribution.** Analytic work typically yields a mean, sometimes a variance. A simulation yields a sample of outcomes, from which every percentile, the shape of the tail, and the probability of any compound event come for free. When the decision hinges on a bad tail rather than an average, that is decisive. **A fourth, softer argument.** A simulation is often readable by non-specialists: it plays out the process they already understand, and its assumptions sit visibly in the code rather than in a derivation's fine print. That makes what-if analysis easy, since changing an assumption means changing a line. ## Three arguments for deriving **Exactness and speed.** A closed form returns the answer instantly, to full precision, every time. If the result sits inside an optimisation loop or a serving path, a formula is worth a great deal. **Insight.** A formula shows which parameters matter and how. `1/sqrt(n)` in a formula tells you the whole scaling story; a table of simulated numbers has to be reverse-engineered to reveal it. Formulas also differentiate, which matters when sensitivities or gradients are needed. **Auditability.** A derivation can be checked line by line by a reviewer. A simulation can only be checked by reading the code and trusting the seed, the version and the run configuration. ## The hybrid answer, which is usually the best one Most real problems are not all-or-nothing. Solve analytically whatever part yields, and simulate only the residual. Conditioning on the tractable piece and taking its expectation exactly, instead of simulating it, is a standard variance-reduction move: replacing a simulated quantity by its conditional expectation can only lower variance. In practice this looks like simulating the messy stochastic driver and computing the deterministic payoff exactly, rather than simulating everything end to end. Analytic results are also the best available test for a simulation. Run the simulation on a special case with a known formula and check that it reproduces it within its stated margin. A simulation that has never been validated against a closed-form case is untested code with a persuasive output. ## Governance, the part a lead owns When a simulated number drives a real decision, three obligations follow. - **Report the error.** Every simulated figure ships with its number of runs and its Monte Carlo margin. A bare number invites readers to over-read the last two digits. - **Separate the error sources.** Simulation noise is bought away with runs. Input uncertainty needs the simulation re-run across plausible parameter values. Model error needs validation against observed outcomes. Conflating them is the most common failure of simulation-driven decisions, and the sharpest version of it is a team that answers doubts about the model by adding more draws. - **Make it reproducible.** Seeds, model version, parameter set and run count recorded with the result. Otherwise the number cannot be re-derived when someone challenges it six months later, which is exactly when it matters. ## The failure mode to name out loud Simulation is seductive precisely because it always produces a number. A closed-form attempt that fails, fails visibly; a simulation of a misspecified model produces a confident, well-formatted, wrong answer, complete with a reassuringly narrow margin. The discipline that prevents this is validation against known cases and against observed reality, not more compute. ## What to say out loud Name intractability, dimension and full-distribution output as the reasons to simulate; exactness, insight and auditability as the reasons to derive; propose the hybrid; and close on the governance point that a simulated number must travel with its margin, its seed and its validation.
- Why does Monte Carlo beat grid-based numerical integration in high dimensions?A grid over `d` variables needs a point count that grows exponentially in `d`, so it becomes unaffordable within a handful of dimensions. Monte Carlo error is proportional to `1/sqrt(n)` regardless of `d`; only the constant, set by the integrand's variability, is affected. In one or two dimensions deterministic methods still win comfortably.
- How would you validate a simulation before letting it drive a decision?Run it on special cases where a closed form is known and check it reproduces them within its stated margin. Check invariants that must hold by construction, such as probabilities summing to one. Compare its predictions against observed outcomes where any exist. Then re-run across plausible input parameters to see whether the decision itself is stable.
- A team answers doubts about their simulation by running ten times as many iterations; what is wrong?They are treating model doubt as if it were sampling noise. More runs shrink only the simulation's own variability around whatever the model implies, so a missing mechanism simply gets a tighter interval around the wrong answer. Doubts about the model are settled by validation against known cases and observed outcomes.
saying these in an interview costs you the question
- Simulates a quantity that has a simple closed form
- Treats a simulated number as exact
- Answers model doubts by adding more iterations
- Claims grid integration scales fine to many dimensions
- Ships a simulated result with no seed or run count recorded