{"id":49616038,"url":"https://github.com/Verified-Intelligence/auto_LiRPA","last_synced_at":"2026-05-21T11:01:12.261Z","repository":{"id":37949628,"uuid":"244249648","full_name":"Verified-Intelligence/auto_LiRPA","owner":"Verified-Intelligence","description":"auto_LiRPA: An Automatic Linear Relaxation based Perturbation Analysis Library for Neural Networks and General Computational Graphs","archived":false,"fork":false,"pushed_at":"2025-03-16T20:30:07.000Z","size":34824,"stargazers_count":325,"open_issues_count":16,"forks_count":93,"subscribers_count":7,"default_branch":"master","last_synced_at":"2025-09-05T01:39:21.886Z","etag":null,"topics":["adversarial-defense","adversarial-examples","adversarial-machine-learning","certified-defense-models","crown-bound","ibp-bounds","robustness","robustness-verification"],"latest_commit_sha":null,"homepage":"https://arxiv.org/pdf/2002.12920","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Verified-Intelligence.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2020-03-02T00:55:45.000Z","updated_at":"2025-08-30T10:56:05.000Z","dependencies_parsed_at":"2023-02-17T01:02:13.065Z","dependency_job_id":"1a79ea0d-c802-4323-89c6-b2085612e286","html_url":"https://github.com/Verified-Intelligence/auto_LiRPA","commit_stats":{"total_commits":19,"total_committers":4,"mean_commits":4.75,"dds":0.5789473684210527,"last_synced_commit":"d2592c13198e0eb536967186758c264604b59539"},"previous_names":["kaidixu/auto_lirpa"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/Verified-Intelligence/auto_LiRPA","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Verified-Intelligence%2Fauto_LiRPA","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Verified-Intelligence%2Fauto_LiRPA/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Verified-Intelligence%2Fauto_LiRPA/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Verified-Intelligence%2Fauto_LiRPA/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Verified-Intelligence","download_url":"https://codeload.github.com/Verified-Intelligence/auto_LiRPA/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Verified-Intelligence%2Fauto_LiRPA/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33298247,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-21T02:57:32.698Z","status":"ssl_error","status_checked_at":"2026-05-21T02:57:31.990Z","response_time":62,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["adversarial-defense","adversarial-examples","adversarial-machine-learning","certified-defense-models","crown-bound","ibp-bounds","robustness","robustness-verification"],"created_at":"2026-05-04T22:00:25.951Z","updated_at":"2026-05-21T11:01:12.255Z","avatar_url":"https://github.com/Verified-Intelligence.png","language":"Python","funding_links":[],"categories":["Formal Verification \u0026 Robustness"],"sub_categories":["Neural Network Verifiers"],"readme":"# auto_LiRPA: Automatic Linear Relaxation based Perturbation Analysis for Neural Networks\n\n[![Documentation Status](https://readthedocs.org/projects/auto-lirpa/badge/?version=latest)](https://auto-lirpa.readthedocs.io/en/latest/?badge=latest)\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](http://PaperCode.cc/AutoLiRPA-Demo)\n[![Video Introduction](https://img.shields.io/badge/play-video-red.svg)](http://PaperCode.cc/AutoLiRPA-Video)\n[![BSD license](https://img.shields.io/badge/License-BSD-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)\n\n\u003cp align=\"center\"\u003e\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Video\"\u003e\u003cimg src=\"http://www.huan-zhang.com/images/upload/lirpa/auto_lirpa_2.png\" width=\"45%\" height=\"45%\" float=\"left\"\u003e\u003c/a\u003e\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Video\"\u003e\u003cimg src=\"http://www.huan-zhang.com/images/upload/lirpa/auto_lirpa_1.png\" width=\"45%\" height=\"45%\" float=\"right\"\u003e\u003c/a\u003e\n\u003c/p\u003e\n\n## What's New?\n- [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) (using `auto_LiRPA` as its core library) is the winner of [VNN-COMP 2025](https://sites.google.com/view/vnn2025) and is **ranked top-1** in all [scored benchmarks](https://github.com/VNN-COMP/vnncomp2025_results/blob/main/SCORING-SMALL-TOL/latex/main.pdf). (08/2025)\n- Bounding of computation graphs containing Jacobian operators now supports more nonlinear operators (e.g., ```tanh```, ```sigmoid```), enabling verification of [continuous-time Lyapunov stability](https://github.com/Verified-Intelligence/Two-Stage_Neural_Controller_Training). (12/2025)\n- [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) (using `auto_LiRPA` as its core library) is the winner of [VNN-COMP 2024](https://sites.google.com/view/vnn2024). Our tool is **ranked top-1** in all benchmarks (including 12 [regular track](https://github.com/ChristopherBrix/vnncomp2024_results/blob/main/SCORING/latex/results_regular_track.pdf) and 9 [extended track](https://github.com/ChristopherBrix/vnncomp2024_results/blob/main/SCORING/latex/results_extended_track.pdf) benchmarks). (08/2024)\n- The [INVPROP algorithm](https://arxiv.org/pdf/2302.01404.pdf) allows to compute overapproximationsw of preimages (the set of inputs of an NN generating a given output set) and tighten bounds using output constraints. (03/2024)\n- Branch-and-bound support for non-ReLU and general nonlinearities ([GenBaB](https://arxiv.org/pdf/2405.21063)) with optimizable bounds (α-CROWN) for new nonlinear functions (sin, cos, GeLU). We achieve significant improvements on verifying neural networks with non-ReLU nonlinearities such as Transformers, LSTM, and [ML4ACOPF](https://github.com/AI4OPT/ml4acopf_benchmark). (09/2023)\n- [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) ([alpha-beta-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git)) (using `auto_LiRPA` as its core library) **won** [VNN-COMP 2023](https://sites.google.com/view/vnn2023). (08/2023)\n- Bound computation for higher-order computational graphs to support bounding Jacobian, Jacobian-vector products, and [local Lipschitz constants](https://arxiv.org/abs/2210.07394). (11/2022)\n- Our neural network verification tool [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) ([alpha-beta-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git)) (using `auto_LiRPA` as its core library) **won** [VNN-COMP 2022](https://sites.google.com/view/vnn2022). Our library supports the large CIFAR100, TinyImageNet and ImageNet models in VNN-COMP 2022. (09/2022)\n- Implementation of **general cutting planes** ([GCP-CROWN](https://arxiv.org/pdf/2208.05740.pdf)), support of more activation functions and improved performance and scalability. (09/2022)\n- Our neural network verification tool [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) ([alpha-beta-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git)) **won** [VNN-COMP 2021](https://sites.google.com/view/vnn2021) **with the highest total score**, outperforming 11 SOTA verifiers. α,β-CROWN uses the `auto_LiRPA` library as its core bound computation library. (09/2021)\n- [Optimized CROWN/LiRPA](https://arxiv.org/pdf/2011.13824.pdf) bound (α-CROWN) for ReLU, **sigmoid**, **tanh**, and **maxpool** activation functions, which can significantly outperform regular CROWN bounds. See [simple_verification.py](examples/vision/simple_verification.py#L59) for an example. (07/31/2021)\n- Handle split constraints for ReLU neurons ([β-CROWN](https://arxiv.org/pdf/2103.06624.pdf)) for complete verifiers. (07/31/2021)\n- A memory efficient GPU implementation of backward (CROWN) bounds for\nconvolutional layers. (10/31/2020)\n- Certified defense models for downscaled ImageNet, TinyImageNet, CIFAR-10, LSTM/Transformer. (08/20/2020)\n- Adding support to **complex vision models** including DenseNet, ResNeXt and WideResNet. (06/30/2020)\n- **Loss fusion**, a technique that reduces training cost of tight LiRPA bounds\n(e.g. CROWN-IBP) to the same asymptotic complexity of IBP, making LiRPA based certified\ndefense scalable to large datasets (e.g., TinyImageNet, downscaled ImageNet). (06/30/2020)\n- **Multi-GPU** support to scale LiRPA based training to large models and datasets. (06/30/2020)\n- Initial release. (02/28/2020)\n\n## Introduction\n\n`auto_LiRPA` is a library for automatically deriving and computing bounds with\nlinear relaxation based perturbation analysis (LiRPA) (e.g.\n[CROWN](https://arxiv.org/pdf/1811.00866.pdf) and\n[DeepPoly](https://files.sri.inf.ethz.ch/website/papers/DeepPoly.pdf)) for\nneural networks, which is a useful tool for formal robustness verification. We\ngeneralize existing LiRPA algorithms for feed-forward neural networks to a\ngraph algorithm on general computational graphs, defined by PyTorch.\nAdditionally, our implementation is also automatically **differentiable**,\nallowing optimizing network parameters to shape the bounds into certain\nspecifications (e.g., certified defense). You can find [a video ▶️ introduction\nhere](http://PaperCode.cc/AutoLiRPA-Video).\n\nOur library supports the following algorithms:\n\n* Backward mode LiRPA bound propagation ([CROWN](https://arxiv.org/pdf/1811.00866.pdf)/[DeepPoly](https://files.sri.inf.ethz.ch/website/papers/DeepPoly.pdf))\n* Backward mode LiRPA bound propagation with optimized bounds ([α-CROWN](https://arxiv.org/pdf/2011.13824.pdf))\n* Backward mode LiRPA bound propagation with split constraints ([β-CROWN](https://arxiv.org/pdf/2103.06624.pdf) for ReLU, and [GenBaB](https://arxiv.org/pdf/2405.21063) for general nonlinear functions)\n* Generalized backward mode LiRPA bound propagation with general cutting plane constraints ([GCP-CROWN](https://arxiv.org/pdf/2208.05740.pdf))\n* Backward mode LiRPA bound propagation with bounds tightened using output constraints ([INVPROP](https://arxiv.org/pdf/2302.01404.pdf))\n* Generalized backward mode LiRPA bound propagation for higher-order computational graphs  ([Shi et al., 2022](https://arxiv.org/abs/2210.07394))\n* Forward mode LiRPA bound propagation ([Xu et al., 2020](https://arxiv.org/pdf/2002.12920))\n* Forward mode LiRPA bound propagation with optimized bounds (similar to [α-CROWN](https://arxiv.org/pdf/2011.13824.pdf))\n* Interval bound propagation ([IBP](https://arxiv.org/pdf/1810.12715.pdf))\n* Hybrid approaches, e.g., Forward+Backward, IBP+Backward ([CROWN-IBP](https://arxiv.org/pdf/1906.06316.pdf)), [α,β-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git) ([alpha-beta-CROWN](https://github.com/Verified-Intelligence/alpha-beta-CROWN.git))\n* MIP/LP formulation of neural networks\n\nOur library allows automatic bound derivation and computation for general\ncomputational graphs, in a similar manner that gradients are obtained in modern\ndeep learning frameworks -- users only define the computation in a forward\npass, and `auto_LiRPA` traverses through the computational graph and derives\nbounds for any nodes on the graph.  With `auto_LiRPA` we free users from\nderiving and implementing LiPRA for most common tasks, and they can simply\napply LiPRA as a tool for their own applications.  This is especially useful\nfor users who are not experts of LiRPA and cannot derive these bounds manually\n(LiRPA is significantly more complicated than backpropagation).\n\n## Technical Background in 1 Minute\n\nDeep learning frameworks such as PyTorch represent neural networks (NN) as\na computational graph, where each mathematical operation is a node and edges\ndefine the flow of computation:\n\n\u003cp align=\"center\"\u003e\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Video\"\u003e\u003cimg src=\"http://www.huan-zhang.com/images/upload/lirpa/auto_LiRPA_background_1.png\" width=\"80%\"\u003e\u003c/a\u003e\n\u003c/p\u003e\n\nNormally, the inputs of a computation graph (which defines a NN) are data and\nmodel weights, and PyTorch goes through the graph and produces model prediction\n(a bunch of numbers):\n\n\u003cp align=\"center\"\u003e\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Video\"\u003e\u003cimg src=\"http://www.huan-zhang.com/images/upload/lirpa/auto_LiRPA_background_2.png\" width=\"80%\"\u003e\u003c/a\u003e\n\u003c/p\u003e\n\nOur `auto_LiRPA` library conducts perturbation analysis on a computational\ngraph, where the input data and model weights are defined within some\nuser-defined ranges.  We get guaranteed output ranges (bounds):\n\n\u003cp align=\"center\"\u003e\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Video\"\u003e\u003cimg src=\"http://www.huan-zhang.com/images/upload/lirpa/auto_LiRPA_background_3.png\" width=\"80%\"\u003e\u003c/a\u003e\n\u003c/p\u003e\n\n## Installation\n\nPython 3.11+ and PyTorch 2.0+ are required.\nIt is highly recommended to have a pre-installed PyTorch\nthat matches your system and our version requirement\n(see [PyTorch Get Started](https://pytorch.org/get-started)).\nThen you can install `auto_LiRPA` via:\n\n```bash\ngit clone https://github.com/Verified-Intelligence/auto_LiRPA\ncd auto_LiRPA\npip install .\n```\n\nIf you intend to modify this library, use `pip install -e .` instead.\n\n## Quick Start\n\nFirst define your computation as a `nn.Module` and wrap it using\n`auto_LiRPA.BoundedModule()`. Then, you can call the `compute_bounds` function\nto obtain certified lower and upper bounds under input perturbations:\n\n```python\nfrom auto_LiRPA import BoundedModule, BoundedTensor, PerturbationLpNorm\n\n# Define computation as a nn.Module.\nclass MyModel(nn.Module):\n    def forward(self, x):\n        # Define your computation here.\n\nmodel = MyModel()\nmy_input = load_a_batch_of_data()\n# Wrap the model with auto_LiRPA.\nmodel = BoundedModule(model, my_input)\n# Define perturbation. Here we add Linf perturbation to input data.\nptb = PerturbationLpNorm(norm=np.inf, eps=0.1)\n# Make the input a BoundedTensor with the pre-defined perturbation.\nmy_input = BoundedTensor(my_input, ptb)\n# Regular forward propagation using BoundedTensor works as usual.\nprediction = model(my_input)\n# Compute LiRPA bounds using the backward mode bound propagation (CROWN).\nlb, ub = model.compute_bounds(x=(my_input,), method=\"backward\")\n```\n\nCheckout\n[examples/vision/simple_verification.py](examples/vision/simple_verification.py)\nfor a complete but very basic example.\n\n\u003ca href=\"http://PaperCode.cc/AutoLiRPA-Demo\"\u003e\u003cimg align=\"left\" width=64 height=64 src=\"https://colab.research.google.com/img/colab_favicon_256px.png\"\u003e\u003c/a\u003e\nWe also provide a [Google Colab Demo](http://PaperCode.cc/AutoLiRPA-Demo) including an example of computing verification\nbounds for a 18-layer ResNet model on CIFAR-10 dataset. Once the ResNet model\nis defined as usual in Pytorch, obtaining provable output bounds is as easy as\nobtaining gradients through autodiff. Bounds are efficiently computed on GPUs.\n\n## More Working Examples\n\nWe provide [a wide range of examples](doc/src/examples.md) of using `auto_LiRPA`:\n\n* [Basic Bound Computation on a Toy Neural Network (simplest example)](examples/simple/toy.py)\n* [Basic Bound Computation with **Robustness Verification** of Neural Networks as an example](doc/src/examples.md#basic-bound-computation-and-robustness-verification-of-neural-networks)\n* [MIP/LP Formulation of Neural Networks](examples/simple/mip_lp_solver.py)\n* [Basic **Certified Adversarial Defense** Training](doc/src/examples.md#basic-certified-adversarial-defense-training)\n* [Large-scale Certified Defense Training on **ImageNet**](doc/src/examples.md#certified-adversarial-defense-on-downscaled-imagenet-and-tinyimagenet-with-loss-fusion)\n* [Certified Adversarial Defense Training on Sequence Data with **LSTM**](doc/src/examples.md#certified-adversarial-defense-training-for-lstm-on-mnist)\n* [Certifiably Robust Language Classifier using **Transformers**](doc/src/examples.md#certifiably-robust-language-classifier-with-transformer-and-lstm)\n* [Certified Robustness against **Model Weight Perturbations**](doc/src/examples.md#certified-robustness-against-model-weight-perturbations-and-certified-defense)\n* [Bounding **Jacobian** and **local Lipschitz constants**](examples/vision/jacobian.py)\n* [Compute an Overapproximate of Neural Network **Preimage**](examples/simple/invprop.py)\n\n`auto_LiRPA` has also been used in the following works:\n* [**α,β-CROWN for complete neural network verification**](https://github.com/Verified-Intelligence/alpha-beta-CROWN)\n* [**Fast certified robust training**](https://github.com/shizhouxing/Fast-Certified-Robust-Training)\n* [**Computing local Lipschitz constants**](https://github.com/shizhouxing/Local-Lipschitz-Constants)\n\n## Full Documentations\n\nFor more documentations, please refer to:\n\n* [Documentation homepage](https://auto-lirpa.readthedocs.io)\n* [API documentation](https://auto-lirpa.readthedocs.io/en/latest/api.html)\n* [Adding custom operators](https://auto-lirpa.readthedocs.io/en/latest/custom_op.html)\n* [Guide](https://auto-lirpa.readthedocs.io/en/latest/paper.html) for reproducing [our NeurIPS 2020 paper](https://arxiv.org/abs/2002.12920)\n\n## Publications\n\nPlease kindly cite our papers if you use the `auto_LiRPA` library. Full [BibTeX entries](doc/src/examples.md#bibtex-entries) can be found [here](doc/src/examples.md#bibtex-entries).\n\nThe general LiRPA based bound propagation algorithm was originally proposed in our paper:\n\n* [Automatic Perturbation Analysis for Scalable Certified Robustness and Beyond](https://arxiv.org/pdf/2002.12920).\nNeurIPS 2020.\nKaidi Xu\\*, Zhouxing Shi\\*, Huan Zhang\\*, Yihan Wang, Kai-Wei Chang, Minlie Huang, Bhavya Kailkhura, Xue Lin, Cho-Jui Hsieh (\\* Equal contribution)\n\nThe `auto_LiRPA` library is further extended to support:\n\n* Optimized bounds (α-CROWN):\n\n  [Fast and Complete: Enabling Complete Neural Network Verification with Rapid and Massively Parallel Incomplete Verifiers](https://arxiv.org/pdf/2011.13824.pdf). ICLR 2021. Kaidi Xu\\*, Huan Zhang\\*, Shiqi Wang, Yihan Wang, Suman Jana, Xue Lin and Cho-Jui Hsieh (\\* Equal contribution).\n\n* Split constraints (β-CROWN):\n\n  [Beta-CROWN: Efficient Bound Propagation with Per-neuron Split Constraints for Complete and Incomplete Neural Network Verification](https://arxiv.org/pdf/2103.06624.pdf). NeurIPS 2021. Shiqi Wang\\*, Huan Zhang\\*, Kaidi Xu\\*, Suman Jana, Xue Lin, Cho-Jui Hsieh and Zico Kolter (\\* Equal contribution).\n\n* General constraints (GCP-CROWN):\n\n  [GCP-CROWN: General Cutting Planes for Bound-Propagation-Based Neural Network Verification](https://arxiv.org/abs/2208.05740). Huan Zhang\\*, Shiqi Wang\\*, Kaidi Xu\\*, Linyi Li, Bo Li, Suman Jana, Cho-Jui Hsieh and Zico Kolter (\\* Equal contribution).\n\n* Higher-order computational graphs (Lipschitz constants and Jacobian):\n\n  [Efficiently Computing Local Lipschitz Constants of Neural Networks via Bound Propagation](https://arxiv.org/abs/2210.07394). NeurIPS 2022. Zhouxing Shi, Yihan Wang, Huan Zhang, Zico Kolter, Cho-Jui Hsieh.\n\n* Branch-and-bound for non-ReLU and general nonlinear functions (GenBaB):\n\n  [Neural Network Verification with Branch-and-Bound for General Nonlinearities](https://arxiv.org/pdf/2405.21063). TACAS 2025. Zhouxing Shi\\*, Qirui Jin\\*, Zico Kolter, Suman Jana, Cho-Jui Hsieh, Huan Zhang (\\* Equal contribution).\n\n* Tightening of bounds and preimage computation using the INVPROP algorithm:\n\n  [Provably Bounding Neural Network Preimages](https://arxiv.org/pdf/2302.01404.pdf). NeurIPS 2023. Suhas Kotha\\*, Christopher Brix\\*, Zico Kolter, Krishnamurthy (Dj) Dvijotham\\*\\*, Huan Zhang\\*\\* (\\* Equal contribution; \\*\\* Equal advising).\n\nCertified training (verification-aware training by optimizing bounds) using `auto_LiRPA` is improved with:\n\n* Much shorter warmup schedule and faster training:\n\n  [Fast Certified Robust Training with Short Warmup](https://arxiv.org/pdf/2103.17268.pdf). NeurIPS 2021. Zhouxing Shi\\*, Yihan Wang\\*, Huan Zhang, Jinfeng Yi and Cho-Jui Hsieh (\\* Equal contribution).\n\n* Training-time branch-and-bound:\n\n  [Certified Training with Branch-and-Bound: A Case Study on Lyapunov-stable Neural Control](https://arxiv.org/abs/2411.18235). Zhouxing Shi, Cho-Jui Hsieh, and Huan Zhang.\n\n\n## Developers and Copyright\n\nTeam leaders:\n* Faculty: Huan Zhang (huan@huan-zhang.com), UIUC\n* Student: Xiangru Zhong (xiangru4@illinois.edu), UIUC\n\nCurrent developers (* indicates members of VNN-COMP 2025 team):\n* \\*Duo Zhou (duozhou2@illinois.edu), UIUC\n* \\*Keyi Shen (keyis2@illinois.edu), UIUC (graduated, now at Georgia Tech)\n* \\*Hesun Chen (hesunc2@illinois.edu), UIUC\n* \\*Haoyu Li (haoyuli5@illinois.edu), UIUC\n* \\*Ruize Gao (ruizeg2@illinois.edu), UIUC\n* \\*Hao Cheng (haoc539@illinois.edu), UIUC\n* Zhouxing Shi (zhouxingshichn@gmail.com), UCLA/UC Riverside\n* Lei Huang (leih5@illinois.edu), UIUC\n* Taobo Liao (taobol2@illinois.edu), UIUC\n* Jorge Chavez (jorgejc2@illinois.edu), UIUC\n\nPast developers:\n* Hongji Xu (hx84@duke.edu), Duke University (intern with Prof. Huan Zhang)\n* Christopher Brix (brix@cs.rwth-aachen.de), RWTH Aachen University\n* Hao Chen (haoc8@illinois.edu), UIUC\n* Keyu Lu (keyulu2@illinois.edu), UIUC\n* Kaidi Xu (kx46@drexel.edu), Drexel University\n* Sanil Chawla (schawla7@illinois.edu), UIUC\n* Linyi Li (linyi2@illinois.edu), UIUC\n* Zhuolin Yang (zhuolin5@illinois.edu), UIUC\n* Zhuowen Yuan (realzhuowen@gmail.com), UIUC\n* Qirui Jin (qiruijin@umich.edu), University of Michigan\n* Shiqi Wang (sw3215@columbia.edu), Columbia University\n* Yihan Wang (yihanwang@ucla.edu), UCLA\n* Jinqi (Kathryn) Chen (jinqic@cs.cmu.edu), CMU\n\n`auto_LiRPA` is currently supported in part by the National Science Foundation (NSF; award 2331967, 2525287), the AI2050 program at Schmidt Science, the Virtual Institute for Scientific Software (VISS) at Georgia Tech, the University Research Program at Toyota Research Institute (TRI), and a Mathworks research award.\n\nWe thank the [commits](https://github.com/Verified-Intelligence/auto_LiRPA/commits) and [pull requests](https://github.com/Verified-Intelligence/auto_LiRPA/pulls) from community contributors.\n\nOur library is released under the BSD 3-Clause license.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FVerified-Intelligence%2Fauto_LiRPA","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FVerified-Intelligence%2Fauto_LiRPA","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FVerified-Intelligence%2Fauto_LiRPA/lists"}