Category Theory with Adjunctions and Limits

Transcription

1 Category Theory with Adjunctions and Limits Eugene W. Stark Department of Computer Science Stony Brook University Stony Brook, New York USA October 10, 2017 Abstract This article attempts to develop a usable framework for doing category theory in Isabelle/HOL. Our point of view, which to some extent differs from that of the previous AFP articles on the subject, is to try to explore how category theory can be done efficaciously within HOL, rather than trying to match exactly the way things are done using a traditional approach. To this end, we define the notion of category in an object-free style, in which a category is represented by a single partial composition operation on arrows. This way of defining categories provides some advantages in the context of HOL, including the ability to avoid the use of records and the possibility of defining functors and natural transformations simply as certain functions on arrows, rather than as composite objects. We define various constructions associated with the basic notions, including: dual category, product category, functor category, discrete category, free category, functor composition, and horizontal and vertical composite of natural transformations. A set category locale is defined that axiomatizes the notion category of all sets at a type and all functions between them, and a fairly extensive set of properties of set categories is derived from the locale assumptions. The notion of a set category is used to prove the Yoneda Lemma in a general setting of a category equipped with a hom embedding, which maps arrows of the category to the universe of the set category. We also give a treatment of adjunctions, defining adjunctions via left and right adjoint functors, natural bijections between hom-sets, and unit and counit natural transformations, and showing the equivalence of these definitions. We also develop the theory of limits, including representations of functors, diagrams and cones, and diagonal functors. We show that right adjoint functors preserve limits, and that limits can be constructed via products and equalizers. We characterize the conditions under which limits exist in a set category. We also examine the case of limits in a functor category, ultimately culminating in a that the Yoneda embedding preserves limits. 1

2 Contents 1 Introduction 5 2 Category Partial Magmas Categories Classical Categories AbstractedCategory 25 4 FreeCategory Graphs Free Categories Discrete Categories Quivers Parallel Pairs DiscreteCategory 51 6 DualCategory 54 7 EpiMonoIso 57 8 InitialTerminal 69 9 Functor SetCategory Some Lemmas about Restriction Set Categories Categoricity Further Properties of Set Categories Initial Object Identity Arrows Inclusions Image Factorization

3 Points and Terminal Objects The Determines Same Function Relation on Arrows Retractions, Sections, and Isomorphisms Monomorphisms and Epimorphisms Concrete Set Categories SetCat ProductCategory NaturalTransformation Definition of a Natural Transformation Components of a Natural Transformation Functors as Natural Transformations Constant Natural Transformations Vertical Composition Natural Isomorphisms Horizontal Composition BinaryFunctor FunctorCategory Construction Additional Properties Evaluation Functor Currying Yoneda Hom-Functors Yoneda Functors Adjunction Left Adjoint Functor Right Adjoint Functor Various Definitions of Adjunction Meta-Adjunction Hom-Adjunction Unit/Counit Adjunction Adjunction Meta-Adjunctions Induce Unit/Counit Adjunctions Meta-Adjunctions Induce Left and Right Adjoint Functors Unit/Counit Adjunctions Induce Meta-Adjunctions Left and Right Adjoint Functors Induce Meta-Adjunctions Meta-Adjunctions Induce Hom-Adjunctions Hom-Adjunctions Induce Meta-Adjunctions

4 17.10Putting it All Together Composition of Adjunctions Right Adjoints are Unique up to Natural Isomorphism Limit Representations of Functors Diagrams and Cones Limits Limit Cones Limits by Representation Putting it all Together Limit Cones Induce Limit Situations Representations of the Cones Functor Induce Limit Situations Categories with Limits Diagonal Functors Right Adjoint Functors Preserve Limits Special Kinds of Limits Terminal Objects Products Equalizers Limits by Products and Equalizers Limits in a Set Category Limits in Functor Categories The Yoneda Functor Preserves Limits Subcategory Full Subcategory Inclusion Functor Equivalence of Categories 416 4

5 Chapter 1 Introduction This article attempts to develop a usable framework for doing category theory in Isabelle/HOL. Perhaps the main issue that one faces in doing this is how best to represent what is essentially a theory of a partially defined operation (composition) in HOL, which is a theory of total functions. The fact that in HOL every function is total means that a value must be given for the composition of any pair of arrows of a category, even if those arrows are not really composable. Proofs must constantly concern themselves with whether or not a particular term does or does not denote an arrow, and whether particular pairs of arrows are or are not composable. This kind of issue crops up in the most basic situations, such as trying to use associativity of composition to prove that two arrows are equal. Without some sort of systematic way of dealing with this issue, it is hard to do s of interesting results, because one is constantly distracted from the main line of reasoning by the necessity of proving lemmas that show that various expressions denote well-defined arrows, that various pairs of arrows are composable, etc. In trying to develop category theory in this setting, one notices fairly soon that some of the problem can be solved by creating introduction rules that allow the assistant to automatically infer, say, that a given term denotes an arrow with a particular domain and codomain from similar properties of its proper subterms. This upward reasoning helps, but it goes only so far. Eventually one faces a situation in which it is desired to prove theorems whose hypotheses state that certain terms denote arrows with particular domains and codomains, but the requires similar lemmas about the proper subterms. Without some way of doing this downward reasoning, it becomes very tedious to establish the necessary lemmas. Another issue that one faces when trying to formulate category theory within HOL is the lack of the set-theoretic universe that is usually assumed in traditional developments. Since there is no type of all sets in HOL, one cannot construct the category Set of all sets and functions between them. Instead, the best one can do is consider a category of all sets and functions at a particular type. Although the lack of set-theoretic universe would likely cause complications for some applications of category theory, there are many applications for which the lack of a universe is not really a hindrance. So one might well adopt a point of view that accepts a priori the lack of a universe and asks 5

