Package 'poseticDataAnalysis'

Description

Build and manipulate partially ordered sets (posets), to perform some data analysis on them and to implement multi-criteria decision making procedures. Several efficient ways for generating linear extensions are implemented, together with functions for building mutual ranking probabilities, incomparability, dominance and separation scores (Fattore, M., De Capitani, L., Avellone, A., Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. ANNALS OF OPERATIONS RESEARCH doi:10.1007/s10479-024-06352-3).

Author(s)

Maintainer: Alessandro Avellone [email protected]

Authors:

• Alessandro Avellone [email protected]

• Lucio De Capitani [email protected]

• Marco Fattore [email protected]

Description

Starting from a dataset related to $n$ statistical units, scored against $k$ ordinal 0/1-indicators and partially ordered component-wise into a Boolean lattice $B_k=(\{0,1\}^k,\leq_{cmp})$, it finds the bidimensional data representation generated by a specific reversed pair of lexicographic linear extensions.

Usage

BidimentionalPosetRepresentation(profile, weights, variablesPriority)

Arguments

Value

a list of 2 elements named 'LossVAlue' and 'Representation'.

'LossVAlue' real number indicating the value of the global error $L(D^{out}|D^{inp}, p)$ corresponding to the representation induced by the chosen 'variablesPriority'.

'Representation' a data frame with $m$ values (one value for each observed profile) of 5 variables named 'profiles', 'x', 'y', 'weights' and 'error'. '$profile' is an integer vector containing the base-10 representation of the $k$-dimensional Boolean vectors representing observed profiles. '$x' is an integer vector containing the x-coordinates of points representing observed profiles in the bidimensional representation. '$y' is an integer vector containing the y-coordinates of points representing observed profiles in the bidimensional representation. '$weights' is a real vector with the frequencies/weights of each observed profile. '$error' is a real vector with the values of the approximation errors $L(b|D^{inp}, p)$ associated to each observed profile in the bidimensional representation.

Examples

#SIMULATING OBSERVED BINARY DATA
#number of binary variables
k <- 6
#building observed profiles matrix
profiles <- sapply((0:(2^k-1)) ,function(x){ as.integer(intToBits(x))})
profiles <- t(profiles[1:k, ])
#building the vector of observation frequencies
weights <- sample.int(100, nrow(profiles), replace=TRUE)
#Chosing (at random) a variable priority
vp <- sample.int(k, k, replace=FALSE)
result <- BidimentionalPosetRepresentation(profiles, weights, vp)

Description

Constructs a component-wise poset, starting from a collection of binary variables.

Usage

BinaryVariablePOSet(variables)

Arguments

Details

Given $k$ input binary variables, the function produces a poset $(V,\leq_{cmp})$, where $V$ is the set of $2^k$ binary vectors built from the variables, and $\leq_{cmp}$ is the component-wise order.

Value

An object of S4 class 'BinarVariablePOSet' (subclass of 'POSet').

Examples

vrbs <- c("var1", "var2", "var3")
binPoset <-  BinaryVariablePOSet(variables = vrbs)

Description

An S4 class to represent a Binary Variable POSet.

Slots

ptr

an external pointer to C++ data

Description

Computes the dominance matrix of the input poset, based on the BLS formula of Brueggemann et al. (2003).

Usage

BLSDominance(poset)

Arguments

Value

The BLS dominance matrix

References

Brueggemann R., Lerche D. B., Sørensen P. B. (2003). First attempts to relate structures of Hasse diagrams with mutual probabilities, in: Sørensen P.B., Brueggemann R., Lerche D.B., Voigt K.,Welzl G., Simon U., Abs M., Erfmann M., Carlsen L., Gyldenkærne S., Thomsen M., Fauser P., Mogensen B. B., Pudenz S., Kronvang B. Order Theory in Environmental Sciences Integrative approaches.The 5th workshop held at the National Environmental Research Institute (NERI), Roskilde, Denmark, November 2002. National Environmental Research Institute, Denmark - NERI Technical Report, No. 479.

Examples

el <- c("a", "b", "c", "d")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)
pos <- POSet(elements = el, dom = dom)

res <- BLSDominance(pos)

Description

'BubleyDyerEvaluation' computes the averages of the input functions (defined on linear orders) over a subset of linear extensions of the input poset, randomly generated by the Bubley-Dyer procedure.

Usage

BubleyDyerEvaluation(
  generator,
  n = NULL,
  error = NULL,
  output_every_sec = NULL
)

Arguments

Details

The function 'BubleyDyerEvaluation' allows the user to update previously computed averages, so as to improve estimation accuracy. The 'generator' internally stores the averages computed at each call of 'BubleyDyerEvaluation'. At the subsequent call (with the same 'generator' argument), the previously computed averages are updated, based on the newly sampled linear extensions. In this case, the number of additional linear extensions is determined either directly, by parameter 'n', or indirectly, by specifying parameter 'error', which sets the desired "distance" from uniformity of the sampling distribution of linear extensions, in the Bubley-Dyer procedure. In the latter case, the number of additional linear extensions is computed as $n_\epsilon-n_a$, where $n_\epsilon$ is the number of linear extensions necessary to achive the desired "distance" and $n_a$ is the total number of linear extensions generated in the previous calls of 'BubleyDyerEvaluation'. If $n_\epsilon-n_a\leq 0$, no further linear extensions are generated and a warning message is displayed.

