Modeling claims as topics

Marc-Antoine Parent

November 19, 2020

What we want to model

Communication is about topics

Semiotic triangle: The symbols (text, speech, icons…) refer to both an object “out there” (usually) and to the mental concepts of that object in the mind of each party to the communication act.

Anything we ever talk about is a topic. When we do computer models of topics (more symbols), obviously they are neither the object nor the concepts; but by making our topic modelling more and more formal, we attempt to disambiguate denotation and get ever-closer to the concept.

The relation between topics and symbols

We will focus on linguistic text literals as primary symbols; even when analyzing audio/video feeds, we tend to go through a textual transcript. Most words or phrases are polysemic and subject to many interpretations. (Words have many definitions in a dictionary.) To reflect that, we will have a many-to-many relation between those text literals and the topic representation.

@startuml
Topic "*" -> "*" TextLiteral : < expresses
TextLiteral : value
TextLiteral : language
Topic : id
@enduml

Progressive formalization

  • The text literal is also a topic in its own right, as it can be discussed as such.
    • There may be non-text literals as topics.
  • Every topic starts as a TextLiteral - Topic pair, and the formal analysis gets added progressively on the Topic side
@startuml
Topic "*" --> "*" TextLiteral : < expresses
Topic <|-- TopicLiteral
TopicLiteral : value
TopicLiteral <|-- TextLiteral
TextLiteral : language
Topic : id
TopicLiteral : type
@enduml

Progressive formalization

@startuml
Topic "*" --> "*" TextLiteral : < expresses
Topic <|-- TopicLiteral
TopicLiteral : value
TopicLiteral <|-- TextLiteral
TextLiteral : language
Topic : id
TopicLiteral : type
Topic "1?" --> "1/l" TextLiteral : < represents
@enduml
  • The text literal is also a topic in its own right, as it can be discussed as such.
    • There may be non-text literals as topics.
  • Every topic starts as a TextLiteral - Topic pair, and the formal analysis gets added progressively on the Topic side
  • One string can be designated as canonical representation
    • should ideally be unique per language (but not a hard constraint)

Topic addressability

Since anything can be a topic of conversation (anything can be a subject of a claim), all topics have to be addressable in the same namespace. In other words, there must be a unified addressing space for every entity discussed below. It should be understood that they’re all topics in one way or another.

@startuml
Topic : id
Topic <|-- TextLiteral
Topic <|-- Claim
Topic <|-- Argument
Topic <|-- Entity
@enduml

Claims

Claim: Something that can be assigned a truth value by someone.

Note: for a very lenient definition of truth value, that could allow probabilistic, modal, and other models of truth valuation.

@startuml
class Claim
@enduml

Claim families

A claim may be equivalent to another claim except for the truth value. Eg:

  • Everybody survives covid-19
  • Not everybody survives covid-19
  • Usually, people survive covid-19
  • People survive covid-19 with 98% probability

The core claim is the same; those form a claim family. Assessing that a claim belongs to a claim family may take some observation. There is an element of arbitrariness in deciding which claim is the core claim.

Modeling claim families

@startuml
Claim "1" <--o ClaimLink : < canonical
Claim "1" <--o ClaimLink : < derived
ClaimLink : truth_value
@enduml

We can think of what is common to all members of the family as truth-value-less (what Rönnbäck called a Posit) but there is no loss of generality in assuming that it is equivalent to the claim bearing the true truth value, which I will designate as canonical.

We could include the truth value in the claim itself, but since the family “structure” may come later than claim identification, I propose encoding it into the link between family members. The claim family is thus represented implicitly by the collection of those links centered on the canonical claim.

Modeling claim families (rejected)

The alternative would be to model the claim family explicitly; the disadvantage is it may require assigning a truth value to the claim after it has been created, introducing mutability.

@startuml
ClaimFamily o--> "1" Claim : > canonical
ClaimFamily o--> "*" Claim : > derived
Claim : truth_value
@enduml

Arguments

