Template Instantiation

Version

v5 · 2026-09-07 · History

Prime #

1469

Origin domain

Computer Science & Software Engineering

Subdomain

generative systems → Computer Science & Software Engineering

Related primes

Form and Content, Invariance

Core Idea

Template instantiation is the operation that produces a concrete instance by binding payloads into the open, typed slots of a frame that persists unchanged across uses. Six roles are constitutive: a frame reusable beyond one occasion; slots identified by name, position, or type and carrying constraints on what may enter them; payloads supplied per occasion; a binding that associates payloads with slots; an instance in which those positions are no longer open; and a conformance criterion deciding whether a proposed filling counts. Remove any one of the six and what remains is a different operation wearing the same word. ^[1]

The construct buys two things at once, and they are worth separating because a design can have either without the other. The first is design-once economy: whatever the frame settles is settled a single time, so the marginal cost of the hundredth instance falls to the cost of its payload rather than the cost of a design. The second is comparability: two instances of one frame can differ only where the frame left room, which makes every difference between them localizable to a named position and every similarity attributable to the frame rather than to coincidence. ^[2]

Cardinality belongs to the frame rather than to whoever fills it. A slot may be required, optional, or repeatable, and a template admitting a list of beneficiaries or an unbounded number of experimental replicates is not thereby less of a template; what dissolves the construct is a position whose admissible fillings are decided afresh on every use, because then nothing has been reused except an inclination. ^[3]

The frame's silences are as load-bearing as its slots. Everything a template fixes is a commitment inherited by whoever fills it, usually without restatement and often without notice: the order of clauses, the units, the categories on offer, the questions never posed. This is the source of both the construct's power and its pathology: whatever lets one careful design propagate through ten thousand instances lets one unexamined assumption travel exactly as far.

Two failure modes follow from the structure rather than from bad luck. Slot-fit failure occurs when a payload cannot be admitted: the matter has two landlords and the form provides one line, the measurement arrives in units the field will not accept. Frame drift occurs when instances are edited after production until the population no longer shares the structure the template describes, at which point the comparability the template was adopted for has quietly lapsed while the template itself still sits in the repository looking authoritative.

Structural Signature

Persistent frame with open, constrained positions → payloads supplied per occasion → a binding that closes the positions → an instance bearing a traceable relation to the frame → a conformance decision, with whatever could not be bound reported as misfit. ^[1]

Recurring features:

• Separability of frame from filling. The frame can be stated without reciting any filling, and a filling can be supplied without redescribing the frame. Where describing the pattern requires quoting one of its products, there is no template, only a favoured example.
• Addressable positions. Slots are reachable by name, index, or type rather than by pointing at a location, which is what lets a payload be supplied by someone who never watched the frame being authored.
• Admissibility rather than mere emptiness. Each position restricts what may enter it through a type, a range, a coded vocabulary, or a cardinality, so a proposed filling can be refused before any instance exists.
• A binding with a before and an after. There is a moment at which open positions close. The instance dates from that moment, and questions about its contents are not merely unanswered beforehand but ill-formed.
• Frame invariance across the binding. The frame is the same object after producing an instance as before it, which is what makes the next product comparable to the last rather than merely reminiscent of it.
• Traceable provenance. The product retains something — a form number, a generated-file header, a die mark, a construction's syntactic shape — identifying which frame made it and therefore which commitments it inherited.
• Reported residue. What could not be bound surfaces rather than vanishing: an unfilled required position, a payload with nowhere to go, a validation message naming the field that refused.

What It Is Not

Working from an example is not this. Opening last quarter's report and typing over it yields a document that looks templated and is not, because nothing declares which parts were meant to vary, nothing refuses a wrong filling, and the next author inherits whichever accidents of the source happened to survive the overtyping. Freehand work made in the likeness of a predecessor falls outside the construct wherever no invariant positions and no conformance rule constrain the result. ^[4]

It is not a claim that the products resemble one another. Uniform output is a property of narrow slots, not of instantiation as such; a frame with a free-text position and an unbounded repeat group yields instances no reader would group by eye. Sameness of appearance is evidence about slot design and nothing else.

It does not require a designer, a convention, or anyone to interpret the result. Frames with positions and admissibility rules run in developmental biology and in grammar with no committee anywhere, and the operation is present wherever the roles are, whether or not anybody would use the word.

Possessing a template is not instantiating one. A frame nobody binds is an inert document, and a great many organizations maintain libraries of such documents while producing their actual output some other way. The converse also holds: a group can be running a frame it has never written down, and the tacit version is a real template provided it genuinely constrains and genuinely refuses.