6 instead how much of traditional category theory could be done in such a setting. There have been two previous category theory submissions to the AFP. The first [5] is an exploratory work that develops just enough category theory to enable the statement and of a version of the Yoneda Lemma. The main features are: the use of records to define categories and functors, construction of a category of all subsets of a given set, where the arrows are domain set/codomain set/function triples, and the use of the category of all sets of elements of the arrow type of category C as the target for the Yoneda functor for C. The second category theory submission to the AFP [2] is somewhat more extensive in its scope, and tries to match more closely a traditional development of category theory through the use of a set-theoretic universe obtained by an axiomatic extension of HOL. Categories, functors, and natural transformations are defined as multicomponent records, similarly to [5]. The category of sets is defined, having as its object and arrow type the type ZF, which is the axiomatically defined set-theoretic universe. Included in [2] is a more extensive development of natural transformations, vertical composition, and functor categories than is to be found in [5]. However, as in [5], the main purely category-theoretic result in [2] is the Yoneda Lemma. Beyond the use of extensional functions, which take on a particular default value outside of their domains of definition, neither [5] nor [2] explicitly describe a systematic approach to the problem of obtaining lemmas that establish when the various terms appearing in a denote well-defined arrows. The present development differs in a number of respects from that of [5] and [2], both in style and scope. The main stylistic features of the present development are as follows: The notion of a category is defined in an object-free style, motivated by [1], Sec , in which a category is represented by a single partial composition operation on arrows. This way of defining categories provides some advantages in the context of HOL, including the possibility of avoiding extensive use of composite objects constructed using records. (Katovsky seemed to have had some similar ideas, since he refers in [3] to a theory PartialBinaryAlgebra that was also motivated by [1], although this theory did not ultimately become part of his AFP article.) Functors and natural transformation are defined simply to be certain functions on arrows, where locale predicates are used to express the conditions that must be satisfied. This makes it possible to define functors and natural transformations easily using lambda notation without records. Rules for reasoning about categories, functors, and natural transformations are defined so that all diagrammatic hypotheses reduce to conjunctions of assertions, each of which states that a given entity is an arrow, has a particular domain, or has a particular codomain. A system of introduction and elimination rules is established which permits both upward reasoning, in which such diagrammatic assertions are established for larger terms using corresponding assertions about the proper subterms, as well as downward reasoning, in which diagrammatic assertions about proper subterms are inferred from such assertions about a larger term, to be carried out automatically. 6

7 Constructions on categories, functors, and natural transformations are defined using locales in a formulaic fashion. As an example, the product category construction is defined using a locale that takes two categories (given by their partial composition operations) as parameters. The partial composition operation for the product category is given by a function comp defined in the locale. Lemmas proved within the locale include the fact that comp indeed defines a category, as well as characterizations of the basic notions (domain, codomain, identities, composition) in terms of those of the parameter categories. For some constructions, such as the product category, it is possible and convenient to have a transparent arrow type, which permits reasoning about the construction without having to introduce an elaborate system of constructors, destructors, and associated rules. For other constructions, such as the functor category, it is more desirable to use an opaque arrow type that hides the concrete structure, and forces all reasoning to take place using a fixed set of rules. Rather than commit to a specific concrete construction of a category of sets and functions a set category locale is defined which axiomatizes the properties of the category of sets with elements at a particular type and functions between such. In keeping with the definitional approach, the axiomatization is shown consistent by exhibiting a particular interpretation for the locale, however care is taken to to ensure that any s making use of the interpretation depend only on the locale assumptions and not on the concrete details of the construction. The set category axioms are also shown to be categorical, in the sense that a bijection between the sets of terminal objects of two interpretations of the locale extends to an isomorphism of categories. This supports the idea that the locale axioms are an adequate characterization of the properties of a category of sets and functions and the details of a particular concrete construction can be kept hidden. A brief synopsis of the formal mathematical content of the present development is as follows: Definitions are given for the notions: category, functor, and natural transformation. Several constructions on categories are given, including: free category, discrete category, dual category, product category, and functor category. Composite functor, horizontal and vertical composite of natural transformations are defined, and various properties proved. The notion of a set category is defined and a fairly extensive development of the consequences of the definition is carried out. Hom-functors and Yoneda functors are defined and the Yoneda Lemma is proved. Adjunctions are defined in several ways, including universal arrows, natural isomorphisms between hom-sets, and unit and counit natural transformations. The relationships between the definitions are established. 7

8 The theory of limits is developed, including the notions of diagram, cone, limit cone, representable functors, products, and equalizers. It is proved that a category with products at a particular index type has limits of all diagrams at that type. The completeness properties of a set category are established. Limits in functor categories are explored, culminating in a that the Yoneda embedding preserves limits. One thing that is not done in the current development is to introduce any special syntax. There are a few reasons for this. First of all, I haven t found the lack of special syntax to be a significant hindrance to creating the formal development. Second, I wanted to be sure that any syntax that I did introduce would actually make the development easier to read and write, rather than more difficult. (I tended to find, for example, that the proliferation of special syntax introduced in [2] made the presentation seem less readily accessible than if the syntax had been omitted.) Third, it is easier to introduce syntax judiciously and incrementally at a later date than it is to remove or change syntax that was introduced prematurely. 8