Argument: entailment link between claims. Only applies to one “truth configuration” of the claims.

@startuml
Claim : type
Argument o--> "1" Claim : > conclusion
Argument o--> "*" Claim : > premises
@enduml

Argument family

Arguments that have the same underlying set of claims with different truth values are different rows of the same truth table.

Eg: A & !B -> C !A & B -> !C

@startuml
object argument1
object argument2
object premise1
object premise2
object conclusion1
object derived_claim1
object derived_claim2
object derived_claim3
object premise1neg
object premise2neg
object conclusion1neg
object argument_set

argument1 --> premise1 : > premise
argument1 --> premise2neg : > premise
argument1 --> conclusion1 : > conclusion
argument2 --> premise1neg : > premise
argument2 --> premise2 : > premise
argument2 --> conclusion1neg : > conclusion
conclusion1 <-- derived_claim1 : < canonical
premise1neg <-- derived_claim1 : < derived
premise2 <-- derived_claim2 : < canonical
premise2neg <-- derived_claim2 : < derived
conclusion1 <-- derived_claim3 : < canonical
conclusion1neg <-- derived_claim3 : < derived
derived_claim1 : false
derived_claim2 : false
derived_claim3 : false
argument_set --> argument1
argument_set --> argument2
@enduml

Adding a premise

  • Creating a different argument with an augmented premise set may change the truth value set of the conclusion
    • if yes, that was an implicit premise
    • if no, that is an irrelevant premise
      • No need to model relevance separately

Entities

Entities: what is the claim about? What is it claiming?

Entities allow to group claims; also claim generalization is grounded in entity taxonomy.

@startuml
Claim : type
Claim o--> "*" Entity
@enduml

Distinguo

  • Some entity definitions may carry claims
  • A distinguo distinguishes definitions through a claim
@startuml
Claim "1" <--o ClaimLink : < canonical
Claim "1" <--o ClaimLink : < derived
ClaimLink : truth_value
ClaimLink : type
ClaimLink <--o Distinguo : < discriminant
Entity "1" <--o Distinguo : < canonical
Entity "1" <--o Distinguo : < derived
@enduml

Grounding

An argument about an argument: saying it is well-founded because (a claim)

Formulas

A claim with unbound variables. (Probably for much later.)

Provenance

  • Text taken from documents or conversations keeps its provenance
@startuml
Document <-- "*" Quote
Quote : position
Document <|-- Conversation
Quote -> "1" TextLiteral
TextLiteral : value
TextLiteral : language
Document : id
Document : url
@enduml

How to model it

Topics all the way down

  • Everything is a topic
  • Associations are N-ary relations qualified by role
@startuml
Topic <|-- Association
Topic : id
Topic : type
Topic "*" <--o "1" Association 
Association : type
(Topic, Association) . Casting
Casting : role
Topic *--> "*" Property
Property : type
Property : literal
@enduml

Topics all the way down

  • Everything is a topic (incl. types)
  • Associations are N-ary relations qualified by role
@startuml
Topic <|-- Association
Topic <|-- Type
Topic : id
Topic --> Type
Topic "*" <--o "1" Association 
Association --> Type
(Topic, Association) . Casting
Casting --> Type
Topic *--> "*" Property
Property --> Type
Property : literal
@enduml

Compare to RDF

  • Everything is a resource, designated by URI
  • triples: Subject - Predicate - Object (optional: Container graph)
  • ObjectProperty: Object is a resource
  • LiteralProperty: Object is a literal (with a type and language)
@startuml
hide circle
Resource : URI
Triple : Resource subject
Triple : Resource predicate
Triple : Resource|Literal object
Resource "1" <--o Triple : < subject
Resource "0..1" <--o Triple : < object
Literal "0..1" <--o Triple : < object
Resource "1" <--o Triple : < predicate
Literal : data
Literal : Resource type
Literal : string language
@enduml

Issues with RDF

  • Triples are not resources, cannot be subject or object
  • Literals are not resources, cannot be subject
  • No standard way to model N-ary relations
