Cubist

LANGUAGE REFERENCE · CHAPTER 18

Error messages

Every error message shown in this reference, what it means, and what to do.

How to read an error

Every error and warning has a code, such as E606 or W703. The code comes before the message wherever the checker reports one: error E606 at line 2:3 (wrong): Type mismatch: … on the command line, and E606: Type mismatch: … in the REPL and the workspace, where it links here. E codes come from the parser and the elaborator, K codes are refusals by the kernel, and W codes are warnings. A code keeps its meaning as the message’s wording changes, and this page has an entry for each, at errors.html#E606: the sections below explain the codes this reference shows, and every code lists them all.

Every rejected example in this reference shows its error as a // Error: comment, on the line where the checker reports it. An accepted example that draws a warning shows it as a // Warning: comment in the same way. This chapter lists those messages by topic, with what each means, what to do, and where an example shows it. Parts in italics stand for names or numbers from your source.

An error names the declaration it belongs to, and the workspace marks the statement it points at. A rejected declaration is not added, so every declaration that uses it fails too, with “Untranslated dependency”. Fix the first error in a file first.

Reading the source

These are reported before anything is checked, at the first token that does not fit.

CodeMessageMeaning and fixExample
E151“Imports must come before declarations.”Move every import to the start of the file.files
E106“Unexpected character c”Source is ASCII. Write ->, forall and exists instead of symbols.names
E110“Expected a name.”A name cannot start with a digit.names
E112“Expected ':' or '<', found token”Every parameter needs a type, after a colon, or, for a universe variable, a bound after <.parameters
E109 E153“Write := to give a value: …”A binding (def, let, obtain, simp_set) gives its value with :=; = is the equality type. The message shows the form to use.declarations
E108“Expected ';', found token”A missing semicolon, reported at the next token.declarations
E117“Separate names with commas: (n, m : Nat)”Names that share a type are separated by commas, in parameters, fun binders and after forall or exists.several parameters
E128“End forall's type with a dot: forall n : Nat. P(n)”A dot, followed by a space, separates a quantifier’s type from its body; the same holds for exists. A comma would read as the next parameter.forall and exists
E108“Expected '}', found ';'.”The braces of with unfolding hold one expression, without a semicolon.unfolding hints
E108“Expected '=', found token”A calc step is an equality; other relations cannot be chained yet.not yet available
E139“Expected a proof statement; found word”The word is not a statement. apply, refine and sorry do not exist yet.statements, not yet available
E136“have was removed: write let name : T := term; …”let has have's forms: let name : T := term; and let name : T { … }.local lemmas
E137“show was removed: …”Prove the restated goal, let h : T { … }, then close with exact h;.restating the goal
E138“suffices was removed: …”Prove the claim first, let h : T { … }, then prove the goal from h.reasoning backwards
E164“cases was removed: write match value { left(a) => { … } right(b) => { … } }.”The match statement takes a sum apart, each clause proving the goal at its side. Write match where the source had cases; the clauses may stay as they were.taking a sum apart
E123“Expected an expression, found '{'.”A block is not a term. Prove the part first with let name : T { … }.blocks
E140“Use obtain to unpack a pair.”let names one term; obtain takes a pair apart.let
E120“A pair has only the projections .1 and .2. …”A projection is .1 or .2. A tuple nests pairs to the right, so the third component of (a, b, c) is .2.2.using pairs
E131“A pair pattern needs at least two components.”Write obtain (a, b) := pair;, or name the whole value with let.obtain
E122“Unary numerals are limited to 256. Import nat and use nat for binary naturals.”Build larger numbers with arithmetic, or use binary literals.numbers, limits
E144“simp only requires an explicit rule list.”Write simp only [rules];, or plain simp; for the default rules.simplification
E145“simp only cannot exclude rules.”without removes default rules; simp only has none. Leave the rule out of the list instead.rule selection
E149“simp_rule priority must be an integer from 0 to 1000.”Give a priority in range.registration

Names and declarations

CodeMessageMeaning and fixExample
E343“Untranslated name: name”The name is not in scope. It may be declared later, be the declaration itself (there is no recursion), need an import (+ needs import unat;), be misspelled, or not be a construct of the language, such as Interval as a type.order, numbers
E253“m::name names a declaration of m, which is not imported here: import m;”A qualified name names a declaration of the module it is written in or of an imported one. Import the module.qualified names
E254“m declares no name, so m::name names nothing.”The module declares no such name. Check the module and the name.qualified names
E340“Untranslated dependency: name”The named declaration failed, so its users are blocked. Fix the named declaration.checking
E872“Duplicate declaration …: a declaration in this module already owns that name.”A name is declared twice in one module. Rename one; the earlier declaration remains available.order
E327“Simplification rule name is already registered in this module.”Register each rule once per module.registration
E008“An axiom is the whole value of a top-level definition without parameters: def Name := axiom Statement;”axiom states an assumption only as the whole value of a definition, which names it. A family’s parameters belong to the statement, not to the definition: write def Name := axiom F; for a family F.axioms
E568“f has two parameters named x: give each its own name.”A definition's parameters, implicit or not, and a declared type's, have distinct names, since a call can give each one by its name. A constructor's arguments do too (E569). Rename one.implicit parameters

Types and terms

CodeMessageMeaning and fixExample
E606“Type mismatch: found A, expected B.”A term of type A is used where a B is needed, and the two are not equal by computation. The message shows both types in Cubist syntax, with definitions under their source names and redexes reduced; when the whole declaration is compared, both are its full statement. Check argument order, universes and endpoints. From rfl, it means the two sides are only equal propositionally: use a lemma, rw or simp.exact, conversion
E352“Source application is not a function.”Something that is not a function is applied.currying
E382“f takes n arguments; this is one more.”The call gives more arguments than the function takes. Remove the extra ones, or apply the result separately if it is itself a function.parameters
E388“Nothing determines the parameter x of f, of type T: …”A hole _, or a parameter left out before a named argument, is not fixed by the other arguments' types or by the type expected of the call. Holes are never filled by searching for a term of their type. Write the argument.holes
E392“The parameter x of f is not determined: U0 fits, and so would a larger universe. …”The hole is a type that cumulativity leaves open: a type in U0 is in every larger universe too. A bound from the expected type that agrees settles it; otherwise write the type: by position, in double braces for an implicit parameter, as same{{_, U0}}(T), or by name.holes
E391“Nothing determines the universe U of f: …”A universe hole that no argument's type bounds, where the call's type depends on it. Write the universe: by position, in double braces for an implicit one, as f{{U0}}(…) or f{{U := U0}}(…), or by name in parentheses for an explicit one.universe arguments
E385“A hole _ stands for an argument of a call, …”A hole is an argument of a call to a definition or a function, which the call determines. Anywhere else, such as a whole proof, write the term.holes
E346“Untyped lambda requires an expected function type.”Give the binder a type, or put the function where a function type is expected.functions
E350 E414 E415“Pair requires an expected type.”, “Sum injection requires an expected type.”, “absurd requires an expected type.”The form needs its type from context. Supply it with a stated result type, let name : T or typed(T, term).expected types
E351“Expected a Sigma type for pair.”A pair is checked against a type that is not a pair type, or a tuple does not match the nesting of its type.tuples
E349“Projection .1 requires a dependent pair; found a value of type T.”Only a pair has projections. The message shows the type of the projected value.using pairs
E356“unpack requires a dependent pair.”Only pairs can be unpacked.using pairs
E912“x + y means what a selected notation binds + to: for natural numbers, use nat; or write nat.(x + y).”An operator means only what the selected notation binds, and nothing is selected here: a function named add in scope gives + no meaning. After import unat;, write use unat; at the top of the file, or unat.(2 + 3) for one expression. -, / and ^ name the integers instead (E399).numbers

Proof blocks

CodeMessageMeaning and fixExample
E358“Proof block has no conclusion.”The block ends without closing its goal. Add a closing statement; after ext, the new goal still needs one.statements, changing the goal
E444“Statements after exact are unreachable.”Nothing may follow a closing statement. Prove intermediate claims with let before closing.statements
E458“intro requires a dependent function goal.”The goal is not a function type, or all its inputs are already introduced.intro
E466“obtain requires a dependent pair matching its pattern.”The value is not a pair, or the pattern’s nesting differs from its type’s.obtain

Computation and conversion

CodeMessageMeaning and fixExample
E337“No checked definition to unfold: name”Hints name top-level checked definitions only.unfolding hints
K344“Native prototype syntax depth exceeds 512.”The kernel builds no term more than 512 nodes deep, and a computation that would build one stops. A unary numeral of 512 or more is that deep. Compute less of the term, as an evaluation's pattern that does not observe the deep part, or use binary numbers.evaluate

Universes