9 Chapter 2 Category theory Category imports Main HOL Library.FuncSet begin This theory develops an object-free definition of category loosely following [1], Sec We define the notion category in terms of axioms that concern a single partial binary operation on a type, some of whose elements are to be regarded as the arrows of the category. The nonstandard definition of category has some advantages and disadvantages. An advantage is that only one piece of data (the composition operation) is required to specify a category, so the use of records is not required to bundle up several separate objects. A related advantage is the fact that functors and natural transformations can be defined simply to be functions that satisfy certain axioms, rather than more complex composite objects. One disadvantage is that the notions of object and identity arrow are conflated, though this is easy to get used to. Perhaps a more significant disadvantage is that each arrow of a category must carry along the information about its domain and codomain. This implies, for example, that the arrows of a category of sets and functions cannot be directly identified with functions, but rather only with functions that have been equipped with their domain and codomain sets. To represent the partiality of the composition operation of a category, we assume that the composition for a category has a unique zero element, which we call null, and we consider arrows to be composable if and only if their composite is non-null. Functors and natural transformations are required to map arrows to arrows and be extensional in the sense that they map non-arrows to null. This is so that equality of functors and natural transformations coincides with their extensional equality as functions in HOL. The fact that we co-opt an element of the arrow type to serve as null means that it is not possible to define a category whose arrows exhaust the elements of a given type. This presents a disadvantage in some situations. For example, we cannot construct a discrete category whose arrows are directly identified with the set of all elements of a given type a; instead, we must pass to a larger type (such as a option) so that there is an element available for use as null. The presence of null, however, is crucial to our being able to 9

10 define a system of introduction and elimination rules that can be applied automatically to establish that a given expression denotes an arrow. Without null, we would be able to define an introduction rule to infer, say, that the composition of composable arrows is composable, but not an elimination rule to infer that arrows are composable from the fact that their composite is an arrow. Having the ability to do both is critical to the usability of the theory. 2.1 Partial Magmas A partial magma is a partial binary operation C defined on the set of elements at a type a. As discussed above, we assume the existence of a unique element null of type a that is a zero for C, and we use null to represent undefined. We think of the operation C as an operation of composition, and we regard elements f and g of type a as composable if C g f null. type-synonym a comp = a a a locale partial-magma = fixes C :: a comp assumes ex-un-null:!n. f. C n f = n C f n = n begin definition null :: a where null = (THE n. f. C n f = n C f n = n) lemma nulli : assumes f. C n f = n C f n = n shows n = null using assms null-def ex-un-null the1-equality [of λn. f. C n f = n C f n = n] by auto lemma comp-null: shows C null f = null and C f null = null using null-def ex-un-null thei [of λn. f. C n f = n C f n = n] by auto A unit is an element a such that composition of any other element f with a on either the left or the right results in f whenever the composition is defined. definition unit :: a bool where unit a ( f. (C a f null C a f = f ) (C f a null C f a = f )) lemma uniti : assumes f. C a f null = C a f = f and f. C f a null = C f a = f shows unit a using assms unit-def by auto A domain of an element f is a unit a for which composition of f with a on the right is 10

11 defined. We say that f has a domain if a domain a for f exists. The notions of codomain and has a codomain are defined similarly, using composition on the left. Note that, although these definitions are completely dual, the choice of terminology implies that we will think of composition as being written in traditional order, as opposed to diagram order. It is pretty much essential to do it this way, to maintain compatibility with the notation for function application once we start working with functors and natural transformations. definition has-dom where has-dom f ( a. unit a C f a null) definition has-cod where has-cod f ( b. unit b C b f null) lemma has-domi : assumes unit a C f a null shows has-dom f using assms has-dom-def by blast lemma has-codi : assumes unit b C b f null shows has-cod f using assms has-cod-def by blast An element f is an arrow if either it has a domain or it has a codomain. In an arbitrary partial magma it is possible for f to have one but not the other, but the category locale will include assumptions to rule this out. definition arr :: a bool where arr f has-dom f has-cod f lemma arri : assumes has-dom f has-cod f shows arr f using assms arr-def by simp lemma not-arr-null: shows arr null by (simp add: arr-def has-dom-def comp-null(1 ) comp-null(2 ) has-cod-def ) end 2.2 Categories A category is defined to be a partial magma whose composition satisfies an associativity condition and in which every arrow has both a domain and a codomain. The associativity condition involves four matching conditions (match-1, match-2, match-3, and match-4 ) which constrain the domain of definition of the composition, and a fifth condition (comp-assoc ) which states that the results of the two ways of composing three 11

12 elements are equal. In the presence of the comp-assoc axiom match-4 can be derived from match-3 and vice versa, however we retain all four conditions so that the set of axioms is self-dual, which is sometimes useful. The name comp-assoc is primed because we later introduce a variant form comp-assoc which is more convenient to use in practice but less convenient when establishing interpretations. locale category = partial-magma C for C :: a comp + assumes match-1 : [ C h g null; C (C h g) f null ] = C g f null and match-2 : [ C h (C g f ) null; C g f null ] = C h g null and match-3 : [ C g f null; C h g null ] = C (C h g) f null and match-4 : [ C g f null; C h g null ] = C h (C g f ) null and comp-assoc : [ C g f null; C h g null ] = C h (C g f ) = C (C h g) f and has-dom-iff-has-cod: has-dom f has-cod f begin lemma dom-unique: assumes unit a and C f a null and unit a and C f a null shows a = a using assms unit-def match-1 by metis lemma cod-unique: assumes unit b and C b f null and unit b and C b f null shows b = b using assms unit-def match-2 by metis definition dom where dom f = (if has-dom f then (SOME a. unit a C f a null) else null) definition cod where cod f = (if has-cod f then (SOME b. unit b C b f null) else null) lemma has-domd: assumes has-dom f shows arr f and unit (dom f ) and C f (dom f ) = f from assms obtain a where A: unit a C f a null using has-dom-def by blast have F : unit (dom f ) C f (dom f ) null using assms dom-def has-dom-def somei-ex [of λa. unit a C f a null] by auto show arr f using A by (simp add: arr-def assms) show unit (dom f ) using A F by simp show C f (dom f ) = f using A F unit-def by blast lemma has-codd: assumes has-cod f shows arr f and unit (cod f ) and C (cod f ) f = f from assms obtain b where B: unit b C b f null using has-cod-def by blast 12