In case new function averages are desired, run 'BubleyDyerEvaluation' with a 'generator' argument newly generated by function 'BuildBubleyDyerEvaluationGenerator'.

Value

List of the estimated averages, along with the number of linear extensions used to compute them.

References

Bubley, R., Dyer, M. (1999). Faster random generation of linear extensions. Discrete Mathematics, 201, 81-88. https://doi.org/10.1016/S0012-365X(98)00333-1

Examples

el1 <- c("a", "b", "c", "d")
el2 <- c("x", "y")
el3 <- c("h", "k")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = el1, dom = dom)

pos2 <- LinearPOSet(elements = el2)

pos3 <- LinearPOSet(elements = el3)

pos <- ProductPOSet(pos1, pos2, pos3)

# median_distr computes the frequency distribution of median profile

elements <- POSetElements(pos)

median_distr <- function(le) {
  n <- length(elements)
  if (n %% 2 != 0) {
    res <- (elements == le[(n + 1) / 2])
  } else {
    res <- (elements == le[n / 2])
  }
  res <- as.matrix(res)
  rownames(res) <- elements
  colnames(res) <- "median_distr"
  return (as.matrix(res))
}

# computation with parameter n
BDgen <- BuildBubleyDyerEvaluationGenerator(poset = pos, seed = NULL, median_distr)
res <- BubleyDyerEvaluation(BDgen, n=40000, output_every_sec=1)
#refinement results with parameter n
res <- BubleyDyerEvaluation(BDgen, n=10000, output_every_sec=1)
#refinement results with parameter error
res <- BubleyDyerEvaluation(BDgen, error=0.2, output_every_sec=1)
#Attempt to further refine results with parameter `error=0.2` does not modify previous result
res <- BubleyDyerEvaluation(BDgen, error=0.2, output_every_sec=1)

# computation with parameter error
BDgen <- BuildBubleyDyerEvaluationGenerator(poset = pos, seed = NULL, median_distr)
res <- BubleyDyerEvaluation(BDgen, error=0.2, output_every_sec=1)

Description

An S4 class to represent function evaluation based on the Bubley-Dyer procedure.

Slots

ptr

an external pointer to a C++ data

Description

An S4 class to represent the linear extension generator based on the Bubley-Dyer procedure.

Slots

ptr

an external pointer to C++ data

Description

Computes an approximated MRP matrix, starting from a set of linear extensions sampled according to the Bubley-Dyer procedure.

Usage

BubleyDyerMRP(generator, n = NULL, error = NULL, output_every_sec = NULL)

Arguments

Details

The function 'BubleyDyerMRP' allows the user to update a previously computed approximated MRP matrix, so as to improve estimation accuracy. Specifically, the argument 'generator' internally stores the approximated MRP matrix computed at each execution of 'BubleyDyerMRP'. At the subsequent call (with the same 'generator' argument), the previously computed MRP are updated, based on the newly sampled linear extensions. In this case, the number of additional linear extensions is determined either directly, by parameter 'n', or indirectly, by specifying parameter 'error', which sets the desired "distance" from uniformity of the sampling distribution of linear extensions, in the Bubley-Dyer procedure. In the latter case, the number of additional linear extensions is computed as $n_\epsilon-n_a$, where $n_\epsilon$ is the number of linear extensions necessary to achive the desired "distance" and $n_a$ is the total number of linear extensions generated in the previous calls of 'BubleyDyerEvaluation'. If $n_\epsilon-n_a\leq 0$, no further linear extensions are generated and a warning message is displayed.

In case a newly computed approximated MRP matrix is desired, run 'BubleyDyerMRP' with a 'generator' argument newly generated by function [BubleyDyerMRPGenerator()].

Value

A list of two elements: 1) the matrix of approximated MRP and 2) the number of linear extensions generated to compute it.

References

Bubley, R., Dyer, M. (1999). Faster random generation of linear extensions. Discrete Mathematics, 201, 81-88. https://doi.org/10.1016/S0012-365X(98)00333-1

Examples