CodeMessageMeaning and fixExample
E342“Universe was removed: bind a universe variable as U < UU0.”Write U < UU0 where the source had U : Universe.universe variables
E321“A universe variable's bound must be UU0, as in U < UU0.”Only UU0 bounds a universe variable.UU0
E175“name is reserved…; pick another name.”Keywords such as fun and let, the built-in types Unit and Void, Unit's element tt, and generated interface names such as map and model, cannot be bound. The message identifies generated interface names and points to docs/guides/keywords.md.Reserved names
E518“A universe argument must lie below UU0: …”A generic declaration was used at UU0 or above. Use U0, U1, … or a universe variable.UU0
E322“Expected a universe: U0, UU0, a universe variable, next(E) or max(E, F).”A type or a term stands where a universe is required, such as next(UNat).next and max
E111“name is a universe constant; pick another name.”Names such as U1 and UU2 are universes.UU0

Equality and paths

CodeMessageMeaning and fixExample
E429“Path endpoints do not match.”In trans(p, q), p must end where q starts.operations
E417“cong requires a path.”The second argument must be a path.operations
E421“Transport endpoints do not match.”The stated endpoints must be the path’s, in order. Transport backwards along sym(p).transport
E420“transport requires a path.”The fourth argument must be a path.transport
E422“Path induction endpoints/carrier do not match.”The type and endpoints passed to path_induction must be the path’s.path induction
E423“Based induction needs universes.”The first two arguments of based_induction are universes.path induction
E366“hlevel could not prove goal”The message names each obligation the goal needs, down to the first that nothing discharges, and why. Supply that evidence as a hypothesis or with hlevel with [h];. Some goals are false: UNat is not a proposition.hlevel

Inductive types and recursion

CodeMessageMeaning and fixExample
E561“The match has no case for c(…) in value.”No clause fits that constructor of the value, here or nested inside another pattern. Add a clause for it, or a variable or _ that covers it.patterns
E559“This clause is never reached: the clauses before it take every case it would.”Clauses are tried in order, and earlier ones, a variable or _ among them, already take every case this one fits. Move it before them, or remove it.patterns
E567“The match on a sum needs a clause for right: right(a) => { … }.”A match on A or B has a clause for each side, left(a) and right(b). Add the missing one.taking a sum apart
E519“nil needs an expected type, to know which List(…) it builds: write typed(List(…), nil).”A constructor of a parameterized type takes only its declared arguments, so the type’s arguments come from context. Give a result type, or use typed.parameters
E528“UNat has no constructor left: its constructors are zero, succ.”A match clause names a constructor that the matched type does not have, such as a sum’s left on UNat. Use the listed constructors.match
E557“c takes n constructor fields in parentheses; name its induction hypotheses after with, or omit with.”An induction clause must name exactly the constructor’s fields inside parentheses. Its optional with list names one hypothesis per recursive field.induction
E547“loop is being defined: it can call itself only on an argument of a constructor”A definition calls itself, but its whole body is not a match on one of its parameters. Make it one, and recurse on a child bound by a clause.order, structural recursion
E552“The recursive call of f is not on an argument of the matched constructor: only structural recursion, …”A recursive call passes something other than a child bound by the clause, such as the original input or a new constructor value. Recurse on a child.structural recursion

Equational reasoning and simplification

CodeMessageMeaning and fixExample
E446“rfl requires a homogeneous equality goal.”The goal is not an equality.rfl
E450“calc step left endpoint does not match the preceding endpoint.”Adjacent steps must share an endpoint; the message shows both. Write _ for the previous right side.calc
E451“calc final endpoint does not match the goal.”The chain must end at the goal’s right side; the message shows where it ends and what the goal needs.calc
E448“calc requires a homogeneous equality goal.”The goal is not an equality.calc
E442“Rewrite occurrence n was not found (m eligible matches).”Fewer matches exist than requested, or none: the rule must be instantiated at exactly the subterm that appears. Rewriting never looks under binders. The message shows the goal that was searched.rw
E452“rw left an unresolved equality goal; add a following proof statement.”The rewrite worked, but the new goal does not hold by computation. The message shows that goal and the rewrites that changed it. Add another statement.rw
E431“rw requires a homogeneous equality proof.”Instantiate the rule fully, as in unat_add_zero(n), or use simp only.rw
E441“Rewrite match occurs in an unsupported dependent position.”The only match is in a dependent argument. Use an explicit cong.rw
E360“rw requires a homogeneous equality goal.”The goal is a type, not an equality. simp rewrites types.rw
E436“A simplification rule parameter is not determined by the matched side; supply arguments.”Matching cannot fix every parameter. Pass the missing arguments.simplification
E456“simp only left an unresolved equality goal; add a following proof statement.”The simplified goal does not hold by computation. The message shows it, the sides that changed and the rules that fired, and may name a rule whose premise was not proved. Add a statement.simplification
E456“Rule name has an unproved premise at parameter n; …”A conditional rule could not fire. Supply a local proof with simp with [h].conditional rules
E367“Simplification cycle detected in the selected rules.”A rule rewrites its output back into its input, as commutativity does. The message names the rules that brought the goal back. Instantiate them at specific arguments.traversal
E369“… budget exceeded.”Rewriting, matching or term size hit a fixed bound; the message shows the goal where the search stopped. Narrow the rules with simp only, or split the proof.traversal
E454“simp at requires a local hypothesis: name.”simp … at h simplifies a hypothesis in the context, not a library lemma.rule selection
E453“A simplified hypothesis copy must be followed by a proof statement.”simp … at h as h2 leaves the goal open. Use h2 in a following statement.rule selection
E331“Simplification premise witness must be local: name.”with [h] lists hypotheses from the context.conditional rules

A search, or a declaration, that uses up its fuel fails with “search ran out of search fuel: n kind.”, naming what ran out: subterm visits, candidate rules tried, rewrites, premise searches, term nodes walked or kernel queries. A search’s message also shows the goal where it stopped. The defaults are well above what the checked proofs need, so such a failure usually means a rule set that keeps rewriting. The kernel’s own step limit per operation and a checker’s time limit fail differently: “Kernel checking/reduction budget exhausted.” and “Declaration time limit exceeded.”

Theories and models

CodeMessageMeaning and fixExample
E803“T has two fields named f: give each its own name.”A model's fields are read by name, so a theory's fields, its own and its parents', have distinct names. Rename one.theories
E828“T gets the carrier M from P and Q with different kinds or indices: rename one, as in Q(M := …).”Two parents give a carrier of one name, merged into one carrier of the child only when both are sets, or both propositions, of one type. Rename it in one parent to keep them apart.extension
E817“T's models have no homomorphisms: …”A homomorphism preserves each operation, pushing each argument that holds a carrier forward and pulling one with a carrier left of an arrow back. An argument with a carrier on both sides of an arrow, a carrier with no h-level, and a few other forms leave a theory without homomorphisms; the message names which.homomorphisms
E834“use selects a model of a theory, such as m : Group(U0); this is a value of type A.”use puts a model's fields and notation in scope; the value given is not a model of a theory.use
E856“The law l is not an equation between operation terms: the equational strategy does not support this law.”initial and free present a theory by its operations and laws, each law a path constructor; the current equational strategy does not support a law that is a truncation or another proposition. This refusal does not establish nonexistence of an initial model.initial models
E881“The equational strategy does not yet generate folds for T's implemented inherited members.”The current initial/free strategy cannot generate fold preservation proofs for operations or laws supplied by checked inherited definitions. Models and parent projections remain available.initial models

Cubical paths and higher inductive types

CodeMessageMeaning and fixExample
E341“Interval coordinates can only be used in interval arguments.”A coordinate is not a term. Use it only in @, flip, meet, join and faces.the interval
E338“path i => ... needs an expected Path or PathP type.”Use the shorthand where a path type is expected, or write path(family, body).shorthand
E463“lift needs an expected Path or PathP type; annotate the result type.”lift needs a declared path type to determine its endpoints.dependent paths
E461“ext requires equality of functions.”The goal is not an equality of functions.ext
E604“Composition tube disagrees with its base.”A wall does not start on the base. Check each wall at the base coordinate.composition
E470“glue needs the Glue type it builds an element of: write typed(Glue(…), glue(…)).”A glue term is checked at a Glue type: give it one with typed, or use it where one is expected.Glue types
E472“unglue takes an element of a Glue type.”The argument of unglue is not of a Glue type.Glue types
E530“c is a point constructor: give its computational clause in match, before obligations.”Point constructors define how the match computes and belong in the main braces before obligations; only path and squash clauses go in obligations.obligations
E531“match on T needs a clause for c. Give path clauses in obligations { … }, or obligations by { … }.”Every constructor needs a clause. Add the missing point clause to the match, or give or prove the missing path clause in obligations.obligations
E532“obligations by a term or proof block needs exactly one missing declared path clause; found n. Use named obligations { … } for separate clauses.”A single proof block or term after obligations by does not name which path constructor it proves, so it works only when exactly one declared path constructor is omitted. Write separate clauses in obligations { … }.obligations
E546“Cannot generate c: B must be a proposition; …. Give checked h-level evidence, or an explicit obligation.”A generated T.squash clause, or a declared path clause left to obligations by hlevel, needs h-level evidence that the search could not find. The message names the type and level of the subgoal that failed: the result family itself, a part of it that the structural rules reached (such as the carrier of an equality in it, at one level higher), or a premise of a registered rule or of quantified evidence that the search tried. Supply a proof of the level as a hypothesis, pass a hint with obligations by hlevel with [h], or write the clause explicitly.obligations

