Jean — Molecular Biology & Genomics

SALI activity cliffs (Guha & Van Drie 2008) in a list of small molecules with one activity each: every pair scored as the activity difference over one minus the Tanimoto similarity of RDKit path fingerprints, steepest first; identical fingerprints with different activities score Infinity. Indices are 0-based.

Replace a Sanger read's own base calls with TraceTuner's, on the trace that is open, so the rest of the editor works from the re-called read: its sequence, its consensus, its verification against a reference, and every export. The signal is untouched — this is the same electropherogram with a second opinion about where the bases are — and every coordinate already on the read is carried across the peaks it sits on, so a trim window, a hand-corrected call and an annotation all follow. Reports what moved and what could not be placed. Use `call_bases_from_trace` instead to ASK what the re-call says without changing the read.

Pairwise-align ONE sequencing read against a reference and hand on the two gapped rows, so the read can be graded. Needleman-Wunsch with free end gaps and the IUPAC substitution matrix — SeqTrace's aligner, the same call the trace editor makes, so a pipeline and the panel align a read identically. Leave `reference` unset to align against the record this step runs on.

Multiple-sequence alignment over several sequences, under either of TWO engines that answer different questions and neither of which is a fallback for the other. `poa` (partial-order, poapy) aligns into a graph, keeps every path a read took and produces its own consensus row — what a pile of reads over one locus wants. `progressive` (biotite) computes Feng-Doolittle distances, clusters them into a guide tree and merges along it under "once a gap, always a gap" — the classic MSA algorithm, what a FAMILY of homologous genes wants, and what a reader coming from Clustal or MUSCLE expects. Wire many upstream `record`/`sequence` outputs into `sequences`, or name library documents.

Read an alignment window and say how well its reads agree with the reference underneath them, the way the pileup's own bar does: the compared and differing base counts, plus the RefSeq gene models and known dbSNP variants over the same window. The reference is a FASTA in this project or a public UCSC assembly, exactly as the panel offers it. There is no threshold and no verdict: a rate in the tens of percent almost always means the reads were aligned to a different assembly than the one asked for, and when the file declares its own reference length the answer says so as a fact rather than as a judgement.

Read one window of a BAM or SAM in this project: its reads, the depth across it, and what the pairs say about the library — the same window, filters and record cap the pileup draws. Wire `reads` into an alignment or a screen the way the pane's own hand-offs do.

Melt curves to melting temperature, under any of THREE engines that answer different questions and none of which is a fallback for another. `plate` (RDML-Python) normalises, derives twice, calls the peaks of -dF/dT and CLASSIFIES them against the target's expected Tm into per-reaction verdicts — one peak in the window is the product, an extra peak is an artifact or a primer dimer, no peak at all is a reaction that did not amplify; it is the only engine that produces a verdict. `vertex` (MBmca diffQ) fits a quadratic near the extremum and reports its vertex, so the Tm is NOT one of the sampled temperatures — the only sub-grid answer. `curve` (qpcR) does no plate normalisation and gives no verdicts, but reports every melting peak with the AREA under it. Replicate spread travels with all three, because it describes the readings rather than the method.

Say what a genomic region holds in the reference tracks: the genes and RefSeq transcripts it overlaps, which complete coding sequences it CONTAINS (the only case where a residue-level design is honest), the DGV structural variants seen there in control populations with their frequencies, and how much of it lies in segmental duplications and how similar the best paralogue is. Every track answers with its authority, table and retrieval date. Coordinates are 1-based and inclusive, as a person writes chr17:41196312-41277500.

Type the ANTIBODY-ANTIGEN INTERFACE of a deposited complex: which residue of each antibody chain touches which residue of the antigen, how close, and what kind of interaction each pair makes - ionic, polar, weak polar, hydrophobic, aromatic, carbonyl, or a disulfide. The antigen is found rather than named: a protein chain with no immunoglobulin variable domain is the thing being bound. Geometric definitions are CREDO's as Arpeggio implements them, graded contact-for-contact against pdbe-arpeggio. `polar` is the hydrogen-bond criterion WITHOUT the donor angle, because a crystal structure carries no hydrogens; it is the superset an angle test would filter, and no angle-checked hydrogen bond is claimed.

Assign each CDR of an antibody heavy, kappa or lambda variable domain to its canonical structure class: SCALOP's length-independent clusters of known loop conformations (CDR-H1, H2, L1, L2, L3; H3 has no canonical classes). Each loop is scored against every cluster of its length by the cluster's position-specific log-odds; the best score above SCALOP's threshold names the class and its median structure (a PDB chain). Graded against the real SCALOP on every heavy, kappa and lambda chain of ANARCI's PDB benchmark.

Name the CONSTANT region of an antibody chain: which immunoglobulin gene and allele it carries (IGHG1, IGHA2, IGKC, IGLC2 …), and where each IMGT domain sits on it — CH1, the hinge, CH2, CH3, the secretory tail and the membrane exons, or the single C region of a light chain. A domain search says 'a C1-set immunoglobulin domain'; this says which isotype it is. Reads IMGT/GENE-DB's own per-label translations for every species, and is graded against UniProtKB's curated human constant chains and their CH1/hinge/CH2/CH3 regions.

Scan antibody and TCR variable domains for sequence liabilities (Asn deamidation, Asp isomerization, N-glycosylation sequons, Asp-Pro cleavage, Met and Trp oxidation, unpaired or missing conserved cysteines), each placed in its IMGT region so CDR hits can be told from framework ones. Every motif is cited to its source.

Properties of an assembled antibody from its heavy and light chains: molecular weight, isoelectric point, net charge at a pH, and the extinction coefficient and A280 with cysteines reduced and with every pair formed into a cystine, for a Fab (1 heavy + 1 light) or an IgG (2 + 2). Each chain keeps its own termini, so this is not the same as pasting the chains end to end. Graded against Biopython ProtParam over every heavy/light pair of ANARCI's PDB benchmark.

