Finite Topology

On this page is information about software I am writing to run on the FriCAS computer algebra system.

I am not sure about using the terminology 'finite topology' or 'topology over a finite set', perhaps I should just say 'non-metric' but I want to distinguish this from 'simplicial complexes' which are implemented in FriCAS as discussed on page here.

My concern is that, although the topology is applied to a finite set, I think elements of the set may represent a possibly infinite number of points.

It seems to me that these finite structures can get very big (I wonder why infinite structures involve less data than finite structures?).

So I think it is unlikely that a user or programmer would want to label (that is a human readable non-numeric label) every point. I think its possible that they might need to label a few special points. For example points that need to be glued together or generate a quotient topology by specifying an equivalence class on an existing topology.

> This representation, is, of course, just a first thought. However, it is
> not just using integers, but can work over any type of elements.

I think the most important thing, from my point of view, is that these domains need to be generated and constructed in programs. That is a TopologicalSpace might need to be constructed from other TopologicalSpaces. So defining these things over Symbols or Strings seems like a problem. Or if two TopologicalSpaces were defined over different types (not just product) but combining them in many possible ways?

> I actually already think, whether it might be better to use as
> representation
>
>      Rep ==> Record(space: List T, opensets: Set Integer)
>
> and let the Integer in "opensets" function as a bitvector with respect
> to the elements in the list given by "space".

Using a bitvector is an interesting idea. How would it scale up to a lage number of points?

Or, since we are working with a subset of the power set, could we treat the power set as a lattice then represent the topology by a bit map on it.

How this is Coded

I have put my implementation so far here, but this is still a work on progress.

We need to represent topological spaces and the continuous maps between them.

Topological Spaces

The representation of a topological space requires two pieces of information:

A collection of points. A topology on those points, implemented as a collection of open sets.

The structure can be represented as a set of points for each open set.

Rep := Record(topSet : List S, topol : TopologyFinite)

Rep := Record(basis:Boolean,topology:List (Set NNI))

Each open set is coded as

Set NNI

So non negative integers are used as indexes into the list of points.

I did it this way because:

• We may not want to label each point, in which case we can just work in terms of the NNIs
• The topology is defined independently of the types of the points so the topology can be applied to a different set of points (provided there are the same number).
• Since NNI's have order, they can be sorted, may be more efficiently compared.

Example - Discrete Topology In this example there are 3 open sets denoted by the blue letters A, B and C. We define these open sets by elements they contain, here denoted by the red letters a, b, c, d, e, f and g. A := {a,d,e,g} B := {b,d,f,g} C := {c,e,f,g}

(1) -> ts2 := topoSpaceFiniteDiscrete(["A","B","C"]) $ TopoSpaceFinite Symbol

   (1)  [[A, B, C], topology=[{3}, {2}, {2, 3}, {1}, {1, 3}, {1, 2}]]
                                                Type: TopoSpaceFinite(Symbol)

All isomorphic topologies

In order to work with isomorphic classes of topologies instead of individual topologies I have used a similar algorithm with a different representation. Instead of sets of labelled open sets I have used unlabeled sets. So the only thing we know about the open sets is how many elements it contains. Unfortunately this looses information about the meets and joins so this needs to be put back in. This is done by representing the substructure and from this the meets and joins can be calculated.

Alexandrov Topology

Alexandrov Topology are also known as finitely generated spaces (topology is uniquely determined by the family of all finite subspaces). This makes them a generalization of finite topological spaces.

see https://en.wikipedia.org/wiki/Alexandrov_topology

Birkhoff's Representation Theorem

Birkhoff's representation theorem for distributive lattices states that the elements of any finite distributive lattice can be represented as finite sets, in such a way that the lattice operations correspond to unions and intersections of sets.

The theorem can be interpreted as providing a one-to-one correspondence between distributive lattices and partial orders, between quasi-ordinal knowledge spaces and preorders, or between finite topological spaces and preorders.

https://en.wikipedia.org/wiki/Birkhoff's_representation_theorem

Finding all Possible Topologies on a given Set

I have put some information about this on the page here.

Continuous Maps

An important reason for working with topological spaces is that they allow continuous maps to be defined. In their most general form, these continuous maps do not require metric spaces.

A continuous map takes points which are close to each other in the domain and maps them to points which are close to each other in the codomain. That is it preserves 'closeness' using a very general definition of 'closeness'. The mapping of points can be total and can be some combination of injective, surjective and bijective just like maps in set.

The mapping of points could also be partial f|a where we only consider points in a given open set. There is no requirement that points from a given openset map to a corresponding openset in the codomain.

However there is a requirement that open sets in the codomain correspond to opensets in the domain, that is, have a pre-image.

For instance, both open sets 'a' and 'b' can exist but only 'b' is required as pre-image.

This is equivalent to the points mapping in the forward direction and the open sets being mapped in the reverse direction. This is how we draw an adjunction, although this is more specific as it is a homotopy equivalence.

Product Topology

The product topology is the coarsest topology (that is, the topology with the fewest open sets) for which all the projections are continuous.

Quotient Topology

The quotient topology is the finest topology (that is, the topology with the most open sets) that makes continuous the canonical projection map (the function that maps points to their equivalence classes).

Nerve

EuclideanSpace

home

This page discusses my attempts to implement simplicial sets using the Axiom/FriCAS computer algebra system. For a discussion about the mathematics of simplicial sets see the page here.

This is part of a series of pages about implementing code for algebraic topology, these pages start here.

My code for this page is on github here.

Where Are You

This is one of a series of pages describing code that I have written for FriCAS.

)co fricas/topology.spad