{ "model": { "rank": 5099, "code": "thing-q185612", "model_id": "vr.tr.regular-expression", "name": "regular expression", "purpose": "Enable an agent to recognise a regular expression, determine its meaning in a specified dialect and execution context, and judge whether it is suitable and safe for an intended text-processing task.", "family": "Thing Registry", "category": "Information and virtual systems", "status": "research-draft", "kind": "thing", "plane": "INF", "domain": "INF.MED", "industry": "", "version": "", "url": "/models/thing/q185612/", "tier": 2, "score": 70, "payload": { "layer": "wikidata", "aliases": [ "URL match pattern", "Python version 3 regular expression", "PRONOM internal signature", "POSIX Extended Regular Expressions", "POSIX Basic Regular Expressions", "Raku rules", "Java regular expressions", "Perl regular expression" ], "aliasCount": 8, "merged": 8, "knownIn": 70, "facets": null, "markers": [], "lexicalClass": "", "senseRank": null, "alsoRegisteredAs": null, "source": { "dataset": "wikidata", "item": "Q185612", "url": "https://www.wikidata.org/wiki/Q185612", "license": "CC0 1.0" } }, "research": { "vercy": "1.0-draft", "publication": { "status": "research-draft", "adjudicationStatus": "unreviewed", "publishableCanonical": false, "generatedAt": "2026-09-09T21:39:40Z", "providers": [ "Codex" ], "breadth": "recalled by Codex without web access - no source was read", "missingProviders": [], "pass": 2, "cost": { "grok": { "seconds": 18.7, "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.4\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a0881b-d5d5-7680-ad15-6f4d71215edc\n--------\nuser\nDescribe what is already known about one registered thing. Answer as JSON only, no prose around it.\n\nThing: regular expression\nSense to describe: (none recorded)\nDomain code: INF.MED\nAlso known as: (none)\n\n\nContext for this batch of 1001 things:\n# Batch 005: 1", "usd": 0, "recall": true }, "codex": { "seconds": 59.8, "error": "Reading additional input from stdin...\nOpenAI Codex v0.153.4\n--------\nworkdir: R:\\02_PROJECTS\\02_Meta_Models_Platforms\\Ver.cy\\current\\thing-registry-backlog\nmodel: gpt-6-astra\nprovider: openai\napproval: never\nsandbox: read-only\nreasoning effort: none\nreasoning summaries: none\nsession id: 01a0881b-d5df-7433-a1b1-f43c95456993\n--------\nuser\nYou are drafting a Vercy meta-model for one registered thing. Answer as JSON only, no prose around it.\n\nThing: regular expression\nRegistry id: vr.tr.regular-expression\nPlane / domain: INF / INF.MED\nRegistry definition: (none recorded)\nNames folded into this en" } } }, "metaModel": { "id": "THING-Q185612", "registryId": "vr.tr.regular-expression", "name": "regular expression", "version": "0.1.0-research.1", "entryKind": "thing", "family": "Thing Registry", "domain": [ "INF.MED" ], "status": "research-draft" }, "canonicalUrl": "https://ver.cy/models/thing/q185612/", "model": { "registry_id": "vr.tr.regular-expression", "name": "regular expression", "purpose": "Enable an agent to recognise a regular expression, determine its meaning in a specified dialect and execution context, and judge whether it is suitable and safe for an intended text-processing task.", "definition": "A regular expression is a formal expression denoting a regular language, used in computing to specify text patterns for matching, although many practical dialects add constructs that can describe nonregular languages.", "scope_statement": "This model owns a regular expression as a symbolic text-pattern expression, including its dialect-dependent meaning, matching options, capture behaviour, intended use and execution constraints; it distinguishes the expression from its source-code encoding, compiled representation and individual executions.", "in_scope": [ "Pattern text, dialect and options needed to interpret the expression", "Accepted text and match-selection behaviour under specified operations", "Captures, assertions, character classes and repetition constraints", "Unicode, case, newline and boundary semantics", "Evidence of correctness, portability and bounded execution for intended uses" ], "out_of_scope": [ "Regex engine implementation and deployment lifecycle", "Replacement templates and downstream text transformations", "Input datasets, documents and their content governance", "General-purpose parsers and complete language grammars", "Host-language string literals, transport encodings and compiled pattern objects as independent artifacts" ], "distinguishing_features": [ "Its pattern text is interpreted using a declared regular-expression dialect; identical characters can instead be literal text when passed to a literal-search operation.", "It expresses text constraints using regex syntax, rather than inheriting the wildcard rules of a filename glob.", "Its identity as an expression is distinct from the engine that interprets it and from the match records an execution produces.", "A regex used for validation requires an explicit whole-input acceptance rule; finding a matching substring alone does not establish that the entire input conforms.", "The model covers practical regex dialects as well as classical regular expressions; the label alone does not establish that every supported construct denotes a regular language." ], "characteristics": [ { "name": "Pattern body", "kind": "category", "unit_or_values": "Exact pattern text after decoding any host-language or transport representation", "why_it_matters": "Escaping or normalisation changes can alter the expression before the engine interprets it." }, { "name": "Dialect binding", "kind": "relation", "unit_or_values": "Dialect specification and target engine/version", "why_it_matters": "Syntax validity and matching behaviour depend on the selected interpreter." }, { "name": "Effective matching options", "kind": "category", "unit_or_values": "External flags and inline option settings, including their scope and precedence", "why_it_matters": "Options can change character comparison, anchors, wildcard behaviour and pattern parsing." }, { "name": "Operation contract", "kind": "category", "unit_or_values": "Whole-input match, prefix match, substring search or repeated match enumeration", "why_it_matters": "The same expression can produce different acceptance and extraction outcomes under different operations." }, { "name": "Capture contract", "kind": "category", "unit_or_values": "Group names or numbers, intended meanings, optionality and repeated-capture expectations", "why_it_matters": "Consumers may depend on capture structure even when overall matched text is unchanged." }, { "name": "Empty-match capability", "kind": "state", "unit_or_values": "Possible, impossible or unresolved under the declared context", "why_it_matters": "Zero-length matches affect iteration, splitting and progress guarantees." }, { "name": "Text interpretation", "kind": "category", "unit_or_values": "Byte or Unicode processing, character-unit conventions, case rules, newline rules and normalisation assumptions", "why_it_matters": "Visual similarity does not guarantee equivalent matching behaviour." }, { "name": "Observed execution cost", "kind": "measurement", "unit_or_values": "Elapsed milliseconds and peak memory bytes for named input families, sizes and engine configurations", "why_it_matters": "Performance evidence must be tied to the conditions under which it was obtained." }, { "name": "Verification status", "kind": "state", "unit_or_values": "Untested, tested for declared cases, known counterexample or verified under stated assumptions", "why_it_matters": "An agent needs to distinguish intended behaviour from demonstrated behaviour." } ], "affordances": [ "Parse and compile the expression in a declared engine to check syntax and feature support.", "Evaluate acceptance, selected spans and captures against labelled examples and boundary cases.", "Search or extract text using an explicit operation and capture contract.", "Compare candidate revisions for changes in accepted inputs, match selection and capture outputs.", "Assess portability across named engines using feature checks and comparative tests.", "Run bounded adversarial performance checks and restrict execution when resource requirements remain unresolved." ] }, "sources": [], "structure": { "bundles": [ { "id": "pattern-identity-and-dialect", "name": "Pattern identity and dialect", "description": "Establish the exact expression and the interpretation rules that give it meaning.", "rationale": "Pattern text without its decoding context, dialect and options is insufficient to reproduce behaviour.", "layers": [ { "id": "expression-representation", "name": "Expression representation", "description": "Separate the engine-facing pattern from its surrounding representation.", "findings": [ { "id": "engine-facing-pattern", "name": "Engine-facing pattern", "description": "Record the exact pattern received by the regex engine and identify any delimiters or escaping that belong to its container.", "questions": [ { "text": "What exact pattern text reaches the engine after string-literal, configuration or transport decoding?", "kind": "definition", "id": "engine-facing-pattern-q01" }, { "text": "Which surrounding delimiters and escape sequences belong to the host representation rather than the expression?", "kind": "boundary", "id": "engine-facing-pattern-q02" } ] } ] }, { "id": "interpretation-binding", "name": "Interpretation binding", "description": "Identify syntax rules, feature support and effective options.", "findings": [ { "id": "dialect-and-option-resolution", "name": "Dialect and option resolution", "description": "Bind the expression to a dialect and target engine, accounting for external flags and scoped inline settings.", "questions": [ { "text": "Which dialect reference and engine/version define the intended interpretation?", "kind": "provenance", "id": "dialect-and-option-resolution-q01" }, { "text": "What options are effective in each part of the pattern after inline and external settings are resolved?", "kind": "definition", "id": "dialect-and-option-resolution-q02" } ] } ] } ] }, { "id": "acceptance-and-match-selection", "name": "Acceptance and match selection", "description": "Describe what qualifies as a match and which qualifying result an operation selects.", "rationale": "Validation, searching and repeated matching require different contracts even when they share a pattern.", "layers": [ { "id": "acceptance-boundaries", "name": "Acceptance boundaries", "description": "Connect the intended text constraint to input coverage and assertion behaviour.", "findings": [ { "id": "input-coverage-contract", "name": "Input coverage contract", "description": "Specify whether acceptance concerns the entire input, a prefix or a substring, including the effects of anchors and surrounding context.", "questions": [ { "text": "Must the entire input satisfy the expression, or is a matching prefix or substring sufficient?", "kind": "definition", "id": "input-coverage-contract-q01" }, { "text": "Can final newlines, line-oriented anchors or lookaround context cause acceptance to differ from the intended boundary rule?", "kind": "boundary", "id": "input-coverage-contract-q02" } ] } ] }, { "id": "selection-and-iteration", "name": "Selection and iteration", "description": "Resolve competing matches and the progression of repeated searches.", "findings": [ { "id": "selected-match-sequence", "name": "Selected match sequence", "description": "Record how engine selection rules, alternatives and repetition interact with overlap and zero-length match handling.", "questions": [ { "text": "When several matches are possible, which span does the target engine select under this operation?", "kind": "definition", "id": "selected-match-sequence-q01" }, { "text": "How should repeated matching advance after a zero-length match, and are overlapping matches required?", "kind": "action", "id": "selected-match-sequence-q02" } ] } ] } ] }, { "id": "captures-and-pattern-capabilities", "name": "Captures and pattern capabilities", "description": "Make extraction outputs and dialect-specific constructs explicit.", "rationale": "Matching the expected span does not guarantee correct capture outputs or support in another engine.", "layers": [ { "id": "capture-interface", "name": "Capture interface", "description": "Treat capture groups as an observable interface consumed by downstream actions.", "findings": [ { "id": "capture-output-contract", "name": "Capture output contract", "description": "Describe group identity and meaning, including unmatched optional groups, empty captures and groups inside repetition.", "questions": [ { "text": "Which named or numbered groups are consumed, and what text is each intended to return?", "kind": "definition", "id": "capture-output-contract-q01" }, { "text": "How must consumers distinguish an unmatched group, an empty capture and the outputs of a repeated group?", "kind": "boundary", "id": "capture-output-contract-q02" } ] } ] }, { "id": "construct-dependencies", "name": "Construct dependencies", "description": "Identify pattern features that constrain interpretation, analysis and migration.", "findings": [ { "id": "feature-and-portability-profile", "name": "Feature and portability profile", "description": "Record dependencies such as backreferences, lookaround, recursion or engine-specific syntax without assuming that all regex dialects share them.", "questions": [ { "text": "Which constructs does this expression use that require explicit support checks in a target engine?", "kind": "definition", "id": "feature-and-portability-profile-q01" }, { "text": "What accepted-input, span and capture comparisons are required before a translated expression can replace this one?", "kind": "action", "id": "feature-and-portability-profile-q02" } ] } ] } ] }, { "id": "character-and-boundary-semantics", "name": "Character and boundary semantics", "description": "Specify how the expression interprets text units, classes and boundaries.", "rationale": "Regex behaviour can change across scripts, encodings and newline conventions while the visible pattern remains identical.", "layers": [ { "id": "text-units-and-equivalence", "name": "Text units and equivalence", "description": "Clarify what counts as a character and which text differences matching ignores.", "findings": [ { "id": "unicode-and-case-contract", "name": "Unicode and case contract", "description": "Record relevant byte, code-unit, code-point or grapheme behaviour and the assumptions governing case comparison and normalisation.", "questions": [ { "text": "What text units do wildcard matching, repetition and returned offsets use in the target environment?", "kind": "definition", "id": "unicode-and-case-contract-q01" }, { "text": "Are case folding and Unicode normalisation required, and which transformations occur before regex evaluation?", "kind": "boundary", "id": "unicode-and-case-contract-q02" } ] } ] }, { "id": "classes-and-text-boundaries", "name": "Classes and text boundaries", "description": "Define shorthand classes, word boundaries and newline-sensitive behaviour.", "findings": [ { "id": "class-and-boundary-coverage", "name": "Class and boundary coverage", "description": "Make the intended coverage of digit, word and whitespace classes explicit alongside wildcard and line-boundary rules.", "questions": [ { "text": "Which characters should digit, word and whitespace classes include, and does the declared dialect match that intention?", "kind": "definition", "id": "class-and-boundary-coverage-q01" }, { "text": "Which newline sequences and script-specific boundary cases must tests cover for anchors, dots and word-boundary assertions?", "kind": "measurement", "id": "class-and-boundary-coverage-q02" } ] } ] } ] }, { "id": "correctness-and-execution-suitability", "name": "Correctness and execution suitability", "description": "Assess whether the expression fulfils its intended task within acceptable resource limits.", "rationale": "A syntactically valid regex may accept unintended inputs, expose unstable captures or consume excessive resources.", "layers": [ { "id": "behavioural-evidence", "name": "Behavioural evidence", "description": "Connect intended requirements to examples, counterexamples and revision checks.", "findings": [ { "id": "acceptance-and-extraction-tests", "name": "Acceptance and extraction tests", "description": "Maintain labelled cases with expected acceptance, selected spans and captures, including cases close to the intended boundary.", "questions": [ { "text": "Which independently stated requirement determines the expected result for each positive and negative example?", "kind": "provenance", "id": "acceptance-and-extraction-tests-q01" }, { "text": "Do tests cover empty input, near misses, unexpected prefixes or suffixes and every capture consumed downstream?", "kind": "measurement", "id": "acceptance-and-extraction-tests-q02" } ] } ] }, { "id": "resource-bounds-and-input-trust", "name": "Resource bounds and input trust", "description": "Evaluate compilation and matching costs in relation to pattern and input control.", "findings": [ { "id": "bounded-execution-contract", "name": "Bounded execution contract", "description": "Tie execution permission to measured costs, input-size assumptions, engine guarantees and available interruption controls.", "questions": [ { "text": "Who controls the pattern and input, and what compilation and matching costs occur as adversarial near-miss inputs grow?", "kind": "measurement", "id": "bounded-execution-contract-q01" }, { "text": "What input limits, timeouts, engine restrictions or pattern revisions are required before this expression may run in its intended context?", "kind": "action", "id": "bounded-execution-contract-q02" } ] } ] } ] }, { "id": "evidence-and-external-alignment", "name": "Evidence and external alignment", "description": "What the world already says about this thing, gathered so the model can be checked against it.", "rationale": "A model that cannot be lined up against existing standards, identifiers and practice cannot be adopted by anyone who already uses them.", "layers": [ { "id": "reported-evidence", "name": "Reported evidence", "description": "Findings from the breadth pass, kept separate from the structural claims.", "findings": [ { "id": "evidence-confidence-notes", "name": "Check these first", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "This describes the computing and formal-language sense; no narrower sense was supplied.", "Practical dialects differ substantially: backreferences can exceed classical regular-language expressiveness, and not all engines support them.", "Exact syntax, Unicode behavior, resource limits, and performance guarantees require checking the chosen implementation and version." ], "questions": [ { "id": "evidence-confidence-notes-q01", "text": "Which of these check these first hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-kinds", "name": "Kinds and varieties", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "Classical formal-language regular expressions", "POSIX basic regular expressions (BRE)", "POSIX extended regular expressions (ERE)", "Perl-compatible regular expressions", "ECMAScript regular expressions" ], "questions": [ { "id": "evidence-kinds-q01", "text": "Which of these kinds and varieties hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-standards-and-regulation", "name": "Standards and regulation", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "IEEE Std 1003.1 (POSIX), issued by IEEE, specifies basic and extended regular-expression syntax and matching behavior.", "ECMA-262, issued by Ecma International, specifies ECMAScript regular expressions.", "Unicode Technical Standard #18, Unicode Regular Expressions, issued by the Unicode Consortium, specifies levels of Unicode support for regular-expression implementations." ], "questions": [ { "id": "evidence-standards-and-regulation-q01", "text": "Which of these standards and regulation hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-real-world-use", "name": "Real-world use", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "Searching and replacing text in editors and command-line tools.", "Checking whether input conforms to a specified textual format.", "Extracting fields from logs and other text.", "Specifying token patterns for lexical analysis.", "Filtering records or routing requests according to textual patterns." ], "questions": [ { "id": "evidence-real-world-use-q01", "text": "Which of these real-world use hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-failure-modes-and-hazards", "name": "Failure modes and hazards", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ "Some backtracking engines take extremely long on certain pattern-and-input combinations, enabling regular-expression denial of service.", "Unanchored matching or incorrect grouping can accept unintended input or reject valid input.", "Dialect differences in syntax, match selection, and supported features can change results when patterns are moved between implementations.", "Unicode, locale, case-folding, and character-boundary assumptions can produce unexpected matches.", "Incorrect escaping across programming-language strings and regular-expression syntax can alter a pattern; interpolating untrusted text can introduce unintended pattern operations." ], "questions": [ { "id": "evidence-failure-modes-and-hazards-q01", "text": "Which of these failure modes and hazards hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] }, { "id": "evidence-neighbours", "name": "Neighbouring kinds and how to tell them apart", "description": "Recalled without web access and unsourced; every item is a lead to verify.", "evidence": [ { "name": "regular language", "difference": "A regular language is a set of strings; a classical regular expression is one way to describe that set." }, { "name": "finite automaton", "difference": "A finite automaton recognizes strings through states and transitions; classical regular expressions describe the same class of languages through expression syntax." }, { "name": "glob pattern", "difference": "A glob is a wildcard pattern commonly used for filenames, with syntax and matching rules distinct from regular expressions." }, { "name": "context-free grammar", "difference": "A context-free grammar can describe arbitrary recursive nesting, which classical regular expressions cannot express." }, { "name": "regular-expression engine", "difference": "The engine executes matching operations; the regular expression is the pattern supplied to it." } ], "questions": [ { "id": "evidence-neighbours-q01", "text": "Which of these neighbouring kinds and how to tell them apart hold for the sense of regular expression this model covers, and on what evidence?", "kind": "provenance" } ] } ] } ] } ] }, "openQuestions": [ "Should the registry entry explicitly encompass practical regex constructs beyond classical regular-language expressions, or record that distinction as a required subtype?", "When should two patterns count as the same expression: exact pattern-and-option identity, equal accepted languages, or equal observable spans and captures under a declared operation?", "Which dialect specifications and engine versions should anchor the first researched publication and its portability claims?", "Which Unicode, locale and newline dependencies must be recorded directly versus inherited from an execution-environment model?", "What evidence threshold should permit an agent to classify a regex as suitable for untrusted inputs under a particular engine and resource budget?" ], "statistics": { "bundles": 6, "layers": 11, "findings": 16, "questions": 26 } }, "draft": { "generator": "vr.draft.v3", "status": "draft-generated", "researched": false, "archetype": "work, medium or creative form", "method": "Written from the archetype playbook - what this kind of thing needs beyond identity and provenance - and from the structure that recurred across 6,333 models already researched by two engines. Applied to this entry by rule. No source was read for this thing and no claim here is researched. This entry carries no facets of its own, so they were inferred from its domain - a guess about a whole domain applied to one thing.", "facetsInferred": true, "nextPass": "A researcher replaces this draft with a sourced specification. Treat every sentence below as a proposal to argue with.", "purpose": "Give an agent a durable, checkable way to recognise a regular expression, record what state it is in, and decide what may be done with it.", "whatItIs": "Enable an agent to recognise a regular expression, determine its meaning in a specified dialect and execution context, and judge whether it is suitable and safe for an intended text-processing task.", "characteristics": { "substance": "information", "origin": "conceptual", "agency": "inert" }, "whatYouCanDoWithIt": [ "read and interpreted", "observed and measured" ], "distinguishingFeatures": [ "Names folded into this entry, which a task may need to split apart again: URL match pattern, Python version 3 regular expression, PRONOM internal signature, POSIX Extended Regular Expressions, POSIX Basic Regular Expressions, Raku rules, Java regular expressions, Perl regular expression.", "8 finer distinctions are held as aliases rather than separate entries, because telling them apart needs a task that asks for it.", "Described in 70 Wikipedia languages, which is a measure of how widely the thing is known, not of how important it is." ], "openQuestionsForResearch": [ "Which of the bundles below does a real task actually need, and which are ceremony?", "What does this thing have that the facets do not capture at all?", "Which neighbouring kind is most often confused with a regular expression, and on what evidence are they told apart?" ], "whatItIsMadeOf": "content that has to be carried by something else", "physicalCharacter": [ "Does nothing on its own; everything it does, something else did to it.", "These come from the domain this entry sits in rather than from the entry itself, so treat them as a first guess about the whole domain applied to one thing." ], "whatCanBeDoneWithIt": [ "read it and act on what it says", "observe it, measure it, record its state" ], "howItIsRecognised": [ "What is seen is a copy or a performance, not the work. Recognising the work means recognising the content through whatever is carrying it." ], "relatedModels": [ { "relation": "covers", "note": "Finer kinds folded into this entry because telling them apart needs a task that asks for it. Each is a model waiting to be split out when one does.", "targets": [ "URL match pattern", "Python version 3 regular expression", "PRONOM internal signature", "POSIX Extended Regular Expressions", "POSIX Basic Regular Expressions", "Raku rules", "Java regular expressions", "Perl regular expression" ] } ], "standing": "Described in 70 Wikipedia languages, which measures how widely it is written about rather than how important or how common it is. 8 finer distinctions are held inside this entry as names rather than as separate models.", "structure": { "bundles": [ { "id": "identity-and-classification", "name": "Identity, naming and classification", "description": "How an agent tells one regular expression from another, and a regular expression from things that resemble it.", "rationale": "Recognition comes before every other claim. Without stable identity nothing else in the model can be trusted to be about the same thing twice.", "layers": [ { "id": "naming-and-identifiers", "name": "Names and identifiers", "description": "The names this thing goes by and the identifiers that survive translation and time.", "findings": [ { "id": "preferred-name-and-aliases", "name": "Preferred name, aliases and local names", "description": "Which name to use, which names mean the same thing, and which merely sound similar.", "questions": [ { "id": "preferred-name-and-aliases-q01", "text": "What identifies and describes the name of a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "preferred-name-and-aliases-q02", "text": "Who or what asserted this about the name of a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "preferred-name-and-aliases-q03", "text": "What may an agent decide or do once the name of a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] }, { "id": "stable-identifiers", "name": "Stable identifiers and external keys", "description": "Identifiers that keep pointing at this kind of thing across systems and languages.", "questions": [ { "id": "stable-identifiers-q01", "text": "What identifies and describes an identifier for a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "stable-identifiers-q02", "text": "Who or what asserted this about an identifier for a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "stable-identifiers-q03", "text": "What may an agent decide or do once an identifier for a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] }, { "id": "classification-and-granularity", "name": "Classification and granularity", "description": "Where a regular expression sits among kinds, and how finely a task needs to cut it.", "findings": [ { "id": "kind-and-parents", "name": "Kind, parents and neighbouring kinds", "description": "The classes this thing belongs to and the ones it is next to.", "questions": [ { "id": "kind-and-parents-q01", "text": "What identifies and describes the kind of a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "kind-and-parents-q02", "text": "Who or what asserted this about the kind of a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "kind-and-parents-q03", "text": "What may an agent decide or do once the kind of a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] }, { "id": "distinguishing-features", "name": "Distinguishing features", "description": "What separates a regular expression from the things most often confused with it.", "questions": [ { "id": "distinguishing-features-q01", "text": "What identifies and describes what distinguishes a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "distinguishing-features-q02", "text": "Who or what asserted this about what distinguishes a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "distinguishing-features-q03", "text": "What may an agent decide or do once what distinguishes a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] } ] }, { "id": "state-and-lifecycle", "name": "State and lifecycle", "description": "The states a regular expression passes through and the events that move it between them.", "rationale": "Most decisions about a thing depend on what state it is in now, which is a claim with a time on it, not a property.", "layers": [ { "id": "lifecycle-stages", "name": "Lifecycle stages", "description": "From coming into existence to ceasing to be one of these.", "findings": [ { "id": "stages-and-transitions", "name": "Stages and transitions", "description": "The stages worth naming and what moves a regular expression between them.", "questions": [ { "id": "stages-and-transitions-q01", "text": "What identifies and describes the lifecycle of a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "stages-and-transitions-q02", "text": "Who or what asserted this about the lifecycle of a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "stages-and-transitions-q03", "text": "What may an agent decide or do once the lifecycle of a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] }, { "id": "observations-and-status", "name": "Observations and current status", "description": "What is observed about a regular expression, how often and by whom.", "findings": [ { "id": "observation-record", "name": "Observation record", "description": "How an observation of a regular expression is recorded so that it can be superseded rather than overwritten.", "questions": [ { "id": "observation-record-q01", "text": "What identifies and describes an observation of a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "observation-record-q02", "text": "Who or what asserted this about an observation of a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "observation-record-q03", "text": "What may an agent decide or do once an observation of a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] } ] }, { "id": "content-and-access", "name": "Content, encoding and access", "description": "What a regular expression says, how it is encoded and who may read it.", "rationale": "An informational thing carries content that can be copied, versioned and withheld, none of which its physical carrier explains.", "layers": [ { "id": "content-and-encoding", "name": "Content and encoding", "description": "The content itself, its format and its language.", "findings": [ { "id": "content-and-format", "name": "Content, format and language", "description": "What a regular expression contains and in what form it is held.", "questions": [ { "id": "content-and-format-q01", "text": "What identifies and describes the content of a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "content-and-format-q02", "text": "Who or what asserted this about the content of a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "content-and-format-q03", "text": "What may an agent decide or do once the content of a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] }, { "id": "access-and-rights", "name": "Access, rights and retention", "description": "Who may read, copy or change it, and for how long it is kept.", "findings": [ { "id": "access-rules", "name": "Access rules and retention", "description": "The permissions attached to a regular expression and the period it survives.", "questions": [ { "id": "access-rules-q01", "text": "What identifies and describes access to a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "access-rules-q02", "text": "Who or what asserted this about access to a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "access-rules-q03", "text": "What may an agent decide or do once access to a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] } ] }, { "id": "work-and-manifestation", "name": "Work, version and copy", "description": "Which level of regular expression a statement is about.", "rationale": "The work, the edition, the file and the copy in hand are four things; rights and content attach to different ones.", "layers": [ { "id": "levels", "name": "Levels of the thing", "description": "Work, expression, manifestation and item, in plain terms.", "findings": [ { "id": "level-rules", "name": "What belongs at each level", "description": "Which facts hold for the work and which only for one copy.", "questions": [ { "id": "level-rules-q01", "text": "For regular expression, which facts belong to the work itself, which to a version, and which to a single copy?", "kind": "boundary" }, { "id": "level-rules-q02", "text": "What identifier exists at each level, and which one is being cited?", "kind": "definition" } ] } ] }, { "id": "versions", "name": "Versions, editions and variants", "description": "How versions differ and which is canonical to whom.", "findings": [ { "id": "version-record", "name": "Versions and canonicity", "description": "Differences that matter and who calls one authoritative.", "questions": [ { "id": "version-record-q01", "text": "Which versions or editions of regular expression exist, and how do they differ substantively?", "kind": "definition" }, { "id": "version-record-q02", "text": "Who treats which version as authoritative, and for what purpose?", "kind": "provenance" } ] } ] } ] }, { "id": "authorship-and-rights", "name": "Authorship, rights and permitted use", "description": "Who made regular expression and what may be done with it.", "rationale": "Rights are jurisdictional, time-limited and attached to a level, and an agent that ignores that will copy what it may not.", "layers": [ { "id": "authorship", "name": "Authorship and contribution", "description": "Who contributed what, and in what capacity.", "findings": [ { "id": "contribution-record", "name": "Contributors and roles", "description": "The people and bodies behind it, with their roles.", "questions": [ { "id": "contribution-record-q01", "text": "Who authored or contributed to regular expression, in what roles, and how is that attested?", "kind": "provenance" }, { "id": "contribution-record-q02", "text": "Where authorship is disputed or anonymous, what is recorded instead?", "kind": "boundary" } ] } ] }, { "id": "rights", "name": "Rights and permissions", "description": "Which rights subsist, where, until when, and what they permit.", "findings": [ { "id": "rights-record", "name": "Rights, term and permitted acts", "description": "The regime in force and what it allows.", "questions": [ { "id": "rights-record-q01", "text": "What rights subsist in regular expression, in which jurisdictions, and until when?", "kind": "definition" }, { "id": "rights-record-q02", "text": "Which acts are permitted without further permission, and which must an agent refuse?", "kind": "action" } ] } ] } ] }, { "id": "provenance-and-evidence", "name": "Provenance, evidence and time", "description": "Where every claim about a regular expression came from and when it held.", "rationale": "A claim without a source and a time cannot be superseded, only overwritten, and an agent that overwrites loses the ability to explain itself.", "layers": [ { "id": "source-and-authority", "name": "Source and authority", "description": "Who said it, on what evidence, and how strongly.", "findings": [ { "id": "claim-provenance", "name": "Claim provenance and confidence", "description": "The authority behind each claim about a regular expression and how confident it is.", "questions": [ { "id": "claim-provenance-q01", "text": "What identifies and describes a claim about a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "claim-provenance-q02", "text": "Who or what asserted this about a claim about a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "claim-provenance-q03", "text": "What may an agent decide or do once a claim about a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] }, { "id": "time-and-versions", "name": "Time, versions and supersession", "description": "When a claim was true, when it was learnt, and what replaced it.", "findings": [ { "id": "validity-and-supersession", "name": "Validity period and supersession", "description": "How an old claim about a regular expression is retired without being erased.", "questions": [ { "id": "validity-and-supersession-q01", "text": "What identifies and describes the validity of a claim about a regular expression, and in what units or vocabulary?", "kind": "definition", "answer_data": [ "identifiers", "types and classes", "values with units", "explicit unknowns" ] }, { "id": "validity-and-supersession-q02", "text": "Who or what asserted this about the validity of a claim about a regular expression, by which method, and when was it true?", "kind": "provenance", "answer_data": [ "authority", "method", "evidence", "event time", "knowledge time" ] }, { "id": "validity-and-supersession-q03", "text": "What may an agent decide or do once the validity of a claim about a regular expression is known, and what must it refuse?", "kind": "action", "answer_data": [ "permitted actions", "preconditions", "refusals", "escalation" ] } ] } ] } ] } ] }, "statistics": { "bundles": 6, "layers": 12, "findings": 14, "questions": 38 } } } }