How common each residue of an antibody variable domain is at its IMGT position, and which residues are rarer there than a cut (abYsis's 1% "unusual residue" by default). Two distributions: IMGT's own germline V and J alleles of a species (one count per reference allele), or a bundled Observed Antibody Space repertoire subset (one count per unique expressed sequence; human naive B cells, Jaffe et al. 2022). Graded against independent pandas counts of ANARCI's germline alignments and of every OAS data unit of the subset.

Put the features from a GTF in this project onto the open record. A GTF lists features and their positions and carries no sequence, so this is how one reaches a molecule. It REFUSES unless something says the two are in the same coordinate space: if the file names a genome build and the record names the same one it proceeds; if they name different ones it refuses outright; if either is silent it refuses until you pass coordinates_only, which states that you are applying the intervals as positions in this record's own numbering with no genome correspondence checked. Reports what would not fit rather than trimming it.

Substitute one called ALT allele into a sequence and return the edited bases, the range the edit occupies and the length change. The REF allele is checked against the sequence first and a mismatch REFUSES naming both: applying a call from a different assembly would produce a construct that looks fine and is wrong. Symbolic and breakend alleles are refused for what they are: they name a rearrangement rather than replacement bases.

Turn index sequences into the oligos a synthesiser makes: each index spliced between 5'/3' adapter arms, or onto a PCR primer in either orientation with an optional spacer. Audited for the problems that only exist once tag and oligo are concatenated and that no check of the index alone can see — a homopolymer run across the junction, a 5' tetramer recurring as its reverse complement, and an oligo over the synthesis length guideline.

Stack several CDSs into one contiguous operon, designing a fresh ribosome-binding site in front of each one AGAINST ITS REAL UPSTREAM CONTEXT — which is why the RBS for gene 2 is not the RBS design_rbs would give it in isolation. Returns the assembled sequence, its layout, and each gene's achieved strength.

Run a MULTI-LEVEL assembly plan (DnaCauldron `AssemblyPlan`): several assemblies arranged into dependency levels, where each level's products become parts for the next. Emits the FINAL construct as a record. The plan is DnaCauldron's own spreadsheet shape — one row per construct, `construct_name, part, part, …`.

Assess a small molecule given as SMILES or a molfile: RDKit's descriptors, medchem's drug-likeness rules (Lipinski, Veber, Ghose, Egan, REOS, rule of three, CNS and more) and the papers' own readings where medchem departs from them, with every bound and this molecule's value, a structural-alert screen (PAINS, Brenk, NIH, ZINC and ChEMBL's seven curated sets) with the matched atoms, the molecular formula with its masses and natural-abundance isotope pattern, QED drug-likeness under all three weightings, ESOL aqueous solubility, synthetic accessibility and natural-product likeness, the Bemis–Murcko scaffold and generic framework, the BOILED-Egg's gut-absorption and brain-penetration verdicts, and per-atom logP, polar-surface and charge contributions. Readings are taken with hydrogens implicit, the form the descriptors and the rules' papers assume. An alert flags a nuisance or reactive substructure; it is not a verdict on activity or toxicity.

Check an index set you ALREADY have, rather than designing a new one: the minimum distance between any two, how many errors that guarantees correcting, the full distance matrices, and — optionally — the subset that survives pruning to a stricter error budget. This is the question asked of a set inherited from a kit or a previous experiment.

Check every annotated CDS of one or more GenBank maps against its own bases and genetic code: a frame that does not close (frameshift), a stop inside the reading frame, a first codon the code cannot start with, a last codon that is not a stop, and a /translation the bases do not give. A partial end (< or >) is not judged, and a /pseudo CDS carries no flag. Where an annotation ends without a stop it reads on in frame (round the origin of a circular map) to the first stop and says how many codons that adds, whether it runs into another annotated CDS (a fusion annotated in pieces) and the read-through a random backbone of the same composition would give. Extraction and translation match Biopython on all 1,871 CDS of 695 NCBI vector records.

Find and name known features on the subject — vector parts, origins, resistance markers and tags — by exact match, by local alignment (which finds a diverged copy and reports the identity and coverage that earned it), or by both, on either strand and across the origin, plus Cre/loxP and Gateway att recognition sites. Emits an annotated record, so a downstream map or export carries the annotations.

Protein → DNA: the coding sequence that would encode a protein, weighted by a real codon-usage table. Four rules — the host's most-frequent codon (EMBOSS backtranseq), a draw from the family's real frequency distribution, the IUPAC-degenerate consensus for primers/probes (EMBOSS backtranambig), or DnaChisel's table-free first codon. It does NOT optimize: for restriction-site avoidance, a GC target or repeat removal, follow it with optimize_sequence.

Bayesian protein inference, Epifany (validated against OpenMS BayesianProteinInferenceAlgorithm on PXD000001): the posterior probability that each protein, each indistinguishable group and each peptide-spectrum match is present, from the matches' posterior error probabilities under a network in which present proteins emit their peptides. Shared peptides are weighed between their proteins instead of being counted for each.

Search a sequence against THIS PROJECT'S OWN records with blastn or blastp, on this machine: the local database is built from every project record of the program's alphabet, and every E-value is computed from that database's own size. Use it to ask which of my constructs, reads or proteins carry this span. Nothing leaves the machine; for public databases use blast_search.

Search a sequence against NCBI BLAST+ at EMBL-EBI (blastn, blastp, blastx, tblastn or tblastx) over ENA, UniProtKB, PDB and the vector-screening sets. This is the similarity search a methods section cites: it turns an unnamed span into named homologues with E-values, and hands the hits, the tabular report and the job id downstream. The sequence LEAVES THE MACHINE.

Resampling error bars on ONE reaction's Cq. A Cq is read off a fitted model, so its uncertainty is how tightly the observations pin that model down - which propagating a measured spread cannot answer. This refits the curve a few hundred times, either by resampling its residuals or by leaving observations out, and reports the spread of everything the fit produces: every model coefficient, the Cq under each definition, the efficiency and the initial fluorescence, each with the quantiles of the iterations rather than a normal approximation, so an asymmetric interval means the estimate genuinely is asymmetric. Reproduces qpcR 1.4.2's `pcrboot`.

Read one window of a genome the way a genome browser shows it: the cytogenetic bands it spans, the transcripts in the chosen RefSeq set, which residues of each protein the window encodes (translated from the assembly’s own bases), how many dbSNP 155 variants fall in it and how many ClinVar calls pathogenic, and every CRISPR site for the chosen nuclease (SpCas9 unless told otherwise) with its strand, cut position and on-target scores. Give a gene symbol (resolved through MANE Select, then HGNC) or a locus, 1-based and inclusive. Each lane refuses a window wider than it will read, and says so.

Fill Addgene's own deposit spreadsheet from a record: one row per plasmid with its name and sequence, plus your answers for every plasmid (purpose, plasmid type, cloning method, resistance, growth strain and the other drop-downs). The sheet is fetched from Addgene each run, so its columns and choices are current; a value it would refuse is left out and named, and `columns` lists every column with its choices. It WRITES A FILE and sends nothing.

Build DnaCauldron's assembly report from an assembly result: the per-construct summary table, the constructs and errors spreadsheets as pandas-compatible CSV, and the Outcome / Number of assemblies stats. Wire `golden_gate_assemble` or `gibson_assemble`'s `products`, `errors` and `warnings` outputs into it.

Turn a record into what ENA's Webin-CLI takes for an annotated sequence (`-context sequence`): an ENA flat file (`.embl`) and its manifest. Features are checked against the tables ENA's own validator reads, so what Webin-CLI would refuse (an unknown key, a missing mandatory qualifier, a double quote in a value, a duplicate feature) is refused or rewritten here, by name. A description under 10 characters, an entry under 100 bp and a missing study are reported first. It WRITES FILES and sends nothing.

Turn a record into the SUBMISSION SET NCBI's `table2asn` consumes: a `.fsa` whose defline carries the source modifiers, and a 5-column feature table (`.tbl`) beside it. This is not a GenBank export — GenBank's submission pipeline takes neither a `.gb` nor a plain fasta. Its real work is REFUSING and MIGRATING what GenBank will not accept: twelve feature keys were retired in 2014 in favour of `regulatory` (promoter, terminator and RBS among them, so every plasmid map is affected), a qualifier not on a key's approved list is dropped by name, and an unapproved key is kept as a `misc_feature` carrying its original name. Since December 2024 GenBank has required `collection_date` and `geo_loc_name` on every submission, and both are validated here against the INSDC vocabularies BEFORE a file is written. It WRITES FILES and sends nothing: no account, no key, no upload — `table2asn` stays yours to run, and the submission template it also wants is yours to make.

Build a phylogeny from aligned sequences — distance methods (NJ, BIONJ, FastME, UPGMA/WPGMA), parsimony, maximum likelihood, or Bayesian MCMC under a strict clock and coalescent prior — with branch support from a bootstrap, aLRT or aBayes, or, for the Bayesian method, clade posterior probabilities. Wire it downstream of align_sequences.

Power and sample size for a planned experiment: how many replicates a test needs to detect an effect, or what power, detectable effect or significance level a design that is already fixed gives. Leave ONE quantity out with `solve_for` and it is solved; everything else is given. Thirteen tests in two families: Cohen's standardized effect sizes (pwr 1.3-0: t one/two-sample/paired and unequal n, one and two proportions by arcsine h, normal mean, correlation, chi-square w, one-way ANOVA f, linear-model f²) and raw units (R's power.t.test from a difference and SD, power.prop.test from two proportions, power.anova.test from variances). Every number is R's, reproduced: the solved value is uniroot's root at R's tolerance, and an unreachable target is refused with R's own message. Returns the power curve around the answer and the R call that reproduces it.

Sample size and power for an RNA-seq comparison of two groups, one gene at a time: the biological replicates per group needed to detect a fold change at a given sequencing depth and within-group coefficient of variation, or the power, detectable fold change, CV or α a fixed design gives. Leave one of n, cv, effect, alpha and power out (or name it in `solve_for`). Every quantity takes a list, and the answer is the whole grid, so depth against replicates is one call. RNASeqPower 1.52.0 (Hart et al. 2013), reproduced: a negative binomial count with Poisson sequencing noise 1/depth plus biological variance CV².

Call the bases of a Sanger trace from the signal, discarding the instrument's calls and deriving the bases, their positions and their quality from the peaks. The read can come back a DIFFERENT LENGTH than the file's. This ANSWERS the question; `adopt_trace_calls` is what puts the answer onto the read.

Amplification curves to Cq, one row per reaction. Fits each raw fluorescence curve to a sigmoid (l4-l7, b4-b7), reads the Cq off it under any of the seven definitions (cpD1, cpD2, maxE, expR, Cy0, CQ, maxRatio) or at a fluorescence threshold you set (the classic Ct), and returns the per-reaction efficiency and the fit-quality block beside it, so a bad fit is visible next to the Cq it produced rather than hidden behind it. Also reports the two exponential-phase locators (Tichopad take-off, model midpoint), which come back null rather than 0 when a curve has no exponential phase at all.

Call the bases of a Sanger trace AND ask at every position whether a second allele is present, writing a two-base IUB code (R, Y, S, W, K, M) where it is. `mode: het` assumes the two alleles are present in equal amounts, which is the diploid heterozygote case; `mode: mix` assumes nothing about their ratio, for a mixed template, a contaminated read or a pooled sample. The two disagree: on this repo's own corpus they differ on 348 of 5,605 calls. Also returns the ALTERNATIVE calls the search considered and rejected.

Withdraw a research run's pending hypotheses (all of them, or the ones named) so no resume runs them, and return the sealed run file. Nothing is deleted: a canceled hypothesis stays registered and still counts in e-BH with e 1, because it was registered before any result and dropping it would raise the others' chance of support after the fact. Answered and settled hypotheses cannot be canceled. To stop a run that is advancing in budgeted slices, stop calling resume_research_run; cancel when the pending hypotheses should never run.

A small molecule's tautomers and the canonical one, as RDKit's TautomerEnumerator finds and scores them: 37 hydrogen-shift transforms (after MolVS and Sitzmann 2010), scored by aromatic rings, twelve weighted groups and hydrogens on P, S, Se and Te, ties to the smaller SMILES. Returns every tautomer, the canonical SMILES, the score and the 0-based atoms (implicit hydrogens, molfile order) a hydrogen moved between.

Check a published PCR or sequencing assay against the sequences that are circulating now: for each oligo, where its best binding site is in each genome, how many positions mismatch, and whether a mismatch sits in the 3′ end a polymerase has to extend through. It answers the question an assay's age raises — the design was made against the genomes available on the day, and the target has drifted under it since — as a RATE per oligo with an exact binomial interval, plus the mismatch count at each position of the oligo, which is the shape a manufacturer's own in-silico inclusivity table takes. IUPAC codes in an oligo are read as the breadth its designers meant, so a position a code covers is never a mismatch; a site overlapping ambiguous bases in a submitted assembly is missing data and leaves that genome out of that oligo's denominator rather than counting as a match or a mismatch. A probe gets no 3′-end rate, because it is not extended. Graded against EMBOSS fuzznuc on every oligo of twelve published SARS-CoV-2 assays over 400 genomes.

Will the sequencer SEE these indexes? Per-cycle channel occupancy for a set of index sequences under an instrument's own SBS chemistry, checked against Illumina's rules (no dark cycle, both channels preferred, no GG in the first two cycles), each violation citing the vendor article it comes from — and the same set scored across EVERY chemistry generation at once, because XLEAP moved the dual-color base from A to C and a set balanced on a NovaSeq 6000 is not balanced on a NovaSeq X. This is the color question alone; check_index_pool asks it alongside distance, duplicates and hopping for a whole pool.

Check parts BEFORE a Type-IIS assembly: how many recognition sites each carries, which of them are the two deliberate flanking sites and which are internal sites that will mis-cut the part. This is what answers “why will this assembly not work” — an internal site has to be domesticated (silently recoded) before the reaction can be trusted.

Will this pool of sample indexes actually sequence? One verdict over the indexes a lab is about to load: duplicates, uniform length, the distance the set really guarantees against the distance it claims, per-cycle color balance on the chosen instrument's own chemistry, the index-2 orientation that instrument reads, and index-hopping exposure — how many i7 x i5 combinations exist against how many are in use, and which swaps would turn one sample's read into another's undetectably. Takes a pasted list or a vendor kit by id. It CHECKS a pool; design_barcodes builds one.

Decide whether a sequence is scientifically admissible: protein unchanged, forbidden restriction sites absent, reading frame intact, length/GC/CAI inside stated bounds. Every verdict names what broke, where, and the remedy. Run this after any design or optimisation step, and stop the chain when `admissible` is false — never report a designed sequence without it.

Measure a sequence against what a NAMED synthesis vendor publishes it can make: length, average and windowed GC, homopolymer runs, tandem repeats, long repeats and hairpin-forming inverted repeats. Every threshold is the vendor's own, read from the vendor's own page with the date it was read, and every finding carries the span it is about so it can be drawn. It reports the limits that are MET as well as the ones exceeded, because a list of failures cannot tell a clean sequence from an unchecked one. It never predicts a synthesis outcome and never rules a sequence out: a vendor publishes what it supports, so being outside a published window is a conversation with the supplier, not a rejection.

Whether the host's own methylation blocks the given enzymes ON THIS PLASMID, from REBASE's methylation-sensitivity tables localised onto your sites. The other term of the same reaction question `find_star_sites` answers. It is deliberately per-SITE and not per-enzyme: REBASE says Dam blocks ClaI, and pBR322's single ClaI site carries no overlapping GATC, so the enzyme-level warning does not apply there. An enzyme REBASE has never examined comes back `examined: false`, which is UNTESTED and never a clearance.

Check primer pairs for products off their template, the way NCBI Primer-BLAST does, and rank them by it: each distinct primer is searched against a sequence database at EMBL-EBI with short-query BLAST, hits are paired into products by Primer-BLAST's own mismatch rule, and the template is searched too so the record identical to it is recognized as the intended target. Pairs with no product elsewhere rank first, in the order given, then pairs not checked, then pairs with a named unintended product. Primer sequences and the template LEAVE THE MACHINE; the database is a collection, not an assembled genome, and cannot be filtered by organism.

A QC gate over a TABLE: assert something about every row at once (every band inside a size window, no guide above an off-target score, at least three assays under a penalty). Fails the pipeline (so everything downstream skips) and names the rows that broke the rule.

A Scorpion probe's two melting temperatures, side by side: the stem-loop's own hairpin and the duplex the loop makes with its target on the amplicon. A Scorpion is a primer carrying a stem-loop probe on a non-amplifiable blocker (Whitcombe 1999), and it reports by the loop finding its target and pulling the stem apart - so the design question is a RELATION between those two structures, not a property of either. Returns both temperatures, their difference, the stem's GC, and a verdict against WHATEVER margin you pass. It does not apply a margin of its own authority: the widely-quoted 5-10 °C figure comes from one design tool's tech note and has no primary citation, so the default is labelled as that rule of thumb and every result says which margin produced its verdict.

A QC gate. Compares a wired value against a threshold and PASSES or FAILS the pipeline there — every node downstream of a failed gate is skipped, so a run stops at the first check that does not hold. This is how a pipeline expresses 'only continue if the clone is right'.

ddPCR droplet amplitudes to populations. For TWO targets, a four-way classification — NN, NP, PN, PP — under any of THREE published methods that answer different questions and none of which is a fallback for another. `grid` applies eight fixed thresholds: reproducible and auditable, the only one that does not move when the data does, and the only one that needs someone to have chosen the numbers. `kmeans` clusters both channels at once and names the clusters by where they sit, so it adapts to the well, and it CANNOT abstain because k-means partitions everything. `knn` classifies against a well you have already labelled and abstains into `Rain` when the neighbour vote is weaker than a floor you set, so it is the only one that can decline per droplet. They disagree on the droplets between the populations, and that disagreement is the honest measure of how much an answer rests on the method rather than on the data. Distinct from `gate_droplets`, which asks whether a droplet is EMPTY per channel and ends in a concentration; this asks which of four populations it belongs to. For ONE to FOUR targets multiplexed by amplitude, ddPCRclust names up to sixteen populations from the primary clusters and reports each target's copies per droplet, by any of three first clusterings or their consensus: `density` places the primaries from density gates, `samspectral` from spectral clustering of a faithful sample, `flowpeaks` from the density peaks k-means clusters climb to, and `ensemble` (ddPCRclust's own default) runs all three and keeps the partition that agrees most with the others, with their mean corrected Rand index as the confidence. A plate of exports with ddPCRclust's run template is classified well by well and can be normalised to a constant control.

