Welcome

Welcome to the user guide for the oat_python package. Open applied topology (OAT) is a library for fast, user-friendly algebra and topology. OAT has

• a user-friendly frontend for Python users, called oat_python

• a fast backend written in Rust, called oat_rust

This page contains the user guide for oat_python.

Caution: breaking changes

OAT is in early stages of develpoment, and it’s evolving quickly. Code that you write today may not work tomorrow, due to these changes. We will do our very best to make sure that if/when this happens, you will only need to make small changes to your code to fix the problem (e.g., updating the name of a function). However, please do bear this in mind as you write your code!

Community

OAT is by and for the open source community. Reach out to the developers if you

• Need help getting started

• Wish for a missing feature

• Want to try coding

A collaboration of 20 research centers at colleges, universities, private, and public organizations support OAT’s development. The founding developers are Princton University, Macalester College, and the University of Delaware The National Science Foundation granted seed funding for OAT in 2019 under the ExHACT project, and Pacific Northwest National Laboratory (PNNL) provides continuing financial support. PNNL now coordinates development. See here for further details.

Values

Our shared values are

• Inclusion

• Respect, and

• A shared passion to expand human knowledge, through algebraic topology

Mission

Performance

OAT is a first-class solver for cutting-edge applications. It is ideally suited to large, sparse data sets. The core library is written in Rust, a low-level systems programming language designed for safety and performance. High-level wrappers are available in Python.

Reliability

OAT has more unit tests than type definitions and function definitions, combined. Its modular design enables end users to write their own checks for correctness, with ease. The library inherits strong safety guarantees from the the Rust compiler.

Transparency

OAT documentation emphasizes clarity and accessibility for users with all backgrounds. It includes more than 180 working examples, and describes both code and underlying mathematical concepts in detail. The Tutorials illustrate how to combine multiple tools into larger applications. The platform’s modular design breaks large solvers into basic components, which it exposes to the user for inspection. In addition, the library provides powerful methods to inspect and analyze objects, consistent with the way humans naturally think about problems; for example, you can look up rows and columns of boundary matrices using cubes, simplices, or cells as keys.

Modularity

OAT reduces complex problems to the same basic building blocks that topologists use when writing on a chalk board. Users can mix and match those blocks with confidence, using a simple, streamlined interface. They can even create new components that work seemlessly with the rest of the library, including coefficient rings, sparse matrix data structures, and customized filtrations on simplicial complexes.

Contributing and understanding the code

For information on contributing including an overview of how the code in this project is organized, see CONTRIBUTING.md.

License

For inforamtion on copyright and licensing, see LICENSE.

Attributions

OAT is an extension of the ExHACT library. See ATTRIBUTIONS.md for details.

Table of Contents

• Install
• API
  • Homology
  • Vietoris Rips
    • BoundaryMatrix
    • BoundaryMatrixDecomposition
    • ChangeOfBasisMatrix
    • ChangeOfBasisMatrixInverse
    • GeneralizedMatchingMatrix
    • LaplacianMatrix
    • SubmatrixIndexTool
    • VectorIndexTool
    • VietorisRipsComplex
    • WeightedSimplex
  • Point clouds
    • annulus()
    • circle()
    • disk()
    • half_dome()
    • sphere_or_slice()
    • sphere_or_slice_spiral()
    • stanford_dragon()
    • torus()
    • torus_curve()
    • two_circles()
  • Hypergraphs
    • BoundaryMatrixDecompositionDowker
    • transpose_listlist()
    • unique_row_indices()
    • unique_rows()
    • zigzag_homology()
    • Additional tools
  • Plotting
    • ball_2d()
    • barcode()
    • blank_background()
    • contains_3d_trace()
    • contrast_initial_and_optimal_cycles_in_3d()
    • display_dataframes_side_by_side()
    • fig_3d_for_simplices()
    • is_dark_color()
    • mesh_rectangle()
    • persistence_diagram()
    • persistence_diagram_guidelines()
    • set_background_color()
    • surface_cube()
    • surface_octahedron()
    • surface_rectangle()
    • surface_sphere()
    • trace_2d_for_edge()
    • trace_2d_for_edges()
    • trace_2d_for_triangle()
    • trace_2d_for_triangles()
    • trace_2d_for_vertices()
    • trace_3d_for_edge()
    • trace_3d_for_edges()
    • trace_3d_for_triangles()
    • trace_3d_for_vertices()
    • vertex_embedding_for_networkx_graph()
    • vertex_embedding_for_simplices()
    • wire_rectangle()
    • wire_sphere_3d()
  • Simplices
    • dimension_m_faces_as_rows_for_dimension_n_simplices_as_rows()
    • dimension_m_faces_for_simplices()
    • networkx_graph_for_simplices()
    • vertices_incident_to_simplices()
  • Matrices
    • assert_almost_equal_csr()
    • assert_symmetric_triplets_csr()
    • is_structurally_zero()
    • minmax()
    • test_minmax()
    • test_validate_square_and_symmetric_matrix()
    • triplets_for_csr()
    • validate_square_and_symmetric_matrix()
  • Dissimilarity
    • distance_iterator()
    • enclosing_radius_for_cloud_slow()
    • enclosing_radius_for_matrix()
    • enclosing_radius_for_points()
    • euclidean_distance()
    • euclidean_distance_one_sided()
    • farthest_point_sampling()
    • hop_distance_for_networkx_graph()
    • hop_distance_for_simpices()
    • sparse_matrix_for_cloud_slow()
    • sparse_matrix_for_csr()
    • sparse_matrix_for_dense()
    • sparse_matrix_for_points()
    • test_dissimilarity_matrix()
    • test_validate_dissimilarity_matrix()
    • validate_dissimilarity_matrix()
  • Barcodes
    • max_finite_value()
  • Core
• Glossary
  • Matrices
  • Graphs and simplicial complexes
  • Filtrations
  • Dissimilarity
• Tutorials
  • Dowker complexes and Hypergraphs
  • Plotting
  • Point cloud generators
  • Vietoris Rips complexes
• FAQ
  • Cite
  • Developers
  • Contribute
  • History
  • Contact