Fibonacci heap in Python

I have this implementation of the Fibonacci heap in Python:

import math

__author__ = 'Rodion "rodde" Efremov'


class FibonacciHeapNode:
    def __init__(self, element, priority):
        self.element = element
        self.priority = priority
        self.parent = None
        self.left = self
        self.right = self
        self.child = None
        self.degree = 0
        self.marked = False


class FibonacciHeap:
    LOG_PHI = math.log((1 + math.sqrt(5)) / 2)

    def __init__(self):
        self.minimum_node = None
        self.array = []
        self.map = dict()

    def __len__(self):
        return len(self.map)

    def add(self, element, priority):
        if element in self.map:
            return False

        node = FibonacciHeapNode(element, priority)

        if self.minimum_node:
            node.left = self.minimum_node
            node.right = self.minimum_node.right
            self.minimum_node.right = node
            node.right.left = node

            if priority < self.minimum_node.priority:
                self.minimum_node = node
        else:
            self.minimum_node = node

        self.map[element] = node
        return True

    def decrease_key(self, element, priority):
        target_node = self.map[element]

        if not target_node:
            return False

        if target_node.priority <= priority:
            return False

        target_node.priority = priority
        y = target_node.parent
        x = target_node

        if y and x.priority < y.priority:
            self.cut(x, y)
            self.cascading_cut(y)

        if self.minimum_node.priority > x.priority:
            self.minimum_node = x

        return True

    def extract_minimum(self):
        if len(self.map) == 0:
            raise ValueError("Extracting from empty Fibonacci heap")

        z = self.minimum_node
        number_of_children = z.degree
        x = z.child
        tmp_right = None

        while number_of_children:
            tmp_right = x.right

            x.left.right = x.right
            x.right.left = x.left

            x.left = self.minimum_node
            x.right = self.minimum_node.right
            self.minimum_node.right = x
            x.right.left = x

            x.parent = None
            x = tmp_right
            number_of_children -= 1

        z.left.right = z.right
        z.right.left = z.left

        if z == z.right:
            self.minimum_node = None
        else:
            self.minimum_node = z.right
            self.consolidate()

        element = z.element
        del self.map[element]
        return element

    def wipe_array(self):
        for i in range(len(self.array)):
            self.array[i] = None

    def consolidate(self):
        array_size = math.floor(math.log(len(self.map)) / self.LOG_PHI) + 1
        self.wipe_array()
        self.ensure_array_size(array_size)
        x = self.minimum_node
        root_list_size = 0

        if x:
            root_list_size = 1
            x = x.right

            while x != self.minimum_node:
                root_list_size += 1
                x = x.right

        while root_list_size:
            degree = x.degree
            next = x.right

            while self.array[degree]:
                y = self.array[degree]

                if x.priority > y.priority:
                    tmp = y
                    y = x
                    x = tmp

                self.link(y, x)
                self.array[degree] = None
                degree += 1

            self.array[degree] = x
            x = next
            root_list_size -= 1

        self.minimum_node = None

        for y in self.array:
            if y:
                if not self.minimum_node:
                    self.minimum_node = y
                else:
                    self.move_to_root_list(y)

    def move_to_root_list(self, node):
        node.left.right = node.right
        node.right.left = node.left

        node.left = self.minimum_node
        node.right = self.minimum_node.right
        self.minimum_node.right = node
        node.right.left = node

        if self.minimum_node.priority > node.priority:
            self.minimum_node = node

    def link(self, y, x):
        y.left.right = y.right
        y.right.left = y.left

        y.parent = x

        if not x.child:
            x.child = y
            y.right = y
            y.left = y
        else:
            y.left = x.child
            y.right = x.child.right
            x.child.right = y
            y.right.left = y

        x.degree += 1

    def cut(self, x, y):
        x.left.right = x.right
        x.right.left = x.left
        y.degree -= 1

        if y.child == x:
            y.child = x.right

        if y.degree == 0:
            y.child = None

        x.left = self.minimum_node
        x.right = self.minimum_node.right
        self.minimum_node.right = x
        x.right.left = x

        x.parent = None
        x.marked = False

    def cascading_cut(self, y):
        z = y.parent

        if z:
            if not y.marked:
                y.marked = True
            else:
                self.cut(y, z)
                self.cascading_cut(z)

    def ensure_array_size(self, array_size):
        while len(self.array) < array_size:
            self.array.append(None)


def main():
    heap = FibonacciHeap()

    for i in range(10):
        heap.add(i, 10 - i)

    heap.decrease_key(5, 15)  # No op
    heap.decrease_key(4, -1)  # 4 should come out first

    while heap:
        print(heap.extract_minimum())

if __name__ == "__main__":
    main()

I would like to hear your comments regarding how to improve it.