Which Golden Braid / MoClo / Yeast ToolKit grammar, position and level the open plasmid represents (or null). Reads the record's own annotations, which is what lets an assembled transcription unit be recognised by its backbone half, and what lets a Level-0 module whose own backbone carries an extra site for the release enzyme be told from that backbone. Configured entry vectors are a Parts Bin concept and are NOT available here, so a TU sitting in a named acceptor is reported by its overhangs rather than by that acceptor's name.

Cluster or diversity-pick a list of small molecules on 1 − Tanimoto of Morgan radius-2 fingerprints: Butina sphere exclusion (RDKit ClusterData, optional reordering), MaxMin diversity picking (RDKit MaxMinPicker, seeded), or average linkage (UPGMA) cut into k clusters. Indices are 0-based.

Frequency of optimal codons (Fop, Ikemura 1981) for an in-frame CDS against a real codon-usage table: what share of its codons are the ones a highly-expressed gene in that host would use. Where CAI scores how CLOSE each codon is to its family's best, Fop scores only whether it IS one of the best, which makes it comparable across genes of different amino-acid composition. Name a table this project holds in `table`, or one of the bundled hosts in `host`.

Fetch a real codon-usage table for an organism and save it into this project, so later steps can score against it by name. NCBI builds the table by counting codons in the annotated CDS of a RefSeq assembly (the same counting the Codon Usage panel does, with the assembly and CDS count in the provenance); the Kazusa mirror serves a published table for an organism the mirror covers. The table LEAVES NOTHING but takes a network round-trip. Hand the saved name to `codon_usage_analysis` or `codon_optimality` in `table`.

