code: def test_split_monotonic_index_min_max():
      left_min_max = [[0, True, 3, True], [3, False, 5, False]]
      right_min_max = [[1, False, 3, True], [4, False, 6, True]]
      left_splits, right_splits = split_monotonic_index_min_max(
          left_min_max, True, right_min_max, True
      )
      assert left_splits == [
          [(0, True, 1, True), (1, False, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
      ]
      assert right_splits == [
          [(0, True, 1, True), (1, False, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
      ]
      left_splits, right_splits = split_monotonic_index_min_max(
          right_min_max, False, left_min_max, False
      )
      assert list(reversed(left_splits)) == [
          [(0, True, 1, True), (1, False, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
      ]
      assert list(reversed(right_splits)) == [
          [(0, True, 1, True), (1, False, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
      ]
  
      left_min_max = [[2, True, 4, True], [8, True, 9, False]]
      right_min_max = [[1, False, 3, True], [4, False, 6, True]]
      left_splits, right_splits = split_monotonic_index_min_max(
          left_min_max, True, right_min_max, True
      )
      assert left_splits == [
          [
              (1, False, 2, False),
              (2, True, 3, True),
              (3, False, 4, True),
          ],
          [(4, False, 6, True), (8, True, 9, False)],
      ]
      assert right_splits == [
          [(1, False, 2, False), (2, True, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 6, True),
              (8, True, 9, False),
          ],
      ]
  
      left_min_max = [
          [1, False, 3, True],
          [4, False, 6, True],
          [10, True, 12, False],
          [13, True, 14, False],
      ]
      right_min_max = [[2, True, 4, True], [5, True, 7, False]]
      left_splits, right_splits = split_monotonic_index_min_max(
          left_min_max, True, right_min_max, True
      )
      assert left_splits == [
          [(1, False, 2, False), (2, True, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
          [(6, False, 7, False), (10, True, 12, False)],
          [(13, True, 14, False)],
      ]
      assert right_splits == [
          [
              (1, False, 2, False),
              (2, True, 3, True),
              (3, False, 4, True),
          ],
          [
              (4, False, 5, False),
              (5, True, 6, True),
              (6, False, 7, False),
              (10, True, 12, False),
              (13, True, 14, False),
          ],
      ]
      left_splits, right_splits = split_monotonic_index_min_max(
          right_min_max, True, left_min_max, True
      )
      assert left_splits == [
          [
              (1, False, 2, False),
              (2, True, 3, True),
              (3, False, 4, True),
          ],
          [
              (4, False, 5, False),
              (5, True, 6, True),
              (6, False, 7, False),
              (10, True, 12, False),
              (13, True, 14, False),
          ],
      ]
      assert right_splits == [
          [(1, False, 2, False), (2, True, 3, True)],
          [
              (3, False, 4, True),
              (4, False, 5, False),
              (5, True, 6, True),
          ],
          [(6, False, 7, False), (10, True, 12, False)],
          [(13, True, 14, False)],
      ]
  
      # left min_max like ([.., .., 4 True], [4, False, ..., ...]
      # right min_max like ([..., ..., 4 False], [4, True, ..., ...]
      left_min_max = [[1, False, 4, True], [4, False, 6, True]]
      right_min_max = [[1, False, 4, False], [4, True, 6, True]]
      left_splits, right_splits = split_monotonic_index_min_max(
          left_min_max, True, right_min_max, True
      )
      assert left_splits == [
          [(1, False, 4, False), (4, True, 4, True)],
          [(4, False, 6, True)],
      ]
      assert right_splits == [
          [(1, False, 4, False)],
          [(4, True, 4, True), (4, False, 6, True)],
      ]
  
      # identical index
      left_min_max = [[1, False, 3, True], [4, False, 6, True]]
      right_min_max = [[1, False, 3, True], [4, False, 6, True]]
      left_splits, right_splits = split_monotonic_index_min_max(
          left_min_max, True, right_min_max, True
      )
      assert left_splits == [[tuple(it)] for it in left_min_max]
      assert right_splits == [[tuple(it)] for it in left_min_max]
  
imports: import operator
  from collections import OrderedDict
  from numbers import Integral
  from typing import List, Dict
  import numpy
  import pandas
  import pytest
  from ...config import option_context
  from ...core import tile
  from ...utils import Timer
  from ..core import IndexValue
  from ..initializer import DataFrame, Series, Index
  from ..utils import decide_dataframe_chunk_sizes, decide_series_chunk_size, split_monotonic_index_min_max, build_split_idx_to_origin_idx, parse_index, filter_index_value, infer_dtypes, infer_index_value, validate_axis, fetch_corner_data, make_dtypes, build_concatenated_rows_frame, merge_index_value, auto_merge_chunks, whether_to_clean_up
label_desc: Use image node_id 4 for calling a global function with example usage: test_split_monotonic_index_min_max() without return types