Quick start

A power relation (i.e, a ranking over subsets of a finite set N; see the Section on PowerRelation objects for a formal definition) can be constructed using the functions PowerRelation() or as.PowerRelation().

library(socialranking)
PowerRelation(list(list(c(1,2)), list(1, c()), list(2)))

## 12 > (1 ~ {}) > 2

as.PowerRelation("12 > 1 ~ {} > 2")

## 12 > (1 ~ {}) > 2

as.PowerRelation("ab > a ~ {} > b")

## ab > (a ~ {}) > b

as.PowerRelation(list(c(1,2), 1, c(), 2))

## 12 > 1 > {} > 2

as.PowerRelation(list(c(1,2), 1, c(), 2), comparators = c(">", "~", ">"))

## 12 > (1 ~ {}) > 2

Functions used to analyze a given PowerRelation object can be grouped into three main categories:

• Comparison functions, only comparing two elements;
• Score functions, calculating the scores for each element;
• Ranking functions, creating SocialRanking objects.

Comparison and score functions are often used to evaluate a social ranking solution (see section on PowerRelation objects for a formal definition). Listed below are some of the most prominent functions and solutions introduced in the aforementioned papers.

These functions may be called as follows.

pr <- as.PowerRelation("ab > abc ~ ac ~ bc > a ~ c > {} > b")

# a dominates b, but b does not dominate a
c(dominates(pr, "a", "b"),
  dominates(pr, "b", "a"))

## [1]  TRUE FALSE

# calculate cumulative scores
scores <- cumulativeScores(pr)
# show score of element a
scores$a

## [1] 1 3 4 4 4

# performing a bunch of rankings
lexcelRanking(pr)

## a > b > c

L1Ranking(pr)

## a > b > c

dualLexcelRanking(pr)

## a > c > b

copelandRanking(pr)

## a > b ~ c

kramerSimpsonRanking(pr)

## a > b ~ c

ordinalBanzhafRanking(pr)

## a > c > b

Lastly, an incidence matrix for all given coalitions can be constructed using powerRelationMatrix(pr) or as.relation(pr) from the relations package [12]. The incidence matrix may be displayed using relations::relation_incidence().

rel <- relations::as.relation(pr)
rel

## A binary relation of size 8 x 8.

relations::relation_incidence(rel)

## Incidences:
##     ab ​abc ​​ac ​​​bc ​​​​a ​​​​​c ​​​​​​{} ​​​​​​​b
## ab   1   1  1  1 1 1  1 1
## ​abc  0   1  1  1 1 1  1 1
## ​​ac   0   1  1  1 1 1  1 1
## ​​​bc   0   1  1  1 1 1  1 1
## ​​​​a    0   0  0  0 1 1  1 1
## ​​​​​c    0   0  0  0 1 1  1 1
## ​​​​​​{}   0   0  0  0 0 0  1 1
## ​​​​​​​b    0   0  0  0 0 0  0 1

Creating PowerRelation objects

A power relation in the socialranking package is defined to be reflexive, transitive and total. In designing the package it was deemed logical to have the coalitions specified in a consecutive order, as seen in Example 1. Each coalition in that order is split either by a ">" (left side strictly better) or a "~" (two coalitions indifferent to one another). The following code chunk shows the power relation from Example 1 and how a correlating PowerRelation object can be constructed.

library(socialranking)
pr <- PowerRelation(list(
  list(c(1,2)),
  list(2, c()),
  list(1)
))
pr

## 12 > (2 ~ {}) > 1

class(pr)

## [1] "PowerRelation"      "SingleCharElements"

Notice how coalitions such as {1, 2} are written as 12 to improve readability. Similarly, passing a string to the function as.PowerRelation() saves some typing on the user’s end by interpreting each character of a coalition as a separate element. Note that spaces in that function are ignored.

as.PowerRelation("12 > 2~{} > 1")

## 12 > (2 ~ {}) > 1

The compact notation is only done in PowerRelation objects where every element is one digit or one character long. If this is not the case, curly braces and commas are added where needed.

prLong <- PowerRelation(list(
  list(c("Alice", "Bob")), 
  list("Bob", c()),
  list("Alice")
))
prLong

## {Alice, Bob} > ({Bob} ~ {}) > {Alice}

