how to combine logically the data on columns of a pandas DataFrame to generate a new DataFrame?

I've made a programm that return a "belonging table" DataFrame of edges of Multigraph that models a Electrical Grid.
each line is a a path between a load and a source, the columns are the names of the lines that connect the load to the source.

The program I wrote generates an output df that looks like this one, but much larger.

import pandas as pd

belonging = pd.DataFrame({'A': {0: False, 1: False, 2: True, 3: True},
              'B': {0: True, 1: True, 2: False, 3: False},
              'C': {0: False, 1: True, 2: False, 3: True},
              'D': {0: True, 1: False, 2: True, 3: False}})

>>>
       A      B      C      D      E     F
0  False  False   True  False   True  True
1  False  False   True   True  False  True
2   True   True  False  False   True  True
3   True   True  False   True  False  True

Now I need to generate a "failure modes" table, that give an output that would be like this:

result = pd.DataFrame(
    {'Failure Modes' : {0: 'F', 1: 'A // C', 2: "B // C", 3: "D // E"},
     'Order of Failure' : {0: 1, 1: 2, 2: 2, 3: 2}
    }
)
>>> 
  Failure Modes  Order of Failure
0             F                 1
1        A // C                 2
2        B // C                 2
3        D // E                 2

The failure Modes table is contructed from the boolean value of the columns, if all the items in a column are true, than that is a first order of faliure. The second order of faliure tries to check for the truth values of every two columns, except those already found to be a first order.
And so on the nth-order. with n <= len(belonging.columns).

Describing it makes it sound simpler to me than I can write in code. Thank you in advance.

To get the nth-order failure modes, you'll need to construct the powerset of each of your columns and then evaluate your logical operaiton:

import pandas as pd
from itertools import combinations
from numpy import logical_xor

belonging = pd.DataFrame({
    'A': {0: False, 1: False, 2: True, 3: True},
    'B': {0: False, 1: False, 2: True, 3: True},
    'C': {0: True, 1: True, 2: False, 3: False},
    'D': {0: False, 1: True, 2: False, 3: True},
    'E': {0: True, 1: False, 2: True, 3: False},
    'F': {0: True, 1: True, 2: True, 3: True},
})

def powerset(entities):
    for i in range(len(entities)+1):
        yield from combinations(entities, r=i)

failures = {}
for cols in powerset(belonging.columns):
    if len(cols) == 0: continue
    failures['//'.join(cols)] = {
        'failure': logical_xor.reduce(belonging[list(cols)], axis=1).all(),
        'order': len(cols)
    }

test_df = pd.DataFrame.from_dict(failures, orient='index')

print(test_df)
                  failure  order
A                   False      1
B                   False      1
C                   False      1
D                   False      1
E                   False      1
...                   ...    ...
A//B//C//E//F       False      5
A//B//D//E//F       False      5
A//C//D//E//F        True      5
B//C//D//E//F        True      5
A//B//C//D//E//F    False      6

[63 rows x 2 columns]

Now that we have evaluated our test on every member of our powerset, we can use a simple filtering operation to locate the members who met our logical test:

print(
    test_df.loc[lambda d: d['failure']]
)

               failure  order
F                 True      1
A//C              True      2
B//C              True      2
D//E              True      2
A//B//F           True      3
A//B//D//E        True      4
A//C//D//E//F     True      5
B//C//D//E//F     True      5

To account for columns that you have encountered in a previous order, we can update our for-loop as follows:

from collections import defaultdict

# same as the above code (data & powerset fn)
# ...

failures = {}
seen = defaultdict(set)
for cols in powerset(belonging.columns):
    if len(cols) == 0 or seen[len(cols)].issuperset(cols):
        continue

    failures['//'.join(cols)] = {
        'failure': logical_xor.reduce(belonging[list(cols)], axis=1).all(),
        'order': len(cols)
    }

    # updated current order seen data w/ previous order seen data
    seen[len(cols)] = seen[len(cols)].union(seen[len(cols)-1])

    # update current order seen data w/ columns that exhibit a failure
    if failures['//'.join(cols)]['failure']:
        seen[len(cols)] = seen[len(cols)].union(cols)

    # break out early once we have attributed failures to all columns
    if len(seen[len(cols)]) == len(belonging.columns):
        break

test_df = pd.DataFrame.from_dict(failures, orient='index')

print(test_df)
      failure  order
A       False      1
B       False      1
C       False      1
D       False      1
E       False      1
F        True      1
A//B    False      2
A//C     True      2
A//D    False      2
A//E    False      2
B//C     True      2
B//D    False      2
B//E    False      2
C//D    False      2
C//E    False      2
D//E     True      2

print(test_df.loc[lambda d: d['failure']])
      failure  order
F        True      1
A//C     True      2
B//C     True      2
D//E     True      2

Using the soluting presented by @Cammeron Riddel and @Mozway I got to this solution to the problem:

bt = pd.DataFrame({
    'a': [False, False, True,True],
    'b': [False, False, True, True],
    'c': [True, True, False, False],
    'd': [False, True, False, True],
    'e': [True, False, True, False],
    'f': [True, True, True, True],
    })
# bt = belonging_table

def power_set(entities):
    for i in range(len(entities)+1):
        yield from combinations(entities, r=i)

seen = defaultdict(set)
failures = pd.DataFrame(columns=['Oder'])
for columns in power_set(bt.columns):

    order = len(columns)
    last_order = order - 1

    seen[order] = seen[order].union(seen[last_order])

    if len(columns) == 0 or set(columns).intersection(seen[last_order]):
        continue

    if logical_xor.reduce(bt[list(columns)], axis=1).all():
        failures.loc['//'.join([str(edge) for edge in columns])] = order
        seen[order] = seen[order].union(columns)

    if len(seen[order]) == len(bt.columns):
        break

failures

    Order
f	    1
a//c	2
b//c	2
d//e	2

This changes where made because of errors found in larger origin destiny pairs with up too 500 different paths