el1 <- c("a", "b", "c")
el2 <- c("x", "y", "z")
el3 <- c("h", "k")
dom <- matrix(c(
  "a", "b",
  "c", "b"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = el1, dom = dom)

pos2 <- LinearPOSet(elements = el2)

pos3 <- LinearPOSet(elements = el3)

pos <- ProductPOSet(pos1, pos2, pos3)

BDgen <- BubleyDyerMRPGenerator(pos)
#MRP computation with parameter n
res <- BubleyDyerMRP(BDgen, n=700000, output_every_sec=1)
#MRP refinement with parameter n
res <- BubleyDyerMRP(BDgen, n=100000, output_every_sec=1)
#MRP refinement with parameter error
res <- BubleyDyerMRP(BDgen, error=0.05, output_every_sec=1)
#Attempt to further refine MRP with parameter `error=0.05` does not modify previous result
res <- BubleyDyerMRP(BDgen, error=0.05, output_every_sec=1)

#new MRP computation with parameter error
BDgen <- BubleyDyerMRPGenerator(pos)
res <- BubleyDyerMRP(BDgen, error=0.05, output_every_sec=1)

Description

Creates an object of S4 class 'BubleyDyerMRPGenerator' for the computation of an approximated MRP matrix, starting from a set of random linear extensions, sampled according to the Bubley-Dyer procedure. Actually, this function does not compute the MRP matrix, but just the object that will compute it, by using function 'BubleyDyerMRP'.

Usage

BubleyDyerMRPGenerator(poset = NULL, seed = NULL)

Arguments

Value

An object of S4 class 'BubleyDyerMRPGenerator'.

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

BDgen <- BubleyDyerMRPGenerator(pos)

Description

An S4 class to represent the MRP generator based on the Bubley-Dyer procedure.

Slots

ptr

an external pointer to C++ data

Description

Computes approximated separation matrices, starting from a set of linear extensions sampled according to the Bubley-Dyer procedure.

Usage

BubleyDyerSeparation(
  generator,
  n = NULL,
  error = NULL,
  output_every_sec = NULL
)

Arguments

Details

See the documentation of [BuildBubleyDyerSeparationGenerator()] for details on how the different types of separations are defined and computed.

Value

A list containing: 1) the required type of approximated separation matrices, according to the parameter 'type' used to build the 'generator' ( see[BuildBubleyDyerSeparationGenerator()]); 2) the number of generated linear extensions.

References

Bubley, R., Dyer, M. (1999). Faster random generation of linear extensions. Discrete Mathematics, 201, 81-88. https://doi.org/10.1016/S0012-365X(98)00333-1

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

BDgen <- BuildBubleyDyerSeparationGenerator(pos, seed = NULL,
                  type="symmetric", "asymmetricUpper", "vertical")

SEP_matrices <- BubleyDyerSeparation(BDgen, n=10000, output_every_sec=5)

Description

An S4 class to represent function separation based on the Bubley-Dyer procedure.

Slots

ptr

an external pointer to a C++ data

types

list of separation to be computed

Description

'BuildBubleyDyerEvaluationGenerator' creates an object of S4 class 'BuildBubleyDyerEvaluationGenerator', for the estimation of the mean values of the input functions, over linear extensions sampled according to the Bubley-Dyer procedure. Actually, this function does not perform the computation of mean values, but just generates the object that will compute them by using function 'BubleyDyerEvaluation'.

Usage

BuildBubleyDyerEvaluationGenerator(poset, seed, f1, ...)

Arguments

Value

An object of S4-class 'BuildBubleyDyerEvaluationGenerator'.

Examples

el1 <- c("a", "b", "c", "d")
el2 <- c("x", "y")
el3 <- c("h", "k")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = el1, dom = dom)

pos2 <- LinearPOSet(elements = el2)

pos3 <- LinearPOSet(elements = el3)

pos <- ProductPOSet(pos1, pos2, pos3)

# median_distr computes the frequency distribution of median profile

elements <- POSetElements(pos)

median_distr <- function(le) {
  n <- length(elements)
  if (n %% 2 != 0) {
    res <- (elements == le[(n + 1) / 2])
  } else {
    res <- (elements == le[n / 2])
  }
  res <- as.matrix(res)
  rownames(res) <- elements
  colnames(res) <- "median_distr"
  return (as.matrix(res))
}

BDgen <- BuildBubleyDyerEvaluationGenerator(poset = pos, seed = NULL, median_distr)

Description

Creates an object of S4 class 'BubleyDyerSeparationGenerator' for the computation of approximated separation matrices, starting from a set of random linear extensions, sampled according to the Bubley-Dyer procedure (see Bubley and Dyer, 1999) Actually, this function does not compute the separation matrices, but just the object that will compute them, by using function 'BubleyDyerSeparation'.

Usage

BuildBubleyDyerSeparationGenerator(poset, seed, type, ...)

Arguments

Details

The symmetric separation associated to elements $a$ and $b$ in the input poset is the average absolute difference between the positions of $a$ and $b$ observed in the sampled linear extensions (whose elements are arranged in ascending order):

$Sep_{ab}=\frac{1}{n}\sum_{i^1}^{n}|Pos_{l_i}(a)-Pos_{l_i}(b)|$,

where $n$ is the numbers of sampled linear extensions; $l_i$ represents a sampled linear extension and $Pos_{l_i}(\cdot)$ stands for the position of element $\cdot$ into the sequence of poset elements arranged in increasing order according to $l_i$.

