<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def get_segmentation(recording, single_clf, single_stroke_clf, stroke_segmented_classifier):
 """ Get a list of segmentations of recording with the probability of the segmentation being correct. Parameters recording : A list of lists Each sublist represents a stroke single_clf : object A classifier for single symbols single_stroke_clf : object A classifier which decides if a single stroke is a complete symbol stroke_segmented_classifier : object Classifier which decides if two strokes belong to one symbol or not Returns ------- list of tuples : Segmentations together with their probabilities. Each probability has to be positive and the sum may not be bigger than 1.0. Examples -------- [ ([[0, 1], [2]], 0.8), ([[0], [1,2]], 0.1), ([[0,2], [1]], 0.05) ] """

    mst_wood = get_mst_wood(recording, single_clf)
    return [(normalize_segmentation([mst['strokes'] for mst in mst_wood]),
             1.0)]

    # HandwrittenData(json.dumps(recording)).show()
    # return [([[i for i in range(len(recording))]], 1.0)]
    # #mst_wood = break_mst(mst, recording)  # TODO

    # for i in range(0, 2**len(points)):
    #     segmentation = get_segmentation_from_mst(mst, i)
    # TODO

    X_symbol = [get_median_stroke_distance(recording)]

    # Pre-segment to 8 strokes
    # TODO: Take first 4 strokes and add strokes within their bounding box
    # TODO: What if that is more then 8 strokes?
    # -> Geometry
    #    Build tree structure. A stroke `c` is the child of another stroke `p`,
    #    if the bounding box of `c` is within the bounding box of `p`.
    #       Problem: B <-> 13
    g_top_segmentations = [([], 1.0)]  # g_top_segmentations

    # range(int(math.ceil(float(len(recording))/8))):
    for chunk_part in mst_wood:
        # chunk = recording[8*chunk_part:8*(chunk_part+1)]
        chunk = [recording[stroke] for stroke in chunk_part['strokes']]

        # Segment after pre-segmentation
        prob = [[1.0 for _ in chunk] for _ in chunk]
        for strokeid1, strokeid2 in itertools.product(range(len(chunk)),
                                                      range(len(chunk))):
            if strokeid1 == strokeid2:
                continue
            X = get_stroke_features(chunk, strokeid1, strokeid2)
            X += X_symbol
            X = numpy.array([X], dtype=numpy.float32)
            prob[strokeid1][strokeid2] = stroke_segmented_classifier(X)

        # Top segmentations
        ts = list(partitions.get_top_segmentations(prob, 500))
        for i, segmentation in enumerate(ts):
            symbols = apply_segmentation(chunk, segmentation)
            min_top2 = partitions.TopFinder(1, find_min=True)
            for i, symbol in enumerate(symbols):
                predictions = single_clf.predict(symbol)
                min_top2.push("value-%i" % i,
                              predictions[0]['probability'] +
                              predictions[1]['probability'])
            ts[i][1] *= list(min_top2)[0][1]
        # for i, segmentation in enumerate(ts):
        #     ts[i][0] = update_segmentation_data(ts[i][0], 8*chunk_part)
        g_top_segmentations = merge_segmentations(g_top_segmentations,
                                                  ts,
                                                  chunk_part['strokes'])
    return [(normalize_segmentation(seg), probability)
            for seg, probability in g_top_segmentations]