# User:Michiexile/MATH198/Lecture 1

### From HaskellWiki

(Difference between revisions)
|          |                           |          |                                                                                                                                                                                                    |
|----------|---------------------------|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
|          |                           |          |                                                                                                                                                                                                    |
| Line 13: |                           | Line 13: |                                                                                                                                                                                                    |
|          |                           |          |                                                                                                                                                                                                    |
|          | ===What do we require?=== |          | ===What do we require?===                                                                                                                                                                          |
|          |                           | +        |                                                                                                                                                                                                    |
|          |                           | +        | Our examples will be drawn from discrete mathematics, logic, Haskell programming and linear algebra. I expect the following concepts to be at least vaguely familiar to anyone taking this course: |
|          |                           | +        | * Sets                                                                                                                                                                                             |
|          |                           | +        | * Functions                                                                                                                                                                                        |
|          |                           | +        | * Permutations                                                                                                                                                                                     |
|          |                           | +        | * Groups                                                                                                                                                                                           |
|          |                           | +        | * Partially ordered sets                                                                                                                                                                           |
|          |                           | +        | * Vector spaces                                                                                                                                                                                    |
|          |                           | +        | * Linear maps                                                                                                                                                                                      |
|          |                           | +        | * Matrices                                                                                                                                                                                         |
|          |                           | +        | * Homomorphisms                                                                                                                                                                                    |
|          |                           |          |                                                                                                                                                                                                    |
|          | ==Category==              |          | ==Category==                                                                                                                                                                                       |

## 2 Introduction

### 2.1 Why this course?

An introduction to Haskell will usually come with pointers toward Category Theory as a useful tool, though not with much more than the mention of the subject. This course is intended to fill that gap, and provide an introduction to Category Theory that ties into Haskell and functional programming as a source of examples and applications.

### 2.2 What will we cover?

The definition of categories, special objects and morphisms, functors, natural transformation, (co-)limits and special cases of these, adjunctions, freeness and presentations as categorical constructs, monads and Kleisli arrows, recursion with categorical constructs.

Maybe, just maybe, if we have enough time, we'll finish with looking at the definition of a topos, and how this encodes logic internal to a category. Applications to fuzzy sets.

### 2.3 What do we require?

Our examples will be drawn from discrete mathematics, logic, Haskell programming and linear algebra. I expect the following concepts to be at least vaguely familiar to anyone taking this course:

• Sets
• Functions
• Permutations
• Groups
• Partially ordered sets
• Vector spaces
• Linear maps
• Matrices
• Homomorphisms

## 3 Category

### 3.1 Graphs and paths

A graph is a collection G0 of vertices and a collection G1 of arrows. The structure of the graph is captured in the existence of two functions, that we shall call source and target, both going from G1 to G1. In other words, each arrow has a source and a target.

We denote by [v,w] the collection of arrows with source v and target w.

We extend the notation, and denote by Gi the collection of all paths of length i. Such a path is a sequence $f_1,\dots,f_i$ of arrows, such that for each j, target(fj − 1) = source(fj).

### 3.2 Definition of a category

A category is a graph with some special structure:

• Each [v,w] is a set and equipped with a composition operation $[u,v] \times [v,w] \to [u,w]$. In other words, any two arrows, such that the target of one is the source of the other, can be composed to give a new arrow with target and source from the ones left out.

We write $f:u\to v$ if $f\in[u,v]$.

$u \to v \to w$ => $u \to w$

• The composition of arrows is associative.
• Each vertex v has a dedicated arrow 1v with source and target v, called the identity arrow.
• Each identity arrow is a left- and right-identity for the composition operation.

The composition of $f:u\to v$ with $g:v\to w$ is denoted by $gf:u\to v\to w$. A mnemonic here is that you write things so associativity looks right. Hence, (gf)(x) = g(f(x)). This will make more sense once we get around to generalized elements later on.

### 3.3 Examples

• The empty category with no vertices and no arrows.
• The category 1 with a single vertex and only its identity arrow.
• The category 2 with two objects, their identity arrows and the arrow $a\to b$.
• For vertices take vector spaces. For arrows, take linear maps. This is a category, the identity arrow is just the identity map f(x) = x and composition is just function composition.
• For vertices take finite sets. For arrows, take functions.
• For vertices take logical propositions. For arrows take proofs in propositional logic. The identity arrow is the empty proof: P proves P without an actual proof. And if you can prove P using Q and then R using P, then this composes to a proof of R using Q.
• For vertices, take data types. For arrows take (computable) functions. This forms a category, in which we can discuss an abstraction that mirrors most of Haskell. There are issues making Haskell not quite a category on its own, but we get close enough to draw helpful conclusions and analogies.
• Suppose P is a set equipped with a partial ordering relation <. Then we can form a category out of this set with elements for vertices and with a single element in [v,w] if and only if v<w. Then the transitivity and reflexivity of partial orderings show that this forms a category.

Some language we want settled:

A category is concrete if it is like the vector spaces and the sets among the examples - the collection of all sets-with-specific-additional-structure equipped with all functions-respecting-that-structure. We require already that [v,w] is always a set.

A category is small if the collection of all vertices, too, is a set.
{"extraction_info": {"found_math": true, "script_math_tex": 0, "script_math_asciimath": 0, "math_annotations": 0, "math_alttext": 0, "mathml": 0, "mathjax_tag": 0, "mathjax_inline_tex": 0, "mathjax_display_tex": 0, "mathjax_asciimath": 0, "img_math": 10, "codecogs_latex": 0, "wp_latex": 0, "mimetex.cgi": 0, "/images/math/codecogs": 0, "mathtex.cgi": 0}, "config": {"markdown_headings": true, "markdown_code": true, "boilerplate_config": {"ratio_threshold": 0.18, "absolute_threshold": 10, "end_threshold": 15, "enable": true}, "remove_buttons": true, "remove_image_figures": true, "remove_link_clusters": true, "table_config": {"min_rows": 2, "min_cols": 3, "format": "github"}, "remove_chinese": true, "remove_edit_buttons": true, "extract_latex": true}, "english_confidence": 0.8942943215370178, "perplexity_flag": "middle"}