Asymmetric lower and upper separations are defined as: $Sep_{a < b}=\frac{1}{n}\sum_{i^1}^{n}(Pos_{l_i}(b)-Pos_{l_i}(a))\mathbb{1}(a <_{l_i} b)$, $Sep_{b < a}=\frac{1}{n}\sum_{i^1}^{n}(Pos_{l_i}(a)-Pos_{l_i}(b))\mathbb{1}(b <_{l_i} a)$, where $a\leq_{l_i} b$ means that $a$ is lower or equal to $b$ in the linear order defined by linear extension $l_i$ and $\mathbb{1}$ is the indicator function. Note that $Sep_{ab}=Sep_{a < b}+Sep_{a < b}$.

Vertical and horizontal separations ($vSep$ and $hSep$, respectively) are defined as

$vSep_{ab}=|Sep_{a < b}-Sep_{b < a}|$ and #' $hSep_{ab}=Sep_{ab}-vSep_{ab}|$.

For a detailed explanation on why $vSep$ and $hSep$ can be interpreted as vertical and horizontal components of the separation between two poset elements, see Fattore et. al (2024).

Value

An object of S4 class 'BubleyDyerSeparationGenerator'.

References

Bubley, R., Dyer, M. (1999). Faster random generation of linear extensions. Discrete Mathematics, 201, 81-88. https://doi.org/10.1016/S0012-365X(98)00333-1

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

BDgen <- BuildBubleyDyerSeparationGenerator(pos, seed = NULL,
              type="symmetric", "asymmetricUpper", "vertical")

Description

Extracts the elements comparable with the input element, in the poset.

Usage

ComparabilitySetOf(poset, element)

Arguments

Value

A vector of character strings (the names of the poset elements comparable to the input element).

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

cmp <- ComparabilitySetOf(pos, "a")

Description

Computes the cover matrix of the input poset.

Usage

CoverMatrix(poset)

Arguments

Value

A square boolean matrix $C$ ($C[i,j]=TRUE$ if and only if the $j$-th element of the input poset covers the $i$-th).

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

C <- CoverMatrix(pos)

Description

Computes the cover relation of the input poset.

Usage

CoverRelation(poset)

Arguments

Value

A two-column matrix $M$ of character strings (element $M[i,2]$ covers element $M[i,1]$).

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

M <- CoverRelation(pos)

Description

Builds a crown from two unordered collections of elements, with the same size.

Usage

CrownPOSet(elements_1, elements_2)

Arguments

Details

Let $a_1,\ldots,a_n$ and $b_1,\ldots,b_n$ be two disjoint collections of $n$ elements. The "crown" over them is the poset $P=(V,\lhd)$ having $a_1,\ldots,a_n,b_1,\ldots,b_n$ as ground set and where $(a_i||a_j)$, $(b_i||b_j)$, $(a_i||b_i)$ and $a_i\lhd b_j$, for each $i\neq j$ ($||$ stands for "incomparable to").

Value

A crown, an object of S4 class 'POSet'.

Examples

elems1<-c("a1", "a2", "a3", "a4", "a5")
elems2<-c("b1", "b2", "b3", "b4", "b5")
crown<-CrownPOSet(elems1, elems2)

Description

Computes the disjoint sum of the input posets.

Usage

DisjointSumPOSet(poset1, poset2, ...)

Arguments

Details

Let $P_1=(V_1,\leq_1),\ldots,P_k=(V_k,\leq_k)$ be $k$ posets on disjoint ground sets. Their disjoint sum is the poset $P=(V,\lhd)$ having as ground set the union of the input ground sets, with $a\leq b$ if and only if $a,b\in V_i$ and $a\leq_i b$ for some $i$.

Value

The disjoint sum poset, an object of S4 class 'POSet'.

Examples

elems1 <- c("a", "b", "c", "d")
elems2 <- c("e", "f", "g", "h")

dom1 <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

dom2 <- matrix(c(
  "e", "f",
  "g", "h",
  "h", "f"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = elems1, dom = dom1)

pos2 <- POSet(elements = elems2, dom = dom2)

dsj.sum <- DisjointSumPOSet(pos1, pos2)

Description

Computes the dominance matrix of the input poset.

Usage

DominanceMatrix(poset)

Arguments

Value

An $n\times n$ boolean matrix $Z$, where $n$ is the number of poset elements, with $Z[i,j]=TRUE$, if and only if the j-th poset element weakly dominates ($\leq$) the i-th element, in the input order relation.

Examples

elems <- c("a", "b", "c", "d")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

Z <- DominanceMatrix(pos)

Description

Given two elements $a$ and $b$ of $V$, checks whether $a\leq b$ in poset $(V,\leq)$.

Usage

Dominates(poset, element1, element2)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- Dominates(pos, "a", "d")

Description

Computes the downset of a set of elements of the input poset.

Usage

DownsetOf(poset, elements)

Arguments

Value

A vector of character strings (the names of the elements of the downset).

Examples

elems<- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "a", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

dwn <- DownsetOf(pos, c("b","d"))

Description

Computes the dual of the input poset.

Usage

DualPOSet(poset)

Arguments

Details

Let $P=(V,\leq)$ be a poset. Then its dual $P_d=(V,\leq_d)$ is defined by $a\leq_d b$ if and only if $b\leq a$ in $P$. In other words, the dual of $P$ is obtained by reversing its dominances.

Value

The dual of the input poset, an object of S4 class 'POSet'.

Examples

elems <- c("a", "b", "c", "d")

doms <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = elems, dom = doms)

