diff --git a/Makefile b/Makefile
index f3779003..8d49d064 100644
--- a/Makefile
+++ b/Makefile
@@ -101,7 +101,7 @@ mongorestore-nmdc-db:
 	mkdir -p /tmp/remote-mongodump/nmdc
 	# SSH into the remote server, stream the dump directory as a gzipped tar archive, and extract it locally.
 	ssh -i ~/.ssh/nersc ${NERSC_USERNAME}@dtn01.nersc.gov \
-		'tar -czf - -C /global/cfs/projectdirs/m3408/nmdc-mongodumps/dump_nmdc-prod_2024-07-29_20-12-07/nmdc .' \
+		'tar -czf - -C /global/cfs/projectdirs/m3408/nmdc-mongodumps/dump_nmdc-prod_2024-11-25_20-12-02/nmdc .' \
 		| tar -xzv -C /tmp/remote-mongodump/nmdc
 	mongorestore -v -h localhost:27018 -u admin -p root --authenticationDatabase=admin \
 		--drop --nsInclude='nmdc.*' --dir /tmp/remote-mongodump
diff --git a/docs/nb/bulk_validation_referential_integrity_check.ipynb b/docs/nb/bulk_validation_referential_integrity_check.ipynb
index 06a01ec8..9defa5e5 100644
--- a/docs/nb/bulk_validation_referential_integrity_check.ipynb
+++ b/docs/nb/bulk_validation_referential_integrity_check.ipynb
@@ -37,7 +37,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "mongodb://localhost:27018\n"
+      "localhost:27018\n"
      ]
     }
    ],
