Maximal elements in partial order

Question

I am looking for Python code to find maximal elements in a partial order.

There are two other posts, which address the problem,

but they only have vague descriptions and no code. Also some years have passed, since these were asked.

edit: To be more specific, both of them suggest building a DAG. My own idea is with some loops, and adding to and deleting from lists. However, I would like to know whether there is some short "pythonic" way, of coding this.

More precisely, I have a list of arrays with entries 0,1; all of the same length. These arrays are the image space of some matrix over GF(2), the field with just 0 and 1.

Let x and y be two arrays. I say x <= y, if this inequality holds piecewise.

edit: More precisely, my inequality is given by the function

def leq(x,y):
  return all([x[i] <= y[i] for i in range(len(x))])

Example

Input:

[1 1 0]
[1 0 0]
[1 0 1]

Output:

[1 1 0]
[1 0 1]

edit I have written down my idea

import numpy as np

l = [np.array([1, 1, 0]), np.array([1, 0, 0]), np.array([0, 1, 1])]
l.sort(reverse=True, key=np.sum)
maximal = [l[0]]
for e in l:
    i = 0
    replaced = False
    while i < len(maximal):
        if (maximal[i] <= e).all():
            if replaced:
                maximal.remove(maximal[i])
            else:
                maximal[i] = e.copy()
                replaced = True
        if (e <= maximal[i]).all():
            break
        i += 1
    if i == len(maximal) and not replaced:
        maximal.append(e.copy())

How can I compute this nicely (shorter code/faster runtime) in Python?

If you cannot find code that does this already, then it is time to write it yourself. — Code-Apprentice, Mar 07 '18 at 15:37
Do `x` and `y` iterate over all possible pairs from the list of inputs? — Code-Apprentice, Mar 07 '18 at 15:38
The first link you gave describes an algorithm in words. I suggest you refine that algorithm until you can translate it into code. — Code-Apprentice, Mar 07 '18 at 15:40
Are you saying something like `[piece for piece in all_pieces if piece.count(1) >= 2]` ? — Pax Vobiscum, Mar 07 '18 at 15:40
`x` and `y` are arbitrary arrays. This was just to make clear which partial order I want. — Hennich, Mar 07 '18 at 15:40
@PaxVobiscum The OP defines `<=` in the last sentence: I say x <= y for two arrays, if this inequality holds piecewise. I take "piecewise" to mean lexicographical ordering — Code-Apprentice, Mar 07 '18 at 15:42
This question is unclear to me. One of the links describes a really simple algorithm to solve this. Can't you just implement it? If not, what's the problem? Please be more specific. — Sven Marnach, Mar 07 '18 at 15:43
I think he means that `x <= y iff array[y][x] = 1` . But this doesn't fit the given arrays, I think the example is for `x < y iff array[y][x]` — kutschkem, Mar 07 '18 at 15:44
@Code-Apprentice No, lexicographical ordering would be a total ordering, and there would be only one maximum. — Sven Marnach, Mar 07 '18 at 15:44
@Code-Apprentice ah ok so he means `array x <= array y iff for all i x[i] <= y[i]` — kutschkem, Mar 07 '18 at 15:46
@Code-Apprentice I gave an explicit definition of my order, even in code. So please stop talking about lexicographic order, this will only lead to confusion. — Hennich, Mar 07 '18 at 17:39
@Hennich I missed that edit. The code definition of your ordering is much more precise than the original description. — Code-Apprentice, Mar 07 '18 at 17:40
@Code-Apprentice In the cases I looked at, yes, the results are correct. (PS: now added numpy import). But it's quite verbose. And I guess more pythonic would also mean faster. — Hennich, Mar 07 '18 at 17:47
@Hennich For a review of working code, try our sister site [codereview.se]. For optimizations, run a profiler to find the bottle necks. — Code-Apprentice, Mar 07 '18 at 18:25

score 0 · Accepted Answer · answered Mar 12 '18 at 14:46

After some more testing, I ended up with the following code. The above code from the question still had some bugs.

import numpy as np

def maximal_elements(input_list):
  """Given a list of np.array, compute the maximal elements.

  Call:
    maximal = maximal_elements(input_list)
  Input:
    input_list: list of np.array, all need to have the same length.
  Output:
    maximal: list of np.array, which contains the maximal elements of input_list,
      the order used is elementwise "<="      
  """
  l = input_list.copy()
  l.sort(reverse=True, key=np.sum)
  maximal = [l[0]]
  for e in l[1:]:
    i = 0
    replaced = False
    while i < len(maximal):
      if (maximal[i] <= e).all():
        if replaced:
          maximal.pop(i)
          i -= 1
        else:
          maximal[i] = e.copy()
          replaced = True
      if (e <= maximal[i]).all():
        if not (e == maximal[i]).all():
          break
      i += 1
    if i == len(maximal) and not replaced:
      maximal.append(e.copy())
  return maximal

import itertools
import random
random.seed(2)
l = [np.array(e) for e in random.sample(list(itertools.product([0,1], repeat=5)), 9)]
maximal_elements(l)

returns [array([1, 1, 1, 1, 0]), array([1, 0, 1, 1, 1]), array([0, 1, 0, 1, 1])]

Maximal elements in partial order

1 Answers1