class(prLong)

## [1] "PowerRelation"

Some may have spotted a "SingleCharElements" class missing in class(prLong) that has been there in class(pr). "SingleCharElements" influences how coalitions are printed. If it is removed from class(pr), the output will include the same curly braces and commas displayed in prLong.

class(pr) <- class(pr)[-which(class(pr) == "SingleCharElements")]
pr

## {1, 2} > ({2} ~ {}) > {1}

Internally a PowerRelation is a list with four attributes.

While coalitions are formally defined as sets, meaning the order doesn’t matter and each element is unique, the package tries to stay flexible. As such, coalitions will only be sorted during initialization, but duplicate elements will not be removed.

prAtts <- PowerRelation(list(
  list(c(2,2,1,1,2)),
  list(c(2,1), c())
))

## Warning in createLookupTables(equivalenceClasses): Found 1 coalition that contain elements more than once.
##     - 1, 2 in the coalition {1, 1, 2, 2, 2}

prAtts

## 11222 > (12 ~ {})

prAtts$elements

## [1] 1 2

prAtts$coalitionLookup(c(1,2))

## [1] 2

prAtts$coalitionLookup(c(2,1))

## [1] 2

prAtts$coalitionLookup(c(2,1,2,1,2))

## [1] 1

prAtts$elementLookup(2)

## [[1]]
## [1] 1 1
## 
## [[2]]
## [1] 1 1
## 
## [[3]]
## [1] 1 1
## 
## [[4]]
## [1] 2 1

Manipulating PowerRelation objects

It is strongly discouraged to directly manipulate PowerRelation objects, as its attributes are so tightly coupled. This would require updates in multiple places. Instead, it is advisable to simply create new PowerRelation objects.

To permutate the order of equivalence classes, it is possible to take the equivalence classes in $eqs and use a vector of indexes to move them around.

pr <- as.PowerRelation("12 > (1 ~ {}) > 2")
PowerRelation(pr$eqs[c(2, 3, 1)])

## (1 ~ {}) > 2 > 12

PowerRelation(rev(pr$eqs))

## 2 > (1 ~ {}) > 12

For permutating individual coalitions, using as.PowerRelation.list() may be more convenient since it doesn’t require nested list indexing.

coalitions <- unlist(pr$eqs, recursive = FALSE)
compares <- c(">", "~", ">")
as.PowerRelation(coalitions[c(2,1,3,4)], comparators = compares)

## 1 > (12 ~ {}) > 2

# notice that the length of comparators does not need to match
# length(coalitions)-1
as.PowerRelation(rev(coalitions), comparators = c("~", ">"))

## (2 ~ {}) > (1 ~ 12)

# not setting the comparators parameter turns it into a linear order
as.PowerRelation(coalitions)

## 12 > 1 > {} > 2

pr <- PowerRelation(list(
  list(c("AT", "DE"), "FR"),
  list("DE"),
  list(c("AT", "FR"), "AT")
))
pr

## ({AT, DE} ~ {FR}) > {DE} > ({AT, FR} ~ {AT})

# since we have 3 elements, the super set 2^N should include 8 coalitions
appendMissingCoalitions(pr)

## ({AT, DE} ~ {FR}) > {DE} > ({AT, FR} ~ {AT}) > ({AT, DE, FR} ~ {DE, FR} ~ {})

pr <- as.PowerRelation("a > b > c ~ ac > abc")
makePowerRelationMonotonic(pr)

## (abc ~ ab ~ ac ~ a) > (bc ~ b) > c

makePowerRelationMonotonic(pr, addMissingCoalitions = FALSE)

## (abc ~ ac ~ a) > b > c

# notice how an empty coalition in some equivalence class
# causes all remaining coalitions to be moved there
makePowerRelationMonotonic(as.PowerRelation("ab > c > {} > abc > a > b"))

## (abc ~ ab) > (ac ~ bc ~ c) > (a ~ b ~ {})

Creating power sets

As the number of elements n increases, the number of possible coalitions increases to |2^N| = 2ⁿ. createPowerset() is a convenient function that not only creates a power set 2^N which can be used to call PowerRelation or as.PowerRelation(), but also formats the function call in such a way that makes it easy to rearrange the ordering of the coalitions. RStudio offers shortcuts such as Alt+Up or Alt+Down (Option+Up or Option+Down on MacOS) to move one or multiple lines of code up or down (see fig. below).