Finally, a blank is not a slot when there is no second occasion. A gap left in a one-off document is merely unfinished; reuse is what gives the frame something to be invariant across, and without it neither the economy nor the comparability arises.

Broad Use

Documents and law. Standard-form contracts whose negotiated terms live in schedules, statutory forms, court pleadings, wills, purchase orders, and the boilerplate-plus-particulars structure that dominates commercial paper.

Software. Parametric polymorphism and generics, macros, class definitions instantiated as objects, code generators, container images parameterized at run time, infrastructure modules, and the prompt scaffolds now used to drive language models.

Manufacturing. Molds, dies, jigs, stencils, and photolithographic masks, where the frame is a physical negative whose cost is borne once and whose products are cheap.

Empirical research. Experimental protocols, case report forms, reporting checklists, and survey instruments, each fixing what will be recorded before anything is observed.

Language. Argument-structure constructions with open positions, idiom frames admitting a restricted class of fillers, formulaic verse, and the fixed openings and closings of letters.

Biology. Developmental programs producing serially repeated structures from one genetic frame, where the same regulatory apparatus yields segments differing only at the positions the program leaves variable.

Composed form. Twelve-bar blues, sonata form, sonnet structure, modular building systems, and standard floor-plan types.

What makes these one family is not that they are all called templates; several are not. It is that the same four roles carry the reasoning in each — a frame that outlives its products, positions that constrain what may enter, a binding that closes them, and a product traceable to the frame — and that the questions worth asking are identical once the local vocabulary is stripped away.

Clarity

The confusion this construct dissolves is about authorship of properties. Presented with a finished instance, a reader cannot tell by inspection which of its features were chosen on this occasion and which were supplied by the frame, and readers routinely credit the visible filler with decisions made by an absent designer. Naming the frame turns that into a well-posed question with a mechanical answer: hold the instance against the frame, and everything that does not vary is not the filler's doing. ^[5]

Three plausible inferences collapse once this is clear. Agreement among instances of one frame is not independent corroboration, because they were not independent. A defect appearing in every instance is one defect rather than many, and counting it repeatedly overstates both its prevalence and the cost of fixing it. And an omission shared by a whole population of documents is usually a fact about a form rather than about the world it describes.

It also dissolves a stale argument. When one party insists these cases are all the same and another insists every case is unique, both are right at their own level, and the frame states precisely where the boundary between the levels falls: fixed by the template on one side, chosen per instance on the other. The dispute is only about which level the speaker had in view.

Manages Complexity

What instantiation lets you stop tracking is the internal structure of individual instances. A population of a thousand documents is not a thousand structures to hold in mind; it is one frame, a constraint per position, and a thousand small tuples of payloads. The description shrinks from instance count times property count down to the frame's properties plus what each occasion actually supplied, and the shrinkage is exact rather than approximate because the frame's invariance guarantees nothing has been lost in the compression. ^[6]

Three recurring chores disappear with it. Well-formedness need not be re-established case by case, since the conformance check does it once per binding and reports by name what failed. Shape need not be discovered by reading, since knowing which frame produced a thing tells you where in it anything lives. And a correction need not be propagated a thousand times, because in systems where instances are derived rather than authored it is applied to one object.

The same arithmetic locates scarce attention. An hour spent reviewing a frame is an hour spent on every instance it will ever produce, which is why an unreviewed frame is the most expensive unexamined object in most systems, and why review effort is usually spent in the wrong place: on instances, where it buys one document at a time.

Abstract Reasoning

The construct licenses a specific diagnostic procedure on any population of similar artifacts. Align the population and factor it: what never varies is the candidate frame, and each locus of variation is a candidate position. Then probe admissibility by proposing a filling that ought to be refused; if nothing is ever refused the locus is a free field rather than a slot, and if everything is refused it is a constant that was misread as a variable. ^[7]

The third step is the one most often skipped, and it is a counterfactual. Shared structure can arise because a frame produced it or because independent efforts converged on the same solution to the same constraint, and the two look identical in a static sample. Edit the frame and watch whether subsequent products move. Convergent form will not move; template output will, and the lag before it does is itself informative about how instances are made.

Two further inferences follow. Read the silences: a property no instance ever expresses is evidence about the frame rather than about the domain, and a systematic absence localizes to a position that does not exist. And attribute the anomalies: a feature present everywhere that nobody remembers choosing is almost certainly a frame commitment, so tracing it identifies both who decided it and who can undecide it.