dual <- DualPOSet(pos1)

Description

'ExactEvaluation' computes the mean values of the input functions (defined on linear orders) over the set of linear extensions of the input poset. The linear extensions are generated according to the algorithm given in Habib M, Medina R, Nourine L and Steiner G (2001).

Usage

ExactEvaluation(poset, output_every_sec = NULL, f1, ...)

Arguments

Value

A list of the computed averages, along with the number of linear extensions generated to compute them.

References

Habib M, Medina R, Nourine L and Steiner G (2001). Efficient algorithms on distributive lattices. Discrete Applied Mathematics, 110, 169-187. https://doi.org/10.1016/S0166-218X(00)00258-4.

Examples

el1 <- c("a", "b", "c", "d")
el2 <- c("x", "y")
el3 <- c("h", "k")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = el1, dom = dom)

pos2 <- LinearPOSet(elements = el2)

pos3 <- LinearPOSet(elements = el3)

pos <- ProductPOSet(pos1, pos2, pos3)

# median_distr computes the frequency distribution of median profile

elements <- POSetElements(pos)

median_distr <- function(le) {
  n <- length(elements)
  if (n %% 2 != 0) {
    res <- (elements == le[(n + 1) / 2])
  } else {
    res <- (elements == le[n / 2])
  }
  res <- as.matrix(res)
  rownames(res) <- elements
  colnames(res) <- "median_distr"
  return (as.matrix(res))
}

res  <- ExactEvaluation(pos, output_every_sec=1, median_distr)

Description

Computes the MRP matrix of a poset. The MRP associated to $a\leq b$, with $a$ and $b$ two elements of the input poset, is the share of linear extensions of it where $b$ dominates $a$. The linear extensions are computed according to the algorithm given in Habib M, Medina R, Nourine L and Steiner G (2001).

Usage

ExactMRP(poset, output_every_sec = NULL)

Arguments

Value

A list of two elements: 1) the MRP matrix and 2) the number of linear extensions generated to compute it.

References

Habib M, Medina R, Nourine L and Steiner G (2001). Efficient algorithms on distributive lattices. Discrete Applied Mathematics, 110, 169-187. https://doi.org/10.1016/S0166-218X(00)00258-4.

Examples

el1 <- c("a", "b", "c", "d")
el2 <- c("x", "y")
el3 <- c("h", "k")
dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = el1, dom = dom)

pos2 <- LinearPOSet(elements = el2)

pos3 <- LinearPOSet(elements = el3)

pos <- ProductPOSet(pos1, pos2, pos3)

MRP <- ExactMRP(pos, output_every_sec=1)

Description

An S4 class to represent the exact MRP generator.

Slots

ptr

an external pointer to C++ data

Description

Computes exact separation matrices by evaluating the average separation over all the linear extensions of the input poset. The linear extensions are generated according to the algorithm given in Habib M, Medina R, Nourine L and Steiner G (2001).

Usage

ExactSeparation(poset, output_every_sec = NULL, type, ...)

Arguments

Details

The symmetric separation associated to two elements $a$ and $b$ of the input poset, is the average absolute difference between the positions of $a$ and $b$ observed over all linear extensions (whose elements are arranged in ascending order):

$Sep_{ab}=\frac{1}{n}\sum_{i^1}^{n}|Pos_{l_i}(a)-Pos_{l_i}(b)|$,

where $n$ is the numbers of linear extensions of the input poset; $l_i$ represents a single linear extension and $Pos_{l_i}(\cdot)$ stands for the position of element $\cdot$ into the sequence of poset elements arranged in increasing order according to $l_i$.

Asymmetric lower and upper separations are defined as: $Sep_{a < b}=\frac{1}{n}\sum_{i^1}^{n}(Pos_{l_i}(b)-Pos_{l_i}(a))\mathbb{1}(a <_{l_i} b)$, $Sep_{b < a}=\frac{1}{n}\sum_{i^1}^{n}(Pos_{l_i}(a)-Pos_{l_i}(b))\mathbb{1}(b <_{l_i} a)$, where $a\leq_{l_i} b$ means that $a$ is lower or equal to $b$ in the linear order defined by linear extension $l_i$ and $\mathbb{1}$ is the indicator function. Note that $Sep_{ab}=Sep_{a < b}+Sep_{a < b}$.

Vertical and horizontal separations ($vSep$ and $hSep$, respectively) are defined as

$vSep_{ab}=|Sep_{a < b}-Sep_{b < a}|$ and #' $hSep_{ab}=Sep_{ab}-vSep_{ab}|$.

