Coq 在匹配中展开类型函数（如析构函数） TL；博士

我想写一个不动点定义，它匹配依赖类型中的一个值，而不使用证明模式。关键问题是Coq不会使用

匹配

来注意依赖类型中的类型是等价的；我可以在证明模式下强制它，但我不知道在没有它的情况下是否可以这样做

---

我在做一个涉及很多矩阵运算的项目。矩阵可以是任意多个维度（每个维度都是矩形的），因此我编写了一个定义来计算矩阵的类型：

Require Import Coq.Unicode.Utf8.
Require Export Vector.
Import VectorNotations.
Require Import List.
Import ListNotations.

Fixpoint matrix (A: Type) (dims: list nat) :=
  match dims with
  | [] => A
  | head::tail => Vector.t (matrix A tail) head
  end.

出于“原因”，我需要对元素进行线性化，以便选择线性化矩阵的第n个元素。我的第一次尝试是尝试返回一个一维矩阵，但我遇到了一堵墙，上面有列表的

折叠（左）

（请提供继续操作的建议）：

我认为转换为列表可能更容易，因此：

Fixpoint linearize' {A: Type} {dims: list nat} (m: matrix A dims): list A :=
  match dims with
  | [] => []
  | h::t => Vector.fold_left
            (@app A)
            []
            (Vector.map linearize' (m: Vector.t (matrix (list A) t) h))
  end.

但Coq抱怨：

In environment
linearize' : ∀ (A : Type) (dims : list nat), matrix A dims → list A
A : Type
dims : list nat
m : matrix A dims
h : nat
t : list nat
The term "m" has type "matrix A dims" while it is expected to have type
 "Vector.t (matrix (list A) t) h".

我能够用“证明风格”来写定义，但我很困惑，我不能让Coq接受本质上相同的不动点

Definition linearize {A: Type} {dims: list nat} (m: matrix A dims): list A.
Proof.
  induction dims.
  - (* unfold matrix in m. *) (* exact [m]. *) apply [m].
  - simpl in m.
    (* exact (Vector.fold_left (@List.app A) [] (Vector.map IHdims m)). *)
    apply (Vector.map IHdims) in m.
    apply (Vector.fold_left (@List.app A) [] m).
Defined.

似乎如果我能让Coq破坏

m

和

dims

的类型，就像在归纳法中发生的那样，我会很乐意去做…这里是

打印线性化。

linearize = 
λ (A : Type) (dims : list nat) (m : matrix A dims),
  list_rect (λ dims0 : list nat, matrix A dims0 → list A)
    (λ m0 : matrix A [], [m0])
    (λ (a : nat) (dims0 : list nat) (IHdims : matrix A dims0 → list A) 
       (m0 : matrix A (a :: dims0)),
       let m1 := Vector.map IHdims m0 in Vector.fold_left (app (A:=A)) [] m1)
    dims m
     : ∀ (A : Type) (dims : list nat), matrix A dims → list A

Arguments linearize {A}%type_scope {dims}%list_scope _

---

这是在Coq中使用依赖类型的主要难题之一。解决方案是重写线性化，以便在匹配后返回函数：

Require Import Coq.Unicode.Utf8.
Require Export Vector.
Import VectorNotations.
Require Import List.
Import ListNotations.

Fixpoint matrix (A: Type) (dims: list nat) :=
  match dims with
  | [] => A
  | head::tail => Vector.t (matrix A tail) head
  end.

Fixpoint linearize {A: Type} {dims: list nat} : matrix A dims -> list A :=
  match dims with
  | [] => fun _ => []
  | dim :: dims => fun mat =>
    let res := Vector.map (@linearize _ dims) mat in
    Vector.fold_left (@app _) [] res
  end.

这种技巧被称为护航模式；你可以在这里找到更多信息：。

我的第一反应是“

列表。如果你离开了，他会过得很不愉快。”

这里有一个使用
列表的解决方案。请改为向右折叠

Definition product (dims: list nat) := List.fold_right Nat.mul 1 dims.

Fixpoint concat {A} {n m : nat} (v : Vector.t (Vector.t A m) n) : Vector.t A (n * m) :=
  match v with
  | []%vector => []%vector
  | (x :: xs)%vector => append x (concat xs)
  end. 

Fixpoint linearize {A: Type} {dims: list nat} : matrix A dims -> matrix A [product dims] :=
  match dims with
  | [] => fun a => (a :: [])%vector
  | head :: tail => fun a => concat (Vector.map (linearize (dims := tail)) a)
  end.

fold_left
的问题在于，在非空的情况下，它会展开为一个立即的递归调用，这会为依赖类型的编程隐藏太多的信息。一个用例可能是定义尾部递归函数，但这里不适用

使用
fold_right
，每当您在
dims
上进行模式匹配时，
cons
案例会显示一个
Nat.mul
，它允许您使用
concat:Vector.t（Vector.tam）n->Vector.ta（n*m）
。你能说得更具体些吗？您想在不使用校对模式的情况下编写
线性化
吗？@ArthurAzevedoDeAmorim确实是，已编辑。
Definition product (dims: list nat) := List.fold_right Nat.mul 1 dims.

Fixpoint concat {A} {n m : nat} (v : Vector.t (Vector.t A m) n) : Vector.t A (n * m) :=
  match v with
  | []%vector => []%vector
  | (x :: xs)%vector => append x (concat xs)
  end. 

Fixpoint linearize {A: Type} {dims: list nat} : matrix A dims -> matrix A [product dims] :=
  match dims with
  | [] => fun a => (a :: [])%vector
  | head :: tail => fun a => concat (Vector.map (linearize (dims := tail)) a)
  end.