{
  "content": {
    "icon": "bi-signpost-split",
    "id": "the-techniques",
    "intro": "Each technique a surface is observed by works in one reasoning mode and is listed with the surfaces that use it.",
    "subsections": [
      {
        "blocks": [
          {
            "items": [
              "Mode: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Reads structure and types for defects before execution",
                "term": "Principle"
              },
              {
                "description": "[Static Analysis](/records/architecture/static-analysis)",
                "term": "Refused by rules"
              },
              {
                "description": "Reports nothing when its rule never visits the construct, as with a misspelled visitor key",
                "term": "Goes silent when"
              },
              {
                "description": "[numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-static-analysis",
        "title": "static-analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Compares observed with expected results on an isolated unit",
                "term": "Principle"
              },
              {
                "description": "Passes when the doubles that isolate the unit no longer behave like the real collaborators",
                "term": "Goes silent when"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-unit-testing",
        "title": "unit-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Compares observed with expected results across cooperating parts",
                "term": "Principle"
              },
              {
                "description": "Passes on an environment that differs from production in the part that fails",
                "term": "Goes silent when"
              },
              {
                "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-integration-testing",
        "title": "integration-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Compares observed with expected results on the whole system",
                "term": "Principle"
              },
              {
                "description": "Is retried until it passes, so an intermittent failure is read as noise",
                "term": "Goes silent when"
              },
              {
                "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-end-to-end-testing",
        "title": "end-to-end-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [classification](/records/reasoning/mode-classification)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Asserts that an invariant holds across a generated input space",
                "term": "Principle"
              },
              {
                "description": "[Property-Based Testing](/records/architecture/property-based-testing)",
                "term": "Refused by rules"
              },
              {
                "description": "Passes when the generator never produces the inputs that break the property",
                "term": "Goes silent when"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-property-based-testing",
        "title": "property-based-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Compares observed results with a reference implementation, the oracle",
                "term": "Principle"
              },
              {
                "description": "Passes when the reference implementation shares the defect",
                "term": "Goes silent when"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-differential-testing",
        "title": "differential-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Compares an observed interface with an agreed contract",
                "term": "Principle"
              },
              {
                "description": "Passes against a copy of the contract that drifted from the one the provider serves",
                "term": "Goes silent when"
              },
              {
                "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-contract-testing",
        "title": "contract-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Checks boundary data against its declared shape at runtime",
                "term": "Principle"
              },
              {
                "description": "Never runs on a path that reaches the core without crossing the boundary",
                "term": "Goes silent when"
              },
              {
                "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-runtime-validation",
        "title": "runtime-validation"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Checks a runtime condition against an assumed invariant",
                "term": "Principle"
              },
              {
                "description": "Is compiled out or disabled in the build that runs in production",
                "term": "Goes silent when"
              },
              {
                "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-assertion-checking",
        "title": "assertion-checking"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [creation](/records/reasoning/mode-creation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Generates adversarial inputs to provoke unhandled failures",
                "term": "Principle"
              },
              {
                "description": "Stops before the generated inputs reach the failing region, and the run reports no crash",
                "term": "Goes silent when"
              },
              {
                "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-fuzz-testing",
        "title": "fuzz-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [prediction](/records/reasoning/mode-prediction)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Projects behavior under expected demand",
                "term": "Principle"
              },
              {
                "description": "Runs a workload shaped unlike real demand",
                "term": "Goes silent when"
              },
              {
                "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-load-testing",
        "title": "load-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [prediction](/records/reasoning/mode-prediction)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Projects behavior past its limits to expose timing and ordering defects",
                "term": "Principle"
              },
              {
                "description": "Ends at a limit below the one production reaches",
                "term": "Goes silent when"
              },
              {
                "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-stress-testing",
        "title": "stress-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Measures the distribution of execution cost",
                "term": "Principle"
              },
              {
                "description": "[Profiling](/records/architecture/profiling)",
                "term": "Refused by rules"
              },
              {
                "description": "Samples too coarsely to see a short, frequent cost",
                "term": "Goes silent when"
              },
              {
                "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-profiling",
        "title": "profiling"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Measures allocation and retention over time",
                "term": "Principle"
              },
              {
                "description": "Measures a run too short for retention to show",
                "term": "Goes silent when"
              },
              {
                "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-heap-analysis",
        "title": "heap-analysis"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [description](/records/reasoning/mode-description)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Describes the runtime flow across components",
                "term": "Principle"
              },
              {
                "description": "Loses spans at an uninstrumented hop, and the trace reads as complete",
                "term": "Goes silent when"
              },
              {
                "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-tracing",
        "title": "tracing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [intervention](/records/reasoning/mode-intervention)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Induces a failure and observes the response",
                "term": "Principle"
              },
              {
                "description": "Injects only the faults the developer anticipated",
                "term": "Goes silent when"
              },
              {
                "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-fault-injection",
        "title": "fault-injection"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [intervention](/records/reasoning/mode-intervention)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Induces random failures and observes how the system recovers",
                "term": "Principle"
              },
              {
                "description": "Runs where the dependency that fails in production is absent",
                "term": "Goes silent when"
              },
              {
                "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-chaos-testing",
        "title": "chaos-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [explanation](/records/reasoning/mode-explanation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Proves that a property holds across the reachable state space",
                "term": "Principle"
              },
              {
                "description": "Proves the model while the code drifts away from it",
                "term": "Goes silent when"
              },
              {
                "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-model-checking",
        "title": "model-checking"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [reflection](/records/reasoning/mode-reflection)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Reproduces a run to isolate a non-deterministic cause",
                "term": "Principle"
              },
              {
                "description": "Replays a recording that left out the source of the non-determinism",
                "term": "Goes silent when"
              },
              {
                "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-deterministic-replay",
        "title": "deterministic-replay"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [observation](/records/reasoning/mode-observation)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Observes live behavior for deviations from normal",
                "term": "Principle"
              },
              {
                "description": "[Monitoring](/records/architecture/monitoring)",
                "term": "Refused by rules"
              },
              {
                "description": "Reports no deviation because the signal it watches was never emitted",
                "term": "Goes silent when"
              },
              {
                "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                "term": "Surfaces"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-monitoring",
        "title": "monitoring"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [intervention](/records/reasoning/mode-intervention)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Introduces a deliberate defect and checks that the tests or the rule report it",
                "term": "Principle"
              },
              {
                "description": "Counts a mutant as caught by a test that fails for an unrelated reason",
                "term": "Goes silent when"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-mutation-testing",
        "title": "mutation-testing"
      },
      {
        "blocks": [
          {
            "items": [
              "Mode: [comparison](/records/reasoning/mode-comparison)"
            ],
            "kind": "list"
          },
          {
            "entries": [
              {
                "description": "Reads back what was written and compares it with what was meant to be written",
                "term": "Principle"
              },
              {
                "description": "Reads from a cache or a buffer instead of the store the write reached",
                "term": "Goes silent when"
              }
            ],
            "kind": "glossary"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                "term": "Checked by"
              },
              {
                "description": "Every surface that lists the technique, and the code those surfaces cover",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                "term": "Refusal"
              },
              {
                "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                "term": "Evidence"
              },
              {
                "description": "The technique record, which every surface that lists it cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "id": "reasoning-technique-read-after-write-verification",
        "title": "read-after-write-verification"
      }
    ],
    "title": "The techniques"
  },
  "graph": {
    "narrative": true,
    "requires": [],
    "teaches": [],
    "traces": []
  },
  "href": "https://banes-lab.com/ontology/reasoning#the-techniques",
  "number": "210",
  "page": "ontology",
  "ref": "chapter:/ontology/reasoning#the-techniques",
  "relations": [
    {
      "links": [
        {
          "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#architecture-static-analysis",
          "json": "https://banes-lab.com/json/records/architecture/static-analysis",
          "label": "Static Analysis",
          "markdown": "https://banes-lab.com/records/architecture/static-analysis.md",
          "ref": "architecture:static-analysis"
        },
        {
          "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-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-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-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-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-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-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#architecture-property-based-testing",
          "json": "https://banes-lab.com/json/records/architecture/property-based-testing",
          "label": "Property-Based Testing",
          "markdown": "https://banes-lab.com/records/architecture/property-based-testing.md",
          "ref": "architecture:property-based-testing"
        },
        {
          "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-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-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-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-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-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-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-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-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-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-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#architecture-profiling",
          "json": "https://banes-lab.com/json/records/architecture/profiling",
          "label": "Profiling",
          "markdown": "https://banes-lab.com/records/architecture/profiling.md",
          "ref": "architecture:profiling"
        },
        {
          "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-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-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/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-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-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-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#architecture-monitoring",
          "json": "https://banes-lab.com/json/records/architecture/monitoring",
          "label": "Monitoring",
          "markdown": "https://banes-lab.com/records/architecture/monitoring.md",
          "ref": "architecture:monitoring"
        }
      ],
      "relation": "links-to"
    }
  ],
  "route": null,
  "section": "the-techniques",
  "summary": "Each technique a surface is observed by works in one reasoning mode and is listed with the surfaces that use it.",
  "tab": "reasoning",
  "title": "The techniques",
  "siblings": {
    "next": {
      "href": "https://banes-lab.com/ontology/reasoning#the-invariants",
      "json": "https://banes-lab.com/json/ontology/reasoning/the-invariants",
      "label": "The invariants",
      "markdown": "https://banes-lab.com/ontology/reasoning/the-invariants.md",
      "ref": "chapter:/ontology/reasoning#the-invariants"
    },
    "previous": {
      "href": "https://banes-lab.com/ontology/reasoning#the-test-surfaces",
      "json": "https://banes-lab.com/json/ontology/reasoning/the-test-surfaces",
      "label": "The test surfaces",
      "markdown": "https://banes-lab.com/ontology/reasoning/the-test-surfaces.md",
      "ref": "chapter:/ontology/reasoning#the-test-surfaces"
    }
  },
  "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"
  }
}