poseticDataAnalysis: Posetic Data Analysis

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 alessandro.avellone@unimib.it

Authors:

• Lucio De Capitani lucio.decapitani1@unimib.it

• Marco Fattore marco.fattore@unimib.it

Computing the BLS dominance matrix of a poset.

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)

Bidimensional representation of multidimensional ordinal binary data generated by a specific reversed pair of lexicographic linear extensions

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)

Constructing a component-wise poset of binary vectors.

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)

An S4 class to represent a Binary Variable POSet.

Description

An S4 class to represent a Binary Variable POSet.

Slots

ptr

an external pointer to C++ data

Estimating function averages on linear extensions, by the Bubley-Dyer procedure.

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)

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

Description

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

Slots

ptr

an external pointer to a C++ data

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

Description

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

Slots

ptr

an external pointer to C++ data

Approximating MRP matrix computation, using the Bubley-Dyer procedure.

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)

Generator of an approximated MRP matrix.

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)

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

Description

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

Slots

ptr

an external pointer to C++ data

Approximated separation matrices computation, using the Bubley-Dyer procedure (see Bubley and Dyer, 1999).

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 ( seeBuildBubleyDyerSeparationGenerator()); 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)

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

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

Generator for the approximated computation of the mean value of functions over linear extensions.

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)

Generator of an approximated separation matrix.

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")

Extracting the comparability set of a poset element.

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")

Computing the cover matrix of a poset.

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)

Computing the cover relation of a poset.

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)

Building crowns.

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)

Disjoint sum of posets.

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)

Computing the dominance matrix.

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)

Checking whether one element dominates another.

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")

Computing downsets.

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"))

Dual of a poset.

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)

Computing function mean values on linear extensions

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)

Computing Mutual Ranking Probabilities (MRP).

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)

An S4 class to represent the exact MRP generator.

Description

An S4 class to represent the exact MRP generator.

Slots

ptr

an external pointer to C++ data

Exact separation matrices computation.

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")

Building fences.

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")

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

Description

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

Slots

ptr

an external pointer to C++ data

Fuzzy in-betweenness array computation

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")

Fuzzy in-betweenness array computation with minimum t-norm and maximum t-conorm

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")

Fuzzy in-betweenness array computation with Product t-norm and Probabilistic-sum t-conorm

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")

Fuzzy separation matrix computation

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")

Fuzzy Separation computation with minimum t-norm and maximum t-conorm

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")

Fuzzy Separation matrix computation with Product t-norm and Probabilistic-sum t-conorm

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")

Computing the incomparability relation of a poset.

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)

Extracting the incomparability set of a poset element.

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")

Computing the intersection of a collection of posets.

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)

Checking binary relation antisymmetry.

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)

Checking comparability between two elements of a poset.

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")

Checking whether one element is dominated by another.

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")

Checking for downsets.

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"))

Checking poset extensions.

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)

Checking incomparability between two elements of a poset.

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")

Checking maximality.

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")

Checking minimality.

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")

Checking for partial ordering.

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)

Checking for pre-ordering (or quasi-ordering).

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)

Checking binary relation reflexivity.

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)

Checking binary relation symmetry.

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)

Checking binary relation transitivity.

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)

Checking upsets.

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"))

Generator of linear extensions through the Bubley-Dyer procedure.

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)

Generator of all the linear extensions of a poset.

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)

An S4 class to represent the exact linear extension generator.

Description

An S4 class to represent the exact linear extension generator.

Slots

ptr

an external pointer to C++ data

Generates linear extensions of a given poset, by using a linear extension generator

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)

MRP matrix computation over the set of lexicographic linear extensions.

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

Value

the MRP matrix computed over the set of lexicographic linear extensions.

Examples

#variables with common number of degrees
# default labels for variable degrees
nvar <- 3
deg  <- 4
lMRP <- LexMRP(nvar=nvar, deg=deg)

#user supplied variable degree labels
nvar <- 3
deg  <- c("a","b","c","d")
lMRP <- LexMRP(nvar=nvar, deg=deg)


#variables with different numbers of degrees
# default labels for variable degrees
nvar <- 3
deg  <- c(4,2,3)
lMRP <- LexMRP(nvar=nvar, deg=deg)

#user supplied variable degree labels
nvar <- 3
deg  <- list(c("a","b","c","d"),c("0","1"),c("x","y","z"))
lMRP <- LexMRP(nvar=nvar, deg=deg)