@@ -93,7 +93,7 @@
     {
      "data": {
       "text/plain": [
-       "'11.0.0rc22'"
+       "'11.1.0'"
       ]
      },
      "execution_count": 3,
@@ -140,15 +140,7 @@
    "id": "bcb5802b-8205-49b7-8784-dc137baff1a0",
    "metadata": {},
    "source": [
-    "## Check for errors in the database"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1ab96cda-30ab-4e93-a0b1-3a936599305d",
-   "metadata": {},
-   "source": [
-    "The `nmdc_schema_collection_names` function returns the populated (having at least one document) set-intersection of (a) the set of collection names present in the Mongo database and (b) the set of Database slots in the schema that correspond to a collection (defined as being multivalued and values being inlined as a list)."
+    "## Create slot mappings"
    ]
   },
   {
@@ -156,18 +148,9 @@
    "execution_count": 5,
    "id": "1d76b70e-4412-4b17-9db9-322ac791859a",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'study_set', 'workflow_execution_set', 'material_processing_set', 'instrument_set', 'data_object_set', 'configuration_set', 'biosample_set', 'functional_annotation_agg', 'calibration_set', 'processed_sample_set', 'field_research_site_set', 'data_generation_set'}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "collection_names = get_nonempty_nmdc_schema_collection_names(mdb)\n",
-    "print(collection_names)"
+    "collection_names = populated_schema_collection_names_with_id_field(mdb) # `get_nonempty_nmdc_schema_collection_names` to include \"functional_annotation_agg\""
    ]
   },
   {
@@ -211,107 +194,6 @@
     "}"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "12e7d00e-0ec4-45de-b0da-1b618ef7e80b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def collect_errors(note_doc_field_errors):\n",
-    "    errors = {\"bad_type\": [], \"no_type\": [], \"bad_slot\": [], \"is_null\": []}\n",
-    "    n_docs_total = sum(mdb[coll_name].estimated_document_count() for coll_name in collection_names)\n",
-    "    pbar = tqdm(total=n_docs_total)\n",
-    "    n_errors_cache = 0\n",
-    "    for coll_name in sorted(collection_names):\n",
-    "        cls_names = collection_name_to_class_names[coll_name]\n",
-    "        pbar.set_description(f\"processing {coll_name}...\")\n",
-    "        # Iterate over each document (as a dictionary) in this collection.\n",
-    "        for doc in mdb[coll_name].find():\n",
-    "            doc = dissoc(doc, \"_id\")\n",
-    "            \n",
-    "            # Ensure we know the document's type.\n",
-    "            cls_name = None\n",
-    "            cls_type_match = re.match(r\"^nmdc:(?P<name>.+)\", doc.get(\"type\", \"\"))\n",
-    "            if cls_type_match is not None:\n",
-    "                cls_name = cls_type_match.group(\"name\")\n",
-    "                if cls_name not in cls_names:\n",
-    "                    errors[\"bad_type\"].append(f\"{coll_name} doc {doc['id']}: doc type {cls_name} not in those allowed for {coll_name}, i.e. {cls_names}.\")\n",
-    "                    cls_name = None\n",
-    "            elif len(cls_names) == 1:\n",
-    "                cls_name = cls_names[0]\n",
-    "            else:\n",
-    "                errors[\"no_type\"].append(f\"{coll_name} doc {doc['id']}: 'type' not set.\")\n",
-    "\n",
-    "            if cls_name is not None:        \n",
-    "                slot_map = cls_slot_map[cls_name]\n",
-    "                # Iterate over each key/value pair in the dictionary (document).\n",
-    "                for field, value in doc.items():\n",
-    "                    if field in slot_map:\n",
-    "                        if not isinstance(value, list):\n",
-    "                            value = [value]\n",
-    "                        for v in value:\n",
-    "                            note_doc_field_errors(value=v,field=field,doc=doc,coll_name=coll_name,errors=errors)                \n",
-    "                    else:\n",
-    "                        errors[\"bad_slot\"].append(f\"{coll_name} doc {doc['id']}: field '{field}' not a valid slot\")\n",
-    "            pbar.update(1)\n",
-    "            n_errors = sum([len(v) for v in errors.values()])\n",
-    "            if n_errors > n_errors_cache:\n",
-    "                print(f\"{n_errors} errors so far...\")\n",
-    "                n_errors_cache = n_errors\n",
-    "    pbar.close()\n",
-    "    return errors"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "14afb4c6-b0b7-4fd7-8e2f-13c682c74409",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def note_doc_field_errors(value=None, field=None, doc=None, coll_name=None, errors=None):\n",
-    "    # No fields should be null-valued.\n",
-    "    # Example of how this may happen: JSON serialization from pydantic models may set optional fields to `null`.\n",
-    "    if value is None:\n",
-    "        errors[\"is_null\"].append(f\"{coll_name} doc {doc['id']}: field {field} is null.\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "829039e5-7abe-4c50-ba44-e384b45b7535",
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "6c88577a3a9342808d3bbc0e3707a95a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "  0%|          | 0/2351449 [00:00<?, ?it/s]"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'bad_type': [], 'no_type': [], 'bad_slot': [], 'is_null': []}\n"
-     ]
-    }
-   ],
-   "source": [
-    "errors = collect_errors(note_doc_field_errors)\n",
-    "print(errors)"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "21c2f771-b8da-466a-90e8-2c17ac5e6388",
@@ -334,44 +216,74 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "98fbfdff-51d6-42c5-9448-3b4616a2c9cb",
+   "execution_count": 8,
+   "id": "11ac53f2-057e-471b-a260-f5a65e3361af",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Any ancestor of a document class is a document-referenceable range, i.e., a valid range of a document-reference-ranged slot.\n",
-    "document_referenceable_ranges = set(chain.from_iterable(schema_view.class_ancestors(cls_name) for cls_name in document_class_names))\n",
+    "# From https://github.com/microbiomedata/refscan/blob/af092b0e068b671849fe0f323fac2ed54b81d574/refscan/lib/helpers.py#L141-L176\n",
     "\n",
-    "document_reference_ranged_slots = defaultdict(list)\n",
-    "for cls_name, slot_map in cls_slot_map.items():\n",
-    "    for slot_name, slot in slot_map.items():\n",
-    "        if str(slot.range) in document_referenceable_ranges:\n",
-    "            document_reference_ranged_slots[cls_name].append(slot_name)"
+    "from typing import List\n",
+    "from linkml_runtime import linkml_model\n",
+    "\n",
+    "def get_names_of_classes_in_effective_range_of_slot(\n",
+    "    schema_view: SchemaView, slot_definition: linkml_model.SlotDefinition\n",
+    ") -> List[str]:\n",
+    "    r\"\"\"\n",
+    "    Determine the slot's \"effective\" range, by taking into account its `any_of` constraints (if defined).\n",
+    "\n",
+    "    Note: The `any_of` constraints constrain the slot's \"effective\" range beyond that described by the\n",
+    "          induced slot definition's `range` attribute. `SchemaView` does not seem to provide the result\n",
+    "          of applying those additional constraints, so we do it manually here (if any are defined).\n",
+    "          Reference: https://github.com/orgs/linkml/discussions/2101#discussion-6625646\n",
+    "\n",
+    "    Reference: https://linkml.io/linkml-model/latest/docs/any_of/\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Initialize the list to be empty.\n",
+    "    names_of_eligible_target_classes = []\n",
+    "\n",
+    "    # If the `any_of` constraint is defined on this slot, use that instead of the `range`.\n",
+    "    if \"any_of\" in slot_definition and len(slot_definition.any_of) > 0:\n",
+    "        for slot_expression in slot_definition.any_of:\n",
+    "            # Use the slot expression's `range` to get the specified eligible class name\n",
+    "            # and the names of all classes that inherit from that eligible class.\n",
+    "            if slot_expression.range in schema_view.all_classes():\n",
+    "                own_and_descendant_class_names = schema_view.class_descendants(slot_expression.range)\n",
+    "                names_of_eligible_target_classes.extend(own_and_descendant_class_names)\n",
+    "    else:\n",
+    "        # Use the slot's `range` to get the specified eligible class name\n",
+    "        # and the names of all classes that inherit from that eligible class.\n",
+    "        if slot_definition.range in schema_view.all_classes():\n",
+    "            own_and_descendant_class_names = schema_view.class_descendants(slot_definition.range)\n",
+    "            names_of_eligible_target_classes.extend(own_and_descendant_class_names)\n",
+    "\n",
+    "    # Remove duplicate class names.\n",
+    "    names_of_eligible_target_classes = list(set(names_of_eligible_target_classes))\n",
+    "\n",
+    "    return names_of_eligible_target_classes"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "d253c567-533f-440f-8376-03a6e1e905cf",
+   "execution_count": 9,
+   "id": "98fbfdff-51d6-42c5-9448-3b4616a2c9cb",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def doc_cls(doc, coll_name=None):\n",
-    "    \"\"\"Return unprefixed name of document class.\n",
+    "# Any ancestor of a document class is a document-referenceable range, i.e., a valid range of a document-reference-ranged slot.\n",
+    "document_referenceable_ranges = set(chain.from_iterable(schema_view.class_ancestors(cls_name) for cls_name in document_class_names))\n",
     "\n",
-    "    Try to get from doc['type'] (lopping off 'nmdc:' prefix).\n",
-    "    Else, if can unambiguously infer type given coll_name, use that.\n",
-    "    Else, return None.\n",
-    "    \"\"\"\n",
-    "    if 'type' in doc:\n",
-    "        return doc['type'][5:] # lop off \"nmdc:\" prefix\n",
-    "    elif coll_name and len(collection_name_to_class_names[coll_name]) == 1:\n",
-    "        return collection_name_to_class_names[coll_name][0]"
+    "document_reference_ranged_slots = defaultdict(list)\n",
+    "for cls_name, slot_map in cls_slot_map.items():\n",
+    "    for slot_name, slot in slot_map.items():\n",
+    "        if set(get_names_of_classes_in_effective_range_of_slot(schema_view, slot)) & document_referenceable_ranges:\n",
+    "            document_reference_ranged_slots[cls_name].append(slot_name)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 10,
    "id": "b2e618f3-78b9-42b6-8ea9-63d080b1b0f6",
    "metadata": {
     "scrolled": true
@@ -380,12 +292,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f63a4ce942bc4278b3e99a5a87b0155c",
+       "model_id": "47b7ed79df384cf98c527651021fe2cd",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "  0%|          | 0/2351449 [00:00<?, ?it/s]"
+       "  0%|          | 0/163175 [00:00<?, ?it/s]"
       ]
      },
      "metadata": {},
