# Introduction to Representing Sentences as Logical Statements

**TLDR:** Most sentences can be translated to simple predicate logic. There are some very important cases where natural languages are recursive, but those cases are limited to a few particular connectives (like causation and attitude verbs). I propose the hypothesis that, contrary to mainstream formal semantics, events should not be treated as basic entities, and rather as ways to organize information which can already be expressed without events.

Motivations for this investigation:

1.  Better understanding how language works as an angle for better understanding minds.
2.  (To a lesser extent, as a starting angle for creating a good language for reasoning more effectively.)[^ehq9w42grzb]

There's a tight correspondence between sentences and logical statements. Roughly speaking, when we hear a sentence, our minds very likely parse it into a logical statement, along with inferring other details that are not captured by the coarseness of sentences in human languages (like imagining a visual scene), and then apply inferences (e.g. about what is likely going to happen next).

In theory, one could have a language where all the sentences are just statements in predicate logic, bypassing the first parsing step. Creating such a simple system may be a useful investigation that may move us closer to better understanding how language works. 

This post proposes a partially-formal system based on predicate logic, which could be seen as a very low-level language. I think everything that can be meaningfully said in natural languages can also be said in this simple system, although a translated statement sometimes look not closely analogous to the original sentence. To be clear, I definitely don't claim that this system explains how most of the meaning of sentences gets parsed, though it is a small step into that direction.

In many respects, the framework presented here aligns with traditions in formal semantics, though it diverges in its treatment of events.

This work focuses on the structure of the logical representation itself rather than the processes by which natural language sentences are translated into such representations. The primary concern is with the formal target representation, not the translation mechanism.

(Basic familiarity with predicate logic is assumed.)

Objects
-------

What are objects?

On the logic side, objects (sometimes also called "individuals" or "constants") are the basic entities of which predicates describe relations.

If `car(x)` is a statement in our predicate logic, then `car` is a predicate and `x` is an object.

What do objects correspond to on the language side?

Examples of objects: your monitor, Socrates, the laptop on my table

Importantly, the following are concepts, not objects: monitor, person, laptop

Objects are particular concrete instances, whereas concepts are classes.

If I say "Peter's laptop is broken", "Peter's laptop" identifies an object x where `laptop(x) and owns(Peter, x)`, let's say it's object `x28`. Now our mind substitutes this for "Peter's laptop", so the statement becomes "x28 is broken", aka `state(x28, 'broken')`.

Objects sometimes have names, like "Socrates". But often we only keep track of different objects in our minds and not in language, and identify objects partially by using context information. E.g. "the laptop" can refer to different objects in different contexts, but when used it's usually clear which object is meant. However, how objects get identified does not concern us here - we simply assume that we know names for all objects and use them directly.

So particular visual objects are one type of object, but there are also other types.[^92stn4uks0b] Examples of such "abstract objects" include: Harvard university, my bank account, the novel "Harry Potter and the methods of rationality" (HPMoR), the US Constitution.

Again, those are not to be confused with the following concepts, which aren't objects: university, bank account, novel, constitution

You might ask: "Wait, I have a print copy of HPMoR, and this print copy is a separate object from other print copies other people have. So shouldn't particular copies be the objects, and HPMoR a concept that can apply to particular copies?" Good question! We can indeed define a concept `HPMoR_print_copy`, where your particular copy is an object that inhabits that concept. But HPMoR is an abstract object independent of its physical manifestations in the world. That said, what exactly counts as an abstract object in my framework isn't completely clearly fleshed out yet.

If you're familiar with object-oriented programming, another intuition pump might be that concepts are sorta like classes, and objects are sorta like objects/instantiations.

(By the way, events like "the meeting" or "the Second World War" do not count as objects in my framework.)

Predicates
----------

We've already learned to know one type of predicate, namely concepts. Here we discuss other kinds of predicates.

### Relations

Relations are predicates between objects. For example:

"Alice and Bob are siblings": `sibling(Alice, Bob)`

