8.7.1 Naive van Kampen

8.7.1 Naive van Kampen

We begin with a “naive” version of the

van Kampen theorem

, which is useful but not quite as useful as the classical version.
In

\autoref

sec:better-vankampen we will improve it to a more useful version.

Given types

A

,

B

,

C

and

functions

f

:

A

→

B

and

g

:

A

→

C

, let

P

be their

pushout

B

⊔

A

C

.
As we saw in

\autoref

sec:

colimits

,

P

is the

higher inductive type

generated by

•

i

:

B

→

P

,

•

j

:

C

→

P

, and

•

for all

x

:

A

, a path

k

⁢

x

:

i

⁢

f

⁢

x

=

j

⁢

g

⁢

x

.

Define

𝖼𝗈𝖽𝖾

:

P

→

P

→

𝒰

by double

induction

on

P

as follows.

•

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

b

,

i

⁢

b

′

)

is a set-quotient (see

\autoref

sec:set-quotients) of the type of

sequences

(

b

,

p

0

,

x

1

,

q

1

,

y

1

,

p

1

,

x

2

,

q

2

,

y

2

,

p

2

,

…

,

y

n

,

p

n

,

b

′

)

where

–

n

:

ℕ

–

x

k

:

A

and

y

k

:

A

for

0

<

k

≤

n

–

p

0

:

Π

1

⁢

B

⁢

(

b

,

f

⁢

x

1

)

and

p

n

:

Π

1

⁢

B

⁢

(

f

⁢

y

n

,

b

′

)

for

n

>

0

, and

p

0

:

Π

1

⁢

B

⁢

(

b

,

b

′

)

for

n

=

0

–

p

k

:

Π

1

⁢

B

⁢

(

f

⁢

y

k

,

f

⁢

x

k

+

1

)

for

1

≤

k

<

n

–

q

k

:

Π

1

⁢

C

⁢

(

g

⁢

x

k

,

g

⁢

y

k

)

for

1

≤

k

≤

n

The

quotient

is generated by the following equalities:

(

…

,

q

k

,

y

k

,

𝗋𝖾𝖿𝗅

f

⁢

y

k

,

y

k

,

q

k

+

1

,

…

)

=

(

…

,

q

k

⁢

\centerdot

⁢

q

k

+

1

,

…

)

(

…

,

p

k

,

x

k

,

𝗋𝖾𝖿𝗅

g

⁢

x

k

,

x

k

,

p

k

+

1

,

…

)

=

(

…

,

p

k

⁢

\centerdot

⁢

p

k

+

1

,

…

)

(see

\autoref

rmk:naive below).
We leave it to the reader to define this type of sequences precisely as an inductive type.

•

𝖼𝗈𝖽𝖾

⁢

(

j

⁢

c

,

j

⁢

c

′

)

is identical, with the roles of

B

and

C

reversed.
We likewise notationally reverse the roles of

x

and

y

, and of

p

and

q

.

•

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

b

,

j

⁢

c

)

and

𝖼𝗈𝖽𝖾

⁢

(

j

⁢

c

,

i

⁢

b

)

are

similar

, with the parity changed so that they start in one type and end in the other.

•

For

a

:

A

and

b

:

B

, we require an

equivalence

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

b

,

i

⁢

f

⁢

a

)

≃

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

b

,

j

⁢

g

⁢

a

)

.

(8.7.1)

We define this to consist of the two functions defined on sequences by

(

…

,

y

n

,

p

n

,

f

⁢

a

)

↦

(

…

,

y

n

,

p

n

,

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

g

⁢

a

)

,

(

…

,

x

n

,

p

n

,

a

,

𝗋𝖾𝖿𝗅

f

⁢

a

,

f

⁢

a

)

\mapsfrom

⁢

(

…

,

x

n

,

p

n

,

g

⁢

a

)

.

Both of these functions are easily seen to respect the

equivalence relations

, and hence to define functions on the types of codes.
The left-to-right-to-left composite is