13 have F : unit (cod f ) C (cod f ) f null using assms cod-def has-cod-def somei-ex [of λb. unit b C b f null] by auto show arr f using B by (simp add: arr-def assms) show unit (cod f ) using B F by simp show C (cod f ) f = f using B F unit-def by blast lemma dom-simp: assumes unit a and C f a null shows dom f = a have 1 : arr f using assms by (simp add: has-domd(1 ) has-domi ) hence unit (dom f ) C f (dom f ) null by (metis assms(1 ) assms(2 ) has-domi has-domd(2 ) has-domd(3 ) unit-def ) thus?thesis using assms dom-unique by blast lemma cod-simp: assumes unit b and C b f null shows cod f = b have 1 : arr f using assms by (simp add: has-codd(1 ) has-codi ) hence unit (cod f ) C (cod f ) f null by (metis assms(1 ) assms(2 ) has-codi has-codd(2 ) has-codd(3 ) unit-def ) thus?thesis using assms cod-unique by blast It is occasionally useful to have available the facts that the functions dom and cod preserve null. lemma dom-null: shows dom null = null using has-domd(1 ) dom-def not-arr-null by auto lemma cod-null: shows cod null = null using has-codd(1 ) cod-def not-arr-null by auto An identity is an arrow a that is its own domain and codomain. We will also refer to identities as objects. definition ide :: a bool where ide a (has-dom a has-cod a) dom a = a cod a = a lemma ided [simp]: assumes ide a shows arr a and dom a = a and cod a = a using assms arr-def ide-def by auto lemma idei-dom: 13

14 assumes arr a and dom a = a shows ide a using assms by (metis (no-types, lifting) has-dom-iff-has-cod cod-unique ide-def has-codd(2 ) has-codd(3 ) has-domd(2 ) has-domd(3 ) dom-def not-arr-null) lemma idei-cod: assumes arr a and cod a = a shows ide a using assms by (metis (no-types, lifting) has-dom-iff-has-cod dom-unique idei-dom cod-def has-codd(2 ) has-codd(3 ) has-domd(2 ) has-domd(3 ) not-arr-null) lemma ide-dom [simp]: assumes arr f shows ide (dom f ) using assms by (metis (no-types, lifting) cod-simp has-domd(2 ) has-domi arr-def has-domd(3 ) has-dom-iff-has-cod idei-cod match-1 not-arr-null) lemma ide-cod [simp]: assumes arr f shows ide (cod f ) using assms by (metis (no-types, lifting) arr-def cod-simp has-codd(2 ) has-codi has-codd(3 ) has-dom-iff-has-cod idei-cod match-2 not-arr-null) To obtain the only if direction in the next two results and in similar results later for composition and the application of functors and natural transformations, is the reason for assuming the existence of null as a special element of the arrow type, as opposed to, say, using option types to represent partiality. The presence of null allows us not only to make the upward inference that the domain of an arrow is again an arrow, but also to make the downward inference that if dom f is an arrow then so is f. Similarly, we will be able to infer not only that if f and g are composable arrows then C g f is an arrow, but also that if C g f is an arrow then f and g are composable arrows. These inferences allow most necessary facts about what terms denote arrows to be deduced automatically from minimal assumptions. Typically all that is required is to assume or establish that certain terms denote arrows in particular hom-sets at the point where those terms are first introduced, and then similar facts about related terms can be derived automatically. Without this feature, nearly every would involve many tedious additional steps to establish that each of the terms appearing in the (including all its subterms) in fact denote arrows. lemma arr-dom-iff-arr: shows arr (dom f ) arr f using arri ide-dom dom-def not-arr-null ided by force 14

15 lemma arr-cod-iff-arr: shows arr (cod f ) arr f using arri ide-cod cod-def not-arr-null ided by force lemma comp-arr-dom [simp]: assumes arr f shows C f (dom f ) = f using assms by (metis arr-dom-iff-arr has-domd(3 ) dom-def not-arr-null) lemma comp-cod-arr [simp]: assumes arr f shows C (cod f ) f = f using assms by (metis arr-cod-iff-arr cod-def has-codd(3 ) not-arr-null) lemma comp-arr-ide [simp]: assumes ide a and dom f = a shows C f a = f using assms has-domd(3 ) ided(1 ) dom-def not-arr-null by auto lemma comp-ide-arr [simp]: assumes ide b and cod f = b shows C b f = f using assms cod-def has-codd(3 ) ided(1 ) not-arr-null by auto lemma dom-dom: assumes arr f shows dom (dom f ) = dom f using assms ide-dom ided by blast lemma cod-cod: assumes arr f shows cod (cod f ) = cod f using assms ide-cod ided by blast lemma dom-cod: assumes arr f shows dom (cod f ) = cod f using assms ide-cod ided by blast lemma cod-dom: assumes arr f shows cod (dom f ) = dom f using assms ide-dom ided by blast lemma arr-comp [simp]: assumes arr f and arr g and cod f = dom g shows arr (C g f ) using assms match-3 by (metis (no-types, hide-lams) arri comp-cod-arr comp-arr-dom comp-null(2 ) ex-un-null 15

16 has-dom-def local.dom-def ) The following is another example of a crucial downward rule that would not be possible without a reserved null value. lemma arr-compd: assumes arr (C g f ) shows arr f and arr g and cod f = dom g show arr f using assms match-1 arr-def has-dom-iff-has-cod has-dom-def not-arr-null by metis show arr g using assms match-2 arr-def has-dom-iff-has-cod has-cod-def not-arr-null by metis show cod f = dom g using assms arr f arr g match-1 match-2 dom-simp cod-simp not-arr-null by (metis (no-types, lifting) comp-cod-arr has-dom-iff-has-cod arr-def has-codd(2 )) lemma dom-comp [simp]: assumes arr f and arr g and cod f = dom g shows dom (C g f ) = dom f have 0 : arr (C g f ) using assms by auto have 1 : arr (C f (dom f )) using assms comp-arr-dom by simp have unit (dom (C g f )) C (C g f ) (dom (C g f )) null using 0 has-dom-iff-has-cod has-domd by (metis (no-types, lifting) arr-dom-iff-arr dom-def not-arr-null) moreover have unit (dom f ) C (C g f ) (dom f ) null show unit (dom f ) using assms(1 ) has-domd has-dom-iff-has-cod by (metis ided(1 ) ide-dom dom-def not-arr-null) show C (C g f ) (dom f ) null have C g f = C g (C f (dom f )) using 0 comp-arr-dom by (simp add: assms(1 )) also have... = C (C g f ) (dom f ) using 0 1 comp-assoc not-arr-null by metis finally show?thesis using 0 not-arr-null by auto ultimately show?thesis using dom-unique by blast lemma cod-comp [simp]: assumes arr f and arr g and cod f = dom g shows cod (C g f ) = cod g have 0 : arr (C g f ) using assms arr-comp by blast have 1 : arr (C (cod g) g) using assms comp-cod-arr by simp 16

