Ologs: Semantic Restrictions on Arrows · learning: questions

Spivak says that an olog’s arrows convey “aspects” of a thing. An issue I have with this is that it is unclear if there is any way to distinguish between an “aspect” of a thing, and any other kind of semantic assertion about that thing. What is not an aspect?

Let’s consider restricting the arrows of an olog to a single kind of semantic relation, to see if it sheds light on if arrows should be semantically unrestricted (or if there should be different classes of arrows for different kinds of relations).

1. Arrows are Subtype Relations

dog —>|is| mammal
dog —>|is| animal
dog —>|is| thing
dog —>|is| pet
dog —>|is| organism
dog —>|is| species
dog —>|is| concept

And so on. This is the well-known idea that a category is equivalent to a poset.

2. Arrows are Properties

dog —> friendly
dog —> furry
dog —> warm
friendly —> nice

I haven’t figured this one out yet because it seems like it would need to be written entirely in adjectives, so you would need to claim an adjective like yellow has some other property than yellowness. Not sure it makes sense. At that point it might be more like a web of synonyms, instead.

3. Arrows are some kind of “possession” or “containment”

dog —>|has| legs
dog —>|has| mouth
dog —>|has| a set of friends (which could be empty)
dog —>|has| hopes for future
dog —>|has| feelings
dog —>|has| collar
dog —>|has| ability to run
dog —>|has| an age

All I can say for now is that this one comes closest to the example ologs of Spivak’s I have seen. But semantically, what kind of “has” is this? In linguistics, I believe the most abstract catch-all for all kinds of “having” is called ‘reference’. It simply means, “is associated with”, in some way. Could ologs thus be adequately formulated with all arrows simply labeled as “is associated with”?

The takeaway for now.

I am pretty sure Spivak’s ologs use both arrows-as-subtypes and arrows-as-reference. Do they use any other kinds of arrows?

dog —>|need| water

If the verb expresses a universal property of the noun class, then it seems that any verb is acceptable in an olog.

dog —>|run| Hawaii

If the verb expresses something about a member of the class, then it does not seem suitable for an olog (so far).

Philosophically, could we say (for now) that the olog expresses the “necessary and sufficient” conditions of a thing? Which leads to the question: what can’t it therefore express? “Necessary and sufficient conditions” of an abstract Ideal Form are atemporal - it leads to the question, “can ologs talk about non-universal things, like the particularities of a single dog, or an event that happened at some point in historical time? How?”

This is the next question: can you construct a language of particularities out of a language of universals, or do you need to allow yourself the ability to express particularities a priori, in the language you are using?

Morgan Rogers (he/him) (Mar 12 2024 at 19:32):

A "model" of an olog assigns to each name (e.g. dog) a set representing the collection of dogs. The individuals are elements of that set. The olog is only really able to talk about properties common to all members of this collection, if I understand correctly; any distinguishing characteristics (properties distinguishing elements/members) exist only in the model.

John Baez (Mar 12 2024 at 19:59):

You cleverly dodged Julius' next bullet by saying "a set representing the collection of dogs" rather than "the set of dogs". It is hard to include actual dogs in one's foundations of mathematics.

Morgan Rogers (he/him) (Mar 12 2024 at 20:09):

Kevin Carlson (aka Arlin) (Mar 12 2024 at 20:09):

Is it? Zermelo set theory/more recently ZFA just has a lot of stuff, and some of the stuff is sets but as far as I can tell the other stuff might as well be actual dogs.

Eric M Downes (Mar 12 2024 at 20:10):

Kevin Carlson (aka Arlin) (Mar 12 2024 at 20:11):

Morgan Rogers (he/him) (Mar 12 2024 at 20:12):

~~If you choose the right Godel numbering, I bet you can show that "there does not exist a number which is a dog" is not decidable in Peano arithmetic.~~

John Baez (Mar 12 2024 at 20:32):

I've never opened up a ZFA set and checked to see if there are dogs inside. If there are, someone should feed them.

Seriously, I think it changes math when your sets contain elements for which equality can be tricky to check, which came into existence at some point in history, and which sometimes run off and get lost, or die. You can try to handle all these issues and create a precise formalization of sets of dogs... but is this really what we want to spend our time on?

Eric M Downes (Mar 12 2024 at 21:33):