Codon-usage analysis of an in-frame CDS: CAI / expression stats, GC, and every rare-codon occurrence for the chosen organism (pydna port), plus the two bias measures that need NO reference table — ENC (Wright 1990) and RCBS (Roymondal 2009), which are therefore computable for any organism.

How this region's codon usage compares with the record's OTHER genes (CUFS, Diament, Pinter & Tuller 2014). Every other codon score grades one sequence against a reference TABLE; this one grades two sequences against each other, so it stays available for an organism no authority covers. Answers 'does the gene I inserted use codons like the rest of this construct'.

Several antibodies side by side: each record numbered by ANARCI, its heavy or its light variable domains aligned column by column by their numbering (a column is one scheme position, so nothing is re-aligned and an insertion is its own column), the CDR of every column under the chosen definition, how many columns agree, and the same properties read off each V domain: length, mass, isoelectric point, net charge, GRAVY, ε280 and the net charge of its CDRs. The alignment is abnumber's `Chain.align`, graded against it over every chain of ANARCI's PDB benchmark; the properties against Biopython ProtParam.

Align two constructs' build procedures step by step, in order — was this built the same way as that? Works across formats: a build received as a SnapGene binary and the same build received as an OpenCloning strategy align, because each step's identity is derived from the reaction and its parameters rather than assigned.

How similar two small molecules are: Tanimoto under six RDKit fingerprints (Morgan/ECFP4, atom pair, topological torsion, RDKit path, pattern, MACCS), every DataStructs metric (Tanimoto, Dice, cosine, Sokal, Russell, Rogot-Goldberg, all-bit, Kulczynski, McConnaughey, asymmetric, Braun-Blanquet, on-bit, Tversky) on the chosen one, and count-based Tanimoto, Dice and Tversky on Morgan counts. The first molecule is the query.

Compare a SET of sequencing reads against one reference in ONE shared frame: align every read to the reference, vote a consensus column by column, and report the positions where the reads differ from it, each with the change it makes to the protein. This is the whole-plate answer that grading reads one at a time cannot give — a variant is accepted only when every covering read agrees, so a single bad call does not become a mutation. Reads arrive as records or bases; the reference is the record this step runs on.

Compare trees over the same taxa: the Robinson-Foulds distance between two of them, and the consensus of any number. Two methods disagreeing is a result about the data, so the distance and the shared topology are reported together.

Merge one or two Sanger reads into a consensus with the ported SeqTrace caller. With two reads (typically a forward and a reverse of the same amplicon) an IUPAC ambiguity code marks a position the two DISAGREE about; with one read there is nothing to disagree with and a code marks a position where no single base cleared the confidence bar. Returns the consensus, how many positions are ambiguous, and how many the consensus's own trimming stage cut from the ends.

Read an Affymetrix array result's own allele-specific copy number: for each segment the major and minor allele counts (1+1, 2+0, 0+0), what they mean (balanced, allelic imbalance, loss of heterozygosity placed against the sample's own ploidy, homozygous deletion), and ASCAT's whole-genome summary over them (LOH fraction, homozygous deletions, modal allele state, whole-genome doubling, genomic instability). OncoScan results state a split when the aberrant-cell fraction was determined; the tool says why when a file states none.

Join two Affymetrix copy-number samples' own calls and report which events they share and which only one of them carries: for every pair, the chromosome both files resolved to, the kind, the bases they overlap and their reciprocal overlap; and separately each sample's unshared calls. Kind is part of the match, so a gain in one sample and a loss in the other at one locus are reported as two unshared calls rather than as agreement. Chromosomes only one file indexes are listed apart and are NOT reported as differences: nothing about them was compared. NO OVERLAP THRESHOLD IS APPLIED — every pair comes back with its numbers, and which agreement counts as agreement is a laboratory's judgement.

Scan every indexed chromosome of an Affymetrix copy-number container and report what the file itself called: gains, losses and stretches of homozygosity, with their positions, marker counts and spans, plus a per-chromosome summary. Reads the file's own CNState and LOH columns and infers nothing — for a second opinion computed from the log2 ratios, use copy_number_segment. A chromosome that was read and carries nothing is reported as clean, which is a different answer from one that could not be read. NO GENOME BUILD IS ASSUMED: positions are the file's own.

Recompute loss of heterozygosity from an Affymetrix array's own per-marker genotype calls, rather than reading the runs the producer wrote: APT's window method, with the false-positive rate and the assumed genotyping error rate as parameters. Answers where a sample has lost one parental haplotype, including where copy number is normal. Needs a container that states genotype calls — an OncoScan OSCHP does; a CytoScan CYCHP states the set with no rows, and this says so rather than answering empty.

Estimate which mosaic fraction class each region of one chromosome is closest to, as Affymetrix Power Tools computes it. A mosaic event is present in only some of the sample's cells, so its log2 ratio sits between the levels a clonal change would produce. Every segment comes back with the class it was assigned (±0.3, ±0.5, ±0.7, ±1.0), the fraction that class is NAMED for, its confidence, and whether the method CALLED it as mosaic — a whole-copy change of exactly ±1.0 is clonal and is reported with call 0, which is the vendor's own test. The mixture values are class labels, not measured cell fractions: there is no published method for this estimate and no independent implementation to grade it against, so it is reported as APT computes it and the provenance output carries that sentence. A chromosome with fewer than 4,330 markers is refused by name rather than answered empty, because the method's own boundary adjustments would delete every call.

Read an Affymetrix copy-number container (CNCHP/CYCHP/OSCHP/CHP) in this project and say what is in it: the algorithm and array that produced it, its data sets and their graphs, the per-chromosome marker index the file carries, and — for one chromosome — each graph decimated to a summary with its real range. Values the analysis left undefined are counted and reported, never plotted as zero. NO GENOME BUILD IS ASSUMED: positions are the file's own, because these files name an annotation release and not an assembly.

Place an Affymetrix copy-number sample's own calls in ClinGen's curated regions: for each region, which gains, losses or stretches of homozygosity fall in it, at what reciprocal overlap, and how much of the region they cover between them. Regions come from ClinGen's dosage-sensitivity curation, cached with its retrieval date — a loss is reported against the region's haploinsufficiency score and a gain against its triplosensitivity score, and no score is claimed for LOH or mosaic events, which change no copy number. NO THRESHOLD IS APPLIED: every overlap is reported with its numbers and which calls are worth reporting is a laboratory's judgement. Regions ClinGen has not placed on this build are listed separately and are NOT reported as clean.

Segment one chromosome of an Affymetrix copy-number container by up to four independent methods and report where they agree. The HMM lays a copy-number model over the log2 ratios and calls a state per segment; circular binary segmentation finds where the mean changes with no model of what a gain looks like, by permutation test; piecewise constant fitting picks the piecewise-constant curve minimizing squared error plus a penalty per jump, with no test and no seed; PELT minimizes the same shape of objective exactly and prices a boundary with an information criterion rather than a tuned constant, so its segment count follows from a model-selection rule. Every parameter and every default is the canvas's own. NO GENOME BUILD IS ASSUMED and no method is on unless asked for.

Read an Affymetrix array result's own somatic-mutation calls: one row per mutation probe set with the producer's call, the score behind it and the two thresholds that call was graded against. OncoScan CNV Plus states this table; CytoScan and SNP 6.0 results do not, and the tool says so rather than answering empty.

Call HITS from a pooled CRISPR screen: per-guide read counts in, a gene-level Bayes factor and a precision/recall curve out. This is the other end of a screen from the pool designer — it reads what came back rather than deciding what to order. The estimator is BAGEL2 (Kim & Hart 2021), reproduced byte-for-byte against upstream, so a gene's Bayes factor here is the number BAGEL2 prints for the same counts. It is a COMPARISON against two reference gene sets, not an absolute fitness measure, and it reports how many of those reference genes the library actually carries, because a screen whose gene symbols do not match the reference sets trains on almost nothing and still returns a ranking. MAGeCK's alpha-RRA and drugZ are different statistics that disagree with this one on the same counts; neither is computed here, and a hit list must say which statistic produced it.

Design and score CRISPR guides on the subject — on/off-target scores, QC flags, and cloning-enzyme conflicts. Nuclease list comes from the real nuclease registry.

Turn the open record's annotated targets into an ORDERABLE sgRNA oligo pool: the best N guides per target, filtered at order time (Pol-III terminator, Graf inactive motif, cloning-enzyme site, minimum on-target score), each composed into the oligo a synthesiser makes — the vector's cloning overhangs around the spacer plus, optionally, one of CRISPOR's eleven subpool barcodes. A spacer that serves two overlapping targets takes ONE well, and every candidate a filter held back is counted by reason, so a short pool says which rule shortened it. It designs a library; it does not analyse one. No recommended representation, MOI or read depth is embedded — the screen-scale arithmetic is in the editor panel, where the numbers are the user's.

