SYMBOL INDEX (1396 symbols across 60 files)

FILE: cotengra/__init__.py
  function hyper_optimize (line 214) | def hyper_optimize(
  function hyper_compressed_optimize (line 236) | def hyper_compressed_optimize(
  function random_greedy_optimize (line 253) | def random_greedy_optimize(

FILE: cotengra/contract.py
  function set_default_implementation (line 13) | def set_default_implementation(impl):
  function get_default_implementation (line 18) | def get_default_implementation():
  function default_implementation (line 23) | def default_implementation(impl):
  function _sanitize_equation (line 35) | def _sanitize_equation(eq):
  function _parse_einsum_single (line 62) | def _parse_einsum_single(eq, shape):
  function _parse_eq_to_pure_multiplication (line 122) | def _parse_eq_to_pure_multiplication(a_term, shape_a, b_term, shape_b, o...
  function _parse_eq_to_batch_matmul (line 168) | def _parse_eq_to_batch_matmul(eq, shape_a, shape_b):
  function _einsum_single (line 332) | def _einsum_single(eq, x, backend=None):
  function _do_contraction_via_bmm (line 364) | def _do_contraction_via_bmm(
  function einsum (line 414) | def einsum(eq, a, b=None, *, backend=None):
  function gen_nice_inds (line 462) | def gen_nice_inds():
  function _parse_tensordot_axes_to_matmul (line 473) | def _parse_tensordot_axes_to_matmul(axes, shape_a, shape_b):
  function tensordot (line 521) | def tensordot(a, b, axes=2, *, backend=None):
  function extract_contractions (line 573) | def extract_contractions(
  class Contractor (line 654) | class Contractor:
    method __init__ (line 702) | def __init__(
    method __call__ (line 718) | def __call__(self, *arrays, **kwargs):
  class CuQuantumContractor (line 840) | class CuQuantumContractor:
    method __init__ (line 841) | def __init__(
    method setup (line 883) | def setup(self, *arrays):
    method __call__ (line 901) | def __call__(
    method __del__ (line 920) | def __del__(self):
  function make_contractor (line 925) | def make_contractor(

FILE: cotengra/core.py
  function cached_node_property (line 59) | def cached_node_property(name):
  function legs_union (line 76) | def legs_union(legs_seq):
  function legs_without (line 88) | def legs_without(legs, ind):
  function get_with_default (line 95) | def get_with_default(k, obj, default):
  class SliceInfo (line 100) | class SliceInfo:
    method sliced_range (line 107) | def sliced_range(self):
  function get_slice_strides (line 114) | def get_slice_strides(sliced_inds):
  class AdderWithMaybeExponentStripped (line 125) | class AdderWithMaybeExponentStripped:
    method __init__ (line 133) | def __init__(self):
    method __call__ (line 138) | def __call__(self, x, y):
  class ContractionTree (line 175) | class ContractionTree:
    method __init__ (line 215) | def __init__(
    method set_state_from (line 318) | def set_state_from(self, other):
    method copy (line 368) | def copy(self):
    method set_default_objective (line 374) | def set_default_objective(self, objective):
    method get_default_objective (line 378) | def get_default_objective(self):
    method get_default_combo_factor (line 384) | def get_default_combo_factor(self):
    method get_score (line 392) | def get_score(self, objective=None):
    method nslices (line 404) | def nslices(self):
    method nchunks (line 411) | def nchunks(self):
    method input_to_node (line 419) | def input_to_node(self, i):
    method node_to_input (line 434) | def node_to_input(self, node):
    method node_to_terms (line 449) | def node_to_terms(self, node):
    method gen_leaves (line 458) | def gen_leaves(self):
    method get_incomplete_nodes (line 464) | def get_incomplete_nodes(self):
    method autocomplete (line 517) | def autocomplete(self, **contract_opts):
    method from_path (line 537) | def from_path(
    method from_info (line 639) | def from_info(cls, info, **kwargs):
    method from_eq (line 650) | def from_eq(cls, eq, size_dict, **kwargs):
    method get_eq (line 665) | def get_eq(self):
    method get_shapes (line 676) | def get_shapes(self):
    method get_inputs_sliced (line 687) | def get_inputs_sliced(self):
    method get_output_sliced (line 700) | def get_output_sliced(self):
    method get_eq_sliced (line 710) | def get_eq_sliced(self):
    method get_shapes_sliced (line 722) | def get_shapes_sliced(self):
    method from_edge_path (line 738) | def from_edge_path(
    method _add_node (line 765) | def _add_node(self, node, check=False, **kwargs):
    method _remove_node (line 830) | def _remove_node(self, node):
    method compute_leaf_legs (line 861) | def compute_leaf_legs(self, i):
    method has_preprocessing (line 906) | def has_preprocessing(self):
    method has_hyper_indices (line 912) | def has_hyper_indices(self):
    method get_extent (line 920) | def get_extent(self, node):
    method get_subgraph (line 940) | def get_subgraph(self, node) -> tuple[int, ...]:
    method get_legs (line 970) | def get_legs(self, node):
    method get_involved (line 1002) | def get_involved(self, node):
    method get_size (line 1010) | def get_size(self, node):
    method get_flops (line 1015) | def get_flops(self, node):
    method get_can_dot (line 1025) | def get_can_dot(self, node):
    method get_inds (line 1035) | def get_inds(self, node):
    method get_tensordot_axes (line 1054) | def get_tensordot_axes(self, node):
    method get_tensordot_perm (line 1069) | def get_tensordot_perm(self, node):
    method get_einsum_eq (line 1083) | def get_einsum_eq(self, node):
    method is_leaf (line 1097) | def is_leaf(self, node):
    method is_root (line 1111) | def is_root(self, node):
    method is_descendant (line 1125) | def is_descendant(self, node, ancestor):
    method get_peak_size (line 1141) | def get_peak_size(self, node):
    method reorder_for_peak_size (line 1170) | def reorder_for_peak_size(self):
    method get_centrality (line 1189) | def get_centrality(self, node):
    method total_flops (line 1196) | def total_flops(self, dtype=None, log=None):
    method total_write (line 1229) | def total_write(self):
    method combo_cost (line 1240) | def combo_cost(self, factor=DEFAULT_COMBO_FACTOR, combine=sum, log=None):
    method max_size (line 1256) | def max_size(self, log=None):
    method max_contraction_size (line 1274) | def max_contraction_size(self, log=None):
    method peak_size (line 1299) | def peak_size(self, order=None, log=None):
    method contract_stats (line 1318) | def contract_stats(self, force=False):
    method arithmetic_intensity (line 1349) | def arithmetic_intensity(self):
    method contraction_scaling (line 1355) | def contraction_scaling(self):
    method contraction_cost (line 1362) | def contraction_cost(self, log=None):
    method naive_cost (line 1366) | def naive_cost(self, log=None):
    method speedup (line 1383) | def speedup(self, log=None):
    method contraction_width (line 1398) | def contraction_width(self, log=2):
    method compressed_contract_stats (line 1402) | def compressed_contract_stats(
    method total_flops_compressed (line 1448) | def total_flops_compressed(
    method total_write_compressed (line 1479) | def total_write_compressed(
    method combo_cost_compressed (line 1502) | def combo_cost_compressed(
    method max_size_compressed (line 1526) | def max_size_compressed(
    method peak_size_compressed (line 1545) | def peak_size_compressed(
    method contraction_width_compressed (line 1569) | def contraction_width_compressed(
    method _update_tracked (line 1578) | def _update_tracked(self, node):
    method contract_nodes_pair (line 1586) | def contract_nodes_pair(
    method contract_nodes (line 1668) | def contract_nodes(
    method is_complete (line 1755) | def is_complete(self):
    method get_default_order (line 1778) | def get_default_order(self):
    method _traverse_dfs (line 1781) | def _traverse_dfs(self):
    method _traverse_ordered (line 1801) | def _traverse_ordered(self, order):
    method traverse (line 1834) | def traverse(self, order=None):
    method descend (line 1866) | def descend(self, mode="dfs"):
    method get_subtree (line 1898) | def get_subtree(self, node, size, search="bfs", seed=None):
    method remove_ind (line 1966) | def remove_ind(self, ind, project=None, inplace=False):
    method restore_ind (line 2046) | def restore_ind(self, ind, inplace=False):
    method unslice_rand (line 2093) | def unslice_rand(self, seed=None, inplace=False):
    method unslice_all (line 2113) | def unslice_all(self, inplace=False):
    method calc_subtree_candidates (line 2134) | def calc_subtree_candidates(self, pwr=2, what="flops"):
    method _subtree_remove_and_optimize (line 2158) | def _subtree_remove_and_optimize(
    method _subtree_reconfigure_descend (line 2189) | def _subtree_reconfigure_descend(
    method _subtree_reconfigure_rand_select (line 2251) | def _subtree_reconfigure_rand_select(
    method subtree_reconfigure (line 2316) | def subtree_reconfigure(
    method subtree_reconfigure_forest (line 2439) | def subtree_reconfigure_forest(
    method slice (line 2620) | def slice(
    method slice_and_reconfigure (line 2711) | def slice_and_reconfigure(
    method slice_and_reconfigure_forest (line 2798) | def slice_and_reconfigure_forest(
    method compressed_reconfigure (line 2973) | def compressed_reconfigure(
    method windowed_reconfigure (line 3074) | def windowed_reconfigure(
    method flat_tree (line 3137) | def flat_tree(self, order=None):
    method get_leaves_ordered (line 3160) | def get_leaves_ordered(self):
    method get_path (line 3176) | def get_path(self, order=None):
    method get_numpy_path (line 3217) | def get_numpy_path(self, order=None):
    method get_ssa_path (line 3223) | def get_ssa_path(self, order=None):
    method surface_order (line 3249) | def surface_order(self, node):
    method set_surface_order_from_path (line 3252) | def set_surface_order_from_path(self, ssa_path):
    method get_path_surface (line 3273) | def get_path_surface(self):
    method get_ssa_path_surface (line 3280) | def get_ssa_path_surface(self):
    method get_spans (line 3287) | def get_spans(self):
    method compute_centralities (line 3362) | def compute_centralities(self, combine="mean"):
    method get_hypergraph (line 3382) | def get_hypergraph(self, accel=False):
    method reset_contraction_indices (line 3388) | def reset_contraction_indices(self):
    method sort_contraction_indices (line 3409) | def sort_contraction_indices(
    method print_contractions (line 3496) | def print_contractions(self, sort=None, show_brackets=True):
    method get_contractor (line 3626) | def get_contractor(
    method contract_core (line 3712) | def contract_core(
    method slice_key (line 3763) | def slice_key(self, i, strides=None):
    method slice_arrays (line 3790) | def slice_arrays(self, arrays, i):
    method contract_slice (line 3809) | def contract_slice(self, arrays, i, **kwargs):
    method gather_slices (line 3813) | def gather_slices(self, slices, backend=None, progbar=False):
    method gen_output_chunks (line 3872) | def gen_output_chunks(
    method contract (line 3931) | def contract(
    method contract_mpi (line 4020) | def contract_mpi(self, arrays, comm=None, root=None, **kwargs):
    method benchmark (line 4080) | def benchmark(
    method plot_hypergraph (line 4164) | def plot_hypergraph(self, **kwargs):
    method describe (line 4168) | def describe(self, info="normal", join=" "):
    method __repr__ (line 4201) | def __repr__(self):
    method __str__ (line 4213) | def __str__(self):
  function _reconfigure_tree (line 4221) | def _reconfigure_tree(tree, *args, **kwargs):
  function _slice_and_reconfigure_tree (line 4225) | def _slice_and_reconfigure_tree(tree, *args, **kwargs):
  function _get_tree_info (line 4229) | def _get_tree_info(tree):
  function _describe_tree (line 4235) | def _describe_tree(tree, info="normal"):
  class ContractionTreeCompressed (line 4239) | class ContractionTreeCompressed(ContractionTree):
    method set_state_from (line 4244) | def set_state_from(self, other):
    method from_path (line 4249) | def from_path(
    method get_default_order (line 4301) | def get_default_order(self):
    method get_default_objective (line 4304) | def get_default_objective(self):
    method get_default_chi (line 4309) | def get_default_chi(self):
    method get_default_compress_late (line 4321) | def get_default_compress_late(self):
    method get_contractor (line 4344) | def get_contractor(self, *_, **__):
    method simulated_anneal (line 4352) | def simulated_anneal(
  class PartitionTreeBuilder (line 4409) | class PartitionTreeBuilder:
    method __init__ (line 4425) | def __init__(self, partition_fn):
    method build_divide (line 4428) | def build_divide(
    method build_agglom (line 4539) | def build_agglom(
    method trial_fn (line 4607) | def trial_fn(self, inputs, output, size_dict, **partition_opts):
    method trial_fn_agglom (line 4610) | def trial_fn_agglom(self, inputs, output, size_dict, **partition_opts):
  function jitter (line 4614) | def jitter(x, strength, rng):
  function jitter_dict (line 4618) | def jitter_dict(d, strength, seed=None):
  function separate (line 4623) | def separate(xs, blocks):

FILE: cotengra/core_multi.py
  class ContractionTreeMulti (line 6) | class ContractionTreeMulti(ContractionTree):
    method __init__ (line 7) | def __init__(
    method set_state_from (line 23) | def set_state_from(self, other):
    method _remove_node (line 29) | def _remove_node(self, node):
    method _update_tracked (line 34) | def _update_tracked(self, node):
    method get_node_var_inds (line 40) | def get_node_var_inds(self, node):
    method get_node_is_bright (line 59) | def get_node_is_bright(self, node):
    method get_node_mult (line 75) | def get_node_mult(self, node):
    method get_node_cache_mult (line 81) | def get_node_cache_mult(self, node, sliced_ind_ordering):
    method get_flops (line 91) | def get_flops(self, node):
    method get_cache_contrib (line 98) | def get_cache_contrib(self, node):
    method peak_size (line 118) | def peak_size(self, log=None):
    method reorder_contractions_for_peak_est (line 135) | def reorder_contractions_for_peak_est(self):
    method reorder_sliced_inds (line 158) | def reorder_sliced_inds(self):
    method exact_multi_stats (line 167) | def exact_multi_stats(self, configs):

FILE: cotengra/experimental/hyper_de.py
  class HyperDESampler (line 13) | class HyperDESampler:
    method __init__ (line 46) | def __init__(
    method _mutate (line 85) | def _mutate(self, target_idx):
    method _sample_generation (line 114) | def _sample_generation(self):
    method _extend_generation (line 126) | def _extend_generation(self, target_idx=None):
    method ask (line 143) | def ask(self):
    method tell (line 163) | def tell(self, trial_number, score):
  class DEOptLib (line 196) | class DEOptLib(HyperOptLib):
    method setup (line 199) | def setup(
    method get_setting (line 281) | def get_setting(self):
    method report_result (line 292) | def report_result(self, setting, trial, score):

FILE: cotengra/experimental/hyper_pe.py
  class HyperPESampler (line 15) | class HyperPESampler:
    method __init__ (line 50) | def __init__(
    method _make_sigmas (line 92) | def _make_sigmas(self):
    method _sample_candidate (line 104) | def _sample_candidate(self, worker_idx, noise=None):
    method _sample_generation (line 139) | def _sample_generation(self):
    method _extend_generation (line 151) | def _extend_generation(self, worker_idx=None, noise=None):
    method ask (line 167) | def ask(self):
    method tell (line 187) | def tell(self, trial_number, score):
  class PEOptLib (line 250) | class PEOptLib(HyperOptLib):
    method setup (line 253) | def setup(
    method get_setting (line 339) | def get_setting(self):
    method report_result (line 350) | def report_result(self, setting, trial, score):

FILE: cotengra/experimental/hyper_pymoo.py
  function _get_pymoo_algorithm (line 18) | def _get_pymoo_algorithm(name):
  class HyperPymooSampler (line 60) | class HyperPymooSampler:
    method __init__ (line 63) | def __init__(
    method ask (line 106) | def ask(self):
    method tell (line 133) | def tell(self, trial_number, score):
  class PymooOptLib (line 150) | class PymooOptLib(HyperOptLib):
    method setup (line 153) | def setup(
    method get_setting (line 189) | def get_setting(self):
    method report_result (line 199) | def report_result(self, setting, trial, score):

FILE: cotengra/experimental/hyper_scipy.py
  class _StopOptimization (line 29) | class _StopOptimization(Exception):
  class ScipyAskTell (line 33) | class ScipyAskTell:
    method __init__ (line 51) | def __init__(self, method, bounds, **kwargs):
    method _get_optimizer_fn (line 64) | def _get_optimizer_fn(self):
    method _objective (line 69) | def _objective(self, x):
    method _run (line 78) | def _run(self):
    method start (line 93) | def start(self):
    method ask (line 98) | def ask(self):
    method tell (line 111) | def tell(self, score):
    method stop (line 115) | def stop(self):
  class HyperScipySampler (line 127) | class HyperScipySampler:
    method __init__ (line 152) | def __init__(
    method _make_worker (line 178) | def _make_worker(self):
    method _next_worker (line 188) | def _next_worker(self):
    method ask (line 207) | def ask(self):
    method tell (line 230) | def tell(self, trial_number, score):
    method stop (line 238) | def stop(self):
  class ScipyOptLib (line 244) | class ScipyOptLib(HyperOptLib):
    method setup (line 249) | def setup(
    method get_setting (line 312) | def get_setting(self):
    method report_result (line 322) | def report_result(self, setting, trial, score):
    method cleanup (line 328) | def cleanup(self):

FILE: cotengra/experimental/hyper_smac.py
  function build_config_space (line 9) | def build_config_space(method, space):
  function config_to_params (line 56) | def config_to_params(config):
  class SMACOptLib (line 61) | class SMACOptLib(HyperOptLib):
    method setup (line 66) | def setup(
    method get_setting (line 115) | def get_setting(self):
    method report_result (line 127) | def report_result(self, setting, trial, score):

FILE: cotengra/experimental/path_compressed_branchbound.py
  class CompressedExhaustive (line 14) | class CompressedExhaustive:
    method __init__ (line 48) | def __init__(
    method setup (line 97) | def setup(self, inputs, output, size_dict):
    method expand_node (line 124) | def expand_node(
    method _update_progbar (line 219) | def _update_progbar(self, pbar, c):
    method run (line 227) | def run(self, inputs, output, size_dict):
    method ssa_path (line 294) | def ssa_path(self):
    method path (line 298) | def path(self):
    method explore_path (line 301) | def explore_path(self, path, high_priority=True, restrict=False):
    method search (line 346) | def search(self, inputs, output, size_dict):
    method __call__ (line 356) | def __call__(self, inputs, output, size_dict):
  function do_reconfigure (line 362) | def do_reconfigure(tree, time, chi):
  class CompressedTreeRefiner (line 373) | class CompressedTreeRefiner:
    method __init__ (line 374) | def __init__(
    method _check_score (line 400) | def _check_score(self, key, tree, score=None):
    method _get_next_tree (line 409) | def _get_next_tree(self):
    method _get_next_result_seq (line 415) | def _get_next_result_seq(self):
    method _get_next_result_par (line 420) | def _get_next_result_par(self, max_futures):
    method _process_result (line 437) | def _process_result(self, tree, key, time, old, new):
    method refine (line 445) | def refine(self, num_its=None, bins=30):

FILE: cotengra/experimental/path_compressed_mcts.py
  class Node (line 10) | class Node:
    method __init__ (line 24) | def __init__(
    method update (line 45) | def update(self, x):
    method __hash__ (line 58) | def __hash__(self):
    method __lt__ (line 61) | def __lt__(self, other):
    method __repr__ (line 64) | def __repr__(self):
  class MCTS (line 74) | class MCTS:
    method __init__ (line 75) | def __init__(
    method __repr__ (line 100) | def __repr__(self):
    method setup (line 109) | def setup(self, inputs, output, size_dict):
    method get_ssa_path (line 133) | def get_ssa_path(self):
    method check_node (line 145) | def check_node(self, node):
    method delete_node (line 201) | def delete_node(self, node):
    method backprop (line 237) | def backprop(self, node):
    method simulate_node (line 255) | def simulate_node(self, node):
    method simulate_optimized (line 272) | def simulate_optimized(self, node):
    method is_deadend (line 307) | def is_deadend(self, node):
    method descend (line 315) | def descend(self):
    method ssa_path (line 340) | def ssa_path(self):
    method path (line 345) | def path(self):
    method run (line 349) | def run(self, inputs, output, size_dict):
    method search (line 364) | def search(self, inputs, output, size_dict):
    method __call__ (line 374) | def __call__(self, inputs, output, size_dict):

FILE: cotengra/experimental/scoring.py
  class CompressedTracedObjective (line 1) | class CompressedTracedObjective(Objective):
    method __init__ (line 2) | def __init__(self, chi, compress_late=False, r=1):
    method trace (line 7) | def trace(self, trial):
  class CompressedSizeTracedObjective (line 52) | class CompressedSizeTracedObjective(CompressedTracedObjective):
    method __init__ (line 53) | def __init__(self, secondary_weight=1e-3, **kwargs):
    method __call__ (line 57) | def __call__(self, trial):
  class CompressedPeakTracedObjective (line 66) | class CompressedPeakTracedObjective(CompressedTracedObjective):
    method __init__ (line 67) | def __init__(self, secondary_weight=1e-3, **kwargs):
    method __call__ (line 71) | def __call__(self, trial):
  class CompressedFlopsTracedObjective (line 80) | class CompressedFlopsTracedObjective(CompressedTracedObjective):
    method __init__ (line 81) | def __init__(self, secondary_weight=1e-3, **kwargs):
    method __call__ (line 85) | def __call__(self, trial):
  class CompressedComboTracedObjective (line 94) | class CompressedComboTracedObjective(CompressedTracedObjective):
    method __init__ (line 95) | def __init__(self, factor=DEFAULT_COMBO_FACTOR, **kwargs):
    method __call__ (line 99) | def __call__(self, trial):

FILE: cotengra/hypergraph.py
  class HyperGraph (line 24) | class HyperGraph:
    method __init__ (line 58) | def __init__(self, inputs, output=None, size_dict=None):
    method copy (line 75) | def copy(self):
    method from_edges (line 87) | def from_edges(cls, edges, output=(), size_dict=()):
    method get_num_nodes (line 104) | def get_num_nodes(self):
    method num_nodes (line 108) | def num_nodes(self):
    method get_num_edges (line 111) | def get_num_edges(self):
    method num_edges (line 115) | def num_edges(self):
    method __len__ (line 118) | def __len__(self):
    method edges_size (line 121) | def edges_size(self, es):
    method bond_size (line 125) | def bond_size(self, i, j):
    method node_size (line 131) | def node_size(self, i):
    method neighborhood_size (line 135) | def neighborhood_size(self, nodes):
    method contract_pair_cost (line 145) | def contract_pair_cost(self, i, j):
    method neighborhood_compress_cost (line 151) | def neighborhood_compress_cost(self, chi, nodes):
    method total_node_size (line 187) | def total_node_size(self):
    method output_nodes (line 191) | def output_nodes(self):
    method neighbors (line 195) | def neighbors(self, i):
    method neighbor_edges (line 201) | def neighbor_edges(self, i):
    method has_node (line 211) | def has_node(self, i):
    method get_node (line 215) | def get_node(self, i):
    method get_edge (line 219) | def get_edge(self, e):
    method has_edge (line 223) | def has_edge(self, e):
    method next_node (line 227) | def next_node(self):
    method add_node (line 236) | def add_node(self, inds, node=None):
    method remove_node (line 252) | def remove_node(self, i):
    method remove_edge (line 261) | def remove_edge(self, e):
    method contract (line 267) | def contract(self, i, j, node=None):
    method compress (line 279) | def compress(self, chi, edges=None):
    method compute_contracted_inds (line 302) | def compute_contracted_inds(self, nodes):
    method candidate_contraction_size (line 313) | def candidate_contraction_size(self, i, j, chi=None):
    method all_shortest_distances (line 338) | def all_shortest_distances(
    method all_shortest_distances_condensed (line 390) | def all_shortest_distances_condensed(
    method simple_distance (line 409) | def simple_distance(self, region, p=2):
    method simple_closeness (line 438) | def simple_closeness(self, p=0.75, mu=0.5):
    method simple_centrality (line 494) | def simple_centrality(self, r=None, smoothness=2, **closeness_opts):
    method compute_loops (line 539) | def compute_loops(self, start=None, max_loop_length=None):
    method get_laplacian (line 607) | def get_laplacian(self):
    method get_resistance_distances (line 621) | def get_resistance_distances(self):
    method resistance_centrality (line 635) | def resistance_centrality(self, rescale=True):
    method to_networkx (line 645) | def to_networkx(H, as_tree_leaves=None):
    method compute_weights (line 709) | def compute_weights(
    method __repr__ (line 743) | def __repr__(self):
  function get_hypergraph (line 747) | def get_hypergraph(inputs, output=None, size_dict=None, accel=False):
  function calc_edge_weight (line 764) | def calc_edge_weight(ix, size_dict, scale="log"):
  function calc_edge_weight_float (line 780) | def calc_edge_weight_float(ix, size_dict, scale="log"):
  function calc_node_weight (line 796) | def calc_node_weight(term, size_dict, scale="linear"):
  function calc_node_weight_float (line 813) | def calc_node_weight_float(term, size_dict, scale="linear"):
  class LineGraph (line 830) | class LineGraph:
    method __init__ (line 833) | def __init__(self, inputs, output):
    method to_gr_str (line 849) | def to_gr_str(self):
    method to_gr_file (line 855) | def to_gr_file(self, fname):
    method to_cnf_str (line 860) | def to_cnf_str(self):
    method to_cnf_file (line 866) | def to_cnf_file(self, fname):
  function popcount (line 875) | def popcount(x):
  function popcount (line 886) | def popcount(x):
  function dict_affine_renorm (line 890) | def dict_affine_renorm(d):

FILE: cotengra/hyperoptimizers/_param_mapping.py
  class LCBOptimizer (line 13) | class LCBOptimizer:
    method __init__ (line 19) | def __init__(self, options, exploration=1.0, temperature=1.0, seed=None):
    method ask (line 30) | def ask(self):
    method tell (line 53) | def tell(self, option, score):
  class Param (line 60) | class Param:
    method __init__ (line 65) | def __init__(self, name):
    method get_raw_bounds (line 69) | def get_raw_bounds(self):
    method convert_raw (line 72) | def convert_raw(self, vi):
  class ParamFloat (line 76) | class ParamFloat(Param):
    method __init__ (line 77) | def __init__(self, min, max, **kwargs):
    method convert_raw (line 82) | def convert_raw(self, x):
  class ParamFloatExp (line 90) | class ParamFloatExp(ParamFloat):
    method __init__ (line 93) | def __init__(self, min, max, power=0.5, **kwargs):
    method convert_raw (line 105) | def convert_raw(self, x):
  class ParamInt (line 112) | class ParamInt(Param):
    method __init__ (line 113) | def __init__(self, min, max, **kwargs):
    method convert_raw (line 118) | def convert_raw(self, x):
  class ParamString (line 126) | class ParamString(Param):
    method __init__ (line 127) | def __init__(self, options, name):
    method convert_raw (line 132) | def convert_raw(self, x):
  class ParamBool (line 137) | class ParamBool(Param):
    method __init__ (line 138) | def __init__(self, name):
    method convert_raw (line 143) | def convert_raw(self, x):
  function build_params (line 147) | def build_params(space, exponential_param_power=None):
  function convert_raw (line 185) | def convert_raw(params, x):
  function num_params (line 211) | def num_params(params):
  function generate_lhs_points (line 216) | def generate_lhs_points(ndim, n, rng):

FILE: cotengra/hyperoptimizers/hyper.py
  function get_default_hq_methods (line 30) | def get_default_hq_methods():
  function get_default_optlib_eco (line 45) | def get_default_optlib_eco():
  function get_default_optlib (line 58) | def get_default_optlib():
  function get_hyper_space (line 77) | def get_hyper_space():
  function get_hyper_constants (line 81) | def get_hyper_constants():
  class HyperOptLib (line 85) | class HyperOptLib:
    method setup (line 92) | def setup(self, methods, space, optimizer=None, **kwargs):
    method get_setting (line 109) | def get_setting(self):
    method report_result (line 120) | def report_result(self, setting, trial, score):
    method cleanup (line 134) | def cleanup(self):
  function register_hyper_optlib (line 142) | def register_hyper_optlib(name, cls, defaults=None):
  function register_hyper_function (line 156) | def register_hyper_function(name, ssa_func, space, constants=None):
  function list_hyper_functions (line 177) | def list_hyper_functions():
  function base_trial_fn (line 182) | def base_trial_fn(inputs, output, size_dict, method, **kwargs):
  class TrialSetObjective (line 200) | class TrialSetObjective:
    method __init__ (line 201) | def __init__(self, trial_fn, objective):
    method __call__ (line 205) | def __call__(self, *args, **kwargs):
  class TrialConvertTree (line 211) | class TrialConvertTree:
    method __init__ (line 212) | def __init__(self, trial_fn, cls):
    method __call__ (line 216) | def __call__(self, *args, **kwargs):
  class TrialTreeMulti (line 226) | class TrialTreeMulti:
    method __init__ (line 227) | def __init__(self, trial_fn, varmults, numconfigs):
    method __call__ (line 232) | def __call__(self, *args, **kwargs):
  class SlicedTrialFn (line 245) | class SlicedTrialFn:
    method __init__ (line 246) | def __init__(self, trial_fn, **opts):
    method __call__ (line 250) | def __call__(self, *args, **kwargs):
  class SimulatedAnnealingTrialFn (line 265) | class SimulatedAnnealingTrialFn:
    method __init__ (line 266) | def __init__(self, trial_fn, **opts):
    method __call__ (line 270) | def __call__(self, *args, **kwargs):
  class ReconfTrialFn (line 282) | class ReconfTrialFn:
    method __init__ (line 283) | def __init__(self, trial_fn, forested=False, parallel=False, **opts):
    method __call__ (line 289) | def __call__(self, *args, **kwargs):
  class SlicedReconfTrialFn (line 311) | class SlicedReconfTrialFn:
    method __init__ (line 312) | def __init__(self, trial_fn, forested=False, parallel=False, **opts):
    method __call__ (line 318) | def __call__(self, *args, **kwargs):
  class CompressedReconfTrial (line 340) | class CompressedReconfTrial:
    method __init__ (line 341) | def __init__(self, trial_fn, minimize=None, **opts):
    method __call__ (line 346) | def __call__(self, *args, **kwargs):
  class ComputeScore (line 353) | class ComputeScore:
    method __init__ (line 358) | def __init__(
    method __call__ (line 378) | def __call__(self, *args, **kwargs):
  function progress_description (line 421) | def progress_description(best, info="concise"):
  class HyperOptimizer (line 431) | class HyperOptimizer(PathOptimizer):
    method __init__ (line 497) | def __init__(
    method minimize (line 588) | def minimize(self):
    method minimize (line 592) | def minimize(self, minimize):
    method parallel (line 600) | def parallel(self):
    method parallel (line 604) | def parallel(self, parallel):
    method tree (line 614) | def tree(self):
    method path (line 618) | def path(self):
    method setup (line 621) | def setup(self, inputs, output, size_dict):
    method _maybe_cancel_futures (line 665) | def _maybe_cancel_futures(self):
    method _maybe_report_result (line 671) | def _maybe_report_result(self, setting, trial):
    method _gen_results (line 703) | def _gen_results(self, repeats, trial_fn, trial_args):
    method _get_and_report_next_future (line 721) | def _get_and_report_next_future(self):
    method _gen_results_parallel (line 733) | def _gen_results_parallel(self, repeats, trial_fn, trial_args):
    method _search (line 757) | def _search(self, inputs, output, size_dict):
    method search (line 836) | def search(self, inputs, output, size_dict):
    method get_tree (line 847) | def get_tree(self):
    method __call__ (line 851) | def __call__(self, inputs, output, size_dict, memory_limit=None):
    method get_trials (line 860) | def get_trials(self, sort=None):
    method print_trials (line 892) | def print_trials(self, sort=None):
    method to_df (line 911) | def to_df(self):
    method to_dfs_parametrized (line 930) | def to_dfs_parametrized(self):
  class ReusableHyperOptimizer (line 962) | class ReusableHyperOptimizer(ReusableOptimizer):
    method _get_path_relevant_opts (line 993) | def _get_path_relevant_opts(self):
    method _get_suboptimizer (line 1011) | def _get_suboptimizer(self):
    method _deconstruct_tree (line 1014) | def _deconstruct_tree(self, opt, tree):
    method _reconstruct_tree (line 1022) | def _reconstruct_tree(self, inputs, output, size_dict, con):
  class HyperCompressedOptimizer (line 1037) | class HyperCompressedOptimizer(HyperOptimizer):
    method __init__ (line 1099) | def __init__(
  class ReusableHyperCompressedOptimizer (line 1124) | class ReusableHyperCompressedOptimizer(ReusableHyperOptimizer):
    method __init__ (line 1154) | def __init__(
    method _get_suboptimizer (line 1183) | def _get_suboptimizer(self):
    method _deconstruct_tree (line 1186) | def _deconstruct_tree(self, opt, tree):
    method _reconstruct_tree (line 1193) | def _reconstruct_tree(self, inputs, output, size_dict, con):
  class HyperMultiOptimizer (line 1203) | class HyperMultiOptimizer(HyperOptimizer):

FILE: cotengra/hyperoptimizers/hyper_cmaes.py
  class HyperCMAESSampler (line 16) | class HyperCMAESSampler:
    method __init__ (line 17) | def __init__(
    method ask (line 51) | def ask(self):
    method tell (line 62) | def tell(self, trial_number, value):
  class CMAESOptLib (line 72) | class CMAESOptLib(HyperOptLib):
    method setup (line 77) | def setup(
    method get_setting (line 105) | def get_setting(self):
    method report_result (line 115) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_es.py
  function _reflect (line 19) | def _reflect(x):
  class SteadyStateES (line 30) | class SteadyStateES:
    method __init__ (line 95) | def __init__(
    method _init_state (line 162) | def _init_state(self):
    method ask (line 191) | def ask(self):
    method tell (line 254) | def tell(self, trial_number, score):
    method _restart (line 333) | def _restart(self):
  class ESOptLib (line 354) | class ESOptLib(HyperOptLib):
    method setup (line 357) | def setup(
    method get_setting (line 468) | def get_setting(self):
    method report_result (line 479) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_neldermead.py
  function _clip (line 23) | def _clip(x, lo=-1.0, hi=1.0):
  function clamp (line 28) | def clamp(xs, lo=-1.0, hi=1.0):
  class _NMCore (line 33) | class _NMCore:
    method __init__ (line 86) | def __init__(
    method converged (line 146) | def converged(self):
    method best_vertex (line 151) | def best_vertex(self):
    method best_score (line 155) | def best_score(self):
    method _centroid_of (line 158) | def _centroid_of(self, vertices):
    method _reflect (line 162) | def _reflect(self, centroid, worst):
    method _expand (line 170) | def _expand(self, centroid, reflected):
    method _contract_outside_pt (line 178) | def _contract_outside_pt(self, centroid, reflected):
    method _contract_inside_pt (line 186) | def _contract_inside_pt(self, centroid, worst):
    method _shrink_vertex (line 194) | def _shrink_vertex(self, best, vertex):
    method _sort_simplex (line 202) | def _sort_simplex(self):
    method _simplex_diameter (line 207) | def _simplex_diameter(self):
    method _diameter_converged (line 221) | def _diameter_converged(self):
    method _initialize_simplex (line 237) | def _initialize_simplex(self, center, scales):
    method _enqueue (line 252) | def _enqueue(self, x, role):
    method _try_advance (line 259) | def _try_advance(self):
    method _try_advance_init (line 271) | def _try_advance_init(self):
    method inject_vertex (line 296) | def inject_vertex(self, x, score):
    method _begin_reflect (line 351) | def _begin_reflect(self):
    method _try_advance_reflect (line 371) | def _try_advance_reflect(self):
    method _try_advance_expand (line 418) | def _try_advance_expand(self):
    method _try_advance_contract (line 441) | def _try_advance_contract(self):
    method _begin_shrink (line 469) | def _begin_shrink(self):
    method _try_advance_shrink (line 476) | def _try_advance_shrink(self):
    method ask (line 497) | def ask(self):
    method tell (line 510) | def tell(self, token, score):
  class HyperNelderMeadSampler (line 531) | class HyperNelderMeadSampler:
    method __init__ (line 580) | def __init__(
    method _make_core (line 652) | def _make_core(self, center, scales):
    method _ask_filler (line 667) | def _ask_filler(self):
    method ask (line 694) | def ask(self):
    method tell (line 743) | def tell(self, trial_number, score):
  class NelderMeadOptLib (line 811) | class NelderMeadOptLib(HyperOptLib):
    method setup (line 814) | def setup(
    method get_setting (line 919) | def get_setting(self):
    method report_result (line 930) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_nevergrad.py
  function convert_param_to_nevergrad (line 6) | def convert_param_to_nevergrad(param):
  function get_methods_space (line 23) | def get_methods_space(methods):
  function convert_to_nevergrad_space (line 29) | def convert_to_nevergrad_space(method, space):
  class NevergradOptLib (line 37) | class NevergradOptLib(HyperOptLib):
    method setup (line 40) | def setup(
    method get_setting (line 123) | def get_setting(self):
    method report_result (line 134) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_optuna.py
  function make_getter (line 8) | def make_getter(name, param):
  function make_retriever (line 28) | def make_retriever(methods, space):
  class OptunaOptLib (line 57) | class OptunaOptLib(HyperOptLib):
    method setup (line 60) | def setup(
    method get_setting (line 80) | def get_setting(self):
    method report_result (line 96) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_random.py
  function sample_bool (line 10) | def sample_bool(rng):
  function sample_int (line 14) | def sample_int(rng, low, high):
  function sample_option (line 18) | def sample_option(rng, options):
  function sample_uniform (line 22) | def sample_uniform(rng, low, high):
  function sample_loguniform (line 26) | def sample_loguniform(rng, low, high):
  class RandomSpace (line 30) | class RandomSpace:
    method __init__ (line 31) | def __init__(self, space, seed=None):
    method sample (line 62) | def sample(self):
  class LHSRandomSpace (line 66) | class LHSRandomSpace:
    method __init__ (line 85) | def __init__(self, space, n, seed=None):
    method _stratify_float (line 127) | def _stratify_float(self, n, lo, hi):
    method _stratify_int (line 139) | def _stratify_int(self, n, lo, hi):
    method _stratify_categorical (line 157) | def _stratify_categorical(self, n, options):
    method sample (line 170) | def sample(self):
  class RandomSampler (line 179) | class RandomSampler:
    method __init__ (line 196) | def __init__(self, methods, spaces, n_samples=None, seed=None):
    method ask (line 209) | def ask(self):
  class RandomOptLib (line 216) | class RandomOptLib(HyperOptLib):
    method setup (line 226) | def setup(
    method get_setting (line 261) | def get_setting(self):
    method report_result (line 265) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_sbplx.py
  class HyperSbplxSampler (line 19) | class HyperSbplxSampler:
    method __init__ (line 89) | def __init__(
    method _partition_dims (line 188) | def _partition_dims(self):
    method _partition_greedy (line 210) | def _partition_greedy(self, order):
    method _partition_goodness (line 227) | def _partition_goodness(self, order, magnitudes):
    method _clamp_scale_factor (line 267) | def _clamp_scale_factor(self, factor):
    method _start_cycle (line 270) | def _start_cycle(self):
    method _start_sub_nm (line 279) | def _start_sub_nm(self):
    method _cycle_converged (line 302) | def _cycle_converged(self):
    method _embed_sub_vector (line 315) | def _embed_sub_vector(self, sub_x):
    method _ask_filler (line 324) | def _ask_filler(self):
    method _rescale_step (line 343) | def _rescale_step(self, step, factor, minimum=0.0):
    method _reset_cycle_state (line 360) | def _reset_cycle_state(self):
    method _restart (line 370) | def _restart(self, mode):
    method ask (line 408) | def ask(self):
    method tell (line 472) | def tell(self, trial_number, score):
    method _finish_subspace (line 527) | def _finish_subspace(self):
    method _update_steps_after_cycle (line 544) | def _update_steps_after_cycle(self):
    method _finish_cycle (line 581) | def _finish_cycle(self):
  class SbplxOptLib (line 616) | class SbplxOptLib(HyperOptLib):
    method setup (line 621) | def setup(
    method get_setting (line 746) | def get_setting(self):
    method report_result (line 757) | def report_result(self, setting, trial, score):

FILE: cotengra/hyperoptimizers/hyper_skopt.py
  function convert_param_to_skopt (line 6) | def convert_param_to_skopt(param, name):
  function get_methods_space (line 29) | def get_methods_space(methods):
  function convert_to_skopt_space (line 35) | def convert_to_skopt_space(method, space):
  class SkoptOptLib (line 42) | class SkoptOptLib(HyperOptLib):
    method setup (line 45) | def setup(
    method get_setting (line 111) | def get_setting(self):
    method report_result (line 129) | def report_result(self, setting, trial, score):

FILE: cotengra/interface.py
  function register_preset (line 26) | def register_preset(
  function preset_to_optimizer (line 74) | def preset_to_optimizer(preset):
  function can_hash_optimize (line 91) | def can_hash_optimize(cls):
  function identity (line 98) | def identity(x):
  function list_hash_prepare (line 105) | def list_hash_prepare(optimize):
  function hash_prepare_optimize (line 112) | def hash_prepare_optimize(optimize):
  function hash_contraction (line 125) | def hash_contraction(inputs, output, size_dict, optimize, **kwargs):
  function normalize_input (line 136) | def normalize_input(
  function _find_path_explicit_path (line 174) | def _find_path_explicit_path(inputs, output, size_dict, optimize):
  function _find_path_optimizer (line 186) | def _find_path_optimizer(inputs, output, size_dict, optimize, **kwargs):
  function _find_path_preset (line 190) | def _find_path_preset(inputs, output, size_dict, optimize, **kwargs):
  function _find_path_tree (line 195) | def _find_path_tree(inputs, output, size_dict, optimize, **kwargs):
  function find_path (line 199) | def find_path(inputs, output, size_dict, optimize="auto", **kwargs):
  function array_contract_path (line 242) | def array_contract_path(
  function _find_tree_explicit (line 310) | def _find_tree_explicit(inputs, output, size_dict, optimize, **kwargs):
  function _find_tree_optimizer_search (line 321) | def _find_tree_optimizer_search(inputs, output, size_dict, optimize, **k...
  function _find_tree_optimizer_basic (line 325) | def _find_tree_optimizer_basic(inputs, output, size_dict, optimize, **kw...
  function _find_tree_preset (line 330) | def _find_tree_preset(inputs, output, size_dict, optimize, **kwargs):
  function _find_tree_tree (line 343) | def _find_tree_tree(inputs, output, size_dict, optimize, **kwargs):
  function find_tree (line 351) | def find_tree(inputs, output, size_dict, optimize="auto", **kwargs):
  function array_contract_tree (line 394) | def array_contract_tree(
  class Variadic (line 461) | class Variadic:
    method __init__ (line 468) | def __init__(self, fn, **kwargs):
    method __call__ (line 472) | def __call__(self, *arrays, **kwargs):
  class Via (line 476) | class Via:
    method __init__ (line 483) | def __init__(self, fn, convert_in, convert_out):
    method __call__ (line 488) | def __call__(self, *arrays, **kwargs):
  class WithBackend (line 494) | class WithBackend:
    method __init__ (line 501) | def __init__(self, fn):
    method __call__ (line 504) | def __call__(self, *args, backend=None, **kwargs):
  function _array_contract_expression_with_constants (line 511) | def _array_contract_expression_with_constants(
  function _wrap_strip_exponent_final (line 577) | def _wrap_strip_exponent_final(fn):
  function _build_expression (line 585) | def _build_expression(
  function array_contract_expression (line 673) | def array_contract_expression(
  function array_contract (line 805) | def array_contract(
  function einsum_tree (line 875) | def einsum_tree(
  function einsum_expression (line 925) | def einsum_expression(
  function einsum (line 1039) | def einsum(
  function ncon (line 1111) | def ncon(arrays, indices, **kwargs):

FILE: cotengra/nodeops.py
  class NodeOpsFrozenset (line 5) | class NodeOpsFrozenset:
    method copy (line 10) | def copy(self):
    method node_from_single (line 25) | def node_from_single(x):
    method node_supremum (line 30) | def node_supremum(size):
    method node_get_single_el (line 35) | def node_get_single_el(node):
    method node_tie_breaker (line 40) | def node_tie_breaker(x):
    method is_valid_node (line 48) | def is_valid_node(node):
    method node_union (line 61) | def node_union(x, y):
    method node_union_it (line 66) | def node_union_it(bs):
    method node_issubset (line 74) | def node_issubset(x, y):
    method is_leaf (line 79) | def is_leaf(node):
    method is_supremum (line 83) | def is_supremum(node, N):
  class BitSetInt (line 87) | class BitSetInt(int):
    method __new__ (line 102) | def __new__(cls, it=0):
    method __hash__ (line 109) | def __hash__(self):
    method infimum (line 113) | def infimum(cls):
    method supremum (line 117) | def supremum(cls, size):
    method __len__ (line 120) | def __len__(self):
    method iter_sparse (line 123) | def iter_sparse(self):
    method iter_dense (line 130) | def iter_dense(self):
    method iter_numpy (line 133) | def iter_numpy(self):
    method __iter__ (line 143) | def __iter__(self):
    method __contains__ (line 163) | def __contains__(self, i):
    method __sub__ (line 166) | def __sub__(self, i):
    method difference (line 169) | def difference(self, i):
    method __and__ (line 172) | def __and__(self, i):
    method intersection (line 175) | def intersection(self, i):
    method __or__ (line 178) | def __or__(self, i):
    method union (line 181) | def union(*it):
    method issubset (line 184) | def issubset(self, other):
    method __repr__ (line 192) | def __repr__(self):
  class NodeOpsBitSetInt (line 196) | class NodeOpsBitSetInt:
    method copy (line 201) | def copy(self):
    method node_from_single (line 210) | def node_from_single(x):
    method node_supremum (line 214) | def node_supremum(size):
    method node_get_single_el (line 218) | def node_get_single_el(node):
    method node_tie_breaker (line 222) | def node_tie_breaker(x):
    method is_valid_node (line 226) | def is_valid_node(node):
    method node_union (line 233) | def node_union(x, y):
    method node_union_it (line 237) | def node_union_it(bs):
    method node_issubset (line 244) | def node_issubset(x, y):
    method is_leaf (line 248) | def is_leaf(node):
    method is_supremum (line 252) | def is_supremum(node, N):
  class NodeOpsSSA (line 256) | class NodeOpsSSA:
    method __init__ (line 259) | def __init__(self, N):
    method copy (line 263) | def copy(self):
    method get_next_ssa (line 269) | def get_next_ssa(self):
    method node_size (line 276) | def node_size(self, node):
    method node_from_single (line 279) | def node_from_single(self, x):
    method node_supremum (line 282) | def node_supremum(self, size):
    method node_get_single_el (line 285) | def node_get_single_el(self, node):
    method node_tie_breaker (line 288) | def node_tie_breaker(self, x):
    method is_valid_node (line 291) | def is_valid_node(self, node):
    method node_union (line 294) | def node_union(self, x, y):
    method node_union_it (line 297) | def node_union_it(self, bs):
    method new_node_for_union (line 300) | def new_node_for_union(self, nodes):
    method node_from_seq (line 308) | def node_from_seq(self, seq):
    method new_node_for_seq (line 311) | def new_node_for_seq(self, seq):
    method node_issubset (line 320) | def node_issubset(self, x, y):
    method is_leaf (line 323) | def is_leaf(self, node):
    method is_supremum (line 326) | def is_supremum(self, node, N):
  function get_nodeops (line 334) | def get_nodeops(node_type_str: str, N=None):

FILE: cotengra/oe.py
  class PathOptimizer (line 10) | class PathOptimizer:
  function get_path_fn (line 13) | def get_path_fn(*_, **__):
  function register_path_fn (line 16) | def register_path_fn(*_, **__):

FILE: cotengra/parallel.py
  function _remember_auto_backend (line 39) | def _remember_auto_backend(backend):
  function choose_default_num_workers (line 60) | def choose_default_num_workers():
  function get_pool (line 70) | def get_pool(n_workers=None, maybe_create=False, backend=None):
  function _infer_backed_cached (line 101) | def _infer_backed_cached(pool_class):
  function _infer_backend (line 124) | def _infer_backend(pool):
  function get_n_workers (line 129) | def get_n_workers(pool=None):
  function parse_parallel_arg (line 163) | def parse_parallel_arg(parallel):
  function set_parallel_backend (line 220) | def set_parallel_backend(backend):
  function maybe_leave_pool (line 230) | def maybe_leave_pool(pool):
  function maybe_rejoin_pool (line 236) | def maybe_rejoin_pool(is_worker, pool):
  function _worker_call (line 242) | def _worker_call(fn, args, kwargs):
  function submit (line 255) | def submit(pool, fn, *args, **kwargs):
  function scatter (line 269) | def scatter(pool, data):
  function can_scatter (line 276) | def can_scatter(pool):
  function should_nest (line 281) | def should_nest(pool):
  function get_loky_get_reusable_executor (line 295) | def get_loky_get_reusable_executor():
  class CachedProcessPoolExecutor (line 306) | class CachedProcessPoolExecutor:
    method __init__ (line 307) | def __init__(self):
    method __call__ (line 313) | def __call__(self, n_workers=None):
    method is_initialized (line 328) | def is_initialized(self):
    method shutdown (line 331) | def shutdown(self):
    method __del__ (line 338) | def __del__(self):
  function _get_process_pool_cf (line 345) | def _get_process_pool_cf(n_workers=None):
  class CachedThreadPoolExecutor (line 349) | class CachedThreadPoolExecutor:
    method __init__ (line 350) | def __init__(self):
    method __call__ (line 356) | def __call__(self, n_workers=None):
    method is_initialized (line 370) | def is_initialized(self):
    method shutdown (line 373) | def shutdown(self):
    method __del__ (line 380) | def __del__(self):
  function _get_thread_pool_cf (line 387) | def _get_thread_pool_cf(n_workers=None):
  function _get_pool_dask (line 394) | def _get_pool_dask(n_workers=None, maybe_create=False):
  function _maybe_leave_pool_dask (line 459) | def _maybe_leave_pool_dask():
  function _rejoin_pool_dask (line 470) | def _rejoin_pool_dask():
  function get_ray (line 480) | def get_ray():
  class RayFuture (line 487) | class RayFuture:
    method __init__ (line 492) | def __init__(self, obj):
    method result (line 496) | def result(self, timeout=None):
    method done (line 499) | def done(self):
    method cancel (line 504) | def cancel(self):
  function _unpack_futures_tuple (line 509) | def _unpack_futures_tuple(x):
  function _unpack_futures_list (line 513) | def _unpack_futures_list(x):
  function _unpack_futures_dict (line 517) | def _unpack_futures_dict(x):
  function _unpack_futures_identity (line 521) | def _unpack_futures_identity(x):
  function _unpack_futures (line 536) | def _unpack_futures(x):
  function get_remote_fn (line 547) | def get_remote_fn(fn, **remote_opts):
  function get_fn_as_remote_object (line 556) | def get_fn_as_remote_object(fn):
  function get_deploy (line 562) | def get_deploy(**remote_opts):
  class RayExecutor (line 576) | class RayExecutor:
    method __init__ (line 579) | def __init__(self, *args, default_remote_opts=None, **kwargs):
    method _maybe_inject_remote_opts (line 588) | def _maybe_inject_remote_opts(self, remote_opts=None):
    method submit (line 597) | def submit(self, fn, *args, pure=False, remote_opts=None, **kwargs):
    method map (line 615) | def map(self, func, *iterables, remote_opts=None):
    method scatter (line 623) | def scatter(self, data):
    method shutdown (line 630) | def shutdown(self):
  function _get_pool_ray (line 640) | def _get_pool_ray(n_workers=None, maybe_create=False):

FILE: cotengra/pathfinders/path_basic.py
  function is_simplifiable (line 18) | def is_simplifiable(legs, appearances):
  function compute_simplified (line 31) | def compute_simplified(legs, appearances):
  function compute_contracted (line 58) | def compute_contracted(ilegs, jlegs, appearances):
  function compute_size (line 97) | def compute_size(legs, sizes):
  function compute_flops (line 105) | def compute_flops(ilegs, jlegs, sizes):
  function compute_con_cost_flops (line 118) | def compute_con_cost_flops(
  function compute_con_cost_max (line 140) | def compute_con_cost_max(
  function compute_con_cost_size (line 162) | def compute_con_cost_size(
  function compute_con_cost_write (line 184) | def compute_con_cost_write(
  function compute_con_cost_combo (line 207) | def compute_con_cost_combo(
  function compute_con_cost_limit (line 237) | def compute_con_cost_limit(
  function parse_minimize_for_optimal (line 271) | def parse_minimize_for_optimal(minimize):
  class ContractionProcessor (line 316) | class ContractionProcessor:
    method __init__ (line 334) | def __init__(
    method copy (line 378) | def copy(self):
    method neighbors (line 392) | def neighbors(self, i):
    method neighbors_limit (line 411) | def neighbors_limit(self, i, max_neighbors):
    method print_current_terms (line 443) | def print_current_terms(self):
    method remove_ix (line 448) | def remove_ix(self, ix):
    method pop_node (line 457) | def pop_node(self, i):
    method add_node (line 473) | def add_node(self, legs):
    method check (line 484) | def check(self):
    method contract_nodes (line 493) | def contract_nodes(self, i, j, new_legs=None):
    method simplify_batch (line 510) | def simplify_batch(self):
    method simplify_single_terms (line 522) | def simplify_single_terms(self):
    method simplify_scalars (line 532) | def simplify_scalars(self):
    method simplify_hadamard (line 558) | def simplify_hadamard(self):
    method simplify (line 576) | def simplify(self):
    method subgraphs (line 587) | def subgraphs(self):
    method optimize_greedy (line 607) | def optimize_greedy(
    method optimize_optimal_connected (line 698) | def optimize_optimal_connected(
    method optimize_optimal (line 815) | def optimize_optimal(
    method optimize_remaining_by_size (line 827) | def optimize_remaining_by_size(self):
  function linear_to_ssa (line 855) | def linear_to_ssa(path, N=None):
  function ssa_to_linear (line 877) | def ssa_to_linear(ssa_path, N=None):
  function edge_path_to_ssa (line 902) | def edge_path_to_ssa(edge_path, inputs):
  function edge_path_to_linear (line 960) | def edge_path_to_linear(edge_path, inputs):
  function is_ssa_path (line 980) | def is_ssa_path(path, nterms):
  function optimize_simplify (line 995) | def optimize_simplify(inputs, output, size_dict, use_ssa=False):
  function optimize_greedy (line 1029) | def optimize_greedy(
  function optimize_random_greedy_track_flops (line 1103) | def optimize_random_greedy_track_flops(
  function optimize_optimal (line 1242) | def optimize_optimal(
  class EnsureInputsOutputAreSequence (line 1329) | class EnsureInputsOutputAreSequence:
    method __init__ (line 1330) | def __init__(self, f):
    method __call__ (line 1333) | def __call__(self, inputs, output, *args, **kwargs):
  function get_optimize_greedy (line 1342) | def get_optimize_greedy(accel="auto"):
  function get_optimize_random_greedy_track_flops (line 1360) | def get_optimize_random_greedy_track_flops(accel="auto"):
  class GreedyOptimizer (line 1377) | class GreedyOptimizer(PathOptimizer):
    method __init__ (line 1390) | def __init__(
    method maybe_update_defaults (line 1404) | def maybe_update_defaults(self, **kwargs):
    method ssa_path (line 1415) | def ssa_path(self, inputs, output, size_dict, **kwargs):
    method search (line 1424) | def search(self, inputs, output, size_dict, **kwargs):
    method __call__ (line 1432) | def __call__(self, inputs, output, size_dict, **kwargs):
  class RandomGreedyOptimizer (line 1442) | class RandomGreedyOptimizer(PathOptimizer):
    method __init__ (line 1505) | def __init__(
    method maybe_update_defaults (line 1548) | def maybe_update_defaults(self, **kwargs):
    method ssa_path (line 1559) | def ssa_path(self, inputs, output, size_dict, **kwargs):
    method search (line 1602) | def search(self, inputs, output, size_dict, **kwargs):
    method __call__ (line 1619) | def __call__(self, inputs, output, size_dict, **kwargs):
  class ReusableRandomGreedyOptimizer (line 1629) | class ReusableRandomGreedyOptimizer(ReusableOptimizer):
    method _get_path_relevant_opts (line 1632) | def _get_path_relevant_opts(self):
    method _get_suboptimizer (line 1645) | def _get_suboptimizer(self):
    method _deconstruct_tree (line 1648) | def _deconstruct_tree(self, opt, tree):
    method _reconstruct_tree (line 1656) | def _reconstruct_tree(self, inputs, output, size_dict, con):
  function get_optimize_optimal (line 1669) | def get_optimize_optimal(accel="auto"):
  class OptimalOptimizer (line 1686) | class OptimalOptimizer(PathOptimizer):
    method __init__ (line 1699) | def __init__(
    method maybe_update_defaults (line 1713) | def maybe_update_defaults(self, **kwargs):
    method ssa_path (line 1724) | def ssa_path(self, inputs, output, size_dict, **kwargs):
    method search (line 1733) | def search(self, inputs, output, size_dict, **kwargs):
    method __call__ (line 1741) | def __call__(self, inputs, output, size_dict, **kwargs):

FILE: cotengra/pathfinders/path_compressed.py
  class MiniTree (line 12) | class MiniTree:
    method __init__ (line 19) | def __init__(self):
    method copy (line 26) | def copy(self):
    method add (line 34) | def add(self, p, l, r):
    method contract (line 50) | def contract(self, p):
    method __repr__ (line 66) | def __repr__(self):
  class EmptyMiniTree (line 77) | class EmptyMiniTree:
    method __init__ (line 80) | def __init__(self, hgi, hgf):
    method copy (line 118) | def copy(self):
    method contract (line 123) | def contract(self, p):
  class Node (line 140) | class Node:
    method __init__ (line 145) | def __init__(self, hg, plr, chi, tracker, compress_late=False):
    method first (line 153) | def first(cls, inputs, output, size_dict, minimize):
    method next (line 179) | def next(self, p, l, r):
    method graph_key (line 213) | def graph_key(self):
    method __repr__ (line 216) | def __repr__(self):
  function ssa_path_to_bit_path (line 220) | def ssa_path_to_bit_path(path):
  function bit_path_to_ssa_path (line 234) | def bit_path_to_ssa_path(bitpath):
  class WindowedOptimizer (line 244) | class WindowedOptimizer:
    method __init__ (line 247) | def __init__(
    method tracker (line 264) | def tracker(self):
    method plot_size_footprint (line 269) | def plot_size_footprint(self, figsize=(8, 3)):
    method optimize_window (line 291) | def optimize_window(
    method refine (line 377) | def refine(
    method simulated_anneal (line 421) | def simulated_anneal(
    method get_ssa_path (line 531) | def get_ssa_path(self):

FILE: cotengra/pathfinders/path_compressed_greedy.py
  function _binary_combine (line 20) | def _binary_combine(func, x, y):
  class GreedyCompressed (line 33) | class GreedyCompressed:
    method __init__ (line 72) | def __init__(
    method _score (line 104) | def _score(self, i1, i2):
    method get_ssa_path (line 140) | def get_ssa_path(self, inputs, output, size_dict):
    method search (line 201) | def search(self, inputs, output, size_dict):
    method __call__ (line 209) | def __call__(self, inputs, output, size_dict, memory_limit=None):
  function greedy_compressed (line 215) | def greedy_compressed(inputs, output, size_dict, memory_limit=None, **kw...
  function trial_greedy_compressed (line 223) | def trial_greedy_compressed(inputs, output, size_dict, **kwargs):
  class GreedySpan (line 268) | class GreedySpan:
    method __init__ (line 296) | def __init__(
    method get_ssa_path (line 323) | def get_ssa_path(self, inputs, output, size_dict):
    method search (line 428) | def search(self, inputs, output, size_dict):
    method __call__ (line 436) | def __call__(self, inputs, output, size_dict, memory_limit=None):
  function greedy_span (line 442) | def greedy_span(inputs, output, size_dict, memory_limit=None, **kwargs):
  function trial_greedy_span (line 446) | def trial_greedy_span(inputs, output, size_dict, **kwargs):

FILE: cotengra/pathfinders/path_edgesort.py
  class EdgeSortOptimizer (line 5) | class EdgeSortOptimizer(PathOptimizer):
    method __init__ (line 16) | def __init__(self, reverse=False):
    method search (line 19) | def search(self, inputs, output, size_dict, **kwargs):
    method __call__ (line 32) | def __call__(self, inputs, output, size_dict, **kwargs):

FILE: cotengra/pathfinders/path_flowcutter.py
  class FlowCutterOptimizer (line 18) | class FlowCutterOptimizer(PathOptimizer):
    method __init__ (line 19) | def __init__(
    method run_flowcutter (line 26) | def run_flowcutter(self, file, max_time=None):
    method compute_edge_path (line 45) | def compute_edge_path(self, lg):
    method build_tree (line 50) | def build_tree(self, inputs, output, size_dict, memory_limit=None):
    method __call__ (line 76) | def __call__(self, inputs, output, size_dict, memory_limit=None):
  function optimize_flowcutter (line 80) | def optimize_flowcutter(
  function trial_flowcutter (line 87) | def trial_flowcutter(inputs, output, size_dict, max_time=10, seed=None):

FILE: cotengra/pathfinders/path_greedy.py
  function trial_greedy (line 12) | def trial_greedy(

FILE: cotengra/pathfinders/path_igraph.py
  function oe_to_igraph (line 19) | def oe_to_igraph(
  function igraph_subgraph_find_membership (line 46) | def igraph_subgraph_find_membership(
  function trial_igraph_dendrogram (line 100) | def trial_igraph_dendrogram(
  function trial_spinglass (line 166) | def trial_spinglass(

FILE: cotengra/pathfinders/path_kahypar.py
  function get_kahypar_profile_dir (line 13) | def get_kahypar_profile_dir():
  function to_sparse (line 33) | def to_sparse(hg, weight_nodes="const", weight_edges="log"):
  function kahypar_subgraph_find_membership (line 50) | def kahypar_subgraph_find_membership(

FILE: cotengra/pathfinders/path_labels.py
  function pop_fact (line 12) | def pop_fact(p, parts, n, pop_small_bias, pop_big_bias):
  function labels_partition (line 20) | def labels_partition(

FILE: cotengra/pathfinders/path_quickbb.py
  class QuickBBOptimizer (line 16) | class QuickBBOptimizer(PathOptimizer):
    method __init__ (line 17) | def __init__(self, max_time=10, executable="quickbb_64", seed=None):
    method run_quickbb (line 21) | def run_quickbb(self, fname, outfile, statfile, max_time=None):
    method build_tree (line 77) | def build_tree(self, inputs, output, size_dict):
    method __call__ (line 113) | def __call__(self, inputs, output, size_dict, memory_limit=None):
  function optimize_quickbb (line 117) | def optimize_quickbb(
  function trial_quickbb (line 124) | def trial_quickbb(inputs, output, size_dict, max_time=10, seed=None):

FILE: cotengra/pathfinders/path_random.py
  class RandomOptimizer (line 10) | class RandomOptimizer(PathOptimizer):
    method __init__ (line 21) | def __init__(self, seed=None):
    method __call__ (line 24) | def __call__(self, inputs, outputs, size_dict):
    method search (line 36) | def search(self, inputs, outputs, size_dict):

FILE: cotengra/pathfinders/path_simulated_annealing.py
  function compute_contracted_info (line 19) | def compute_contracted_info(legsa, legsb, appearances, size_dict):
  function linspace_generator (line 71) | def linspace_generator(start, stop, num, log=False):
  function _describe_tree (line 110) | def _describe_tree(tree, info="concise"):
  function _score_tree (line 114) | def _score_tree(scorer, tree, target_size=None, coeff_size_penalty=1.0):
  function _slice_tree_basic (line 125) | def _slice_tree_basic(tree, current_target_size, rng, unslice=1):
  function _slice_tree_reslice (line 134) | def _slice_tree_reslice(tree, current_target_size, rng):
  function _slice_tree_drift (line 138) | def _slice_tree_drift(tree, current_target_size, rng):
  function simulated_anneal_tree (line 152) | def simulated_anneal_tree(
  function _do_anneal (line 380) | def _do_anneal(tree, *args, **kwargs):
  function parallel_temper_tree (line 384) | def parallel_temper_tree(

FILE: cotengra/pathfinders/treedecomp.py
  class TreeDecomposition (line 48) | class TreeDecomposition:
    method __init__ (line 53) | def __init__(self):
  class EliminationOrdering (line 64) | class EliminationOrdering:
    method __init__ (line 69) | def __init__(self):
  function _increment_eo (line 76) | def _increment_eo(td, eo):
  function td_to_eo (line 119) | def td_to_eo(td):
  function td_str_to_tree_decomposition (line 140) | def td_str_to_tree_decomposition(td_str):

FILE: cotengra/plot.py
  function show_and_close (line 10) | def show_and_close(fn):
  function use_neutral_style (line 46) | def use_neutral_style(fn):
  function plot_trials_alt (line 60) | def plot_trials_alt(self, y=None, width=800, height=300):
  function plot_scatter (line 118) | def plot_scatter(
  function plot_trials (line 251) | def plot_trials(
  function plot_scatter_alt (line 272) | def plot_scatter_alt(
  function logxextrapolate (line 310) | def logxextrapolate(p1, p2, x):
  function mapper (line 319) | def mapper(y, x, mn, mx):
  function mapper_cat (line 323) | def mapper_cat(c, x, lookup):
  function plot_parameters_parallel (line 328) | def plot_parameters_parallel(
  function tree_to_networkx (line 452) | def tree_to_networkx(tree):
  function hypergraph_compute_plot_info_G (line 482) | def hypergraph_compute_plot_info_G(
  function rotate (line 610) | def rotate(xy, theta):
  function span (line 624) | def span(xy):
  function massage_pos (line 629) | def massage_pos(pos, nangles=100, flatten=False):
  function layout_pygraphviz (line 648) | def layout_pygraphviz(
  function get_nice_pos (line 713) | def get_nice_pos(
  function plot_tree (line 807) | def plot_tree(
  function plot_tree_ring (line 1089) | def plot_tree_ring(tree, **kwargs):
  function plot_tree_tent (line 1096) | def plot_tree_tent(tree, **kwargs):
  function plot_tree_span (line 1105) | def plot_tree_span(tree, **kwargs):
  function tree_to_df (line 1115) | def tree_to_df(tree):
  function plot_contractions (line 1152) | def plot_contractions(
  function plot_contractions_alt (line 1259) | def plot_contractions_alt(
  function slicefinder_to_df (line 1297) | def slicefinder_to_df(slice_finder, relative_flops=False):
  function plot_slicings (line 1322) | def plot_slicings(
  function plot_slicings_alt (line 1366) | def plot_slicings_alt(
  function plot_hypergraph (line 1401) | def plot_hypergraph(
  function plot_tree_rubberband (line 1560) | def plot_tree_rubberband(
  function plot_tree_flat (line 1643) | def plot_tree_flat(
  function plot_tree_circuit (line 1880) | def plot_tree_circuit(

FILE: cotengra/presets.py
  function estimate_optimal_hardness (line 26) | def estimate_optimal_hardness(inputs):
  class AutoOptimizer (line 44) | class AutoOptimizer(PathOptimizer):
    method __init__ (line 49) | def __init__(
    method _get_optimizer_hyper_threadsafe (line 76) | def _get_optimizer_hyper_threadsafe(self):
    method search (line 89) | def search(self, inputs, output, size_dict, **kwargs):
    method __call__ (line 115) | def __call__(self, inputs, output, size_dict, **kwargs):
  class AutoHQOptimizer (line 133) | class AutoHQOptimizer(AutoOptimizer):
    method __init__ (line 140) | def __init__(self, **kwargs):
  function get_auto_optimizer (line 154) | def get_auto_optimizer():
  function auto_optimize (line 159) | def auto_optimize(inputs, output, size_dict, **kwargs):
  function auto_optimize_tree (line 164) | def auto_optimize_tree(inputs, output, size_dict, **kwargs):
  function get_auto_hq_optimizer (line 171) | def get_auto_hq_optimizer():
  function auto_hq_optimize (line 176) | def auto_hq_optimize(inputs, output, size_dict, **kwargs):
  function auto_optimize_hq_tree (line 181) | def auto_optimize_hq_tree(inputs, output, size_dict, **kwargs):

FILE: cotengra/reusable.py
  function sortedtuple (line 10) | def sortedtuple(x):
  function make_hashable (line 14) | def make_hashable(x):
  function hash_contraction_a (line 25) | def hash_contraction_a(inputs, output, size_dict):
  function hash_contraction_b (line 41) | def hash_contraction_b(inputs, output, size_dict):
  function hash_contraction (line 58) | def hash_contraction(inputs, output, size_dict, method="a"):
  class ReusableOptimizer (line 68) | class ReusableOptimizer(PathOptimizer):
    method __init__ (line 105) | def __init__(
    method last_opt (line 142) | def last_opt(self):
    method _get_path_relevant_opts (line 145) | def _get_path_relevant_opts(self):
    method auto_hash_path_relevant_opts (line 151) | def auto_hash_path_relevant_opts(self):
    method hash_query (line 161) | def hash_query(self, inputs, output, size_dict):
    method minimize (line 175) | def minimize(self):
    method update_from_tree (line 181) | def update_from_tree(self, tree, overwrite="improved"):
    method _run_optimizer (line 219) | def _run_optimizer(self, inputs, output, size_dict):
    method _maybe_run_optimizer (line 231) | def _maybe_run_optimizer(self, inputs, output, size_dict):
    method __call__ (line 261) | def __call__(self, inputs, output, size_dict, memory_limit=None):
    method _get_suboptimizer (line 265) | def _get_suboptimizer(self):
    method _deconstruct_tree (line 268) | def _deconstruct_tree(self, opt, tree):
    method _run_optimizer (line 271) | def _run_optimizer(self, inputs, output, size_dict):
    method _reconstruct_tree (line 278) | def _reconstruct_tree(self, inputs, output, size_dict, con):
    method search (line 281) | def search(self, inputs, output, size_dict):
    method cleanup (line 290) | def cleanup(self):

FILE: cotengra/schematic.py
  class Drawing (line 11) | class Drawing:
    method __init__ (line 47) | def __init__(
    method _adjust_lims (line 106) | def _adjust_lims(self, x, y):
    method text (line 139) | def text(self, coo, text, preset=None, **kwargs):
    method text_between (line 173) | def text_between(self, cooa, coob, text, preset=None, **kwargs):
    method label_ax (line 227) | def label_ax(self, x, y, text, preset=None, **kwargs):
    method label_fig (line 250) | def label_fig(self, x, y, text, preset=None, **kwargs):
    method _parse_style_for_marker (line 273) | def _parse_style_for_marker(self, coo, preset=None, **kwargs):
    method _adjust_lims_for_marker (line 295) | def _adjust_lims_for_marker(self, x, y, r):
    method circle (line 304) | def circle(self, coo, preset=None, **kwargs):
    method wedge (line 324) | def wedge(self, coo, theta1, theta2, preset=None, **kwargs):
    method dot (line 357) | def dot(self, coo, preset=None, **kwargs):
    method regular_polygon (line 376) | def regular_polygon(self, coo, preset=None, **kwargs):
    method marker (line 406) | def marker(self, coo, preset=None, **kwargs):
    method square (line 448) | def square(self, coo, preset=None, **kwargs):
    method cube (line 451) | def cube(self, coo, preset=None, **kwargs):
    method line (line 483) | def line(self, cooa, coob, preset=None, **kwargs):
    method line_offset (line 577) | def line_offset(
    method arrowhead (line 674) | def arrowhead(self, cooa, coob, preset=None, **kwargs):
    method curve (line 749) | def curve(self, coos, preset=None, **kwargs):
    method shape (line 846) | def shape(self, coos, preset=None, **kwargs):
    method rectangle (line 897) | def rectangle(self, cooa, coob, preset=None, **kwargs):
    method patch (line 915) | def patch(self, coos, preset=None, **kwargs):
    method patch_around (line 987) | def patch_around(self, coos, *, preset=None, **kwargs):
    method patch_around_circles (line 1047) | def patch_around_circles(
    method savefig (line 1134) | def savefig(self, fname, dpi=300, bbox_inches="tight"):
  function parse_style_preset (line 1138) | def parse_style_preset(presets, preset, **kwargs):
  function simple_scale (line 1169) | def simple_scale(i, j, xscale=1, yscale=1):
  function axonometric_project (line 1173) | def axonometric_project(
  function coo_to_zorder (line 1214) | def coo_to_zorder(i, j, k, xscale=1, yscale=1, zscale=1):
  function get_color (line 1240) | def get_color(
  function mod_sat (line 1300) | def mod_sat(c, mod=None, alpha=None):
  function auto_colors (line 1316) | def auto_colors(nc, alpha=None, default_sequence=False):
  function darken_color (line 1373) | def darken_color(color, factor=2 / 3):
  function average_color (line 1379) | def average_color(colors):
  function jitter_color (line 1397) | def jitter_color(color, factor=0.05):
  function set_coloring_seed (line 1415) | def set_coloring_seed(seed):
  function hash_to_nvalues (line 1427) | def hash_to_nvalues(s, nval, seed=None):
  function hash_to_color (line 1449) | def hash_to_color(
  function mean (line 1493) | def mean(xs):
  function distance (line 1503) | def distance(pa, pb):
  function get_angle (line 1511) | def get_angle(pa, pb):
  function get_rotator_and_inverse (line 1517) | def get_rotator_and_inverse(pa, pb):
  function get_control_points (line 1542) | def get_control_points(pa, pb, pc, spacing=1 / 3):
  function gen_points_around (line 1585) | def gen_points_around(coo, radius=1, resolution=12):

FILE: cotengra/scoring.py
  class Objective (line 11) | class Objective:
    method __call__ (line 16) | def __call__(self, trial):
    method __repr__ (line 23) | def __repr__(self):
    method __hash__ (line 31) | def __hash__(self):
  function ensure_basic_quantities_are_computed (line 38) | def ensure_basic_quantities_are_computed(trial):
  class ExactObjective (line 50) | class ExactObjective(Objective):
    method cost_local_tree_node (line 53) | def cost_local_tree_node(self, tree, node):
    method score_local (line 59) | def score_local(self, **kwargs):
    method score_slice_index (line 65) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 71) | def get_dynamic_programming_minimize(self):
  class FlopsObjective (line 78) | class FlopsObjective(ExactObjective):
    method __init__ (line 90) | def __init__(self, secondary_weight=1e-3):
    method cost_local_tree_node (line 94) | def cost_local_tree_node(self, tree, node):
    method score_local (line 97) | def score_local(self, **kwargs):
    method score_slice_index (line 106) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 113) | def get_dynamic_programming_minimize(self):
    method __call__ (line 116) | def __call__(self, trial):
  class WriteObjective (line 125) | class WriteObjective(ExactObjective):
    method __init__ (line 139) | def __init__(self, secondary_weight=1e-3):
    method cost_local_tree_node (line 143) | def cost_local_tree_node(self, tree, node):
    method score_local (line 146) | def score_local(self, **kwargs):
    method score_slice_index (line 155) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 162) | def get_dynamic_programming_minimize(self):
    method __call__ (line 165) | def __call__(self, trial):
  class SizeObjective (line 174) | class SizeObjective(ExactObjective):
    method __init__ (line 186) | def __init__(self, secondary_weight=1e-3):
    method cost_local_tree_node (line 190) | def cost_local_tree_node(self, tree, node):
    method score_local (line 193) | def score_local(self, **kwargs):
    method score_slice_index (line 202) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 209) | def get_dynamic_programming_minimize(self):
    method __call__ (line 212) | def __call__(self, trial):
  class ComboObjective (line 221) | class ComboObjective(ExactObjective):
    method __init__ (line 240) | def __init__(
    method cost_local_tree_node (line 247) | def cost_local_tree_node(self, tree, node):
    method score_local (line 250) | def score_local(self, **kwargs):
    method score_slice_index (line 269) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 276) | def get_dynamic_programming_minimize(self):
    method __call__ (line 279) | def __call__(self, trial):
  class LimitObjective (line 284) | class LimitObjective(ExactObjective):
    method __init__ (line 304) | def __init__(self, factor=DEFAULT_COMBO_FACTOR):
    method cost_local_tree_node (line 308) | def cost_local_tree_node(self, tree, node):
    method score_local (line 311) | def score_local(self, **kwargs):
    method score_slice_index (line 321) | def score_slice_index(self, costs, ix):
    method get_dynamic_programming_minimize (line 328) | def get_dynamic_programming_minimize(self):
    method __call__ (line 331) | def __call__(self, trial):
  class CompressedStatsTracker (line 339) | class CompressedStatsTracker:
    method __init__ (line 353) | def __init__(self, hg, chi):
    method copy (line 378) | def copy(self):
    method update_pre_step (line 384) | def update_pre_step(self):
    method update_pre_compress (line 388) | def update_pre_compress(self, hg, *nodes):
    method update_post_compress (line 394) | def update_post_compress(self, hg, *nodes):
    method update_pre_contract (line 399) | def update_pre_contract(self, hg, i, j):
    method update_post_contract (line 405) | def update_post_contract(self, hg, ij):
    method update_post_step (line 413) | def update_post_step(self):
    method update_score (line 420) | def update_score(self, other):
    method combo_score (line 432) | def combo_score(self):
    method score (line 436) | def score(self):
    method describe (line 439) | def describe(self, join=" "):
    method __repr__ (line 454) | def __repr__(self):
  class CompressedStatsTrackerSize (line 458) | class CompressedStatsTrackerSize(CompressedStatsTracker):
    method __init__ (line 461) | def __init__(self, hg, chi, secondary_weight=1e-3):
    method score (line 466) | def score(self):
  class CompressedStatsTrackerPeak (line 473) | class CompressedStatsTrackerPeak(CompressedStatsTracker):
    method __init__ (line 476) | def __init__(self, hg, chi, secondary_weight=1e-3):
    method score (line 481) | def score(self):
  class CompressedStatsTrackerWrite (line 488) | class CompressedStatsTrackerWrite(CompressedStatsTracker):
    method __init__ (line 491) | def __init__(self, hg, chi, secondary_weight=1e-3):
    method score (line 496) | def score(self):
  class CompressedStatsTrackerFlops (line 503) | class CompressedStatsTrackerFlops(CompressedStatsTracker):
    method __init__ (line 506) | def __init__(self, hg, chi, secondary_weight=1e-3):
    method score (line 511) | def score(self):
  class CompressedStatsTrackerCombo (line 518) | class CompressedStatsTrackerCombo(CompressedStatsTracker):
    method __init__ (line 521) | def __init__(self, hg, chi, factor=DEFAULT_COMBO_FACTOR):
    method score (line 526) | def score(self):
  class CompressedObjective (line 530) | class CompressedObjective(Objective):
    method __init__ (line 533) | def __init__(self, chi="auto", compress_late=False):
    method get_compressed_stats_tracker (line 538) | def get_compressed_stats_tracker(self, hg):
    method compute_compressed_stats (line 553) | def compute_compressed_stats(self, trial):
  class CompressedSizeObjective (line 566) | class CompressedSizeObjective(CompressedObjective):
    method __init__ (line 586) | def __init__(
    method get_compressed_stats_tracker (line 595) | def get_compressed_stats_tracker(self, hg):
    method __call__ (line 600) | def __call__(self, trial):
  class CompressedPeakObjective (line 615) | class CompressedPeakObjective(CompressedObjective):
    method __init__ (line 636) | def __init__(
    method get_compressed_stats_tracker (line 645) | def get_compressed_stats_tracker(self, hg):
    method __call__ (line 650) | def __call__(self, trial):
  class CompressedWriteObjective (line 665) | class CompressedWriteObjective(CompressedObjective):
    method __init__ (line 686) | def __init__(
    method get_compressed_stats_tracker (line 695) | def get_compressed_stats_tracker(self, hg):
    method __call__ (line 700) | def __call__(self, trial):
  class CompressedFlopsObjective (line 715) | class CompressedFlopsObjective(CompressedObjective):
    method __init__ (line 736) | def __init__(
    method get_compressed_stats_tracker (line 745) | def get_compressed_stats_tracker(self, hg):
    method __call__ (line 750) | def __call__(self, trial):
  class CompressedComboObjective (line 765) | class CompressedComboObjective(CompressedObjective):
    method __init__ (line 768) | def __init__(
    method get_compressed_stats_tracker (line 777) | def get_compressed_stats_tracker(self, hg):
    method __call__ (line 782) | def __call__(self, trial):
  function parse_minimize (line 817) | def parse_minimize(minimize):
  function _get_score_fn_str_cached (line 827) | def _get_score_fn_str_cached(minimize):
  function get_score_fn (line 880) | def get_score_fn(minimize):
  class MultiObjective (line 892) | class MultiObjective(Objective):
    method __init__ (line 895) | def __init__(self, num_configs):
    method compute_mult (line 898) | def compute_mult(self, dims):
    method estimate_node_mult (line 901) | def estimate_node_mult(self, tree, node):
    method estimate_node_cache_mult (line 906) | def estimate_node_cache_mult(self, tree, node, sliced_ind_ordering):
  class MultiObjectiveDense (line 920) | class MultiObjectiveDense(MultiObjective):
    method compute_mult (line 927) | def compute_mult(self, dims):
  function expected_coupons (line 931) | def expected_coupons(num_sub, num_total):
  class MultiObjectiveUniform (line 938) | class MultiObjectiveUniform(MultiObjective):
    method compute_mult (line 945) | def compute_mult(self, dims):
  class MultiObjectiveLinear (line 949) | class MultiObjectiveLinear(MultiObjective):
    method __init__ (line 957) | def __init__(self, num_configs, coeff=1):
    method compute_mult (line 961) | def compute_mult(self, dims):

FILE: cotengra/slicer.py
  class ContractionCosts (line 17) | class ContractionCosts:
    method __init__ (line 43) | def __init__(
    method _set_state_from (line 77) | def _set_state_from(self, other):
    method copy (line 89) | def copy(self):
    method from_contraction_tree (line 96) | def from_contraction_tree(cls, contraction_tree, **kwargs):
    method from_info (line 115) | def from_info(cls, info, **kwargs):
    method size (line 121) | def size(self):
    method flops (line 125) | def flops(self):
    method total_flops (line 129) | def total_flops(self):
    method overhead (line 133) | def overhead(self):
    method remove (line 136) | def remove(self, ix, inplace=False):
    method __repr__ (line 194) | def __repr__(self):
  class SliceFinder (line 204) | class SliceFinder:
    method __init__ (line 232) | def __init__(
    method _maybe_default (line 283) | def _maybe_default(self, attr, value):
    method best (line 288) | def best(
    method trial (line 333) | def trial(
    method search (line 409) | def search(

FILE: cotengra/utils.py
  function getter (line 20) | def getter(index):
  function groupby (line 33) | def groupby(key, seq):
  function interleave (line 45) | def interleave(seqs):
  function unique (line 57) | def unique(it):
  function deprecated (line 61) | def deprecated(fn, old_name, new_name):
  function prod (line 74) | def prod(it):
  class oset (line 82) | class oset:
    method __init__ (line 90) | def __init__(self, it=()):
    method _from_dict (line 94) | def _from_dict(cls, d):
    method from_dict (line 100) | def from_dict(cls, d):
    method copy (line 104) | def copy(self):
    method add (line 107) | def add(self, k):
    method discard (line 110) | def discard(self, k):
    method remove (line 113) | def remove(self, k):
    method clear (line 116) | def clear(self):
    method update (line 119) | def update(self, *others):
    method union (line 123) | def union(self, *others):
    method intersection_update (line 128) | def intersection_update(self, *others):
    method intersection (line 135) | def intersection(self, *others):
    method difference_update (line 145) | def difference_update(self, *others):
    method difference (line 152) | def difference(self, *others):
    method symmetric_difference (line 159) | def symmetric_difference(self, other):
    method __eq__ (line 168) | def __eq__(self, other):
    method __or__ (line 173) | def __or__(self, other):
    method __ior__ (line 176) | def __ior__(self, other):
    method __and__ (line 180) | def __and__(self, other):
    method __iand__ (line 183) | def __iand__(self, other):
    method __sub__ (line 187) | def __sub__(self, other):
    method __isub__ (line 190) | def __isub__(self, other):
    method __len__ (line 194) | def __len__(self):
    method __iter__ (line 197) | def __iter__(self):
    method __contains__ (line 200) | def __contains__(self, x):
    method __repr__ (line 203) | def __repr__(self):
  class MaxCounter (line 207) | class MaxCounter:
    method __init__ (line 239) | def __init__(self, it=None):
    method copy (line 246) | def copy(self):
    method discard (line 252) | def discard(self, x):
    method add (line 267) | def add(self, x):
    method max (line 272) | def max(self):
  class BitSet (line 277) | class BitSet:
    method __init__ (line 280) | def __init__(self, it):
    method asint (line 288) | def asint(self, elem):
    method fromint (line 291) | def fromint(self, n):
    method frommembers (line 294) | def frommembers(self, it=()):
  class BitMembers (line 300) | class BitMembers:
    method fromint (line 304) | def fromint(cls, bitset, n):
    method frommembers (line 311) | def frommembers(cls, bitset, it=()):
    method __int__ (line 317) | def __int__(self):
    method __eq__ (line 322) | def __eq__(self, other):
    method __len__ (line 327) | def __len__(self):
    method __iter__ (line 330) | def __iter__(self):
    method add (line 337) | def add(self, elem):
    method clear (line 340) | def clear(self):
    method copy (line 343) | def copy(self):
    method __bool__ (line 346) | def __bool__(self):
    method __contains__ (line 349) | def __contains__(self, elem):
    method discard (line 352) | def discard(self, elem):
    method remove (line 355) | def remove(self, elem):
    method difference_update (line 360) | def difference_update(self, *others):
    method difference (line 366) | def difference(self, *others):
    method intersection_update (line 373) | def intersection_update(self, *others):
    method intersection (line 379) | def intersection(self, *others):
    method isdisjoint (line 386) | def isdisjoint(self, other):
    method issubset (line 389) | def issubset(self, other):
    method issuperset (line 392) | def issuperset(self, other):
    method symmetric_difference_update (line 395) | def symmetric_difference_update(self, other):
    method symmetric_difference (line 400) | def symmetric_difference(self, other):
    method update (line 405) | def update(self, *others):
    method union (line 410) | def union(self, *others):
    method __repr__ (line 415) | def __repr__(self):
  class DiskDict (line 419) | class DiskDict:
    method __init__ (line 446) | def __init__(self, directory=None, max_retries=3, retry_delay=0.01):
    method clear (line 457) | def clear(self):
    method cleanup (line 466) | def cleanup(self, delete_dir=False):
    method __contains__ (line 476) | def __contains__(self, k):
    method __setitem__ (line 488) | def __setitem__(self, k, v):
    method __delitem__ (line 502) | def __delitem__(self, k):
    method __getitem__ (line 521) | def __getitem__(self, k):
    method get (line 553) | def get(self, k, default=None):
    method keys (line 559) | def keys(self):
    method values (line 574) | def values(self):
    method items (line 578) | def items(self):
  function get_rng (line 583) | def get_rng(seed=None):
  class GumbelBatchedGenerator (line 605) | class GumbelBatchedGenerator:
    method __init__ (line 608) | def __init__(self, seed=None):
    method __call__ (line 611) | def __call__(self):
  class BadTrial (line 615) | class BadTrial(Exception):
  function compute_size_by_dict (line 624) | def compute_size_by_dict(indices, size_dict):
  function get_symbol (line 657) | def get_symbol(i):
  function get_symbol_map (line 689) | def get_symbol_map(inputs):
  function rand_equation (line 711) | def rand_equation(
  function tree_equation (line 791) | def tree_equation(
  function networkx_graph_to_equation (line 828) | def networkx_graph_to_equation(
  function randreg_equation (line 872) | def randreg_equation(
  function perverse_equation (line 908) | def perverse_equation(
  function rand_tree (line 960) | def rand_tree(
  function lattice_equation (line 991) | def lattice_equation(dims, cyclic=False, d_min=2, d_max=None, seed=None):
  function find_output_str (line 1057) | def find_output_str(lhs):
  function eq_to_inputs_output (line 1083) | def eq_to_inputs_output(eq):
  function inputs_output_to_eq (line 1108) | def inputs_output_to_eq(inputs, output, canonicalize=False):
  function shapes_inputs_to_size_dict (line 1135) | def shapes_inputs_to_size_dict(shapes, inputs):
  function make_rand_size_dict_from_inputs (line 1159) | def make_rand_size_dict_from_inputs(inputs, d_min=2, d_max=3, seed=None):
  function make_shapes_from_inputs (line 1188) | def make_shapes_from_inputs(inputs, size_dict):
  function make_arrays_from_inputs (line 1206) | def make_arrays_from_inputs(inputs, size_dict, seed=None, dtype="float64"):
  function make_arrays_from_eq (line 1250) | def make_arrays_from_eq(
  function find_output_from_inputs (line 1289) | def find_output_from_inputs(inputs):
  function is_edge_path (line 1321) | def is_edge_path(optimize):
  function canonicalize_inputs (line 1330) | def canonicalize_inputs(
  function convert_from_interleaved (line 1415) | def convert_from_interleaved(args):
  function check_ellipsis (line 1433) | def check_ellipsis(term):
  function parse_equation_ellipses (line 1455) | def parse_equation_ellipses(eq, shapes, tuples=False):
  function parse_einsum_input (line 1517) | def parse_einsum_input(args, shapes=False, tuples=False, constants=None):
  function save_to_json (line 1565) | def save_to_json(inputs, output, size_dict, filename):
  function load_from_json (line 1591) | def load_from_json(filename):

FILE: docs/_pygments/_pygments_dark.py
  class MarianaDark (line 39) | class MarianaDark(Style):

FILE: docs/_pygments/_pygments_light.py
  class MarianaLight (line 39) | class MarianaLight(Style):

FILE: docs/conf.py
  function linkcode_resolve (line 96) | def linkcode_resolve(domain, info):

FILE: tests/test_backends.py
  function _has (line 22) | def _has(name):
  function _setup_backend (line 64) | def _setup_backend(backend):
  function _to_backend (line 72) | def _to_backend(x, backend):
  function test_contract_backend (line 102) | def test_contract_backend(backend, dtype, strip_exponent, slicing):

FILE: tests/test_compressed.py
  function test_compressed_greedy (line 6) | def test_compressed_greedy():
  function test_compressed_span (line 24) | def test_compressed_span():
  function test_compressed_agglom (line 42) | def test_compressed_agglom():
  function test_compressed_reconfigure (line 64) | def test_compressed_reconfigure(order_only):
  function test_compressed_windowed_reconfigure (line 78) | def test_compressed_windowed_reconfigure():

FILE: tests/test_compute.py
  function test_basic_equations (line 107) | def test_basic_equations(eq, dtype, strip_exponent):
  function test_contraction_tree_rand_equation (line 127) | def test_contraction_tree_rand_equation(
  function test_lazy_sliced_output_reduce (line 188) | def test_lazy_sliced_output_reduce():
  function test_exponent_stripping (line 221) | def test_exponent_stripping(autojit, dtype):
  function test_einsum_expression (line 255) | def test_einsum_expression(

FILE: tests/test_hypergraph.py
  function test_shortest_distances (line 6) | def test_shortest_distances():
  function test_resistance_centrality (line 16) | def test_resistance_centrality():
  function test_simple_centrality (line 25) | def test_simple_centrality():
  function test_compute_loops (line 34) | def test_compute_loops():
  function test_plot_nonconsec (line 47) | def test_plot_nonconsec():

FILE: tests/test_interface.py
  function test_array_contract_path_cache (line 8) | def test_array_contract_path_cache(optimize_type):
  function test_array_contract_expression_cache (line 37) | def test_array_contract_expression_cache(optimize_type, strip_exponent):
  function test_einsum_formats_interleaved (line 85) | def test_einsum_formats_interleaved():
  function test_einsum_ellipses (line 110) | def test_einsum_ellipses(eq, shapes):
  function test_slice_and_strip_exponent (line 117) | def test_slice_and_strip_exponent():
  function test_null_tree (line 166) | def test_null_tree():

FILE: tests/test_optimizers.py
  function rand_reg_contract (line 26) | def rand_reg_contract(n, deg, seed=None):
  function contraction_20_5 (line 50) | def contraction_20_5():
  function test_basic (line 87) | def test_basic(contraction_20_5, method, requires):
  function test_single_term_uniform (line 106) | def test_single_term_uniform(inputs, output, size_dict, method, requires):
  function test_single_term_direct (line 125) | def test_single_term_direct(inputs, output, size_dict, method, requires):
  function test_hyper (line 152) | def test_hyper(contraction_20_5, optlib, requires, parallel):
  function test_hyper_sbplx_restart_patience_triggers_local_restart (line 170) | def test_hyper_sbplx_restart_patience_triggers_local_restart():
  function test_hyper_sbplx_partition_uses_goodness_heuristic (line 201) | def test_hyper_sbplx_partition_uses_goodness_heuristic():
  function test_hyper_sbplx_partition_greedy_equal_chunks (line 218) | def test_hyper_sbplx_partition_greedy_equal_chunks():
  function test_hyper_sbplx_cycle_step_scaling_clamped_by_omega (line 238) | def test_hyper_sbplx_cycle_step_scaling_clamped_by_omega():
  function test_hyper_sbplx_cycle_convergence_is_relative_to_scale (line 257) | def test_hyper_sbplx_cycle_convergence_is_relative_to_scale():
  function test_hyper_sbplx_repeated_restarts_escalate_to_global_restart (line 272) | def test_hyper_sbplx_repeated_restarts_escalate_to_global_restart():
  function test_hyper_sbplx_improvement_resets_restart_counters (line 303) | def test_hyper_sbplx_improvement_resets_restart_counters():
  function test_hyper_sbplx_stale_nm_results_ignored_after_restart (line 324) | def test_hyper_sbplx_stale_nm_results_ignored_after_restart():
  function test_nmcore_inject_vertex_diameter_gate_accepts_nearby (line 346) | def test_nmcore_inject_vertex_diameter_gate_accepts_nearby():
  function test_nmcore_inject_vertex_diameter_gate_rejects_far (line 365) | def test_nmcore_inject_vertex_diameter_gate_rejects_far():
  function test_nmcore_inject_vertex_early_convergence_signal (line 383) | def test_nmcore_inject_vertex_early_convergence_signal():
  function test_nmcore_inject_vertex_inf_diameter_fraction (line 403) | def test_nmcore_inject_vertex_inf_diameter_fraction():
  function test_nm_sampler_adaptive_filler_scale (line 420) | def test_nm_sampler_adaptive_filler_scale():
  function test_sbplx_sampler_adaptive_filler_scale (line 457) | def test_sbplx_sampler_adaptive_filler_scale():
  function test_nmcore_psi_convergence_uses_relative_diameter (line 479) | def test_nmcore_psi_convergence_uses_relative_diameter():
  function test_nm_sampler_exits_init_phase_with_inf_scores (line 496) | def test_nm_sampler_exits_init_phase_with_inf_scores():
  function test_cmaes_report_result_handles_inf (line 523) | def test_cmaes_report_result_handles_inf():
  function test_optuna_report_result_handles_inf (line 542) | def test_optuna_report_result_handles_inf():
  function test_binaries (line 581) | def test_binaries(contraction_20_5, optimize):
  function test_hyper_slicer (line 590) | def test_hyper_slicer(parallel):
  function test_hyper_reconf (line 613) | def test_hyper_reconf(parallel):
  function test_hyper_slicer_reconf (line 633) | def test_hyper_slicer_reconf(parallel):
  function test_insane_nested (line 661) | def test_insane_nested(parallel_backend):
  function test_plotting (line 694) | def test_plotting():
  function test_auto_optimizers_threadsafe (line 712) | def test_auto_optimizers_threadsafe():
  function test_reusable_optimizes_overwrite_improved (line 731) | def test_reusable_optimizes_overwrite_improved():

FILE: tests/test_parallel.py
  function _reset_parallel_state (line 18) | def _reset_parallel_state():
  function _check_worker_flag (line 27) | def _check_worker_flag():
  function _worker_auto_returns_none (line 32) | def _worker_auto_returns_none():
  function _subprocess_auto_returns_none (line 37) | def _subprocess_auto_returns_none(q):
  function test_auto_creates_pool (line 42) | def test_auto_creates_pool():
  function test_default_backend_preference (line 52) | def test_default_backend_preference():
  function test_explicit_process_backend_reuses_auto (line 60) | def test_explicit_process_backend_reuses_auto():
  function test_explicit_loky_reuses_auto (line 73) | def test_explicit_loky_reuses_auto():
  function test_threads_remain_explicit_only_for_auto (line 89) | def test_threads_remain_explicit_only_for_auto():
  function test_threads_do_not_clobber_remembered_auto_backend (line 103) | def test_threads_do_not_clobber_remembered_auto_backend():
  function test_worker_flag_prevents_auto_pool (line 116) | def test_worker_flag_prevents_auto_pool():
  function test_submit_sets_worker_flag_for_process_pools (line 127) | def test_submit_sets_worker_flag_for_process_pools():
  function test_submit_does_not_mark_thread_workers (line 138) | def test_submit_does_not_mark_thread_workers():
  function test_spawn_like_workers_disable_auto (line 153) | def test_spawn_like_workers_disable_auto(start_method):
  function test_subprocess_no_auto_pool_fork (line 167) | def test_subprocess_no_auto_pool_fork():
  function test_random_greedy_parallel_process_backend (line 188) | def test_random_greedy_parallel_process_backend(monkeypatch):
  function test_pool_persists_across_calls (line 211) | def test_pool_persists_across_calls():
  function test_explicit_parallel_true_sets_pid (line 222) | def test_explicit_parallel_true_sets_pid():
  function test_pid_mismatch_returns_none (line 233) | def test_pid_mismatch_returns_none():

FILE: tests/test_paths_basic.py
  function test_manual_cases (line 99) | def test_manual_cases(eq, which):
  function test_basic_rand (line 115) | def test_basic_rand(seed, which):
  function test_random_greedy_track_flops (line 143) | def test_random_greedy_track_flops(seed):
  function test_basic_perverse (line 177) | def test_basic_perverse(seed, which):
  function test_optimal_lattice_eq (line 194) | def test_optimal_lattice_eq():
  function test_random_optimize (line 208) | def test_random_optimize():
  function test_edgesort_optimize (line 221) | def test_edgesort_optimize():
  function test_edgesort_optimize_manual_labelled_reverse (line 234) | def test_edgesort_optimize_manual_labelled_reverse():

FILE: tests/test_slicer.py
  function test_slicer (line 6) | def test_slicer():
  function test_plot (line 16) | def test_plot():
  function test_plot_alt (line 28) | def test_plot_alt():

FILE: tests/test_tree.py
  function test_contraction_tree_equivalency (line 7) | def test_contraction_tree_equivalency(nodeops):
  function test_contraction_tree_from_path_incomplete (line 47) | def test_contraction_tree_from_path_incomplete(ssa, autocomplete, nodeops):
  function test_tree_incomplete (line 90) | def test_tree_incomplete(nodeops):
  function test_reconfigure (line 116) | def test_reconfigure(select, minimize):
  function test_reconfigure_forested (line 171) | def test_reconfigure_forested(parallel, requires):
  function test_reconfigure_with_n_smaller_than_subtree_size (line 198) | def test_reconfigure_with_n_smaller_than_subtree_size():
  function test_slice_and_reconfigure (line 214) | def test_slice_and_reconfigure(forested, parallel, requires):
  function test_plot (line 238) | def test_plot():
  function test_plot_alt (line 258) | def test_plot_alt():
  function test_compressed_rank (line 271) | def test_compressed_rank(optimize):
  function test_print_contractions (line 283) | def test_print_contractions(seed):
  function test_remove_ind (line 287) | def test_remove_ind():
  function test_restore_ind (line 339) | def test_restore_ind(ind):
  function test_unslice_rand (line 353) | def test_unslice_rand():
  function test_unslice_all (line 367) | def test_unslice_all():
  function test_reslice_and_reconfigure (line 378) | def test_reslice_and_reconfigure():
  function test_tree_with_one_node (line 389) | def test_tree_with_one_node():
  function test_slice_and_restore_preprocessed_inds (line 400) | def test_slice_and_restore_preprocessed_inds(seed, nodeops):
  function test_tree_from_edge_path (line 436) | def test_tree_from_edge_path(n, seed, nodeops):
  function test_tree_build_divide_labels (line 456) | def test_tree_build_divide_labels():
  function test_tree_build_agglom_labels (line 466) | def test_tree_build_agglom_labels():
  function test_tree_peak_size_reorder (line 477) | def test_tree_peak_size_reorder(seed):
  function test_contraction_tree_from_ssa_path_complete (line 491) | def test_contraction_tree_from_ssa_path_complete(nodeops):
  function test_ssa_subgraph_tracking (line 513) | def test_ssa_subgraph_tracking():
  function test_ssa_surface_order (line 537) | def test_ssa_surface_order():
  function test_simulated_anneal_tree (line 554) | def test_simulated_anneal_tree():
  function test_simulated_anneal_tree_with_slicing (line 570) | def test_simulated_anneal_tree_with_slicing():
  function test_tree_single_input_nosimp (line 590) | def test_tree_single_input_nosimp(path, slice):
  function test_tree_single_input_simp (line 612) | def test_tree_single_input_simp(path, slice):
  function test_tree_single_input_transpose (line 635) | def test_tree_single_input_transpose(path, slice):