{
 "id": "epv44pt4d9",
 "slug": "fault-simulation",
 "title": "Fault simulation",
 "updated": "2026-09-30",
 "topic_path": [
  {
   "id": "technology",
   "label": "Technology and the built world",
   "api_url": "https://www.edgepedia.org/api/v1/topics/technology"
  },
  {
   "id": "technology.engineering",
   "label": "Engineering and manufacturing",
   "api_url": "https://www.edgepedia.org/api/v1/topics/technology.engineering"
  },
  {
   "id": "technology.engineering.manufacturing.digital.cad",
   "label": "Computer-aided engineering and EDA",
   "api_url": "https://www.edgepedia.org/api/v1/topics/technology.engineering.manufacturing.digital.cad"
  }
 ],
 "geo": [
  {
   "id": "geo.nongeo.t1946.technology.engineering",
   "label": "Non-geographic · 1946 to 2000: Engineering and manufacturing",
   "api_url": "https://www.edgepedia.org/api/v1/geo/geo.nongeo.t1946.technology.engineering",
   "path": [
    {
     "id": "geo.nongeo",
     "label": "Non-geographic",
     "api_url": "https://www.edgepedia.org/api/v1/geo/geo.nongeo"
    },
    {
     "id": "geo.nongeo.t1946",
     "label": "Non-geographic · 1946 to 2000",
     "api_url": "https://www.edgepedia.org/api/v1/geo/geo.nongeo.t1946"
    },
    {
     "id": "geo.nongeo.t1946.technology",
     "label": "Technology and the built world",
     "api_url": "https://www.edgepedia.org/api/v1/geo/geo.nongeo.t1946.technology"
    },
    {
     "id": "geo.nongeo.t1946.technology.engineering",
     "label": "Engineering and manufacturing",
     "api_url": "https://www.edgepedia.org/api/v1/geo/geo.nongeo.t1946.technology.engineering"
    }
   ]
  }
 ],
 "excerpt": "Fault simulation is a digital circuit testing method that injects modeled faults, usually stuck-at, into a circuit design and simulates its behavior to measure how well test vectors detect them.",
 "snippet": "Fault simulation is a digital circuit testing method that injects modeled faults, usually stuck-at, into a circuit design and simulates its behavior to measure how well test vectors detect them.",
 "node": "technology.engineering.manufacturing.digital.cad",
 "markdown": "# Fault simulation\n\nFault simulation is a digital circuit testing method that injects modeled faults into a circuit design and simulates its behavior to measure how well a set of test vectors detects those faults. Its inputs are a circuit description, a sequence of test vectors, and a fault model; its outputs are a fault coverage number (fault grading), the set of undetected faults identifying areas of low coverage, a fault dictionary for post-test diagnosis, and information for test set compaction.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup><sup> • </sup><sup>[2](https://www.lirmm.fr/~virazel/COURS/M2%20-%20HAE926E/Lecture/CH3%20Fault%20Simulation.pdf)</sup> It sits between logic simulation, which models only the fault-free circuit, and automatic test pattern generation (ATPG), which is far more computationally expensive; fault simulation is also used to grade functional patterns and to find faults accidentally detected by a vector.<sup>[3](https://www.ee.nthu.edu.tw/~syhuang/testing/ch3.fault_simulation.pdf)</sup>\n\n| Key fact | Detail |\n|---|---|\n| Outputs | Fault coverage, undetected-fault set, fault dictionary, test compaction information<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup> |\n| Dominant fault model | Stuck-at, covering nearly 64% of CMOS defects<sup>[4](https://pld.ttu.ee/~raiub/BOOK/Ch_3/papers/Ch31_Fault%20simulation%20and%20fault%20injection%20technology%20based%20on%20SystemC_r.pdf)</sup> |\n| Classic algorithms | Serial, parallel, deductive, concurrent, differential, PPSFP |\n| Complexity | About \\( F \\cdot P \\cdot G \\sim O(G^{3}) \\) for \\( G \\) gates, \\( F \\) faults, \\( P \\) patterns; reduced by fault dropping<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup> |\n| Standard benchmarks | ISCAS'85: C432 (160 gates, 524 faults) to C7552 (3512 gates, 7550 faults)<sup>[5](https://ddd.fit.cvut.cz/www/prj/Benchmarks/iscas85.pdf)</sup> |\n| Known bias | X-state pessimism can underestimate coverage by up to 14.2% (c7552)<sup>[6](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2012/ETS_HilleKWB2012.pdf)</sup> |\n| Recent acceleration | GPU (7–80×), ML prediction (EPICS 5.94× over a commercial tool)<sup>[7](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2018/TCAD_SchneW2018.pdf)</sup><sup> • </sup><sup>[8](https://dl.acm.org/doi/10.1109/DAC63849.2025.11132928)</sup> |\n\n## How it works\n\nA fault simulator runs the circuit twice in effect: once as designed (the good machine) and once with a modeled fault present, then compares outputs. A fault is detected when the faulty response differs from the good response at an observable primary output for some applied vector. The fault model defines what is injected: the stuck-at model fixes a line at logic 0 or 1 regardless of what drives it; bridging models short two nets; transition and delay faults model timing behavior; single-event upset (SEU) and single-event transient (SET) models capture soft errors.<sup>[9](https://arxiv.org/pdf/2204.13183)</sup>\n\nFault lists are shortened before simulation by equivalence collapsing: for an n-input gate with controlling value c, all input s-a-c faults and the corresponding output fault are functionally equivalent, so only \\( n+2 \\) single stuck faults per gate need be considered.<sup>[10](https://pld.ttu.ee/diagnostika/theory/fault.html)</sup> Fault-simulation cost is about proportional to \\( F \\cdot P \\cdot G \\) for \\( G \\) gates, \\( F \\) faults, and \\( P \\) patterns, higher than logic simulation by a factor of \\( F \\) (the fault count) but much lower than ATPG.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup>\n\n## How it is done\n\nThe practitioner flow is: build a circuit model (with 2/3/4-value logic coding, e.g. 0, 1, X, Z, and zero- or unit-delay timing), derive a collapsed fault list, apply the test vectors, run the simulation, and report coverage.<sup>[2](https://www.lirmm.fr/~virazel/COURS/M2%20-%20HAE926E/Lecture/CH3%20Fault%20Simulation.pdf)</sup> Fault dropping halts simulation of a fault once detected; it is used for fault grading but avoided when the full fault dictionary for diagnosis is wanted.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup> Faults whose output response changes to or from X are reported as probably detected, since they may not be observable in practice.<sup>[11](http://opencircuitdesign.com/irsim/archive/fsim.pdf)</sup>\n\n## Origin\n\nSundaram Seshu described an improved diagnosis program in IEEE Transactions on Electronic Computers in 1965.<sup>[12](https://doi.org/10.1109/pgec.1965.264063)</sup> Fred H. Hardie and Robert J. Suhocki reported the design and use of fault simulation for the Saturn computer in 1967.<sup>[13](https://doi.org/10.1109/pgec.1967.264644)</sup> D.B. Armstrong published the deductive method in IEEE Transactions on Computers in 1972,<sup>[14](https://doi.org/10.1109/t-c.1972.223542)</sup> and E. G. Ulrich and T. Baker published concurrent simulation of nearly identical digital networks in Computer in 1974.<sup>[15](https://doi.org/10.1109/mc.1974.6323496)</sup>\n\n## Variants\n\n**Serial** simulation performs one fault-free simulation plus \\( n \\) independent faulty simulations for \\( n \\) faults; it is very slow (\\( n+1 \\) consecutive runs) but simple, memory-light, and handles any fault model the underlying logic simulator supports, including delay and bridging models.<sup>[2](https://www.lirmm.fr/~virazel/COURS/M2%20-%20HAE926E/Lecture/CH3%20Fault%20Simulation.pdf)</sup><sup> • </sup><sup>[16](http://digimat.in/nptel/courses/video/117105137/lec14.pdf)</sup>\n\n**Parallel** simulation is a compiled-code method exploiting bit-parallelism: bit 0 of each word holds the good value and the remaining bits hold faulty values, so each pass simulates \\( w-1 \\) faults for word length \\( w \\), a speedup of about \\( w-1 \\) over serial. It applies only to unit- or zero-delay models, and a fault cannot be dropped until all \\( w-1 \\) faults in its word are detected.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup><sup> • </sup><sup>[2](https://www.lirmm.fr/~virazel/COURS/M2%20-%20HAE926E/Lecture/CH3%20Fault%20Simulation.pdf)</sup>\n\n**Deductive** simulation explicitly simulates only the good circuit and propagates a fault list Lᵢ on each line using set-theoretic rules, for example [Lₐ∩L_b]∪c for an AND gate with inputs 0, 0, and output 0; the union of lists at the primary outputs contains the faults detected by the vector. List sizes can grow dynamically and cause memory explosion.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup><sup> • </sup><sup>[3](https://www.ee.nthu.edu.tw/~syhuang/testing/ch3.fault_simulation.pdf)</sup>\n\n**Concurrent** simulation keeps, for each gate, a list of bad gates storing only the input/output values that differ from the fault-free circuit, and can process multiple patterns in a single run. It is faster than deductive simulation but with a more severe run-time memory problem.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup><sup> • </sup><sup>[3](https://www.ee.nthu.edu.tw/~syhuang/testing/ch3.fault_simulation.pdf)</sup>\n\n**Differential** fault simulation (DSIM) simulates the good machine and each faulty machine separately, one after another, reprocessing only each machine's differences from the previously simulated machine, which dramatically reduces memory requirements; it ran 3 to 12 times faster than an existing concurrent fault simulator.<sup>[17](https://link.springer.com/article/10.1007/BF00134011)</sup>\n\n**PPSFP** (parallel-pattern single-fault propagation) packs w test patterns into a w-bit word and simulates a single fault at a time for good and faulty circuits, starting from the collapsed fault list and deleting a fault once any pattern in the word detects it. It was applied to transition fault simulation at the [International Test Conference](https://www.edgepedia.org/international-test-conference).<sup>[16](http://digimat.in/nptel/courses/video/117105137/lec14.pdf)</sup><sup> • </sup><sup>[18](https://doi.org/10.1109/tcad.1987.1270316)</sup>\n\n## Applications\n\nFPGA-based fault emulation speeds sequential fault grading using static fault injection (direct configuration change) or dynamic fault injection (control hardware built into the netlist).<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup> The motivation is speed: simulating an RTL description is multiple orders of magnitude slower than actual circuit operation, so even small processors can only be evaluated over very short time intervals.<sup>[19](https://inria.hal.science/hal-01950931/file/fps18.pdf)</sup> Emulation reduces campaign time but requires a fully synthesizable description and added control circuitry whose complexity grows with the number of injectable memory elements.<sup>[19](https://inria.hal.science/hal-01950931/file/fps18.pdf)</sup> On the hardware side, the GPU-based SWIFT switch-level fault simulator processes designs with millions of gates, with worst-case speedups of 7 to 80× over unparallelized logic-level event-driven simulation.<sup>[7](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2018/TCAD_SchneW2018.pdf)</sup> EPICS combines loop fusion with event traversal and strongly-connected-component-specialized algorithms for large industrial sequential circuits, achieving a 5.94× speedup over a state-of-the-art commercial tool at the same fault coverage; its motivation is that [ISO 26262](https://www.edgepedia.org/iso-26262) mandates high diagnostic coverage requiring extensive gate-level fault simulation.<sup>[8](https://dl.acm.org/doi/10.1109/DAC63849.2025.11132928)</sup>\n\n## Limitations and alternatives\n\n**Fault-model mismatch.** The stuck-at model covers nearly 64% of CMOS defects, so a 100% stuck-at coverage number says little about the rest.<sup>[4](https://pld.ttu.ee/~raiub/BOOK/Ch_3/papers/Ch31_Fault%20simulation%20and%20fault%20injection%20technology%20based%20on%20SystemC_r.pdf)</sup>\n\n**X-state pessimism.** Classic n-valued algorithms such as PPSFP and concurrent simulation pessimistically underestimate coverage when unknowns propagate. A SAT-based exact algorithm increased computed coverage on c7552 by up to 14.2% over 3-valued simulation, and compared with approximate hybrid simulation up to 30% additional faults were actually detectable.<sup>[6](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2012/ETS_HilleKWB2012.pdf)</sup>\n\n**Redundancy.** An undetectable stuck fault makes a combinational circuit redundant, allowing gate simplification, and multiple faults can mask one another, including circular masking.<sup>[10](https://pld.ttu.ee/diagnostika/theory/fault.html)</sup> Efficient fault simulators handling IDDQ, path-delay, or crosstalk fault models remain a recognized gap.<sup>[20](https://s2.smu.edu/~mitch/ftp_dir/pubs/mwscas05.pdf)</sup>\n\nApproximations trade accuracy for speed: critical path tracing marks sensitive inputs and identifies critical lines by backward traversal, running in \\( O(G) \\) for fanout-free circuits, but suffers from stem criticality anomalies and multiple-path sensitization; it was published by Miron Abramovici, P. R. Menon, and David T. Miller as an alternative to fault simulation.<sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup><sup> • </sup><sup>[21](https://doi.org/10.1109/mdt.1984.5005582)</sup> STAFAN (statistical fault analysis), by Sunil Jain and Vishwani Agrawal, computes detection probability from logic simulation alone, e.g. \\( d_{l} = C_{1}(l) \\cdot O(l) \\) for a stuck-at-0 on line \\( l \\), with observability computed backwards from primary outputs.<sup>[22](https://doi.org/10.1109/mdt.1985.294683)</sup><sup> • </sup><sup>[1](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)</sup>\n\n## References\n\n1. [Testing Digital Systems I, Fault Simulation (lecture notes, M. Tahoori, KIT)](https://cdnc.itec.kit.edu/downloads/06_Fault_Simulation.pdf)\n2. [CH3 Fault Simulation (Arnaud Virazel, LIRMM)](https://www.lirmm.fr/~virazel/COURS/M2%20-%20HAE926E/Lecture/CH3%20Fault%20Simulation.pdf)\n3. [Ch3 Fault Simulation (S.-Y. Huang, NTHU)](https://www.ee.nthu.edu.tw/~syhuang/testing/ch3.fault_simulation.pdf)\n4. [Fault simulation and fault injection technology based on SystemC (book chapter)](https://pld.ttu.ee/~raiub/BOOK/Ch_3/papers/Ch31_Fault%20simulation%20and%20fault%20injection%20technology%20based%20on%20SystemC_r.pdf)\n5. [The ISCAS '85 benchmark circuits and netlist format (David Bryan, MCNC, 1988)](https://ddd.fit.cvut.cz/www/prj/Benchmarks/iscas85.pdf)\n6. [Exact Stuck-at Fault Classification in the Presence of Unknowns (Hillebrecht et al., ETS 2012)](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2012/ETS_HilleKWB2012.pdf)\n7. [SWIFT: Switch Level Fault Simulation on GPUs (IEEE TCAD 2018)](https://www.iti.uni-stuttgart.de/fileadmin/rami/files/publications/2018/TCAD_SchneW2018.pdf)\n8. [EPICS: Efficient Parallel Pattern Fault Simulation for Sequential Circuits via Strongly Connected Components (DAC 2025)](https://dl.acm.org/doi/10.1109/DAC63849.2025.11132928)\n9. [MetaFI: model-driven simulator-independent fault simulation framework (arXiv 2022)](https://arxiv.org/pdf/2204.13183)\n10. [Fault Modeling and Simulation (Tallinn University of Technology theory text)](https://pld.ttu.ee/diagnostika/theory/fault.html)\n11. [Fault Simulation Using Irsim (Arturo Salz, Stanford, 1993)](http://opencircuitdesign.com/irsim/archive/fsim.pdf)\n12. [Sundaram Seshu (1965). On an Improved Diagnosis Program. IEEE Transactions on Electronic Computers.](https://doi.org/10.1109/pgec.1965.264063)\n13. [Fred H. Hardie, Robert J. Suhocki (1967). Design and Use of Fault Simulation for Saturn Computer Design. IEEE Transactions on Electronic Computers.](https://doi.org/10.1109/pgec.1967.264644)\n14. [D.B. Armstrong (1972). A Deductive Method for Simulating Faults in Logic Circuits. IEEE Transactions on Computers.](https://doi.org/10.1109/t-c.1972.223542)\n15. [E. G. Ulrich, T. Baker (1974). Concurrent simulation of nearly identical digital networks. Computer.](https://doi.org/10.1109/mc.1974.6323496)\n16. [Digital VLSI Testing, Lecture 14: Logic and Fault Simulation (S. Chattopadhyay, IIT Kharagpur, NPTEL)](http://digimat.in/nptel/courses/video/117105137/lec14.pdf)\n17. [Differential fault simulation for sequential circuits (Cheng & Yu, Journal of Electronic Testing 1:7-13, 1990)](https://link.springer.com/article/10.1007/BF00134011)\n18. [Accelerated Fault Simulation and Fault Grading in Combinational Circuits (Antreich & Schulz, IEEE TCAD 1987), record page](https://doi.org/10.1109/tcad.1987.1270316)\n19. [Fault Injection survey (FPS 2018, INRIA HAL)](https://inria.hal.science/hal-01950931/file/fps18.pdf)\n20. [A Survey and Comparison of Digital Logic Simulators (MWSCAS 2005)](https://s2.smu.edu/~mitch/ftp_dir/pubs/mwscas05.pdf)\n21. [Miron Abramovici, P. R. Menon, David T. Miller (1984). Critical Path Tracing: An Alternative to Fault Simulation. IEEE Design & Test of Computers.](https://doi.org/10.1109/mdt.1984.5005582)\n22. [Sunil Jain, Vishwani Agrawal (1985). Statistical Fault Analysis. IEEE Design & Test of Computers.](https://doi.org/10.1109/mdt.1985.294683)\n\n---\n*Topic: Encyclopedia › Technology and the built world › Engineering and manufacturing › Computer-aided engineering and EDA*\n\n*Initially written Sep 29, 2026 · Reviewed: Sep 30, 2026 · Edited: Sep 30, 2026 · Last review: Sep 30, 2026*\n\n*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*\n\nLicense: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license\n",
 "same_as": [
  "https://s2.smu.edu/~mitch/ftp_dir/pubs/mwscas05.pdf"
 ],
 "url": "https://www.edgepedia.org/fault-simulation",
 "markdown_url": "https://www.edgepedia.org/fault-simulation.md",
 "license": {
  "name": "Edgepedia Community License 1.0",
  "url": "https://www.edgepedia.org/edgepedia/license",
  "summary": "Free with credit, commercial use included. AI training is open to everyone. For other uses, organizations over USD 100M in revenue or 100M monthly users license separately.",
  "spdx": "LicenseRef-Edgepedia-Community-1.0"
 },
 "credit": "\"Fault simulation\", Edgepedia (EdgeChat), https://www.edgepedia.org/fault-simulation. Edgepedia Community License 1.0.",
 "credit_md": "\"[Fault simulation](https://www.edgepedia.org/fault-simulation)\", Edgepedia (EdgeChat), [https://www.edgepedia.org/fault-simulation](https://www.edgepedia.org/fault-simulation). [Edgepedia Community License 1.0](https://www.edgepedia.org/edgepedia/license).",
 "credit_html": "\"<a href=\"https://www.edgepedia.org/fault-simulation\">Fault simulation</a>\", Edgepedia (EdgeChat), <a href=\"https://www.edgepedia.org/fault-simulation\">https://www.edgepedia.org/fault-simulation</a>. <a href=\"https://www.edgepedia.org/edgepedia/license\">Edgepedia Community License 1.0</a>.",
 "speakable": "Fault simulation is a digital circuit testing method that injects modeled faults, usually stuck-at, into a circuit design and simulates its behavior to measure how well test vectors detect them."
}