17 have unit (cod (C g f )) C (cod (C g f )) (C g f ) null using 0 has-dom-iff-has-cod has-codd by (metis (no-types, lifting) arr-cod-iff-arr cod-def not-arr-null) moreover have unit (cod g) C (cod g) (C g f ) null show unit (cod g) using assms(2 ) has-codd has-dom-iff-has-cod by (metis cod-def ided(1 ) ide-cod not-arr-null) show C (cod g) (C g f ) null have C g f = C (C (cod g) g) f using 0 comp-cod-arr by (simp add: assms(2 )) also have... = C (cod g) (C g f ) using 0 1 comp-assoc not-arr-null by metis finally show?thesis using 0 not-arr-null by auto ultimately show?thesis using cod-unique by blast lemma ide-comp-simp: assumes ide (C g f ) shows C g f = dom f using assms by (metis arr-compd(1 ) arr-compd(2 ) arr-compd(3 ) dom-comp ided(1 ) ided(2 )) Here we define some common configurations of arrows. These are all defined as abbreviations, because we want all diagrammatic assumptions in a theorem to reduce readily to a conjunction of assertions of the form arr f, dom f = X, or cod f = Y. abbreviation seq where seq g f arr f arr g cod f = dom g abbreviation endo where endo f arr f dom f = cod f abbreviation par where par f g arr f arr g dom f = dom g cod f = cod g abbreviation antipar where antipar f g arr f arr g dom f = cod g cod f = dom g abbreviation span where span f g arr f arr g dom f = dom g abbreviation cospan where cospan f g arr f arr g cod f = cod g The following form of associativity seems to work better in practical s than the version in the category locale assumptions, however it is inconvenient to establish when 17

18 proving an interpretation, because of the presence of dom and cod in the hypotheses. lemma comp-assoc [iff ]: assumes seq g f and seq h g shows C (C h g) f = C h (C g f ) have arr (C g f ) arr (C h g) arr f arr g arr h cod f = dom g cod g = dom h using assms(1 ) assms(2 ) by simp thus?thesis using assms comp-assoc not-arr-null by metis Diagrammatic assumptions required in s are often conveniently stated in terms of hom-sets. Note that f hom (dom f ) (cod f ) is equivalent to arr f, and that we can also use f hom a (cod f ) or f hom (dom f ) b when we don t have any other name for the codomain or domain of f. abbreviation hom where hom a b {f. arr f dom f = a cod f = b} lemma comp-in-hom: assumes arr f and arr g and cod f = dom g shows C g f hom (dom f ) (cod g) using assms by simp The intention below was to develop the basic results above without having any facts implicitly applied, and only then to set annotations for some of the facts. However, I found that if I did not annotate some of the facts as they were introduced, they did not get used automatically later on. This can be verified and/or debugged by removing the annotations above and seeing what breaks in theories that depend on this one. This behavior is mysterious and I don t know the reason for it. lemmas dom-dom cod-cod dom-cod cod-dom dom-comp cod-comp arr-comp comp-assoc ide-dom ide-cod comp-arr-dom comp-cod-arr comp-ide-arr comp-arr-ide ided not-arr-null comp-null [simp] lemmas ide-dom ide-cod ided [elim] lemmas has-domi has-codi idei-dom [intro] end 2.3 Classical Categories In this section we define a secondary axiomatization of categories, classical-category, which is a more traditional one, except that in view of the totality of functions in HOL we need to introduce predicates Obj and Arr that characterize the bona fide objects and arrows among the elements of their respective types. A category defined this way is not extensional, in the sense that there will in general be categories with the same sets of objects and arrows, such that Dom, Cod, Id, and Comp agree on these objects and arrows, but they do not necessarily agree on other values of the corresponding types. 18