createPowerset(
  c("a", "b", "c"),
  result = "print"
)

## as.PowerRelation("
##   abc
##   > ab
##   > ac
##   > bc
##   > a
##   > b
##   > c
##   > {}
## ")

Using Alt+Up or Alt+Down to move one or more lines of code

By default, createPowerset() returns the power set in the form of a list. This list can be passed directly to as.PowerRelation() to create a linear order.

ps <- createPowerset(1:2, includeEmptySet = FALSE)
ps

## [[1]]
## [1] 1 2
## 
## [[2]]
## [1] 1
## 
## [[3]]
## [1] 2

as.PowerRelation(ps)

## 12 > 1 > 2

# equivalent
PowerRelation(list(ps))

## (12 ~ 1 ~ 2)

as.PowerRelation(createPowerset(letters[1:4]))

## abcd > abc > abd > acd > bcd > ab > ac > ad > bc > bd > cd > a > b > c > d > {}

Generating PowerRelation objects

For the ease of experimentation, it is possible to have power relations created automatically given a list of coalitions. Either,

• create random power relations using generateRandomPowerRelation(), or
• generate a sequence of all possible power relations with powerRelationGenerator().

For the former, one may also specify if the generated power relation should be a linear order (as in, there are no ~ but only strict > relations) and whether or not the power relation should be monotonic (as in, {1} ≻ {1, 2} is not monotonic because {1} ⊂ {1, 2}).

set.seed(1)
coalitions <- createPowerset(1:3)
generateRandomPowerRelation(coalitions)

## 13 > (2 ~ 12) > {} > (1 ~ 123) > 23 > 3

generateRandomPowerRelation(coalitions)

## ({} ~ 1 ~ 2 ~ 12 ~ 123) > 3 > 13 > 23

generateRandomPowerRelation(coalitions, linearOrder = TRUE)

## 12 > 2 > 123 > 23 > 13 > 3 > {} > 1

generateRandomPowerRelation(coalitions, monotonic = TRUE)

## (123 ~ 23 ~ 12 ~ 13 ~ 1) > (2 ~ 3 ~ {})

generateRandomPowerRelation(coalitions, linearOrder = TRUE, monotonic = TRUE)

## 123 > 23 > 12 > 2 > 13 > 1 > 3 > {}

For looping through all possible power relations, powerRelationGenerator() returns a generator function that, when called repeatedly, returns one unique PowerRelation object after the other. If all permutations have been exhausted, NULL is returned.

coalitions <- list(c(1,2), 1, 2)
gen <- powerRelationGenerator(coalitions)
while(!is.null(pr <- gen())) {
  print(pr)
}

## (12 ~ 1 ~ 2)
## (12 ~ 1) > 2
## (12 ~ 2) > 1
## (1 ~ 2) > 12
## 12 > (1 ~ 2)
## 1 > (12 ~ 2)
## 2 > (12 ~ 1)
## 12 > 1 > 2
## 12 > 2 > 1
## 1 > 12 > 2
## 2 > 12 > 1
## 1 > 2 > 12
## 2 > 1 > 12

Permutations over power relations can be split into two parts:

1. generating partitions, or, generating differently sized equivalence classes, and
2. moving coalitions between these partitions.

In the code example above, we started with a single partition of size three, wherein all coalitions are considered equally preferable. By the end, we have reached the maximum number of partitions, where each coalition is put inside an equivalence class of size 1.

The partition generation can be reversed, such that we first receive linear power relations.

gen <- powerRelationGenerator(coalitions, startWithLinearOrder = TRUE)
while(!is.null(pr <- gen())) {
  print(pr)
}

## 12 > 1 > 2
## 12 > 2 > 1
## 1 > 12 > 2
## 2 > 12 > 1
## 1 > 2 > 12
## 2 > 1 > 12
## 12 > (1 ~ 2)
## 1 > (12 ~ 2)
## 2 > (12 ~ 1)
## (12 ~ 1) > 2
## (12 ~ 2) > 1
## (1 ~ 2) > 12
## (12 ~ 1 ~ 2)

