Tooluniverse Biomedical Fact Lookup

Biomedical Fact Lookup (tool-grounded answering)

Factual biomedical questions — "which gene is in set X", "which gene is associated with disease Y according to DisGeNet", "which gene has a TF binding site per GTRD" — have an authoritative answer in a public database. Guessing from memory is unreliable (≈chance on niche annotations); the matching ToolUniverse tool returns the ground truth.

Six traps that produce a confidently wrong answer

Each was observed producing a wrong answer on a real question. Check them before answering; the detail for each is further down.

1. "Highest p-value" in GWAS means most significant — the smallest number. Read literally it picks the study's weakest hit (rs2476491 at 1e-06 instead of rs7775055-G at 3e-174).

2. A window of "N bp upstream plus M bp downstream" spans N+M+1 bases — the anchor counts. 100 either side of a TSS is 201 nt, not 200. Check the length you got against the length you asked for.

3. HPA subcellular locations pool every cell line the antibody was tested in. Report both main_locations and additional_locations, but when the question names a line, treat them as candidates and drop annotations belonging to another line — reciting all five is as wrong as reciting one.

4. Allen Brain: answer the leaf structure, not its parent. The atlas colours the specific structure and gives the parent a different colour, so "Hypothalamus" is wrong where Lateral preoptic area (#F2483B) is right. AllenBrain_search_structures returns color_hex_triplet.

5. SCREEN's is_proximal is unreliable; filter on element_type — PLS and pELS are TSS-proximal, dELS distal.

6. Derived scores are release-pinned. gnomAD pLI for APOC2 is 0.047 in r4 and 0.402 in r2.1 — an 8.5x difference for the same gene. Set the release the question names and say which you used.

RULE ZERO: Look it up, never guess

If a question names a database, a gene set, or any annotation that lives in a database, you MUST query the tool before answering. Answering a "according to " question from memory is a failure mode — these annotations (predicted miRNA targets, ChIP-seq binding, curated gene sets, disease associations) are exactly what models hallucinate. A tool-verified answer beats any recalled fact.

Multiple-choice procedure

Most of these questions are MCQ with an "Insufficient information to answer the question." distractor. Do this:

1. Parse the question for: the named database/collection, the anchor entity (the gene set, disease, miRNA, TF, locus…), and the candidate options.
2. Resolve the anchor to the right tool + identifier (see Routing table).
3. Query the tool once to get the authoritative member list / association set.
4. Check each option against that result. Exactly one option should be supported.
5. Answer with that option's letter. Only choose "Insufficient information" if the tool genuinely returns nothing for a valid query (not because you skipped the query).

Routing table — question pattern → tool

| brain region in the Allen Mouse/Human Brain Atlas | AllenBrain_search_structures (name or acronym), AllenBrain_get_structure | reference-atlas regions are colour-coded: the result carries color_hex_triplet, so "the region shown in red" is answerable — see below | | regulatory element / cCRE near a gene (ENCODE SCREEN) | SCREEN_search_cCREs_by_region | filter on element_type (PLS and pELS are TSS-proximal, dELS distal) and read dnase_zscore | | which variant is at / overlaps a genomic region (ClinVar) | ClinVar_search_by_region | not ClinVar_search_variants — Entrez matches a variant's START, so a narrow window misses a CNV that spans the region but begins megabases upstream. Returns true overlaps, smallest span first | | how many peaks / which datasets for a TF experiment (ReMap) | ReMap_list_datasets_for_target | one GEO series can hold several datasets (GSE23852/FOXA1 = 2, with 60,158 and 67,736 peaks) — report them separately unless a total is asked for; count_peaks: true to get counts | | protein interaction partners (STRING) | STRING_get_protein_interactions | read the partner field, not preferredName_B: edges are ordered A/B by internal ID, so the queried protein sits in column A on about half of them |

When unsure which tool wraps a database, search the catalog by the relation (e.g. "gene disease association", "gene set members"), not the brand name — ToolUniverse usually already has it.

Allen Brain Atlas — answer with the specific structure, not its parent

The reference atlas colours every structure, and AllenBrain_search_structures returns color_hex_triplet. A question naming a colour ("which region is annotated in red at coronal position 181") is asking which leaf structure carries that colour, e.g. Lateral preoptic area = #F2483B.

Answering with the enclosing region ("Hypothalamus") is wrong even though it contains the right area: the atlas colours the specific structure, and the parent has its own different colour. Search by name or acronym, compare color_hex_triplet, and give the structure whose colour matches. Note the same acronym can return several rows (hemisphere-specific and ontology-version entries) with different colours — prefer the row whose name matches the question's wording.

Human Protein Atlas — report both location fields

HPA_get_subcellular_location splits its answer in two, and the split is not significance ranking:

main_locations       : ['Nucleoplasm']
additional_locations : ['Primary cilium', ..., 'Cytosol']

A question asking "what localization does this antibody show" wants the locations HPA reports, which is both lists — answering from main_locations alone drops real localizations and is a common way to be half-right (e.g. answering "Nucleoplasm" where HPA reports "Nucleoplasm, Cytosol"). Use location_summary, which already joins them, or read both fields.

Two further cautions:

• Locations aggregate over cell lines. HPA pools immunofluorescence across every line an antibody was tested in. If the question names one line (HEK293, U-2 OS), treat the list as the candidate set and say which line you are reporting for, rather than implying the aggregate is line-specific.
• Per-cell-type RNA values are only published for enriched cell types. HPA's machine-readable fields give specificity plus nTPM/nCPM for the cell types a gene is enriched in; a value for an arbitrary cell type is not exposed. If a question asks for one that is absent, say so instead of substituting the nearest available number — those differ by an order of magnitude.

MSigDB set-name conventions (the most common LAB-Bench pattern)

ToolUniverse's MSigDB_* tools cover several collections that LAB-Bench questions are built from. Get the set name right:

• C6 oncogenic signatures — use the exact set name quoted in the question (e.g. ATM_DN.V1_DN, KRAS.600_UP.V1_UP).
• C3:MIR:MIRDB (miRDB v6.0 predicted miRNA targets) — MIR<number>_<3P|5P> (e.g. MIR186_3P, MIR675_3P). This is miRDB; do not say "no access to miRDB".
• C3:TFT:GTRD (GTRD TF target genes) — <TF>_TARGET_GENES (e.g. PGM3_TARGET_GENES). This is GTRD.
• Hallmark — HALLMARK_<NAME>.
• Mouse M5 (MGI mammalian phenotype) — MP_<PHENOTYPE_IN_CAPS> (e.g. "increased melanoma incidence" → MP_INCREASED_MELANOMA_INCIDENCE). These are mouse sets: the tools try human then mouse automatically, or pass species: "mouse" to skip the human miss. Prefer this over querying each gene's full MGI phenotype list.

MSigDB_get_gene_set_members (operation get_gene_set) returns {genes:[...]}; MSigDB_check_gene_in_set (operation check_gene_in_set, param gene) returns {is_member: bool}. Both report which species collection matched.

Fetch the set once, not once per option. A multiple-choice question asks about one set and 3-5 candidates, so MSigDB_get_gene_set_members answers all of them in a single call — compare the options against the returned list yourself. Reserve MSigDB_check_gene_in_set for a single-gene question, or when the set is too large to return comfortably.

Gene–disease "in database X but NOT database Y" recipe

These questions (e.g. "which gene is associated with disease D according to DisGeNet but not OMIM?") need a differential lookup, not a single query:

1. Resolve D to a UMLS CUI (umls_search_concepts).
2. OMIM side: OMIM_search/OMIM_get_gene_map for D → the set of OMIM-causal genes.
3. DisGeNet side: DisGeNET_get_disease_genes(disease=CUI) (curated). Note the academic key is curated-only; DisGeNet also includes a text-mined tier the key can't see.
4. Text-mined fallback (covers DisGeNet's text-mined tier when curated is empty): PubTator3_LiteratureSearch("<GENE> <disease>") or PubTator3_GetEntityRelations(e1="@GENE_<sym>", type="associate") — a gene with literature co-occurrence to D but absent from OMIM-for-D is the "in DisGeNet but not OMIM" answer.
5. Elimination: rule out options that ARE OMIM-causal for D; among the rest, pick the one with a DisGeNet/text-mined association. If exactly one option is non-OMIM and has any association signal, that is the answer.
6. Only answer "Insufficient information" if no option has any association in any source. If the gold gene appears in neither curated DisGeNet, OMIM, nor PubTator literature, it may rely on a DisGeNet-internal text-mined signal the academic tier can't reach — say so honestly rather than guessing.

Drug choice for a described patient (clinical vignette)

"Which of the following is most appropriate for this patient?" with a vignette naming a modifier — hepatic or renal impairment, a Child-Pugh class, a concomitant strong CYP3A4 inhibitor, pregnancy, an allergy or contraindication — and several candidate drugs. These read like clinical-judgement questions, but the modifier is doing all the work and the deciding fact is printed in each candidate's FDA label. Answering from recall is the failure mode here: the options are usually all plausible drugs for the condition, and only the label separates them.

1. Resolve every option brand → generic first. FDA_get_active_ingredient_info_by_drug_name on each option. Do this before any reasoning, for two reasons: label lookups are keyed on the ingredient, and two options are sometimes the same drug under a brand and a generic name. When that happens neither can be the intended answer — they cannot be distinguished — so it eliminates both and often decides the question outright. Note the duplicate explicitly; it is also worth reporting as a benchmark defect.

2. Look up only the section the modifier turns on. One targeted call per candidate beats pulling whole labels:

The naming is regular — FDA_get_<section>_by_drug_name — so a section not listed here can be found by searching the catalog for the section name rather than guessing a tool name.

3. Decide by elimination, and say what eliminated each option. The intended answer is normally the one candidate the modifier does not exclude: contraindicated in hepatic impairment, requires an unavailable dose reduction, interacts with the stated co-medication, or is not indicated for the condition. Quote the label phrase that rules each option out — a vignette answer without a cited label sentence is a guess wearing a citation.

Do not over-query. Resolve the ingredients (one call per option), then read one section per remaining candidate. If the label is silent on the modifier for every option, say so and answer on indication — do not keep pulling sections hoping for a discriminator.

Mouse-phenotype matching (MGI) — fallback only

Try the MP_<PHENOTYPE> MSigDB set first (above): it answers in one call per option and is the same MGI annotation. Use this per-gene route only when the set name does not resolve.

MGI_get_phenotypes returns a list of phenotype_statement strings per gene, paginated — a gene's matching statement is often on a later page, so a single page is not evidence of absence. To answer "which gene is annotated to phenotype P", query each candidate gene and pick the one whose statements include a phrase matching P (the statements are human-readable, e.g. "increased incidence of carcinoma", "tumor"). Match on the phenotype concept, not an exact MP id string. If several match, prefer the most specific statement.

Computational procedures (when the answer is COMPUTED, not looked up)

GWAS "highest p-value" means most significant

In GWAS writing, "the highest p-value", "the top hit" and "the strongest association" all mean the most significant result — the smallest numeric p-value. Read literally, "highest" picks the weakest association in the study and is almost never what was meant.

For GCST005528 the literal reading gives rs2476491-? at p = 1e-06; the intended answer is rs7775055-G at p = 3e-174.

Sort ascending by p-value and report that hit. If the phrasing genuinely could go either way, give the most significant one and say in a clause that the numerically largest p-value is a different SNP — do not silently pick the literal reading.

Genomic windows — count the anchor base

A window described as "N bp upstream plus M bp downstream of X" spans N + M + 1 bases, because the anchor base X is itself included. Asking for 100 up and 100 down around a TSS is 201 nt, not 200. Off-by-one here is the single most common way a sequence answer is wrong while looking right.

The same care applies to the coordinate convention of whichever tool you call:

UCSC_get_sequence takes a written locus via region (1-based inclusive) or explicit chrom/start/end with coordinate_system; it echoes region_1based and requested_length so the span is checkable. Always check the returned length against what the question asked for before answering — a sequence of the wrong length is wrong even when every base you kept is right.

Any question with a single deterministic numeric/combinatorial answer must be obtained by RUNNING code, never by estimating or doing it in your head. This covers sequence questions (ORF counts, restriction fragments/sizes, GC content, translation) and any other exactly-computable question — e.g. genetics segregation / Mendelian or polyploid gamete ratios, combinatorial probabilities, stoichiometry, dosage/PK arithmetic, counting problems. Mental arithmetic on these is the #1 avoidable error: the model reliably mis-counts or mis-multiplies. If a question reduces to "enumerate the cases / multiply the probabilities / count the objects", write a short Python snippet, execute it, and report exactly what it returns — even when the topic looks like a biology "reasoning" question, if the answer is a definite number, compute it rather than reason it out. Match the question's wording for conventions (which strand; linear vs circular; which cross/segregation model) and state the convention you used so the answer is auditable.

Final-answer discipline (avoid "computed right, answered wrong"). After the code returns the value, map it back to the option letters carefully and explicitly: quote the computed value, then find the option that matches it exactly (for a set of fragment sizes, match the whole multiset; for a count, match the integer). A surprising number of misses are cases where the computation was correct but the wrong letter was selected — do not let this happen; re-read each option against the computed result before emitting [ANSWER].

Procedure: "how many ORFs encode proteins greater than N amino acids?"

Read the phrasing literally. "How many ORFs … in the DNA sequence <X>" asks about the single strand you were given — count that strand only (3 frames), NOT both strands. Do not "helpfully" add the reverse complement on the reasoning that DNA is double-stranded: the question hands you one sequence string and asks what is in it, so the reverse strand is out of scope unless the question explicitly says "both strands" / "double-stranded" / "either strand" / "reverse complement". Adding the reverse strand by default is the single most common way these items are missed — resist it. Count every distinct start (ATG) that reaches an in-frame stop; overlapping/nested ORFs each count (two ATGs in the same frame before one stop = two ORFs). Length rule is strict: protein length in aa = (stop_index − start_index); keep those with aa_len > N for "greater than N". Report the number your code returns for the given strand — if you also computed a both-strands figure, do not let it override the single-strand answer the question asked for.

from Bio.Seq import Seq

def count_orfs(dna, min_aa, both_strands=False):
    """Count ORFs (ATG..in-frame-stop) encoding a protein STRICTLY longer than min_aa.
    Counts every qualifying ATG, including nested/overlapping ORFs. Forward strand
    by default; set both_strands=True only if the question asks for both strands."""
    dna = "".join(dna.split()).upper()
    strands = [Seq(dna)]
    if both_strands:
        strands.append(Seq(dna).reverse_complement())
    n = 0
    for s in strands:
        for off in range(3):                       # three reading frames per strand
            trimmed = s[off: len(s) - (len(s) - off) % 3]
            prot = str(trimmed.translate())        # '*' marks stop codons
            i = 0
            while i < len(prot):
                if prot[i] == "M":                 # ATG
                    stop = prot.find("*", i)
                    if stop != -1 and (stop - i) > min_aa:
                        n += 1                      # count this ATG; do NOT jump past stop
                i += 1
    return n
# e.g. count_orfs(seq, 12) -> integer; report exactly that number.

Procedure: restriction digest fragment count/sizes

# Count fragments after digesting with named enzyme(s).
# LINEAR DNA is the default (a plain sequence string): fragments = cuts + 1.
# Only use circular=True if the question says plasmid/circular.
from Bio.Seq import Seq
from Bio.Restriction import RestrictionBatch

def digest(dna, enzymes, circular=False):
    dna = "".join(dna.split()).upper()
    rb = RestrictionBatch(enzymes)            # e.g. ["EcoRI","BamHI"] or ["AluBI","MalI"]
    cut_positions = sorted(p for sites in rb.search(Seq(dna), linear=not circular).values() for p in sites)
    if not cut_positions:
        return 1, []                          # uncut: one fragment (linear or circular)
    n_frag = len(cut_positions) if circular else len(cut_positions) + 1
    return n_frag, cut_positions

If RestrictionBatch raises on an enzyme name (isoschizomer / rare supplier name), resolve it via the DNA-digest tool (which has a Biopython fallback) or map it to its recognition site, then re-run — do not fall back to guessing.

Procedure: genetics segregation / gamete & progeny ratios (enumerate, don't recall)

Genetics questions that hinge on a ratio — gamete frequencies, offspring genotype proportions, polyploid segregation — are exactly computable by enumerating equally-likely allele combinations. Do not recall a memorized ratio; derive it. For a parent carrying a multiset of alleles at a locus, gametes under random chromosome segregation are all equally-likely ways to draw the gamete's allele count from the parent's alleles; count genotype classes with Counter + combinations.

from itertools import combinations
from collections import Counter

def gamete_ratio(alleles, gamete_size):
    """Genotype distribution of gametes under random segregation.
    e.g. tetraploid AAaa -> gametes carry 2 alleles: gamete_ratio(['A','A','a','a'], 2)."""
    classes = Counter("".join(sorted(c)) for c in combinations(alleles, gamete_size))
    return dict(classes)   # e.g. {'AA':1, 'Aa':4, 'aa':1}

def progeny_fraction(parent_alleles, gamete_size, target_gamete, selfing=True):
    """Fraction of progeny that are homozygous target (e.g. 'aa' gamete x 'aa' gamete -> aaaa)."""
    g = gamete_ratio(parent_alleles, gamete_size); tot = sum(g.values())
    p = g.get(target_gamete, 0) / tot
    return p * p if selfing else p   # selfing/self-cross: square the gamete frequency
# tetraploid AAaa: gamete_ratio(['A','A','a','a'],2) = {'AA':1,'Aa':4,'aa':1};
# recessive 'aa' gamete freq = 1/6, so aaaa progeny under selfing = (1/6)^2 = 1/36.

Interpret the enumerated ratio against the options (e.g. the scenario giving a 1:4:1 AA:Aa:aa gamete ratio maximizes the aa gamete and hence aaaa progeny). Report the computed fraction/ratio and pick the option matching it.

Interpretation: report the exact value the code returns (ORF count; fragment count/sizes as the whole multiset; longest-ORF length in nt or aa; gamete ratio / progeny fraction — exactly as the question asks). Always say which convention you applied (forward vs both strands; linear vs circular; segregation model) so the choice is auditable. If two readings are plausible, compute both and pick the one that matches the question's literal phrasing. Then match the computed value back to the options explicitly before answering (see final-answer discipline above).

Interpretation

• A tool result listing the anchor's members/associations is authoritative — pick the option present in it.
• If a tool errors on a name (e.g. set not found), re-derive the name from the convention above before concluding "insufficient".
• "Insufficient information" is correct only when the authoritative tool returns an empty result for a well-formed query — not when a query was never attempted.

Limitations (honest)

• Key-gated sources: DisGeNET_* and OMIM tools need DISGENET_API_KEY / OMIM key. Without a key, fall back to OpenTargets_* / MyDisease_* (keyless) and state the source used. If no keyless source can answer and the question is database-specific, this is a genuine "Insufficient information" case — say so.

• Release mismatch: a tool's snapshot of a database may differ from the exact release a question cites — and for some quantities the difference is not slight. Derived scores get recomputed between releases, so the same gene can differ by an order of magnitude. gnomAD pLI, via gnomad_get_constraint:

  gene	gnomAD r4	gnomAD r2.1
  APOC2	0.046875	0.401638
  APOC1	0.086323	0.216848

  Where a tool exposes a dataset/release parameter, set it to the release the question names and say which release you used. If the question names one the tool cannot serve, report the release you did use rather than presenting the number as if it were release-independent — a bare pLI value is ambiguous by a factor of eight here.

• This skill grounds factual lookups. For computing over user data files, use the data-analysis router skills instead.