<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.2 20190208//EN" "http://jats.nlm.nih.gov/publishing/1.2/JATS-journalpublishing1.dtd"><article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" article-type="methods-article" dtd-version="1.2" xml:lang="en">
    <front>
        <journal-meta>
            <journal-id journal-id-type="pmc">F1000Research</journal-id>
            <journal-title-group>
                <journal-title>F1000Research</journal-title>
            </journal-title-group>
            <issn pub-type="epub">2046-1402</issn>
            <publisher>
                <publisher-name>F1000 Research Limited</publisher-name>
                <publisher-loc>London, UK</publisher-loc>
            </publisher>
        </journal-meta>
        <article-meta>
            <article-id pub-id-type="doi">10.12688/f1000research.13349.2</article-id>
            <article-categories>
                <subj-group subj-group-type="heading">
                    <subject>Method Article</subject>
                </subj-group>
                <subj-group>
                    <subject>Articles</subject>
                    <subj-group>
                        <subject>Experimental Biophysical Methods</subject>
                    </subj-group>
                </subj-group>
            </article-categories>
            <title-group>
                <article-title>Fast P(RMNE): Fast forensic DNA probability of random man not excluded calculation</article-title>
                <fn-group content-type="pub-status">
                    <fn>
                        <p>[version 2; peer review: peer review discontinued]</p>
                    </fn>
                </fn-group>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author" corresp="yes">
                    <name>
                        <surname>Ricke</surname>
                        <given-names>Darrell O.</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Conceptualization</role>
                    <role content-type="http://credit.niso.org/">Data Curation</role>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Funding Acquisition</role>
                    <role content-type="http://credit.niso.org/">Investigation</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Project Administration</role>
                    <role content-type="http://credit.niso.org/">Resources</role>
                    <role content-type="http://credit.niso.org/">Software</role>
                    <role content-type="http://credit.niso.org/">Supervision</role>
                    <role content-type="http://credit.niso.org/">Validation</role>
                    <role content-type="http://credit.niso.org/">Visualization</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Original Draft Preparation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <uri content-type="orcid">https://orcid.org/0000-0002-2842-2809</uri>
                    <xref ref-type="corresp" rid="c1">a</xref>
                    <xref ref-type="aff" rid="a1">1</xref>
                </contrib>
                <contrib contrib-type="author" corresp="no">
                    <name>
                        <surname>Schwartz</surname>
                        <given-names>Steven</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Investigation</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Software</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <xref ref-type="aff" rid="a1">1</xref>
                </contrib>
                <aff id="a1">
                    <label>1</label>Bioengineering Systems &amp; Technologies, Massachusetts Institute of Technology Lincoln Laboratory, Lexington, MA, 02420-9108, USA</aff>
            </contrib-group>
            <author-notes>
                <corresp id="c1">
                    <label>a</label>
                    <email xlink:href="mailto:Darrell.Ricke@ll.mit.edu">Darrell.Ricke@ll.mit.edu</email>
                </corresp>
                <fn fn-type="conflict">
                    <p>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>31</day>
                <month>10</month>
                <year>2018</year>
            </pub-date>
            <pub-date pub-type="collection">
                <year>2017</year>
            </pub-date>
            <volume>6</volume>
            <elocation-id>2154</elocation-id>
            <history>
                <date date-type="accepted">
                    <day>22</day>
                    <month>10</month>
                    <year>2018</year>
                </date>
            </history>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2018 Ricke DO and Schwartz S</copyright-statement>
                <copyright-year>2018</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access article distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <self-uri content-type="pdf" xlink:href="https://f1000research.com/articles/6-2154/pdf"/>
            <abstract>
                <p>High throughput sequencing (HTS) of DNA forensic samples is expanding from the sizing of short tandem repeats (STRs) to massively parallel sequencing (MPS). HTS panels are expanding from the FBI 20 core Combined DNA Index System (CODIS) loci to include SNPs. The calculation of random man not excluded, P(RMNE), is used in DNA mixture analysis to estimate the probability that a person is present in a DNA mixture. This calculation encounters calculation artifacts with expansion to larger panel sizes. Increasing the floating-point precision of the calculations allows for increased panel sizes but with a corresponding increase in computation time. The Taylor series higher precision libraries used fail on some input data sets leading to algorithm unreliability. Herein, a new formula is introduced for calculating P(RMNE) that scales to larger SNP panel sizes while being computationally efficient (patent pending).</p>
            </abstract>
            <kwd-group kwd-group-type="author">
                <kwd>DNA forensic</kwd>
                <kwd>identification</kwd>
                <kwd>mixture analysis</kwd>
                <kwd>probability of random man not excluded</kwd>
            </kwd-group>
            <funding-group>
                <award-group id="fund-1">
                    <funding-source>Assistant Secretary of Defense for Research &amp; Engineering</funding-source>
                    <award-id>FA8721-05-C-002</award-id>
                </award-group>
                <funding-statement>This work is sponsored by the Assistant Secretary of Defense for Research &amp; Engineering under Air Force Contract #FA8721-05-C-002. Opinions, interpretations, recommendations and conclusions are those of the author and are not necessarily endorsed by the United States Government.</funding-statement>
                <funding-statement>
                    <italic>The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.</italic>
                </funding-statement>
            </funding-group>
        </article-meta>
        <notes>
            <sec sec-type="version-changes">
                <label>Revised</label>
                <title>Amendments from Version 1</title>
                <p>An adjustment factor for linkage disequilibrium has been added to the Fast P(RMNE) formulas. Figures 1-3 have been revised.</p>
            </sec>
        </notes>
    </front>
    <body>
        <sec sec-type="intro">
            <title>Introduction</title>
            <p>High throughput sequencing (HTS) of DNA single nucleotide polymorphism (SNP) panels have significant advantages for analysis of DNA mixtures and trace DNA profiles compared to sizing STRs. Analysis of mixtures by sized STRs is limited to mixtures of two individuals within DNA ratios of 1:1 to 1:10. In contrast, SNP-based methods offer the potential to analyze complex mixtures of 15 contributors or more
                <sup>
                    <xref ref-type="bibr" rid="ref-2">2</xref>
                </sup>. The current method of calculating the significance of a match between a SNP DNA mixture and a reference profile is the random man not excluded P(RMNE) calculation
                <sup>
                    <xref ref-type="bibr" rid="ref-2">2</xref>
                </sup> for forensic applications. However, performance and precision issues are being observed with current implementations of the P(RMNE) calculations
                <sup>
                    <xref ref-type="bibr" rid="ref-2">2</xref>
                </sup>. To address the calculation artifacts and performance issues, a novel P(RMNE) calculation method is presented.</p>
        </sec>
        <sec sec-type="methods">
            <title>Methods</title>
            <sec>
                <title>A. Taylor series P(RMNE) implementation</title>
                <p>Most SNPs have just two alleles. The most common SNP allele is named the major allele. The other SNP allele(s) are named the minor allele(s). In a mixture profile, the minor allele ratio is calculated as the ratio of minor allele reads divided by the total number of reads. Methods for calculating P(RMNE) have been presented that focus on the mixture SNP loci with no called minor alleles in a mixture profile (e.g., SNPs with minor allele ratios &lt;= 0.001 threshold)
                    <sup>
                        <xref ref-type="bibr" rid="ref-2">2</xref>,
                        <xref ref-type="bibr" rid="ref-3">3</xref>
                    </sup>. The P(RMNE) method described by Isaacson 
                    <italic toggle="yes">et al.</italic>
                    <sup>
                        <xref ref-type="bibr" rid="ref-2">2</xref>
                    </sup> was implemented in Sherlock&#x2019;s Toolkit
                    <sup>
                        <xref ref-type="bibr" rid="ref-4">4</xref>
                    </sup>. This formulation enabled P(RMNE) calculations with a small number of dropped alleles for reference profiles compared to mixture profiles. For larger DNA panels, an issue with precision was observed with the Sherlock&#x2019;s Toolkit implementation, see 
                    <xref ref-type="fig" rid="f1">Figure 1</xref>. This method was re-implemented in Java with higher precision libraries in an effort to eliminate the calculation artifacts observed (
                    <xref ref-type="fig" rid="f1">Figure 1</xref>). The Discrete Fourier Transform-Characteristic Function (DFT-CF) method was implemented with Taylor series approximation of trigonometric functions, named Taylor-32 for 32-bit floating point and Taylor-64 for 64-bit floating point calculations.</p>
                <fig fig-type="figure" id="f1" orientation="portrait" position="float">
                    <label>Figure 1. </label>
                    <caption>
                        <title>P(RMNE) Results for 1,000 SNP Panel; D&#x2019; sum is 184 and N-E is 816.</title>
                    </caption>
                    <graphic orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/18329/26e1df8d-c795-4c2d-a4df-efdf1edc1f3f_figure1.gif"/>
                </fig>
            </sec>
            <sec>
                <title>B. Mathar&#x2019;s BigDecimalMath P(RMNE) calculation</title>
                <p>The Taylor series library functions were replaced with functions from Mathar&#x2019;s BigDecimalMath class (
                    <ext-link ext-link-type="uri" xlink:href="http://www.mpia.de/~mathar/progs/jdocs/org/nevec/rjm/BigDecimalMath.html">http://www.mpia.de/~mathar/progs/jdocs/org/nevec/rjm/BigDecimalMath.html</ext-link>) to address issues detected with the Taylor-32 and Taylor-64 methods using both 64-bit and 152-bit precision.</p>
            </sec>
            <sec>
                <title>C. Linkage Disequilibrium</title>
                <p>Adjacent SNPs may be in linkage disequilibrium such that the alleles of the SNPs have non-random association with each other. The linkage disequilibrium between two SNP alleles is measured by D&#x2019; with values between 0 (unlinked) to 1 (fully linked). An adjustment factor for linkage disequilibrium is applied for SNPs ordered by chromosome position. 
                    <xref ref-type="other" rid="e1">Equation (1)</xref> represents the sum of linkage disequilibrium (LD) for the N SNPs with major alleles in a mixture. Adjusting the count of mixture SNPs with major alleles (N) by (E) approximates the number of unlinked SNPs with major alleles in a mixture.</p>
                <p>
                    <disp-formula id="e1">
                        <mml:math display="block" id="math20">
                            <mml:mrow>
                                <mml:mi>E</mml:mi>
                                <mml:mo>=</mml:mo>
                                <mml:mstyle displaystyle="true">
                                    <mml:munderover>
                                        <mml:mo>&#x2211;</mml:mo>
                                        <mml:mrow>
                                            <mml:mi>i</mml:mi>
                                            <mml:mo>=</mml:mo>
                                            <mml:mn>2</mml:mn>
                                        </mml:mrow>
                                        <mml:mi>N</mml:mi>
                                    </mml:munderover>
                                    <mml:mrow>
                                        <mml:msup>
                                            <mml:mi>D</mml:mi>
                                            <mml:mo>&#x2032;</mml:mo>
                                        </mml:msup>
                                        <mml:mo stretchy="false">(</mml:mo>
                                        <mml:mi>S</mml:mi>
                                        <mml:mi>N</mml:mi>
                                        <mml:msub>
                                            <mml:mi>P</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>i</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>1</mml:mn>
                                            </mml:mrow>
                                        </mml:msub>
                                        <mml:mo>:</mml:mo>
                                        <mml:mi>S</mml:mi>
                                        <mml:mi>N</mml:mi>
                                        <mml:msub>
                                            <mml:mi>P</mml:mi>
                                            <mml:mi>i</mml:mi>
                                        </mml:msub>
                                        <mml:mo stretchy="false">)</mml:mo>
                                    </mml:mrow>
                                </mml:mstyle>
                            </mml:mrow>
                        </mml:math>
                    </disp-formula>
                </p>
                <p>
                    <disp-formula id="e2">
                        <mml:math display="block" id="math1">
                            <mml:mrow>
                                <mml:mtable columnalign="left">
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mi>i</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:mrow>
                                                    <mml:mo>(</mml:mo>
                                                    <mml:mrow>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>n</mml:mi>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>i</mml:mi>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mrow>
                                                    <mml:mo>)</mml:mo>
                                                </mml:mrow>
                                                <mml:mo>=</mml:mo>
                                                <mml:mfrac>
                                                    <mml:mrow>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>!</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mrow>
                                                        <mml:mi>i</mml:mi>
                                                        <mml:mo>!</mml:mo>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>i</mml:mi>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                        <mml:mo>!</mml:mo>
                                                    </mml:mrow>
                                                </mml:mfrac>
                                                <mml:mo>=</mml:mo>
                                                <mml:mfrac>
                                                    <mml:mrow>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                        <mml:mo>&#x2026;</mml:mo>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>i</mml:mi>
                                                        <mml:mo>+</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mrow>
                                                        <mml:mi>i</mml:mi>
                                                        <mml:mo>!</mml:mo>
                                                    </mml:mrow>
                                                </mml:mfrac>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">2</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mi>L</mml:mi>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">3</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn>0</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mn>0</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mn>0</mml:mn>
                                                </mml:msup>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">4</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn>1</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mn>1</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mn>1</mml:mn>
                                                </mml:msup>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mo>(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>K</mml:mi>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">5</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mi>L</mml:mi>
                                                </mml:msup>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mfrac>
                                                    <mml:mrow>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                        <mml:mo>&#x2026;</mml:mo>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo>+</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mrow>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo>!</mml:mo>
                                                    </mml:mrow>
                                                </mml:mfrac>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mi>L</mml:mi>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">6</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr columnalign="left">
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo>+</mml:mo>
                                                <mml:mn>1</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>=</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>q</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>2</mml:mn>
                                                        <mml:mo>(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>)</mml:mo>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>C</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>m</mml:mi>
                                                <mml:mi>b</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mi>a</mml:mi>
                                                <mml:mi>t</mml:mi>
                                                <mml:mi>i</mml:mi>
                                                <mml:mi>o</mml:mi>
                                                <mml:mi>n</mml:mi>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>N</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mi>E</mml:mi>
                                                <mml:mo>,</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo>+</mml:mo>
                                                <mml:mn>1</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:msup>
                                                    <mml:mi>K</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo>+</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:mrow>
                                                </mml:msup>
                                                <mml:mo>=</mml:mo>
                                                <mml:msub>
                                                    <mml:mi>P</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mi>R</mml:mi>
                                                        <mml:mi>M</mml:mi>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mi>E</mml:mi>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo stretchy="false">)</mml:mo>
                                                <mml:mo>*</mml:mo>
                                                <mml:mfrac>
                                                    <mml:mrow>
                                                        <mml:mo stretchy="false">(</mml:mo>
                                                        <mml:mi>N</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>E</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo stretchy="false">)</mml:mo>
                                                    </mml:mrow>
                                                    <mml:mrow>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo>+</mml:mo>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:mrow>
                                                </mml:mfrac>
                                                <mml:mo>*</mml:mo>
                                                <mml:mi>K</mml:mi>
                                            </mml:mrow>
                                        </mml:mtd>
                                        <mml:mtd columnalign="left">
                                            <mml:mrow>
                                                <mml:mo stretchy="false">(</mml:mo>
                                                <mml:mn mathvariant="bold">7</mml:mn>
                                                <mml:mo stretchy="false">)</mml:mo>
                                            </mml:mrow>
                                        </mml:mtd>
                                    </mml:mtr>
                                </mml:mtable>
                            </mml:mrow>
                        </mml:math>
                    </disp-formula>
                </p>
            </sec>
            <sec>
                <title>D. Fast P(RMNE)</title>
                <p>An alternative to the DFT-CF P(RMNE) method was implemented. A mixture will have N loci with no called minor alleles. Let p be the average minor allele ratio at these mixture loci. Let q be defined as 1 &#x2013; p such that p + q = 1. SNP panels can be optimized for DNA mixture analysis
                    <sup>
                        <xref ref-type="bibr" rid="ref-2">2</xref>,
                        <xref ref-type="bibr" rid="ref-3">3</xref>
                    </sup>; the average of the SNP minor allele ratios used for a P(RMNE) calculation can be used to approximate large numbers of individual SNPs with similar minor allele ratios. For an individual with two alleles at a SNP loci the probability for these alleles can be represented as (p+q)
                    <sup>2</sup> = p
                    <sup>2</sup> + 2pq + q
                    <sup>2</sup> = 1. A perfect reference match to a mixture has major:major (MM) alleles at every locus with no called minor alleles in the mixture profile. Mismatches are defined as reference loci with major:minor (mM) or minor:minor (mm) at these mixture loci with no called minor alleles (MM). The number of mismatches is defined as L between a reference and a mixture. Let K be (1 &#x2013; q
                    <sup>2</sup>)/q
                    <sup>2</sup> represent the ratio of transition from MM to non-MM (i.e., mM or mm). Let Combination represent the standard statistics combination operation for representing possible SNP loci that mismatch between a reference and a mixture 
                    <xref ref-type="other" rid="e1">(1)</xref>. P
                    <sub>RMNE</sub>(L) can be estimated by the term for no mismatches, q
                    <sup>2(N-E)</sup>, times the possible combinations of L mismatches, Combination(N-E, L), times the transition term K
                    <sup>L</sup> 
                    <xref ref-type="other" rid="e2">(2)</xref>
                    <sup>
                        <xref ref-type="bibr" rid="ref-2">2</xref>
                    </sup>. 
                    <xref ref-type="other" rid="e2">Equation (3)</xref> illustrates the calculation for no mismatches (L=0), and 
                    <xref ref-type="other" rid="e2">(4)</xref> for one mismatch (L=1). Consecutive terms can be calculated efficiently for multiple L values as illustrated by 
                    <xref ref-type="other" rid="e2">(5)</xref> and 
                    <xref ref-type="other" rid="e2">(6)</xref>. This optimization has the additional benefit of multiplying a large value, (N-E-L)/(L+1), with a small value, K, where calculating (N-E)!/L!(N-E-L)! by itself can stress the precision capability of an implementation for large values for N-E and L. 
                    <xref ref-type="other" rid="e2">Equation (7)</xref> represents the P(RMNE) calculation for 0 to L mismatches.</p>
                <p>
                    <disp-formula id="e8">
                        <mml:math display="block" id="math30">
                            <mml:mrow>
                                <mml:msub>
                                    <mml:mi>P</mml:mi>
                                    <mml:mrow>
                                        <mml:mi>R</mml:mi>
                                        <mml:mi>M</mml:mi>
                                        <mml:mi>N</mml:mi>
                                        <mml:mi>E</mml:mi>
                                    </mml:mrow>
                                </mml:msub>
                                <mml:mo stretchy="false">(</mml:mo>
                                <mml:mn>0</mml:mn>
                                <mml:mspace width="0.2em"/>
                                <mml:mi>t</mml:mi>
                                <mml:mi>o</mml:mi>
                                <mml:mspace width="0.2em"/>
                                <mml:mi>L</mml:mi>
                                <mml:mo stretchy="false">)</mml:mo>
                                <mml:mo>=</mml:mo>
                                <mml:mstyle displaystyle="true">
                                    <mml:munderover>
                                        <mml:mo>&#x2211;</mml:mo>
                                        <mml:mrow>
                                            <mml:mi>i</mml:mi>
                                            <mml:mo>=</mml:mo>
                                            <mml:mn>0</mml:mn>
                                        </mml:mrow>
                                        <mml:mi>L</mml:mi>
                                    </mml:munderover>
                                    <mml:mrow>
                                        <mml:msub>
                                            <mml:mi>P</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>R</mml:mi>
                                                <mml:mi>M</mml:mi>
                                                <mml:mi>N</mml:mi>
                                                <mml:mi>E</mml:mi>
                                            </mml:mrow>
                                        </mml:msub>
                                        <mml:mo stretchy="false">(</mml:mo>
                                        <mml:mi>i</mml:mi>
                                        <mml:mo stretchy="false">)</mml:mo>
                                    </mml:mrow>
                                </mml:mstyle>
                            </mml:mrow>
                            <mml:mrow>
                                <mml:mo>&#x2009;</mml:mo>
                                <mml:mo>&#x2009;</mml:mo>
                                <mml:mo>&#x2009;</mml:mo>
                                <mml:mo>&#x2009;</mml:mo>
                                <mml:mo>&#x2009;</mml:mo>
                                <mml:mo stretchy="false">(</mml:mo>
                                <mml:mn mathvariant="bold">8</mml:mn>
                                <mml:mo stretchy="false">)</mml:mo>
                            </mml:mrow>
                        </mml:math>
                    </disp-formula>