(

…

,

y

n

,

p

n

,

f

⁢

a

)

↦

(

…

,

y

n

,

p

n

,

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

a

,

𝗋𝖾𝖿𝗅

f

⁢

a

,

f

⁢

a

)

which is equal to the

identity

by a generating equality of the quotient.
The other composite is analogous.
Thus we have defined an equivalence (

8.7.1

).

•

Similarly, we require equivalences

𝖼𝗈𝖽𝖾

⁢

(

j

⁢

c

,

i

⁢

f

⁢

a

)

≃

𝖼𝗈𝖽𝖾

⁢

(

j

⁢

c

,

j

⁢

g

⁢

a

)

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

f

⁢

a

,

i

⁢

b

)

≃

(

j

⁢

g

⁢

a

,

i

⁢

b

)

𝖼𝗈𝖽𝖾

⁢

(

i

⁢

f

⁢

a

,

j

⁢

c

)

≃

(

j

⁢

g

⁢

a

,

j

⁢

c

)

all of which are defined in exactly the same way (the second two by adding

reflexivity

terms on the beginning rather than the end).

•

Finally, we need to know that for

a

,

a

′

:

A

, the following

diagram

commutes:

\xymatrix

𝖼𝗈𝖽𝖾

(ifa,ifa’)

\ar

[r]

\ar

[d] &

𝖼𝗈𝖽𝖾

(ifa,jga’)

\ar

[d]

𝖼𝗈𝖽𝖾

(jga,ifa’)

\ar

[r] &

𝖼𝗈𝖽𝖾

(jga,jga’)

(8.7.2)

This amounts to saying that if we add something to the beginning and then something to the end of a sequence, we might as well have done it in the other order.

Remark 8.7.3

.

One might expect to see in the

definition

of

code

some additional generating

equations

for the set-quotient, such as

(

…

,

p

k

-

1

⁢

\centerdot

⁢

f

⁢

w

,

x

k

′

,

q

k

,

…

)

=

(

…

,

p

k

-

1

,

x

k

,

g

⁢

w

⁢

\centerdot

⁢

q

k

,

…

)

(for $w:\Pi_{1}A(x_{k},x_{k}^{\prime})$)

(

…

,

q

k

⁢

\centerdot

⁢

g

⁢

w

,

y

k

′

,

p

k

,

…

)

=

(

…

,

q

k

,

y

k

,

f

⁢

w

⁢

\centerdot

⁢

p

k

,

…

)

.

(for $w:\Pi_{1}A(y_{k},y_{k}^{\prime})$)

However, these are not necessary!
In fact, they follow automatically by path induction on

w

.
This is the main

difference

between the “naive” van Kampen theorem and the more refined one we will consider in the next subsection.

Continuing on, we can characterize transporting in the

fibration

𝖼𝗈𝖽𝖾

:

•

For

p

:

b

=

B

b

′

and

u

:

P

, we have

𝗍𝗋𝖺𝗇𝗌𝗉𝗈𝗋𝗍

b

↦

𝖼𝗈𝖽𝖾

⁢

(

u

,

i

⁢

b

)

⁢

(

p

,

(

…

,

y

n

,

p

n

,

b

)

)

=

(

…

,

y

n

,

p

n

⁢

\centerdot

⁢

p

,

b

′

)

.

•

For

q

:

c

=

C

c

′

and

u

:

P

, we have

𝗍𝗋𝖺𝗇𝗌𝗉𝗈𝗋𝗍

c

↦

𝖼𝗈𝖽𝖾

⁢

(

u

,

j

⁢

c

)

⁢

(

q

,

(

…

,

x

n

,

q

n

,

c

)

)

=

(

…

,

x

n

,

q

n

⁢

\centerdot

⁢

q

,

c

′

)

.

Here we are abusing notation by using the same name for a path in

X

and its image in

Π

1

⁢

X

.
Note that transport in

Π

1

⁢

X

is also given by

concatenation

with (the image of) a path.
From this we can prove the above statements by induction on

u