"Alice speaks French": `speaks(Alice, French)`

### Attributes

Attributes are predicates between objects and values. I don't define precisely what a value is here, but it might get clear from examples:

"Russia is large": `area(Russia, high)`

"Mia is young": `age(Mia, low)`

"Josh weighs 80kg": `weight(Josh, 80kg)`

We can distinguish between absolute values, like "80kg", and relative values, like "low" and "high", which express the value relative to a reference distribution which is inferred from context. Actually, we perhaps don't want to capture statements like `age(Mia, low)` per se, but perhaps rather like `age(Mia, low, reference_distribution=students_enrolled_in_university)`. In a more precise language than English, "low" could mean something like "between -1.5 SD and -0.5 SD relative to the reference distribution".

Attributes can be seen as functions which map inputs to a value. We introduce notation for function-like predicates:

`P[x]` stands for `v` such that `P(x,v)`.

So now we can e.g. also write `weight[Josh]=80kg` or `area[Russia]=high`.

### Single-argument predicates over statements

We can also have predicates over statements. Multi-argument predicates that can take one or more statements as input will be discussed later.

Examples of single-argument predicates over statements include "theorem", "argument". For example:

"1+1=2 is a theorem" `theorem({1+1=2})`

(The curly brackets are just for convenience, so we can see directly that this is a statement.)

Introducing new objects
-----------------------

Suppose we don't yet know that Alice has a cat, and then someone tells us "Alice has exactly one cat" (and we unconditionally believe that). One option would be to express the statement as:

`EXISTS x: {cat(x) AND possess(Alice, x) AND FORALL y: {cat(y) AND possess(Alice, y)} => y=x}`

When someone now tells us "Alice's cat weighs 6kg", and later "Alice has a gray cat", we can add the following statement and we can derive by logic that they refer to the same cat:

`EXISTS x: cat(x) AND possess(Alice, x) AND weight(x, 6kg)` `EXISTS x: cat(x) AND possess(Alice, x) AND color(x, gray)`

However, this approach seems a bit inconvenient. So instead we use the approach where we create a new object for Alice's cat and later when someone talks about a cat of Alice we just identify that this object is meant and save information about this object.

In this alternative approach, the initial sentence "Alice has exactly one cat" still gets parsed the same, since words like "one" and "a" are indicators that we do not refer to an object that already exists in our context, and parse those sentences into "EXISTS" statements. But now our language system has some machinery for identifying when "EXISTS"-statements identify a particular object, and for such cases, it checks whether it already knows of an object with the unique properties, and if not creates one.

So in this case the system picks a new unique object name, let's say 'Alices_cat', and then we get the statements:

`cat(Alices_cat)` `possess(Alice, Alices_cat)` `FORALL y: {cat(y) AND possess(Alice, y)} => y=Alices_cat`

Now when we hear the statement "Alice's cat weighs 6kg", we don't parse the statement into `"EXISTS x: cat(x) AND possess(Alice, x) AND weight(x, 6kg)"`, but instead, recognize that "Alice's cat" refers to an object which is assumed to be identifiable, then run our object identification procedure to infer that "Alice's cat" refers to "Alices_cat", substitute this, and parse the sentence to `"weight(Alices_cat, 6kg)"`.

By the way, this doesn't mean that we cannot have 2 separate objects which are actually referring to the same object. Someone could tell us "Alice has exactly one pet named 'Lucy'", and we might create an object 'Lucy', and actually 'Lucy' and 'Alices_cat' refer to the same cat, and we might later learn that and unify those objects.

Temporal scope
--------------

Statements can have temporal scopes that describe in what interval(s) the statement is true. If no temporal scope is provided, the statement holds universally (e.g. "Momentum is conserved" or "Socrates is a man").

But there are statements which obviously have bounded temporal scope:

"John is wearing his suit": `(t1 <= t <= t2) => wearing(John, Johns_suit, t)`

(We assume here that "Johns_suit" is an object that is already known, and that estimates for t1 and t2 get inferred from context.)