(I'll answer for math generally, as I think your question really has more to do with the philosophy of correspondence between objects of thought and objects of reality.)

When viewed through the lens of a model, everything has aspects, including the model itself. I think one must come to the (sometimes uncomfortable) conclusion that many of the aspects of a thing are often not data we provide the theory, but emergent properties that we "discover" when we attempt to model the objects of the theory we "invented".

Wether those aspects are incidental / accidental to our model is ~ Ramsey theory, how durable / universal aspects are ~ category theory. We here in CT land prefer models that have features just when they are universal, and minimal/no extra/incidental features.

A question that leads beyond itself is not "is a dog a set or an atom" -- that's a mirror to what we put in, but we start with instead, "well what are the aspects of a dog, based on how you defined it?" (what you you prove starting with that definition) and proceed to "how durable are those aspects in similar contexts; do hamsters defined thusly also satisfy the adjoint canine theorem; is there an adjoint mammal theorem?" and so on. This is true wether the thing with aspects is an atom with concrete properties like "3" in ZFA or a set "{{},{{}}}" in ZFC, or

\bar{3}:1\to\mathbb{N}

in ETCS. All of these things emphasize different aspects. It's practical; we set it up to express what we want/need. The only hard rule is consistency with the rest of what we have said or cited.

It looks to me like it can be either. I believe you could restrict to Typed Ologs if you want, where the arrows have a strict type relationship you provide, or to literal references like pointers, or anything in between.

The olog seems to be a database that is waiting for you to fill it with data. You do this using a functor to

\mathsf{Set}

. What makes a relationship between ologs with data in them (with functors to Set,

I, J

) "meaningful" and not just some arbitrary mapping between one concatenation of unstructured JSON and another, is that there be a "meaningfulness pullback"

I^*J

You could have arrow

I

represent subtypes and arrow

J

represent memory locations for those type definitions and a pullback would exist. You could have arrow

I

represent literal references to machine memory locations,

J

map to the last unix epoch that object was referenced and have a pullback exist, just be sure to distinguish between the "external" functor arrows

I,J

and the "internal" morphism arrow between ologs

F

; those will need to mean different things most of the time.

Spivak is abstracting away almost all the questions that have got you hung up as far as I can tell? He is proposing a new structure whose aspects he means to cover any robust non-error-prone use of a database whatsoever. Not by specifying in exacting details what every arrow must mean, but just by requiring you confirm your ologs obeys certain commutative diagrams once you build them. Like, you deploy the olog cluster, ingest your data from

\mathsf{Set}

, and then your data pipeline engineer writes a bunch of tests, not looking at the data content itself, but just wether it satisfies consistency criteria.

This is a little confusing because usually we do want our arrows to mean something specific in a given category, but within an olog it looks like they can be different kinds of arrows, or more specifically a union/join type of those different types, if you're familiar with Scala. So David is hinting at a construction valid in any category meeting certain criteria, which is a common and beautiful thing to find once you start looking.

Ryan Wisnesky (Mar 12 2024 at 22:23):

Many of the questions David Spivak asks/answers in the original olog paper are not unique to knowledge representation with ologs, they are about knowledge representation with logic or algebra in general. For example, even in a "knowledge graph", a weaker structure than a category, one way ask, what meanings may be ascribed to the edges, i.e., consider morphisms from a graph to categories beyond Set (and there are even commercial products that do this for graphs). And Rosebrugh's work on entity-attribute sketches foreshadows ologs. Anyway this thread reminds me a lot of the discussions around RDF/OWL and the semantic web, where people were trying to understand, philosophically, what it could do, when really that question can only be answered using math.

Julius Hamilton (Mar 23 2024 at 20:19):

I’m still planning on reading and responding to the above.
I just wanted to say I think a really simple solution is to label all arrows in a olog with “is associated with”. This makes it clearer that the type of relation is fully abstracted away.

Joshua Meyers (Mar 25 2024 at 11:50):

In a model of an olog, each arrow is interpreted as a function. So to make sense, it has to be something that could be interpreted as a function. For example, if we have an arrow People ->[is a sibling to] People, that wouldn't make sense, because some people have no siblings and some people have multiple siblings, so it is not a function. Subtypes work because we can have a function which sends UIDs (unique identifiers) for dogs to UIDs for mammals, for instance. A quality such as Dog -> Weight works because we can have a function sending each dog to it's weight. Possession can work in the case that each UID in the source possesses exactly one thing in the target. For example, People ->[owns house] Houses works if and only if nobody in the set assigned to People is homeless or owns multiple houses.

John Onstead (Mar 25 2024 at 22:16):

Joshua Meyers brings up a good point. But if you wanted to fully abstract away any type of relation (and so include any example of possession such as with someone possessing multiple things in the target set) or the example of People ->[is a sibling to] People, then you would need to consider binary relations instead of functions. Now, Ologs are categories equipped with a model functor from the category to Set. However, if you want to "stretch" the definition of olog, you could instead simply consider a category equipped with a "model" functor into Rel, the category of sets and the binary relations between them. Indeed, there is a canonical inclusion Set -> Rel and so any olog modeled in Set is also one modeled in Rel, which you can get by simply composing the olog model functor with the inclusion.
The good thing about binary relations is that there's a whole family of different kinds/properties of binary relation (of which functions are one special kind), each of which can be interpreted in different ways. Therefore, you can appreciably narrow down what kind of semantics a certain arrow in your olog can represent simply by analyzing the properties of the relation it is mapped to by the model. In addition, if you want to impose semantic restrictions on all the arrows in your olog, you can tune your model to map morphisms in your olog only to binary relations that have some specific property. For example, any relationship between things resembling the sibling example are specified by symmetric endo-relations. An endo-relation is a binary relation between a set and itself, and a symmetric relation is one such that if element a relates to element b, then element b relates to element a (this makes sense for siblings since if you have a sibling, you must also be your sibling's sibling). Your earlier example about subtype relations, likewise, only make sense with injective functions.

Ryan Wisnesky (Mar 25 2024 at 22:31):

one reason regular logic comes up in functional ologs is because that logic allows one to express the same data integrity constraints as 'finitely presented relational ologs'. In CQL for example we primarily use functional ologs but with regular logic on top to get the niceness of Rel.

David Michael Roberts (Mar 26 2024 at 02:54):

Noah Chrein (Apr 10 2024 at 21:39):

to this end I would view fur

\to

dog. or rather fur

\to

this specific dog, assigning to that specific dog its fur. I don't claim this is how Spivak's ologs work.

I agree with this, ologs absolutely allude to much more generic knowledge representation.

Category Theory
Zulip Server
Archive

Stream: learning: questions

Topic: Ologs: Semantic Restrictions on Arrows

Julius Hamilton (Mar 12 2024 at 18:35):