Was sind der Unterschied und die Konsequenzen der Verwendung von Typparametern und Typindizes?

7

In Typentheorien wie Coqs können wir einen Typ mit folgenden Parametern definieren:

Inductive ListP (Element : Type) : Type
  := NilP  : ListP Element
   | ConsP : Element -> ListP Element -> ListP Element.

Alternativ können wir einen Typ mit einem Index wie folgt definieren:

Inductive ListI : Type -> Type
  := NilI  : forall t, ListI t
   | ConsI : forall t, t -> ListI t -> ListI t.

Meine Fragen sind:

Sind diese grundlegend unterschiedlich oder grundsätzlich gleich?
Was sind die Konsequenzen einer Verwendung übereinander?
Wann ist es vorzuziehen, eine über die andere zu verwenden?

type-theory dependent-types

— Warbo
quelle

6

ListP tund ListI tsind isomorph: Sie haben genau die gleichen Konstruktoren.

<prompt>Coq < 12 || 0 < </prompt>Check (NilP, NilI). 
(NilP, NilI)
     : (forall t : Type, ListP t) *
       (forall t : Type, ListI t)

<prompt>Coq < 13 || 0 < </prompt>Check (ConsP, ConsI). 
(ConsP, ConsI)
     : (forall t : Type, t -> ListP t -> ListP t) *
       (forall t : Type, t -> ListI t -> ListI t)

Coq erzeugt jedoch unterschiedliche Induktionsprinzipien.

<prompt>Coq < 14 || 0 < </prompt>Check (ListP_ind, ListI_ind). 
(ListP_ind, ListI_ind)
     : (forall (t : Type) (P : ListP t -> Prop),
        P (NilP t) ->
        (forall (t0 : t) (l : ListP t), P l -> P (ConsP t t0 l)) ->
        forall l : ListP t, P l) *
       (forall P : forall T : Type, ListI T -> Prop,
        (forall t : Type, P t (NilI t)) ->
        (forall (t : Type) (t0 : t) (l : ListI t),
         P t l -> P t (ConsI t t0 l)) ->
        forall (T : Type) (l : ListI T), P T l)

Das Induktionsprinzip von ListIerfordert, dass die Eigenschaft im Elementtyp ( P : forall T, ListI T -> Prop) parametrisch ist, während das Induktionsprinzip von ListPbei jedem Typ t( P : ListP t -> Prop) instanziiert werden kann . Dies ist eine Schwäche von Coqs Front-End, da ungleichmäßige rekursive Typen nicht klug sind. Sie können dasselbe Induktionsprinzip manuell definieren (der Typechecker akzeptiert es, was nicht überraschend ist, da es ListP_inddurch den offensichtlichen Isomorphismus zwischen ListPund transformiert wird ListI).

Das parametrische Formular ListPist einfacher und sofort einsatzbereit. Das ListIFormular kann auf eine ungleichmäßige Rekursion verallgemeinert werden, bei der die Parameter in den rekursiven Aufrufen nicht das Original sind. Ein Beispiel finden Sie unter Polymorphismus und induktive Datentypen .

— Gilles 'SO - hör auf böse zu sein'
quelle

3

Das macht Sinn. Als Faustregel gilt also, dass Indizes für alles verwendet werden können. Parameter können nur verwendet werden, wenn für alle Konstruktoren derselbe Wert verwendet wird. Parameter sind jedoch vorzuziehen, da sie die Induktion vereinfachen.

— Warbo

4

Ich fand auch Folgendes sehr nützlich, insbesondere die Kommentare:

http://homotopytypetheory.org/2011/04/10/just-kidding-understanding-identity-elimination-in-homotopy-type-theory/

Der Grund dafür ist, dass der Identitätstyp Id AMN von A und M "parametrisiert", aber von N "indiziert" wird. Diese Terminologie drückt den Unterschied zwischen "einer Familie induktiv definierter Typen" aus (wobei die Argumente der Familie als Parameter bezeichnet werden). und "eine induktiv definierte Familie von Typen" (wobei die Argumente als Indizes bezeichnet werden). Parameter stehen vor dem 'mu' (für jede Auswahl von Parametern gibt es einen induktiven Typ). Indizes sind „in der Schleife“ - Sie definieren gleichzeitig die gesamte Typenfamilie auf einmal, sodass verschiedene Instanzen der Familie aufeinander verweisen können. Infolgedessen können Indizes ungleichmäßig auftreten (z. B. beim Ergebnistyp der Konstruktoren), während die Parameter ein für alle Mal festgelegt werden.

— Warbo
quelle