"Mary is running": `(t1 <= t <= t2) => running(Mary, t)`

Of course, in real life there aren't crisp boundaries to events, but we wouldn't actually define t1 and t2 precisely, but only approximately, in the sense that we have a probability distribution over those variables. Though it's likely still imperfect because it doesn't reflect the continuity of changes.

We will use the following short notation for temporal scopes:

`"[t1, t2]: P(x1,...,xn)"` stands for `"(t1 <= t <= t2) => P(x1,...,xn, t)"`.

In our formal language, we need to define the temporal scope interval anew for each temporally bounded statement. However, we could later define parsing rules for inferring approximate temporal contexts through quickly expressible tense markers, though this isn't what we focus on here.

By the way, note that often English sentences only describe that there exists a subinterval where something was true, rather than stating that it was true for the whole interval. E.g. "I was skating yesterday" doesn't mean I was skating the whole day.

This temporal-scope approach presented here could be seen as a primitive version of Allen's interval algebra (Allen, 1983).

Location
--------

There can be location scopes similar to temporal scopes:

"At the cinema, there were lots of people."

Given this sentence, "there were lots of people" isn't necessarily true in other places.

But they can also act as modifiers of predicates:

"Mia is learning in her room."

Given this sentence, "Mia is learning" is still true, even if you didn't define that you're talking about what's in Mia's room right now.

Overall I am not quite sure yet how to best treat locations formally.

Statement connectives
---------------------

Sometimes, we can have relations between statements, rather than just objects. These can be clustered into 6 types: Logical connectives, Probabilities, Modal connectives, Temporal connectives, Causal connectives, and attitude verbs.

### Logical connectives

Logical connectives include: "not", "and", "or", "implies"/"if…then…"

Example: "John is at the bar or at the cinema." `{location(John, Bar, NOW)} OR {location(John, Cinema, NOW)}`

(Where as always "Bar" and "Cinema" are objects referring to a specific bar and a specific cinema.)

### Probabilities

We have this special probability predicate "p" which works as you would expect:

"The chance of rolling a 6 is 1/6th." `p[{upward_face[Die]=6}]=1/6.` (As notation for `p({upward_face(Die, 6)}, 1/6)`.)

We just import probability theory into our formalism, including conditional probabilities like `p[A|B]`, although I won't list here the definitions that make probabilistic inference possible.

### Modal connectives

The main modal connectives are "possibly" and "necessarily", indicating whether a statement is tautologically true (=necessary), self-contradictory (=not possible), or whether it's an empirical statement, so that it could be true in some worlds and false in others (=possible and not necessary).

I just mention them here for completeness. This work doesn't discuss those further.

### Causal connective

Words like "because" and "causing" relate statements, like in "The glass fell because the cat jumped on the table". Causation can also be expressed like "If the cat hadn't jumped on the table, the glass wouldn't have fallen". We express both sentences as the following statement in our system:

`{[t1, t2]: jumping(Cat, toward=top_of_table)} CAUSES {[t3, t4]: falling(glass)}`

Where "CAUSES" is a connective like "OR", and the truth conditions for "CAUSES" are defined through Perlian causality (Pearl, 2000). How exactly this can be interpreted is outside the scope of this work.

Actually, whether some fact causes another isn't a binary yes or no, but rather there are different degrees of how strongly something causes something else (based on how well the joint probability distribution our world model assigns to statements approximately factors according to the causal link). But we ignore this complication here.

By the way, in English, there are causative verbs which imply causation without explicitly using words like "cause". E.g. "The news made Bob smile".

### Attitude verbs

There are a few key attitude verbs, and for each there are multiple further slightly different verbs to express more subtlety:

*   believe: think, know, understand, …
*   want: desire, fear, prefer, need, …
*   try/work_towards: attempt, strive, plan, …

Although usually not included as attitude verbs, I would also include:

*   can/could_cause
*   perceive: see, hear, observe, …
*   say: explain, mention, …
*   promise: commit, consent, …