Knowledge Transfer

The portable part is the role skeleton and the interrogation it supports. Where is the frame, what are its positions, what may enter each, who performs the binding, what decides conformance, and what happens to residue — these six questions are this entry's own, and they appear to survive translation into other substrates, as do the two failure modes, the amortization arithmetic,^[8] and the warning that a frame's silences may matter as much as its slots. ^[9]

What does not transfer is everything about what happens after the binding, and this is where analogies break. Retroactivity differs sharply: regenerate the software and every instance follows the frame, but executed contracts, cast parts, and born organisms do not, so the instruction to fix the template means repair-the-population in one substrate and repair-only-the-future in another. Reversibility differs too, since a filled form yields its payload back on demand while a molded part has fused frame and filling permanently, which decides whether an instance can be re-derived or must be discarded.

Two governance facts are equally local. Who owns the frame and on what authority it may be amended has no substrate-independent answer, and neither does the frame-to-instance cost ratio, which decides whether a misfitting case is best met by widening the frame or by handling it outside.

Examples

Formal/abstract

The induction principle in the standard first-order axiomatization of arithmetic is not an axiom. It is a frame with one open position: supply any formula of the language distinguishing a variable, and the frame returns an axiom asserting that if the formula holds at zero and is preserved by successor, it holds everywhere. The frame fixes that shape once, so every axiom it yields has the same three-part structure and the axioms differ from one another in exactly one place, which is the formula bound into the position. ^[10]

Admissibility here is unusually clean. The filling must be a well-formed formula of the language, and the substitution must not let a quantifier already present capture a variable that was free in the payload; a substitution that would do so is refused, and refused before any axiom exists rather than discovered to be defective afterwards. This is slot-fit failure in purely syntactic dress, mechanical and checkable by anyone.

The frame's silence is the instructive part. Because the position accepts only formulas of the language, the principle reaches only the properties that language can express, and the theory generated is therefore weaker than a formulation quantifying directly over all collections of numbers. Nobody chose that weakness for any particular axiom; it is contributed entirely by the frame, and it is the reason the first-order theory admits models other than the intended one while the second-order formulation does not. ^[11]

Mapped back: the schema is the frame and the formula position is its single slot; well-formedness plus capture-avoidance is the admissibility rule; substitution is the binding; each axiom is a product; the syntactic check is the conformance criterion; rejected substitutions are the reported residue; and the restriction to definable properties is the frame commitment that every product inherits without stating and that no inspection of a single axiom would reveal.

Applied/industry

A multi-site clinical trial runs on a case report form. The form fixes, before any participant is enrolled, which observations will exist: the visits, the fields at each visit, the units, the coded vocabularies for diagnoses and adverse events, the required-versus-optional status of each item, and the edit checks that fire when an entry falls outside a plausible range. Sites on three continents, using different languages and different clinical customs, produce records that can be pooled precisely because the frame they filled was identical. ^[12]

Residue is handled as a flow rather than as loss. An entry failing an edit check raises a query that returns to the site by field name, and an event with no matching term in the coded vocabulary is recorded against a catch-all and escalated to whoever maintains the terminology. That is what keeps the frame honest, because the catch-all's contents are the only running record of what the form cannot see.

Both failure modes appear in their institutional dress. The form's silences are absolute: an outcome nobody thought to ask about is not merely unmeasured but permanently unmeasurable for that trial, and no amount of later analysis recovers it. And amendments mid-study create version skew, so records collected under an early revision and a late one are comparable only in the fields the amendment did not touch, which forces the frame version to be carried as data alongside the observations it produced. ^[13]

Mapped back: the approved form is the frame and each field is a position with an explicit admissibility rule; the coded vocabularies are the slot types; data entry at a site is the binding; a participant's record is a product; edit checks are the conformance criterion; queries and catch-all entries are the reported residue; and the amendment history is frame drift made visible, which is why the version stamp on each record is not bureaucratic overhead but the thing that keeps the comparability claim checkable.

Structural Tensions

T1 — Slot granularity has no safe setting. Coarse slots make the frame decide too much: output is uniform, every case served adequately and none well, and the misfit stays invisible because it never produces an error. Fine slots make the frame decide too little: the person filling it faces most of the original design problem the template was adopted to remove, under time pressure and without the designer's context. Each fix is the other's failure, and the right grain depends on how much variation the population carries, which is knowable only after the frame has been in service.

