'Reduces the atom to an affine expression and list of constraints.
Creates the equivalent problem::
maximize    sum(log(D[i, i]))
subject to: D diagonal
diag(D) = diag(Z)
Z is upper triangular.
[D Z; Z.T A] is positive semidefinite
The problem computes the LDL factorization:
.. math::
A = (Z^TD^{-1})D(D^{-1}Z)
This follows from the inequality:
.. math::
\det(A) >= \det(D) + \det([D, Z; Z^T, A])/\det(D)
>= \det(D)
because (Z^TD^{-1})D(D^{-1}Z) is a feasible D, Z that achieves
det(A) = det(D) and the objective maximizes det(D).
Parameters
arg_objs : list
LinExpr for each argument.
size : tuple
The size of the resulting expression.
data :
Additional data required by the atom.
Returns
tuple
(LinOp for objective, list of constraints)'

@staticmethod
def graph_implementation(arg_objs, size, data=None):

    A = arg_objs[0]
    (n, _) = A.size
    X = lu.create_var(((2 * n), (2 * n)))
    (X, constraints) = Semidef((2 * n)).canonical_form
    Z = lu.create_var((n, n))
    D = lu.create_var((n, 1))
    constraints += [SDP(A)]
    Z_lower_tri = lu.upper_tri(lu.transpose(Z))
    constraints.append(lu.create_eq(Z_lower_tri))
    constraints.append(lu.create_eq(D, lu.diag_mat(Z)))
    index.block_eq(X, lu.diag_vec(D), constraints, 0, n, 0, n)
    index.block_eq(X, Z, constraints, 0, n, n, (2 * n))
    index.block_eq(X, A, constraints, n, (2 * n), n, (2 * n))
    (obj, constr) = log.graph_implementation([D], (n, 1))
    return (lu.sum_entries(obj), (constraints + constr))