We'll formally write them like this:

"John believes Mary is smart." `believe(John, {intelligence(Mary, high)})`

A common approach for formalizing this more precisely is using possible world semantics. However, for beliefs at least, I prefer a sorta equivalent but more direct approach of using belief pools.

What we basically do here, is that for another person's beliefs, we have another belief pool, similar to our main belief pool in which all our known statements exist.

One could imagine something like the following Python command being executed `Johns_beliefs.append("intelligence(Mary, high)")`

Where this works in a similar way to how statements get added to our main belief pool, which one could imagine like: `beliefs.append("believe(John, {intelligence(Mary, high)})")`

Of course, there's actually huge overlap between the agent's own beliefs and John's beliefs, and we would need to import a lot of common sense into "Johns_beliefs".

However, especially for other attitude verbs, I am unsure whether an approach analogous to the belief pool approach is good, or whether another formalization is more appropriate. E.g. for desires, it might make more sense to assign utilities to worlds rather than to statements.

### Other thoughts

There are also temporal connectives between statements like "before" and "after", but they are just convenient tools for describing the temporal scope of statements relative to the temporal scope of other statements.

By the way, in case you thought relative clauses are an example for a sentence being part of another sentence, they actually don't count, because they just help to specify an object.

Aspectual verbs ("start", "finish"), raising verbs ("turn out", "seem") and modal auxiliaries all don't count either, because the information they convey can also be conveyed without using an embedded clause.

I just quickly want to remark that I find it remarkable that (unless I overlooked some) these are all the cases where we actually need sentences as parts of other sentences. So while language is indeed recursive, it is so only in some special cases. To me this was an interesting surprise, which made understanding language seem less unwieldy to me than it originally did.

In fact, by now we have covered everything we need for a (not yet very practical) language, although we haven't described how some connectives like "CAUSES" work. Admittedly, we haven't covered events yet, but as we will see now, we can express everything that we would express in English through events by instead using the tools we have so far.

Events as facts
---------------

If, in our system, we want to formalize "John ate the cake", which basically describes "Because John was eating cake, the cake is eaten":

`{[t1, t2]: eating(John, Cake)} CAUSES {(t2 < t) => exists(Cake, false, t)}`

(The "exists" here is a special predicate which is not to be confused with the existential quantifier "EXISTS".)

This is a departure from the dominant Davidsonian event semantics (Davidson, 1967; Parsons, 1990), which would interpret the sentence "John ate the cake" as "there exists an event e which consists of John eating the cake". However, as I will argue throughout this section, I think it makes more sense to treat events as some sort of thing that can have properties, but rather just as a way of compressing information which we already could've expressed otherwise.

Sentences that describe events are very common. Let's look at another example:

"Alice bought a cookie."

Our parsing machinery creates objects "Cookie" and "Seller". In our system, we can have a predicate "buying" for describing that someone is in the process of buying something, but we don't have any native functionality to express that the goal of the process was reached successfully. We could translate the sentence "Alice bought a cookie" as follows:

    {[t1, t2]: buying(Alice, Cookie, Seller)} CAUSES
    {wealth[Alice, t2]=wealth[Alice, t2-epsilon]-price[Cookie] AND
    wealth[Seller, t2]=wealth[Seller, t2-epsilon]+price[Cookie] AND
    NOT(own(Seller, Cookie, t2) AND
    own(Alice, Cookie, t2))}
    