Interval and face formulas beyond 4,096 clauses fail with a lattice budget error. Split such a proof into named steps.

Excluded middle, choice and computability

CodeMessageMeaning and fixExample
E403“Too many arguments to name.”ua or UnivalenceBeta got more arguments than its type allows.univalence
E330“This computable declaration depends on non-computing assumptions: …”The declaration uses an assumption, directly or through a definition. The message names the chain. Replace that step, or drop computable.computable
E324“The evaluated term depends on non-computing assumptions: …”evaluate accepts only terms that use no assumption.evaluate
E326 E477“The term evaluates to a, not b.”, “The term evaluates to a, which does not match p: c is not q.”The normal forms differ; the message shows both. Against a pattern, it names the first part of the value that does not match, and the part of the pattern it fails; the value is shown as far as the pattern computed it, <unevaluated> marking a part it did not.evaluate
E485“evaluate e expecting _; would compute nothing: …”A bare hole matches anything and computes nothing, so it would state only the term's type. Write !_ to check that the term has a weak head, !!_ that it has a normal form, or !!!_ that it has a full normal form.evaluate
E486“A !!! inside a !! part asks for a full normal form, which the !! part's normal form does not hold: …”A !! part is matched against its normal form, in which a stuck definition stays folded, so a !!! inside it cannot be honored. Write !!! on the outer part instead.evaluate

Warnings

A warning does not reject anything: the declaration is checked. It marks a binding that is never used and can be removed, or an evaluation's demand mark that asks for nothing more; see warnings.

CodeMessageMeaning and fixExample
W703“k is unused: the return type does not mention it and the successor clause does not use it. …”The result type is the same for every number, and the successor branch does not use the predecessor. Omit as k.induction
W704“z is unused: the return type does not mention it. …”The result type is the same for every value. Omit as z.match
W705“x is unused in the body: write A -> … instead of forall x : A. ….”The quantified variable is never mentioned. Write A -> B for forall x : A. B, and A and B for exists x : A. B; they are the same types.exists and and
W702“name is never used after this let: remove it.”Nothing later in the block uses the name. Remove the statement.let
W708 W709 W710“The mark before p asks for nothing more: …”An evaluation's demand mark computes no more than its part already does: a pair, an injection, a constructor or an expression computes the part's weak head, an expression its normal form, everything under !! is normalized and everything under !!! fully normalized. Remove the mark.evaluate

Not yet available

These are planned; see the work plan. Until then, they are rejected:

def unfinished : UNat {
  sorry;  // Error: Expected a proof statement; found 'sorry'.
}
import unat;

def hole : UNat {
  exact _;  // Error: A hole _ stands for an argument of a call, which the call's other arguments or the type expected of it determine; anywhere else, write the term.
}
import unat;

def mixed(a, b : UNat, h : a = b) : a <= b {
  calc {
    a = b by h;
    _ <= b by tt;  // Error: Expected '=', found '<='.
  }
}
  • sorry;
  • _ holes anywhere but a call's arguments;
  • chains of relations other than equality in calc;
  • rewriting a hypothesis together with everything that depends on it: simp at makes a new copy instead;
  • solving premises of conditional rules that are not equalities;
  • inductive families with indices, and mutually defined inductive types; see parameters and constructors.

Every code

Each error and warning the checker can report has a code. E codes come from the parser and the elaborator, which turn source into kernel terms; K codes are refusals by the C kernel, which checks those terms; W codes are warnings. This index lists every code with its message, where … stands for the part that varies. A code explained in the sections above links to its explanation. Many K messages guard the kernel against malformed terms, and a term the elaborator builds does not reach them.

Reading the source

CodeMessage
E101Print width must be an integer between 40 and 240.
E102linearizeTuples must be Boolean.
E103Formatting changed source tokens.
E104Formatting changed the expanded syntax tree.
E105No folded notation for … (retired)
E106Unexpected character …
E107Source has too many tokens.
E108Expected '…', found '…'.
E109Write := to give a value: …
E110Expected a name.
E111… is a universe constant; pick another name.
E112Expected ':' or '<', found '…', as in ….
E113A constructor's arguments are terms; bind universes in the declaration's header.
E114trunc takes an integer level n ≥ -1, as in trunc(1).
E115trunc(n) needs n ≥ -1: prop is trunc(-1), set is trunc(0).
E116After ':' give an h-level, a universe or both, as in : prop U.
E117Separate names with commas: …
E118Expanded tuple nesting exceeds 128.
E119Expression nesting exceeds 128.
E120A pair has only the projections .1 and .2. A tuple nests pairs to the right: the third component of (a, b, c) is .2.2.
E121Binary literals are limited to 256 significant bits.
E122Unary numerals are limited to 256. Import nat and use nat for binary naturals.
E123Expected an expression, found '…'.
E124Give the motive after as: match v as z return T { … }.
E125Expected '}' to close the match.
E126Separate binder groups with commas: fun (a : A, b : B) => …
E127Only forall and fun bind a universe variable: exists has no level form.
E128End …'s type with a dot: … n : Nat. P(n)
E129Write a space after the . that ends …'s type: … n : Nat. P(n)
E130Pattern nesting exceeds 128.
E131A pair pattern needs at least two components.
E132obligations by supports hlevel (with optional hints), rfl, a proof block, or a whole clause term; put simp or simpa inside a proof block.
E133Expected '}' to close obligations.
E134Block nesting exceeds 128.
E135Separate names with commas: intro m, n;
E136have was removed: write let name : T := term; or prove the claim in a block, let name : T { … }.
E137show was removed: prove the restated goal in a block, let h : T { … }, then exact h;.
E138suffices was removed: prove the claim first, let h : T { … }, then prove the goal from h.
E139Expected a proof statement; found '…'.
E140Use obtain to unpack a pair.
E141rw requires a path.
E142rw target must be lhs or rhs.
E143rw occurrence must be a positive integer.
E144simp only requires an explicit rule list.
E145simp only cannot exclude rules.
E146The … statement takes apart one value; … the first, then the next inside each clause. (retired)
E147The … statement takes its motive from the goal: write … v { c(xs) => { … } … } without as or return.
E148A clause of the … statement is a proof block: c(xs) => { … }.
E149simp_rule priority must be an integer from 0 to 1000.
E150Expected '}' to close the inductive declaration.
E151Imports must come before declarations.
E152Expected a declaration or directive: def, computable def, inductive, evaluate, print, simp_rule, simp_set, hlevel_rule, theory, initial or free.
E153Write := to give a value: def name : T := term; here `=` read as an equality type
E154Cannot locate a right-hand pair's enclosing parentheses.
E155Tuple linearization changed the expanded syntax tree.
E156Give the motive after as: induction v as z return T { … }.
E157Expected '}' to close the induction.
E158Expected '}' to close the ….
E159print shows evaluate(term), typeof(term), inspect(term) or witness(term).
E162A match on several values takes its motive from return T or the type expected of it, without as.
E163The induction statement takes apart one value; take the first, then the next inside each clause.
E164cases was removed: write match value { left(a) => { … } right(b) => { … } }.
E165Close double braces with }}, two braces together.
E166Implicit parameters are in double braces: def f{{U < UU0, A : U}}(…).
E167A notation is a binary operator: x + y, x * y, x < y or x <= y. (retired)
E168Expected '}' to close the theory.
E169A sort is a set or a proposition: sort M : set; or sort P : prop; (retired)
E170Expected ':' and the type of …, as in …
E171Sections do not nest: close this one with } first.
E172A section gives its definitions parameters: section (G : Group(U0)) { … }.
E173Expected '}' to close the section.
E174A section holds definitions: def and computable def.
E175… is reserved…; pick another name.
E176Reversal is written ~: ~p reverses a path and ~i a coordinate. Prefix - is kept for arithmetic. (retired)
E177… binds … universes; a theory binds one, the universe of its carriers. (retired)
E178… is not the universe of …'s carriers: name it in the header, as in theory …(… < UU0).
E179A theory's header binds the universe of its carriers, as in theory …(U < UU0). (retired)
E180A carrier is a field: write … : set U; or … : prop U;, with the universe named in the header, theory …(U < UU0).
E181A theory's universes are below UU0: … < UU0.
E182Expected ':' and the type of …, as in (x, y : M) or (A : set U).
E183open is now use: write use m; to select a model's fields and notation.
E184Expected '}' to close the notation.
E185A notation's rule binds a binary operator: x + y, x * y, x < y or x <= y. (retired)
E186A rule's pattern names its two operands apart, as x … y. (retired)
E187… binds … twice: a notation has one rule for each operator.
E188x … y is y … x: a notation binds < and <=, and > and >= follow them.
E189A notation binds an operator: x + y, x - y, x * y, x / y, x ^ y, x < y, x <= y, or -x.
E190A pattern names its two operands apart, as x … y.
E191… reads literals once: a notation has a numeral rule or a literal rule, not both.
E192hlevel_rule priority must be an integer from 0 to 1000.
E193A wall's face is a formula of equations i = 0 and i = 1, with and and or, as on i = 0 or j = 1 => ….
E194Expected '}' to close the box.
E195Cannot locate historical transport operands.
E196Historical over migration requires a single exact expression.
E197Induction hypotheses after with are only available in induction clauses.
E198An induction clause takes one constructor pattern.
E199An anonymous universe has no name: name the header universe to refer to it here.

