{
  "content": {
    "icon": "bi-signpost-split",
    "id": "the-nodes",
    "intro": "Every node on the axes is listed with the concept it resolves to, the question it asks, the math type it yields, the shape of its answer, its decision test and its role, and the surfaces and contracts that ground themselves in it.",
    "subsections": [
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
              "Concept: [identity](/records/reasoning/dimension-identity)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-identity",
        "title": "Identity"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
              "Concept: [composition](/records/reasoning/dimension-composition)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-composition",
        "title": "Composition"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [algebra](/records/reasoning/math-type-algebra)",
              "Concept: [structure](/records/reasoning/dimension-structure)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-structure",
        "title": "Structure"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [graph](/records/reasoning/math-type-graph)",
              "Concept: [relation](/records/reasoning/dimension-relation)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-relation",
        "title": "Relation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [space](/records/reasoning/dimension-space)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-space",
        "title": "Space"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [time](/records/reasoning/dimension-time)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-time",
        "title": "Time"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
              "Concept: [state](/records/reasoning/dimension-state)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-state",
        "title": "State"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [change](/records/reasoning/dimension-change)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-change",
        "title": "Change"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
              "Concept: [behavior](/records/reasoning/dimension-behavior)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-behavior",
        "title": "Behavior"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [function](/records/reasoning/dimension-function)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-function",
        "title": "Function"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [cause](/records/reasoning/dimension-cause)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-cause",
        "title": "Cause"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [logic](/records/reasoning/math-type-logic)",
              "Concept: [meaning](/records/reasoning/dimension-meaning)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-meaning",
        "title": "Meaning"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [scale](/records/reasoning/dimension-scale)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-scale",
        "title": "Scale"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [probability](/records/reasoning/dimension-probability)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-probability",
        "title": "Probability"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [ontology](/records/reasoning/axis-ontology)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [novelty](/records/reasoning/dimension-novelty)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ont-novelty",
        "title": "Novelty"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [algebra](/records/reasoning/math-type-algebra)",
              "Concept: [structural](/records/reasoning/lens-structure)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-structural",
        "title": "Structural Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [temporal](/records/reasoning/lens-time)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-temporal",
        "title": "Temporal Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [spatial](/records/reasoning/lens-space)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-spatial",
        "title": "Spatial Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [statistical](/records/reasoning/lens-statistical)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-statistical",
        "title": "Statistical Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [information-theory](/records/reasoning/math-type-information-theory)",
              "Concept: [frequency](/records/reasoning/lens-frequency)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-frequency",
        "title": "Frequency Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [logic](/records/reasoning/math-type-logic)",
              "Concept: [sequential](/records/reasoning/lens-sequential)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-sequential",
        "title": "Sequential Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [graph](/records/reasoning/math-type-graph)",
              "Concept: [relational](/records/reasoning/lens-relation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Relational Graph Duplication](/records/algorithms/relational-graph-duplication)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-relational",
        "title": "Relational Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
              "Concept: [behavioral](/records/reasoning/lens-behavior)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-behavioral",
        "title": "Behavioral Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [functional](/records/reasoning/lens-function)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-functional",
        "title": "Functional Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [logic](/records/reasoning/math-type-logic)",
              "Concept: [semantic](/records/reasoning/lens-meaning)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-semantic",
        "title": "Semantic Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [causal](/records/reasoning/lens-cause)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-causal",
        "title": "Causal Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [predictive](/records/reasoning/lens-prediction)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-predictive",
        "title": "Predictive Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [anomaly](/records/reasoning/lens-anomaly)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-anomaly",
        "title": "Anomaly Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
              "Concept: [evolutionary](/records/reasoning/lens-change)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-evolutionary",
        "title": "Evolutionary Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [analysis](/records/reasoning/axis-analysis)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [fractal](/records/reasoning/lens-fractal)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "[Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ana-fractal",
        "title": "Fractal Analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
              "Concept: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-observation",
        "title": "Observation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [logic](/records/reasoning/math-type-logic)",
              "Concept: [description](/records/reasoning/mode-description)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-description",
        "title": "Description"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [logic](/records/reasoning/math-type-logic)",
              "Concept: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-comparison",
        "title": "Comparison"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
              "Concept: [classification](/records/reasoning/mode-classification)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-classification",
        "title": "Classification"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [explanation](/records/reasoning/mode-explanation)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-explanation",
        "title": "Explanation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [prediction](/records/reasoning/mode-prediction)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-prediction",
        "title": "Prediction"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)",
              "Concept: [intervention](/records/reasoning/mode-intervention)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-intervention",
        "title": "Intervention"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [computation](/records/reasoning/math-type-computation)",
              "Concept: [creation](/records/reasoning/mode-creation)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-creation",
        "title": "Creation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [reasoning](/records/reasoning/axis-reasoning)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [reflection](/records/reasoning/mode-reflection)"
            ],
            "kind": "list"
          },
          {
            "entries": [],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rea-reflection",
        "title": "Reflection"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [algebra](/records/reasoning/math-type-algebra)",
              "Concept: [symbolic](/records/reasoning/representation-symbolic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as equations or notation?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-symbolic",
        "title": "Symbolic Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [numerical](/records/reasoning/representation-number)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as quantities?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-numerical",
        "title": "Numerical Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [geometric](/records/reasoning/representation-geometry)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as shapes or coordinates?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-geometric",
        "title": "Geometric Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [topology](/records/reasoning/math-type-topology)",
              "Concept: [topological](/records/reasoning/representation-topology)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as connectivity or continuity?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-topological",
        "title": "Topological Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [information-theory](/records/reasoning/math-type-information-theory)",
              "Concept: [information-theoretic](/records/reasoning/representation-information-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as entropy or compression?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-information-theoretic",
        "title": "Information-Theoretic Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [probability](/records/reasoning/math-type-probability)",
              "Concept: [probabilistic](/records/reasoning/representation-probability)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as distributions?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-probabilistic",
        "title": "Probabilistic Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
              "Concept: [dynamical](/records/reasoning/representation-dynamical-systems)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as state transitions?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-dynamical",
        "title": "Dynamical Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [representation](/records/reasoning/axis-representation)",
              "Math type: [computation](/records/reasoning/math-type-computation)",
              "Concept: [computational](/records/reasoning/representation-computation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it encoded as an algorithm?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-rep-computational",
        "title": "Computational Representation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What object exists?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-existence",
        "title": "Existence"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [algebra](/records/reasoning/math-type-algebra)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What structure holds?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-structure",
        "title": "Formal Structure"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [graph](/records/reasoning/math-type-graph)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What mapping connects objects?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-relation",
        "title": "Mapping"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [topology](/records/reasoning/math-type-topology)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What environment contains them?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-space",
        "title": "Environment"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [analysis](/records/reasoning/math-type-analysis)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What operation applies?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-transformation",
        "title": "Transformation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [topology](/records/reasoning/math-type-topology)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What is preserved?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-invariance",
        "title": "Invariance"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [probability](/records/reasoning/math-type-probability)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What is uncertain?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-uncertainty",
        "title": "Uncertainty"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [computation](/records/reasoning/math-type-computation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What is computable?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-computation",
        "title": "Computability"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [topology](/records/reasoning/math-type-topology)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What generalizes?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-abstraction",
        "title": "Abstraction"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [computation](/records/reasoning/math-type-computation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What new structure can emerge?",
                "term": "Question"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-creation",
        "title": "Emergence"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [formalization](/records/reasoning/axis-formalization)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What is absent, and is it distinguished from unknown, omitted and zero?",
                "term": "Question"
              },
              {
                "description": "set",
                "term": "Answer shape"
              },
              {
                "description": "every absence a later check must distinguish is represented as its own value",
                "term": "Decision test"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-for-absence",
        "title": "Absence"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [teleology](/records/reasoning/axis-teleology)",
              "Math type: [optimization](/records/reasoning/math-type-optimization)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What is the objective?",
                "term": "Question"
              },
              {
                "description": "[meta_block](/records/pag/production-meta-block), [meta_field](/records/pag/production-meta-field), [node_meta_tag](/records/pag/production-node-meta-tag)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-tel-objective",
        "title": "Objective"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [teleology](/records/reasoning/axis-teleology)",
              "Math type: [optimization](/records/reasoning/math-type-optimization)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "How much does this advance the objective?",
                "term": "Question"
              },
              {
                "description": "number",
                "term": "Answer shape"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-tel-utility",
        "title": "Branch Utility"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [teleology](/records/reasoning/axis-teleology)",
              "Math type: [optimization](/records/reasoning/math-type-optimization)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What does this cost?",
                "term": "Question"
              },
              {
                "description": "number",
                "term": "Answer shape"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-tel-cost",
        "title": "Branch Cost"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [teleology](/records/reasoning/axis-teleology)",
              "Math type: [optimization](/records/reasoning/math-type-optimization)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is this the highest-worth admissible branch?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "the branch has the highest utility minus cost among the admissible branches",
                "term": "Decision test"
              },
              {
                "description": "injection-gate",
                "term": "Role"
              },
              {
                "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity Assignment](/records/algorithms/severity-assignment), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [priority_queue_declaration](/records/pag/production-priority-queue-declaration)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-tel-priority",
        "title": "Branch Priority"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What evidence supports this?",
                "term": "Question"
              },
              {
                "description": "set",
                "term": "Answer shape"
              },
              {
                "description": "the evidence set is non-empty",
                "term": "Decision test"
              },
              {
                "description": "both",
                "term": "Role"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [handoff_gate](/records/pag/production-handoff-gate), [check_line](/records/pag/production-check-line), [check_marker](/records/pag/production-check-marker), [report_block](/records/pag/production-report-block)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-evidence",
        "title": "Evidence"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it true against reality, not merely coherent?",
                "term": "Question"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-ground-truth",
        "title": "Ground Truth"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "What would refute it?",
                "term": "Question"
              },
              {
                "description": "[invariant_record](/records/pag/production-invariant-record)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-falsification",
        "title": "Refutation Condition"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [probability](/records/reasoning/math-type-probability)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "How confident is it, and is that enough?",
                "term": "Question"
              },
              {
                "description": "number[0,1]",
                "term": "Answer shape"
              },
              {
                "description": "confidence is at or above the threshold",
                "term": "Decision test"
              },
              {
                "description": "[verdict](/records/pag/production-verdict)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-confidence",
        "title": "Confidence"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Does refutation outweigh support?",
                "term": "Question"
              },
              {
                "description": "[result_line](/records/pag/production-result-line), [repair_edge](/records/pag/production-repair-edge)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-refutation",
        "title": "Support Against Refutation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Over what set was this checked?",
                "term": "Question"
              },
              {
                "description": "ratio",
                "term": "Answer shape"
              },
              {
                "description": "the declared population is non-empty and every member is measured or named absent",
                "term": "Decision test"
              },
              {
                "description": "both",
                "term": "Role"
              },
              {
                "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [population_clause](/records/pag/production-population-clause), [report_field](/records/pag/production-report-field)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-population",
        "title": "Population"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [information-theory](/records/reasoning/math-type-information-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Was the read derived after the last relevant mutator?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "the fingerprint of the inputs and the code matches the output's declared derivation",
                "term": "Decision test"
              },
              {
                "description": "[freshness_clause](/records/pag/production-freshness-clause), [report_field](/records/pag/production-report-field)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-freshness",
        "title": "Freshness"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Did the read set move beneath the verdict?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "the moved set is empty",
                "term": "Decision test"
              },
              {
                "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [standing_line](/records/pag/production-standing-line)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-standing",
        "title": "Standing"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Where does this stage refuse to continue?",
                "term": "Question"
              },
              {
                "description": "set",
                "term": "Answer shape"
              },
              {
                "description": "a refusal condition is named before the irreversible write",
                "term": "Decision test"
              },
              {
                "description": "injection-gate",
                "term": "Role"
              },
              {
                "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [refusal_line](/records/pag/production-refusal-line)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-refusal",
        "title": "Refusal"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [verification](/records/reasoning/axis-verification)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Does the observation locate a failure, or is an absence of failures read as proof?",
                "term": "Question"
              },
              {
                "description": "set",
                "term": "Answer shape"
              },
              {
                "description": "every observed location is reported as located, and no observed absence is reported as verified",
                "term": "Decision test"
              },
              {
                "description": "[report_field](/records/pag/production-report-field)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ver-observation",
        "title": "Located Observation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is every task done?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "every task is done",
                "term": "Decision test"
              },
              {
                "description": "completion-marker",
                "term": "Role"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-completion",
        "title": "Completion"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is nothing left to resolve?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "no open items remain",
                "term": "Decision test"
              },
              {
                "description": "both",
                "term": "Role"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-saturation",
        "title": "Saturation"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Has progress stopped increasing?",
                "term": "Question"
              },
              {
                "description": "counter",
                "term": "Answer shape"
              },
              {
                "description": "progress is unchanged across a bounded window",
                "term": "Decision test"
              },
              {
                "description": "injection-gate",
                "term": "Role"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-diminishing-returns",
        "title": "Diminishing Returns"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is it blocked on external input?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [result_line](/records/pag/production-result-line), [wait_statement](/records/pag/production-wait-statement)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-block",
        "title": "Blocked Run"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [optimization](/records/reasoning/math-type-optimization)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Do saturation, completion and verification all hold, or is the run blocked?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "saturation, completion and verification all hold, or ter-block holds",
                "term": "Decision test"
              },
              {
                "description": "completion-marker",
                "term": "Role"
              },
              {
                "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion), [report_field](/records/pag/production-report-field)",
                "term": "Grounded by"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-stop",
        "title": "Stop Condition"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is the candidate promoted, or only produced?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "a clean verdict precedes the move into accepted state",
                "term": "Decision test"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-promotion",
        "title": "Promotion"
      },
      {
        "blocks": [
          {
            "items": [
              "Axis: [termination](/records/reasoning/axis-termination)",
              "Math type: [logic](/records/reasoning/math-type-logic)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Is the boundary to the external system explicit, and who crosses it?",
                "term": "Question"
              },
              {
                "description": "boolean",
                "term": "Answer shape"
              },
              {
                "description": "the publication gate names its party",
                "term": "Decision test"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                "term": "Checked by"
              },
              {
                "description": "Every structured document whose constructs ground the node",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the document, the grammar or the node changes",
                "term": "Freshness"
              },
              {
                "description": "The validator fails a gate that omits the clause the node asks for",
                "term": "Refusal"
              },
              {
                "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                "term": "Evidence"
              },
              {
                "description": "The gate clause the node asks for, which every document's gate conforms to",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-node-ter-publication",
        "title": "Publication"
      }
    ],
    "title": "The nodes"
  },
  "graph": {
    "narrative": true,
    "requires": [],
    "teaches": [],
    "traces": []
  },
  "href": "https://banes-lab.com/ontology/reasoning#the-nodes",
  "number": "200",
  "page": "ontology",
  "ref": "chapter:/ontology/reasoning#the-nodes",
  "relations": [
    {
      "links": [
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-ontology",
          "json": "https://banes-lab.com/json/records/reasoning/axis-ontology",
          "label": "Ontology",
          "markdown": "https://banes-lab.com/records/reasoning/axis-ontology.md",
          "ref": "reasoning:axis-ontology"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-set-theory",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-set-theory",
          "label": "Set Theory",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-set-theory.md",
          "ref": "reasoning:math-type-set-theory"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-identity",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-identity",
          "label": "Identity",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-identity.md",
          "ref": "reasoning:dimension-identity"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-composition",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-composition",
          "label": "Composition",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-composition.md",
          "ref": "reasoning:dimension-composition"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-algebra",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-algebra",
          "label": "Algebra",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-algebra.md",
          "ref": "reasoning:math-type-algebra"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-structure",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-structure",
          "label": "Structure",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-structure.md",
          "ref": "reasoning:dimension-structure"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-graph",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-graph",
          "label": "Graph",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-graph.md",
          "ref": "reasoning:math-type-graph"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-relation",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-relation",
          "label": "Relation",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-relation.md",
          "ref": "reasoning:dimension-relation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-topology",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-topology",
          "label": "Topology",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-topology.md",
          "ref": "reasoning:math-type-topology"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-space",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-space",
          "label": "Space",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-space.md",
          "ref": "reasoning:dimension-space"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-analysis",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-analysis",
          "label": "Analysis",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-analysis.md",
          "ref": "reasoning:math-type-analysis"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-time",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-time",
          "label": "Time",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-time.md",
          "ref": "reasoning:dimension-time"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-state",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-state",
          "label": "State",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-state.md",
          "ref": "reasoning:dimension-state"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-change",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-change",
          "label": "Change",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-change.md",
          "ref": "reasoning:dimension-change"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-dynamical-systems",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-dynamical-systems",
          "label": "Dynamical Systems",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-dynamical-systems.md",
          "ref": "reasoning:math-type-dynamical-systems"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-behavior",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-behavior",
          "label": "Behavior",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-behavior.md",
          "ref": "reasoning:dimension-behavior"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-function",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-function",
          "label": "Function",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-function.md",
          "ref": "reasoning:dimension-function"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-cause",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-cause",
          "label": "Cause",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-cause.md",
          "ref": "reasoning:dimension-cause"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-logic",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-logic",
          "label": "Logic",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-logic.md",
          "ref": "reasoning:math-type-logic"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-meaning",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-meaning",
          "label": "Meaning",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-meaning.md",
          "ref": "reasoning:dimension-meaning"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-scale",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-scale",
          "label": "Scale",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-scale.md",
          "ref": "reasoning:dimension-scale"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-probability",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-probability",
          "label": "Probability",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-probability.md",
          "ref": "reasoning:math-type-probability"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-probability",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-probability",
          "label": "Probability",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-probability.md",
          "ref": "reasoning:dimension-probability"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-dimension-novelty",
          "json": "https://banes-lab.com/json/records/reasoning/dimension-novelty",
          "label": "Novelty",
          "markdown": "https://banes-lab.com/records/reasoning/dimension-novelty.md",
          "ref": "reasoning:dimension-novelty"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-concrete-vs-abstract-responsibility-split",
          "json": "https://banes-lab.com/json/records/algorithms/concrete-vs-abstract-responsibility-split",
          "label": "Concrete-vs-Abstract Responsibility Split",
          "markdown": "https://banes-lab.com/records/algorithms/concrete-vs-abstract-responsibility-split.md",
          "ref": "algorithms:concrete-vs-abstract-responsibility-split"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-analysis",
          "json": "https://banes-lab.com/json/records/reasoning/axis-analysis",
          "label": "Analysis",
          "markdown": "https://banes-lab.com/records/reasoning/axis-analysis.md",
          "ref": "reasoning:axis-analysis"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-structure",
          "json": "https://banes-lab.com/json/records/reasoning/lens-structure",
          "label": "Structure",
          "markdown": "https://banes-lab.com/records/reasoning/lens-structure.md",
          "ref": "reasoning:lens-structure"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-time",
          "json": "https://banes-lab.com/json/records/reasoning/lens-time",
          "label": "Time",
          "markdown": "https://banes-lab.com/records/reasoning/lens-time.md",
          "ref": "reasoning:lens-time"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-temporal-coupling-detection",
          "json": "https://banes-lab.com/json/records/algorithms/temporal-coupling-detection",
          "label": "Temporal Coupling Detection",
          "markdown": "https://banes-lab.com/records/algorithms/temporal-coupling-detection.md",
          "ref": "algorithms:temporal-coupling-detection"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-space",
          "json": "https://banes-lab.com/json/records/reasoning/lens-space",
          "label": "Space",
          "markdown": "https://banes-lab.com/records/reasoning/lens-space.md",
          "ref": "reasoning:lens-space"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-statistical",
          "json": "https://banes-lab.com/json/records/reasoning/lens-statistical",
          "label": "Statistical",
          "markdown": "https://banes-lab.com/records/reasoning/lens-statistical.md",
          "ref": "reasoning:lens-statistical"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-information-theory",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-information-theory",
          "label": "Information Theory",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-information-theory.md",
          "ref": "reasoning:math-type-information-theory"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-frequency",
          "json": "https://banes-lab.com/json/records/reasoning/lens-frequency",
          "label": "Frequency",
          "markdown": "https://banes-lab.com/records/reasoning/lens-frequency.md",
          "ref": "reasoning:lens-frequency"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-sequential",
          "json": "https://banes-lab.com/json/records/reasoning/lens-sequential",
          "label": "Sequential",
          "markdown": "https://banes-lab.com/records/reasoning/lens-sequential.md",
          "ref": "reasoning:lens-sequential"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-sequential-chain-duplication",
          "json": "https://banes-lab.com/json/records/algorithms/sequential-chain-duplication",
          "label": "Sequential Chain Duplication",
          "markdown": "https://banes-lab.com/records/algorithms/sequential-chain-duplication.md",
          "ref": "algorithms:sequential-chain-duplication"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-relation",
          "json": "https://banes-lab.com/json/records/reasoning/lens-relation",
          "label": "Relation",
          "markdown": "https://banes-lab.com/records/reasoning/lens-relation.md",
          "ref": "reasoning:lens-relation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-relational-graph-duplication",
          "json": "https://banes-lab.com/json/records/algorithms/relational-graph-duplication",
          "label": "Relational Graph Duplication",
          "markdown": "https://banes-lab.com/records/algorithms/relational-graph-duplication.md",
          "ref": "algorithms:relational-graph-duplication"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-behavior",
          "json": "https://banes-lab.com/json/records/reasoning/lens-behavior",
          "label": "Behavior",
          "markdown": "https://banes-lab.com/records/reasoning/lens-behavior.md",
          "ref": "reasoning:lens-behavior"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-function",
          "json": "https://banes-lab.com/json/records/reasoning/lens-function",
          "label": "Function",
          "markdown": "https://banes-lab.com/records/reasoning/lens-function.md",
          "ref": "reasoning:lens-function"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-meaning",
          "json": "https://banes-lab.com/json/records/reasoning/lens-meaning",
          "label": "Meaning",
          "markdown": "https://banes-lab.com/records/reasoning/lens-meaning.md",
          "ref": "reasoning:lens-meaning"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-conceptual-duplication-detection",
          "json": "https://banes-lab.com/json/records/algorithms/conceptual-duplication-detection",
          "label": "Conceptual Duplication Detection",
          "markdown": "https://banes-lab.com/records/algorithms/conceptual-duplication-detection.md",
          "ref": "algorithms:conceptual-duplication-detection"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-cause",
          "json": "https://banes-lab.com/json/records/reasoning/lens-cause",
          "label": "Cause",
          "markdown": "https://banes-lab.com/records/reasoning/lens-cause.md",
          "ref": "reasoning:lens-cause"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-causal-wiring-duplication",
          "json": "https://banes-lab.com/json/records/algorithms/causal-wiring-duplication",
          "label": "Causal Wiring Duplication",
          "markdown": "https://banes-lab.com/records/algorithms/causal-wiring-duplication.md",
          "ref": "algorithms:causal-wiring-duplication"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-prediction",
          "json": "https://banes-lab.com/json/records/reasoning/lens-prediction",
          "label": "Prediction",
          "markdown": "https://banes-lab.com/records/reasoning/lens-prediction.md",
          "ref": "reasoning:lens-prediction"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-anomaly",
          "json": "https://banes-lab.com/json/records/reasoning/lens-anomaly",
          "label": "Anomaly",
          "markdown": "https://banes-lab.com/records/reasoning/lens-anomaly.md",
          "ref": "reasoning:lens-anomaly"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-anomaly-outlier-detection",
          "json": "https://banes-lab.com/json/records/algorithms/anomaly-outlier-detection",
          "label": "Anomaly Outlier Detection",
          "markdown": "https://banes-lab.com/records/algorithms/anomaly-outlier-detection.md",
          "ref": "algorithms:anomaly-outlier-detection"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-change",
          "json": "https://banes-lab.com/json/records/reasoning/lens-change",
          "label": "Change",
          "markdown": "https://banes-lab.com/records/reasoning/lens-change.md",
          "ref": "reasoning:lens-change"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-lens-fractal",
          "json": "https://banes-lab.com/json/records/reasoning/lens-fractal",
          "label": "Fractal",
          "markdown": "https://banes-lab.com/records/reasoning/lens-fractal.md",
          "ref": "reasoning:lens-fractal"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-fractal-scale-duplication",
          "json": "https://banes-lab.com/json/records/algorithms/fractal-scale-duplication",
          "label": "Fractal Scale Duplication",
          "markdown": "https://banes-lab.com/records/algorithms/fractal-scale-duplication.md",
          "ref": "algorithms:fractal-scale-duplication"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-reasoning",
          "json": "https://banes-lab.com/json/records/reasoning/axis-reasoning",
          "label": "Reasoning",
          "markdown": "https://banes-lab.com/records/reasoning/axis-reasoning.md",
          "ref": "reasoning:axis-reasoning"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-observation",
          "json": "https://banes-lab.com/json/records/reasoning/mode-observation",
          "label": "Observation",
          "markdown": "https://banes-lab.com/records/reasoning/mode-observation.md",
          "ref": "reasoning:mode-observation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-description",
          "json": "https://banes-lab.com/json/records/reasoning/mode-description",
          "label": "Description",
          "markdown": "https://banes-lab.com/records/reasoning/mode-description.md",
          "ref": "reasoning:mode-description"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-comparison",
          "json": "https://banes-lab.com/json/records/reasoning/mode-comparison",
          "label": "Comparison",
          "markdown": "https://banes-lab.com/records/reasoning/mode-comparison.md",
          "ref": "reasoning:mode-comparison"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-classification",
          "json": "https://banes-lab.com/json/records/reasoning/mode-classification",
          "label": "Classification",
          "markdown": "https://banes-lab.com/records/reasoning/mode-classification.md",
          "ref": "reasoning:mode-classification"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-explanation",
          "json": "https://banes-lab.com/json/records/reasoning/mode-explanation",
          "label": "Explanation",
          "markdown": "https://banes-lab.com/records/reasoning/mode-explanation.md",
          "ref": "reasoning:mode-explanation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-prediction",
          "json": "https://banes-lab.com/json/records/reasoning/mode-prediction",
          "label": "Prediction",
          "markdown": "https://banes-lab.com/records/reasoning/mode-prediction.md",
          "ref": "reasoning:mode-prediction"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-intervention",
          "json": "https://banes-lab.com/json/records/reasoning/mode-intervention",
          "label": "Intervention",
          "markdown": "https://banes-lab.com/records/reasoning/mode-intervention.md",
          "ref": "reasoning:mode-intervention"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-computation",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-computation",
          "label": "Computation",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-computation.md",
          "ref": "reasoning:math-type-computation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-creation",
          "json": "https://banes-lab.com/json/records/reasoning/mode-creation",
          "label": "Creation",
          "markdown": "https://banes-lab.com/records/reasoning/mode-creation.md",
          "ref": "reasoning:mode-creation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-mode-reflection",
          "json": "https://banes-lab.com/json/records/reasoning/mode-reflection",
          "label": "Reflection",
          "markdown": "https://banes-lab.com/records/reasoning/mode-reflection.md",
          "ref": "reasoning:mode-reflection"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-representation",
          "json": "https://banes-lab.com/json/records/reasoning/axis-representation",
          "label": "Representation",
          "markdown": "https://banes-lab.com/records/reasoning/axis-representation.md",
          "ref": "reasoning:axis-representation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-symbolic",
          "json": "https://banes-lab.com/json/records/reasoning/representation-symbolic",
          "label": "Symbolic",
          "markdown": "https://banes-lab.com/records/reasoning/representation-symbolic.md",
          "ref": "reasoning:representation-symbolic"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-number",
          "json": "https://banes-lab.com/json/records/reasoning/representation-number",
          "label": "Number",
          "markdown": "https://banes-lab.com/records/reasoning/representation-number.md",
          "ref": "reasoning:representation-number"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-geometry",
          "json": "https://banes-lab.com/json/records/reasoning/representation-geometry",
          "label": "Geometry",
          "markdown": "https://banes-lab.com/records/reasoning/representation-geometry.md",
          "ref": "reasoning:representation-geometry"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-topology",
          "json": "https://banes-lab.com/json/records/reasoning/representation-topology",
          "label": "Topology",
          "markdown": "https://banes-lab.com/records/reasoning/representation-topology.md",
          "ref": "reasoning:representation-topology"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-information-theory",
          "json": "https://banes-lab.com/json/records/reasoning/representation-information-theory",
          "label": "Information Theory",
          "markdown": "https://banes-lab.com/records/reasoning/representation-information-theory.md",
          "ref": "reasoning:representation-information-theory"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-probability",
          "json": "https://banes-lab.com/json/records/reasoning/representation-probability",
          "label": "Probability",
          "markdown": "https://banes-lab.com/records/reasoning/representation-probability.md",
          "ref": "reasoning:representation-probability"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-dynamical-systems",
          "json": "https://banes-lab.com/json/records/reasoning/representation-dynamical-systems",
          "label": "Dynamical Systems",
          "markdown": "https://banes-lab.com/records/reasoning/representation-dynamical-systems.md",
          "ref": "reasoning:representation-dynamical-systems"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-representation-computation",
          "json": "https://banes-lab.com/json/records/reasoning/representation-computation",
          "label": "Computation",
          "markdown": "https://banes-lab.com/records/reasoning/representation-computation.md",
          "ref": "reasoning:representation-computation"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-formalization",
          "json": "https://banes-lab.com/json/records/reasoning/axis-formalization",
          "label": "Formalization",
          "markdown": "https://banes-lab.com/records/reasoning/axis-formalization.md",
          "ref": "reasoning:axis-formalization"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-teleology",
          "json": "https://banes-lab.com/json/records/reasoning/axis-teleology",
          "label": "Teleology",
          "markdown": "https://banes-lab.com/records/reasoning/axis-teleology.md",
          "ref": "reasoning:axis-teleology"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-math-type-optimization",
          "json": "https://banes-lab.com/json/records/reasoning/math-type-optimization",
          "label": "Optimization",
          "markdown": "https://banes-lab.com/records/reasoning/math-type-optimization.md",
          "ref": "reasoning:math-type-optimization"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-meta-block",
          "json": "https://banes-lab.com/json/records/pag/production-meta-block",
          "label": "meta_block",
          "markdown": "https://banes-lab.com/records/pag/production-meta-block.md",
          "ref": "pag:production-meta-block"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-meta-field",
          "json": "https://banes-lab.com/json/records/pag/production-meta-field",
          "label": "meta_field",
          "markdown": "https://banes-lab.com/records/pag/production-meta-field.md",
          "ref": "pag:production-meta-field"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-node-meta-tag",
          "json": "https://banes-lab.com/json/records/pag/production-node-meta-tag",
          "label": "node_meta_tag",
          "markdown": "https://banes-lab.com/records/pag/production-node-meta-tag.md",
          "ref": "pag:production-node-meta-tag"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-adaptive-phase-boundary",
          "json": "https://banes-lab.com/json/records/algorithms/adaptive-phase-boundary",
          "label": "Adaptive Phase Boundary",
          "markdown": "https://banes-lab.com/records/algorithms/adaptive-phase-boundary.md",
          "ref": "algorithms:adaptive-phase-boundary"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-automation-priority-ordering",
          "json": "https://banes-lab.com/json/records/algorithms/automation-priority-ordering",
          "label": "Automation Priority Ordering",
          "markdown": "https://banes-lab.com/records/algorithms/automation-priority-ordering.md",
          "ref": "algorithms:automation-priority-ordering"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-developer-decision-gate",
          "json": "https://banes-lab.com/json/records/algorithms/developer-decision-gate",
          "label": "Developer Decision Gate",
          "markdown": "https://banes-lab.com/records/algorithms/developer-decision-gate.md",
          "ref": "algorithms:developer-decision-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-teleological-intent-gate",
          "json": "https://banes-lab.com/json/records/algorithms/teleological-intent-gate",
          "label": "Teleological Intent Gate",
          "markdown": "https://banes-lab.com/records/algorithms/teleological-intent-gate.md",
          "ref": "algorithms:teleological-intent-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-severity-assignment",
          "json": "https://banes-lab.com/json/records/algorithms/severity-assignment",
          "label": "Severity Assignment",
          "markdown": "https://banes-lab.com/records/algorithms/severity-assignment.md",
          "ref": "algorithms:severity-assignment"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-severity-failure-routing",
          "json": "https://banes-lab.com/json/records/algorithms/severity-failure-routing",
          "label": "Severity Failure Routing",
          "markdown": "https://banes-lab.com/records/algorithms/severity-failure-routing.md",
          "ref": "algorithms:severity-failure-routing"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-severity-ordered-remediation",
          "json": "https://banes-lab.com/json/records/algorithms/severity-ordered-remediation",
          "label": "Severity-Ordered Remediation",
          "markdown": "https://banes-lab.com/records/algorithms/severity-ordered-remediation.md",
          "ref": "algorithms:severity-ordered-remediation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-coverage-risk-prioritization",
          "json": "https://banes-lab.com/json/records/algorithms/coverage-risk-prioritization",
          "label": "Coverage Risk Prioritization",
          "markdown": "https://banes-lab.com/records/algorithms/coverage-risk-prioritization.md",
          "ref": "algorithms:coverage-risk-prioritization"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-anti-pattern-priority-matrix",
          "json": "https://banes-lab.com/json/records/algorithms/anti-pattern-priority-matrix",
          "label": "Anti-Pattern Priority Matrix",
          "markdown": "https://banes-lab.com/records/algorithms/anti-pattern-priority-matrix.md",
          "ref": "algorithms:anti-pattern-priority-matrix"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-reshape-risk-priority",
          "json": "https://banes-lab.com/json/records/algorithms/reshape-risk-priority",
          "label": "Reshape Risk Priority",
          "markdown": "https://banes-lab.com/records/algorithms/reshape-risk-priority.md",
          "ref": "algorithms:reshape-risk-priority"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-vocabulary-admission-gate",
          "json": "https://banes-lab.com/json/records/algorithms/vocabulary-admission-gate",
          "label": "Vocabulary Admission Gate",
          "markdown": "https://banes-lab.com/records/algorithms/vocabulary-admission-gate.md",
          "ref": "algorithms:vocabulary-admission-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-priority-queue-declaration",
          "json": "https://banes-lab.com/json/records/pag/production-priority-queue-declaration",
          "label": "priority_queue_declaration",
          "markdown": "https://banes-lab.com/records/pag/production-priority-queue-declaration.md",
          "ref": "pag:production-priority-queue-declaration"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-verification",
          "json": "https://banes-lab.com/json/records/reasoning/axis-verification",
          "label": "Verification",
          "markdown": "https://banes-lab.com/records/reasoning/axis-verification.md",
          "ref": "reasoning:axis-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-semantic-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-semantic-correctness",
          "label": "Semantic Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-semantic-correctness.md",
          "ref": "reasoning:test-surface-semantic-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-functional-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-functional-correctness",
          "label": "Functional Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-functional-correctness.md",
          "ref": "reasoning:test-surface-functional-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-state-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-state-correctness",
          "label": "State Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-state-correctness.md",
          "ref": "reasoning:test-surface-state-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-interface-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-interface-correctness",
          "label": "Interface Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-interface-correctness.md",
          "ref": "reasoning:test-surface-interface-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-interaction-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-interaction-correctness",
          "label": "Interaction Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-interaction-correctness.md",
          "ref": "reasoning:test-surface-interaction-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-temporal-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-temporal-correctness",
          "label": "Temporal Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-temporal-correctness.md",
          "ref": "reasoning:test-surface-temporal-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-concurrency-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-concurrency-correctness",
          "label": "Concurrency Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-concurrency-correctness.md",
          "ref": "reasoning:test-surface-concurrency-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-memory-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-memory-correctness",
          "label": "Memory Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-memory-correctness.md",
          "ref": "reasoning:test-surface-memory-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-resource-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-resource-correctness",
          "label": "Resource Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-resource-correctness.md",
          "ref": "reasoning:test-surface-resource-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-performance-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-performance-correctness",
          "label": "Performance Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-performance-correctness.md",
          "ref": "reasoning:test-surface-performance-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-reliability-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-reliability-correctness",
          "label": "Reliability Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-reliability-correctness.md",
          "ref": "reasoning:test-surface-reliability-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-availability-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-availability-correctness",
          "label": "Availability Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-availability-correctness.md",
          "ref": "reasoning:test-surface-availability-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-consistency-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-consistency-correctness",
          "label": "Consistency Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-consistency-correctness.md",
          "ref": "reasoning:test-surface-consistency-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-data-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-data-correctness",
          "label": "Data Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-data-correctness.md",
          "ref": "reasoning:test-surface-data-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-numerical-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-numerical-correctness",
          "label": "Numerical Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-numerical-correctness.md",
          "ref": "reasoning:test-surface-numerical-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-security-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-security-correctness",
          "label": "Security Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-security-correctness.md",
          "ref": "reasoning:test-surface-security-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-determinism-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-determinism-correctness",
          "label": "Determinism Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-determinism-correctness.md",
          "ref": "reasoning:test-surface-determinism-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-protocol-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-protocol-correctness",
          "label": "Protocol Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-protocol-correctness.md",
          "ref": "reasoning:test-surface-protocol-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-configuration-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-configuration-correctness",
          "label": "Configuration Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-configuration-correctness.md",
          "ref": "reasoning:test-surface-configuration-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-test-surface-observability-correctness",
          "json": "https://banes-lab.com/json/records/reasoning/test-surface-observability-correctness",
          "label": "Observability Correctness",
          "markdown": "https://banes-lab.com/records/reasoning/test-surface-observability-correctness.md",
          "ref": "reasoning:test-surface-observability-correctness"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-evidence-grounding-validation",
          "json": "https://banes-lab.com/json/records/algorithms/evidence-grounding-validation",
          "label": "Evidence Grounding Validation",
          "markdown": "https://banes-lab.com/records/algorithms/evidence-grounding-validation.md",
          "ref": "algorithms:evidence-grounding-validation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-workflow-validation-gate",
          "json": "https://banes-lab.com/json/records/algorithms/workflow-validation-gate",
          "label": "Workflow Validation Gate",
          "markdown": "https://banes-lab.com/records/algorithms/workflow-validation-gate.md",
          "ref": "algorithms:workflow-validation-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-additive-debt-gate",
          "json": "https://banes-lab.com/json/records/algorithms/additive-debt-gate",
          "label": "Additive Debt Gate",
          "markdown": "https://banes-lab.com/records/algorithms/additive-debt-gate.md",
          "ref": "algorithms:additive-debt-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-zero-duplication-verification",
          "json": "https://banes-lab.com/json/records/algorithms/zero-duplication-verification",
          "label": "Zero-Duplication Verification",
          "markdown": "https://banes-lab.com/records/algorithms/zero-duplication-verification.md",
          "ref": "algorithms:zero-duplication-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-evidence-based-claim-verification",
          "json": "https://banes-lab.com/json/records/algorithms/evidence-based-claim-verification",
          "label": "Evidence-Based Claim Verification",
          "markdown": "https://banes-lab.com/records/algorithms/evidence-based-claim-verification.md",
          "ref": "algorithms:evidence-based-claim-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-verification-execution",
          "json": "https://banes-lab.com/json/records/algorithms/verification-execution",
          "label": "Verification Execution",
          "markdown": "https://banes-lab.com/records/algorithms/verification-execution.md",
          "ref": "algorithms:verification-execution"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-reverification-gate",
          "json": "https://banes-lab.com/json/records/algorithms/reverification-gate",
          "label": "Reverification Gate",
          "markdown": "https://banes-lab.com/records/algorithms/reverification-gate.md",
          "ref": "algorithms:reverification-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-evidence-gated-claim-verification",
          "json": "https://banes-lab.com/json/records/algorithms/evidence-gated-claim-verification",
          "label": "Evidence-Gated Claim Verification",
          "markdown": "https://banes-lab.com/records/algorithms/evidence-gated-claim-verification.md",
          "ref": "algorithms:evidence-gated-claim-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-environment-capability-verification",
          "json": "https://banes-lab.com/json/records/algorithms/environment-capability-verification",
          "label": "Environment Capability Verification",
          "markdown": "https://banes-lab.com/records/algorithms/environment-capability-verification.md",
          "ref": "algorithms:environment-capability-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-recursive-self-verification",
          "json": "https://banes-lab.com/json/records/algorithms/recursive-self-verification",
          "label": "Recursive Self-Verification",
          "markdown": "https://banes-lab.com/records/algorithms/recursive-self-verification.md",
          "ref": "algorithms:recursive-self-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-evidence-verdict",
          "json": "https://banes-lab.com/json/records/algorithms/evidence-verdict",
          "label": "Evidence Verdict",
          "markdown": "https://banes-lab.com/records/algorithms/evidence-verdict.md",
          "ref": "algorithms:evidence-verdict"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-pag-validation-gate",
          "json": "https://banes-lab.com/json/records/algorithms/pag-validation-gate",
          "label": "PAG Handoff Gate",
          "markdown": "https://banes-lab.com/records/algorithms/pag-validation-gate.md",
          "ref": "algorithms:pag-validation-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-anti-pattern-elimination-verification",
          "json": "https://banes-lab.com/json/records/algorithms/anti-pattern-elimination-verification",
          "label": "Anti-Pattern Elimination Verification",
          "markdown": "https://banes-lab.com/records/algorithms/anti-pattern-elimination-verification.md",
          "ref": "algorithms:anti-pattern-elimination-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-plan-phase-verification",
          "json": "https://banes-lab.com/json/records/algorithms/plan-phase-verification",
          "label": "Plan Phase Verification",
          "markdown": "https://banes-lab.com/records/algorithms/plan-phase-verification.md",
          "ref": "algorithms:plan-phase-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-machine-verdict-derivation",
          "json": "https://banes-lab.com/json/records/algorithms/machine-verdict-derivation",
          "label": "Machine Verdict Derivation",
          "markdown": "https://banes-lab.com/records/algorithms/machine-verdict-derivation.md",
          "ref": "algorithms:machine-verdict-derivation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-mode-contract-validation",
          "json": "https://banes-lab.com/json/records/algorithms/mode-contract-validation",
          "label": "Mode Contract Validation",
          "markdown": "https://banes-lab.com/records/algorithms/mode-contract-validation.md",
          "ref": "algorithms:mode-contract-validation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-discovery-verification",
          "json": "https://banes-lab.com/json/records/algorithms/discovery-verification",
          "label": "Discovery Verification",
          "markdown": "https://banes-lab.com/records/algorithms/discovery-verification.md",
          "ref": "algorithms:discovery-verification"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-handoff-gate",
          "json": "https://banes-lab.com/json/records/pag/production-handoff-gate",
          "label": "handoff_gate",
          "markdown": "https://banes-lab.com/records/pag/production-handoff-gate.md",
          "ref": "pag:production-handoff-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-check-line",
          "json": "https://banes-lab.com/json/records/pag/production-check-line",
          "label": "check_line",
          "markdown": "https://banes-lab.com/records/pag/production-check-line.md",
          "ref": "pag:production-check-line"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-check-marker",
          "json": "https://banes-lab.com/json/records/pag/production-check-marker",
          "label": "check_marker",
          "markdown": "https://banes-lab.com/records/pag/production-check-marker.md",
          "ref": "pag:production-check-marker"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-report-block",
          "json": "https://banes-lab.com/json/records/pag/production-report-block",
          "label": "report_block",
          "markdown": "https://banes-lab.com/records/pag/production-report-block.md",
          "ref": "pag:production-report-block"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-invariant-record",
          "json": "https://banes-lab.com/json/records/pag/production-invariant-record",
          "label": "invariant_record",
          "markdown": "https://banes-lab.com/records/pag/production-invariant-record.md",
          "ref": "pag:production-invariant-record"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-verdict",
          "json": "https://banes-lab.com/json/records/pag/production-verdict",
          "label": "verdict",
          "markdown": "https://banes-lab.com/records/pag/production-verdict.md",
          "ref": "pag:production-verdict"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-result-line",
          "json": "https://banes-lab.com/json/records/pag/production-result-line",
          "label": "result_line",
          "markdown": "https://banes-lab.com/records/pag/production-result-line.md",
          "ref": "pag:production-result-line"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-repair-edge",
          "json": "https://banes-lab.com/json/records/pag/production-repair-edge",
          "label": "repair_edge",
          "markdown": "https://banes-lab.com/records/pag/production-repair-edge.md",
          "ref": "pag:production-repair-edge"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-population-clause",
          "json": "https://banes-lab.com/json/records/pag/production-population-clause",
          "label": "population_clause",
          "markdown": "https://banes-lab.com/records/pag/production-population-clause.md",
          "ref": "pag:production-population-clause"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-report-field",
          "json": "https://banes-lab.com/json/records/pag/production-report-field",
          "label": "report_field",
          "markdown": "https://banes-lab.com/records/pag/production-report-field.md",
          "ref": "pag:production-report-field"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-freshness-clause",
          "json": "https://banes-lab.com/json/records/pag/production-freshness-clause",
          "label": "freshness_clause",
          "markdown": "https://banes-lab.com/records/pag/production-freshness-clause.md",
          "ref": "pag:production-freshness-clause"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-standing-line",
          "json": "https://banes-lab.com/json/records/pag/production-standing-line",
          "label": "standing_line",
          "markdown": "https://banes-lab.com/records/pag/production-standing-line.md",
          "ref": "pag:production-standing-line"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-refusal-line",
          "json": "https://banes-lab.com/json/records/pag/production-refusal-line",
          "label": "refusal_line",
          "markdown": "https://banes-lab.com/records/pag/production-refusal-line.md",
          "ref": "pag:production-refusal-line"
        },
        {
          "href": "https://banes-lab.com/ontology/reasoning#reasoning-axis-termination",
          "json": "https://banes-lab.com/json/records/reasoning/axis-termination",
          "label": "Termination",
          "markdown": "https://banes-lab.com/records/reasoning/axis-termination.md",
          "ref": "reasoning:axis-termination"
        },
        {
          "href": "https://banes-lab.com/ontology/grammar#pag-production-wait-statement",
          "json": "https://banes-lab.com/json/records/pag/production-wait-statement",
          "label": "wait_statement",
          "markdown": "https://banes-lab.com/records/pag/production-wait-statement.md",
          "ref": "pag:production-wait-statement"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-agent-generation-completion",
          "json": "https://banes-lab.com/json/records/algorithms/agent-generation-completion",
          "label": "Agent Generation Completion",
          "markdown": "https://banes-lab.com/records/algorithms/agent-generation-completion.md",
          "ref": "algorithms:agent-generation-completion"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-first-time-initiation",
          "json": "https://banes-lab.com/json/records/algorithms/first-time-initiation",
          "label": "First-Time Initiation",
          "markdown": "https://banes-lab.com/records/algorithms/first-time-initiation.md",
          "ref": "algorithms:first-time-initiation"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-automation-completion-status",
          "json": "https://banes-lab.com/json/records/algorithms/automation-completion-status",
          "label": "Automation Completion Status",
          "markdown": "https://banes-lab.com/records/algorithms/automation-completion-status.md",
          "ref": "algorithms:automation-completion-status"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-completion-truthfulness",
          "json": "https://banes-lab.com/json/records/algorithms/completion-truthfulness",
          "label": "Completion Truthfulness",
          "markdown": "https://banes-lab.com/records/algorithms/completion-truthfulness.md",
          "ref": "algorithms:completion-truthfulness"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-explicit-termination",
          "json": "https://banes-lab.com/json/records/algorithms/explicit-termination",
          "label": "Explicit Termination",
          "markdown": "https://banes-lab.com/records/algorithms/explicit-termination.md",
          "ref": "algorithms:explicit-termination"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-iteration-bound",
          "json": "https://banes-lab.com/json/records/algorithms/iteration-bound",
          "label": "Iteration Bound",
          "markdown": "https://banes-lab.com/records/algorithms/iteration-bound.md",
          "ref": "algorithms:iteration-bound"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-validation-gate",
          "json": "https://banes-lab.com/json/records/algorithms/validation-gate",
          "label": "Validation Gate",
          "markdown": "https://banes-lab.com/records/algorithms/validation-gate.md",
          "ref": "algorithms:validation-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-coverage-completion",
          "json": "https://banes-lab.com/json/records/algorithms/coverage-completion",
          "label": "Coverage Completion",
          "markdown": "https://banes-lab.com/records/algorithms/coverage-completion.md",
          "ref": "algorithms:coverage-completion"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-pattern-distillation-completion-truthfulness",
          "json": "https://banes-lab.com/json/records/algorithms/pattern-distillation-completion-truthfulness",
          "label": "Pattern Distillation Completion Truthfulness",
          "markdown": "https://banes-lab.com/records/algorithms/pattern-distillation-completion-truthfulness.md",
          "ref": "algorithms:pattern-distillation-completion-truthfulness"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-phase-close-gate",
          "json": "https://banes-lab.com/json/records/algorithms/phase-close-gate",
          "label": "Phase Close Gate",
          "markdown": "https://banes-lab.com/records/algorithms/phase-close-gate.md",
          "ref": "algorithms:phase-close-gate"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-bounded-cascade-termination",
          "json": "https://banes-lab.com/json/records/algorithms/bounded-cascade-termination",
          "label": "Bounded Cascade Termination",
          "markdown": "https://banes-lab.com/records/algorithms/bounded-cascade-termination.md",
          "ref": "algorithms:bounded-cascade-termination"
        },
        {
          "href": "https://banes-lab.com/ontology/algorithms#algorithms-taxonomy-completion",
          "json": "https://banes-lab.com/json/records/algorithms/taxonomy-completion",
          "label": "Taxonomy Completion",
          "markdown": "https://banes-lab.com/records/algorithms/taxonomy-completion.md",
          "ref": "algorithms:taxonomy-completion"
        }
      ],
      "relation": "links-to"
    }
  ],
  "route": null,
  "section": "the-nodes",
  "summary": "Every node on the axes is listed with the concept it resolves to, the question it asks, the math type it yields, the shape of its answer, its decision test and…",
  "tab": "reasoning",
  "title": "The nodes",
  "siblings": {
    "next": {
      "href": "https://banes-lab.com/ontology/reasoning#the-mathematics",
      "json": "https://banes-lab.com/json/ontology/reasoning/the-mathematics",
      "label": "The mathematics",
      "markdown": "https://banes-lab.com/ontology/reasoning/the-mathematics.md",
      "ref": "chapter:/ontology/reasoning#the-mathematics"
    },
    "previous": {
      "href": "https://banes-lab.com/ontology/reasoning#the-axes",
      "json": "https://banes-lab.com/json/ontology/reasoning/the-axes",
      "label": "The axes",
      "markdown": "https://banes-lab.com/ontology/reasoning/the-axes.md",
      "ref": "chapter:/ontology/reasoning#the-axes"
    }
  },
  "up": {
    "href": "https://banes-lab.com/ontology/reasoning",
    "json": "https://banes-lab.com/json/api/pages/ontology/reasoning",
    "label": "Ontology · Reasoning",
    "markdown": "https://banes-lab.com/api/pages/ontology/reasoning.md",
    "ref": "api:/ontology/reasoning"
  }
}