@@ -403,6 +315,8 @@
     "# Drop any existing `alldocs` collection (e.g. from previous use of this notebook).\n",
     "mdb.alldocs.drop()\n",
     "\n",
+    "BULK_WRITE_BATCH_SIZE = 2_000 # ensure bulk-write batches aren't too huge\n",
+    "\n",
     "# Set up progress bar\n",
     "n_docs_total = sum(mdb[name].estimated_document_count() for name in collection_names)\n",
     "pbar = tqdm(total=n_docs_total)\n",
@@ -411,12 +325,12 @@
     "    pbar.set_description(f\"processing {coll_name}...\")\n",
     "    requests = []\n",
     "    for doc in mdb[coll_name].find():\n",
-    "        doc_type = doc_cls(doc, coll_name=coll_name)\n",
-    "        slots_to_include = [\"id\"] + document_reference_ranged_slots[doc_type]\n",
+    "        doc_type = doc['type'][5:] # lop off \"nmdc:\" prefix\n",
+    "        slots_to_include = [\"id\", \"type\"] + document_reference_ranged_slots[doc_type]\n",
     "        new_doc = pick(slots_to_include, doc)\n",
-    "        new_doc[\"type\"] = schema_view.class_ancestors(doc_type)\n",
+    "        new_doc[\"_type_and_ancestors\"] = schema_view.class_ancestors(doc_type)\n",
     "        requests.append(InsertOne(new_doc))\n",