For a detailed explanation on why $vSep$ and $hSep$ can be interpreted as vertical and horizontal components of the separation between poset elements, see Fattore et. al (2024).

Value

A list containing: 1) the required type of approximated separation matrices, according to the parameter 'type' used to build the 'generator' (see function 'BuildBubleyDyerSeparationGenerator'); 2) the number of generated linear extensions.

References

Habib M, Medina R, Nourine L and Steiner G (2001). Efficient algorithms on distributive lattices. Discrete Applied Mathematics, 110, 169-187. https://doi.org/10.1016/S0166-218X(00)00258-4.

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

SEP_matrices <- ExactSeparation(pos, output_every_sec=5, "symmetric","asymmetricUpper", "vertical")

Description

Builds a fence, from an unordered collection of elements.

Usage

FencePOSet(elements, orientation = "upFirst")

Arguments

Value

A fence, an object of S4 class 'POSet'.

Examples

elems <- c("a", "b", "c", "d", "e")
fence <- FencePOSet(elems, orientation="upFirst")

Description

An S4 class to represent a virtual class for POSet extention.

Slots

ptr

an external pointer to C++ data

Description

Starting from a poset dominance matrix, computes in-betweenness arrays by using a user supplied t-norm and t-conorm.

Usage

FuzzyInBetweenness(dom, norm, conorm, type, ...)

Arguments

Value

a list of three-dimensional arrays, one array for each type of in-betweenness selected by parameter 'type'. The array element of position $[i,j,k]$ represents $finb_{p_i,p_j,p_k}$ for symmetric in-betweenness, $finb_{p_i<p_j<p_k}$ for asymmetricLower in-betweenness, and $finb_{p_k<p_j<p_i}$ for asymmetricUpper in-betweenness.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

tnorm <- function(x,y){x*y}

tconorm <- function(x,y){x+y-x*y}

FinB <- FuzzyInBetweenness(BLS, norm=tnorm, conorm=tconorm, type="symmetric", "asymmetricLower")

Description

Starting from a poset dominance matrix, computes in-betweenness arrays by using minimum t-norm and maximum t-conorm.

Usage

FuzzyInBetweennessMinMax(dom, type, ...)

Arguments

Value

a list of three-dimensional arrays, one array for each type of in-betweenness selected by parameter 'type'. The array element of position $[i,j,k]$ represents $finb_{p_i,p_j,p_k}$ for symmetric in-betweenness, $finb_{p_i<p_j<p_k}$ for asymmetricLower in-betweenness, and $finb_{p_k<p_j<p_i}$ for asymmetricUpper in-betweenness.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

FinB <- FuzzyInBetweennessMinMax(BLS, type="symmetric", "asymmetricLower")

Description

Starting from a poset dominance matrix, computes in-betweenness arrays by using Product t-norm and Probabilistic-sum t-conorm

Usage

FuzzyInBetweennessProbabilistic(dom, type, ...)

Arguments

Value

a list of three-dimensional arrays, one array for each type of in-betweenness selected by parameter 'type'. The array element of position $[i,j,k]$ represents $finb_{p_i,p_j,p_k}$ for symmetric in-betweenness, $finb_{p_i<p_j<p_k}$ for asymmetricLower in-betweenness, and $finb_{p_k<p_j<p_i}$ for asymmetricUpper in-betweenness.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

FinB <- FuzzyInBetweennessProbabilistic(BLS, type="symmetric", "asymmetricLower")

Description

Starting from a poset dominance matrix, computes fuzzy separation matrices by using the t-norm and t-conorm supplied by the user.

Usage

FuzzySeparation(dom, norm, conorm, type, ...)

Arguments

Value

list of required fuzzy separation matrices.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

tnorm <- function(x,y){x*y}

tconorm <- function(x,y){x+y-x*y}

FSep <- FuzzySeparation(BLS, norm=tnorm, conorm=tconorm,
            type="symmetric", "asymmetricLower", "vertical")

Description

Starting from a poset dominance matrix, computes fuzzy Separation matrices by using minimum t-norm and maximum t-conorm.

Usage

FuzzySeparationMinMax(dom, type, ...)

Arguments

Value

list of required fuzzy separation matrices.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

FSep <- FuzzySeparationMinMax(BLS, type="symmetric", "asymmetricLower", "vertical")

Description

Starting from a poset dominance matrix, computes fuzzy Separation matrices by using Product t-norm and Probabilistic-sum t-conorm

Usage

FuzzySeparationProbabilistic(dom, type, ...)

Arguments

Value

list of required fuzzy separation matrices.

References

Fattore, M., De Capitani, L., Avellone, A., and Suardi, A. (2024). A fuzzy posetic toolbox for multi-criteria evaluation on ordinal data systems. Annals of Operations Research, https://doi.org/10.1007/s10479-024-06352-3.

Examples

el <- c("a", "b", "c", "d")

dom_list <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom_list)

BLS <- BLSDominance(pos)

