Encontrando relações numéricas entre colunas

Para resolver seu problema, eu sugiro fortemente que você vetorize seus dados e use o mínimo possível de operações Pandas, já que muitas operações são necessárias e, consequentemente, quanto mais pudermos confiar somente no NumPy, mais rápido o código será executado (o núcleo do NumPy é escrito em C ).

Como há várias operações a serem consideradas ( +, -, *, /), precisamos calcular cada resultado e compará-lo com target_column, mas podemos ser mais eficientes em termos de espaço usando uma máscara booleana (ou seja, um array NumPy ), que é uma coluna que representa, como um valor booleano, a expressão target_column == col1 operation col2. Observe que, tendo um float possível em df, é melhor usar numpy.isclose()to , que podemos definir um limite para as operações de float.

Seu código poderia ser algo assim (incluí um pequeno exemplo no final):

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

def detect_relations(df, numeric_cols, float_tolerance=1e-8):
    results = []
    ops = {
        "+": [(lambda x, y: x + y, "a + b")],   # No need to have `b + a` since sum is commutative
        "-": [
            (lambda x, y: x - y, "a - b"),
            (lambda x, y: y - x, "b - a")
        ],
        "*": [(lambda x, y: x * y, "a * b")],   # Same as sum, `a * b = b * a`
        "/": [
            # We need to ensure that we don't divide by 0
            (lambda x, y: np.divide(x, y, out=np.full_like(x, np.nan, dtype=float), where=(y != 0)), "a / b"),
            (lambda x, y: np.divide(y, x, out=np.full_like(x, np.nan, dtype=float), where=(x != 0)), "b / a")
        ],
    }
    # Iterating trough every combination
    for col1, col2 in combinations(numeric_cols, 2):
        a = df[col1].values
        b = df[col2].values
        # Iterating trough each possible operation
        for _, functions in ops.items():
            for func, op_name in functions:
                # Calculating the result of the operation `func` between col1 and col2
                val = func(a, b)
                # Confronting the result of `col1 operation col2` to the other numeric columns (avoiding col1 and col2)
                for target in numeric_cols:
                    if target in (col1, col2):
                        continue
                    c = df[target].values
                    # We get a boolean mask with the comparison between `col1 operation col2` and `target_column`
                    mask = np.isclose(val, c, atol=float_tolerance, equal_nan=False)
                    # Counting how many relations we found
                    matches = int(mask.sum())
                    total = len(df)
                    
                    results.append({
                        "col1": col1,
                        "col2": col2,
                        "operation": op_name,
                        "target": target,
                        "matches": matches,
                        "total": total,
                        "pct_match": matches / total
                    })
                
    return pd.DataFrame(results)


# --- Example---
df = pd.DataFrame({
    "a": [1, 2, 3, 4],
    "b": [2, 2, 2, 2],
    "c": [2, 4, 6, 8],
    "d": [2, 0, 1, 8],
})

numeric_cols = ["a", "b", "c", "d"]
res = detect_relations(df, numeric_cols)
# Avoid to print combinations with no relation
print(res[res["matches"] > 0].sort_values("pct_match", ascending=False))

Saída:

   col1 col2 operation target  matches  total  pct_match
6     a    b     a * b      c        4      4       1.00
22    a    c     b / a      b        4      4       1.00
46    b    c     b / a      a        4      4       1.00
7     a    b     a * b      d        2      4       0.50
48    b    d     a + b      a        2      4       0.50
26    a    d     a - b      b        2      4       0.50
58    b    d     b / a      a        2      4       0.50
34    a    d     b / a      b        2      4       0.50
3     a    b     a - b      d        2      4       0.50
5     a    b     b - a      d        1      4       0.25
0     a    b     a + b      c        1      4       0.25
19    a    c     a * b      d        1      4       0.25
18    a    c     a * b      b        1      4       0.25
16    a    c     b - a      b        1      4       0.25
11    a    b     b / a      d        1      4       0.25
10    a    b     b / a      c        1      4       0.25
30    a    d     a * b      b        1      4       0.25
24    a    d     a + b      b        1      4       0.25
23    a    c     b / a      d        1      4       0.25
40    b    c     b - a      a        1      4       0.25
35    a    d     b / a      c        1      4       0.25
31    a    d     a * b      c        1      4       0.25
44    b    c     a / b      a        1      4       0.25
50    b    d     a - b      a        1      4       0.25
56    b    d     a / b      a        1      4       0.25
68    c    d     a / b      a        1      4       0.25
70    c    d     b / a      a        1      4       0.25

Análise de complexidade

Gostaria de salientar que o código acima tem uma certa complexidade de tempo e pode ser lento quando o número de elementos é grande.

O código acima precisa passar por uma série de ciclos:

• através de todas as combinações de numerical_cols, isto é (m choose 2) = m(m-1)/2 ~ O(m^2);
• através de todas as possibilidades target, ou seja O(m - 2) = O(m);
• a comparação feita pelo numpy.isclose()ciclo através de cada elemento ne, portanto, tem complexidade de O(n).

Considerando esses ciclos, é fácil ver como o código tem complexidade de tempo de O(m^2 * m * n) = O(n * m^3), então o tempo necessário aumentará cubicamente em relação ao número de colunas numéricas e linearmente em relação ao número de elementos em cada coluna.