Reading the source (continued)

CodeMessage
E001Invalid test pragma: …
E002Historical unary migration would capture existing binding ….
E003Two demand marks in a row, … …, ask for one demand: write !, !! or !!! as one mark.
E004The demand mark … stands right after evaluate, or at the start of a part of an expected pattern, as in evaluate e expecting (!_, _);.
E005A qualified name names one module: module::name.
E006A qualified name is a module's name, ::, and a name, with no space between: unat::zero.
E007… names a module's declaration; a name declared or bound here is plain.
E008An axiom is the whole value of a top-level definition without parameters: def Name := axiom Statement;

Files, modules and tools

CodeMessage
E201Could not load …: HTTP …
E202The declaration limit must be a positive number of milliseconds.
E203No benchmark report yet. Run npm run benchmark:cubical. (retired)
E204Syntax display limit
E205Expected a level, not ….
E206Unsupported cubical notation: …
E207The representation option was removed with the differential fixtures: Nat, W and pushouts are source declarations.
E208H1 is no longer experimental: declared types are on by default, so drop the experimental option.
E209Cyclic source import: …
E210Source was not discovered: …
E211No checked native definition for this name.
E212Unsupported cubical transfer format.
E213Missing source module ….
E214Native source is not available at ….
E215Check a proof first.
E216Unsupported cubical command.
E217Unknown mathematical display node: …
E218Unknown module place: ….
E219Invalid module name: ….
E220No module named … in …….
E221Unable to load source:
E222The checking worker stopped making progress. Reload the page to restart the kernel.
E223Recheck the current source before replacing this simplification.
E224Allow a new tab to open the kernel workbench.
E225Source exceeds 1 MB.
E226Unable to load the checking worker. (retired)
E227Unable to load the checking worker. Build with make wasm.
E228This expression transfer is no longer available. Open it again from the proof inspector.
E229check requires a module or .cubist file.
E230Check a source first.
E231Ambiguous name; use a qualified binding: …
E232Inspect a checked name first.
E233Expected expression or type.
E234export requires a filename.
E235Unknown command …. Type help.
E236… is a command of the console, not of an entry.
E237Unknown command …. /help lists the commands.
E238This session cannot list its modules.
E239Module … was not loaded.
E240… did not check.
E241Could not load the file index: HTTP …
E242The prelude option was removed: no module is imported automatically, so a module imports unat itself; bundledUNat controls unat's bundled source.
E243The benchmark area is library, archive or tests, not ….
E244No saved benchmark of the … yet. Run it in this browser, or run npm run benchmark:cubical -- --area=….
E245This binding is unavailable.
E246This contextual session is stale or closed. Select a context from the current check.
E247Check the current source with contextual scopes enabled.
E248The checking worker is unavailable. Reload the page to restart it.
E249The inspected context is unavailable. Check the source and inspect the occurrence again.
E250Test pragmas require explicit test mode.
E251Unknown workbench state.
E252Unsupported workbench operation.
E253… names a declaration of …, which is not imported here: import …;
E254… declares no …, so … names nothing.
E255… is declared below its use: a declaration uses only the declarations above it.
E256…::… and …::… would be one identity, …: rename one of them.
E257The transfer did not replay completely: …
E258The kernel failed again in the checking worker that replaced a failed one, so no other starts on its own: check the source to start one.

Terms

CodeMessage
E301Expected cubical syntax.
E302Expected a dimension binder.
E303Cubical prototype supports 64 simultaneously live dimensions.
E304Internal elaboration error: … is already bound.
E305At most 64 simultaneous cubical dimensions are supported.
E306Unglue extension requires an explicit Glue type. (retired)
E307Unglue equivalence requires an explicit Glue type. (retired)
E308Cubical lattice term-size budget exceeded.
E309Expected a lattice DNF.
E310Malformed lattice generator.
E311Invalid dimension name.
E312Expected endpoint 0 or 1.
E313Supply the checked generic native-equivalence round-trip lemma.
E314Supply the checked generic native univalence inverse laws. (retired)
E315Cubical syntax construction term-size budget exceeded.
E316Simplification term-size budget exceeded.
E317Malformed universe constant: ….
E318A translator needs a checker: the elaborator over a kernel.
E319Expected an interval coordinate: 0, 1, a coordinate name, ~i, i & j or i | j (or flip, meet, join).
E320Expected a face formula: on(i, 0 or 1), and/or, 0 or 1.
E321A universe variable's bound must be UU0, as in U < UU0.
E322Expected a universe: U0, UU0, a universe variable, next(E) or max(E, F).
E323Expected fun (i : Interval) => ... in a cubical binder.
E324The evaluated term
E325The evaluated term has type …, but the expected value has type ….
E326The term evaluates to …, not ….
E327Simplification rule … is already registered in this module.
E328Simplification set … is already declared in this module.
E329Native cubical check rejected: …
E330This computable declaration
E331Simplification premise witness must be local: ….
E332sym requires a path.
E333p ++ q concatenates paths; found no path.
E334trans requires paths.
E335Numerals and induction require an imported UNat with zero and succ constructors. For binary Nat, use nat_peano.
E336Missing source expression.
E337No checked definition to unfold: …
E338path i => ... needs an expected Path or PathP type.
E339transport requires a homogeneous base path.
E340Untranslated dependency: …
E341Interval coordinates can only be used in interval arguments.
E342Universe was removed: bind a universe variable as U < UU0.
E343Untranslated name: …
E344Too many lambda binders for the expected type.
E345A universe lambda needs a universe-generic type: forall U < UU0. …
E346Untyped lambda requires an expected function type.
E347… combines interval coordinates, as in p @ i … j; it is not an operation on terms.
E348Untranslated operator: …
E349Projection .… requires a dependent pair; found a value of type ….
E350Pair requires an expected type.
E351Expected a Sigma type for pair.
E352Source application is not a function.
E353match requires a value of a declared type, or of a sum.
E354match requires a sum type.
E355A match on a sum has a return type and the clauses left x => …; right y => ….
E356unpack requires a dependent pair.
E357Untranslated syntax: …
E358Proof block has no conclusion.
E359Proof tactic not yet translated: …
E360rw requires a homogeneous equality goal.
E361hlevel uses the library module hlevels: add import hlevels;
E362hlevel does not use quantified hints yet: apply … to its arguments. (retired)
E363The hint … has type …, which states no h-level.
E364hlevel proves IsContr, IsProp, IsSet or HasLevel, or an equality in a proposition; the goal is ….
E365hlevel needs the type of the equality's sides to be in a universe.
E366hlevel could not prove ……; ….
E367Simplification cycle detected in the selected rules. … returned the goal to where it was … rewrite… earlier.
E368General simplification requires a type-valued goal.
E369Simplification rewrite budget exceeded.
E370simp only requires a homogeneous equality goal.
E371induction requires a value of a declared type.
E372… stands for a universe that the printer could not show: write the universe in its place, such as U0 or a universe variable.
E373~p reverses a path; found no path.
E374… has no named parameters: a named argument gives a parameter that a definition declares.
E375… has no parameter …; its parameters are ….
E376… has two parameters named …: give them by position. (retired)
E377The argument … is given twice.
E378… takes its arguments explicitly: a hole _ or a named argument is an argument of a definition or a function.
E379… is a declared type or a constructor, whose arguments are written out: a hole _ or a named argument is an argument of a definition or a function.
E380A recursive call of … takes its arguments explicitly.
E381Give the universe … of … explicitly: a universe argument is not inferred. (retired)
E382… takes … argument…; this is one more.
E383The hole for … of … was solved as …, which does not have its type ….
E385A hole _ stands for an argument of a call, which the call's other arguments or the type expected of it determine; anywhere else, write the term.
E386The argument … of … needs the type of its …, …, which mentions a hole nothing determines…. Give the hole explicitly.
E387The … of … is not determined: … fits, and so would a larger universe…. Give it explicitly. (retired)
E388Nothing determines the … of …, of type …: not the other arguments' types, nor the type expected of the call…. Give it explicitly.
E389The … of … would be …, which mentions a variable bound inside an argument, out of its scope…. Give it explicitly.
E390The universe … of … would be …, which is not below UU0. Give it explicitly.
E391Nothing determines the universe … of …: no argument's type bounds it, and the call's type depends on it. Give it explicitly.
E392The … of … is not determined: … fits, and so would … universe…. Give it explicitly.
E393… takes … argument… by position; give its implicit parameters … in double braces, in order or by name, as …{{…}}(…) or …{{… := …}}(…).
E394… is a theory: its models are ….Model(U), built with ….make(…). (retired)
E395A definition in a section has the section's implicit parameters, not its own: add them to the section's {{…}}.
E396….Model is now …: a theory's name is the type of its models, as in …(U0).
E397… is not in …'s notation, which is selected here: select a notation that binds it, as nat.(x … y), or write the operation.
E398….(…) is an operation when its rule applies one to its operands, as x … y := f(x, y).
E399x … y means what a selected notation binds … to: select one, as integers.(x … y).