FSep <- FuzzySeparationProbabilistic(BLS, type="symmetric", "asymmetricLower", "vertical")

Description

Computes the incomparability relation of the input poset.

Usage

IncomparabilityRelation(poset)

Arguments

Value

A two-column matrix $M$ (element $M[i,2]$ is incomparable with element $M[i,1]$).

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

M <- IncomparabilityRelation(pos)

Description

Extracts the elements incomparable with the input element, in the poset.

Usage

IncomparabilitySetOf(poset, element)

Arguments

Value

A vector of character strings (the names of the poset elements incomparable with the input element).

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)
incmp <- IncomparabilitySetOf(pos, "a")

Description

Computes the poset $(V, \leq_{\cap})=(V, \leq_1)\cap\cdots\cap(V,\leq_k)$.

Usage

IntersectionPOSet(poset1, poset2, ...)

Arguments

Details

Let $P_1 = (V, \leq_1),\cdots, P_k = (V, \leq_k)$ be $k$ posets on the same set $V$. The intersection poset $P_{\cap}=P_1 \cap\cdots\cap P_k$ is the poset $(V, \leq_{\cap})$ where $a\leq_{\cap} b$ if and only if $a\leq_i b$ for all $i=1\cdots k$.

Value

The intersection poset, an object of S4 class 'POSet'.

Examples

elems <- c("a", "b", "c", "d")

dom1 <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

dom2 <- matrix(c(
  "a", "b",
  "b", "c",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = elems, dom = dom1)

pos2 <- POSet(elements = elems, dom = dom2)

pos_int <- IntersectionPOSet(pos1, pos2)

Description

Checks whether the input binary relation is antisymmetric.

Usage

IsAntisymmetric(rel)

Arguments

Value

A boolean value.

Examples

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d",
  "a", "a"
), ncol = 2, byrow = TRUE)

chk <- IsAntisymmetric(rel)

Description

Checks whether two elements $a$ and $b$ of $V$ are comparable in the input poset $(V,\leq)$.

Usage

IsComparableWith(poset, element1, element2)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsComparableWith(pos, "a", "d")

Description

Given two elements $a$ and $b$ of $V$, checks whether $a\leq b$ in poset $(V,\leq)$.

Usage

IsDominatedBy(poset, element1, element2)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsDominatedBy(pos, "a", "d")

Description

Checks whether the input elements form a downset, in the input poset.

Usage

IsDownset(poset, elements)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsDownset(pos, c("a", "b", "c"))

Description

Checks whether poset1 is an extension of poset2.

Usage

IsExtensionOf(poset1, poset2)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom1 <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

dom2 <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d",
  "a", "c"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = elems, dom = dom1)
pos2 <- POSet(elements = elems, dom = dom2)

chk <- IsExtensionOf(pos1, pos2)

Description

Checks whether two elements $a$ and $b$ of $V$ are incomparable, in the input poset $(V,\leq)$.

Usage

IsIncomparableWith(poset, element1, element2)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsIncomparableWith(pos, "a", "d")

Description

Checks whether the input element is maximal in the input poset.

Usage

IsMaximal(poset, element)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk<-IsMaximal(pos, "b")

Description

Checks whether the input element is minimal in the input poset.

Usage

IsMinimal(poset, element)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsMinimal(pos, "a")

Description

Checks whether the input binary relation is a partial order.

Usage

IsPartialOrder(set, rel)

Arguments

Value

A boolean value.

Examples

set<-c("a", "b", "c", "d")

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "d", "a",
  "c", "a",
  "d", "b",
  "a", "a",
  "b", "b",
  "c", "c",
  "d", "d"
), ncol = 2, byrow = TRUE)

chk <- IsPartialOrder(set, rel)

Description

Checks whether the input relation is a pre-order (aka, a quasi-order), i.e. if it is reflexive and transitive.

Usage

IsPreorder(set, rel)

Arguments

Value

A boolean value.

Examples

set<-c("a", "b", "c", "d")

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "a",
  "d", "a",
  "c", "a",
  "d", "b",
  "a", "a",
  "b", "b",
  "c", "c",
  "d", "d"
), ncol = 2, byrow = TRUE)

chk<-IsPreorder(set, rel)

Description

Checks whether the input binary relation is reflexive.

Usage

IsReflexive(set, rel)

Arguments

Value

A boolean value.

Examples

set<-c("a", "b", "c", "d", "e")

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d",
  "a", "a",
  "b", "b",
  "c", "c"
), ncol = 2, byrow = TRUE)

chk <- IsReflexive(set, rel)

Description

Checks whether the input binary relation is symmetric.

Usage

IsSymmetric(rel)

Arguments

Value

A boolean value.

Examples

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d",
  "b", "a",
  "b", "c",
  "d", "b"
), ncol = 2, byrow = TRUE)

chk<-isSymmetric(rel)

Description

Checks whether the input relation is transitive.

Usage

IsTransitive(rel)

Arguments

Value

A boolean value.

Examples

