Inductive type variant of Fin

Fin is defined as a subtype of ℕ. This file defines an equivalent type, Fin2, which is defined inductively. This is useful for its induction principle and different definitional equalities.

Main declarations

• Fin2 n: Inductive type variant of Fin n. fz corresponds to 0 and fs n corresponds to n.
• Fin2.toNat, Fin2.optOfNat, Fin2.ofNat': Conversions to and from ℕ. ofNat' m takes a proof that m < n through the class Fin2.IsLT.
• Fin2.add k: Takes i : Fin2 n to i + k : Fin2 (n + k).
• Fin2.left: Embeds Fin2 n into Fin2 (n + k).
• Fin2.insertPerm a: Permutation of Fin2 n which cycles 0, ..., a - 1 and leaves a, ..., n - 1 unchanged.
• Fin2.remapLeft f: Function Fin2 (m + k) → Fin2 (n + k)→ Fin2 (n + k) by applying f : Fin m → Fin n→ Fin n to 0, ..., m - 1 and sending m + i to n + i.

ink

inductive Fin2 : ℕ → Type

• 0 as a member of Fin (succ n) (Fin 0 is empty)

  fz: {n : ℕ} → Fin2 (Nat.succ n)

• n as a member of Fin (succ n)

  fs: {n : ℕ} → Fin2 n → Fin2 (Nat.succ n)

An alternate definition of Fin n defined as an inductive type instead of a subtype of ℕ.

ink

def Fin2.cases' {n : ℕ} {C : Fin2 (Nat.succ n) → Sort u} (H1 : C Fin2.fz) (H2 : (n : Fin2 n) → C (Fin2.fs n)) (i : Fin2 (Nat.succ n)) : C i

Define a dependent function on Fin2 (succ n) by giving its value at zero (H1) and by giving a dependent function on the rest (H2).

Equations

• Fin2.cases' H1 H2 x = match x with | Fin2.fz => H1 | Fin2.fs n => H2 n

ink

def Fin2.elim0 {C : Fin2 0 → Sort u} (i : Fin2 0) : C i

Ex falso. The dependent eliminator for the empty Fin2 0 type.

Equations

• Fin2.elim0 a = nomatch a

ink

def Fin2.toNat {n : ℕ} : Fin2 n → ℕ

Converts a Fin2 into a natural.

Equations

• Fin2.toNat Fin2.fz = 0
• Fin2.toNat (Fin2.fs i) = Nat.succ (Fin2.toNat i)

ink

def Fin2.optOfNat {n : ℕ} : ℕ → Option (Fin2 n)

Converts a natural into a Fin2 if it is in range

Equations

• Fin2.optOfNat x = none
• Fin2.optOfNat 0 = some Fin2.fz
• Fin2.optOfNat (Nat.succ k) = Fin2.fs <$> Fin2.optOfNat k

ink

def Fin2.add {n : ℕ} (i : Fin2 n) (k : ℕ) : Fin2 (n + k)

i + k : Fin2 (n + k) when i : Fin2 n and k : ℕ

Equations

• Fin2.add i 0 = i
• Fin2.add i (Nat.succ k) = Fin2.fs (Fin2.add i k)

ink

def Fin2.left (k : ℕ) {n : ℕ} : Fin2 n → Fin2 (k + n)

left k is the embedding Fin2 n → Fin2 (k + n)→ Fin2 (k + n)

Equations

• Fin2.left k Fin2.fz = Fin2.fz
• Fin2.left k (Fin2.fs i) = Fin2.fs (Fin2.left k i)

ink

def Fin2.insertPerm {n : ℕ} : Fin2 n → Fin2 n → Fin2 n

insertPerm a is a permutation of Fin2 n with the following properties:

• insertPerm a i = i+1 if i < a
• insertPerm a a = 0
• insertPerm a i = i if i > a

Equations

• Fin2.insertPerm Fin2.fz Fin2.fz = Fin2.fz
• Fin2.insertPerm Fin2.fz (Fin2.fs j) = Fin2.fs j
• Fin2.insertPerm (Fin2.fs a) Fin2.fz = Fin2.fs Fin2.fz
• Fin2.insertPerm (Fin2.fs i) (Fin2.fs j) = match Fin2.insertPerm i j with | Fin2.fz => Fin2.fz | Fin2.fs k => Fin2.fs (Fin2.fs k)

ink

def Fin2.remapLeft {m : ℕ} {n : ℕ} (f : Fin2 m → Fin2 n) (k : ℕ) : Fin2 (m + k) → Fin2 (n + k)

remapLeft f k : Fin2 (m + k) → Fin2 (n + k)→ Fin2 (n + k) applies the function f : Fin2 m → Fin2 n→ Fin2 n to inputs less than m, and leaves the right part on the right (that is, remapLeft f k (m + i) = n + i).

Equations

• Fin2.remapLeft f 0 i = f i
• Fin2.remapLeft f (Nat.succ a) Fin2.fz = Fin2.fz
• Fin2.remapLeft f (Nat.succ a) (Fin2.fs i) = Fin2.fs (Fin2.remapLeft f a i)

ink

class Fin2.IsLT (m : ℕ) (n : ℕ) : Type

• The unique field of Fin2.IsLT, a proof that m < n.

  h : m < n

This is a simple type class inference prover for proof obligations of the form m < n where m n : ℕ.

ink

instance Fin2.IsLT.zero (n : ℕ) : Fin2.IsLT 0 (Nat.succ n)

Equations

• Fin2.IsLT.zero n = { h := (_ : 0 < Nat.succ n) }

ink

instance Fin2.IsLT.succ (m : ℕ) (n : ℕ) [l : Fin2.IsLT m n] : Fin2.IsLT (Nat.succ m) (Nat.succ n)

Equations

• Fin2.IsLT.succ m n = { h := (_ : Nat.succ m < Nat.succ n) }

ink

def Fin2.ofNat' {n : ℕ} (m : ℕ) [inst : Fin2.IsLT m n] : Fin2 n

Use type class inference to infer the boundedness proof, so that we can directly convert a Nat into a Fin2 n. This supports notation like &1 : Fin 3.

Equations

• Fin2.ofNat' x = absurd h (_ : ¬x < 0)
• Fin2.ofNat' 0 = Fin2.fz
• Fin2.ofNat' (Nat.succ m) = Fin2.fs (Fin2.ofNat' m)

ink

instance Fin2.instInhabitedFin2OfNatNatInstOfNatNat : Inhabited (Fin2 1)

Equations

• Fin2.instInhabitedFin2OfNatNatInstOfNatNat = { default := Fin2.fz }