Quantify a CRISPR edit from a pair of Sanger traces — how much of the population was edited, what the indel spectrum looks like, and how well the model fits. Synthego ICE: the CONTROL trace gives the unedited sequence, the EDITED trace is decomposed into a mixture of proposed indels around each guide's cut, and the abundances are fitted. Answers the question a screen cannot: not whether a guide is good, but what it actually did to these cells.

Score CRISPR guides with DeepHF: a predicted knockout EFFICIENCY between 0 and 1 for wild-type SpCas9 (U6 or T7 promoter), eSpCas9(1.1) or SpCas9-HF1. It is not a z-score and not comparable with Rule Set 3 — the two answer different questions and must never be averaged or ranked together. Takes 23-nt protospacers (20-nt spacer + NGG PAM), which is what `crispr_design_guides` produces; a guide whose PAM is not canonical NGG comes back null rather than extrapolated, because the model was trained on NGG only. THE WEIGHTS DOWNLOAD ON FIRST USE, 3-5 MB per model, and scoring is slow by construction: each guide is folded twice, once with the 79-nt tracrRNA scaffold, before the network sees it.

Score CRISPR guides with DeepSpCas9 (Kim et al. 2019, Sci Adv 5:eaax9249): a predicted INDEL FREQUENCY IN PERCENT for wild-type SpCas9. It is a third quantity, not a second opinion: Rule Set 3 is a z-score across a screen and DeepHF is an efficiency in [0, 1], so none of the three may be averaged or ranked together. Takes the 30-nt CONTEXT the model reads whole (4 nt + 20-nt spacer + 3-nt PAM + 3 nt), which is what `crispr_design_guides` reports as `context30`; a 23-nt protospacer is not enough and comes back null rather than padded. Unlike DeepHF it does NOT require a canonical NGG PAM, because its training library was not NGG-only. The output is the network's own linear value and is left unclipped, so a context it scores below zero reads below zero. THE WEIGHTS DOWNLOAD ON FIRST USE, about 0.93 MB, once.

RDKit's R-group decomposition of a list of small molecules on a core given as SMARTS (default RGroupDecomposition parameters): per matched structure its core and substituents R1, R2 …, and the structures the core does not match. Indices are 0-based.

DELTA-BLAST, run on this machine: build a position-specific profile for a protein from the SMART conserved domains it contains, then search other proteins with it (one PSI-BLAST iteration) — more sensitive than BLASTP for distant homologs. Searches the open record's coding sequences unless `subjects` gives FASTA. NCBI BLAST+ 2.17.0's algorithms, checked against the deltablast program on every bundled protein. Nothing is sent anywhere.

Assign reads to the index each one came from, and say how many could NOT be assigned reliably — a hit further from a barcode than the set's guaranteed correction radius is not that barcode, and counting it as one is how a demultiplexing report hides a failed run.