Notice that the “moving coalitions” part was not reversed, only the order the partitions come in.

Similarly, we are also able to skip the current partition.

gen <- powerRelationGenerator(coalitions)
# partition 3

gen <- generateNextPartition(gen)
# partition 2+1

gen <- generateNextPartition(gen)
# partition 1+2
gen()

## 12 > (1 ~ 2)

Note: the number of possible power relations grows tremendously fast as the number of coalitions rises. To get to that number, first consider how many ways n coalitions can be split into k partitions, also known as the Stirling number of second kind,

$$ S(n,k) = \frac{1}{k!}\ \sum_{j=0}^k (-1)^j \binom{k}{j}(k-j)^n. $$

The number of all possible partitions given n coalitions is known as the Bell number (see also numbers::bell()),

$$ B_n = \sum_{j=0}^k S(n,k). $$

Given a set of coalitions 𝒫 ∈ 2^N, the number of total preorders in 𝒯(𝒫) is

$$ |\mathcal{T}(\mathcal{P})| = \sum_{k=0}^{|\mathcal{P}|} k!\ *\ S(|\mathcal{P}|, k) $$

Creating SocialRanking objects

A SocialRanking object represents a total preorder in 𝒯(N) over the elements of N. Internally they are saved as a list of vectors, each containing players that are indifferent to one another. This is somewhat similar to the equivalenceClasses attribute in PowerRelation objects.

The function doRanking offers a generic way of creating SocialRanking objects. Given a sortable vector or list of scores it determines the power relation between all players, where the names of the elements are determined from the names() attribute of scores. Hence, a PowerRelation object is not necessary to create a SocialRanking object.

# we define some arbitrary score vector where "a" scores highest.
# "b" and "c" both score 1, thus they are indifferent.
scores <- c(a = 100, b = 1, c = 1)
doRanking(scores)

## a > b ~ c

# we can also tell doRanking to punish higher scores
doRanking(scores, decreasing = FALSE)

## b ~ c > a

When working with types that cannot be sorted (i.e., lists), a function can be passed to the compare parameter that allows comparisons between arbitrary elements. This function must take two parameters (i.e., a and b) and return a numeric value based on the comparison:

• compare(a,b) > 0: a scores higher than b,
• compare(a,b) < 0: a scores lower than b,
• compare(a,b) == 0: a and b are equivalent.

scores <- list(a = c(3, 3, 3), b = c(2, 3, 2), c = c(7, 0, 2))
doRanking(scores, compare = function(a, b) sum(a) - sum(b))

## a ~ c > b

# a and c are considered to be indifferent, because their sums are the same

doRanking(scores, compare = function(a,b) sum(a) - sum(b), decreasing = FALSE)

## b > a ~ c

Comparison Functions

Comparison functions only compare two elements in a given power relation. They do not offer a social ranking solution. However in cases such as CP-Majority comparison, those comparison functions may be used to construct a social ranking solution in some particular cases.

pr <- as.PowerRelation("3 > 1 > 2 > 12 > 13 > 23")

# 1 clearly dominates 2
dominates(pr, 1, 2)

## [1] TRUE

dominates(pr, 2, 1)

## [1] FALSE

# 3 does not dominate 1, nor does 1 dominate 3, because
# {}u3 > {}u1, but 2u1 > 2u3
dominates(pr, 1, 3)

## [1] FALSE

dominates(pr, 3, 1)

## [1] FALSE

# an element i dominates itself, but it does not strictly dominate itself
# because there is no Sui > Sui
dominates(pr, 1, 1)

## [1] TRUE

dominates(pr, 1, 1, strictly = TRUE)

## [1] FALSE

pr <- as.PowerRelation("ac > bc ~ b > a ~ abc > ab")

# FALSE because ac > bc, whereas b > a
dominates(pr, "a", "b")

## [1] FALSE

# TRUE because ac > bc, ignoring b > a comparison
dominates(pr, "a", "b", includeEmptySet = FALSE)

## [1] TRUE

pr <- as.PowerRelation("ab > (ac ~ bc) > (a ~ c) > {} > b")
cumulativeScores(pr)