-    "        if len(requests) == 1000: # ensure bulk-write batches aren't too huge\n",
+    "        if len(requests) == BULK_WRITE_BATCH_SIZE: \n",
     "            result = mdb.alldocs.bulk_write(requests, ordered=False)\n",
     "            pbar.update(result.inserted_count)\n",
     "            requests.clear()\n",
@@ -467,22 +381,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 11,
    "id": "d0374653-c074-4a87-aef8-24323a5a63b3",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def doc_assertions(limit=0):\n",
-    "    \"\"\"Yields batches of 1000 assertions to greatly speed up processing.\"\"\"\n",
+    "def doc_assertions(limit=0, batch_size=2_000):\n",
+    "    \"\"\"Yields batches of assertions to greatly speed up processing.\"\"\"\n",
     "    # Initialize progress bar.\n",
     "    pbar = tqdm(total=(mdb.alldocs.estimated_document_count() if limit == 0 else limit))\n",
     "    rv = []\n",
     "    for doc in mdb.alldocs.find(limit=limit):\n",
     "        # Iterate over each key/value pair in the dictionary (document).\n",
     "        for field, value in doc.items():\n",
-    "            if field in (\"_id\", \"id\", \"type\"):\n",
+    "            if field.startswith(\"_\") or field in (\"id\", \"type\"):\n",
     "                continue\n",
-    "            slot_range = str(cls_slot_map[doc[\"type\"][0]][field].range) # assumes upstream doc type is listed first.\n",
+    "            acceptable_slot_classes = get_names_of_classes_in_effective_range_of_slot(\n",
+    "                schema_view,\n",
+    "                cls_slot_map[doc[\"type\"][5:]][field],\n",
+    "            )\n",
     "            if not isinstance(value, list):\n",
     "                value = [value]\n",
     "            for v in value:\n",
@@ -491,9 +408,9 @@
     "                    \"id_is_nmdc_id\": \"id\" in doc,\n",
     "                    \"field\": field,\n",
     "                    \"value\": v,\n",
-    "                    \"slot_range\": slot_range,\n",
+    "                    \"acceptable_slot_classes\": acceptable_slot_classes,\n",
     "                })\n",
-    "                if len(rv) == 1000:\n",
+    "                if len(rv) == batch_size:\n",
     "                    yield rv\n",
     "                    rv.clear()\n",
     "        pbar.update(1)\n",
@@ -503,7 +420,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 12,
    "id": "103d70b6-24ab-41bd-8b7f-d2faaa028bdf",
    "metadata": {
     "scrolled": true
@@ -512,12 +429,12 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c8c75b6bd622470f9ded8e3813fc1d64",
+       "model_id": "412f98740ae7449399a874b46adae748",
        "version_major": 2,
        "version_minor": 0
       },
       "text/plain": [
-       "  0%|          | 0/3039449 [00:00<?, ?it/s]"
+       "  0%|          | 0/163175 [00:00<?, ?it/s]"
       ]
      },
      "metadata": {},