The design step's view of a discovery corpus: each record's name, file, length and GC fraction, and how many records each file holds. Runs no test and returns no statistic, so hypotheses proposed from it are proposed before any result is seen (POPPER's metadata-only design step). Use it before run_discovery_programme.

Describe the project the way the copilot is told about it: every file, what it carries and which tool reads it, which files are indexed or paired with each other, and the codon-usage tables a tool resolves by name. Over the API or MCP it describes the files sent as _files; in the app it describes the open project.

Design a set of NGS sample-index barcodes with a guaranteed minimum distance, and report what that set actually corrects — substitutions, or indels too (DNABarcodes).

Design BSP or MSP primers for a methylation assay, on the CONVERTED strands: after bisulfite treatment every unmethylated C reads as T, which is a different template from the one every other designer sees. BSP primers avoid CpGs so they amplify regardless of methylation state; MSP primers sit ON CpGs so they discriminate. Also reports the CpG islands (EMBOSS cpgplot) the assay should target.

Design CODEHOP hybrid oligos from a block of aligned PROTEIN - for homologues too diverged for nucleotide-level design to see at all. Each primer is a 3' DEGENERATE core over a few conserved residues fused to a 5' non-degenerate consensus clamp, back-translated through a codon-usage table. A different algorithm from the degenerate designer, not a variant of it.

Design degenerate primers from a multiple-sequence ALIGNMENT - the 'amplify every homologue in this family' question, which a single-template designer cannot answer because it only ever sees one sequence. A faithful port of DegePrime (Hugerth et al. 2014). Wire an upstream align_sequences `rows` output straight in, or paste an aligned FASTA.

The expression-design deliverable: several coding sequences for one protein, each variant following a different published strategy (maximise codon adaptation, match the host's codon usage, harmonise with the native host, or preserve the initiation region), each scored by an engine — CAI, GC, the folding energy of the Kudla -4..+37 initiation window, and rare codons. It returns the comparison rather than one answer, because the strategies disagree about what limits expression and the researcher picks. Refuses a frame-shifted CDS, an internal stop or a missing host table rather than optimising nonsense.

Generate INDEL-correcting barcodes — FREE divergence codes (Hawkins et al., PNAS 2018) — by reserving each codeword's error sphere over the whole 4^k space, so the guarantee survives an insertion or deletion rather than only a substitution. Or prune a set you already own down to a valid FREE code, and see which members' decode spheres collided. This is a different construction from design_barcodes' distance-based search, and answers a different question: a Levenshtein-distance set corrects indels between two barcodes, a FREE code corrects them in the read.

Design the PCR primers that ADD Type-IIS fusion sites to a part: enzyme site, spacer and the four-base overhang you chose, on a Tm-matched annealing footprint. This is how a sequence that is not yet a Golden Gate part becomes one, and it is the other half of check_golden_gate_parts — that says which parts are unusable, this makes one usable.

Design a genetic circuit that computes: give it a logic function and it synthesizes a NOR/NOT netlist, assigns real characterized repressor gates from a Cello UCF library, predicts the dynamic range between ON and OFF, and emits the construct's DNA. The gate parameters are MEASURED, from the published libraries, with the host and growth conditions they were measured under reported alongside — never estimated here.

Design the PCR primers that CREATE the terminal homology a Gibson/NEBuilder/In-Fusion assembly needs: a Tm-matched pair per fragment, each carrying the 5' overhang that fuses it to its neighbour in the order given (pydna assembly_fragments). This is the step that turns a planned assembly into oligos you can order.

Design HCR v3.0 split-initiator probe pairs against the subject: tile its reverse complement into 52 nt windows, drop windows with C or G runs, a stable hairpin, G+C or RNA:DNA free energy outside their windows, or (given a bowtie2 alignment of the tiles) more than one genome hit, then pick non-overlapping tiles closest to the target free energy and split each around a 2 nt gap into an odd and an even probe carrying half of the chosen amplifier's initiator. Each stage reports how many tiles it kept.

Design an in-situ hybridization probe against the subject: tile it into candidate oligos that meet a melting-temperature, G+C and composition specification, screen them for off-target binding against an alignment and for k-mers abundant in a reference, and gather the survivors into the set that images best. Merges OligoMiner's tiling, its trained specificity model and its k-mer filter with iFISH's probe-set selection; each stage reports what it removed and why.

The complete build package for a knockout or knock-in, as one object: guides inside the target, an off-target census for the chosen one within this molecule, a repair template with real homology arms, a screening PCR whose primers sit OUTSIDE the arms, the protocol in order, the fragments and oligos to buy, and every coordinate ready for the map. Two donor modes: by default the arms sit on the cut (a point insertion — the target's own sequence is kept on both sides), and with `replace_target` the arms flank the whole target and it is deleted, which is the mode for replacing one CDS with another (an empty insert then deletes the target cleanly). It refuses rather than guessing: no PAM in the target, arms that run off a linear molecule, a screening amplicon that cannot clear the arms, or a non-DNA insert; and in the default mode it WARNS when an insert lands inside the target, because that is a fusion rather than a replacement. Arm length, screening flank and guide count are yours to state, because each follows the delivery method and the organism.

Design LAMP (loop-mediated isothermal amplification) primer SETS - four core oligos (F3 · B3 · FIP · BIP) plus optional loop primers, judged against Eiken's own PrimerExplorer V5 criteria. Not a pair: LAMP needs six binding regions in the published order and the distances BETWEEN them are as much of the design as the oligos. Each set comes back with the arithmetic behind its rank.

Design MERFISH encoding probes for the subject transcript: tile it into target regions, keep those whose G+C and melting temperature fall in their windows, that share no k-mer with an rRNA or tRNA, and whose k-mers occur in this gene's transcripts and nowhere else in the transcriptome; attach readout sequences that spell the gene's codeword, add the amplification primers, screen the whole oligo again, select probes that cover every on-bit evenly with least overlap, and drop probes complementary to one another. Each stage reports how many it kept.

Design QCLM (quick-change lightning multi-site) oligos: one primer per mutated site, all annealing in one reaction, with the codons drawn from an organism's usage table. A design/write.

Design site-directed mutagenesis (SOE-PCR/QuikChange) primers for a point change on a CDS: the ranked inner mutagenic pairs, the constant outer pair, and the single spanning primer that replaces an outer when the site sits too near a CDS end. A design/write.

Lay a set of oligos out as a supplier's PLATE order sheet: one worksheet per plate, in the well order the supplier's own order form fills, with the column shape its loading direction requires. A plate order is addressed BY WELL, which a flat tube list cannot express — so this is the shape an oligo set actually gets ordered in once it outgrows a handful of tubes. With `mixed`, a forward and a reverse share one well, which is what the supplier's doubled mix-plate layouts encode. It WRITES A FILE and sends nothing: no account, no key, no network call.

Design a high-fidelity Golden Gate overhang set of a given size against measured ligation data, optionally pinning junctions you cannot change (a fixed vector's own overhangs). The counterpart to score_overhang_fidelity: that grades a set you already have, this proposes one. The search is greedy-plus-steepest-ascent over the same golden-validated objective: real measured data, a heuristic path, no claim of finding the optimum.

Design padlock probes for in-situ sequencing against the subject: find the two-arm targets whose melting temperature falls in a window, check each against a BLAST search for any other transcript that could be ligated across the junction, pack non-overlapping targets from the 3' end, and assemble each into its padlock with the backbone given. Without BLAST results it returns the targets to search, and says the junction check has not been run.

The Primer Designer's own ranked search: scan the open record for primer pairs inside a product-size, Tm, length and GC window, score every candidate on Tm, dimers, hairpins, 3' stability, repeats, clamp and specificity under weights you set, and return the best N. With `task: existing`, supply one primer and it designs the mate. Emits the top pair so a downstream pcr_amplify runs on it. For a sequencing walk use design_sequencing_primers; for pydna's single-pair designer use design_primers.

Design a forward + reverse primer pair to amplify the subject (pydna `primer_design`), with Tm, Ta and suggested Taq/Phusion cycling programs. Emits both primers so a downstream pcr_amplify runs on them — the design→PCR→gel loop.

Design qPCR assays over the subject — primer pair plus hydrolysis probe, ranked by penalty, with amplicon size/GC, per-oligo Tm and whether both primers bind a single site.

Design a 5'UTR (Shine-Dalgarno + spacer) in front of a CDS to hit a target translation-initiation strength (SC-08 engine, Turner-2004 folding).

Design site-saturation mutagenesis (SSM) primers: one overlapping forward/reverse pair per site, each carrying a degenerate codon, sharing ONE reaction-level overlap and 3' temperature so every site amplifies in the same tube (both of Mutation Maker's solvers: fast approximation by default, exhaustive search on request). Every Tm is Biopython's `Tm_NN` over the Allawi & SantaLucia 1997 nearest-neighbour table (`DNA_NN3`, upstream's own), under the salt correction and buffer below. A design/write.

Design a WALK of sequencing primers that reads a whole region, not one pair: tiled reads with confirmed overlap, on both strands by default, plus the coverage the walk actually achieves and any stretch it cannot reach. This is the 'how do I read all 6 kb of this construct' question, which a single pair does not answer. Read length and dead zone default to a named facility's published figures (MSU RTSF, ABI 3730XL) rather than to round numbers.

Decide where to CUT one sequence into Golden Gate fragments, optimising the split positions and the overhangs they create together. Where design_overhang_set proposes junctions for parts you already have, this fragments a sequence you are about to order: it searches every legal arrangement of fragments in your length window and ranks them by the measured ligation efficiency and fidelity of the overhangs each arrangement produces. Ported from OOGGA (Mukundan & Madhusudhan 2025) and scored against the same Potapov 2018 T4 ligase data the fidelity tools use.

Design Xenium custom-panel padlock targets on the subject transcript to 10x Genomics' published rules (CG000683): two 20 nt arms whose primer3 melting temperatures fall in their windows, a ligation-junction dinucleotide the Xenium ligase accepts, no run of five G in the probe, at least four mismatches across both arms to every other transcript in a BLAST search, and probes at least 10 bp apart. Without BLAST results it returns the targets to search and says the off-target check has not been run.

Ask whether a Sanger trace splits into TWO READS OF DIFFERENT LENGTH, which is what a heterozygous insertion or deletion does: clean up to the indel, then a superposition of two sequences offset by its length. This is not mixed-base calling — that asks whether two BASES sit at one position and is blind to a length difference. Emits where the split starts, how long it is, and the two allele sequences the trace deconvolves into, so a pipeline can gate on the answer or carry either allele onward.

Differential expression from raw RNA-seq read counts, by one of the three standard count models. DESeq2 (Love, Huber & Anders 2014): median-of-ratios size factors, negative-binomial GLM with empirical-Bayes shrunken dispersions, Wald or likelihood-ratio test, Cook's-distance outlier handling, independent filtering, optional LFC shrinkage. edgeR quasi-likelihood (Chen et al. 2025): filterByExpr, TMM normalization, a negative-binomial GLM with bias-adjusted QL dispersions squeezed toward an abundance trend, QL F-test. limma-voom (Law et al. 2014): filterByExpr, TMM, log-CPM with mean-variance precision weights, weighted linear models, moderated t. Takes a gene-by-sample count table and a sample table with the design's variables. Every gene of every validated fit is bit-identical to DESeq2 1.52.0, edgeR 4.10.6 and limma 3.68.5 running in R. Hands its significant genes, tested genes and ranked list on for gene-set enrichment.

Digest the subject with the given enzymes into real fragments (sequence + both overhangs). Emits the selected fragment as a NEW record, so a downstream gel/map/ORF runs on that fragment — the digest→assembly hand-off.

The reaction a digest needs, from NEB's own data: the NEBuffer that serves every enzyme together (scored on the WORST enzyme's percent activity, a star-activity buffer disqualified at any percent), the incubation temperature(s), any cofactor that must be added (SAM or ATP), and each product's heat-inactivation step, or the products NEB cannot heat-inactivate. One call is one tube: enzymes that need different temperatures or have no common buffer come back with `singleTube: false`. Needs no open record.

Find the signal peptides or transmembrane segments in reviewed human UniProt that a sequence predictor contradicts. Each feature backed by experiment (evidence code ECO:0000269) is scored to say what a confirmed feature looks like to the predictor; every other feature, annotated from similarity, sequence analysis or a rule, is ranked among those scores, and its conformal p-value (1 + experimental features scoring at or below it) / (experimental + 1) is corrected across all of them. Signal, by either predictor: von Heijne's weight-matrix score (EMBOSS sigcleave) of the cleavage site UniProt annotates, or DeepSig's probability that the protein carries a signal peptide at all (its eukaryotic network ensemble, from the first 96 residues). Transmembrane: the share of the segment the HMM-TM topology model labels membrane helix. A contradiction is a disagreement between two models, to be read, not a correction of UniProt: von Heijne's matrix and the HMM-TM model are weaker than the SignalP and TMHMM runs behind most such annotations; DeepSig is of their generation. The result carries a self-check, half the experimental features tested against the other half, whose calls are all false by construction.

Score every coding sequence of a genome against the genome's own codon usage and report the genes whose synonymous codon choice that average does not explain, with the false discovery rate controlled across the genes. Records from different files are different genomes: each is scored against its own file's usage, and the false discovery rate is controlled once across every gene of every genome. Each gene gets Karlin's B and Supek & Vlahoviček's MILC against the pooled usage of the genes, and a G-test of its codon choice within each amino acid against that usage (χ², degrees of freedom from the amino acids it uses). Outliers are typically highly expressed genes (ribosomal proteins are the most deviant class), genes of unusual composition, and some of foreign origin; an outlier is NOT evidence of horizontal transfer, since codon bias is a poor indicator of transfer.

Measure how often a corpus of maps carries a cryptic σ70 promoter, a cryptic splice site or a synthesis-breaking repeat MORE EXTREME THAN CHANCE, rather than how many it carries. Every map of a few kilobases spells promoters, splice donors and repeats, so a raw hit count measures length and composition; here each map's own extreme (its most negative promoter ΔG, its highest MaxEntScan donor and acceptor score, its longest homopolymer, tandem repeat, repeated stretch and hairpin arm) is scored against k-let-preserving shuffles of that same map, and the false discovery rate is controlled across the corpus within each statistic. No statistic uses a threshold: none of the three models publishes one, and a vendor's repeat limit is a product's capability, which `check_manufacturability` answers instead. The result is a per-statistic rate with an exact binomial interval, plus every map's own test. Cost is dominated by the σ70 scan at roughly a third of a second per map per shuffle, so a corpus of maps at the default 99 shuffles is minutes of work; drop `flags` to the statistics you need to make it cheaper.

Find the genes whose own alignment rejects the species tree. Each named alignment file is one gene, its records the taxa, named as the species tree's tips. For every gene the species tree and each of its nearest-neighbour rearrangements (two per internal branch) is fitted by maximum likelihood under GTR + Γ (rates, base frequencies and shape fitted on the species tree, branch lengths refitted on each rearrangement), and the Shimodaira–Hasegawa test asks whether the species tree is significantly worse than the best of them; the false discovery rate is controlled across genes. A rejection says the gene fits another tree better: incomplete lineage sorting does that to a share of genes among closely spaced species, and so do hidden paralogy, alignment error and transfer, so it is a gene to read, never a call of any one of them. Also reports which genes' best tree is not the species tree, rejected or not, and which alternative trees they choose. Graded against phangorn's pml, optim.pml and SH.test on 122 great-ape genes. About a second of fitting per gene in a browser.

Ask whether a reference-gene stability ranking holds across conditions, and which candidate genes rank well everywhere rather than in one tissue or treatment. Each condition (the Group column of a long-format Cq table) is ranked by geNorm on its own samples; the conditions are then the blocks of a Friedman test and Kendall's W says how far they agree (0 independent orders, 1 the same order everywhere), with an asymptotic χ² p and a Monte Carlo p from shuffling each condition's ranks. Returns every gene's rank in every condition, its mean rank (the meta-ranking) and its best and worst. geNorm cannot order its two most stable genes, so they share rank 1.5 in every condition. Use `rank_reference_genes` for one condition's ranking by all four algorithms.

Ask whether the genes used to normalize expression (reference or housekeeping genes, such as GAPDH, ACTB or B2M) are more or less variable across human tissues than genes of the same abundance, on GTEx v8 median expression. Each candidate's standard deviation of log2(TPM + pseudocount) across the chosen tissues is ranked among the genes nearest it in mean expression (1,000 by default, from the 19,107 protein-coding genes GTEx measures), giving one p for 'more variable than its peers' and one for 'steadier', each corrected across the candidates. The four rankers the field runs (geNorm M, NormFinder, BestKeeper, comparative ΔCt, and RefFinder's consensus) also order the candidates against each other, reading the tissues as samples. A ranker always finds a most stable gene; the null says whether any candidate is stable at all. Tissue medians hide the variation between people within a tissue, so this answers 'across tissues', not 'across samples of one tissue'.

