# Coq Reference

Learn x in y style

```
(* This is a comment *)
(* Inductive type, enumerated finite *)
(* Each item called a constructor *)
Inductive day : Type :=
| monday
| tuesday.
(* lots of periods needed, most things need an 'end' *)
(* This is a function type, has a match structure *)
(* Note that pattern matching happens in order *)
Definition next_weekday (d:day) : day :=
match d with
| monday => tuesday
| tuesday => monday
end.
(* This runs a function *)
Compute (next_weekday monday).
(* Output should be tuesday: day*)
(* Example is an assertion/unit test (silent success) *)
Example test_next_weekday:
(next_weekday (next_weekday tuesday)) = tuesday.
(* This runs the unit test, only throws if error happens. One per Example *)
(* simpl = simplification *)
(* reflexivity = check equality *)
Proof. simpl. reflexivity. Qed.
Inductive bool : Type :=
| true
| false.
Definition negb (b:bool) : bool :=
match b with
| true => false
| false => true
end.
Definition andb (b1:bool) (b2:bool) : bool :=
match b1 with
| true => b2
| false => false
end.
Definition orb (b1:bool) (b2:bool) : bool :=
match b1 with
| true => true
| false => b2
end.
Example test_orb1: (orb true false) = true.
Proof. simpl. reflexivity. Qed.
(* Notation multi-args *)
(* (n m : nat ) is the same as (n: nat) (m: nat) *)
(* can also match two expressions with comma *)
(* match n, m with *)
(* Writing aliases *)
Notation "x || y" := (orb x y).
(* Using above alias *)
Example test_orb5: false || true || false = true.
Proof. simpl. reflexivity. Qed.
Definition nandb (b1:bool) (b2:bool) : bool :=
match b1 with
| true => negb b2
| false => true
end.
Example test_nandb1: (nandb true false) = true.
Proof. simpl. reflexivity. Qed.
Example test_nandb2: (nandb true true) = false.
Proof. simpl. reflexivity. Qed.
Example test_nandb3: (nandb false false) = true.
Proof. simpl. reflexivity. Qed.
Example test_nandb4: (nandb false true) = true.
Proof. simpl. reflexivity. Qed.
Definition andb3 (b1:bool) (b2:bool) (b3:bool) : bool :=
match b1 with
| false => false
| true => (andb b2 b3)
end.
Example test_andb31: (andb3 true true true) = true.
Proof. simpl. reflexivity. Qed.
Example test_andb32: (andb3 true true false) = false.
Proof. simpl. reflexivity. Qed.
(* Prints out the type *)
Check true.
(* should give bool *)
Check nandb.
(* bool -> bool -> bool *)
(* Type within type *)
Inductive rgb : Type :=
| red
| green
| blue.
(* Takes an argument *)
Inductive color: Type :=
| black
| white
| primary (p: rgb).
(* primary colors are only constructors that are members of both color and rgb type *)
(* _ is a wildcard, order matters so red first *)
Definition isred (c : color) : bool :=
match c with
| black => false
| white => false
| primary red => true
| primary _ => false
end.
(* Module system means scope only within here *)
Module Playground.
Definition b : rgb := blue.
End Playground.
Definition b: bool := true.
Check b.
Check Playground.b.
Module TuplePlayground.
Inductive bit : Type :=
| B0
| B1.
(* bits here acts as a constructor *)
Inductive nybble : Type :=
| bits (b0 b1 b2 b3 : bit).
Check (bits B1 B0 B1 B0).
End TuplePlayground.
Module NatPlayground.
(* Example of an infinite type *)
(* O = 0, S O = 1, S (S O) = 2 This is actually what it represents *)
(* S is a constructor for successor, n is the input of nat *)
(* S is not a function! *)
Inductive nat : Type :=
| O
| S (n : nat).
End NatPlayground.
Module NatPlayground2.
(* Fixpoint if Definition has recursion *)
Fixpoint plus (n: nat) (m: nat) : nat :=
match n with
| O => m
| S n' => S (plus n' m)
end.
Compute (plus 3 2).
(* S (plus (S (S O)) (S (S O))) = 5*)
End NatPlayground2.
```