Proof statements, rewriting and simplification

CodeMessage
E401Univalence requires a universe.
E402… takes a universe below UU0.
E403Too many arguments to ….
E404… needs a universe argument. (retired)
E405… with a truncation former needs a universe argument. (retired)
E406Logical assumptions require a universe and an explicit native context. (retired)
E407… holds only for universes below UU0. (retired)
E408Invalid arguments to ….
E409A composition wall has syntax face(i, 0 or 1, fun (j : Interval) => ...).
E410A composition face needs an outer interval coordinate and endpoint 0 or 1.
E411pair_induction requires a dependent pair.
E412FunExt needs a universe.
E413FunExt takes a universe below UU0.
E414absurd requires an expected type.
E415Sum injection requires an expected type.
E416Expected a sum type.
E417cong requires a path.
E418Dependent action needs a function and a path with the supplied endpoints.
E419apd_path needs a dependent function and a homogeneous path.
E420transport requires a path.
E421Transport endpoints do not match.
E422Path induction endpoints/carrier do not match.
E423Based induction needs universes.
E424A scrutinee depends on a hypothesis about another scrutinee; eliminate that hypothesis too.
E425Internal elaboration error: a motive instance needs one value per scrutinee.
E426Internal elaboration error: unknown plan step ….
E427Internal elaboration error: a … step has no forward direction.
E428Expected homogeneous equality paths for composition.
E429Path endpoints do not match.
E430A general goal rewrite requires a checked path of types.
E431rw requires a homogeneous equality proof.
E432Simplification rule has too many parameters.
E433simp only requires homogeneous equality lemmas.
E434A universe-generic rule is matched only where its universe is a bare variable; supply its universe argument, as in lemma(U0).
E435A universe-generic rule's universe is not determined by the matched side; supply it, as in lemma(U0).
E436A simplification rule parameter is not determined by the matched side; supply arguments.
E437Simplification rule lost a parameter.
E438Invalid rewrite occurrence.
E439Rewrite traversal budget exceeded.
E440Rewrite candidate budget exceeded.
E441Rewrite match occurs in an unsupported dependent position.
E442Rewrite occurrence … was not found (… eligible matches).
E443Simplification set … is ambiguous: ….
E444Statements after exact are unreachable.
E445Statements after rfl are unreachable.
E446rfl requires a homogeneous equality goal.
E447Statements after calc are unreachable.
E448calc requires a homogeneous equality goal.
E449calc requires at least one step.
E450calc step left endpoint does not match the preceding endpoint. The step starts at …; the chain so far ends at ….
E451calc final endpoint does not match the goal. The chain ends at …; the goal's right side is ….
E452rw left an unresolved equality goal; add a following proof statement.…
E453A simplified hypothesis copy must be followed by a proof statement.
E454simp at requires a local hypothesis: ….
E455simp left a type goal; add a following proof statement.…
E456simp only left an unresolved equality goal; add a following proof statement.……
E457Statements after simpa are unreachable.
E458intro requires a dependent function goal.
E459Statements after hlevel are unreachable.
E460ext requires equality of functions with a fixed type.
E461ext requires equality of functions.
E462Statements after over are unreachable. (retired)
E463lift needs an expected Path or PathP type; annotate the result type.
E464lift requires a homogeneous base path.
E465let states a type after the colon; found a value of type ….
E466obtain requires a dependent pair matching its pattern.
E467Statements after … are unreachable: each clause's block closes the goal.
E468Statements after cases are not yet translated. (retired)
E469cases requires a sum type. (retired)
E470glue needs the Glue type it builds an element of: write typed(Glue(…), glue(…)).
E471glue builds an element of a Glue type.
E472unglue takes an element of a Glue type.
E473A face needs an interval coordinate and endpoint 0 or 1.
E474A Glue piece has syntax face(i, 0 or 1, T, e) or face_when(φ, T, e).
E475A glue value has syntax face(i, 0 or 1, t) or face_when(φ, t).
E476open takes a model of a theory, such as m : Group(U0); this is a value of type …. (retired)
E477The term evaluates to …, which does not match …: … is not ….
E478A hole in an expected value stands for a pair's component, an injection's value or a constructor's argument; … is none of these, so write it out.
E479witness reads a closed truncation, a value of a truncated declared type such as Trunc(U, A); this is a value of ….
E480The truncation evaluates to …, which holds no constructor to read a witness from.
E481The truncation's witness lies under a composition whose type changes: it is built in …, not ….
E482Path reversal requires a homogeneous path; use an explicit path abstraction for a dependent family.
E483The term evaluates to …, which does not match …: a part of type … is not ….
E484A demand mark, !, !! or !!!, starts a part of an expected value: the whole value, a pair's component, an injection's value or a constructor's argument; … is none of these.
E485evaluate e expecting _; would compute nothing: write !_ to compute the value's weak head, !!_ for its normal form, or !!!_ for its full normal form.
E486A !!! inside a !! part asks for a full normal form, which the !! part's normal form does not hold: write !!! on the outer part.
E487The runtime's evaluation of the value form exhausted its work budget of … steps.
E488The runtime's evaluation of the value form exhausted its allocation budget of … cells.
E489The runtime's evaluation of the value form exceeded its time limit.
E490The runtime failed to evaluate the value form: …
E491… is the archive's legacy builtin, accepted only in archive modules: elsewhere use the library's Trunc, from h1_truncation, and its axioms LEM and Choice, from classical_axioms. (retired)

Inductive types and matching

CodeMessage
E501trunc(n) is supported up to n = ….
E502A sort is type, set, prop or trunc(n) for an integer n ≥ -1.
E503The declared type … already exists.
E504A signature has too many parameters.
E505The path's fiber must live in a universe.
E506Declared types need the instruction kernel.
E507… uses the assumption …: a declared type's parameters and constructors cannot use assumptions, since its signature is closed.
E509… is already a constructor of ….
E510A constructor cannot be named …, as its type is.
E511… occurs in a negative position: …'s argument … takes an argument that mentions … or another argument of ….
E512…'s argument … mentions … but is not one: in H1 an argument is … itself, a function into it, or a path in it.
E513The type of … is not a type.
E514…'s argument … lives in a universe above …'s declared one: a declared type cannot lower its data (K2.5).
E515Inside its declaration, … is applied to its own parameters, …(…): another argument would be an index, which H1 does not admit.
E516… takes no arguments.
E517… takes … argument…: …(…).
E518A universe argument must lie below UU0: U0, U1, … or a universe variable.
E519… needs an expected type, to know which …(…) it builds:
E520apply it at a point where …(…) is expected, as in typed(…(…), …… @ i).
E521write typed(…(…), ……).
E522… builds …(…), but … is expected here.
E523Apply … to its … arguments: the kernel takes its data before its positions.
E524… takes … argument…; apply a path constructor at a coordinate with @.
E525Apply … to all its … arguments: the kernel takes its data before its positions.
E526… takes fewer arguments.
E527The declared type of the matched value is not in scope.
E528… has no constructor …: its constructors are ….
E529… has two clauses.
E530… is a point constructor: give its computational clause in …, before obligations.
E531… on … needs a clause for …. Give path clauses in obligations { … }, or obligations by { … }.
E532obligations by a term or proof block needs exactly one missing declared path clause; found …. Use named obligations { … } for separate clauses.
E533The motive mentions … itself: write it over the matched value, match … as z return … z …, so that recursive calls have their own types.
E534… needs its result's type: give return T, or use it where its type is known.
E535The … statement takes apart a value of a declared type; for a sum, use cases. (retired)
E536The … statement takes apart a value of a declared type.
E537The … statement takes apart a value of a declared type, and declared types (H1) are switched off in this kernel session.
E538… takes … argument… here, so its clause ….
E539Write the dimension… of … after @, as the point the clause covers: ….
E540… has no dimensions to name.
E541… is a path constructor: name its … dimension… after its arguments, as in ….
E542The clause type of … has fewer arguments than expected.
E543The clause type of … has fewer dimensions than expected.
E544Cannot generate …: import hlevels and supply h-level evidence for the motive, or give the clause explicitly.
E545The obligation … is not a path clause.
E546Cannot generate …: … must be …; …. Give checked h-level evidence, or an explicit obligation.
E547… is being defined: it can call itself only on an argument of a constructor that its match takes apart, as …(m) in succ(m) => …, when that match on one of its parameters is its whole body.
E548… takes … argument….
E549A recursive call of … changes …: the match needs its motive over its other parameters.
E550A recursive call of … passes … unchanged: the type of the matched … depends on it.
E551A recursive call of … passes the universe parameter … unchanged.
E552The recursive call of … is not on an argument of the matched constructor: only structural recursion, ….
E553… takes … argument… here, as an argument of the matched constructor.
E554… is a …-dimensional path of the matched type, not an element: call … on it at its dimensions, as …(……).
E555… is an element of the matched type, not a path: call …(…) without @.
E556Internal elaboration error: the recursive result of … takes fewer hypotheses.
E557… takes … constructor field… in parentheses; name its … induction … after with, or omit with.
E558This clause has … pattern…; the match takes apart … value….
E559This clause is never reached: the clauses before it take every case it would.
E560… is not of a declared type: its patterns are variables or _.
E561The match has no case for …… in ….
E562… is a path constructor: name its … dimension… after its arguments.
E563The induction statement takes apart a value of a declared type; for a sum, use match.
E564The … statement takes apart a value of a declared type, or of a sum.
E565A sum's clauses are left(a) => { … } and right(b) => { … }; found ….
E566A sum's clause names its side's value: …(a) => { … }.
E567The match on a sum needs a clause for …: …(a) => { … }.
E568… has two parameters named …: give each its own name.
E569… has two arguments named …: give each its own name.
E570… is bound twice in this clause: name each variable once.
E575… is no h-level rule: ….
E576… is already an h-level rule in this module.
E577Keep only the … constructor field… of … in parentheses; name induction hypotheses after with.
E578… has … recursive field…, so with names … induction …, not …; or omit with.
E579… has no recursive fields, so it has no induction hypotheses: remove with.
E580Binary naturals have bit constructors. Use nat_peano for zero/successor induction, or import unat for structural UNat.