Sweep a set of sequences against every exact recognition site in the NEB catalog and report the sites each one carries far less (avoided) or far more (enriched) often than a stated null predicts, with the false discovery rate controlled across every (sequence, site) test. Avoidance is evidence of the restriction–modification systems a lineage has lived with, and a site a design can rely on being rare. Three nulls: base composition (order-0, Poisson); k-let-preserving shuffles (uShuffle), which holds dinucleotide skews such as CpG depletion in the null rather than reporting them as findings; and R'MES's maximal-order Markov model, the standard in published avoidance analyses, which judges a site of length k against the record's own (k−1)-mers so only what those cannot explain is reported.

Test a hypothesis that a gene drives a phenotype ("gene G regulates IL-2 production") the way POPPER does: each evidence table is one falsification test, an implication of the hypothesis that a gene-level score could contradict (expression in the relevant tissue, association with related disease, interaction with genes annotated to the process). Under the null that G is exchangeable with any gene the tables score, G's p in each table is the share of genes scoring at or beyond it; each p is calibrated to the e-value κ·p^(κ−1), the e-values are multiplied in the order given, and the hypothesis passes when the product exceeds 1/α. The product is a valid e-value only when the tests are independent under the null, so the run also reports the joint p: the product's own share among every gene's product, valid whatever the tables' dependence. Returns every test's score, rank, p, e and running product, the test after which the product first crossed 1/α, and the joint p. Each table is `gene<TAB>score` with one header line; the gene must be in every table.

Ask whether some loci of a multi-locus alignment have a different history from the rest, by the incongruence length difference test (Farris et al. 1994). Each locus is one aligned FASTA file (or a set of wired alignment rows) over the same taxa, named alike in every file. D is the extra parsimony steps one shared tree costs over each locus's own tree; the null deals the same columns into parts of the same sizes at random. One global test over every locus, and one per locus against all the others combined, with the false discovery rate controlled across loci. A locus that recombined or was transferred costs steps when forced onto the others' tree, but so does a locus evolving at a different rate (Darlu & Lecointre 2002), so a call is a candidate for a tree comparison, never a recombination call. Lengths are NNI parsimony searches from each alignment's own neighbour-joining tree. Cost: a run is 1 + k + k·n + k·(1 + 2n) searches for k loci and n permutations, and a search grows fast with taxa: the default 99 permutations over seven Neisseria MLST loci took 23 s on 12 strains, 48 s on 16 and 122 s on 20, and one search of the 62-strain concatenation takes about 8 s, so 62 strains is hours. Each file is one locus; records wired with no file are grouped by the part of their name before ` · `.

Silently recode the internal Type-IIS sites inside a part's coding sequence so the part can be used in a Golden Gate assembly — same protein, no recognition site. Only occurrences the given CDS covers can be fixed this way; any outside it are reported untouched rather than skipped quietly, because a site in a promoter needs a different answer.

Self-similarity or pairwise comparison of the subject as a dot plot — repeats, inversions and shared regions. Three real engines: exact k-mer (FlexiDot/dottup), windowed identity (seqinr) and windowed substitution-matrix scoring (EMBOSS dotmatcher), which answer different questions.

All-against-all dot plot over a sequence SET — EMBOSS `polydot`. Every ordered pair is plotted with the exact k-mer engine and laid out as an N×N grid, so shared regions, repeats and inversions across a whole family are visible in one picture. Answers a different question from `dot_plot`, which compares exactly two: this one ranks which members share material and how much. Wire many upstream record/sequence outputs into `sequences`, or name library documents.

Draw a block of an alignment as an SVG figure: the rows named, the residues shaded by how much of their column agrees with them, the column numbers over the block and Easel's Clustal conservation line under it. Wire `alignedSequences` from align_sequences. Name the window around whatever you are asking about — a variable site, a motif, a gap — because a 2,000-column alignment drawn at once shows nothing.

Run an agarose gel and photograph it: every lane's fragments migrated by the validated pydna model, drawn as a gel-doc image with the marker ladder's bp marks and each lane's name. The same plate the gel panels draw, so the figure and the rail put every fragment in the same place. Wire `fragments` from a digest or `lengths` from an assembly into `lanes`. A fragment the calibrating curve cannot place is COUNTED in `offScale`, never drawn at the well.

Draw a window of a Sanger read as an SVG figure: the four dye traces over their called bases, the per-base Phred bars and a base ruler. The same geometry the Chromatogram tab draws with, so the figure and the tab put every peak in the same place. Name the window around whatever you are asking about — a mutation site, a trim bound, an ambiguous call — because a whole 1,000-base read drawn at once shows nothing.

Draw a tree as an SVG figure — rectangular, slanted, circular or unrooted, as a phylogram or a cladogram, with tip names, branch support and a scale bar. The same layout the phylogeny panel draws with, so the figure and the panel place every node identically. Wire `newick` from build_tree or edit_tree.

Run a sequence through EMBL-EBI's Job Dispatcher: Clustal Omega, MUSCLE, MAFFT, Kalign, T-Coffee, EMBOSS needle/water/matcher/stretcher, LALIGN, phmmer, hmmscan, PSI-BLAST or Phobius. These are the reference implementations a methods section names, so a local alignment can be checked against the tool the field actually cites. The sequences LEAVE THE MACHINE.

Enumerate a small molecule's protonation states across a pH window with Dimorphite-DL (Ropp et al. 2019): each ionisable group it recognizes (substructures with pKa means and spreads taken from measured pKa values) is kept protonated, deprotonated or both, and every combination is returned as SMILES. Reproduces Dimorphite-DL 2.1.0, including that it neutralizes charged groups first and keeps only the part it neutralized.

Run a reaction SMARTS over lists of reactants, every combination, with RDKit's reaction engine: one list per reactant template, in template order. Pick one of 94 library reactions (the 58 robust organic reactions of Hartenfeller et al. 2011 and 36 click-chemistry reactions, as AutoGrow4 encodes them) or pass your own SMARTS. Each product is sanitised; a product set is kept only when every product in it sanitises. Indices are 0-based.

Resolve one of your saved enzyme collections to the enzyme names in it, so a later step can scan, digest or design with 'my Golden Gate set' by name instead of whatever happens to be selected. Names the collection, says which of its enzymes the cut catalog can resolve and which it cannot, and — when a record is open — how many times each one cuts it. Left unnamed it answers for the collection that is currently active, and says that is what it did.

Per-enzyme cut counts on the open plasmid (the EcoRI² superscript-badge numbers).