rel <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d",
  "a", "d",
  "c", "d"
), ncol = 2, byrow = TRUE)

chk<-IsTransitive(rel)

Description

Checks whether the input elements form an upset, in the input poset.

Usage

IsUpset(poset, elements)

Arguments

Value

A boolean value.

Examples

elems <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = elems, dom = dom)

chk <- IsUpset(pos, c("a", "b", "c"))

Description

Creates an object of S4 class 'LEBubleyDyer', needed to sample the linear extensions of a given poset according to the Bubley-Dyer procedure. Actually, this function does not sample the linear extensions, but just generates the object that will sample them by using function 'LEGet'.

Usage

LEBubleyDyer(poset, seed = NULL)

Arguments

Value

An object of class 'LEBubleyDyer'.

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

LEgenBD <- LEBubleyDyer(pos)

Description

Creates an object of S4 class 'LEGenerator' to generate all of the linear extensions of a given poset. Actually, this function does not generate the linear extensions, but just the object that will generate them by using function 'LEGet'.

Usage

LEGenerator(poset)

Arguments

Value

An S4 class object 'LEGenerator'.

Examples

el <- c("a", "b", "c", "d")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "b", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

LEgen <- LEGenerator(pos)

Description

An S4 class to represent the exact linear extension generator.

Slots

ptr

an external pointer to C++ data

Description

Generates the linear extensions of a poset, by using a linear extension generator built by functions 'LEGenerator' and 'LEBubleyDyer'.

Usage

LEGet(
  generator,
  from_start = TRUE,
  n = NULL,
  error = NULL,
  output_every_sec = NULL
)

Arguments

Value

A matrix whose columns reports the generated linear extensions

References

Bubley, R., Dyer, M. (1999). Faster random generation of linear extensions. Discrete Mathematics, 201, 81-88. https://doi.org/10.1016/S0012-365X(98)00333-1

Habib M, Medina R, Nourine L and Steiner G (2001). Efficient algorithms on distributive lattices. Discrete Applied Mathematics, 110, 169-187. https://doi.org/10.1016/S0166-218X(00)00258-4.

Examples

el <- c("a", "b", "c", "d", "e")

dom <- matrix(c(
  "a", "b",
  "c", "b",
  "c", "d"
), ncol = 2, byrow = TRUE)

pos <- POSet(elements = el, dom = dom)

LEgen <- LEGenerator(pos)
LEmatrix <- LEGet(LEgen)

LEgen <- LEGenerator(pos)
LEmatrix_first <- LEGet(LEgen, n=10)
LEmatrix_second <- LEGet(LEgen, from_start=FALSE)
LEmatrix <- cbind(LEmatrix_first,LEmatrix_second)

#Randomly generate n=30 linear extensions from the poset
LEgen <- LEBubleyDyer(pos)
LEmatrix <- LEGet(LEgen, n=30)

#Randomly generate n=60 linear extensions from the poset in two steps
LEgen <- LEBubleyDyer(pos)
LEmatrix_first <- LEGet(LEgen, n=30)
LEmatrix_second <- LEGet(LEgen, n=30, from_start=FALSE)
LEmatrix <- cbind(LEmatrix_first,LEmatrix_second)

#Generates linear extensions from the poset with precision=1
LEgen <- LEBubleyDyer(pos)
LEmatrix <- LEGet(LEgen, error=0.002)

Description

Computes the lexicographic product order of the input partial orders.

Usage

LexicographicProductPOSet(poset1, poset2, ...)

Arguments

Details

Let $P_1 = (V_1, \leq_1),\cdots, P_k = (V_k, \leq_k)$ be $k$ posets. The lexicographic product poset $P_{lxprd}=(V, \leq_{lxprd})$ has ground set the Cartesian product of the input ground sets, with $(a_1,\ldots,a_k)\leq_{lxprd} (b_1,\ldots,b_k)$ if and only $a_1\leq_1 b_1$, or there exists $j$ such that $a_i=b_i$ for $i<j$ and $a_j\leq_j b_j$.

Value

The lexicographic product poset, an object of S4 class 'POSet'.

Examples

elems1 <- c("a", "b", "c", "d", "e")
elems2 <- c("f", "g", "h")

dom1 <- matrix(c(
  "a", "b",
  "c", "b",
  "d", "b"
), ncol = 2, byrow = TRUE)

dom2 <- matrix(c(
  "g", "f",
  "h", "f"
), ncol = 2, byrow = TRUE)

pos1 <- POSet(elements = elems1, dom = dom1)

pos2 <- POSet(elements = elems2, dom = dom2)

#Lexicographic product of pos1 and pos2
lex.prod <- LexicographicProductPOSet(pos1, pos2)

Description

An S4 class to represent a Lexicographic Product POSet.

Slots

ptr

an external pointer to C++ data

Description

Considering the component-wise poset built stating from $k$ ordinal variables, computes MRP matrix by analyzing all poset lexicographic linear extensions.

Usage

LexMRP(nvar, deg)

Arguments