## $a
## [1] 1 2 3 3 3
## 
## $b
## [1] 1 2 2 2 3
## 
## $c
## [1] 0 2 3 3 3
## 
## attr(,"class")
## [1] "CumulativeScores"

# for each index k, $a[k] >= $b[k]
cumulativelyDominates(pr, "a", "b")

## [1] TRUE

# $a[3] > $b[3], therefore a also strictly dominates b
cumulativelyDominates(pr, "a", "b", strictly = TRUE)

## [1] TRUE

# $b[1] > $c[1], but $c[3] > $b[3]
# therefore neither b nor c dominate each other
cumulativelyDominates(pr, "b", "c")

## [1] FALSE

cumulativelyDominates(pr, "c", "b")

## [1] FALSE

pr <- as.PowerRelation("ab > (ac ~ bc) > (a ~ c) > {} > b")
cpMajorityComparisonScore(pr, "a", "b")

## [1]  2 -1

cpMajorityComparisonScore(pr, "b", "a")

## [1]  1 -2

if(sum(cpMajorityComparisonScore(pr, "a", "b")) >= 0) {
  print("a >= b")
} else {
  print("b > a")
}

## [1] "a >= b"

# Now (ac ~ bc) is not counted
cpMajorityComparisonScore(pr, "a", "b", strictly = TRUE)

## [1] 1 0

# Notice that the sum is still the same
sum(cpMajorityComparisonScore(pr, "a", "b", strictly = FALSE)) ==
  sum(cpMajorityComparisonScore(pr, "a", "b", strictly = TRUE))

## [1] TRUE

# extract more information in cpMajorityComparison
cpMajorityComparison(pr, "a", "b")

## a > b
## D_ab = {c, {}}
## D_ba = {c}
## Score of a = 2
## Score of b = 1

# with strictly set to TRUE, coalition c does
# neither appear in D_ab nor in D_ba
cpMajorityComparison(pr, "a", "b", strictly = TRUE)

## a > b
## D_ab = {{}}
## D_ba = {}
## Score of a = 1
## Score of b = 0

Social Ranking Solutions

pr <- as.PowerRelation(list(c(1,2), c(1), c(2)))
pr

## 12 > 1 > 2

# both players 1 and 2 have an Ordinal Banzhaf Score of 1
# therefore they are indifferent to one another
# note that the empty set is missing, as such we cannot compare {}u{i} with {}
ordinalBanzhafScores(pr)

## $`1`
## [1] 1 0 1
## 
## $`2`
## [1] 1 0 1
## 
## attr(,"class")
## [1] "OrdinalBanzhafScores"

ordinalBanzhafRanking(pr)

## 1 ~ 2

pr <- as.PowerRelation("ab > a > {} > b")

# player b has a negative impact on the empty set
# -> player b's score is 1 - 1 = 0
# -> player a's score is 2 - 0 = 2
sapply(ordinalBanzhafScores(pr), function(score) sum(score[c(1,2)]))

## a b 
## 2 0

ordinalBanzhafRanking(pr)

## a > b

pr <- as.PowerRelation("(abc ~ ab ~ c ~ a) > (b ~ bc) > ac")
scores <- copelandScores(pr)

# Based on CP-Majority, a>=b and a>=c (+2), but b>=a (-1)
scores$a

## [1]  2 -1

sapply(copelandScores(pr), sum)

##  a  b  c 
##  1  0 -1

copelandRanking(pr)

## a > b > c

pr <- as.PowerRelation("(abc ~ ab ~ c ~ a) > (b ~ bc) > ac")
kramerSimpsonScores(pr)

##  a  b  c 
## -1 -1 -1 
## attr(,"class")
## [1] "KramerSimpsonScores"

kramerSimpsonRanking(pr)

## a ~ b ~ c

pr <- as.PowerRelation("12 > (123 ~ 23 ~ 3) > (1 ~ 2) > 13")

# show the number of times an element appears in each equivalence class
# e.g. 3 appears 3 times in [[2]] and 1 time in [[4]]
lapply(pr$equivalenceClasses, unlist)

## list()

lexScores <- lexcelScores(pr)
for(i in names(lexScores))
  paste0("Lexcel score of element ", i, ": ", lexScores[i])