T2 — Products drift away from the frame that made them. Once bound, an instance is an independent object with its own edit history, and edits accumulate for good local reasons: an exception this quarter, a clarification for one reader, a field repurposed because the right field did not exist. Nothing announces that the population has stopped sharing the structure the template describes. The comparability that justified the template lapses silently while the frame remains on file, so audits keep validating against a document that describes a population which no longer exists.

T3 — The frame encodes commitments its users cannot see. Slots are visible and silences are not, so people filling a frame experience the offered positions as the space of what can be said. Categories the frame omits become not merely unrecorded but unthinkable within the process, and the omission is never surfaced because absence generates no error and no residue. Detecting it requires reading the frame against cases it was never shown, which is expensive, unrewarded, and structurally nobody's job — least of all the job of those who only ever see instances.

T4 — Filling a slot mechanically discards the judgment the slot presupposes. A well-designed position compresses a decision into a blank, which is exactly what makes the frame efficient and exactly what makes the decision disappear. The blank presents as clerical, invites completion rather than deliberation, and yields a conforming instance whether or not any thinking occurred. Risk assessments, code review checklists, and consent discussions all fail this way, and the failure is undetectable from the artifact, because a slot filled thoughtlessly and one filled carefully are indistinguishable once bound.

T5 — Amortization pressure hardens the frame against the cases it fits worst. Every additional instance strengthens the argument for leaving the frame alone, since the cost of amendment scales with the population while the benefit accrues to the minority whose cases misfit. The accounting also splits: the frame's savings are captured centrally and visibly, while the cost of its misfit is borne one instance at a time by whoever must work around it. Both effects push in the same direction, so frames become most rigid precisely when accumulated evidence of misfit is greatest.

T6 — Conformance certifies fit, never merit. The check a template licenses answers whether a payload was admissible, and that is all it answers; a fully conforming instance can be irrelevant, dishonest, or dangerous. Institutions nonetheless gate on conformance because it is cheap and defensible, and the gate then trains everyone upstream to optimize for admissibility rather than for content. The template's authority makes the substitution hard to contest, since objecting requires arguing against a rule that the instance demonstrably satisfies.

Structural–Framed Character

Template Instantiation sits at the structural end of the structural–framed spectrum, with an aggregate of 0.0 and every diagnostic reading zero. The skeleton that travels has four parts: a reusable frame whose slot structure is identifiable across instances, typed or constrained slots, a binding operation that produces one concrete instance from frame plus payload, and conformance criteria deciding whether the payload fits.

Human-practice-bound is the diagnostic doing most of the work, and it reads 0.0. Biological developmental programs run the frame–slot–binding–instance roles with no designer, convention, or interpreter present; documents, software generics, manufacturing molds, legal forms, experimental protocols and grammatical constructions sit alongside them as further substrates rather than as the home case.

Vocabulary travel reads zero: frame, slot, binding and instance are domain-stripped terms, and each substrate names the operation its own way without one lexicon riding along. Evaluative weight reads zero — the prime describes an operation, and even its failure modes, payload–slot mismatch and gradual mutation of the shared frame, are structural mismatches rather than faults. Institutional origin reads zero; legal forms are one substrate among molds and developmental programs, and no institution is required for a frame to be bound. Import-vs-recognize is recognition: one locates the invariant frame and the binding step already present.

For use, the grade means instantiation transfers as a pattern check, and what must be verified is that the operation is really there — not type–token predication, not copying a filled instance, not parameterization without a produced artifact, and not schema validation, which checks conformance rather than creating it.

Substrate Independence

Template Instantiation is about as substrate-independent as a prime can be — composite 5 / 5 on the substrate-independence scale. What moves between domains is a generative arrangement: a frame that persists unchanged across uses, positions left open under stated admissibility constraints, payloads supplied per occasion, a binding moment at which those positions close, and an instance traceable back to the frame that made it. Printed forms, generic types in code, injection moulds, legal instruments, experimental protocols, developmental programmes and grammatical constructions each run that operation and each report the same residue when a payload will not bind. The frame–slot statement carries no commitment to matter, symbol or institution, and all three host it outright rather than by resemblance.

• Composite substrate independence — 5 / 5
• Domain breadth — 5 / 5
• Structural abstraction — 5 / 5
• Transfer evidence — 4 / 5

Relationships to Other Abstractions

Current abstraction Template Instantiation Prime

Parents (2) — more general patterns this builds on

