Look at the code below (the main testing code is in coeffsTest()):

import sympy as sp

# Generate a matrix with all its entries indexed symbols.
# for example, M = [[M1_1, M1_2], [M2_1, M2_2]]
def SymbolMatrix(symbol, shape, **kwargs):
  rows = list()
  for i in range(shape[0]):
    row = list()
    if shape[1] == 1:
      # ele_symbol = symbol + '_' + str(i) + '_' + str(j)
      ele_symbol = symbol + str(i+1)
      row.append(sp.Symbol(ele_symbol, **kwargs))
    else:
      for j in range(shape[1]):
        # ele_symbol = symbol + '_' + str(i) + '_' + str(j)
        ele_symbol = symbol + str(i+1) + '_' + str(j+1)
        row.append(sp.Symbol(ele_symbol, **kwargs))
    rows.append(row)
  return sp.Matrix(rows)

def coeffsTest():
  N = 2
  D = SymbolMatrix('D', (N,N), real=True)
  d = SymbolMatrix('d', (N,1), real=True)
  lambda_ = sp.Symbol('lambda', real=True)

  # test_divisor = True
  test_divisor = False
  if test_divisor:
    g = sp.Symbol('g', real=True, positive=True, nonzero=True)
    expression = sp.det((D - lambda_ * sp.eye(N,N))**2 - ((1/g)**2)*(d*d.T))
  else:
    g_inv = sp.Symbol('(1/g)', real=True)
    expression = sp.det((D - lambda_ * sp.eye(N,N))**2 - (g_inv**2)*(d*d.T))

  collected = sp.collect(expression, lambda_)

  coeff0 = collected.coeff(lambda_, 0)
  coeff1 = collected.coeff(lambda_, 1)
  coeff2 = collected.coeff(lambda_, 2)
  coeff3 = collected.coeff(lambda_, 3)
  coeff4 = collected.coeff(lambda_, 4)

  print("coeff0: {}n".format(coeff0))
  print("coeff1: {}n".format(coeff1))
  print("coeff2: {}n".format(coeff2))
  print("coeff3: {}n".format(coeff3))
  print("coeff4: {}n".format(coeff4))

if __name__ == '__main__':
  coeffsTest()

Output when test_divisor=True:

coeff0: 0

coeff1: 0

coeff2: 0

coeff3: 0

coeff4: 0

Output when test_divisor=False:

coeff0: -(1/g)**2*D1_1**2*d2**2 + (1/g)**2*D1_1*D1_2*d1*d2 + (1/g)**2*D1_1*D2_1*d1*d2 - (1/g)**2*D1_2*D2_1*d1**2 - (1/g)**2*D1_2*D2_1*d2**2 + (1/g)**2*D1_2*D2_2*d1*d2 + (1/g)**2*D2_1*D2_2*d1*d2 - (1/g)**2*D2_2**2*d1**2 + D1_1**2*D2_2**2 - 2*D1_1*D1_2*D2_1*D2_2 + D1_2**2*D2_1**2

coeff1: 2*(1/g)**2*D1_1*d2**2 - 2*(1/g)**2*D1_2*d1*d2 - 2*(1/g)**2*D2_1*d1*d2 + 2*(1/g)**2*D2_2*d1**2 - 2*D1_1**2*D2_2 + 2*D1_1*D1_2*D2_1 - 2*D1_1*D2_2**2 + 2*D1_2*D2_1*D2_2

coeff2: -(1/g)**2*d1**2 - (1/g)**2*d2**2 + D1_1**2 + 4*D1_1*D2_2 - 2*D1_2*D2_1 + D2_2**2

coeff3: -2*D1_1 - 2*D2_2

coeff4: 1

For test_divisor=True and test_divisor=False, we define two equivalent forms for expression. But the code only work correctly when test_divisor=False. While in the other case, all coeffs are 0.

I’ve noticed that if test_divisor=True, the symbol g will be used as a divisor in the expression (I’ve already added nenzero=True in the assumption list for g). Is there anything else to take care of when some symbol is used as a divisor?