19 We show below that an interpretation of the category induces an interpretation of the classical-category locale. Conversely, we show that if Obj, Arr, Dom, Cod, Id, and Comp comprise an interpretation of classical-category, then we can define from them a partial composition that interprets the category locale. Moreover, the predicate derived arr derived from this partial composition agrees with the originally given predicate Arr, the notions dom, cod, and comp derived from the partial composition agree with the originally given Dom, Cod, and Comp on arguments that satisfy arr, and the identities derived from the partial composition are in bijective correspondence with the elements that satisfy the originally given predicate Obj. In some cases, rather than defining a construction on categories directly in terms of the partial-composition-based axioms, it can be simpler to define the construction in classical terms in a convenient way, and then extract a partial composition via the construction given here. locale classical-category = fixes Obj :: obj bool and Arr :: arr bool and Dom :: arr obj and Cod :: arr obj and Id :: obj arr and Comp :: arr arr arr assumes Obj-Dom: Arr f = Obj (Dom f ) and Obj-Cod: Arr f = Obj (Cod f ) and Arr-Id [simp]: Obj a = Arr (Id a) and Dom-Id [simp]: Obj a = Dom (Id a) = a and Cod-Id [simp]: Obj a = Cod (Id a) = a and Arr-Comp [simp]: [ Arr f ; Arr g; Cod f = Dom g ] = Arr (Comp g f ) and Comp-assoc [simp]: [ Arr f ; Arr g; Arr h; Cod f = Dom g; Cod g = Dom h ] = Comp (Comp h g) f = Comp h (Comp g f ) and Dom-Comp [simp]: [ Arr f ; Arr g; Cod f = Dom g ] = Dom (Comp g f ) = Dom f and Cod-Comp [simp]: [ Arr f ; Arr g; Cod f = Dom g ] = Cod (Comp g f ) = Cod g and Comp-Arr-Id-Dom [simp]: Arr f = Comp f (Id (Dom f )) = f and Comp-Id-Cod-Arr [simp]: Arr f = Comp (Id (Cod f )) f = f begin abbreviation Seq where Seq g f (Arr f Arr g Cod f = Dom g) Because Arr might be the universal predicate for type arr, it is necessary to pass to type arr option in order to have a value available to serve as null. definition comp :: arr option arr option arr option where comp g f = (if f None g None Seq (the g) (the f ) then Some (Comp (the g) (the f )) else None) interpretation C : partial-magma comp show!n. f. comp n f = n comp f n = n 19

20 show f. comp None f = None comp f None = None using comp-def by auto show n. f. comp n f = n comp f n = n = n = None by (metis comp-def ) lemma null-char: shows C.null = None let?p = λn. f. comp n f = n comp f n = n have?p None using comp-def by auto hence (THE n.?p n) = None using C.ex-un-null the1-equality [of?p] by simp thus?thesis using C.null-def by auto It is typically not necessary to exactly characterize the units for a partial composition in order to establish that it defines a category; often it is sufficient simply to show that there are enough units. That is the case here. lemma unit-some-id: assumes Obj A shows C.unit (Some (Id A)) have f. comp f (Some (Id A)) C.null = comp f (Some (Id A)) = f fix f assume f : comp f (Some (Id A)) C.null hence 1 : f = Some (the f ) Seq (the f ) (Id A) using null-char comp-def by (metis option.collapse option.sel) hence Comp (the f ) (Id A) = the f by (simp add: assms) thus comp f (Some (Id A)) = f using f 1 comp-def by simp moreover have f. comp (Some (Id A)) f C.null = comp (Some (Id A)) f = f fix f assume f : comp (Some (Id A)) f C.null hence 1 : f = Some (the f ) Seq (Id A) (the f ) using null-char comp-def by (metis option.collapse option.sel) hence Comp (Id A) (the f ) = the f using assms by auto thus comp (Some (Id A)) f = f using f 1 comp-def by simp ultimately show?thesis using C.unit-def null-char by auto lemma arr-char: shows C.arr f f None Arr (the f ) assume f : C.arr f 20

21 have 1 : f None using f null-char by (metis C.arr-def C.has-cod-def C.has-dom-def comp-def ) then have Arr (the f ) using f by (metis C.arr-def C.has-cod-def C.has-dom-def local.comp-def null-char) with 1 show f None Arr (the f ) by auto next assume f : f None Arr (the f ) have Seq (the f ) (Id (Dom (the f ))) using f Obj-Dom by simp hence comp f (Some (Id (Dom (the f )))) None using f comp-def by auto moreover have C.unit (Some (Id (Dom (the f )))) using f unit-some-id by (simp add: Obj-Dom) ultimately have C.has-dom f using C.has-dom-def null-char by auto thus C.arr f by (simp add: C.arr-def ) lemma comp-simp: assumes comp g f C.null shows comp g f = Some (Comp (the g) (the f )) have f None g None Seq (the g) (the f ) using assms null-char comp-def by metis thus comp g f = Some (Comp (the g) (the f )) using comp-def by auto interpretation C : category comp fix f g h assume gf : comp g f C.null and hgf : comp h (comp g f ) C.null show comp h g C.null using gf hgf Cod-Comp comp-simp comp-def null-char by (metis option.distinct(1 ) option.sel) next fix f g h assume hgf : comp (comp h g) f C.null and hg: comp h g C.null show comp g f C.null using hgf hg Dom-Comp comp-simp comp-def null-char by (metis option.distinct(1 ) option.sel) next fix f g h assume gf : comp g f C.null and hg: comp h g C.null show comp h (comp g f ) C.null using gf hg comp-simp comp-def null-char Arr-Comp Cod-Comp by (metis option.distinct(1 ) option.sel) show comp (comp h g) f C.null using gf hg comp-simp comp-def null-char Arr-Comp Dom-Comp by (metis option.distinct(1 ) option.sel) next 21