Separation matrices computation over the set of lexicographic linear extensions.

Description

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

Usage

LexSeparation(nvar, deg, type, ...)

Arguments

Value

list of required separation matrices.

Examples

#variables with common number of degrees
# default labels for variable degrees
nvar <- 3
deg  <- 4
LexSep <- LexSeparation(nvar=nvar, deg=deg, type= "symmetric", "asymmetricLower")

#user supplied variable degree labels
nvar <- 3
deg  <- c("a","b","c","d")
LexSep <- LexSeparation(nvar=nvar, deg=deg, type= "symmetric", "asymmetricLower")


#variables with different numbers of degrees
# default labels for variable degrees
nvar <- 3
deg  <- c(4,2,3)
LexSep <- LexSeparation(nvar=nvar, deg=deg, type= "symmetric", "asymmetricLower")

#user supplied variable degree labels
nvar <- 3
deg  <- list(c("a","b","c","d"),c("0","1"),c("x","y","z"))
LexSep <- LexSeparation(nvar=nvar, deg=deg, type= "symmetric", "asymmetricLower")

Computing lexicographic product orders.

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)

An S4 class to represent a Lexicographic Product POSet.

Description

An S4 class to represent a Lexicographic Product POSet.

Slots

ptr

an external pointer to C++ data

Lifting posets.

Description

Lifts the input poset, i.e. adds a (possibly new) bottom element to it.

Usage

LiftingPOSet(poset, element)

Arguments

Value

The lifted 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)

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

#Lifting
lifted.pos <- LiftingPOSet(pos, "bot")

Constructing a Linearly Ordered Set.

Description

Constructs a linearly (or completely, or totally) ordered set (V,\leq_{lin}), starting from set V,

Usage

LinearPOSet(elements)

Arguments

Value

An object of S4 class LinearPOSet (subclass of POSet)

Examples

elems <- c("a", "b", "c", "d")
linpos <- LinearPOSet(elements = elems)

An S4 class to represent a Linear POSet.

Description

An S4 class to represent a Linear POSet.

Slots

ptr

an external pointer to C++ data

Linear sum of posets.

Description

Computes the linear sum of the input posets.

Usage

LinearSumPOSet(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 linear 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\leq_i b for some i, or a\in V_i and b\in V_j, with i<j. In other words, the linear sum is obtained by stacking the input posets from bottom, and making all of the minimal elements of P_i covering all of the maximal elements of P_{i-1} (i>1).

Value

The linear 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)

#Linear sum of pos1 and pos2
lin.sum <- LinearSumPOSet(pos1, pos2)

Dimensionality reduction of multidimensional ordinal binary data

Description

Starting from a dataset with 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 that optimally preserves the input order relation. The algorithm finding the best bidimensional representation is optimized by using a parallel C++ implementation.

Usage

OptimalBidimensionalEmbedding(
  profile,
  weights,
  output_every_sec = NULL,
  thread_share = 1
)

Arguments

Value

a list of 5 elements named allLoss, variablesPriority, bestLossVAlue, bestVariablePriority, and bestRepresentation.

allLoss is a vector of dimension k!/2 reporting the value of the loss function L(D^{out}|D^{inp},p) corresponding to the representation induced by each reversed pairs of lexicographic linear extensions. This loss function measures the global errors made in approximating the order structure of the input Boolean Lattice B_k with its bidimensional representations.

variablesPriority is a matrix with k!/2 rows and k columns. Each row is an integer vector of dimension k containing a permutation i_1,...,i_k of 1,...,k. This vector specifies the criterion to build the reversed pair of lexicographic linear extensions used to approximate B_k. The first linear extension is built by ordering profiles first according to their scores on V_{i_1}, then to the scores on V_{i_{2}} and so on, until V_{i_{k}}; the second linear extension is built by ordering profiles first according to their scores on V_{i_k}, then to the scores on V_{i_{k-1}} and so on, until V_{i_{1}}. The j-th row of variablesPriority identifies the reversed pair of lexicographic linear extensions inducing the bidimensional representation associated to the j-th global loss in allLoss.

bestLossVAlue real number indicating the minimum value of the global error L(D^{out}|D^{inp},p) among the k!/2 global errors associated to the different pairs of reversed lexicographic linear extensions.

bestVariablePriority integer vector of dimension k containing the permutation of 1,...,k inducing the best bidimensional representation, i.e. the bidimensional representation with associated global error bestLossVAlue.