Checking

CodeMessage
E601Unsupported library assumption: … (retired)
E602Only LEM and Choice have rebuilt truncation signatures. (retired)
E603Rebuilt LEM and Choice require an admitted proposition truncation. (retired)
E604Instruction kernel: …
E605An assumption needs a checked type.
E606Type mismatch: found …, expected ….
E607Invalid cubical dimension binding.
E608Cubical dimension indices must be distinct.
E609… is not in instruction mode yet.
E610Unbound variable ….
E611Composition tube disagrees with its base.
E612A Glue value's image disagrees with the base.
E613A constructor names an instance of a declared type.
E614The eliminator's motive is over another declared type.
E615A signature's former binds its universe parameters first.
E616A signature's former binds its parameters after its levels.
E617Could not allocate a symbol. (retired)
E618An instance takes each of its signature's parameters.
E619An instance gives each recorded universe parameter its level, and no other.
E620An erased universe parameter has no parameter to read it from.
E621Two pieces disagree where their faces meet.
E622No interval dimension is free for a binder.
E623The motive is a family over another type.
E624Expected …, found ….
E625Type mismatch.
E626The policy … ranked a move that is not open.
E627Unknown move ….
E628Invalid position.
E629Declaration time limit exceeded.
E630Unknown judgement ….
E631Unknown context entry ….
E632The cubical kernel module encodes syntax as ABI version …, but this code expects version …. Rebuild it with `make wasm`.
E633Could not allocate cubical kernel session.
E634Cubical kernel session is disposed.
E635This cubical kernel module has no work counters. Rebuild it with `make wasm`.
E636Unsupported cubical constructor: …
E637Cubical nodes have at most four children.
E638Normalize a term or type an instruction derived.
E639Unknown checked cubical definition.
E640Unknown cubical node handle.
E641Display simplification budget
E642Invalid reduction location.
E643This location does not support the selected reduction.
E644Unknown reduction operation.
E645Unknown reduction target.
E646No checked definition for ….
E647Invalid dimension literal.
E648Unbound cubical dimension: …
E649Unknown checked cubical definition: …
E650A constructor needs its number.
E651Unsupported cubical syntax: …
E652Unknown declared type: …
E653Invalid universe level: …
E654Invalid universe level constant.
E655Expected a universe level.
E656Expected a universe level, not ….
E657Invalid transport face descriptor.
E658Invalid cubical tube list.
E659Invalid cubical Glue system.
E660Invalid cubical Glue element system.
E661Unsupported cubical node: …
E662Declaration transaction was already finished.
E663A path is applied at an interval point; found a face formula.
E664A transport's face is a face formula; found an interval point.
E665A partial element's face is a face formula; found an interval point.
E666An axiom states a type, or a family of types: axiom T; or axiom F; where F(x) is a type.
E667This cubical kernel module has no handle generations. Rebuild it with `make wasm`.
E668The kernel's WebAssembly instance failed (…), and is not used again: nothing computed after the failure is kept.
E669A checked definition has no registered name.
E670No declared type is registered at signature ….
E671The driver made no context entry ….
E672A bound variable was derived outside its binder.
E673Too many entries.
E674A bound variable has no binder around it (index …).
E675The definition … is already registered with another value.

Arguments and their inference

CodeMessage
E701… has no implicit parameters: give its arguments in parentheses, as …(…).
E702… has … implicit parameter…, …; the double braces give ….
E703A recursive call of … passes its implicit parameters unchanged: give only the others, as …(…).
E704… is not an implicit parameter of …: give it in parentheses, as …(… := …).
E705… is an implicit parameter of …: give it in double braces, as …{{… := …}}(…).
E706Internal elaboration error: … of … mentions one of its unknowns.

Theories and models

CodeMessage
E801Renaming … to … would capture a variable named …; pick another name. (retired)
E802… gets a field named … from both … and …: rename one, as in …(… := …).
E803… has two fields named …: give each its own name.
E804… would stand for both … and … in …: a notation means one operation; rename one's notation.
E805… is not a theory here: … extends theories in scope.
E806… has two parents labelled …: label one, as in other : ….
E807… has no field …; its fields are ….
E808… is renamed twice.
E809A notation names an operation's two arguments; … is not an operation of two.
E810A notation names an operation's two arguments, as in mul(x, y : M) : M notation x * y; … has ….
E811The notation of … writes its arguments in order: … … ….
E812A field's name is a plain name; … is not. (retired)
E813… has no fields: a theory declares sorts, operations and laws.
E814The sorts of … need …, from hlevels: import hlevels;
E815… is a model of …, which has no field …: it has …….
E816This is a model of …, which has no field …: it has …….
E817…'s models have no homomorphisms: ….
E818The law … must state a proposition: an equation between elements of a sort, Void, a type declared at prop, or forall, -> or and over those; …. A law holds no data, and homomorphisms ignore laws: declare data as an operation or a constant.
E819…'s header binds … twice: give each its own name.
E820… extends …, whose header binds the universe …: bind … in …'s header too.
E821… extends …, whose header has the parameter …: give … the parameter … with the same type.
E822…'s header binds …, which names a field too: give each its own name.
E823…'s argument … is a … with its evidence: give an index bound as one, (A : … U), or write its evidence after it, …(…, A, A_is_…, …).
E824A notation names a family's two indices in order, as in le(x, y : M) : prop U notation x <= y.
E825…'s models have homomorphisms but no isomorphisms: ….
E826… would stand for … in …, and its parents bind it to …: a notation means one operation; rename one's notation.
E827… gets … from …, a carrier in one and not in another: rename one, as in …(… := …).
E828… gets the carrier … from … with different kinds or indices: rename one, as in …(… := …).
E829…, …'s parent …, has no field ….
E830… is ambiguous in …: …. Write …, or rename one in extends.
E831… is ambiguous in …: it is …. Write …, or give one another notation in extends.
E832… is ambiguous in …: it is …. Write ….
E833…, …'s parent …, binds no operation to …. (retired)
E834use selects a model of a theory, such as m : Group(U0); this is a value of type ….
E835….(…) takes a model of a theory; … is not one.
E836… binds no operation to ….
E837… binds no rule to ….
E838The notation of … reads … in the notation selected where it is used, which is …'s; … is no carrier's element: name the notation it is read in, as ….
E839-x names an operation's one argument; … is not an operation of one.
E840-x names an operation's one argument, as in neg(x : M) : M notation -x.
E842… is declared in another module: only the module that declares a model adds rules to its notation.
E843A model's notation is its theory's; …'s adds only a numeral or a literal rule.
E844A literal rule reads a Lexeme: import lexemes, which defines ….
E845… is recursive, and a field's type cannot unfold it: state the law over a model, outside the theory.
E846notation numeral reads a plain numeral: it marks a derived operation of one natural number, as def of_nat(n : BNat) : R := … notation numeral.
E847A numeral rule reads a … natural number: import ….
E848…'s label would be …, which is reserved: label it, as in other : ….
E850… takes a theory at its universes and parameters, as …; … is none.
E851… takes … argument…, its universes and parameters; this gives ….
E852The equational strategy supports one carrier that is not a family; … has ….
E853…'s carrier … is neither a set nor a proposition: the equational strategy requires a truncated carrier.
E854… takes … with a type depending on the carrier …: the equational strategy supports carrier arguments or types independent of the carrier.
E855… does not return the carrier …: the equational strategy supports carrier-valued operations.
E856The law … is not an equation between operation terms: the equational strategy does not support this law.
E859…'s parent … is labelled …, which names a field of … too: label it apart, as in base : ….
E860…'s pattern binds …, which an argument here names: rename it in …. (retired)
E862… is bound here, which hides the declaration …: rename the binding to refer to it.
E863The generator type of … mentions … or one of its generated names: free requires a type given independently of the declared model.
E864… uses an arrow type: the equational strategy requires named operation arguments, as in succ(x : M) : M.
E865… binds a universe argument: the equational strategy supports term arguments only; bind universes in the theory header.
E866… hides a declaration used by its expansion: rename the initial or free model. (retired)
E867… takes … with a type depending on the … …: the equational strategy supports arguments independent of the theory's laws and carrier evidence.
E868… extends …, whose header binds no universe: bind …, its public universe parameter, in …'s header, or name that universe in …'s header.
E869…'s … binds … in a pattern, under which the expansion names the model …: rename the initial or free model. (retired)
E870The generator type of … lives in a universe above its carrier's declared one: a free model cannot lower its generators. Choose a larger carrier universe or a smaller generator type.
E871Inlining … here would capture its field …: rename the enclosing pattern or statement binding. (retired)
E872Duplicate declaration …: a declaration in this module already owns that name.
E873initial takes no parameters; use free for a parameterized model.
E874free takes explicit parameters in parentheses, as free W(A : U0) : T(U0) on A; implicit parameters are not supported.
E875…'s inherited interfaces have cyclic dependencies after sharing.
E876The equational strategy needs resolved field interfaces.
E877…'s implementation must have its inherited parameter and result types.
E878Cycle among helper definitions: …
E879…'s implemented operations create cyclic field dependencies.
E880An implemented operation used in a field type must be nonrecursive.
E881The equational strategy does not yet generate folds for …'s implemented inherited members.