@@ -527,21 +444,26 @@
    "source": [
     "from pprint import pprint\n",
     "\n",
+    "alldocs_ids = set(mdb.alldocs.distinct(\"id\"))\n",
+    "\n",
     "def doc_field_value_errors(assertions):\n",
     "    errors = {\"not_found\": [], \"invalid_type\": []}\n",
+    "    # group assertions by referenced \"id\" value.\n",
     "    assertions_by_referenced_id_value = defaultdict(list)\n",
     "    for a in assertions:\n",
     "        assertions_by_referenced_id_value[a[\"value\"]].append(a)\n",
+    "    # associate each referenced document id with its type.\n",
     "    doc_id_types = {}\n",
     "    for d in list(mdb.alldocs.find({\"id\": {\"$in\": list(assertions_by_referenced_id_value.keys())}}, {\"_id\": 0, \"id\": 1, \"type\": 1})):\n",
     "        doc_id_types[d[\"id\"]] = d[\"type\"]\n",
     "\n",
     "    for id_value, id_value_assertions in assertions_by_referenced_id_value.items():\n",
-    "        if id_value not in doc_id_types:\n",
+    "        if id_value not in alldocs_ids:\n",
     "            errors[\"not_found\"].extend(id_value_assertions)\n",
     "        else:\n",
     "            for a in id_value_assertions:\n",
-    "                if a[\"slot_range\"] not in doc_id_types[a[\"value\"]]:\n",
+    "                # check that the document-reported type for this id reference is kosher as per the referring slot's schema definition.\n",
+    "                if doc_id_types[a[\"value\"]][5:] not in a[\"acceptable_slot_classes\"]:\n",
     "                    errors[\"invalid_type\"].append(a)\n",
     "\n",
     "    return errors\n",
@@ -550,18 +472,10 @@
     "# Initialize \"global\" error lists.\n",
     "errors = {\"not_found\": [], \"invalid_type\": []}\n",
     "\n",
-    "# Use a with statement to ensure threads are cleaned up promptly\n",
-    "with concurrent.futures.ThreadPoolExecutor(max_workers=None) as executor:\n",
-    "    future_to_errors = {executor.submit(doc_field_value_errors, das): das for das in doc_assertions()}\n",
-    "    for future in concurrent.futures.as_completed(future_to_errors):\n",
-    "        doc_asserts = future_to_errors[future]\n",
-    "        try:\n",
-    "            data = future.result()\n",
-    "        except Exception as exc:\n",
-    "            print(\"exception:\", str(exc))\n",
-    "        else:\n",
-    "            errors[\"not_found\"].extend(data[\"not_found\"])\n",
-    "            errors[\"invalid_type\"].extend(data[\"invalid_type\"])"
+    "for das in doc_assertions(batch_size=2_000):\n",
+    "    rv = doc_field_value_errors(das)\n",
+    "    errors[\"not_found\"].extend(rv[\"not_found\"])\n",
+    "    errors[\"invalid_type\"].extend(rv[\"invalid_type\"])"
    ]
   },
   {
@@ -576,202 +490,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 13,
    "id": "e01450d1-3369-4fc5-80be-9787e00a6597",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(5, 45604)"
+       "(33, 0)"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "len(errors[\"not_found\"]), len(errors[\"invalid_type\"])\n",
-    "# results prior to re-id-ing: (4857, 23503)\n",
-    "# results prior to v10.5.5: (33, 20488)\n",
-    "# results with v10.5.5: (33, 6900)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "54a560df",
-   "metadata": {},
-   "source": [
-    "Display a few errors from one of the lists, as an example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "afd25543-1cb3-4887-9aba-0086d4b998a6",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'nmdc:dobj-11-cvcxxr53', 'nmdc:dobj-11-fg28a080', 'nmdc:dobj-11-gxgpbv06'}"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "{e[\"value\"] for e in errors[\"not_found\"]}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "a25857f4-e26e-4896-9e5f-607e7b4bb07c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'id': 'nmdc:wfmgan-11-w1d6gy98.1',\n",
-       "  'id_is_nmdc_id': True,\n",
-       "  'field': 'has_input',\n",
-       "  'value': 'nmdc:dobj-11-cvcxxr53',\n",
-       "  'slot_range': 'NamedThing'},\n",
-       " {'id': 'nmdc:wfmgan-11-fmymf551.1',\n",
-       "  'id_is_nmdc_id': True,\n",
-       "  'field': 'has_input',\n",
-       "  'value': 'nmdc:dobj-11-fg28a080',\n",
-       "  'slot_range': 'NamedThing'},\n",
-       " {'id': 'nmdc:wfmgan-11-3nkefn97.1',\n",
-       "  'id_is_nmdc_id': True,\n",
-       "  'field': 'has_input',\n",
-       "  'value': 'nmdc:dobj-11-gxgpbv06',\n",
-       "  'slot_range': 'NamedThing'},\n",
-       " {'id': 'nmdc:wfmgan-11-fmymf551.1',\n",
-       "  'id_is_nmdc_id': True,\n",
-       "  'field': 'has_input',\n",
-       "  'value': 'nmdc:dobj-11-fg28a080',\n",
-       "  'slot_range': 'NamedThing'},\n",
-       " {'id': 'nmdc:wfmgan-11-3nkefn97.1',\n",
-       "  'id_is_nmdc_id': True,\n",
-       "  'field': 'has_input',\n",
-       "  'value': 'nmdc:dobj-11-gxgpbv06',\n",
-       "  'slot_range': 'NamedThing'}]"
-      ]
-     },
-     "execution_count": 18,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "errors[\"not_found\"][:5]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2bd191cd",
-   "metadata": {},
-   "source": [
-    "Display an example `invalid_type` errors for each of the set of expected types that are not being found:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "33516e3c-f10d-4c30-942b-0d01d06082f9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'id': 'nmdc:dobj-11-xt088e26', 'id_is_nmdc_id': True, 'field': 'was_generated_by', 'value': 'nmdc:omprc-11-ymxzx274', 'slot_range': 'WorkflowExecution'}\n"
-     ]
-    }
-   ],
-   "source": [
-    "slot_range_examples = {}\n",
-    "for e in errors[\"invalid_type\"]:\n",
-    "    slot_range_examples[e[\"slot_range\"]] = e\n",
-    "\n",
-    "for ex in slot_range_examples.values():\n",
-    "    print(ex)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d4abec53",
-   "metadata": {},
-   "source": [
-    "Spot check one of those errors."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "29ec7e82-d079-4525-bd7b-d770fd69d788",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'_id': ObjectId('66edad78007ef07eb670a09d'),\n",
-       " 'id': 'nmdc:omprc-11-sxze4w22',\n",
-       " 'has_input': ['nmdc:bsm-11-978cs285'],\n",
-       " 'has_output': ['nmdc:dobj-11-1epz0d53'],\n",
-       " 'associated_studies': ['nmdc:sty-11-28tm5d36'],\n",
-       " 'instrument_used': ['nmdc:inst-14-mwrrj632'],\n",
-       " 'type': ['MassSpectrometry',\n",
-       "  'DataGeneration',\n",
-       "  'PlannedProcess',\n",
-       "  'NamedThing']}"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# OmicsProcessing is not subclass of Activity\n",
-    "mdb.alldocs.find_one({\"id\": \"nmdc:omprc-11-sxze4w22\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "802290e0-58dd-4fbd-835a-c9928006819d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'_id': ObjectId('66edad78007ef07eb67078c8'),\n",
-       " 'id': 'nmdc:procsm-11-v5sykd35',\n",
-       " 'type': ['ProcessedSample', 'MaterialEntity', 'NamedThing']}"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# ProcessedSample is not subclass of Biosample\n",
-    "mdb.alldocs.find_one({\"id\": \"nmdc:procsm-11-v5sykd35\"})"
+    "# results with v11.1.0 on `/global/cfs/projectdirs/m3408/nmdc-mongodumps/dump_nmdc-prod_2024-11-25_20-12-02/nmdc`: (33, 0)"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "nmdc-runtime",
    "language": "python",
-   "name": "python3"
+   "name": "nmdc-runtime"
   },
   "language_info": {
    "codemirror_mode": {
@@ -783,7 +527,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,