The Calculus of Constructions has dependent products but no kernel primitive for a vector declaration, a terminating recursive definition over vectors, or case analysis whose result lives in a cumulative universe. A proof-assistant kernel must integrate all of these operations in one conversion judgment. The integration studied here is one frozen calculus, not the intersection of all systems called CIC.
Here PCUIC means the Predicative Calculus of Cumulative Inductive Constructions formalized by the checksum-pinned Coq Coq Correct! artifact, archive commit 914e4c6c8b9a5c7c87454c2da960dd8d4b8c81cd. Its sorts are 𝖯𝗋𝗈𝗉, 𝖲𝖾𝗍, and predicative universes represented by universe expressions. It has universe polymorphism, a cumulative conversion relation, primitive projections, fixpoints, and cofixpoints. Its frozen 𝗅𝖾𝗊_𝗍𝖾𝗋𝗆 clause for two 𝖨𝗇𝖽 terms nevertheless compares their universe instances by 𝖾𝗊_𝖨𝗇𝖽 in PCUICEquality.v; that clause has no FIXME marker. Separately, the 𝖢𝗎𝗆𝗎𝗅𝖺𝗍𝗂𝗏𝖾_𝖼𝗍𝗑 branch of 𝖼𝗈𝗇𝗌𝗂𝗌𝗍𝖾𝗇𝗍_𝗂𝗇𝗌𝗍𝖺𝗇𝖼𝖾 in PCUICTyping.v is marked FIXME Cumulative. It omits the module system, template polymorphism, casts that select a conversion algorithm, function 𝜂, and primitive-record 𝜂.
The theorem statuses in remark 89.20 are part of this card. Results from the living MetaRocq checkout or another CIC presentation do not fill an open cell of the historical system.
The PCUIC sorts are 𝖯𝗋𝗈𝗉, 𝖲𝖾𝗍, and constrained universe expressions. This sort grammar replaces the CoC pure-type-system sort set. The successor-sort operation replaces the CoC axioms, and 𝗌𝗈𝗋𝗍𝖮𝖿𝖯𝗋𝗈𝖽𝗎𝖼𝗍 replaces the product triples. The three-clause declarative cumulative relation replaces beta-convertibility in typing. PCUIC adds local definitions and ordered global declarations, universe instances, inductive and coinductive blocks, cases, primitive projections, guarded fixpoints, configured cofixpoints, and the corresponding root contractions. No CoC sort axiom, PTS triple (𝑠1,𝑠2,𝑠3), or bare equivalence-closure conversion rule remains as a second typing path.
The raw terms of the frozen artifact are generated by the following constructors: 𝑡,𝑢::=𝖱𝖾𝗅(𝑛)∣𝖵𝖺𝗋(𝑥)∣𝖤𝗏𝖺𝗋(𝑛,¯𝑡)∣𝖲𝗈𝗋𝗍(𝑈)∣𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐵)∣𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝑡)∣𝖫𝖾𝗍(𝑥,𝑏,𝐴,𝑡)∣𝖠𝗉𝗉(𝑡,𝑢)∣𝖢𝗈𝗇𝗌𝗍(𝑐,¯𝑢)∣𝖨𝗇𝖽(𝐼,¯𝑢)∣𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍(𝐼,𝑘,¯𝑢)∣𝖢𝖺𝗌𝖾((𝐼,𝑛𝑝),𝑃,𝑐,¯𝑏)∣𝖯𝗋𝗈𝗃(𝑝,𝑐)∣𝖥𝗂𝗑(¯𝑑,𝑘)∣𝖢𝗈𝖥𝗂𝗑(¯𝑑,𝑘). Here 𝑛 is a de Bruijn index; names on binders are printing annotations; ¯𝑢 is a universe instance; 𝑛𝑝 is the number of uniform parameters; ¯𝑏 is a list of branches with arities; and ¯𝑑 is a mutually recursive block with one selected component 𝑘. The raw syntax contains 𝖵𝖺𝗋 and 𝖤𝗏𝖺𝗋 for quotation and goal-level data, but the typing family below has no rule for either constructor. They are therefore not closed kernel terms.
A local declaration is either an assumption 𝑥:𝐴 or a definition 𝑥:=𝑏:𝐴. A local context is a snoc-ordered list of such declarations; de Bruijn index zero denotes its last declaration. A global environmentΣ is an ordered list whose entries are constants or mutual inductive bodies. A constant body contains a type, an optional body, and a universe declaration. A mutual inductive body contains
one shared parameter context and its length 𝑛𝑝;
one or more inductive bodies, each with an arity, constructor list, primitive-projection list, and allowed elimination sort families;
a Finite, CoFinite, or BiFinite tag and one universe declaration. These mean inductive, coinductive, and nonrecursive record, respectively.
A reference may use only an earlier global declaration. We write Σ;Γ⊢𝑡:𝑇 for the artifact’s typing family.
The order on global declarations prevents a constant body from referring to itself except through a checked fixpoint. Mutual inductive references are introduced as one block because constructor types may mention every family in that block.
Write 𝖶𝖥(Σ) for the artifact’s well-formed global-environment family and 𝖶𝖥Σ(Γ) for its local-context family. The empty global environment is well formed. An extension Σ,𝑑 is well formed exactly when Σ is well formed, the name of 𝑑 is fresh, the universe declaration of 𝑑 introduces fresh levels and satisfiable constraints, and 𝑑 satisfies its declaration condition. A constant body has its declared type; an axiom’s type inhabits a sort. A mutual inductive block has a well-formed parameter context with the recorded number of assumptions, checked arities, constructors and projections, valid universe and elimination data, and a true 𝗂𝗇𝖽_𝗀𝗎𝖺𝗋𝖽 oracle. Writing 𝖴𝖣𝖾𝖼𝗅𝖮𝖪(Σ,𝑈) for fresh declared levels, constraints over declared levels, monomorphic-level discipline, and satisfiability, and 𝖣𝖾𝖼𝗅𝖮𝖪(Σ,𝑈,𝑑) for the preceding constant or inductive condition, the global family has the exact outer rules
𝖶𝖥([])
PCUIC-Global-empty
𝖶𝖥(Σ)𝖿𝗋𝖾𝗌𝗁(𝑑,Σ)𝖴𝖣𝖾𝖼𝗅𝖮𝖪(Σ,𝑈𝑑)𝖣𝖾𝖼𝗅𝖮𝖪(Σ,𝑈𝑑,𝑑)
𝖶𝖥(Σ,𝑑)
PCUIC-Global-extend
For a transparent constant, 𝖣𝖾𝖼𝗅𝖮𝖪 is the typing judgment for its body at its declared type; for an axiom it is the existence of a sort for the declared type. For a mutual block it is exactly the parameter, body, constructor, projection, universe, elimination, and guard tuple listed above.
The term-typing family is the least family generated by the following named rules. Here 𝖨𝗇𝗌𝗍(𝑢,𝑈) checks a universe instance, 𝑑[𝑛] lifts by 𝑛, and 𝖶𝖿𝖳𝗒𝗉𝖾Σ,Γ(𝐵) means that 𝐵 is a well-formed arity or has some sort.
𝖶𝖥Σ(Γ)Γ[𝑛]=𝑑
Σ;Γ⊢𝖱𝖾𝗅(𝑛):𝑑.𝗍𝗒𝗉𝖾[𝑛+1]
PCUIC-Rel
𝖶𝖥Σ(Γ)ℓ∈𝗅𝖾𝗏𝖾𝗅𝗌(Σ)
Σ;Γ⊢𝖲𝗈𝗋𝗍(ℓ):𝖲𝗈𝗋𝗍(𝗌𝗎𝗉𝖾𝗋(ℓ))
PCUIC-Sort
Σ;Γ⊢𝐴:𝖲𝗈𝗋𝗍(𝑠1)Σ;Γ,𝑥:𝐴⊢𝐵:𝖲𝗈𝗋𝗍(𝑠2)
Σ;Γ⊢𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐵):𝖲𝗈𝗋𝗍(𝗌𝗈𝗋𝗍𝖮𝖿𝖯𝗋𝗈𝖽𝗎𝖼𝗍(𝑠1,𝑠2))
PCUIC-Prod
Σ;Γ⊢𝐴:𝖲𝗈𝗋𝗍(𝑠)Σ;Γ,𝑥:𝐴⊢𝑡:𝐵
Σ;Γ⊢𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝑡):𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐵)
PCUIC-Lambda
Σ;Γ⊢𝐴:𝖲𝗈𝗋𝗍(𝑠)Σ;Γ⊢𝑏:𝐴Σ;Γ,𝑥:=𝑏:𝐴⊢𝑡:𝐵
Σ;Γ⊢𝖫𝖾𝗍(𝑥,𝑏,𝐴,𝑡):𝖫𝖾𝗍(𝑥,𝑏,𝐴,𝐵)
PCUIC-Let
Σ;Γ⊢𝑓:𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐵)Σ;Γ⊢𝑢:𝐴
Σ;Γ⊢𝖠𝗉𝗉(𝑓,𝑢):𝐵[𝑢/𝑥]
PCUIC-App
Global lookup has three distinct rules. In the constructor conclusion, 𝖼𝗍𝗈𝗋𝖳𝗒𝗉𝖾 performs universe instantiation and substitutes the mutual families for the block-local de Bruijn references.
𝖶𝖥Σ(Γ)𝖽𝖾𝖼𝗅𝖢𝗈𝗇𝗌𝗍(Σ,𝑐,𝑑)𝖨𝗇𝗌𝗍(𝑢,𝑑.𝗎𝗇𝗂𝗏𝖾𝗋𝗌𝖾𝗌)
Σ;Γ⊢𝖢𝗈𝗇𝗌𝗍(𝑐,𝑢):𝑑.𝗍𝗒𝗉𝖾[𝑢]
PCUIC-Const
𝖶𝖥Σ(Γ)𝖽𝖾𝖼𝗅𝖨𝗇𝖽(Σ,𝐼,𝑀,𝐷)𝖨𝗇𝗌𝗍(𝑢,𝑀.𝗎𝗇𝗂𝗏𝖾𝗋𝗌𝖾𝗌)
Σ;Γ⊢𝖨𝗇𝖽(𝐼,𝑢):𝐷.𝖺𝗋𝗂𝗍𝗒[𝑢]
PCUIC-Ind
𝖶𝖥Σ(Γ)𝖽𝖾𝖼𝗅𝖢𝗍𝗈𝗋(Σ,𝐼,𝑘,𝑀,𝐷,𝐶)𝖨𝗇𝗌𝗍(𝑢,𝑀.𝗎𝗇𝗂𝗏𝖾𝗋𝗌𝖾𝗌)
Σ;Γ⊢𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍(𝐼,𝑘,𝑢):𝖼𝗍𝗈𝗋𝖳𝗒𝗉𝖾(𝑀,𝐶,𝐼,𝑘,𝑢)
PCUIC-Construct
For the case rule, define 𝖢𝖺𝗌𝖾𝖮𝖪Σ,Γ to be the exact conjunction 𝖽𝖾𝖼𝗅𝖨𝗇𝖽(Σ,𝐼,𝑀,𝐷),𝑀.𝑛𝑝=𝑛𝑝,¯𝑝=𝖿𝗂𝗋𝗌𝗍𝗇(𝑛𝑝,¯𝑎),Σ;Γ⊢𝑃:𝑃𝑇,𝗍𝗒𝗉𝖾𝗌𝖮𝖿𝖢𝖺𝗌𝖾(𝐼,𝑀,𝐷,¯𝑝,𝑢,𝑃,𝑃𝑇)=(ictx,pctx,𝑠,¯𝐵),𝖼𝗈𝗋𝗋𝖾𝖼𝗍𝖠𝗋𝗂𝗍𝗒(Σ,𝐷,𝐼,𝑢,ictx,¯𝑝,pctx),𝖺𝗅𝗅𝗈𝗐𝖾𝖽𝖥𝖺𝗆𝗂𝗅𝗒(𝑠,𝐷.𝗄𝖾𝗅𝗂𝗆),Σ;Γ⊢𝑐:𝖺𝗉𝗉𝗌(𝖨𝗇𝖽(𝐼,𝑢),¯𝑎),𝖠𝗅𝗅𝟤(𝜆(𝑞,𝑏),(𝑞′,𝐵).𝑞=𝑞′×(Σ;Γ⊢𝑏:𝐵)×(Σ;Γ⊢𝐵:𝖲𝗈𝗋𝗍(𝑠)),¯𝑏,¯𝐵). Here 𝖺𝗅𝗅𝗈𝗐𝖾𝖽𝖥𝖺𝗆𝗂𝗅𝗒(𝑠,𝐷.𝗄𝖾𝗅𝗂𝗆) is the artifact’s existential Boolean test that compares the sort family against the stored elimination families. Nothing is hidden behind a source-language coverage judgment. The rule is
𝖢𝖺𝗌𝖾𝖮𝖪Σ,Γ(𝐼,𝑛𝑝,𝑢,𝑃,𝑐,¯𝑏,¯𝑎)
Σ;Γ⊢𝖢𝖺𝗌𝖾((𝐼,𝑛𝑝),𝑃,𝑐,¯𝑏):𝖺𝗉𝗉𝗌(𝑃,𝗌𝗄𝗂𝗉𝗇(𝑛𝑝,¯𝑎)++[𝑐])
PCUIC-Case
The paired branch arities must agree exactly, and a branch binds only the nonparameter constructor arguments; PCUIC-Case creates no induction hypotheses.
If 𝑝=(𝐼,𝑛𝑝,𝑛𝑎) is a declared projection with stored type 𝑇𝑝, the projection rule is
Let 𝑑ℕ be the ordinary natural-number block, and let 𝑑𝑉 contain 𝖵𝖾𝖼𝗍𝗈𝗋@{𝑢}(𝐴:𝖳𝗒𝗉𝖾@{𝑢}):ℕ→𝖳𝗒𝗉𝖾@{𝑢},𝗏𝗇𝗂𝗅:𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,0),𝗏𝖼𝗈𝗇𝗌:Π(𝑛:ℕ).𝐴→𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝑛)→𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝗌𝗎𝖼(𝑛)). Rule PCUIC-Global-empty derives 𝖶𝖥([]). Two uses of PCUIC-Global-extend, first for 𝑑ℕ and then for 𝑑𝑉, derive 𝖶𝖥([𝑑ℕ,𝑑𝑉]). The first extension is necessary because the arity and constructor types of 𝑑𝑉 refer to ℕ. In a well-formed context Γ=(𝐴:𝖲𝗈𝗋𝗍(𝑢),𝑥:𝐴), the local rules give Σ;Γ⊢𝖲𝗈𝗋𝗍(𝑢):𝖲𝗈𝗋𝗍(𝗌𝗎𝗉𝖾𝗋(𝑢))𝑃𝐶𝑈𝐼𝐶−𝑆𝑜𝑟𝑡,Σ;Γ⊢𝖱𝖾𝗅(0):𝐴𝑃𝐶𝑈𝐼𝐶−𝑅𝑒𝑙,Σ;𝐴:𝖲𝗈𝗋𝗍(𝑢)⊢𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝖱𝖾𝗅(0)):𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐴)𝑃𝐶𝑈𝐼𝐶−𝐿𝑎𝑚𝑏𝑑𝑎,Σ;𝐴:𝖲𝗈𝗋𝗍(𝑢)⊢𝖯𝗋𝗈𝖽(𝑥,𝐴,𝐴):𝖲𝗈𝗋𝗍(𝑢)𝑃𝐶𝑈𝐼𝐶−𝑃𝑟𝑜𝑑. For 𝑎:𝐴, application and local naming continue the same derivation: Σ;𝐴,𝑎⊢𝖠𝗉𝗉(𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝑥),𝑎):𝐴𝑃𝐶𝑈𝐼𝐶−𝐴𝑝𝑝,Σ;𝐴,𝑎⊢𝖫𝖾𝗍(𝑦,𝑎,𝐴,𝑦):𝖫𝖾𝗍(𝑦,𝑎,𝐴,𝐴)𝑃𝐶𝑈𝐼𝐶−𝐿𝑒𝑡. Let 𝑑𝗂𝖽 be the transparent constant declaration with type ∏𝐴:𝖲𝗈𝗋𝗍(𝑢)𝐴→𝐴 and body 𝜆𝐴.𝜆𝑥.𝑥. After global lookup in [𝑑ℕ,𝑑𝑉,𝑑𝗂𝖽], the three lookup rules derive the declared types of 𝖢𝗈𝗇𝗌𝗍(𝗂𝖽,𝑢), 𝖨𝗇𝖽(𝐼𝑉,𝑢), and 𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍(𝐼𝑉,0,𝑢). For 𝑣:𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝗌𝗎𝖼(𝑛)), put 𝐶(0):=𝟏, 𝐶(𝗌𝗎𝖼(𝑚)):=𝐴, and 𝑃𝗁𝖾𝖺𝖽:=𝜆𝑚.𝜆𝑣.𝐶(𝑚). The complete vector-head term with predicate and branches 𝖢𝖺𝗌𝖾((𝐼𝑉,1),𝑃𝗁𝖾𝖺𝖽,𝑣,[(0,⋆),(3,𝜆𝑚.𝜆𝑥.𝜆𝑥𝑠.𝑥)]):𝐴 then concludes by PCUIC-Case: the nil branch has type 𝐶(0) and the cons branch has type 𝐶(𝗌𝗎𝖼(𝑚)). The generated vector-induction block records the vector position as principal. Its cons branch recurses only on the constructor field 𝑥𝑠, so 𝖿𝗂𝗑_𝗀𝗎𝖺𝗋𝖽 returns true and PCUIC-Fix derives the declared type. A constructor-headed vector later enables PCUIC-Fix-unfold.
For the two remaining raw forms, extend the environment by the concrete blocks 𝖡𝗈𝗑@{𝑢}(𝐴:𝖳𝗒𝗉𝖾@{𝑢}):𝖳𝗒𝗉𝖾@{𝑢},𝖻𝗈𝗑:𝐴→𝖡𝗈𝗑(𝐴),𝗎𝗇𝖻𝗈𝗑:𝖡𝗈𝗑(𝐴)→𝐴,(𝑑𝖡𝗈𝗑) and, writing 𝐾𝐴:=𝖪𝖲𝗍𝗋𝖾𝖺𝗆@{𝑢}(𝐴), let 𝐾𝐴:𝖳𝗒𝗉𝖾@{𝑢},𝗄𝖼𝗈𝗇𝗌:𝐴→𝐾𝐴→𝐾𝐴.(𝑑𝖲𝗍𝗋𝖾𝖺𝗆). Declare 𝑑𝖡𝗈𝗑BiFinite with primitive projection 𝑝𝗎𝗇𝖻𝗈𝗑, and declare 𝑑𝖲𝗍𝗋𝖾𝖺𝗆CoFinite. For 𝑎:𝐴, PCUIC-Proj derives 𝑏𝑎:=𝖻𝗈𝗑(𝐴,𝑎):𝖡𝗈𝗑(𝐴),𝖯𝗋𝗈𝗃(𝑝𝗎𝗇𝖻𝗈𝗑,𝑏𝑎):𝐴. Let the selected cofix body be 𝗋𝖾𝗉𝖾𝖺𝗍:𝐴→𝖪𝖲𝗍𝗋𝖾𝖺𝗆(𝐴):=𝜆𝑥.𝗄𝖼𝗈𝗇𝗌(𝑥,𝗋𝖾𝗉𝖾𝖺𝗍(𝑥)). When 𝖺𝗅𝗅𝗈𝗐_𝖼𝗈𝖿𝗂𝗑 holds, its lifted body checks in the one-entry mutual context, and PCUIC-CoFix derives the declared type of the selected component. Finally, if an inferred type 𝐴 is cumulative to a well-formed 𝐵, PCUIC-Cumul derives the widened judgment Σ;Γ⊢𝑡:𝐵. These terms give a concrete edge for every rule on the card; reduction remains a separate relation.
A universe level is one of 𝖯𝗋𝗈𝗉,𝖲𝖾𝗍,𝖫𝖾𝗏𝖾𝗅(𝑥),𝖵𝖺𝗋(𝑛). A universe expression is a nonempty maximum of terms ℓ and ℓ+1. A universe constraint is ℓ<ℓ′, ℓ≤ℓ′, or ℓ=ℓ′. A valuation sends 𝖯𝗋𝗈𝗉 to −1, 𝖲𝖾𝗍 to 0, monomorphic named levels to positive integers, and polymorphic variables to natural numbers. A constraint set is consistent when some valuation satisfies every constraint.
The order 𝑈≤𝜙𝑉 holds when every valuation satisfying 𝜙 gives the integer denotation of 𝑈 at most that of 𝑉. Equality of universes is mutual order. This semantic definition is the specification; the checker uses a graph algorithm whose correctness is a separate obligation.
The sort rule assigns a successor universe to a type universe. Products use the artifact operation 𝗌𝗈𝗋𝗍𝖮𝖿𝖯𝗋𝗈𝖽𝗎𝖼𝗍(𝑠1,𝑠2)={𝖯𝗋𝗈𝗉,𝑠2=𝖯𝗋𝗈𝗉,max(𝑠1,𝑠2),𝑠2≠𝖯𝗋𝗈𝗉. Thus propositions remain impredicative in their domain, whereas informative products follow the cumulative hierarchy.
Write Σ;Γ⊢𝑡⇝0𝑢 for a root contraction. Its rules are the following named inferences; 𝖺𝗉𝗉𝗌 forms a left-associated application spine.
Σ;Γ⊢𝖠𝗉𝗉(𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝑡),𝑎)⇝0𝑡[𝑎/𝑥]
PCUIC-β
Σ;Γ⊢𝖫𝖾𝗍(𝑥,𝑏,𝐴,𝑡)⇝0𝑡[𝑏/𝑥]
PCUIC-ζ
Γ[𝑛].𝖻𝗈𝖽𝗒=𝑏
Σ;Γ⊢𝖱𝖾𝗅(𝑛)⇝0𝑏[𝑛+1]
PCUIC-Rel-δ
𝖽𝖾𝖼𝗅𝖢𝗈𝗇𝗌𝗍(Σ,𝑐,𝑑)𝑑.𝖻𝗈𝖽𝗒=𝑏
Σ;Γ⊢𝖢𝗈𝗇𝗌𝗍(𝑐,𝑢)⇝0𝑏[𝑢]
PCUIC-Global-δ
Define 𝗂𝗈𝗍𝖺𝖱𝖾𝖽(𝑛𝑝,𝑘,¯𝑎,¯𝑏):=𝖺𝗉𝗉𝗌(𝗌𝗇𝖽(¯𝑏[𝑘]),𝗌𝗄𝗂𝗉𝗇(𝑛𝑝,¯𝑎)). Abbreviate 𝑐𝑘:=𝖺𝗉𝗉𝗌(𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍(𝐼,𝑘,𝑢),¯𝑎),𝑟𝑘:=𝗂𝗈𝗍𝖺𝖱𝖾𝖽(𝑛𝑝,𝑘,¯𝑎,¯𝑏). Then constructor case reduction is
Σ;Γ⊢𝖢𝖺𝗌𝖾((𝐼,𝑛𝑝),𝑃,𝑐𝑘,¯𝑏)⇝0𝑟𝑘
PCUIC-ι
The three guarded unfolding rules expose their side conditions.
𝗎𝗇𝖿𝗈𝗅𝖽𝖥𝗂𝗑(¯𝑑,𝑘)=(𝑛𝑎,𝑓)𝗂𝗌𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍𝗈𝗋(𝑛𝑎,¯𝑎)=𝗍𝗋𝗎𝖾
Σ;Γ⊢𝖺𝗉𝗉𝗌(𝖥𝗂𝗑(¯𝑑,𝑘),¯𝑎)⇝0𝖺𝗉𝗉𝗌(𝑓,¯𝑎)
PCUIC-Fix-unfold
For the cofix rules, abbreviate 𝑐:=𝖺𝗉𝗉𝗌(𝖢𝗈𝖥𝗂𝗑(¯𝑑,𝑘),¯𝑎) and 𝑐′:=𝖺𝗉𝗉𝗌(𝑓,¯𝑎).
𝗎𝗇𝖿𝗈𝗅𝖽𝖢𝗈𝖥𝗂𝗑(¯𝑑,𝑘)=(𝑛𝑎,𝑓)
Σ;Γ⊢𝖢𝖺𝗌𝖾(𝑞,𝑃,𝑐,¯𝑏)⇝0𝖢𝖺𝗌𝖾(𝑞,𝑃,𝑐′,¯𝑏)
PCUIC-CoFix-case
𝗎𝗇𝖿𝗈𝗅𝖽𝖢𝗈𝖥𝗂𝗑(¯𝑑,𝑘)=(𝑛𝑎,𝑓)
Σ;Γ⊢𝖯𝗋𝗈𝗃(𝑝,𝑐)⇝0𝖯𝗋𝗈𝗃(𝑝,𝑐′)
PCUIC-CoFix-proj
𝑝=(𝐼,𝑛𝑝,𝑛𝑎)¯𝑎[𝑛𝑝+𝑛𝑎]=𝑎
Σ;Γ⊢𝖯𝗋𝗈𝗃(𝑝,𝑐𝑘)⇝0𝑎
PCUIC-Proj-ι
The compatible one-step relation 𝑡⟶𝑢 closes these root contractions under every argument position of every raw constructor, using the extended local context under binders. The artifact’s declarative cumulativity is generated by exactly three clauses:
𝗅𝖾𝗊_𝗍𝖾𝗋𝗆Σ(𝑡,𝑢)
𝖢𝗎𝗆𝗎𝗅Σ,Γ(𝑡,𝑢)
Cumul-refl
𝑡⟶𝑣𝖢𝗎𝗆𝗎𝗅Σ,Γ(𝑣,𝑢)
𝖢𝗎𝗆𝗎𝗅Σ,Γ(𝑡,𝑢)
Cumul-red-l
𝖢𝗎𝗆𝗎𝗅Σ,Γ(𝑡,𝑣)𝑢⟶𝑣
𝖢𝗎𝗆𝗎𝗅Σ,Γ(𝑡,𝑢)
Cumul-red-r
The base comparison 𝗅𝖾𝗊_𝗍𝖾𝗋𝗆Σ is relative to the global universe constraints. At sorts it includes constraint-relative 𝖾𝗊_𝗎𝗇𝗂𝗏𝖾𝗋𝗌𝖾 and universe order; at products it compares domains by conversion and codomains covariantly. Historical PCUIC does not use contravariant domain cumulativity. The artifact’s 𝖢𝗈𝗇𝗏 relation has the same reduction clauses and uses the equality comparison 𝖾𝗊_𝗍𝖾𝗋𝗆 in its base clause. Neither relation is defined as an equivalence closure. Transitivity of 𝖢𝗎𝗆𝗎𝗅, and symmetry of 𝖢𝗈𝗇𝗏, are derived theorems using confluence. The 𝖢𝗎𝗆𝗎𝗅 premise in PCUIC-Cumul is therefore PCUIC term cumulativity, not subtyping from an earlier programming calculus.
Each root rule has a visible instance: 𝖠𝗉𝗉(𝖫𝖺𝗆𝖻𝖽𝖺(𝑥,𝐴,𝑥),𝑎)⇝0𝑎,𝑃𝐶𝑈𝐼𝐶−𝛽𝖫𝖾𝗍(𝑥,𝑏,𝐴,𝑥)⇝0𝑏.𝑃𝐶𝑈𝐼𝐶−𝜁 A reference to a local definition contracts by PCUIC-Rel-𝛿; a transparent declared constant contracts by PCUIC-Global-𝛿 after universe instantiation. For the vector constructor spine [𝐴,𝑚,𝑥,𝑥𝑠], PCUIC-𝜄 drops the single parameter and applies the cons branch to [𝑚,𝑥,𝑥𝑠]. A checked fixpoint unfolds only when its recorded principal argument is constructor-headed. A cofixpoint unfolds when placed under either a case or a projection, by the two separate cofix rules; after the latter exposes a constructor, PCUIC-Proj-𝜄 selects the field at 𝑛𝑝+𝑛𝑎. These are reductions of raw terms, not equations inferred from the source-language names.
Let the identity’s polymorphic universe declaration be 𝑈𝗂𝖽=({𝑢},∅), where 𝑢∉𝗅𝖾𝗏𝖾𝗅𝗌(Σ). Then 𝖴𝖣𝖾𝖼𝗅𝖮𝖪(Σ,𝑈𝗂𝖽) holds: the sole level is fresh, there are no ill-scoped or monomorphic constraints, and the empty constraint set is satisfied by every valuation. In that declaration context, the identity constant has type 𝗂𝖽@{𝑢}:∏𝐴:𝖳𝗒𝗉𝖾@{𝑢}𝐴→𝐴 and body 𝜆(𝐴:𝖳𝗒𝗉𝖾@{𝑢}).𝜆(𝑥:𝐴).𝑥. At an instance 𝑢↦𝑣, universe substitution changes every occurrence of 𝑢 to 𝑣. Application to 𝐵:𝖳𝗒𝗉𝖾@{𝑣} checks after the constraint solver verifies the instantiated declaration. A later use at a larger level 𝑤 may use cumulativity only after establishing 𝑣≤𝑤; the checker does not infer equality of those levels from their printed names.
★☆☆ For universe variables 𝑢,𝑣, list the constraints required to type ∏𝐴:𝖳𝗒𝗉𝖾@{𝑢}𝐴→𝖳𝗒𝗉𝖾@{𝑣}. Compute its sort using 𝗌𝗈𝗋𝗍𝖮𝖿𝖯𝗋𝗈𝖽𝗎𝖼𝗍 and explain why replacing the codomain by 𝖯𝗋𝗈𝗉 changes that sort.
In a mutual block, parameters are the initial telescope copied unchanged into every family and constructor conclusion. indices are the remaining arguments of an inductive family and may vary between constructor conclusions. A block is constructor-uniform when each constructor concludes in a family from the block applied first to exactly the declared parameters in their original order.
The historical artifact records strict positivity through the Boolean oracle 𝗂𝗇𝖽_𝗀𝗎𝖺𝗋𝖽. A well-formed block requires 𝗂𝗇𝖽_𝗀𝗎𝖺𝗋𝖽(𝑀)=𝗍𝗋𝗎𝖾. The polynomial arrow fragment uses the strict-positivity condition of remark 28.36: a recursive family may occur only as the final result of a recursive arity, never to the left of an arrow. The kernel guard also delta-unfolds transparent aliases and admits a nested occurrence only when it appears as a uniform parameter of a previously declared inductive whose stored positivity information permits that occurrence. Thus the simple arrow condition is exact for the declarations printed in this chapter, but is not a complete definition of the kernel’s nested-positivity criterion. The artifact does not prove that its Boolean oracle implements this mathematical account, so the oracle belongs to the trusted theory boundary.
For each inductive family 𝐼 with parameters ¯𝑝, indices ¯𝑖, and constructors 𝑐1,…,𝑐𝑚, a case term contains
a predicate 𝑃 over the indices and scrutinee;
the scrutinee 𝑐:𝐼¯𝑝¯𝑖;
one branch for each constructor, binding exactly that constructor’s nonparameter arguments.
The declaration stores a list 𝗄𝖾𝗅𝗂𝗆(𝐼) of target sort families among 𝖯𝗋𝗈𝗉, 𝖲𝖾𝗍, and 𝖳𝗒𝗉𝖾. The case rule checks that the sort family of 𝑃 belongs below one of those stored families. When 𝐼 lives in 𝖯𝗋𝗈𝗉, singleton elimination means that well-formedness permits an informative target only when there is at most one constructor and every nonparameter constructor field has sort 𝖯𝗋𝗈𝗉. A proposition with two constructors fails the first test, just as an existential carrying 𝑥:𝐴 fails the second. For a predicative inductive, the frozen 𝖼𝗁𝖾𝖼𝗄_𝗂𝗇𝖽_𝗌𝗈𝗋𝗍𝗌 checks constructor universes and checks index universes only when the configuration flag 𝗂𝗇𝖽𝗂𝖼𝖾𝗌_𝗆𝖺𝗍𝗍𝖾𝗋 is true. Every 𝖼𝗁𝖾𝖼𝗄𝖾𝗋_𝖿𝗅𝖺𝗀𝗌 instance shipped with the artifact sets that flag to false. The function does not validate 𝗄𝖾𝗅𝗂𝗆. Thus the vector trace below explicitly records [𝖯𝗋𝗈𝗉,𝖲𝖾𝗍,𝖳𝗒𝗉𝖾] as declaration data; this list is not derived as a well-formedness invariant for every Type-valued inductive.
The kernel case rule is nonrecursive. A generated induction scheme is a separate constant whose body is a guarded fixpoint containing such a case. Its recursive branch invokes the fixpoint on each recursive constructor argument and passes those results to the branch method. Thus induction hypotheses belong to the type and fixpoint body of the generated scheme; they are not additional arguments passed by 𝜄-reduction of 𝖢𝖺𝗌𝖾.
The elimination list is data checked with the declaration, not a slogan that all propositions erase. Equality has singleton elimination into informative sorts. An existential proposition whose constructor carries a witness from an arbitrary informative type cannot reveal that witness by elimination into 𝖲𝖾𝗍 or 𝖳𝗒𝗉𝖾.
The declaration 𝖡𝖺𝖽:𝖳𝗒𝗉𝖾,𝗋𝗈𝗅𝗅:(𝖡𝖺𝖽→𝖡𝖺𝖽)→𝖡𝖺𝖽 places 𝖡𝖺𝖽 in the domain of an arrow inside a constructor argument. A strict-positivity implementation of 𝗂𝗇𝖽_𝗀𝗎𝖺𝗋𝖽 rejects the block. If it were admitted, the self-application construction used in the strict-positivity boundary of chapter 28 would recover a reduction cycle. Positivity is therefore a normalization premise, not a formatting check on constructor conclusions.
A mutual fixpoint body records a name, type, body, and the position of its principal recursive argument. The historical PCUIC typing rule requires the Boolean oracle 𝖿𝗂𝗑_𝗀𝗎𝖺𝗋𝖽(¯𝑑)=𝗍𝗋𝗎𝖾 and selects one well-typed component. Root reduction unfolds that component only when its principal argument is constructor-headed. The artifact assumes that the guard is stable under reduction, universe equality, renaming, lifting, and substitution.
A cofixpoint uses the same mutual-body representation and unfolds only when the surrounding term is a case or primitive projection. In the frozen artifact, however, PCUIC-CoFix requires only that the configuration flag 𝖺𝗅𝗅𝗈𝗐_𝖼𝗈𝖿𝗂𝗑 is enabled, the selected component exists, the mutual context is well formed, and every body has its declared lifted type. It has no cofix guard premise. This asymmetry with PCUIC-Fix is an exact historical boundary, not an omitted source-language check. Tactics that synthesize decreasing evidence or elaborate an equation compiler are not kernel rules.
The guard excludes a loop that satisfies every other premise of PCUIC-Fix. Let the one-entry block be ¯𝑑Ω:=[𝑓:ℕ→ℕ:=𝜆(𝑛:ℕ).𝑓𝑛],𝐹:=𝖥𝗂𝗑(¯𝑑Ω,0). In the mutual context 𝑓:ℕ→ℕ, the body is a lambda and has the declared lifted type. Its recursive call is not made on a constructor field, so 𝖿𝗂𝗑_𝗀𝗎𝖺𝗋𝖽(¯𝑑Ω)≠𝗍𝗋𝗎𝖾 and PCUIC-Fix cannot derive a type for 𝐹. If that sole premise were deleted, the constructor-headed argument 0 would trigger PCUIC-Fix-unfold and give the one-step loop 𝖺𝗉𝗉𝗌(𝐹,[0])𝑃𝐶𝑈𝐼𝐶−𝐹𝑖𝑥−𝑢𝑛𝑓𝑜𝑙𝑑⇝0𝖺𝗉𝗉𝗌(𝐹,[0]). Thus the guard blocks a concrete divergence rather than merely classifying a source definition.
The observation-triggered unfolding sites avoid immediate unobserved expansion of a cofixpoint; they include no static productivity premise. They also do not turn the constructor presentation into the destructor-corecursor calculus of chapter 33; the two systems have different syntax and subject-reduction obligations.
The Coq Coq Correct! paper records a subject-reduction difficulty for cofixpoint introduction in its selected conversion. The historical formalization therefore contains no unconditional full-PCUIC subject reduction theorem. No result from the destructor presentation of chapter 33 repairs this constructor/cofix system without a translation and preservation proof.
The following traces distinguish declaration checking from later term checking. Each declaration is first parsed to the raw constructors of definition 89.3; the checker then validates universe instances, arities, constructor types, guards, and elimination data before extending the global environment.
Work over the well-formed environment [𝑑ℕ] containing the natural-number block. At universe 𝑢, declare 𝖵𝖾𝖼𝗍𝗈𝗋@{𝑢}(𝐴:𝖳𝗒𝗉𝖾@{𝑢}):ℕ→𝖳𝗒𝗉𝖾@{𝑢},𝗏𝗇𝗂𝗅:𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,0),𝗏𝖼𝗈𝗇𝗌:Π(𝑛:ℕ).𝐴→𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝑛)→𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝗌𝗎𝖼(𝑛)). The checker trace is:
look up ℕ in 𝑑ℕ, then parse one finite inductive body with parameter 𝐴 and index 𝑛;
take the block universe declaration 𝑈𝑉=({𝑢},∅),𝖴𝖣𝖾𝖼𝗅𝖮𝖪([𝑑ℕ],𝑈𝑉), where the second judgment follows by freshness and satisfiability;
verify that its arity ends in 𝖳𝗒𝗉𝖾@{𝑢}, then run the constructor-universe check 𝖼𝗁𝖾𝖼𝗄_𝖼𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍𝗈𝗋𝗌_𝗌𝗆𝖺𝗅𝗅𝖾𝗋. The collected sorts of the two complete constructor types are 𝗂𝗇𝖽_𝖼𝗍𝗈𝗋𝗌_𝗌𝗈𝗋𝗍=[𝑢,𝑢]. Deriving the full 𝗏𝖼𝗈𝗇𝗌 product sort uses ℕ:𝖲𝖾𝗍 and the 𝐴 and 𝖵𝖾𝖼𝗍𝗈𝗋 domains at 𝑢. The check asks for 𝑢≤𝑢 twice against the inductive sort, and both comparisons are entailed;
check both constructor types in the context containing the family and the uniform parameter 𝐴;
check that each recursive occurrence of 𝖵𝖾𝖼𝗍𝗈𝗋 is positive and that each conclusion begins with the same 𝐴;
store the chosen 𝗂𝗇𝖽_𝗄𝖾𝗅𝗂𝗆 entries 𝖯𝗋𝗈𝗉, 𝖲𝖾𝗍, and 𝖳𝗒𝗉𝖾;
generate the nonrecursive case predicate over 𝑛 and the scrutinee; then, as a separate declaration, check the guarded fixpoint that defines the induction scheme.
For 𝑃:∏𝑛:ℕ𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝑛)→U𝑤, the generated induction constant has methods 𝑧:𝑃(0,𝗏𝗇𝗂𝗅),𝑠:∏𝑚:ℕ∏𝑥:𝐴∏𝑥𝑠:𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝑚)𝑃(𝑚,𝑥𝑠)→𝑃(𝗌𝗎𝖼(𝑚),𝗏𝖼𝗈𝗇𝗌(𝑚,𝑥,𝑥𝑠)). Its fixpoint body cases on the vector. The raw cons branch binds only 𝑚,𝑥,𝑥𝑠; the body itself makes the recursive call on 𝑥𝑠 and passes the result to 𝑠. If 𝐼𝑉=(kn,0) is the block’s inductive identifier, the raw case information is (𝐼𝑉,1) and the two branch entries have arities [(0,𝑏𝗇𝗂𝗅),(3,𝑏𝖼𝗈𝗇𝗌)]. The single parameter 𝐴 is discarded by 𝗂𝗈𝗍𝖺𝖱𝖾𝖽 before either branch is applied; no induction hypothesis is among those three cons arguments.
Kernel branch checking remains complete even when the caller knows a successor index. Define 𝐶(0):=𝟏,𝐶(𝗌𝗎𝖼(𝑚)):=𝐴. A head case uses predicate 𝜆𝑚.𝜆𝑣.𝐶(𝑚), nil branch ⋆:𝐶(0), and cons branch 𝜆𝑚.𝜆𝑥.𝜆𝑥𝑠.𝑥:𝐶(𝗌𝗎𝖼(𝑚)). Applying that complete case to 𝑣:𝖵𝖾𝖼𝗍𝗈𝗋(𝐴,𝗌𝗎𝖼(𝑛)) has type 𝐶(𝗌𝗎𝖼(𝑛))≡𝐴. The nil branch is checked but cannot be selected by a well-typed constructor-headed scrutinee at that index.
Declare 𝖤𝗊@{𝑢}(𝐴:𝖳𝗒𝗉𝖾@{𝑢})(𝑥:𝐴):𝐴→𝖯𝗋𝗈𝗉,𝗋𝖾𝖿𝗅:𝖤𝗊(𝐴,𝑥,𝑥). The family has parameters 𝐴,𝑥 and one index. It is strictly positive and has one constructor with no informative nonparameter field. The declaration therefore records singleton elimination, allowing the motive of an equality case to live in 𝖳𝗒𝗉𝖾@{𝑣}. The branch index is 𝑥, so the generated eliminator is the equality eliminator after its parameters and universe instances are restored.
For 𝐴:𝖳𝗒𝗉𝖾@{𝑢} and 𝑃:𝐴→𝖯𝗋𝗈𝗉, declare 𝖤𝗑𝗂𝗌𝗍𝗌(𝐴,𝑃):𝖯𝗋𝗈𝗉,𝗂𝗇𝗍𝗋𝗈:∏𝑥:𝐴𝑃(𝑥)→𝖤𝗑𝗂𝗌𝗍𝗌(𝐴,𝑃). The constructor is positive, but it carries the informative witness 𝑥:𝐴. The checker records elimination into 𝖯𝗋𝗈𝗉, not arbitrary 𝖳𝗒𝗉𝖾. A predicate returning ℕ and a branch returning 𝑥 must therefore be rejected at the elimination-sort check. A predicate returning a proposition may use both 𝑥 and the proof of 𝑃(𝑥). If the ℕ-valued motive were admitted, source case reduction could return a value determined by 𝑥. Erasure replaces the proposition-valued scrutinee by a box, which retains no witness to select that value; the target could not simulate the source reduction described in remark 89.22. The elimination restriction prevents this failure of the box-erasure simulation.
The traces in example 89.15, example 89.16 and example 89.17 establish that the displayed declarations satisfy the chapter’s printed arity, uniformity, positivity, and elimination checks. They do not prove normalization, consistency, canonicity, or correctness of the artifact’s executable checker. Each trace ends with one accepted or rejected declaration-checking obligation. None constructs a reduction normalization function, a model, a closed-value classification theorem, or a simulation between checker output and typing derivations. Those are exactly the missing conclusions named in this qualification.
★★☆ Declare binary trees parameterized by a universe-polymorphic label type. Classify parameters, indices, recursive occurrences, universe constraints, and allowed elimination sorts. Then change one constructor field from 𝖳𝗋𝖾𝖾(𝐴) to 𝖳𝗋𝖾𝖾(𝐴)→𝐴 and identify the path at which strict positivity fails.
The artifact contains both completed proofs and explicit assumptions or admissions. A checker theorem depending on an admitted metatheorem is a conditional theorem about the executable, not an unconditional theorem about PCUIC.
Proof of Theorem 89.19 — Imported: confluence of historical reduction
Proof. This is the endpoint red_confluence in pcuic/theories/PCUICConfluence.v of the frozen artifact. The file constructs parallel reduction, proves its triangle property, transfers the diamond to context-sensitive one-step reduction, and closes under reflexive–transitive reduction. The proof assumes well-formedness of Σ but does not use the strong-normalization axiom. This import has the raw syntax of definition 89.3. Its reduction and conversion are exactly those of definition 89.8. ◻
assumed/open: PCUICSN.v declares normalisation as an axiom and admits the corollary normalisation’.
Canonicity and consistency
open at this frozen signature; the paper notes that they would follow from the normalization statement axiomatized in PCUICSN.v at this signature, but the archive does not prove that statement.
Proof irrelevance used by graph equality
template-coq/theories/common/uGraph.v marks the comment immediately before graph_eq as the proof-irrelevance step; the lemma proves equality of canonical graph representations and is used by the safe checker.
Safe-checker soundness
conditional on the trusted theory base; safechecker/theories/PCUICSafeChecker.v defines typecheck_program with a dependent typing conclusion and additionally admits check_one_ind_body, add_uctx_make_graph, gc_of_constraints_union, and no_prop_levels_union, and assumes graph_eq.
Checker completeness
open: pcuic/theories/PCUICCheckerCompleteness.v contains only its license header and no completeness declaration or proof.
Erasure-relation correctness
erasure/theories/ErasureCorrectness.v proves erases_correct, relative to well-formed typing and the same metatheory assumptions, for the artifact’s weak call-by-value target.
First-order erasure corollaries
stated in the paper as nonmechanized observations; no corresponding theorem occurs in the pinned archive.
No open row is filled by a theorem from a different CIC variant.
Assume the historical artifact’s normalization, subject-reduction, validity, strengthening, principality, fix-guard stability, proof-irrelevance, universe-graph, and inductive-body obligations. Assume also the selected checker configuration, including its unguarded 𝖺𝗅𝗅𝗈𝗐_𝖼𝗈𝖿𝗂𝗑 flag. If its safe checker returns a typing result for a closed program (Σ,𝑡), then the returned type is backed by a squashed derivation in the PCUIC typing relation for the checked environment.
Proof of Theorem 89.21 — Conditional checker endpoint
Proof. The definition typecheck_program constructs its result in the type of checked values rather than returning an unverified Boolean. Its normalization and conversion procedures invoke the listed metatheory interfaces, while environment checking invokes the graph and inductive-body interfaces. Under the stated assumptions, projecting the dependent result yields the typing derivation. Without any one of those assumptions, the artifact term still runs but this projection no longer establishes the corresponding PCUIC theorem; this is why the conclusion is conditional. ◻
The historical erasure replaces types and proofs by a box in an untyped lambda calculus. Its mechanized Theorem 4.7 proves a weak call-by-value simulation: if a well-typed source term erases by the erasure relation and evaluates, then the target evaluates to a value related to the source value. The paper then states Lemma 4.8 and Corollaries 4.8.1–4.8.2 for first-order inductive results under the heading “non-mechanised observations.” Those corollaries identify relational erasure with the executable erasure function, but they are not artifact theorems. Neither endpoint proves source normalization, semantic consistency of added axioms, or correctness for another evaluation order.
The living MetaRocq checkout in the source library is at the following commit: 𝚌𝟾𝚌𝚍𝟺𝟼𝟶𝟻𝟺𝟻𝟷𝟾𝟷𝟿𝟹𝟷𝟶𝟹𝚌𝟹𝚋𝚋𝟹𝟹𝚊𝚊𝟼𝚎𝟷𝟻𝚌𝟽𝚏𝟺𝟾𝟿𝚎𝟽𝟸𝚌. The repository citation is [The26b]. This checkout contains results and syntax absent from the 2019 archive. The comparison below is deliberately syntactic: it records only facts visible in the two pinned abstract syntaxes and imports no theorem from one column into the other.
Feature
Frozen 2019 PCUIC
Pinned 2026 MetaRocq snapshot
Proof irrelevance
A metatheory assumption used by the checker development; there is no distinct judgmentally proof-irrelevant raw sort.
Universes.v has raw sort sSProp, family tag fSProp, order constructors ltPropSProp and ltSPropType, and maps fSProp to Irrelevant. These syntax and order declarations do not discharge the 2019 metatheory assumption.
Primitive records
BiFinite blocks and tProj; primitive-record 𝜂 is absent from conversion.
BasicAst.v retains BiFinite; the raw term syntax retains tProj. A primitive-record 𝜂 result is not imported or claimed here.
Quotients
No raw quotient constructor or quotient reduction rule.
No raw quotient constructor; a library encoding or package is therefore not a new PCUIC kernel rule.
Other primitives
The term grammar ends at fixpoints and cofixpoints.
The raw grammar adds tPrim for the snapshot’s primitive values.
Thus 𝖲𝖯𝗋𝗈𝗉 is not another name for 𝖯𝗋𝗈𝗉. The table establishes only its separate raw sort, order, and relevance data. Its elimination and conversion theorems are status-gated from this chapter and are not inferred from those constructors. Nor does an ordinary quotient package create a quotient computation rule, or a primitive projection create judgmental record 𝜂.
The following second card records the exact assistant deltas used for that comparison. It is a dated access card for the cited mutable language references, not a frozen kernel card or an amalgamated calculus [Agd26, Lea26, Roc26].
Reference card
Exact delta from the frozen 2019 PCUIC rows above
Agda latest record card
A nonrecursive record has judgmental 𝜂 by default, controllable by eta-equality/no-eta-equality; a coinductive record uses copattern observations and disallows 𝜂 by default. This is not the frozen BiFinite/tProj conversion.
Lean 2026 type-system card
Definitional equality adds proof irrelevance and 𝜂 for functions and single-constructor structures. The primitive type former Quot and its lift reduction add a quotient computation absent from frozen PCUIC.
Rocq master record card
An ordinary record elaborates to a one-constructor variant with case-defined projections. The optional projections(primitive) representation instead disables matching and gives nonrecursive records judgmental 𝜂 in the documented cases; recursive primitive records do not receive that 𝜂 rule.
The card compares only the named record, equality, and quotient clauses. Agda, Lean, and Rocq also differ in universes, inductive admissibility, and recursion checks, but none of those unprinted rules is imported here. Thus the card is neither a translation nor a theorem about every release of any assistant.
★★☆ For each hypothesis of theorem 89.21, identify the checker phase that uses it: environment checking, weak-head normalization, conversion, type inference, or declaration checking. Explain why confluence alone does not make weak-head normalization an executable total function.
★★☆ Compare the equality and existential declarations in example 89.16, example 89.17. Write a 𝖳𝗒𝗉𝖾-valued motive for each. State which case is admitted, which is rejected, and which constructor field makes the difference.
★★★ Expand the vector block of example 89.15 into raw 𝖨𝗇𝖽 and 𝖢𝗈𝗇𝗌𝗍𝗋𝗎𝖼𝗍 references with a universe instance. Derive the type of its dependent case predicate and both raw branch types; verify that neither branch receives an induction hypothesis. Then derive the type of the separate generated induction constant. In its cons method, mark the parameter, index, recursive vector, and induction hypothesis separately.
★★★ Take a constructor-headed raw vector case and a primitive projection from a cofixpoint. Give their complete one-step reductions under definition 89.8. Then remove the constructor head from the fixpoint’s principal argument and explain why fix unfolding no longer applies. State separately where a recursive call appears in the fixpoint-built vector induction constant.
★★☆ Reconstruct the status table of remark 89.20 directly from the frozen archive. For every open or conditional cell, record the exact file and declaration name. Do not use the living MetaRocq checkout to change a historical status.
★★★Practical project.pcuic-declaration-trace Implement in Kappa a small declaration checker for the printed fragment containing universe levels, one inductive family, constructors, strict-positivity paths, and an allowed-elimination flag. Maintain the invariant that every accepted constructor ends in the declared family with all parameters uniform and has no family occurrence in a negative position. Its five verdict lines must record these cases:
accept the vector summary of example 89.15 with ACCEPT Vector;
record ACCEPT Equality for the equality summary in example 89.16;
record constructor-arg/domain for the rejection in example 89.12;
reject informative elimination in example 89.17 with Prop-witness-blocks-Type-elimination;
reject a two-constructor proposition named Or, whose fields all have sort 𝖯𝗋𝗈𝗉, with Prop-not-singleton-for-Type-elimination.
Derive informative elimination from at most one constructor and constructor fields of sort 𝖯𝗋𝗈𝗉; do not accept a caller-supplied Boolean certificate. The exact five verdict lines followed by the summary line form the six-line acceptance report. This program checks only the printed fragment; it is not an implementation or proof of the historical PCUIC checker.
Sources. The historical calculus and status audit use Sozeau, Boulier, Forster, Tabareau, and Winterhalter [SBF^+20], together with its exact Zenodo archive [SBF^+19]. The Calculus of Constructions is due to Coquand and Huet [CH88]. The living MetaRocq repository [The26b] is consulted only for the explicitly versioned delta above.