@startuml
hide circle
Resource : URI
Triple : Resource subject
Triple : Resource predicate
Triple : Resource|Literal object
Resource "1" <--o Triple : < subject
Resource "0..1" <--o Triple : < object
Literal "0..1" <--o Triple : < object
Resource "1" <--o Triple : < predicate
Literal : data
Literal : Resource type
Literal : string language
@enduml

Issues with topics

  • Why separate properties and castings? (h/t Felix Dietze)
  • Literals as topics with values
@startuml
Topic : id
Topic <|-- Literal
Topic <|-- Type
Literal : value
Topic <|-- Binding
Topic <-- Binding : < subject
Topic <-- Binding : < object
Type <-- Binding : < predicate
Topic <|-- Association
Binding <|-- Casting
Association <-- Casting : < subject
Binding <|-- Property
Literal <-- Property : < object
hide Property
hide Casting
hide Association
@enduml

Unified model

  • LiteralProperty ~ Property
  • ObjectProperty ~ 2 * Casting
  • ObjectProperty ~ Binding?
@startuml
Topic : id
Topic <|-- Literal
Topic <|-- Type
Literal : value
Topic <|-- Binding
Topic <-- Binding : < subject
Topic <-- Binding : < object
Type <-- Binding : < predicate
Topic <|-- Association
Binding <|-- Casting
Association <-- Casting : < subject
Binding <|-- Property
Literal <-- Property : < object
@enduml

Collections

@startuml
Topic : id
Topic <|-- Literal
Topic <|-- Type
Literal : value
Topic <|-- Binding
Topic <-- Binding : < subject
Topic <-- Binding : < object
Type <-- Binding : < predicate
Topic <|-- Collection
Topic "*" <-- Collection
@enduml

Claims as topics

  • Entities are topics
  • Claims are Bindings, Associations, or collections thereof
    • The reverse may be true…
  • Compare with Wikidata quad (Property with biography)
  • Arguments as claims following a certain structure

Details

  1. Claim: Something that someone may agree or disagree with
  • Informal (language-based)
  • Formal (concept analysis)
    • Includes relations between claims (eg negation)
  1. Argument: entailment link between claims
  • Also formal and informal
  • more relations: contraposition etc.
  • layers (causal, merologic, teleologic, epistemologic…)
  1. Entities: what is being claimed? About what?
  • Entity identification
  • Find implicit claims related to identity’s definition
  • Find derived claims through related entities
  • Many-to-many relationship between entities and their linguistic expression

Big picture

@startuml


interface Topic
Topic : id
interface Association

Topic <|-- Type
Topic <|-- Association

interface Collection
Association <|-- Collection

' An association is like a reified object property
Association "1" *--> "1..*" Binding : < association
Topic <--o Binding : < object

Literal : hash
Literal : value
Literal : type

Literal <|-- TextLiteral
TextLiteral : hash

TextLiteral "0..1/lang" <--o "1" Topic  : < canonical

Topic "*" --> "*" TextLiteral : < represents
(Topic, TextLiteral) . Representation
Representation : topic_id
Representation : text_hash


Entity <|-- Agent

Topic <|-- Entity
Topic <|-- Binding
Association <|-- Claim

Topic "*" <--o Association

Collection <|-- CompositeClaim
CompositeClaim o--> "*" Claim


Association <|-- ClaimLink
Claim "1" <--o ClaimLink : < canonical
Claim "1" <--o ClaimLink : < derived
ClaimLink : truth_value
ClaimLink : type

Claim <|-- Argument
Claim "1" <--o Argument : < conclusion
Claim "*" <--o Argument : < premise

ClaimLink <--o Distinguo : < discriminant
Entity "1" <--o Distinguo : < canonical
Entity "1" <--o Distinguo : < derived

'(Agent, Claim) . Vote
Vote : truth_value
hide Vote
hide Agent

@enduml
// reveal.js plugins