This would indeed be rather annoying to say in full, so it is clear why we want to have a shortcode for "buy". (Though we could get most of the relevant information by saying something like `NOT(own(Alice, Cookie, t1)) AND own(Alice, Cookie, t2)`, but it doesn't capture all the information conveyed by "bought".)

Also, "buying" is quite an abstract predicate and sorta ugly to use. Nicer might be something like "communicating information about the willingness to trade by the conditions determined by the pricetag".

To be clear, none of the above complexity is significant evidence for Davidsonian semantics being better than the system proposed here, since there is still the same hidden complexity in the Davidsonian approach, which would formalize the sentence like: `EXISTS e: Buy(e) AND Agent(e, Alice) AND Theme(e, Cookie)`.

There are not just the implicit events as in the English sentences above, but events also occur explicitly in words like "the party", "the meeting", "the battle". One approach would be to treat such explicit events as abstract objects to relate them to other objects using predicates. However, as I will show, most sentences with such explicit events can be accurately rephrased without using events.

Let's look at example sentences with explicitly mentioned events.

1: "The city was destroyed by a volcano eruption."

This can be rephrased as: "The fact that a specific volcano was erupting in some time interval, caused the city to be destroyed." Formally:

`{[t1,t2]: erupting(Volcano)} CAUSES {[t2,-]: state(City, destroyed)}`

2: "The meeting lasted 2 hours."

This can be simply formalized by assuming that we do not know the precise time of the meeting but that we know the duration:

`EXISTS t1, t2: {[t1,t2]: meeting(Team)} AND {t2-t1=2h}`

3: "I prepared notes for the meeting."

This could be rephrased as: "I prepared notes so I can better express my views during the time when we meet.", which could in turn be rephrased as "I prepared notes because I wanted to better express my views during the time we meet." The "during the time we meet" part is actually slightly annoying to express formally, so let's just say `t1, t2` describe the start- and end-times of the planned meeting, which lets us write the sentence as:

`{want(I, {[t1,t2]: express(I, MyViews, skillfullness=high)})} CAUSES {exists(PrepNotes, true)}`

4: "The meeting was productive."

This could be rephrased as: "I estimate higher expected utility according to my preferences based on the fact that we met than I estimate in the counterfactual." Since I don't know yet how to best formalize preferences, I don't know how to formalize this yet, but the intuitive language translation already doesn't include events.

The general hypothesis here is that whenever we refer to an event in English, we can either see the event as a fact, or we can express the relevant meaning of the statement differently.

There can also be names for particular events, like "World War II (WW2)".

5: "The Nazis started WW2"

This can be rephrased as "The Nazis caused the fact that WW2 happened", which is roughly like "The Nazis caused the fact that there was a lot of battling between armies during 1939-1945". This doesn't seem to quite capture the same meaning, but then it's generally not easy to rephrase the sentence without using "WW2" even if you can rephrase it in a way that uses events, so I'd say it's fine to treat WW2 as fact here.

(By the way, we cannot quite formalize this sentence yet, because "CAUSES" is actually a relation between two statements, not an agentic entity and a statement. But perhaps one can rephrase it as "The fact that the Nazis tried to start a war and were competent enough to do so, caused WW2".)

6: "WW2 was brutal"

The fact based system cannot formalize the sentence very directly, since it doesn't make much sense to assign a property like "brutal" to a fact. In fact, "brutal" seems to only make sense as a property of events, actions, or agent-like entities. However, the sentence "Many people strongly suffered during WW2" still essentially captures the same meaning, and this we can express in our system.

7: "The Nazis lost WW2"

We cannot say this directly in our framework. We could say something like "At the end of WW2, the Allies were in control over Europe", but it seems like in this case it would maybe be nice if a more direct translation were possible.

8: "John won the tournament"

We could say something like "John ranked 1st in the tournament evaluation table", though this is another example where it seems like it may be possible to more nicely translate the sentence, and is thus also some evidence against the presented framework being optimal.

Btw, I think it's important to distinguish events from procedures/algorithms, where the latter can be abstract objects. I'm not sure whether "tournament" would qualify as such.

### Concluding thoughts on events

Overall, I think it neither makes sense to introduce a fundamentally new type for events, nor to treat events as abstract objects, since in most cases the meaning can be expressed well using only temporally bounded facts. (Though I am not completely certain about this.)

Essentially, I have an intuition that in the underlying world model into which sentences get parsed, events are likely just some handles for organizing information, whereas for an abstract object we in some sense have an actual model associated with it.

To be clear, sentences describing events are extremely ubiquitous in natural languages, and events are extremely important for communicating information concisely, and for organizing connected pieces of temporal knowledge. But the key thesis of this section is that parsing rules for events ought to reduce sentences to statements that don't have basic event entities separate from facts.

(I'm happy to discuss this hypothesis further in the comments.)

One option might be to treat events as describing something like similarity clusters of facts, though this is just a hypothesis that has yet to be examined.

Recap
-----

This framework proposes a way to represent natural language using predicate logic. The key components are:

1.  **Objects**: These are specific instances rather than general concepts. For example, "Peter's laptop" is an object, while "laptop" is a concept.
2.  **Predicates**: These include concepts (like "car"), relations between objects (like "siblings"), and attributes that assign values to objects (like "weighs 80kg").
3.  **Time**: Statements can be limited to specific time intervals.
4.  **Statement connectives**: There are only a few types of these (e.g., logical connectives like AND/OR, causality with "because", and attitude verbs like "believes" or "wants").
5.  **Events as facts**: Expressing sentences that indicate events are likely a useful way for efficiently summarizing information, rather than events needing to be treated as separate entities.

The Gap Between Logical Representation and Semantic Understanding
-----------------------------------------------------------------

The way we defined our system, we can let a computer do some logical inference. E.g. from formalizations of the sentences "Socrates is a man" and "all men are mortal", we can derive "Socrates is mortal". However, most of our understanding of who "Socrates" is and what a "man" is isn't captured by our system yet. We're essentially lacking a lot of background associations/knowledge about objects like "Socrates" and predicates like "man", which would be needed to more fully capturing the inferences humans can make. The problem of providing such associations is what I call the "grounding problem". We can distinguish:

1.  Parsing sentences into sensory anticipations. E.g. visualize "the huge dog jumped".
2.  Background information for parsing sentences where a predicate occurs into other sentences without the predicate.
    1.  Especially important is background information that reduces abstract predicates into more low-level predicates. Definitions are an important special case of this.

As example for (2), you could ground "[(half-)sibling(x,y)](https://en.wikipedia.org/wiki/Prolog#Predicates_and_programs)" by defining it as "there exists a person such that it is the parent of both x and y":

`∀ x,y: half_or_full_sibling(x,y) ⟺ (x!=y and ∃ z: parent(z,x) AND parent(z,y))`

Statements like "all men are human" could also be seen as examples for (2). Though the predicates "man"/"human" obviously also require some visual grounding, and if that was properly formalized, maybe "all men are human" would just be a corollary we wouldn't need to state explicitly. (In general, I think the approach of trying of trying to concisely ground something in some lower-level stuff is preferred to just including a lot of background information that comes to mind.)

For capturing empirical truths about reality, there needs to be some entanglement between logical statements and sensory anticipations. (E.g., you could define "mother(x,y)" as "x gave birth to y", and then "gave birth" as some more precise cluster of observations, which eventually need to be able to be identified from visual inputs.)

It is worth noting that natural language categories often resist precise formal definition. Especially low-level predicates rather describe similarity clusters with fuzzy boundaries, where category membership is a matter of degree rather than binary classification. However, I think one can find good definitions for many abstract predicates (e.g. [fair](https://www.lesswrong.com/s/SqFbMbtxGybdS2gRs/p/zqwWicCLNBSA5Ssmn), [arbitrary](https://www.lesswrong.com/posts/HacgrDxJx3Xr7uwCR/arbitrary)), though it's often hard.[^g4dr41u11a9]

Concluding thoughts on this proposed formal statement representation
--------------------------------------------------------------------

This framework for representing natural language sentences as logical statements offers several advantages:

1.  **Simplicity**: The system strives for ontological parsimony, particularly by treating events as temporally bounded facts rather than primitive entities. This approach to simplicity helps the framework move toward computational interpretability, where the semantic content is directly accessible through the logical structure itself.
2.  **Expressiveness**: Despite its relative simplicity, the framework appears capable of representing (almost[^tme5sy74pac]) any semantic content expressible in natural language.

However, several limitations and open questions remain:

1.  **Mental Representation**: While the framework provides a logical structure, human thought processes are likely even more precise and fundamentally probabilistic in nature. Our minds may operate with finer-grained distinctions and continuous probability distributions rather than the discrete logical structures presented here.
2.  **Incomplete Formalization**: The framework didn't define yet how foundational connectives like "CAUSES" or "want" can be interpreted.
3.  **Improper semantic grounding**: Relations between predicates and between predicates and sensory anticipations remain undefined.

### Further work

(ADDED: I recommend reading my quick shortform post "[The problem of finding a good representation of abstract thoughts](https://www.lesswrong.com/posts/f2NX4mNbB4esdinRs/towards_keeperhood-s-shortform?commentId=Z6YicLCaEANoNMcJG)". I think further work towards that is a core priority.)

I think the next most important problems in this "understand language to understand agents" agenda are (in the order I think makes most sense): (Some of the subproblems are rather entangled)

1.  (Evaluate whether my proposed framework here makes sense.)
    1.  Get a better model of what abstract objects are by exploring whether there are ambiguous edge cases and if necessary revising what counts as abstract object. If necessary adjust the whole framework.
    2.  Evaluate whether the proposed treatment of events makes sense and propose a rough formalization that describes how events organize information.
2.  Formalize parsing of statement connectives, in particular attitude verbs.
    1.  Check how satisfactory existing approaches (most notably possible world semantics) are and adjust those as needed.
3.  Formalize grounding for *objects*
    1.  Grounding for visual objects. How to translate between a 3D world-model representation and sentences? ([Related](https://www.lesswrong.com/posts/RrQftNoRHd5ya54cb/towards-a-less-bullshit-model-of-semantics#Second__Toy__Model_Sketch__Rigid_Body_Objects).[^kxgz9l2w4oi])
    2.  Grounding for abstract objects. How do our world models model abstract objects?
4.  Formalize grounding for predicates
    1.  Formalize grounding for attributes.
    2.  Formalize grounding of relations.
    3.  How carve up a good ontology of concepts?
        1.  How identify natural similarity clusters?
        2.  How identify important distinguishing properties?

(Note that it's possible that it might be better for some progress not to be published.)

Related: [The Great Reductionist Project](https://www.lesswrong.com/posts/bTsiPnFndZeqTnWpu/mixed-reference-the-great-reductionist-project), [Towards a Less Bullshit Model of Semantics](https://www.lesswrong.com/posts/RrQftNoRHd5ya54cb/towards-a-less-bullshit-model-of-semantics)

*(Thanks to Kaarel Hänni and Jeremy Gillen for feedback on a draft.)*

[^ehq9w42grzb]: The investigation may also serve as a good starting point for creating a good language which makes proper reasoning easier. Of course, saying precise predicate logic statements would be impractically long, but it may serve as a starting point from which we could then introduce parsing rules to communicate information more concisely. 

[^92stn4uks0b]: The distinction between visual and abstract objects isn't that important for our purposes, but in case you're interested what I mean. A visual object is something that is grounded in our 3D visual anticipations, whereas abstract objects are modelled in some other ways. People/agents are actually just partially visual, since we also model their minds to make predictions about their behavior. Abstract objects like "Harvard university" still exist visually in some sense, but usually we have an abstract model in our mind, e.g. as vaguely agentic entity that has the power to grant degrees. (Though in some context "Harvard university" can also have the type of a location.) 

[^g4dr41u11a9]: Though note that words are often overloaded by some subtly different concepts, and disentangling those might be necessary to find good reductions. 

[^tme5sy74pac]: One thing that's not possible through what I've described is direct quoting / talking about the symbols/words of a sentence itself instead of talking about their referents. 

[^kxgz9l2w4oi]: Sources I think might be worth checking out for this but which I haven't read: 1. Chapter "Perception" in "AI: A modern approach". 2. "Vision" by David Marr.