Built with Alectryon, running Coq+SerAPI. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus. On Mac, use instead of Ctrl.
(* Converting unannotated Coq files *)

(* Alectryon's default is to treat Coq files as mixed Coq + reStructuredText
   files ‘--frontend coq+rst’, but you can use ‘--frontend coq’ all comment
   processing:

      alectryon --frontend coq plain.v # Coq → HTML; produces ‘plain.v.html’

   Conversion from plain Coq to LaTeX isn't supported yet (use coq+rst):

      # alectryon --frontend coq --backend latex plain.v # Coq → LaTeX; produces ‘plain.v.tex’ *)

Require Import List.

A: Type

forall (l1 l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
A: Type

forall (l1 l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
A: Type

forall (l2 : list A) (n : nat), n <= length nil -> skipn n (nil ++ l2) = skipn n nil ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
forall (l2 : list A) (n : nat), n <= length (a :: l1) -> skipn n ((a :: l1) ++ l2) = skipn n (a :: l1) ++ l2
A: Type

forall (l2 : list A) (n : nat), n <= length nil -> skipn n (nil ++ l2) = skipn n nil ++ l2
A: Type
l2: list A

0 <= length nil -> skipn 0 (nil ++ l2) = skipn 0 nil ++ l2
A: Type
l2: list A
n: nat
S n <= length nil -> skipn (S n) (nil ++ l2) = skipn (S n) nil ++ l2
A: Type
l2: list A

0 <= 0 -> l2 = l2
A: Type
l2: list A
n: nat
S n <= 0 -> match l2 with | nil => nil | _ :: l => skipn n l end = l2
A: Type
l2: list A

0 <= 0 -> l2 = l2
reflexivity.
A: Type
l2: list A
n: nat

S n <= 0 -> match l2 with | nil => nil | _ :: l => skipn n l end = l2
inversion 1.
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2

forall (l2 : list A) (n : nat), n <= length (a :: l1) -> skipn n ((a :: l1) ++ l2) = skipn n (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A

0 <= length (a :: l1) -> skipn 0 ((a :: l1) ++ l2) = skipn 0 (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
S n <= length (a :: l1) -> skipn (S n) ((a :: l1) ++ l2) = skipn (S n) (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A

0 <= S (length l1) -> a :: l1 ++ l2 = a :: l1 ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
S n <= length (a :: l1) -> skipn (S n) ((a :: l1) ++ l2) = skipn (S n) (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A

0 <= S (length l1) -> a :: l1 ++ l2 = a :: l1 ++ l2
reflexivity.
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat

S n <= length (a :: l1) -> skipn (S n) ((a :: l1) ++ l2) = skipn (S n) (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
H: S n <= length (a :: l1)

skipn (S n) ((a :: l1) ++ l2) = skipn (S n) (a :: l1) ++ l2
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
H: S n <= length (a :: l1)

n <= length l1
le_S_n : forall n m : nat, S n <= S m -> n <= m
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
H: S n <= length (a :: l1)

n <= length l1
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
H: S n <= length (a :: l1)

S n <= S (length l1)
A: Type
a: A
l1: list A
IHl1: forall (l2 : list A) (n : nat), n <= length l1 -> skipn n (l1 ++ l2) = skipn n l1 ++ l2
l2: list A
n: nat
H: S n <= S (length l1)

S n <= S (length l1)
assumption. Qed.