.
We also have:

•

For

a

:

A

and

u

:

P

,

𝗍𝗋𝖺𝗇𝗌𝗉𝗈𝗋𝗍

v

↦

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

⁢

(

h

⁢

a

,

(

…

,

y

n

,

p

n

,

f

⁢

a

)

)

=

(

…

,

y

n

,

p

n

,

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

g

⁢

a

)

.

This follows essentially from the definition of

𝖼𝗈𝖽𝖾

.

We also

construct

a function

r

:

∏

u

:

P

𝖼𝗈𝖽𝖾

⁢

(

u

,

u

)

by induction on

u

as follows:

r

⁢

i

⁢

b

:

≡

(

b

,

𝗋𝖾𝖿𝗅

b

,

b

)

r

⁢

j

⁢

c

:

≡

(

c

,

𝗋𝖾𝖿𝗅

c

,

c

)

and for

r

⁢

k

⁢

a

we take the composite equality

(

k

⁢

a

,

k

⁢

a

)

*

⁢

(

f

⁢

a

,

𝗋𝖾𝖿𝗅

f

⁢

a

,

f

⁢

a

)

=

(

g

⁢

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

a

,

𝗋𝖾𝖿𝗅

f

⁢

a

,

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

g

⁢

a

)

=

(

g

⁢

a

,

𝗋𝖾𝖿𝗅

g

⁢

a

,

g

⁢

a

)

where the first equality is by the observation above about transporting in

𝖼𝗈𝖽𝖾

, and the second is an

instance

of the set quotient

relation

used to define

𝖼𝗈𝖽𝖾

.

We will now prove:

Theorem 8.7.4

(Naive van Kampen theorem).

For all

u

,

v

:

P

there is an equivalence

Π

1

⁢

P

⁢

(

u

,

v

)

≃

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

.

Proof.

To define a function

𝖾𝗇𝖼𝗈𝖽𝖾

:

Π

1

⁢

P

⁢

(

u

,

v

)

→

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

it suffices to define a function

(

u

=

P

v

)

→

𝖼𝗈𝖽𝖾

(

u

,

v

)

,
since

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

is a set.
We do this by transport:

𝖾𝗇𝖼𝗈𝖽𝖾

(

p

)

:

≡

𝗍𝗋𝖺𝗇𝗌𝗉𝗈𝗋𝗍

v

↦

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

(

p

,

r

(

u

)

)

.

Now to define

𝖽𝖾𝖼𝗈𝖽𝖾

:

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

→

Π

1

⁢

P

⁢

(

u

,

v

)

we proceed as usual by induction on

u

,

v

:

P

.
In each case for

u

and

v

, we apply

i

or

j

to all the equalities

p

k

and

q

k

as appropriate and concatenate the results in

P

, using

h

to identify the

endpoints

.
For instance, when

u

≡

i

⁢

b

and

v

≡

i

⁢

b

′

, we define

𝖽𝖾𝖼𝗈𝖽𝖾

(

b

,

p

0

,

x

1

,

q

1

,

y

1

,

p

1

,

…

,

y

n

,

p

n

,

b

′

)

:

≡

(

p

0

)

\centerdot

h

(

x

1

)

\centerdot

j

(

q

1

)

\centerdot

h

⁢

(

y

1

)

-

1

\centerdot

i

(

p

1

)

\centerdot

⋯

\centerdot

h

⁢

(

y

n

)

-

1

\centerdot

i

(

p

n

)

.

(8.7.5)

This respects the set-quotient equivalence relation and the equivalences such as (

8.7.1

), since

h

:

f

⁢

i

∼

g

⁢

j

is natural and

f

and

g

are functorial.

As usual, to show that the composite

Π

1

⁢

P

⁢

(

u

,

v

)

→

𝖾𝗇𝖼𝗈𝖽𝖾

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

→

𝖽𝖾𝖼𝗈𝖽𝖾

Π

1

⁢

P

⁢

(

u

,

v

)