Notation and operators

CodeMessage
E901-x negates in a selected notation that binds it, as integers.(-x); a path's reversal is ~p.
E902-x is not in …'s notation, which is selected here: select a notation that binds it, as integers.(-x).
E903…'s notation reads no literal …: write nat.(…) for a natural number, or select a notation that reads it. (retired)
E904… is a literal that a selected notation's literal rule reads, as rationals.(…).
E905…'s literal rule refuses … at its character ….
E906…'s literal rule does not evaluate … to an answer; it gives ….
E907…'s notation reads no numeral …: write nat.(…) for a natural number, or select a notation that reads it.
E908…'s notation reads no literal …: select a notation whose literal rule reads it, as rationals.(…).
E909… is a binary literal, which a selected notation's literal rule reads, as nat.(…).
E910…'s notation reads no binary literal …: select one whose literal rule reads it, as nat.(…).
E911… means the natural number in a selected notation that reads it: use nat; or write nat.(…).
E912x … y means what a selected notation binds … to: for natural numbers, use nat; or write nat.(x … y).

Kernel: declared types

CodeMessage
K101Dimension renaming allocation failed.
K102A boundary is nested too deeply.
K103A boundary applies a constructor to too many arguments.
K104A boundary applies an earlier constructor to all its arguments.
K105A boundary is not a constructor expression.
K106A cube is nested too deeply.
K107A cube is the sort or a path type over it.
K108The signature has no such constructor.
K109A constructor's type has fewer arguments than it takes.
K110A position's displayed cube does not follow its cube.
K111Unknown judgement.
K112Expected an eliminator in progress.
K113An eliminator's motive is a family of types over an instance of a declared type: Π (z : S(as)). U(l).
K114The eliminator has a clause for every constructor; close it.
K115The clause's type is not the constructor's clause type: its boundaries must be the displayed boundaries of 3.6.
K116The eliminator lacks a clause: every constructor, the squash included, needs one.
K117HIT join allocation failed.
K118HIT reversal allocation failed.
K119HIT endpoint allocation failed.
K120HIT substitution interval allocation failed.
K121Missing HIT transport face.
K122HIT elimination filling allocation failed.
K123Interval constant allocation failed.
K124A constructor's type has fewer arguments than its application.
K125A constructor's dimensions are its result type's path layers.
K126Transport filling allocation failed.
K127Unchecked homogeneous composition face.
K128Transport computation requires a declared higher sort.
K129Signature table exhausted.
K130Signature table allocation failed.
K131A signature has too many constructors.
K132Constructor table allocation failed.
K133A binder in a boundary reuses a name of the signature. (retired)
K134A binder's type in a boundary mentions the sort, a constructor or a position (section 1.4).
K135A path abstraction or application in a boundary carries a type that is not a cube over the sort (section 1.4).
K136A boundary may not contain a composition, hcomp or transport (section 1.4, Q3).
K137A boundary applies a position to exactly its arity (section 1.4).
K138A boundary applies an earlier constructor to all its data and positions (section 1.4).
K139A constructor's boundary names the constructor itself (section 1.5).
K140A boundary must be a constructor expression: a position or an earlier constructor, applied, or a path application or abstraction of one (section 1.4).
K141A constructor has too many dimensions, or a position too deep a cube.
K142A position's type and a constructor's result end in the sort, or in an iterated path type over it (section 1.2).
K143A constructor's argument reuses a name of the signature. (retired)
K144A constructor has too many arguments.
K145A position's arity reuses a name of the signature. (retired)
K146A position's arity mentions the sort, a constructor or a position: the sort occurs only at the end of a position (section 1.3).
K147A position's arity is too long.
K148A data argument follows a position; the kernel requires all data first (section 1.2).
K149Expected a signature judgement.
K150The signature judgement names no signature.
K151The signature is already admitted; an admitted signature never changes.
K152Only the signature's latest judgement continues it.
K153Declared types (H1) are switched off in this kernel; CC_EXTENSION_H1 switches them on.
K154A signature's former type must be closed.
K155A truncation level is at most the kernel's bound.
K156A signature needs a sort symbol. (retired)
K157A signature has too many universe parameters.
K158A signature's universe parameters range below UU0: x < ω.
K159A signature's former type is Π (xs < ω). Π (ps : Ps). U(ℓ).
K160A signature's parameters need distinct symbols, other than the sort's. (retired)
K161The classification marks a universe parameter the signature does not have.
K162An erased universe parameter needs a determining occurrence: a parameter whose type ends in U(x) (section 1.1). Otherwise it is recorded.
K163Signature allocation failed.
K164A constructor type's context holds a dimension entry.
K165A constructor's type names the constructor itself (section 1.5).
K166The sort entry's type is not the signature's universe.
K167A parameter entry's type is not the signature's.
K168A constructor entry's type is not that constructor's.
K169A constructor type's context holds an entry that is not the signature's: a later constructor, or a name from outside the signature (section 1.5).
K170A constructor type is derived in the signature's universe U(ℓ); lift it there first.
K171A constructor needs a symbol. (retired)
K172A constructor's symbol must be new to the signature. (retired)
K173A constructor type mentions an erased universe parameter; only a recorded one may occur there (section 1.1).
K174Expected an instance of a declared type.
K175Only an admitted signature has instances.
K176A parameter's type does not end in a universe where the signature's does.
K177An erased universe parameter has no determining occurrence.
K178Expected an instance in progress.
K179An instance takes its recorded levels first, one for each recorded universe parameter.
K180An instance takes its recorded levels before its parameters.
K181The instance already has all its parameters.
K182The instance's parameters and levels are not the signature's.
K183A parameter reads an erased universe parameter at another level than an earlier one; lift the lower parameter first.
K184A parameter's type is not the signature's telescope at the earlier parameters.
K185A signature takes one entry for each of its former's parameters.
K186A signature's universe parameter takes a level entry.
K187A signature's term parameter takes a term entry.
K188A signature's entries are pairwise distinct, the sort's apart from its parameters'.
K189A signature's sort takes a term entry.
K190A constructor type mentions an entry outside its signature's telescope.
K191A constructor takes a term entry.
K192A constructor's entry is already in its signature's telescope.

Kernel: instructions