# at index 1, element 2 ranks higher than 3
lexScores['2'] > lexScores['3']

## [1] TRUE

# at index 2, element 2 ranks higher than 1
lexScores['2'] > lexScores['1']

## [1] TRUE

lexcelRanking(pr)

## 2 > 1 > 3

lexcelCumulated <- lapply(lexScores, cumsum)
cumulScores <- cumulativeScores(pr)

paste0(names(lexcelCumulated), ": ", lexcelCumulated, collapse = ', ')

## [1] "1: 1:4, 2: c(1, 3, 4, 4), 3: c(0, 3, 3, 4)"

paste0(names(cumulScores), ": ", cumulScores, collapse = ', ')

## [1] "1: 1:4, 2: c(1, 3, 4, 4), 3: c(0, 3, 3, 4)"

pr <- as.PowerRelation("12 > (123 ~ 23 ~ 3) > (1 ~ 2) > 13")

lexScores <- lexcelScores(pr)

# in regular Lexcel, 1 scores higher than 3
lexScores['1'] > lexScores['3']

## [1] TRUE

# turn Lexcel score into Dual Lexcel score
dualLexScores <- structure(
  lexScores,
  class = 'DualLexcelScores'
)

# now 1 scores lower than 3
dualLexScores['1'] > dualLexScores['3']

## [1] FALSE

# element 2 comes out at the top in both Lexcel and Dual Lexcel
lexcelRanking(pr)

## 2 > 1 > 3

dualLexcelRanking(pr)

## 2 > 3 > 1

pr <- as.PowerRelation('(12 ~ 1 ~ 23) > 123 > {} > (13 ~ 2 ~ 3)')
L1Scores(pr)

## $`1`
##      [,1] [,2] [,3] [,4]
## [1,]    1    0    0    0
## [2,]    1    0    0    1
## [3,]    0    1    0    0
## 
## $`2`
##      [,1] [,2] [,3] [,4]
## [1,]    0    0    0    1
## [2,]    2    0    0    0
## [3,]    0    1    0    0
## 
## $`3`
##      [,1] [,2] [,3] [,4]
## [1,]    0    0    0    1
## [2,]    1    0    0    1
## [3,]    0    1    0    0
## 
## attr(,"class")
## [1] "L1Scores"

L1Ranking(pr)

## 1 > 2 > 3

L2Ranking(pr)

## 1 > 2 > 3

pr2 <- as.PowerRelation('1 ~ 23 ~ 24 ~ 234')
pr2 <- appendMissingCoalitions(pr2)
L1Ranking(pr2)

## 1 > 2 > 3 ~ 4

L2Ranking(pr2)

## 2 > 3 ~ 4 > 1

LPScores(pr)

## $`1`
## [1] 1 0 0
## 
## $`2`
## [1] 4 2 1
## 
## $`3`
## [1] 4 1 1
## 
## attr(,"class")
## [1] "LPScores"

LPRanking(pr)

## 1 > 2 > 3

L1Scores(pr)

## $`1`
##      [,1] [,2] [,3] [,4]
## [1,]    1    0    0    0
## [2,]    1    0    0    1
## [3,]    0    1    0    0
## 
## $`2`
##      [,1] [,2] [,3] [,4]
## [1,]    0    0    0    1
## [2,]    2    0    0    0
## [3,]    0    1    0    0
## 
## $`3`
##      [,1] [,2] [,3] [,4]
## [1,]    0    0    0    1
## [2,]    1    0    0    1
## [3,]    0    1    0    0
## 
## attr(,"class")
## [1] "L1Scores"

LPSScores(pr)

## $`1`
##     
## [1,]
## [2,]
## 
## $`2`
##      [,1] [,2] [,3]
## [1,]    2    0    0
## [2,]    0    1    0
## 
## $`3`
##      [,1] [,2] [,3]
## [1,]    1    0    0
## [2,]    0    1    0
## 
## attr(,"class")
## [1] "LP*Scores"

LPSRanking(pr)

## 1 > 2 > 3

Incidence Matrix

In our vignette we focused more on the intuitive aspects of power relations and social ranking solutions. To reiterate, a power relation is a total preorder, or a reflexive and transitive relation  ≿  ∈ 𝒫 × 𝒫, where ∼ denotes the symmetric part and ≻ its asymmetric part.