22 g)) fix f show C.has-dom f C.has-cod f unfolding C.has-dom-def C.has-cod-def using arr-char null-char Arr-Id Dom-Id Cod-Id Obj-Dom Obj-Cod unit-some-id comp-def by (metis option.distinct(1 ) option.sel) next fix f g h assume gf : comp g f C.null and hg: comp h g C.null show comp h (comp g f ) = comp (comp h g) f have 1 : f = Some (the f ) g = Some (the g) Seq (the g) (the f ) comp g f = Some (Comp (the g) (the f )) using gf comp-simp arr-char null-char comp-def by (metis option.collapse) have 2 : h = Some (the h) Seq (the h) (the g) comp h g = Some (Comp (the h) (the using 1 hg comp-simp arr-char null-char comp-def by (metis option.collapse) show?thesis using 1 2 Comp-assoc null-char comp-def Arr-Comp Cod-Comp Dom-Comp by simp theorem induces-category: shows category comp.. The arrows of the classical category are in bijective correspondence with the arrows of the category defined by comp, and the originally given Dom, Cod, and Comp coincide along this bijection with C.dom, C.cod, and comp. lemma bij-betw-arr-arr: shows bij-betw Some (Collect Arr) (Collect C.arr) (intro bij-betwi ) show Some Collect Arr Collect C.arr using arr-char by auto show the Collect C.arr Collect Arr using arr-char by auto show x. x Collect Arr = the (Some x) = x by auto show y. y Collect C.arr = Some (the y) = y using arr-char by auto lemma dom-char: shows C.dom f = (if C.arr f then Some (Id (Dom (the f ))) else None) (cases C.arr f ) assume f : C.arr f hence C.dom f = Some (Id (Dom (the f ))) using unit-some-id by (simp add: Obj-Dom arr-char comp-def null-char C.dom-simp) thus?thesis using f by auto next assume C.arr f thus?thesis using C.dom-def null-char C.arrI by auto 22

23 lemma cod-char: shows C.cod f = (if C.arr f then Some (Id (Cod (the f ))) else None) (cases C.arr f ) assume f : C.arr f hence C.cod f = Some (Id (Cod (the f ))) by (metis C.comp-cod-arr C.dom-cod arr-char comp-def dom-char) thus?thesis using f by auto next assume C.arr f thus?thesis using C.cod-def null-char C.arrI by auto lemma comp-char: shows comp g f = (if f None g None Seq (the g) (the f ) then Some (Comp (the g) (the f )) else None) using comp-def by simp The objects of the classical category are in bijective correspondence with the identities of the category defined by comp. lemma ide-char: shows C.ide a Arr (the a) a = Some (Id (Dom (the a))) assume a: C.ide a have 1 : C.arr a using a C.ideD by blast hence a None Arr (the a) using arr-char by auto moreover have a = Some (Id (Dom (the a))) using a 1 dom-char using C.ideD(2 ) by auto ultimately show Arr (the a) a = Some (Id (Dom (the a))) by auto next assume a: Arr (the a) a = Some (Id (Dom (the a))) show C.ide a using a arr-char dom-char C.ideI-dom by force lemma bij-betw-obj-ide: shows bij-betw (Some o Id) (Collect Obj ) (Collect C.ide) (intro bij-betwi ) show Some o Id Collect Obj Collect C.ide by (simp add: ide-char) show Dom o the Collect C.ide Collect Obj by (simp add: Obj-Dom ide-char) fix x assume x: x Collect Obj show (Dom o the) ((Some o Id) x) = x using x by simp next fix y assume y: y Collect C.ide show (Some o Id) ((Dom o the) y) = y 23

24 using y using C.ideD(1 ) C.ideD(2 ) dom-char by auto end sublocale classical-category category comp using induces-category by auto A category defined using the nonstandard, partial-composition-based axiomatization admits an interpretation of the classical axioms, and the composition derived from this interpretation coincides with the originally given one. context category begin theorem is-classical-category: shows classical-category ide arr dom cod dom C apply unfold-locales by auto interpretation CC : classical-category ide arr dom cod dom C using is-classical-category by auto In the next result we do not achieve exact agreement, because C might give non-null, non-arrow results for uncomposable arguments, whereas CC.comp by definition always returns null in such cases. This could be avoided by adding to the category locale the assumption CC.Seq f g = C f g = null, but there seems to be little point in doing so, as it would add an additional obligation every time a category is constructed. lemma C-equals-CC-comp: assumes seq g f shows C g f = the (CC.comp (Some g) (Some f )) using assms CC.comp-def by auto end end 24

25 Chapter 3 AbstractedCategory theory AbstractedCategory imports Category begin The locale defined here allows us to lift a category to a different arrow type via an abstraction map. It is used to obtain categories with opaque arrow types, by first defining the category on the concrete representation type, then lifting the composition to the abstract type. I apply this technique in several places to avoid the possibility of contaminating theories with specific details about a particular construction on categories. The construction of functor categories is a good example of this. locale abstracted-category = C : category C for C :: c comp and A :: c a and R :: a c and S :: c set + assumes abs-rep: A (R f ) = f and rep-abs: x S = R (A x) = x and rep-in-domain: R f S and domain-closed: C.arr x x = C.null = x S begin definition comp where comp g f if C.seq (R g) (R f ) then A (C (R g) (R f )) else A C.null interpretation partial-magma comp show!n. f. comp n f = n comp f n = n show f. comp (A C.null) f = A C.null comp f (A C.null) = A C.null using comp-def rep-abs domain-closed by auto show n. f. comp n f = n comp f n = n = n = A C.null by (metis comp-def C.not-arr-null rep-abs domain-closed) 25

26 lemma null-char: shows null = A C.null by (metis C.not-arr-null abstracted-category.comp-def abstracted-category-axioms comp-null(2 ) domain-closed rep-abs) lemma ide-implies-unit-abs: shows C.ide f = unit (A f ) by (simp add: abs-rep domain-closed local.comp-def null-char rep-abs unit-def ) lemma has-dom-char : shows has-dom f C.has-dom (R f ) fix f show has-dom f C.has-dom (R f ) assume f : has-dom f show C.has-dom (R f ) using ide-implies-unit-abs f comp-def has-dom-def C.has-dom-def by (metis C.dom-def C.ideD(1 ) C.not-arr-null C.ide-dom comp-null(2 )) next assume f : C.has-dom (R f ) show has-dom f using ide-implies-unit-abs f comp-def has-dom-def C.has-dom-def by (metis C.arr-dom-iff-arr C.has-domD(1 ) C.has-domD(3 ) C.not-arr-null abstracted-category.domain-closed abstracted-category-axioms C.cod-dom C.ide-dom comp-null(2 ) rep-abs) lemma has-cod-char : shows has-cod f C.has-cod (R f ) fix f show has-cod f C.has-cod (R f ) assume f : has-cod f show C.has-cod (R f ) using ide-implies-unit-abs has-dom-char f comp-def has-cod-def C.has-cod-def by (metis C.category-axioms C.cod-def C.ideD(1 ) C.not-arr-null category.ide-cod null-char) next assume f : C.has-cod (R f ) show has-cod f (intro has-codi ) have unit (A (C.cod (R f ))) using ide-implies-unit-abs f C.arrI C.ide-cod by blast moreover have comp (A (C.cod (R f ))) f null 26

27 have C.seq (R (A (C.cod (R f )))) (R f ) using ide-implies-unit-abs f rep-abs by (simp add: C.arrI C.arr-cod-iff-arr C.dom-cod domain-closed) thus?thesis using ide-implies-unit-abs f comp-def by (metis C.arr-cod-iff-arr C.has-codD(3 ) C.not-arr-null domain-closed null-char rep-abs) ultimately show unit (A (C.cod (R f ))) comp (A (C.cod (R f ))) f null by auto lemma is-category: shows category comp using comp-def C.not-arr-null C.arr-comp C.dom-comp C.cod-comp comp-null(2 ) rep-abs apply (unfold-locales) apply (metis abstracted-category.domain-closed abstracted-category-axioms) apply (metis abstracted-category.domain-closed abstracted-category-axioms) apply (metis abstracted-category.domain-closed abstracted-category-axioms) apply (metis abstracted-category.domain-closed abstracted-category-axioms) show f. has-dom f = has-cod f using has-dom-char has-cod-char by (simp add: C.has-dom-iff-has-cod) show f g h. [ comp g f null; comp h g null ] = comp h (comp g f ) = comp (comp h g) f fix f g h assume gf : comp g f null assume hg: comp h g null have 1 : C.seq (R g) (R f ) C.seq (R h) (R g) using gf hg by (metis comp-def null-char) have 2 : C.seq (R h) (R (A (C (R g) (R f )))) C.seq (R (A (C (R h) (R g)))) (R f ) using 1 rep-abs C.arr-comp C.dom-comp C.cod-comp by (simp add: domain-closed) have comp h (comp g f ) = A (C (R h) (R (A (C (R g) (R f ))))) using 1 2 comp-def by simp also have... = A (C (R h) (C (R g) (R f ))) using 1 rep-abs domain-closed by simp also have... = A (C (C (R h) (R g)) (R f )) using 1 by simp also have... = A (C (R (A (C (R h) (R g)))) (R f )) using 1 rep-abs domain-closed by simp also have... = comp (comp h g) f using 1 2 comp-def by simp finally show comp h (comp g f ) = comp (comp h g) f by simp 27

28 end sublocale abstracted-category category comp using is-category by auto context abstracted-category begin lemma has-dom-char: shows has-dom f C.arr (R f ) using has-dom-char by (simp add: C.arr-def C.has-dom-iff-has-cod) lemma has-cod-char: shows has-cod f C.arr (R f ) using has-cod-char by (simp add: C.arr-def C.has-dom-iff-has-cod) lemma arr-char: shows arr f C.arr (R f ) using has-dom-char has-cod-char arr-def by simp lemma dom-char: shows dom f = (if arr f then A (C.dom (R f )) else null) have arr f = dom f = A (C.dom (R f )) assume f : arr f have unit (A (C.dom (R f ))) using f arr-char ide-implies-unit-abs by simp moreover have comp f (A (C.dom (R f ))) null using f arr-char comp-def null-char rep-abs by (metis C.arr-dom-iff-arr C.comp-arr-dom C.cod-dom not-arr-null abstracted-category.domain-closed abstracted-category-axioms) ultimately show dom f = A (C.dom (R f )) using f dom-simp by simp moreover have arr f = dom f = null by (simp add: arr-def dom-def ) ultimately show?thesis by auto lemma cod-char: shows cod f = (if arr f then A (C.cod (R f )) else null) have arr f = cod f = A (C.cod (R f )) assume f : arr f have unit (A (C.cod (R f ))) 28

29 using f arr-char ide-implies-unit-abs by simp moreover have comp (A (C.cod (R f ))) f null using f arr-char comp-def null-char rep-abs by (metis C.arr-cod-iff-arr C.comp-cod-arr C.dom-cod not-arr-null abstracted-category.domain-closed abstracted-category-axioms) ultimately show cod f = A (C.cod (R f )) using f cod-simp by simp moreover have arr f = cod f = null by (simp add: arr-def cod-def ) ultimately show?thesis by auto lemma ide-char: shows ide a C.ide (R a) using arr-char dom-char by (metis C.arr-dom-iff-arr C.ideD(1 ) C.ideD(2 ) C.ideI-dom abs-rep domain-closed ided(1 ) ided(2 ) idei-dom rep-abs) lemma comp-char: shows comp g f = (if seq g f then A (C (R g) (R f )) else null) using arr-char dom-char cod-char comp-def null-char arr-comp not-arr-null by metis end end 29