bestRepresentation 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 optimal bidimensional representation. ⁠$y⁠ is an integer vector containing the y-coordinates of points representing observed profiles in the optimal 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 optimal 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)
#FINDING THE OPTIMAL BIDIMENSIONAL REPRESENTATION
result <- OptimalBidimensionalEmbedding(profiles, weights)

Extracting the order relation of a poset.

Description

Extracts the order relation from the input poset.

Usage

OrderRelation(poset)

Arguments

Value

A two-column matrix M of character strings (element M[i,2] dominates 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 <- OrderRelation(pos)

Constructing a Partially Ordered Set.

Description

Constructs an object of class POSet, representing a partially ordered set (poset) P=(V,\leq).

Usage

POSet(elements, dom = matrix(ncol = 2, nrow = 0))

Arguments

Value

An object (V, \leq) of S4 class POSet, where V is the ground set and \leq is the partial order relation on it

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)

An S4 class to represent a POSet.

Description

An S4 class to represent a POSet.

Slots

ptr

an external pointer to C++ data

Getting poset elements.

Description

Gets the elements of the ground set V of the input poset (V,\leq).

Usage

POSetElements(poset)

Arguments

Value

A vector of labels (the names of the elements of the ground set V).

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)

gset <- POSetElements(pos)

Computing join (least upper bound).

Description

The function computes the join (if existing) of a set of elements, in the input poset.

Usage

POSetJoin(poset, elements)

Arguments

Value

A character string (the name of the join).

Examples

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

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

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

lub<-POSetJoin(pos, c("a", "c"))

Computing the maximal elements of a poset.

Description

Computes the maximal elements of the input poset, i.e. those elements being strictly dominated by no other elements.

Usage

POSetMaximals(poset)

Arguments

Value

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

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)

mxs <- POSetMaximals(pos)

Computing meet (greatest lower bound).

Description

The function computes the meet (if existing) of a set of elements, in the input poset.

Usage

POSetMeet(poset, elements)

Arguments

Value

A character string (the name of the meet).

Examples

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

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

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

glb<-POSetMeet(pos, c("b", "e"))

Computing the minimal elements of a poset.

Description

Computes the minimal elements of the input poset, i.e. those elements strictly dominating no other elements.

Usage

POSetMinimals(poset)

Arguments

Value

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

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)

mnms <-POSetMinimals(pos)

Constructing the product of posets.

Description

Constructs the product poset (V, \leq_{prd}), starting from a collection of posets.

Usage

ProductPOSet(poset1, poset2, ...)

Arguments

Details

Let P_1 = (V_1, \leq_1), ..., P_k = (V_k, \leq_k) be a collection of posets. The product poset P=P_1 \times...\times P_k is the poset (V, \leq_{prd}) where V=V_1\times...\times V_k and given (a_1, ..., a_k)\in V and (b_1, ..., b_k)\in V, (a_1, ..., a_k)\leq_{prd} (b_1, ..., b_k) if and only if a_i\leq_i b_i for all i=1, ..., k.

Value

The product poset, an object of S4 class ProductPOSet (subclass of POSet).

Examples

elems1 <- c("a", "b", "c", "d")
elems2 <- c("x", "y", "z")
elems3 <- c("q", "r")

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

p1 <- POSet(elements = elems1, dom = dom)
p2 <- LinearPOSet(elements = elems2)
p3 <- LinearPOSet(elements = elems3)

prd12 <- ProductPOSet(p1, p2)

prd123 <- ProductPOSet(p1, p2, p3)

An S4 class to represent a Product POSet.

Description

An S4 class to represent a Product POSet.

Slots

ptr

an external pointer to C++ data

Computing reflexive closure.

Description

Computes the reflexive closure of the input binary relation.

Usage

ReflexiveClosure(set, rel)

Arguments

Value

A reflexive binary relation, as a two-columns character matrix (each row comprises an element (pair) of the transitivity closed relation).

Examples

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

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

r.clo<-ReflexiveClosure(set, rel)

Computing transitive closure.

Description

Computes the transitive closure of the input binary relation.

Usage

TransitiveClosure(rel)

Arguments

Value

A transitive binary relation, as a two-columns character matrix (each row comprises an element (pair) of the transitivity closed relation).

Examples

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

t.clo<-TransitiveClosure(rel)

Computing upsets.

Description

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

Usage

UpsetOf(poset, elements)

Arguments

Value

A vector of character strings (the names of the poset elements in the upset).

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)

up <- UpsetOf(pos, c("a","c"))