is the identity, we first peel off the 0-truncation (since the codomain is a set) and then apply path induction.
The input

𝗋𝖾𝖿𝗅

u

goes to

r

⁢

u

, which then goes back to

𝗋𝖾𝖿𝗅

u

(applying a further induction on

u

to decompose

𝖽𝖾𝖼𝗈𝖽𝖾

⁢

(

r

⁢

u

)

).

Finally, consider the composite

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

→

𝖽𝖾𝖼𝗈𝖽𝖾

Π

1

⁢

P

⁢

(

u

,

v

)

→

𝖾𝗇𝖼𝗈𝖽𝖾

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

.

We proceed by induction on

u

,

v

:

P

.
When

u

≡

i

⁢

b

and

v

≡

i

⁢

b

′

, this composite is

(

b

,

p

0

,

x

1

,

q

1

,

y

1

,

p

1

,

…

,

y

n

,

p

n

,

b

′

)

⁢

↦

(

i

⁢

p

0

⁢

\centerdot

⁢

h

⁢

x

1

⁢

\centerdot

⁢

j

⁢

q

1

⁢

\centerdot

⁢

h

⁢

y

1

-

1

⁢

\centerdot

⁢

i

⁢

p

1

⁢

\centerdot

⁢

⋯

⁢

\centerdot

⁢

h

⁢

y

n

-

1

⁢

\centerdot

⁢

i

⁢

p

n

)

*

⁢

(

r

⁢

i

⁢

b

)

=

(

i

⁢

p

n

)

*

⁢

⋯

⁢

(

j

⁢

q

1

)

*

⁢

(

h

⁢

x

1

)

*

⁢

(

i

⁢

p

0

)

*

⁢

(

b

,

𝗋𝖾𝖿𝗅

b

,

b

)

=

(

i

⁢

p

n

)

*

⁢

⋯

⁢

(

j

⁢

q

1

)

*

⁢

(

h

⁢

x

1

)

*

⁢

(

b

,

p

0

,

i

⁢

f

⁢

x

1

)

=

(

i

⁢

p

n

)

*

⁢

⋯

⁢

(

j

⁢

q

1

)

*

⁢

(

b

,

p

0

,

x

1

,

𝗋𝖾𝖿𝗅

g

⁢

x

1

,

j

⁢

g

⁢

x

1

)

=

(

i

⁢

p

n

)

*

⁢

⋯

⁢

(

b

,

p

0

,

x

1

,

q

1

,

j

⁢

g

⁢

y

1

)

=

⋮

=

(

b

,

p

0

,

x

1

,

q

1

,

y

1

,

p

1

,

…

,

y

n

,

p

n

,

b

′

)

.

i.e., the

identity function

.
(To be precise, there is an implicit inductive

argument

needed here.)
The other three point cases are analogous, and the path cases are

trivial

since all the types are sets.
∎

\autoref

thm:naive-van-kampen allows us to calculate the

fundamental groups

of many types, provided

A

is a set,
for in that case, each

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

is, by definition, a set-quotient of a

set

by a relation.

Example 8.7.5

.

Let

A

:

≡

2

,

B

:

≡

1

, and

C

:

≡

1

.
Then

P

≃

S

1

.
Inspecting the definition of, say,

code

⁢

(

i

⁢

(

⋆

)

,

i

⁢

(

⋆

)

)

, we see that the paths all may as well be trivial, so the only information is in the sequence of

elements

x

1

,

y

1

,

…

,

x

n

,

y

n

:

2

.
Moreover, if we have

x

k

=

y

k

or

y

k

=

x

k

+

1

for any

k

, then the set-quotient relations allow us to excise both of those elements.
Thus, every such sequence is equal to a

canonical

reduced

one in which no two adjacent elements are equal.
Clearly such a reduced sequence is uniquely determined by its length (a

natural number

n

) together with, if

n

>

1

, the information of whether

x

1

is

0

2

or

1

2

, since that determines the rest of the sequence uniquely.
And these data can, of course, be identified with an integer, where