CodeMessage
K201An equality has sides 0 and 1.
K202The type is not included in the target type.
K203Interval allocation failed.
K204Eta needs a term of a Π, level Π, Σ, path or Glue type.
K205Missing position.
K206The position leaves the term.
K207Position depth exceeded.
K208Beta needs a lambda applied to an argument, or a level lambda to a level.
K209Delta needs a definition.
K210Iota needs an eliminator or projection applied to a constructor.
K211A path step needs a path application.
K212Interval copy failed.
K213A path step needs a path lambda, or an endpoint of the annotated type.
K214A face step needs a composition with a tube on a face that holds.
K215A Glue step needs glue [φ ↦ t] (unglue b) whose two Glue types agree, and whose t is b on φ, after normalization.
K216Unknown step rule.
K217A composition system is closed by Comp before it is rewritten.
K218An open signature or an instance in progress is continued by its own instructions, not rewritten.
K219A judgement has sides 0 (term), 2 (type), and 1 for an equality's other term.
K220Replacement allocation failed.
K221A path application's annotation is replaced only by a path type.
K222Replacing a subterm that uses a composition's dimension is not supported.
K223The replacing equality lacks an entry for a bound name it uses.
K224One entry would be bound twice on the path.
K225The last piece must first be shown to agree with the pieces it overlaps.
K226A piece may overlap only the first 64 pieces.
K227A Glue piece's face is one conjunction of endpoint equations, or 0.
K228A Glue piece's face must be consistent.
K229A Glue piece must already be restricted to its face.
K230That piece's face is not one clause.
K231The Glue type has no piece at that position.
K232Not a Glue type under construction.
K233The last piece does not overlap that piece, or already agrees with it.
K234A Glue term needs a Glue type.
K235The Glue term has a value for every piece of its type.
K236A Glue term's value must already be restricted to its face.
K237A value on the face 0 takes no equality.
K238Only an element of a Glue type is unglued.
K239Only a term of a path type can be applied to a dimension.
K240A path applies at a dimension, 0 or 1.
K241An endpoint is 0 or 1.
K242Only a term of a path type can be applied to an interval formula.
K243A path applies at an interval formula.
K244The base of a composition may not use its dimension.
K245That tube's face is not one clause.
K246The system has no tube at that position.
K247The last tube must first be shown to agree with the tubes it overlaps.
K248Not a composition system.
K249A tube's face is one conjunction of endpoint equations, or 0.
K250A tube on the face 0 takes no equality.
K251A tube's face must be consistent.
K252A tube's face may not use the composition's dimension.
K253A tube must already be restricted to its face.
K254A tube may overlap only the first 64 tubes of a system.
K255Not a system of tubes.
K256The last tube does not overlap that tube, or already agrees with it.
K257A declared data sort has no formal composition or transport: compose it with Comp, whose tube φ ↦ u_0 transports (Q1).
K258A homogeneous composition's type may not use its dimension.
K259A transport's face is a face formula.
K260A transport's tubes are its face's clauses, in order.
K261Instruction store handle space exhausted.
K262Instruction store allocation overflow.
K263Instruction store allocation failed.
K264Unknown context entry.
K265A universe variable is not a term: use it in a level, as U(x).
K266Expected a type: a term of a universe.
K267Two dimension entries with one index meet in a context.
K268A context entry still depends on the discharged entry.
K269The binder would capture another dimension entry with its index.
K270Entry index allocation failed. (retired)
K271A context entry needs a symbol. (retired)
K272The symbol already names a context entry. (retired)
K273Expected a level entry.
K274Dimension outside the native range.
K275Unbound level variable.
K276A term variable is not a level.
K277A universe level exceeds the kernel's bound.
K278A motive is a family of types: Π(x : A). U(l).
K279An injection needs a sum type.
K280Sum induction needs a value of a sum type.
K281Only a term of a Π type can be applied.
K282Only a term of a level Π can be instantiated at a level.
K283Instantiation needs a finite level, below ω.
K284A pair needs a Σ type.
K285Only a term of a Σ type has projections.
K286Only a Π or Σ type has a domain.
K287Only a Π or Σ type has a family.
K288Only a closed judgement can be defined.
K289Definition symbol is already registered. (retired)
K290Unknown checked definition reference.
K291A declared type's instance reads finite levels only, below ω (Q16).
K292A restriction's face is one consistent conjunction of endpoint equations.
K293A face entry is an assumption, not a variable or a dimension.
K294A split step needs a composition with a tube on a face of several clauses, or on the face 0.
K295Not a Glue term under construction.
K296Expected a typing judgement.
K297Expected an equality judgement.
K298Expected a dimension entry.
K299Expected a term entry.

Kernel: terms and computation

CodeMessage
K301A signature is still open; close it before committing.
K302Checkpoint compaction allocation failed.
K303Unchecked composition face reached reduction.
K304Composition filling formula allocation failed.
K305Filling direction allocation failed.
K306Backward filling direction allocation failed.
K307Path composition direction allocation failed.
K308Singleton contraction interval allocation failed.
K309Glue endpoint face allocation failed.
K310Preservation interval allocation failed.
K311Glue universal face allocation failed.
K312Glue boundary face allocation failed.
K313Glue composition allocation overflow.
K314Glue composition allocation failed.
K315Universe composition interval allocation failed.
K316Level normal form too large.
K317Level normal form allocation failed.
K318Expected a level.
K319A level successor counts at least one.
K320A bound is not a level.
K321A level variable's key is not a symbol. (retired)
K322Level normalization depth exceeded.
K323Composition face allocation failed.
K324Syntax memo allocation failed.
K325Alpha-comparison scope counter exhausted.
K326Native conversion recursion depth exceeded.
K327Alpha-comparison memo allocation failed.
K328An endpoint substitution needs a dimension and 0 or 1.
K329Unchecked partial face reached reduction.
K330Unknown definition reached reduction.
K331Unchecked Glue face reached reduction.
K332Glue eta face allocation failed.
K333Unchecked Glue projection reached reduction.
K334Path application requires an interval expression.
K335Unchecked path application reached reduction.
K336Native reduction recursion depth exceeded.
K337Native normal-form depth exceeded.
K338Kernel checking/reduction budget exhausted.
K339Unknown term constructor.
K340A universe's level is its child; its payload must be zero.
K341Missing syntax child.
K342Invalid syntax child handle.
K343A formula handle names no registered formula.
K344Native prototype syntax depth exceeds 512.
K345Term handle space exhausted.
K346Term arena capacity overflow.
K347Term arena allocation failed.
K348Normal cache allocation failed.
K349Term symbol space exhausted. (retired)
K350Formula handle space exhausted.
K351Formula arena capacity overflow.
K352Formula arena allocation failed.
K353Formula copy failed.
K354Fresh symbol space exhausted. (retired)
K355Native prototype has exhausted its 64 dimension names.
K356Term substitution dimension allocation failed.
K357Malformed composition tube list.
K358Invalid dimension substitution.
K359Dimension binder outside native range.
K360Fresh dimension allocation failed.
K361Endpoint allocation failed.
K362Invalid interval variable.
K363Invalid face variable.
K364Face copy failed.
K365Cubical lattice term-size or work budget exceeded.
K366Invalid face substitution.
K367Invalid Glue face substitution.
K368Invalid interval substitution.
K369Normalization stack allocation failed.
K370Dimension scan allocation failed.
K371Variable scan allocation failed.
K372Substitution stack allocation failed.
K373Substitution stack depth exceeded.
K374Alpha-comparison stack allocation failed.
K375Level traversal stack allocation failed.
K376A binder's body already mentions the entry it would be opened with.
K377Reduction reached a term with a loose bound variable.
K378Normalization reached a term with a loose bound variable.
K379A term or level binder carries no name: its payload is zero.
K380A variable's index exceeds the kernel's bound.
K381A context reference names no live term or level entry.
K382Instantiation needs locally closed values.
K383An operation opened more binders than the kernel's bound.
K384Opening allocation failed.

Kernel: instructions (continued)

CodeMessage
K401A replacement takes an entry, or 0, for each term or level binder its position crosses.
K402A replacement takes a level entry for a level binder, and a term entry for a term binder.
K403A replacement's entry for a binder is already in the rewritten judgement's context.
K404A replacement's entry for a binder has a type that needs an outer binder given no entry.
K405An equivalence type's operands must be locally closed.
K406Missing entries.
K407A result would hold a variable an operation opened.
K408A judgement's terms are locally closed.
K409A replacement gives one entry to two of its binders.
K410A replacement gives no entry to a binder its occurrence uses.
K411A replacement's equality keeps an entry that depends on a binder's entry.

Warnings

CodeMessage
W701None of … is used after this obtain: remove it.
W702… is never used after this let: remove it.
W703… is unused: the return type does not mention it and the successor clause does not use it. Omit as …: induction … return ….
W704… is unused: the return type does not mention it. Omit as …: match … return ….
W705… is unused in the body: write … instead of … … : …. ….
W706… is unused in the body: take it out of the group and write … for it.
W707… is unused: the return type does not mention it. Omit as …: induction … return ….
W708The … before … asks for nothing more: it is under …, which normalizes its part.
W709The ! before … asks for nothing more: a pair, an injection, a constructor or an expression computes its part's weak head itself.
W710The !! before … asks for nothing more: an expression is compared by its normal form.