• Template Instantiation presupposes Form and Content Prime

  Instantiation requires the reusable structural frame to remain separable from the variable content bound into it.

• Template Instantiation is part of Invariance Prime

  Preservation of the frame and slot semantics across payload substitutions is an internal constituent of template reuse.

Children (5) — more specific cases that build on this

• Associated bundle Domain-specific is a kind of Template Instantiation

  The proposed strict upward parent is prime:template_instantiation.

• Lost-wax casting Domain-specific is a kind of Template Instantiation

  The proposed strict upward parent is prime:template_instantiation.

• Ode Domain-specific is a kind of Template Instantiation

  The proposed strict upward parent is prime:template_instantiation.

▸ Show 2 more

Hierarchy paths (2) — routes to 2 parentless roots

• Template Instantiation → Form and Content → Representation → Abstraction

Show alternative path (1)

Neighborhood in Abstraction Space

Template Instantiation sits in a sparse region of abstraction space (87^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely rather than landing on a neighbor.

Family — Formal Systems & Structural Conditions (20 primes)

Nearest neighbors

• Site — 0.70
• Object Permanence — 0.69
• Bijectivity — 0.69
• Script — 0.68
• Permutation — 0.68

Computed from structural-signature embeddings · 2026-09-10

Not to Be Confused With

Template Instantiation must be separated first from the Type–Token Distinction, its nearest neighbour and the source of most misclassification. A type is a repeatable kind and its tokens are its numerically distinct occurrences; the relation between them is membership or realization, and it is entirely silent about how any token came to exist. This prime is not a relation but a production step, with a frame that existed beforehand, positions that can refuse a payload, and a moment at which openness ends. Nothing is ever rejected for failing to be a token of a type in the way a payload is rejected by a slot. The two also compose in both directions, which is why they are so easily merged: every product a template makes is a token of some type, and the template itself is a repeatable object whose copies are its own tokens. The practical difference is what each question buys: asking what a thing is a token of classifies it, while asking what template produced it says where its properties came from and who can change them for every future instance at once.

Form and Content is the parent and the broader separation: a work's structure held apart from its substance. That separation demands no reuse, no addressable positions, and no capacity to refuse a filling: a poem's form is distinguishable from its subject without any slot into which a subject might be bound. This prime is the special case in which the form persists as an object across occasions and actively constrains what may join it.

Invariance is the other parent, naming properties preserved under transformation. Template instantiation contains an invariance claim as an internal part — the frame is unchanged by producing an instance — but invariance by itself supplies no frame, no positions, no payload, and no product. A conserved quantity is invariant across every process that respects it and instantiates nothing whatsoever.

Schema is a structured representation of a kind of thing, and the two are so often deployed together that the roles blur. The default direction of use separates them. A schema is authored to describe what is acceptable and is run against a candidate to decide conformance; a template is authored to produce what is typical and is run with payloads to yield an artifact. The same document may well be generated by one and validated by the other, and a sufficiently expressive schema can be driven backwards to generate, but the object being written is different in each case: the acceptable region in one, the standard product in the other.

Script is closer than it looks, being a stored representation of a familiar situation with role positions to fill. What it adds is temporal and causal order among its parts, so a script is violated by events arriving in the wrong sequence — a breach with no analogue here, since a frame whose positions were filled out of order still yields a conforming instance. This prime carries no commitment about when its positions are bound.

Abstraction runs the opposite way. It drops detail to retain what matters, leaving nothing in particular open and producing no artifacts. This prime begins from something already general and re-adds particulars under constraint, which makes the two complementary steps rather than rivals: abstraction is how a frame is arrived at, instantiation is what the frame is then for.

Archetype is a recurring pattern identified across a body of instances, typically recovered after the fact from a corpus rather than authored in advance. It has no admissibility rule and no residue: nobody's story is refused for filling the mentor role incorrectly, and no queue collects the cases the archetype could not accommodate. Where an archetype is codified into something that constrains and refuses before production, it has become a template, and the change is substantive rather than terminological.

Composition arranges parts into a coherent whole. A composition may be unique, its parts need not be interchangeable, and the positions need not exist before the things occupying them. A frame is composed too, but its point is that one arrangement outlives every set of parts ever bound into it.

Finally, Standardization is convergence by independent parties on a shared specification, which is a fact about agreement. A template can be entirely private to one author and bound ten thousand times with nobody consenting to anything, and a standard can specify a form without generating a single instance. The two travel together constantly, since agreeing on a frame is a cheap route to comparable output, but the load-bearing role in one is consent and in the other production.

Solution Archetypes

No catalogued solution archetypes reference this prime yet.

References

[1] Minsky, Marvin. A Framework for Representing Knowledge. MIT Artificial Intelligence Laboratory Memo 306, 1974. Establishes a reusable frame whose lower levels carry terminals - slots that must be filled by specific instances - where each terminal specifies conditions its assignments must meet and a failure to meet them sends the system to a replacement frame. registry ↩a ↩b

[2] Krueger, Charles W. "Software Reuse". ACM Computing Surveys, 1992. Supports design-once economy: the one-time cost of creating a reusable artifact is amortized each time it is reused, so the cost of an additional instance falls to what that occasion supplies. registry ↩

[3] World Wide Web Consortium. XML Schema Part 1: Structures (Second Edition). W3C Recommendation, 2004. Supports cardinality as a property of the reusable definition rather than of any use, since occurrence constraints on a particle fix a position as required, optional or repeatable once for every instance validated against it. registry ↩

[4] Dubinsky, Yael, Julia Rubin, Thorsten Berger, Slawomir Duszynski, Martin Becker, and Krzysztof Czarnecki. "An Exploratory Study of Cloning in Industrial Software Product Lines". 17^th European Conference on Software Maintenance and Reengineering, IEEE, 2013. Reports that copying a finished artifact and editing it leaves what varies undeclared - knowledge of it living in people's heads rather than in any specification - and propagates the source's defects to copies nobody has connected. registry ↩

[5] Goldberg, Adele E. Constructions: A Construction Grammar Approach to Argument Structure. University of Chicago Press, 1995. Argues that constructions themselves carry meaning independently of the words filling them, so properties a reader credits to the visible filler are contributed by the frame and are recoverable only by comparison against it. registry ↩

[6] Rissanen, Jorma. "Modeling by Shortest Data Description". Automatica, 1978. Supports the exact two-part description in which total length is the cost of stating the shared model plus the cost of each instance given it, rather than the cost of each instance stated whole. registry ↩

[7] Plotkin, Gordon D. "A Note on Inductive Generalization". Machine Intelligence 5, Edinburgh University Press, 1970. Supports factoring a set of instances into their least general generalization - the common structure, with variables standing at exactly the positions where the instances differ. registry ↩

[8] Krishnan, V., and Saurabh Gupta. "Appropriateness and Impact of Platform-Based Product Development." Management Science, vol. 47, no. 1 (2001): 52–68. Supports only the leverage rationale standing behind the amortization arithmetic, and only for engineered product platforms: platform-based development can "enable a firm to better leverage investments in product design and development." It states no amortization formula and says nothing about the six-question interrogation, the two failure modes, or transfer to other substrates. registry ↩

[9] Entman, Robert M. "Framing: Toward Clarification of a Fractured Paradigm." Journal of Communication, vol. 43, no. 4 (1993): 51–58. Supports only that in framing "the omissions ... may be as critical as the inclusions in guiding the audience" — parity, not a ranking — which is why the comparative claim that silences bind harder than slots, and the explanation that nobody reads them, have been dropped rather than cited. The six-question interrogation, and the claim that it carries into other substrates, are this entry's own. registry ↩

[10] Kaye, Richard. Models of Peano Arithmetic. Oxford University Press, 1991. Supports the first-order induction axiom schema as a frame with one formula position that generates structurally identical axioms differing only in what is bound into it. registry ↩

[11] Skolem, Thoralf. "Ueber die Nicht-charakterisierbarkeit der Zahlenreihe mittels endlich oder abzaehlbar unendlich vieler Aussagen mit ausschliesslich Zahlenvariablen". Fundamenta Mathematicae, 1934. Establishes that an axiomatization restricted to number variables admits models other than the intended one, so the restriction the schema's slot imposes is what costs the theory its categoricity. registry ↩

[12] International Council for Harmonisation. Integrated Addendum to ICH E6(R1): Guideline for Good Clinical Practice E6(R2). ICH, 2016. Defines the case report form as the document designed to record all of the protocol-required information to be reported on each trial subject, fixing what will be recorded before any participant is enrolled. registry ↩

[13] Clinical Data Interchange Standards Consortium. ODM-XML v1.3.2. CDISC, 2013. Supports carrying the frame version on the product: collected clinical data references the MetaDataVersionOID of the study definition it was captured under, since a study may hold several versions of that definition at once. registry ↩