A power relation can be represented as an incidence matrix (b_ij) = B ∈ {0, 1}^{|𝒫| × |𝒫|}. Given two coalitions i, j ∈ 𝒫, if iRj then b_ij = 1, else 0.

With the help of the relations package, the functions relations::as.relation(pr) and powerRelationMatrix(pr) turn a PowerRelation object into a relation object. relations then offers ways to display the relation object as an incidence matrix with relation_incidence(rel) and to test basic properties such relation_is_linear_order(rel), relation_is_acyclic(rel) and relation_is_antisymmetric(rel) (see relations package for more [12]).

pr <- as.PowerRelation("ab > a > {} > b")
rel <- relations::as.relation(pr)

relations::relation_incidence(rel)

## Incidences:
##    ab ​a ​​{} ​​​b
## ab  1 1  1 1
## ​a   0 1  1 1
## ​​{}  0 0  1 1
## ​​​b   0 0  0 1

c(
  relations::relation_is_acyclic(rel),
  relations::relation_is_antisymmetric(rel),
  relations::relation_is_linear_order(rel),
  relations::relation_is_complete(rel),
  relations::relation_is_reflexive(rel),
  relations::relation_is_transitive(rel)
)

## [1] TRUE TRUE TRUE TRUE TRUE TRUE

Note that the columns and rows are sorted by their names in relation_domain(rel), hence why each name is preceded by the ordering number.

# a power relation where coalitions {1} and {2} are indifferent
pr <- as.PowerRelation("12 > (1 ~ 2)")
rel <- relations::as.relation(pr)

# we have both binary relations {1}R{2} as well as {2}R{1}
relations::relation_incidence(rel)

## Incidences:
##    12 ​1 ​​2
## 12  1 1 1
## ​1   0 1 1
## ​​2   0 1 1

# FALSE
c(
  relations::relation_is_acyclic(rel),
  relations::relation_is_antisymmetric(rel),
  relations::relation_is_linear_order(rel),
  relations::relation_is_complete(rel),
  relations::relation_is_reflexive(rel),
  relations::relation_is_transitive(rel)
)

## [1] FALSE FALSE FALSE  TRUE  TRUE  TRUE

Cycles and Transitive Closure

A cycle in a power relation exists, if there is one coalition S ∈ 2^N that appears twice. For example, in {1, 2} ≻ ({1} ∼ ∅) ≻ {1, 2}, the coalition {1, 2} appears at the beginning and at the end of the power relation.

Properly handling power relations and calculating social ranking solutions with cycles is somewhat ill-defined, hence a warning message is shown as soon as one is created.

as.PowerRelation("12 > 2 > (1 ~ 2) > 12")

## Warning in createLookupTables(equivalenceClasses): Found 2 duplicate coalitions, listed below. This violates transitivity and can cause issues with certain ranking solutions. You may want to take a look at socialranking::transitiveClosure().
##     - {2}
##     - {1, 2}

## 12 > 2 > (1 ~ 2) > 12

Recall that a power relation is transitive, meaning for three coalitions x, y, z ∈ 2^N, if xRy and yRz, then xRz. If we introduce cycles, we pretty much introduce symmetry. Assume we have the power relation x ≻ y ≻ x. Then, even though xRy and yRx are defined as the asymmetric part of the power relation ≿, together they form the symmetric power relation x ∼ y.

transitiveClosure(pr) is a function that turns a power relation with cycles into one without one. In the process of removing duplicate coalitions, it turns all asymmectric relations within a cycle into symmetric relations.

pr <- suppressWarnings(as.PowerRelation(list(1, 2, 1)))
pr

## 1 > 2 > 1

transitiveClosure(pr)

## (1 ~ 2)

# two cycles, (1>3>1) and (2>23>2)
pr <- suppressWarnings(
  as.PowerRelation("1 > 3 > 1 > 2 > 23 > 2")
)

transitiveClosure(pr)

## (1 ~ 3) > (2 ~ 23)

# overlapping cycles
pr <- suppressWarnings(
  as.PowerRelation("c > ac > b > ac > (a ~ b) > abc")
)

transitiveClosure(pr)

## c > (ac ~ b ~ a) > abc