The effect a power calculation needs, measured from a pilot instead of guessed: two groups of one measurement in a table, standardized as Hedges' g (default), Cohen's d or Glass's Δ with its noncentral-t confidence interval (effectsize 1.0.3, reproduced), and the two-sample t design sized at the estimate and at the interval limit nearest zero. A column can be subtracted row by row first (a reference gene's Ct, giving delta-Ct). Returns the `design` calculate_power takes: Cohen's d for the `t` test, the raw difference and SD for `t_raw`.

Write an index set out in the form the next step needs: a CSV or TSV order sheet, FASTA, an IDT bulk-input sheet of the bare tags, an Illumina BCLConvert SampleSheet, or the actual oligos — adapters built on a template, or primers carrying the tag — with the junction warnings that emission produces.

Write a construct's recorded build out as a document: a methods section, a step spreadsheet, the full decoded record, the molecule carrying its own history as GenBank qualifiers, the whole strategy as an OpenCloning document, the runnable QUEEN script that rebuilds it, or the build as an SBOL 2 document. This is the Export tab of the History & Provenance panel (the same seven writers), refusing the same formats that source cannot produce.

Render the open plasmid's circular map to a publication SVG string — the same figure the Export panel draws, with the same knobs and the same defaults. Give it enzymes to draw the outer restriction-site ring.

Write a Sanger read out in any of the eight formats the trace editor's Export section offers, and hand the file back as TEXT in the pipeline rather than as a download. Reports what the chosen target DROPPED — a read written as FASTA loses its annotations, and every target but FASTQ loses the per-base quality — because those losses are invisible in the file itself. Trims the ends first when asked, by the same three methods the Trim section offers, so a graph does not need a separate step to write a trimmed read.

Convert a tree between the four formats this workbench reads and writes — Newick, NEXUS, PhyloXML and NeXML — sniffing the input format rather than making the caller declare it. Newick loses annotations the richer formats carry, which is why the conversion is a step you choose rather than something done silently on export.

FastQC's report on FASTQ reads, every module a default FastQC run reports: per-base quality boxes, per-tile quality (when the headers carry a tile), per-sequence quality, per-base sequence content, per-sequence GC against FastQC's theoretical normal, per-base N content, sequence length distribution, duplication levels, overrepresented sequences with their possible source, and adapter content, each with FastQC's own pass/warn/fail grade and the limit it was graded on. The numbers are FastQC 0.13.0's, checked against the real program, including its quirks: a read's mean quality is the integer mean of its characters, GC is counted on the read cut to a whole 100 (or 1,000) bases, duplication is counted on the first 50 bases, and an adapter found at a position counts at every position after it, so the curve is cumulative. FastQC does not detect the encoding: Phred+33 unless you say 64. It does not trim or filter anything.

Fetch a sequence by accession from an authoritative archive (NCBI Nucleotide or Protein, ENA, UniProtKB, the iGEM Registry, Addgene, or the EBI Dbfetch gateway) and hand it downstream as a real record with its annotations. This is how a pipeline starts from a published sequence rather than from whatever happens to be open.

Keep only the rows of a table-shaped output that meet a condition — the bands above a size, the guides over a score, the assays under a penalty. Emits the kept rows plus how many were dropped, so a downstream gate can act on the count.

Resolve an organism to its published genome assemblies and the chromosomes, plasmids and organelles each one is made of, with every accession and length NCBI reports. This is how a pipeline starts from a SPECIES rather than from an accession somebody looked up by hand: hand the replicon accession it returns to fetch_record, with a region, to pull a window of that chromosome. Assemblies come back reference-first, so the default pick is the canonical genome.

Short linear motifs in a protein: degrons, docking sites, targeting signals, cleavage and modification sites — the three-to-eleven-residue functional sites a profile-HMM domain scan cannot see. Runs ELM's own class patterns ON THIS MACHINE; only the class table is fetched. Applies ELM's context filters: the chance-probability cutoff, family selection, and the globular-domain filter when you pass domains. It does NOT scan for DOMAINS — for those call scan_protein_domains, which submits to EMBL-EBI InterProScan and returns `domains` in exactly the form this tool's `domains` parameter takes.

Find open reading frames on BOTH strands of the subject (origin-spanning when circular).

Find known SNPs under primers, the check NCBI Primer-BLAST makes with "Primer binding site may not contain known SNP". The template is placed on the UCSC assembly it was cut from, and the placement is proved by comparing the assembly's own sequence with the template; dbSNP 155 is then read over that span from the UCSC Genome Browser, and every primer is reported with the SNPs under it and each one's distance from the 3' end. `excluded` is the SNP spans in the form design_primer_pairs takes, to design around them. The template's sequence does not leave the machine; the assembly, chromosome and span are sent to UCSC.

Cut positions of the given enzymes on the open plasmid (top/bottom cut, overhang, kind).

Where the given enzymes could ALSO cut the open plasmid under non-standard conditions, from REBASE's own star-activity list and its one-base rule. Not cut sites: these need low ionic strength, high pH, Mn²⁺ for Mg²⁺, glycerol, DMSO or some detergents, and are what turns an over-digested reaction into a band pattern that reads as the wrong clone.

Fold a guide RNA — the spacer alone, and the whole sgRNA on a real published scaffold — and report which bases of the spacer pair with the scaffold. A spacer that base-pairs into the scaffold disrupts the structure Cas9 binds, which is a physical cause of a dead guide rather than a score. Every free energy is a minimum-free-energy fold under the Turner 2004 nearest-neighbour parameters, in kcal/mol, cross-checked against ViennaRNA 2.7.2.

Minimum-free-energy secondary structure (dot-bracket + ΔG) of an RNA/DNA sequence (Turner-2004).

Theoretical MS/MS fragment ion ladder of a peptide: a, b, c from the N-terminus and x, y, z from the C-terminus, with neutral-loss and radical variants, at each charge up to a maximum (validated against pyteomics, cross-checked against OpenMS). Takes ProForma modification tags (a signed mass, a Unimod name, or UNIMOD:accession) on residues and termini.

Overlap-extension (fusion) PCR — join fragments that share terminal homology into one product, carrying their features across (pydna). Emits the fused product as a NEW record.

Two-channel ddPCR droplet-amplitude exports to a template concentration, by CLASSIFYING the raw droplets rather than trusting a count the instrument already made. Four steps in a fixed order, each of which needs the previous one's output: a k-means quality check marks wells whose two droplet clusters are not separable, a plate-wide 1%-slice IQR cutoff marks outlier droplets, a two-component Gaussian mixture per well per channel sets the empty-droplet cutoff on the droplets that survive, and the empty fraction inverts through the Poisson zero term to copies/uL. Reports the cluster the droplets landed in and the reason any well was rejected, so a failed well reads as rejected rather than as a concentration. This is the counterpart of `quantify_dpcr`, not a duplicate: that one starts from per-well positive COUNTS an instrument already classified, this one starts from the amplitudes and does the classifying.

GC fraction of the subject — whole-sequence, or a sliding window profile (DnaChisel).

Preranked gene set enrichment analysis (GSEA; Subramanian et al. 2005) with fgsea's multilevel p-values (Korotkevich et al.), as clusterProfiler's GSEA() runs it (enrichit 0.2.6): weighted running-sum enrichment score, normalized ES against size-matched permutations, multilevel Monte Carlo p-values down to eps, adjusted p and q-value, rank at maximum, leading-edge genes. Seeded: a seed reproduces upstream's p-values exactly, and every set is bit-identical to enrichit in R on pasilla's DESeq2 Wald statistics against every fly GO term.

Over-representation analysis (ORA): which gene sets hold more of a gene list than chance, by the one-sided hypergeometric test against a background, as clusterProfiler's enricher() runs it (enrichit 0.2.6). Reports gene and background ratios, fold enrichment, odds ratio, z-score, p, adjusted p and Storey q-value per set, and which sets pass both cutoffs. Every tested set is bit-identical to enrichit in R on pasilla's DE genes against every fly GO term.

3D conformers of a small molecule by OpenChemLib's torsion-library generator, each scored and optionally minimized under MMFF94, MMFF94s or MMFF94s+ (whose MMFF94 equals Halgren's OPTIMOL on all 761 validation-suite structures), lowest energy first, as molfiles with every hydrogen; for a 3D molfile also the energy of its own geometry. Energies in kcal/mol.

Principal components of a call set's genotypes, the population-structure picture: biallelic sites above a minor-allele count, LD-pruned by sliding windows, scaled per site (Patterson, standard or centring) and decomposed; every sample's coordinates with its population, and the variance each component explains (scikit-allel pca). Validated on 1000 Genomes phase 3 APOL1, all 2,504 samples.

What a construct was BUILT from: the recorded operations, the molecules they consumed, how many rounds deep the build goes, and which of the 5 sources the record came from. This is the build history, not the edit history — for what CHANGED in a document and when, call get_document_history instead.