</p>
            </sec>
            <sec>
                <title>E. Benchmark Systems</title>
                <p>Timing for the Sherlock&#x2019;s Toolkit (Python), Taylor, and Mathar algorithms (Java) were run on an Intel Xeon E5-2609 v2 2.5 GHz dual CPU system with 32 GB RAM. Fast P(RMNE) (Ruby) was run on a MacBook Pro laptop with 2.8 GHz Intel i7, 16 GB 1600 MHz DDR3 RAM, 750 GB SSD hard drive.</p>
            </sec>
        </sec>
        <sec sec-type="results">
            <title>Results</title>
            <p>The calculated P(RMNE) values for Sherlock&#x2019;s Toolkit and Taylor-32 both have calculation artifacts/precision issues compared to the Taylor-64 method for a panel of 1,000 SNPs in 
                <xref ref-type="fig" rid="f1">Figure 1</xref>. The Sherlock&#x2019;s Toolkit P(RMNE) values start to deviate from actual P(RMNE) values with 36 or less mismatches while the Taylor-32 deviates at 5 or less mismatches. When the panel size is increased to 3,000 SNPs, the Taylor methods are unable to calculate P(RMNE) values. For higher precision, the Mathar BigDecimalMath library was used with 64-bit and 152-bit precision. Calculation artifacts are seen for the Mathar 64-bit method for the 3,000 SNP panel (
                <xref ref-type="fig" rid="f2">Figure 2</xref>) and the Mathar 152-bit method for the 4,000 SNP panel (
                <xref ref-type="fig" rid="f3">Figure 3</xref>). The root mean square error (RMSE) between Fast P(RMNE) and Mathar-152 was 2.2e-41. This calculation excluded the Mathar 152-bit calculation artifacts between 0 and 19 mismatches. Algorithm timing results are shown in 
                <xref ref-type="fig" rid="f4">Figure 4</xref>. For the 1,000 SNP panel, the Taylor 64-bit algorithm runs in 142 s and the Taylor 152-bit in 1,017 s. The Taylor methods did not complete for the larger panel sizes.</p>
            <fig fig-type="figure" id="f2" orientation="portrait" position="float">
                <label>Figure 2. </label>
                <caption>
                    <title>P(RMNE) Results for 3,000 SNP Panel; D&#x2019; sum is 860 and N-E is 2,140.</title>
                </caption>
                <graphic orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/18329/26e1df8d-c795-4c2d-a4df-efdf1edc1f3f_figure2.gif"/>
            </fig>
            <fig fig-type="figure" id="f3" orientation="portrait" position="float">
                <label>Figure 3. </label>
                <caption>
                    <title>P(RMNE) Results for 4,000 SNP Panel; D&#x2019; sum is 1,269 and N-E is 2,731.</title>
                </caption>
                <graphic orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/18329/26e1df8d-c795-4c2d-a4df-efdf1edc1f3f_figure3.gif"/>
            </fig>
            <fig fig-type="figure" id="f4" orientation="portrait" position="float">
                <label>Figure 4. </label>
                <caption>
                    <title>P(RMNE) Algorithm Runtimes.</title>
                </caption>
                <graphic orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/18329/26e1df8d-c795-4c2d-a4df-efdf1edc1f3f_figure4.gif"/>
            </fig>
        </sec>
        <sec sec-type="discussion">
            <title>Discussion</title>
            <p>A calculation artifact was observed for some datasets with the P(RMNE) method implemented in Sherlock&#x2019;s Toolkit, see 
                <xref ref-type="fig" rid="f1">Figure 1</xref>. Shifting to higher precision libraries, improved the results for smaller SNP panels, but calculation artifacts appear for larger SNP panels, see 
                <xref ref-type="fig" rid="f2">Figure 2</xref> and 
                <xref ref-type="fig" rid="f3">Figure 3</xref>. Also, the Taylor methods crash with larger panels or return no results. The Mathar BigDecimalMath libraries work better than the Taylor method library, but calculation artifacts are again observed for the 4,000 SNP panels for both Mathar-64 and Mathar-152 methods. The runtimes for these higher precision methods as increased beyond what was desirable for rapid forensic sample analysis. The Fast P(RMNE) method addresses both the calculation artifact issue (
                <xref ref-type="fig" rid="f3">Figure 3</xref>) and the runtime issue (
                <xref ref-type="fig" rid="f4">Figure 4</xref>). 
                <xref ref-type="other" rid="e2">Equation (6)</xref> enables the rapid calculation of P(RMNE) for a series of possible mismatches in a fraction of a second on any modern CPU processor. Adjusting for linkage disequilibrium in SNP panels provides an improved estimate of P(RMNE).</p>
        </sec>
        <sec>
            <title>Data availability</title>
            <p> The calculations and SNP panel data for each method and SNP panels used are included in Ricke, Darrell, 2017, &#x201c;Fast P(RMNE) Data&#x201d;, doi: 
                <ext-link ext-link-type="uri" xlink:href="http://dx.doi.org/10.7910/DVN/ZUN3GD">10.7910/DVN/ZUN3GD</ext-link>, Harvard Dataverse.</p>
        </sec>
    </body>
    <back>
        <ack>
            <title>Acknowledgment</title>
            <p>We would like to thank Nancy DeLosa for assisting with the Taylor and Mathar methods implementations.</p>
        </ack>
        <ref-list>
            <ref id="ref-1">
                <label>1</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">
				
                        <name name-style="western">
                            <surname>Ricke</surname>
                            <given-names>DO</given-names>
                        </name>
				</person-group>,
                    <collab>Inventor, Massachusetts Institute of Technology assignee</collab>:
                    <article-title>DNA Mixtures from One or More Sources and Methods of Building Individual Profiles Therefrom.</article-title>US patent pending 62/534,590,<year>2017</year>.</mixed-citation>
            </ref>
            <ref id="ref-2">
                <label>2</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">
				
                        <name name-style="western">
                            <surname>Isaacson</surname>
                            <given-names>J</given-names>
                        </name>
				
                        <name name-style="western">
                            <surname>Schwoebel</surname>
                            <given-names>E</given-names>
                        </name>
				
                        <name name-style="western">
                            <surname>Shcherbina</surname>
                            <given-names>A</given-names>
                        </name>
				
                        <etal/>
			</person-group>:
                    <article-title>Robust detection of individual forensic profiles in DNA mixtures.</article-title>
                    <source>
				
                        <italic toggle="yes">Forensic Sci Int Genet.</italic>
			</source>
                    <year>2015</year>;<volume>14</volume>:<fpage>31</fpage>&#x2013;<lpage>37</lpage>.
                    <pub-id pub-id-type="pmid">25280378</pub-id>
                    <pub-id pub-id-type="doi">10.1016/j.fsigen.2014.09.003</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref-3">
                <label>3</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">
				
                        <name name-style="western">
                            <surname>Voskoboinik</surname>
                            <given-names>L</given-names>
                        </name>
				
                        <name name-style="western">
                            <surname>Darvasi</surname>
                            <given-names>A</given-names>
                        </name>
			</person-group>:
                    <article-title>Forensic identification of an individual in complex DNA mixtures.</article-title>
                    <source>
				
                        <italic toggle="yes">Forensic Sci Int Genet.</italic>
			</source>
                    <year>2011</year>;<volume>5</volume>(<issue>5</issue>):<fpage>428</fpage>&#x2013;<lpage>435</lpage>.
                    <pub-id pub-id-type="pmid">20888313</pub-id>
                    <pub-id pub-id-type="doi">10.1016/j.fsigen.2010.09.002</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref-4">
                <label>4</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">
				
                        <name name-style="western">
                            <surname>Ricke</surname>
                            <given-names>D</given-names>
                        </name>
				
                        <name name-style="western">
                            <surname>Shcherbina</surname>
                            <given-names>A</given-names>
                        </name>
				
                        <name name-style="western">
                            <surname>Chiu</surname>
                            <given-names>N</given-names>
                        </name>
				
                        <etal/>
			</person-group>:
                    <article-title>Sherlock's Toolkit: A forensic DNA analysis system.</article-title>
                    <source>
			
                        <italic toggle="yes">Technologies for Homeland Security (HST), 2015 IEEE International Symposium on,</italic>
			</source>
                    <year>2015</year>.
                    <pub-id pub-id-type="doi">10.1109/THS.2015.7225306</pub-id>
                </mixed-citation>
            </ref>
        </ref-list>
    </back>
</article>