n

is the

absolute value

and

x

1

encodes the sign.
Thus we recover

π

1

⁢

(

S

1

)

≅

Z

.

Since

\autoref

thm:naive-van-kampen asserts only a

bijection

of families of sets, this

isomorphism

π

1

⁢

(

S

1

)

≅

ℤ

is likewise only a bijection of sets.
We could, however, define a concatenation

operation

on

𝖼𝗈𝖽𝖾

(by concatenating sequences) and show that

𝖾𝗇𝖼𝗈𝖽𝖾

and

𝖽𝖾𝖼𝗈𝖽𝖾

form an isomorphism respecting this

structure

.
(In the

language

of

\autoref

cha:category-theory, these would be “pregroupoids”.)
We leave the details to the reader.

Example 8.7.6

.

More generally, let

B

:

≡

1

and

C

:

≡

1

but

A

be arbitrary, so that

P

is the

suspension

of

A

.
Then once again the paths

p

k

and

q

k

are trivial, so that the only information in a path code is a sequence of elements

x

1

,

y

1

,

…

,

x

n

,

y

n

:

A

.
The first two generating equalities say that adjacent equal elements can be canceled, so it makes sense to think of this sequence as a word of the form

x

1

⁢

y

1

-

1

⁢

x

2

⁢

y

2

-

1

⁢

⋯

⁢

x

n

⁢

y

n

-

1

in a group.
Indeed, it looks similar to the

free group

on

A

(or equivalently on

∥

A

∥

0

; see

\autoref

thm:freegroup-nonset), but we are considering only words that start with a non-inverted element, alternate between inverted and non-inverted elements, and end with an inverted one.
This effectively reduces the size of the

generating set

by one.
For instance, if

A

has a point

a

:

A

, then we can identify

π

1

⁢

(

Σ

⁢

A

)

with the group presented by

∥

A

∥

0

as

generators

with the relation

|

a

|

0

=

e

; see

\autoref

ex:vksusppt,

\autoref

ex:vksuspnopt for details.

Example 8.7.7

.

Let

A

:

≡

1

and

B

and

C

be arbitrary, so that

f

and

g

simply equip

B

and

C

with

basepoints

b

and

c

, say.
Then

P

is the

wedge

B

∨

C

of

B

and

C

(the

coproduct

in the

category

of based spaces).
In this case, it is the elements

x

k

and

y

k

which are trivial, so that the only information is a sequence of loops

(

p

0

,

q

1

,

p

1

,

…

,

p

n

)

with

p

k

:

π

1

⁢

(

B

,

b

)

and

q

k

:

π

1

⁢

(

C

,

c

)

.
Such sequences, modulo the equivalence relation we have imposed, are easily identified with the explicit description of the

free product

of the groups

π

1

⁢

(

B

,

b

)

and

π

1

⁢

(

C

,

c

)

, as constructed in

\autoref

sec:free-algebras.
Thus, we have

π

1

⁢

(

B

∨

C

)

≅

π

1

⁢

(

B

)

*

π

1

⁢

(

C

)

.

However,

\autoref

thm:naive-van-kampen stops just short of being the full classical van Kampen theorem, which handles
the case where

A

is not necessarily a set,
and states that

π

1

⁢

(

B

⊔

A

C

)

≅

π

1

⁢

(

B

)

*

π

1

⁢

(

A

)

π

1

⁢

(

C

)

(with base point coming from

A

).
Indeed, the

conclusion

of

\autoref

thm:naive-van-kampen says nothing at all about

π

1

⁢

(

A

)

; the paths in

A

are “built into the quotienting” in a type-theoretic way that makes it hard to extract explicit information, in that

𝖼𝗈𝖽𝖾

⁢

(

u

,

v

)

is a set-quotient of a non-set by a relation.
For this reason, in the next subsection we consider a better version of the van Kampen theorem.

Title

8.7.1 Naive van Kampen

\metatable

Generated on Thu Feb 8 19:41:44 2018 by

LaTeXML