diff options
Diffstat (limited to 'math')
110 files changed, 5753 insertions, 729 deletions
diff --git a/math/R-cran-combinat/pkg-descr b/math/R-cran-combinat/pkg-descr index e27b37a777d3..322223dcabdd 100644 --- a/math/R-cran-combinat/pkg-descr +++ b/math/R-cran-combinat/pkg-descr @@ -1 +1,17 @@ -Routines for combinatorics. +The R-cran-combinat package provides a collection of essential routines +for combinatorial mathematics within the R environment. Combinatorics is +a branch of mathematics concerning the study of finite or countable +discrete structures. + +This package offers functions to generate and manipulate various combinatorial +objects, including permutations, combinations, and partitions. It is +invaluable for researchers, statisticians, and data scientists who need +to perform tasks such as: + +- Generating all possible orderings of a set of items. +- Selecting subsets of items without regard to their order. +- Enumerating ways to divide a set into non-empty subsets. + +By providing these fundamental combinatorial tools, R-cran-combinat +facilitates a wide range of applications in probability, statistics, +computer science, and experimental design. diff --git a/math/R-cran-conf.design/pkg-descr b/math/R-cran-conf.design/pkg-descr index 73da04d8c40a..de393137be7b 100644 --- a/math/R-cran-conf.design/pkg-descr +++ b/math/R-cran-conf.design/pkg-descr @@ -1,2 +1,24 @@ -This small library contains a series of simple tools for constructing and -manipulating confounded and fractional factorial designs. +The R-cran-conf.design package provides a specialized set of tools +within the R environment for the construction and manipulation of +confounded and fractional factorial designs. These experimental designs +are fundamental in statistics and engineering for efficiently studying +the effects of multiple factors on an outcome, especially when resources +are limited. + +Confounded designs allow for the study of a large number of factors +with a smaller number of experimental runs by strategically sacrificing +information about higher-order interactions. Fractional factorial designs +are a type of confounded design that uses a fraction of the full factorial +experiment, making them highly efficient for screening important factors. + +This library simplifies the process of setting up and analyzing such +designs, making it invaluable for: + +- Experiment design in industrial and scientific research. +- Quality improvement and process optimization. +- Situations where a full factorial experiment is impractical due to + cost or time constraints. + +By offering these simple yet powerful tools, R-cran-conf.design enables +researchers and practitioners to conduct more efficient and insightful +experiments. diff --git a/math/R-cran-cvar/pkg-descr b/math/R-cran-cvar/pkg-descr index ca1bec8d7a68..efad457a0534 100644 --- a/math/R-cran-cvar/pkg-descr +++ b/math/R-cran-cvar/pkg-descr @@ -1,7 +1,23 @@ -Compute expected shortfall (ES) and Value at Risk (VaR) from a quantile -function, distribution function, random number generator or probability density -function. ES is also known as Conditional Value at Risk (CVaR). Virtually any -continuous distribution can be specified. The functions are vectorized over the -arguments. The computations are done directly from the definitions, see e.g. -Acerbi and Tasche (2002) <doi:10.1111/1468-0300.00091>. Some support for GARCH -models is provided, as well. +The R-cran-cvar package provides essential tools for risk management, +enabling the computation of Expected Shortfall (ES) and Value at Risk (VaR). +ES, also known as Conditional Value at Risk (CVaR), and VaR are key metrics +used to quantify potential financial losses in portfolios or investments. + +This package offers high flexibility, allowing users to compute these +risk measures from various input types, including: + +- Quantile functions +- Distribution functions +- Random number generators +- Probability density functions + +It supports virtually any continuous distribution, making it adaptable +to diverse financial models. The functions are vectorized for efficient +computation across multiple arguments. The calculations are performed +directly from their definitions, as detailed by Acerbi and Tasche (2002). +Additionally, the package includes some support for GARCH (Generalized +Autoregressive Conditional Heteroskedasticity) models, further enhancing +its utility for analyzing financial time series volatility. + +R-cran-cvar is an invaluable resource for financial analysts, risk managers, +and quantitative researchers working with R to assess and manage financial risk. diff --git a/math/R-cran-forcats/Makefile b/math/R-cran-forcats/Makefile index 3cb52739dad4..ffb9a07bcd34 100644 --- a/math/R-cran-forcats/Makefile +++ b/math/R-cran-forcats/Makefile @@ -1,6 +1,5 @@ PORTNAME= forcats -DISTVERSION= 1.0.0 -PORTREVISION= 2 +DISTVERSION= 1.0.1 CATEGORIES= math DISTNAME= ${PORTNAME}_${DISTVERSION} diff --git a/math/R-cran-forcats/distinfo b/math/R-cran-forcats/distinfo index c251c633b30e..c37196557911 100644 --- a/math/R-cran-forcats/distinfo +++ b/math/R-cran-forcats/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1675153338 -SHA256 (forcats_1.0.0.tar.gz) = c5bb157909d92e1e1a427c0dc5cb358ea00a43a14918a9088fa4f6630962254e -SIZE (forcats_1.0.0.tar.gz) = 294183 +TIMESTAMP = 1758869742 +SHA256 (forcats_1.0.1.tar.gz) = 1de46b83b7038a293e612775197b7ffe47bd079cd2385aa7c65e98171bbd3605 +SIZE (forcats_1.0.1.tar.gz) = 294628 diff --git a/math/R-cran-fracdiff/pkg-descr b/math/R-cran-fracdiff/pkg-descr index 2058c9e95b8e..229027fb8b72 100644 --- a/math/R-cran-fracdiff/pkg-descr +++ b/math/R-cran-fracdiff/pkg-descr @@ -1,3 +1,20 @@ -Maximum likelihood estimation of the parameters of a fractionally -differenced ARIMA(p,d,q) model (Haslett and Raftery, Appl.Statistics, -1989). +The R-cran-fracdiff package provides robust functionality for the +maximum likelihood estimation of parameters in fractionally differenced +ARIMA(p,d,q) models. These models are a powerful extension of traditional +ARIMA models, designed to capture long-range dependence in time series data, +where the 'd' parameter (differencing order) can be a non-integer value. + +Fractionally differenced ARIMA models are particularly useful for +analyzing phenomena that exhibit persistent memory effects, such as: + +- Financial time series (e.g., stock prices, volatility) +- Hydrological data (e.g., river flows, rainfall) +- Environmental data (e.g., temperature anomalies) +- Long-memory processes in various scientific and engineering fields + +Based on the methodology by Haslett and Raftery (Applied Statistics, 1989), +this package offers a reliable and statistically sound approach to +modeling time series with fractional integration. It enables researchers +and practitioners in R to accurately estimate the parameters of these +complex models, leading to more precise forecasts and a deeper understanding +of long-memory processes. diff --git a/math/R-cran-gbutils/pkg-descr b/math/R-cran-gbutils/pkg-descr index 8182290d8372..6d016a6ddf25 100644 --- a/math/R-cran-gbutils/pkg-descr +++ b/math/R-cran-gbutils/pkg-descr @@ -1,8 +1,17 @@ -Plot density and distribution functions with automatic selection of suitable -regions. Numerically invert (compute quantiles) distribution functions. -Simulate real and complex numbers from distributions of their magnitude and -arguments. Optionally, the magnitudes and/or arguments may be fixed in almost -arbitrary ways. Create polynomials from roots given in Cartesian or polar form. -Small programming utilities: check if an object is identical to NA, count -positional arguments in a call, set intersection of more than two sets, check -if an argument is unnamed, compute the graph of S4 classes in packages. +The R-cran-gbutils package offers general-purpose utilities for numerical +and statistical computations in R, enhancing flexibility and ease of use. + +Key functionalities include: + +- **Distribution Analysis**: Plotting density/distribution functions, + numerically inverting distributions for quantiles, and simulating + real/complex numbers from magnitude/argument distributions. +- **Polynomial Manipulation**: Creating polynomials from roots + (Cartesian or polar form). +- **Programming Utilities**: Checking for NA identity, counting + positional arguments, computing set intersections for multiple sets, + identifying unnamed arguments, and graphing S4 classes. + +This invaluable toolkit streamlines common tasks in data analysis, +statistical modeling, and numerical programming, boosting productivity +and analytical capabilities for R users. diff --git a/math/R-cran-magic/pkg-descr b/math/R-cran-magic/pkg-descr index 500c3c8314bf..973187f4cb25 100644 --- a/math/R-cran-magic/pkg-descr +++ b/math/R-cran-magic/pkg-descr @@ -1,11 +1,19 @@ -A collection of efficient, vectorized algorithms for the creation -and investigation of magic squares and hypercubes, including a -variety of functions for the manipulation and analysis of arbitrarily -dimensioned arrays. The package includes methods for creating normal -magic squares of any order greater than 2. The ultimate intention -is for the package to be a computerized embodiment all magic square -knowledge, including direct numerical verification of properties -of magic squares (such as recent results on the determinant of -odd-ordered semimagic squares). Some antimagic functionality is -included. The package also serves as a rebuttal to the often-heard -comment "I thought R was just for statistics". +The R-cran-magic package provides efficient, vectorized algorithms for +creating and investigating magic squares and hypercubes. It includes +functions for manipulating and analyzing multi-dimensional arrays. + +Key features: + +- **Magic Square Creation**: Methods for generating normal magic + squares of any order greater than 2. +- **Analysis Tools**: Functions for the manipulation and analysis of + arbitrarily dimensioned arrays, including numerical verification + of magic square properties (e.g., determinant of odd-ordered + semimagic squares). +- **Antimagic Functionality**: Support for antimagic squares and + related concepts. + +The package aims to be a comprehensive computerized embodiment of magic +square knowledge, offering direct numerical verification of their +properties. It is a valuable resource for mathematicians, statisticians, +and R users interested in combinatorial designs and recreational mathematics. diff --git a/math/R-cran-nortest/pkg-descr b/math/R-cran-nortest/pkg-descr index c6ea3f75138a..9931aa8c41fa 100644 --- a/math/R-cran-nortest/pkg-descr +++ b/math/R-cran-nortest/pkg-descr @@ -1 +1,17 @@ -Five omnibus tests for testing the composite hypothesis of normality. +The R-cran-nortest package provides a suite of five omnibus tests +for assessing the composite hypothesis of normality in statistical data. +Normality tests are crucial in statistics to determine if a data set +is well-modeled by a normal distribution, which is a common assumption +for many parametric statistical methods. + +This package includes implementations of the following widely used tests: +- Anderson-Darling test +- Cramer-von Mises test +- Shapiro-Francia test +- Lilliefors test (Kolmogorov-Smirnov test with estimated parameters) +- Pearson chi-square test + +These tests are valuable tools for statisticians, researchers, and data +analysts working with R, enabling them to rigorously evaluate the +distributional assumptions of their data before applying further +statistical procedures. diff --git a/math/R-cran-quadprog/pkg-descr b/math/R-cran-quadprog/pkg-descr index 95c41d16dc00..c4a3622d3ad8 100644 --- a/math/R-cran-quadprog/pkg-descr +++ b/math/R-cran-quadprog/pkg-descr @@ -1,3 +1,18 @@ -This routine implements the dual method of Goldfarb and Idnani -(1982, 1983) for solving quadratic programming problems of the form -min(?dT b + 1/2bT Db) with the constraints AT b >= b0. +The R-cran-quadprog package provides an efficient and reliable implementation +of the dual method by Goldfarb and Idnani (1982, 1983) for solving +quadratic programming problems. + +Quadratic programming is a type of mathematical optimization problem that +involves minimizing a quadratic objective function subject to linear +constraints. This package is particularly useful for tasks such as +portfolio optimization, support vector machines, and other statistical +modeling applications where such optimization is required. + +Specifically, it solves problems of the form: +minimize -d'b + 1/2 b'Db +subject to A'b >= b0 + +where 'b' is the vector of variables to be optimized, 'd' is a vector, +'D' is a symmetric positive-definite matrix, 'A' is a matrix, and 'b0' +is a vector. The routine ensures accurate and robust solutions for +these types of constrained optimization problems within the R environment. diff --git a/math/R-cran-qualityTools/pkg-descr b/math/R-cran-qualityTools/pkg-descr index a5da45e35c2e..22f262d64ea9 100644 --- a/math/R-cran-qualityTools/pkg-descr +++ b/math/R-cran-qualityTools/pkg-descr @@ -1,10 +1,21 @@ -qualityTools: Statistical Methods for Quality Science +The R-cran-qualityTools package provides a comprehensive suite of +statistical methods essential for Quality Science and Six Sigma +Quality Management, particularly supporting the Define, Measure, +Analyze, Improve, and Control (DMAIC) cycle. -Contains methods associated with the Define, Measure, Analyze, Improve and -Control (i.e. DMAIC) cycle of the Six Sigma Quality Management -methodology.It covers distribution fitting, normal and non-normal process -capability indices, techniques for Measurement Systems Analysis especially -gage capability indices and Gage Repeatability (i.e Gage RR) and -Reproducibility studies, factorial and fractional factorial designs as -well as response surface methods including the use of desirability -functions. +Key functionalities include: + +- **Distribution Fitting**: Tools for fitting various statistical + distributions to data. +- **Process Capability Analysis**: Calculation of normal and non-normal + process capability indices. +- **Measurement Systems Analysis (MSA)**: Techniques such as gauge + capability indices and Gauge Repeatability and Reproducibility (GR&R) + studies. +- **Experimental Design**: Support for factorial and fractional + factorial designs. +- **Response Surface Methods**: Including the use of desirability functions. + +This package is an invaluable resource for quality engineers, statisticians, +and practitioners implementing Six Sigma methodologies, enabling robust +analysis and improvement of processes. diff --git a/math/R-cran-terra/Makefile b/math/R-cran-terra/Makefile index 6cf421ca8011..fe55a87518d5 100644 --- a/math/R-cran-terra/Makefile +++ b/math/R-cran-terra/Makefile @@ -1,5 +1,5 @@ PORTNAME= terra -DISTVERSION= 1.8-60 +DISTVERSION= 1.8-70 CATEGORIES= math DISTNAME= ${PORTNAME}_${DISTVERSION} diff --git a/math/R-cran-terra/distinfo b/math/R-cran-terra/distinfo index a2ff24f11e8e..b626e7f15391 100644 --- a/math/R-cran-terra/distinfo +++ b/math/R-cran-terra/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1753717458 -SHA256 (terra_1.8-60.tar.gz) = de8ea8bb116b668146dba8668209864f992117a8e2b7e3b109502f545bce8c23 -SIZE (terra_1.8-60.tar.gz) = 1046067 +TIMESTAMP = 1759055123 +SHA256 (terra_1.8-70.tar.gz) = 94e163d237d021727aeeeea7303a6845268db4e8910e65738350ceae9f979903 +SIZE (terra_1.8-70.tar.gz) = 1049207 diff --git a/math/algae/pkg-descr b/math/algae/pkg-descr index ddbd3871533e..153feada2264 100644 --- a/math/algae/pkg-descr +++ b/math/algae/pkg-descr @@ -1,4 +1,19 @@ -Algae is a programming language for numerical analysis. It was written in -the Boeing Company to fulfill their need for a fast and versatile tool, -capable of handling large systems. Algae has been applied to interesting -problems in aerospace and related fields for more than a decade. +Algae is a specialized programming language meticulously designed for +numerical analysis, particularly adept at tackling complex and large-scale +computational problems. Developed by the Boeing Company, Algae was +created to meet the demanding requirements of a fast, versatile, and +robust tool for advanced engineering and scientific applications. + +Its core strengths lie in efficiently handling numerical computations +involving large systems, making it suitable for: + +- Solving differential equations +- Performing matrix operations +- Implementing optimization algorithms +- Simulating complex physical phenomena + +With a proven track record of over a decade in aerospace and related +fields, Algae continues to be a valuable asset for researchers and +engineers who require a powerful and reliable language for high-performance +numerical analysis. Its design emphasizes both speed and the ability +to manage extensive datasets and intricate models. diff --git a/math/apc/pkg-descr b/math/apc/pkg-descr index 7d46f00f722e..f5785f99e19e 100644 --- a/math/apc/pkg-descr +++ b/math/apc/pkg-descr @@ -1,17 +1,20 @@ - the Auto Payment Calculator V1.0 Release - Copyright (C) 1997 Eric A. Griff +APC (Auto Payment Calculator) is a simple, Xforms-based graphical +application designed for the X Window System. It provides a user-friendly +interface for calculating auto loan payments. -Auto Payment Calculator is a simple, xforms based, application for -use under the X-windows system, that calculates auto loan payments. +Users can easily input the principal amount, loan term (in months), +and interest rate. Upon calculation, it displays the monthly payment, +as well as the number of weeks and the corresponding weekly payment. -It is pretty straight forward. You enter the Principal (Amount), -Term (in months), and Rate, and then with either [RETURN] -(or [enter] or whatever your keyboard equivelent is), (ALT-C), or -clicking the calculate button; you will have the payment in months, -as well as number of weeks, and weekly payment. +Key features include: -You may also [TAB] through the Amount, Term, and Rate, as well as -hold down ALT and press the character in its Name that is underlined -to go do that function. As long as all three are filled in, you may -hit [ENTER] to Calculate right there. This makes it easy to cycle -quickly through numerous terms, amounts, and rates. +- **Intuitive Interface**: Built with Xforms for a straightforward + graphical user experience. +- **Loan Calculation**: Quickly determines monthly and weekly payments + based on user-provided loan details. +- **Interactive Input**: Supports keyboard navigation (e.g., Tab, Enter) + and mouse interaction for efficient data entry. + +APC is a practical utility for individuals needing to quickly estimate +car loan payments, offering a clear and concise solution within the +X Window environment. diff --git a/math/aribas/pkg-descr b/math/aribas/pkg-descr index 165f8177d398..31ea2becfaf4 100644 --- a/math/aribas/pkg-descr +++ b/math/aribas/pkg-descr @@ -1,6 +1,22 @@ -ARIBAS is an interactive interpreter for big integer arithmetic and -multi-precision floating point arithmetic with a Pascal/Modula like -syntax. It has several builtin functions for algorithmic number -theory like gcd, Jacobi symbol, Rabin probabilistic prime test, -continued fraction and quadratic sieve factorization, Pollard rho -factorization, etc. +ARIBAS is an interactive interpreter designed for advanced arithmetic, +offering robust support for both big integer and multi-precision +floating-point calculations. Its Pascal/Modula-like syntax provides +a familiar and structured environment for users to perform complex +mathematical operations. + +This powerful tool comes equipped with a rich set of built-in functions +specifically tailored for algorithmic number theory, including: + +- **Number Theoretic Functions**: Greatest Common Divisor (GCD), + Jacobi symbol, and continued fraction expansions. +- **Primality Testing**: Rabin probabilistic prime test for efficient + identification of prime numbers. +- **Integer Factorization Algorithms**: + - Quadratic sieve factorization for general integers. + - Pollard's rho factorization for finding smaller prime factors. + +ARIBAS is an invaluable resource for mathematicians, computer scientists, +and cryptographers who require precise and efficient tools for number +theoretic research, cryptographic analysis, and other applications +involving large numbers and complex arithmetic. Its interactive nature +makes it ideal for experimentation and exploration of numerical properties. diff --git a/math/arpack++/pkg-descr b/math/arpack++/pkg-descr index be857c4234e9..2e84fa9b3d96 100644 --- a/math/arpack++/pkg-descr +++ b/math/arpack++/pkg-descr @@ -1,4 +1,18 @@ -ARPACK++ is a collection of classes that offers c++ programmers an interface -to ARPACK. It preserves the full capability, performance, accuracy and low -memory requirements of the FORTRAN package, but takes advantage of the C++ -object-oriented programming environment. +ARPACK++ provides an object-oriented C++ interface to ARPACK (ARnoldi +PACKage), a widely used Fortran library for solving large-scale +eigenvalue problems. This wrapper allows C++ developers to leverage +ARPACK's power within a modern programming paradigm. + +ARPACK is known for efficiently computing a few eigenvalues and +eigenvectors of large, sparse matrices, making it vital in quantum +mechanics, structural engineering, and data analysis. ARPACK++ retains +the original Fortran package's strengths: + +- **Full Capability**: Access to all ARPACK functionalities for + various eigenvalue problems. +- **High Performance**: Maintains computational speed and efficiency. +- **Exceptional Accuracy**: Delivers precise numerical results. +- **Low Memory Requirements**: Optimized for large matrices. + +By integrating ARPACK's robust numerical algorithms with C++ flexibility, +ARPACK++ offers a powerful solution for complex eigenvalue computations. diff --git a/math/atlas/pkg-descr b/math/atlas/pkg-descr index 6e7e6aed22a0..c07eeac58026 100644 --- a/math/atlas/pkg-descr +++ b/math/atlas/pkg-descr @@ -1,18 +1,21 @@ -The ATLAS (Automatically Tuned Linear Algebra Software) project is an ongoing -research effort focusing on applying empirical techniques in order to provide -portable performance. At present, it provides C and Fortran77 interfaces to -a portable, efficient BLAS implementation, as well as enhanced versions of a -few routines from LAPACK. To link with ATLAS shared libraries: +ATLAS (Automatically Tuned Linear Algebra Software) is a high-performance +software library for numerical linear algebra. It focuses on applying +empirical optimization techniques to deliver portable and efficient +performance across diverse hardware architectures. -Serial (thread-safe) Fortran77 BLAS: - -lf77blas -Multi-threaded Fortran77 BLAS: - -lptf77blas -Serial (thread-safe) C BLAS: - -lcblas -Multi-threaded C BLAS: - -lptcblas -ATLAS-enhanced LAPACK, serial (thread-safe) interface: - -lalapack -lf77blas -lcblas -ATLAS-enhanced LAPACK, multi-threaded interface: - -lalapack -lptf77blas -lptcblas +ATLAS provides optimized implementations of: + +- **BLAS (Basic Linear Algebra Subprograms)**: Offers C and Fortran77 + interfaces for Level 1, 2, and 3 BLAS routines, crucial for vector, + matrix-vector, and matrix-matrix operations. Both serial (thread-safe) + and multi-threaded versions are available. +- **LAPACK (Linear Algebra Package)**: Includes enhanced versions of + key LAPACK routines, providing efficient solutions for problems + like solving systems of linear equations, eigenvalue problems, and + singular value decomposition. + +The project's core strength lies in its ability to automatically tune +itself to the specific characteristics of the underlying hardware during +installation, ensuring optimal performance. ATLAS is an invaluable +resource for scientific computing, engineering simulations, and any +application requiring fast and reliable linear algebra computations. diff --git a/math/blacs/pkg-descr b/math/blacs/pkg-descr index 23b4f5cf0aa5..ee27799d8874 100644 --- a/math/blacs/pkg-descr +++ b/math/blacs/pkg-descr @@ -1,5 +1,23 @@ -The BLACS (Basic Linear Algebra Communication Subprograms) -project is an ongoing investigation whose purpose is to create -a linear algebra oriented message passing interface -that may be implemented efficiently and uniformly across -a large range of distributed memory platforms. +The BLACS (Basic Linear Algebra Communication Subprograms) library is a +fundamental component for high-performance parallel computing, specifically +designed to facilitate linear algebra operations on distributed memory +platforms. It provides a standardized and efficient message passing +interface tailored for numerical linear algebra algorithms. + +BLACS enables the communication and synchronization of data between +processors in a parallel computing environment, which is crucial for +implementing scalable versions of dense linear algebra routines. This +makes it an essential building block for: + +- **Distributed Linear Algebra Libraries**: Such as ScaLAPACK, which + relies on BLACS for inter-processor communication. +- **Scientific Simulations**: Large-scale computations in physics, + engineering, and other fields that require solving complex linear + systems or eigenvalue problems across multiple nodes. +- **High-Performance Computing (HPC)**: Optimizing numerical workloads + on clusters and supercomputers. + +By offering a uniform and efficient communication layer, BLACS allows +developers to write portable and high-performing parallel linear algebra +code, ensuring that numerical applications can effectively utilize the +power of distributed memory architectures. diff --git a/math/blocksolve95/pkg-descr b/math/blocksolve95/pkg-descr index 522f5f3c5f41..6b4bed580e5d 100644 --- a/math/blocksolve95/pkg-descr +++ b/math/blocksolve95/pkg-descr @@ -1,13 +1,15 @@ -BlockSolve95 is a scalable parallel software library primarily intended for the -solution of sparse linear systems that arise from physical models, especially -problems involving multiple degrees of freedom at each node. For example, when -the finite element method is used to solve practical problems in structural -engineering, each node typically has two to five degrees of freedom; -BlockSolve95 is designed to take advantage of problems with this type of local -structure. BlockSolve95 is also reasonably efficient for problems that have -only one degree of freedom associated with each node, such as the three- -dimensional Poisson problem. +BlockSolve95 is a scalable parallel software library designed for the +efficient solution of large, sparse linear systems. It is particularly +optimized for problems arising from physical models, especially those +with multiple degrees of freedom at each node (e.g., finite element +methods in structural engineering). -BlockSolve95 is general purpose; we do not require that the matrices have any -particular structure other than being sparse and being symmetric in structure -(but not necessarily in value). +The library effectively handles problems with this local structure, +while also remaining reasonably efficient for systems with a single +degree of freedom per node (e.g., three-dimensional Poisson problems). + +BlockSolve95 is a general-purpose solver, requiring only that matrices +are sparse and symmetric in structure (though not necessarily in value). +It provides a robust solution for complex scientific and engineering +simulations that demand high-performance parallel computation for +large sparse linear systems. diff --git a/math/brial/pkg-descr b/math/brial/pkg-descr index bc7e9d80a98b..4b7d2deb9b3a 100644 --- a/math/brial/pkg-descr +++ b/math/brial/pkg-descr @@ -1,11 +1,22 @@ -BRiAl is the successor to PolyBoRi. +BRiAl (Boolean Rings and Algebra) is a powerful C++ library for +computations with polynomials over Boolean rings, serving as the +successor to PolyBoRi. It provides high-level data types and efficient +algorithms for symbolic computation in this specialized algebraic domain. -The core of PolyBoRi is a C++ library, which provides high-level data -types for Boolean polynomials and monomials, exponent vectors, as well -as for the underlying polynomial rings and subsets of the powerset of -the Boolean variables. As a unique approach, binary decision diagrams -are used as internal storage type for polynomial structures. On top of -this C++-library we provide a Python interface. This allows parsing of -complex polynomial systems, as well as sophisticated and extendable -strategies for Groebner base computation. PolyBoRi features a powerful -reference implementation for Groebner basis computation. +Key features include: + +- **High-level Data Types**: For Boolean polynomials, monomials, + exponent vectors, and related algebraic structures. +- **Binary Decision Diagrams (BDDs)**: Utilizes BDDs as the internal + storage type for polynomial structures, enabling efficient + representation and manipulation. +- **Python Interface**: Offers a convenient Python binding, allowing + for parsing complex polynomial systems and implementing sophisticated + strategies for Grobner basis computation. +- **Grobner Basis Computation**: Provides a robust and powerful + reference implementation for Grobner basis algorithms, essential + for solving systems of polynomial equations. + +BRiAl is an invaluable tool for researchers and developers in areas +such as cryptography, coding theory, formal verification, and computer +algebra, where efficient manipulation of Boolean polynomials is critical. diff --git a/math/cadical/Makefile b/math/cadical/Makefile index 67a944066d57..01262dfc3416 100644 --- a/math/cadical/Makefile +++ b/math/cadical/Makefile @@ -5,7 +5,8 @@ CATEGORIES= math devel MAINTAINER= yuri@FreeBSD.org COMMENT= Simple CDCL satisfiability solver -WWW= http://fmv.jku.at/cadical/ +WWW= https://fmv.jku.at/cadical/ \ + https://github.com/arminbiere/cadical LICENSE= MIT LICENSE_FILE= ${WRKSRC}/LICENSE diff --git a/math/clblas/pkg-descr b/math/clblas/pkg-descr index a63d390014d0..6b9073ad0249 100644 --- a/math/clblas/pkg-descr +++ b/math/clblas/pkg-descr @@ -1,11 +1,21 @@ -clBLAS +clBLAS is a high-performance software library that provides optimized +BLAS (Basic Linear Algebra Subprograms) functions implemented in OpenCL. +BLAS routines are fundamental building blocks for numerical linear algebra, +widely used in scientific computing, engineering, and data analysis. -a software library containing BLAS functions written in OpenCL +The primary goal of clBLAS is to empower developers to leverage the +performance and power efficiency of heterogeneous computing environments. +It achieves this by: -The primary goal of clBLAS is to make it easier for developers to utilize the -inherent performance and power efficiency benefits of heterogeneous computing. -clBLAS interfaces do not hide nor wrap OpenCL interfaces, but rather leaves -OpenCL state management to the control of the user to allow for maximum -performance and flexibility. The clBLAS library does generate and enqueue -optimized OpenCL kernels, relieving the user from the task of writing, -optimizing and maintaining kernel code themselves. +- **OpenCL Integration**: Directly utilizes OpenCL interfaces, allowing + users full control over OpenCL state management for maximum + performance and flexibility. +- **Optimized Kernel Generation**: Automatically generates and enqueues + optimized OpenCL kernels, freeing users from the complex task of + writing, optimizing, and maintaining kernel code. + +clBLAS is an invaluable resource for developers and researchers who need +to accelerate their linear algebra workloads by harnessing the parallel +processing capabilities of GPUs and other OpenCL-compatible devices. +It streamlines the development of high-performance computing applications +by providing a robust and efficient foundation for numerical operations. diff --git a/math/clblast/pkg-descr b/math/clblast/pkg-descr index cf3cfb06b914..c3c31015723b 100644 --- a/math/clblast/pkg-descr +++ b/math/clblast/pkg-descr @@ -1,2 +1,22 @@ -Modern, lightweight, performant and tunable OpenCL BLAS library. Tuned for -Intel, AMD, and NVIDIA accelerators. +CLBlast is a cutting-edge, lightweight, and highly performant OpenCL +BLAS (Basic Linear Algebra Subprograms) library. It provides efficient +and accelerated linear algebra computations on OpenCL-compatible devices. + +BLAS routines are fundamental building blocks for numerical algorithms +in scientific computing, machine learning, and data analysis. CLBlast +leverages OpenCL to offload these tasks to GPUs and other accelerators, +significantly speeding up applications. + +Key features and benefits: + +- **Modern Design**: Built with contemporary OpenCL practices for + optimal performance. +- **Lightweight Footprint**: Minimizes overhead for diverse systems. +- **High Performance**: Achieves superior execution speeds through + careful optimization. +- **Tunable**: Allows fine-grained control to extract maximum + performance from specific hardware (Intel, AMD, NVIDIA accelerators). + +CLBlast is an invaluable resource for developers and researchers seeking +to accelerate numerical workloads by harnessing parallel processing +capabilities of modern hardware through OpenCL. diff --git a/math/clfft/pkg-descr b/math/clfft/pkg-descr index 321354154a5f..4c745e85430d 100644 --- a/math/clfft/pkg-descr +++ b/math/clfft/pkg-descr @@ -1,7 +1,24 @@ -clFFT +clFFT is a high-performance software library providing optimized Fast +Fourier Transform (FFT) functions implemented in OpenCL. The FFT is a +fundamental algorithm in digital signal processing and numerical analysis, +used for tasks such as spectral analysis, image processing, and solving +partial differential equations. -a software library containing FFT functions written in OpenCL +Leveraging the OpenCL framework, clFFT enables efficient computation +of FFTs on a wide range of parallel processing devices. Its key features +include: -clFFT is a software library containing FFT functions written in OpenCL. In -addition to GPU devices, the libraries also support running on CPU devices to -facilitate debugging and heterogeneous programming. +- **GPU Acceleration**: Primarily designed to harness the power of + Graphics Processing Units (GPUs) for significant speedups in FFT + computations. +- **CPU Support**: Also supports execution on Central Processing Units + (CPUs), which is beneficial for debugging, development, and + heterogeneous computing environments where a mix of device types + is utilized. +- **OpenCL Standard**: Adheres to the OpenCL standard, ensuring + portability across different hardware vendors and platforms. + +clFFT is an invaluable resource for developers and researchers who need +to perform fast and efficient Fourier transforms on large datasets, +particularly in applications that can benefit from the parallel +processing capabilities of modern GPUs and multi-core CPUs. diff --git a/math/cliquer/pkg-descr b/math/cliquer/pkg-descr index 421b623dcc63..e23a63616285 100644 --- a/math/cliquer/pkg-descr +++ b/math/cliquer/pkg-descr @@ -1,9 +1,23 @@ -Cliquer is a set of C routines for finding cliques in an arbitrary weighted -graph. It uses an exact branch-and-bound algorithm developed by Patric -Ostergard. It is designed with the aim of being efficient while still being -flexible and easy to use. +Cliquer is a highly efficient C library designed for finding cliques +in arbitrary weighted graphs. In graph theory, a clique is a subset +of vertices where every pair of vertices is connected by an edge. +Finding cliques is a fundamental problem with applications in social +network analysis, bioinformatics, and computer vision. -Note: this port do not use the upstream version, but the version autotoolized -by Dima Pasechnik. +This library implements an exact branch-and-bound algorithm developed +by Patric Ostergard, ensuring optimal solutions. Cliquer is meticulously +designed to be: -See also: https://github.com/dimpase/autocliquer +- **Efficient**: Optimized for performance, even on complex graphs. +- **Flexible**: Adaptable to various graph structures and problem + specifications. +- **Easy to Use**: Provides a straightforward API for integration + into other applications. + +Note that this port utilizes a version of Cliquer that has been +autotoolized by Dima Pasechnik, enhancing its build system and +portability. This ensures a robust and well-maintained package. + +Cliquer is an invaluable resource for researchers and developers working +with graph algorithms, offering a powerful and reliable tool for +identifying dense subgraphs and solving related combinatorial problems. diff --git a/math/clrng/pkg-descr b/math/clrng/pkg-descr index 93c0bf766561..4d94cc188962 100644 --- a/math/clrng/pkg-descr +++ b/math/clrng/pkg-descr @@ -1,11 +1,24 @@ -clRNG +clRNG is a specialized library designed for high-quality uniform random +number generation within OpenCL environments. It provides a robust and +efficient solution for parallel applications requiring statistically +sound random numbers on GPUs and other OpenCL-compatible devices. -a library for uniform random number generation in OpenCL. +The library introduces the concept of "streams of random numbers," which +act as virtual random number generators. These streams can be created +in unlimited quantities on the host system and then utilized by work +items on computing devices to generate random numbers. Each stream also +features equally-spaced substreams, offering additional flexibility for +complex simulations. -Streams of random numbers act as virtual random number generators. -They can be created on the host computer in unlimited numbers, and -then used either on the host or on computing devices by work items -to generate random numbers. Each stream also has equally-spaced -substreams, which are occasionally useful. The API is currently -implemented for four different RNGs, namely the MRG31k3p, MRG32k3a, -LFSR113 and Philox-4x32-10 generators. +clRNG currently implements a selection of well-regarded pseudorandom +number generators, including: + +- MRG31k3p +- MRG32k3a +- LFSR113 +- Philox-4x32-10 + +This library is an invaluable resource for researchers and developers +in fields such as Monte Carlo simulations, scientific computing, and +machine learning, where efficient and reliable parallel random number +generation is crucial. diff --git a/math/cocoalib/pkg-descr b/math/cocoalib/pkg-descr index 6b610cd891f4..7d3c9bd0133c 100644 --- a/math/cocoalib/pkg-descr +++ b/math/cocoalib/pkg-descr @@ -1,6 +1,20 @@ -CoCoALib is a C++ library for Computations in Commutative Algebra, -focused mainly on polynomial rings, ideals, Groebner basis and -similar topics. +CoCoALib is a powerful C++ library dedicated to Computations in +Commutative Algebra. This field of mathematics is fundamental to +algebraic geometry, number theory, and computer algebra systems, +focusing on algebraic structures like rings and ideals. -You might like to install CoCoA-5 too, a shell that lets you interact -with most of CoCoALib without the need to learn C++. +The library provides a robust set of tools for working with: + +- **Polynomial Rings**: Operations on multivariate polynomials. +- **Ideals**: Computations with ideals in polynomial rings. +- **Grobner Bases**: A cornerstone algorithm for solving systems of + polynomial equations and performing other algebraic manipulations. +- **Related Topics**: Other advanced concepts in commutative algebra. + +For users who prefer an interactive environment without direct C++ +programming, the companion CoCoA-5 shell (available separately) offers +a user-friendly interface to most of CoCoALib's functionalities. + +CoCoALib is an invaluable resource for mathematicians, computer scientists, +and researchers engaged in algebraic computations, providing a high-performance +and flexible framework for exploring complex algebraic structures. diff --git a/math/concorde/pkg-descr b/math/concorde/pkg-descr index 2fe47df09e48..84039a11969c 100644 --- a/math/concorde/pkg-descr +++ b/math/concorde/pkg-descr @@ -1,14 +1,22 @@ -Concorde is a computer code for the traveling salesman problem (TSP) -and some related network optimization problems. The code is written -in the ANSI C programming language and it is available for academic -research use; for other uses, contact bico@isye.gatech.edu for -licensing options. +Concorde is a highly optimized computer code designed for solving the +Traveling Salesman Problem (TSP) and various related network optimization +problems. Implemented in ANSI C, it is renowned for its ability to find +optimal solutions to extremely large and complex instances of the TSP. -Concorde's TSP solver has been used to obtain the optimal solutions to -106 of the 110 TSPLIB instances; the largest having 15,112 cities. +Key features and capabilities include: -The Concorde callable library includes over 700 functions permitting -users to create specialized codes for TSP-like problems. All Concorde -functions are thread-safe for programming in shared-memory parallel -environments; the main TSP solver includes code for running over -networks of Unix workstations. +- **Optimal TSP Solutions**: Concorde's TSP solver has successfully + found optimal solutions for 106 of the 110 TSPLIB instances, + including problems with up to 15,112 cities. +- **Extensive Callable Library**: Provides over 700 functions, allowing + users to develop specialized codes for TSP-like problems and integrate + Concorde's powerful algorithms into their own applications. +- **Parallel Computing Support**: All functions are thread-safe for + shared-memory parallel environments. The main TSP solver also + supports execution across networks of Unix workstations, enabling + distributed computation for even larger problems. + +Concorde is an invaluable resource for researchers and practitioners +in combinatorial optimization, operations research, and computer science, +offering a robust and efficient solution for one of the most famous +problems in theoretical computer science. diff --git a/math/crlibm/pkg-descr b/math/crlibm/pkg-descr index 7a3c0fe62f25..04d020e0cfb8 100644 --- a/math/crlibm/pkg-descr +++ b/math/crlibm/pkg-descr @@ -1,21 +1,24 @@ -CRlibm is an efficient and proven mathematical library, which -provides implementations of the double-precision C99 standard -elementary functions, correctly rounded in the four IEEE-754 rounding -modes, and sufficiently efficient in average time, worst-case time, -and memory consumption to replace existing libms transparently. +CRlibm is an efficient and rigorously proven mathematical library +providing correctly rounded implementations of double-precision C99 +standard elementary functions. It supports all four IEEE-754 rounding +modes, offering high accuracy and reliability for numerical computations. -The distribution includes extensive documentation with the proof -of each function (currently more than 100 pages), as well as all -the Maple scripts used to develop the functions. This makes this -library an excellent tutorial on software elementary function +Designed for transparent replacement of existing `libm` implementations, +CRlibm maintains efficiency in average and worst-case time, along with +optimized memory consumption. Its development includes extensive +documentation with formal proofs for each function, making it an +excellent resource for understanding software elementary function development. -CRlibm also includes a lightweight library for multiple precision, -scslib (Software Carry Save Library). This library has been developed -specifically to answer the needs of the CRlibm project: precision -up to a few hundred bits, portability, compatibility with IEEE -floating-point standards, performance comparable to or better than -GMP, and a small footprint. It uses a data-structure which allows -carry propagations to be avoided during multiple-precision -multiplications, and supports addition, subtraction, multiplication, -and conversions. +CRlibm also integrates scslib (Software Carry Save Library), a lightweight +multiple-precision library. scslib is tailored for CRlibm's needs, +offering precision up to a few hundred bits, portability, IEEE +floating-point compatibility, and performance comparable to or better +than GMP, all within a small footprint. It efficiently handles +multiple-precision additions, subtractions, multiplications, and conversions +by avoiding carry propagations during multiplication. + +CRlibm is an invaluable tool for applications demanding high-precision, +correctly rounded mathematical functions, particularly in scientific +computing, financial modeling, and other fields where numerical accuracy +is paramount. diff --git a/math/dieharder/pkg-descr b/math/dieharder/pkg-descr index 327aac1c5bda..4efd18b2e129 100644 --- a/math/dieharder/pkg-descr +++ b/math/dieharder/pkg-descr @@ -1,22 +1,21 @@ -At the suggestion of Linas Vepstas on the Gnu Scientific Library (GSL) list, -this GPL'd suite of random number tests will be named "Dieharder". Using a -movie sequel pun for the name is a double tribute to George Marsaglia, whose -"Diehard battery of tests" of random number generators has enjoyed years of -enduring usefulness as a test suite. +Dieharder is a comprehensive, GPL-licensed test suite for evaluating +the quality of random number generators (RNGs). It builds upon the +legacy of George Marsaglia's "Diehard battery of tests" and expands +upon it with modern statistical methodologies. -The dieharder suite is more than just the diehard tests cleaned up and given a -pretty GPL'd source face in native C: tests from the Statistical Test Suite -(STS) developed by the National Institute for Standards and Technology (NIST) -are being incorporated, as are new tests developed by rgb. Where possible, -tests are parametrized and controllable so that failure, at least, is -unambiguous. +This suite incorporates a diverse collection of tests, including: -A further design goal is to provide some indication of *why* a generator fails -a test, where such information can be extracted during the test process and -placed in usable form. For example, the bit-distribution tests should -(eventually) be able to display the actual histogram for the different bit -n-tuplets. +- **Diehard Tests**: Classic tests for assessing RNG randomness. +- **NIST Statistical Test Suite (STS)**: Tests developed by the + National Institute for Standards and Technology. +- **New Tests**: Additional tests developed by the project's author. -Dieharder is by design extensible. It is intended to be the "Swiss army knife -of random number test suites", or if you prefer, "the last suite you'll ever -ware" for testing random numbers. +Dieharder is designed with extensibility in mind, allowing for the +incorporation of new tests and analysis methods. A key design goal is +to provide not just pass/fail results, but also insights into *why* an +RNG might fail a particular test, offering diagnostic information +(e.g., displaying histograms for bit distributions). + +This makes Dieharder an invaluable tool for researchers, cryptographers, +and developers who require rigorous validation of RNGs for applications +in simulations, security, and statistical analysis. diff --git a/math/edenmath/pkg-descr b/math/edenmath/pkg-descr index addee44d96db..2a4a94c42681 100644 --- a/math/edenmath/pkg-descr +++ b/math/edenmath/pkg-descr @@ -1,4 +1,20 @@ -EdenMath is a scientific calculator. It does standard arithmetic, -probability, and trigonometric functions. +EdenMath is a user-friendly scientific calculator designed to perform +a wide array of mathematical computations. It offers a comprehensive +set of functionalities, making it a versatile tool for students, +educators, and professionals alike. -LICENSE: GPL2 or later +Key features of EdenMath include: + +- **Standard Arithmetic**: Basic operations such as addition, subtraction, + multiplication, and division. +- **Advanced Mathematical Functions**: Support for powers, roots, logarithms, + and exponential functions. +- **Trigonometric Functions**: Calculations involving sine, cosine, tangent, + and their inverses. +- **Probability and Statistics**: Functions for permutations, combinations, + and basic statistical calculations. + +With its intuitive interface, EdenMath simplifies complex calculations, +providing accurate and quick results. It is distributed under the terms +of the GPL2 or later license, ensuring it remains free and open-source +for everyone to use and modify. diff --git a/math/eispack/pkg-descr b/math/eispack/pkg-descr index 02e4215b6d3c..82fbd65a543e 100644 --- a/math/eispack/pkg-descr +++ b/math/eispack/pkg-descr @@ -1,15 +1,19 @@ -This is eispack from research.att.com. I've cleaned up the Makefile, but -it is otherwise the same. The package is described in: +EISPACK is a classic software library for solving eigenvalue problems. +It provides a comprehensive collection of Fortran subroutines for +computing eigenvalues and eigenvectors of various types of matrices. -1. Smith, B.T, Boyle, J.M, Dongerra, J.J., Garbow, B.S., Ikebe, Y., - Klema, V.C., and Moler, C.B., Matrix Eigensystem Routines -- EISPACK - Guide, Lecture Notes in Computer Science, Vol. 6, Second Edition, - Springer-Verlag, New York, Heidelberg, Berlin, 1976 +Originally developed by a team including B.T. Smith, J.M. Boyle, J.J. +Dongarra, B.S. Garbow, Y. Ikebe, V.C. Klema, and C.B. Moler, EISPACK +has been a foundational resource in numerical linear algebra. The +library is described in detail in: -2. Garbow, B.S., Boyle J.M., Dongerra, J.J, and Moler C.B., Matrix - Eigensystem Routines -- EISPACK Guide Extension, Lecture Notes in - Computer Science, Vol. 51, Springer-Verlag, New York, Heidelberg, - Berlin, 1977 +1. Smith et al., "Matrix Eigensystem Routines -- EISPACK Guide," + Lecture Notes in Computer Science, Vol. 6, Springer-Verlag, 1976. +2. Garbow et al., "Matrix Eigensystem Routines -- EISPACK Guide + Extension," Lecture Notes in Computer Science, Vol. 51, + Springer-Verlag, 1977. -As the package is in FORTRAN there are no include files for the library, -and the only thing to install is the library itself. +As a Fortran-based library, it primarily installs the compiled library +itself. EISPACK remains a valuable reference and tool for researchers +and developers working with eigenvalue computations, particularly in +scientific and engineering applications. diff --git a/math/emc2/pkg-descr b/math/emc2/pkg-descr index 4d9ac4b08048..3652c87a1473 100644 --- a/math/emc2/pkg-descr +++ b/math/emc2/pkg-descr @@ -1,8 +1,20 @@ -Emc2 is a portable, interactive, graphical editor of two-dimensional mesh -geometries. It can create and modify geometries (as in CAD), and define line -discretizations, subdomains, and reference numbers (to take into account -boundary conditions and material properties). Grid and Delaunay-Voronoi -meshes composed of triangles or quadrilaterals can be regularized, rotated, -and modified via the addition, removal, or moving of vertices. +Emc2 is a portable, interactive, and graphical editor for two-dimensional +mesh geometries. It provides a comprehensive environment for creating, +modifying, and analyzing mesh structures, making it an invaluable tool +for numerical simulations and engineering applications. -It is suggested that users also install the math/bamg port. +Key functionalities include: + +- **Geometry Creation and Modification**: Functions similar to CAD + software for designing and altering 2D shapes. +- **Mesh Definition**: Define line discretizations, subdomains, and + assign reference numbers for boundary conditions and material properties. +- **Mesh Generation**: Create grid and Delaunay-Voronoi meshes composed + of triangles or quadrilaterals. +- **Mesh Manipulation**: Regularize, rotate, and modify meshes by + adding, removing, or moving vertices, ensuring optimal mesh quality. + +Emc2 streamlines the preprocessing stage for finite element analysis, +computational fluid dynamics, and other simulation methods. For enhanced +mesh generation capabilities, it is highly suggested that users also +install the `math/bamg` port. diff --git a/math/ent/pkg-descr b/math/ent/pkg-descr index d457f4f297d5..c13730e54306 100644 --- a/math/ent/pkg-descr +++ b/math/ent/pkg-descr @@ -1,5 +1,20 @@ -ent applies various tests to sequences of bytes stored in files and reports the -results of those tests. The program is useful for evaluating pseudorandom -number generators for encryption and statistical sampling applications, -compression algorithms, and other applications where the information density of -a file is of interest. +Ent is a powerful command-line utility for applying statistical tests +to byte sequences within files. It provides insights into the randomness +and information density of data, crucial for evaluating various digital +processes. + +Key analyses performed include: + +- **Entropy Calculation**: Measures information content per byte. +- **Chi-Square Test**: Assesses uniformity of byte distribution. +- **Arithmetic Mean and Monte Carlo Pi Estimation**: Statistical indicators. +- **Serial Correlation Coefficient**: Detects patterns between bytes. + +Ent is particularly useful for: + +- **Evaluating Pseudorandom Number Generators (PRNGs)**: Essential for + cryptography and statistical sampling. +- **Assessing Compression Algorithms**: Analyzing information density. +- **Analyzing Data Streams**: Identifying non-random patterns. + +It helps users ensure the integrity and quality of their data and algorithms. diff --git a/math/fftw/pkg-descr b/math/fftw/pkg-descr index 8595fe3ffd99..8f75c980a493 100644 --- a/math/fftw/pkg-descr +++ b/math/fftw/pkg-descr @@ -1,14 +1,23 @@ -FFTW is a C subroutine library for computing the Discrete Fourier Transform -(DFT) in one or more dimensions, of both real and complex data, and of -arbitrary input size. We believe that FFTW, which is free software, should -become the FFT library of choice for most applications. Our benchmarks, -performed on a variety of platforms, show that FFTW's performance is -typically superior to that of other publicly available FFT software. -Moreover, FFTW's performance is portable: the program will perform well on -most architectures without modification. - -The FFTW package was developed at MIT by Matteo Frigo and Steven G. -Johnson. Please send email to fftw@theory.lcs.mit.edu so that we can keep -track of users and send you information about new releases. The latest -version of FFTW, benchmarks, links, and other information can be found at -the FFTW home page. +FFTW (Fastest Fourier Transform in the West) is a highly optimized C +subroutine library for computing the Discrete Fourier Transform (DFT). +It supports one or more dimensions, both real and complex data, and +arbitrary input size, making it a versatile tool for various applications. + +FFTW is renowned for its exceptional performance, consistently outperforming +other publicly available FFT software across a wide range of platforms. +Its performance is also highly portable, ensuring optimal execution on +most architectures without requiring modifications. + +Key features and benefits include: + +- **Versatile DFT Computation**: Handles 1D, 2D, and multi-dimensional + DFTs for both real and complex datasets. +- **Arbitrary Input Size**: Efficiently processes data of any length, + without power-of-two restrictions. +- **Self-Optimizing**: Employs adaptive algorithms that tune themselves + to the underlying hardware for peak performance. + +Developed at MIT by Matteo Frigo and Steven G. Johnson, FFTW has become +the de facto standard for FFT computations in scientific computing, +signal processing, image analysis, and many other fields where fast +and accurate Fourier transforms are critical. diff --git a/math/frobby/pkg-descr b/math/frobby/pkg-descr index 00d91886bcc3..f202f5d90ba4 100644 --- a/math/frobby/pkg-descr +++ b/math/frobby/pkg-descr @@ -1,13 +1,21 @@ -Frobby is a software system and project for computations with monomial -ideals. Frobby is free software and it is intended as a vehicle for -computational and mathematical research on monomial ideals. +Frobby is a powerful software system and project dedicated to computations +with monomial ideals. As free software, it serves as a vital tool for +computational and mathematical research in this specialized area of algebra. -The current functionality includes Euler characteristic, Hilbert -series, maximal standard monomials, combinatorial optimization on -monomial ideals, primary decomposition, irreducible decomposition, -Alexander dual, associated primes, minimization and intersection of -monomial ideals as well as the computation of Frobenius problems -(using 4ti2) with very large numbers. Frobby is also able to translate -between formats that can be used with several different computer -systems, such as Macaulay 2, Monos, 4ti2, CoCoA4 and Singular. Thus -Frobby can be used with any of those systems. +Its extensive functionality includes: + +- **Ideal Properties**: Euler characteristic, Hilbert series, maximal + standard monomials, primary decomposition, irreducible decomposition, + Alexander dual, and associated primes. +- **Ideal Operations**: Minimization and intersection of monomial ideals. +- **Frobenius Problems**: Computation of Frobenius problems, even with + very large numbers, leveraging the capabilities of 4ti2. +- **Interoperability**: Supports translation between formats compatible + with various computer algebra systems, including Macaulay2, Monos, + 4ti2, CoCoA4, and Singular. This allows Frobby to seamlessly integrate + with and extend the capabilities of these systems. + +Frobby is an invaluable resource for researchers and students in +commutative algebra, algebraic geometry, and computational mathematics, +providing a flexible and robust platform for exploring the intricate +properties of monomial ideals. diff --git a/math/gexpr/pkg-descr b/math/gexpr/pkg-descr index 373f9b9e11e5..20485cdc3642 100644 --- a/math/gexpr/pkg-descr +++ b/math/gexpr/pkg-descr @@ -1,3 +1,12 @@ -Gexpr is a shell calculator with floating point, standard C functions, -relational operators, and output in base 2/8/10/16. It is a light alternative -to bc(1). It can also be used to add floating point math to shell scripts. +Gexpr is a powerful and lightweight command-line calculator designed +for shell environments. It supports floating-point arithmetic, a wide +range of standard C mathematical functions, and relational operators +for conditional expressions. Gexpr offers flexible output options, +allowing results to be displayed in binary, octal, decimal, or +hexadecimal bases. + +It serves as an excellent alternative to traditional command-line +calculators like bc(1), especially when a more streamlined and +feature-rich solution is desired. Furthermore, gexpr can be seamlessly +integrated into shell scripts, providing robust floating-point math +capabilities for automation and complex calculations. diff --git a/math/glgraph/pkg-descr b/math/glgraph/pkg-descr index 9573516c24cf..4360cd67124f 100644 --- a/math/glgraph/pkg-descr +++ b/math/glgraph/pkg-descr @@ -1,2 +1,15 @@ -GLgraph visualize mathematical functions. It can handle 3 unknowns (x,z,t) and -can produce a 4D function with 3 space and 1 time dimension. +GLgraph is a powerful and interactive visualization tool designed to +render complex mathematical functions in a graphical environment. +Leveraging OpenGL, it provides dynamic 3D and 4D representations, +making abstract mathematical concepts tangible and explorable. + +This utility excels at visualizing functions with up to three independent +variables (typically denoted as x, z, and t). Notably, it can generate +stunning 4D function plots, where three dimensions represent space and +the fourth dimension represents time, allowing for the visualization of +evolving systems or dynamic surfaces. + +GLgraph is an invaluable resource for students, educators, and researchers +in mathematics, physics, engineering, and other scientific disciplines +who need to understand and analyze multi-dimensional functions through +intuitive and high-quality graphical representations. diff --git a/math/gmp-ecm/pkg-descr b/math/gmp-ecm/pkg-descr index 6420ee302738..db04a907fa7e 100644 --- a/math/gmp-ecm/pkg-descr +++ b/math/gmp-ecm/pkg-descr @@ -1,2 +1,20 @@ -GMP-ECM is a program to factor integers using the Elliptic Curve Method -(ECM), based on the GNU MP multiprecision library. +GMP-ECM is a specialized program for efficient integer factorization +using the Elliptic Curve Method (ECM). This method excels at finding +relatively small prime factors of very large numbers, making it a +crucial tool in computational number theory and cryptography. + +It leverages the high-performance GNU MP (Multiple Precision) library +for arbitrary-precision arithmetic, allowing it to handle integers of +virtually any size with accuracy and speed. + +Key applications include: + +- **Cryptanalysis**: Analyzing cryptographic systems (e.g., RSA). +- **Number Theory Research**: Exploring properties of integers and + primes. +- **Computational Mathematics**: Decomposing numbers into prime + components. + +GMP-ECM offers a robust and optimized solution for researchers, +cryptographers, and mathematicians needing efficient large integer +factorization. diff --git a/math/grace/pkg-descr b/math/grace/pkg-descr index 353625118e9a..7d92f6141c1e 100644 --- a/math/grace/pkg-descr +++ b/math/grace/pkg-descr @@ -1,16 +1,24 @@ -Grace is a WYSIWYG 2D plotting tool for the X Window System and M*tif, -successor of ACE/gr (Xmgr). A few of its features are: +Grace is a powerful WYSIWYG (What You See Is What You Get) 2D plotting +tool for the X Window System, built with Motif. It is the successor to +ACE/gr (Xmgr) and provides an extensive set of features for creating +high-quality scientific plots. - * User defined scaling, tick marks, labels, symbols, line styles, - colors. - * Batch mode for unattended plotting. - * Read and write parameters used during a session. - * Polynomial regression, splines, running averages, DFT/FFT, - cross/auto-correlation. - * Exports high-resolution graphics to (E)PS, PDF, MIF, and SVG - formats - * Supports cross-platform PNM, JPEG and PNG formats +Key features include: -While grace has a convenient point-and-click interface, most parameter -settings and operations are available through a command line interface -(found in Data/Commands). +- **Customizable Plot Elements**: User-defined scaling, tick marks, + labels, symbols, line styles, and colors. +- **Batch Processing**: Supports batch mode for unattended plotting, + ideal for automated data visualization. +- **Session Management**: Ability to read and write parameters used + during a session for reproducibility. +- **Data Analysis**: Built-in functions for polynomial regression, + splines, running averages, DFT/FFT, and cross/auto-correlation. +- **High-Resolution Export**: Exports graphics to various formats, + including (E)PS, PDF, MIF, and SVG. +- **Image Format Support**: Supports cross-platform PNM, JPEG, and PNG + image formats. +- **Dual Interface**: Offers both a convenient point-and-click graphical + interface and a comprehensive command-line interface for advanced control. + +Grace is an invaluable tool for scientists, engineers, and researchers +who require precise and visually appealing data representation. diff --git a/math/grpn/pkg-descr b/math/grpn/pkg-descr index bab25a81dcde..0bd93d9e6f01 100644 --- a/math/grpn/pkg-descr +++ b/math/grpn/pkg-descr @@ -1,7 +1,21 @@ -GRPN is a RPN calculator for the X Window system built using -the GIMP Toolkit (GTK). +GRPN is a powerful and intuitive Reverse Polish Notation (RPN) calculator +designed for the X Window System, built with the GIMP Toolkit (GTK). +RPN calculators streamline complex calculations by eliminating the need +for parentheses and prioritizing operational flow. -GRPN works with real numbers, complex numbers, matrices, and -complex matrices. Numbers can be displayed in 4 different -radix modes, and complex numbers can be displayed in either -Cartesian or polar form. +This graphical calculator offers extensive support for various number +types and display formats, making it a versatile tool for mathematicians, +engineers, and students. Key features include: + +- **Diverse Data Types**: Handles calculations with real numbers, + complex numbers, matrices, and complex matrices. +- **Flexible Radix Modes**: Numbers can be displayed in four different + radix modes (e.g., binary, octal, decimal, hexadecimal) for enhanced + versatility in various computing contexts. +- **Complex Number Representation**: Complex numbers can be viewed in + either Cartesian (a + bi) or polar (r * e^(i*theta)) form, catering + to different analytical needs. + +GRPN provides a robust and user-friendly environment for performing +advanced mathematical computations, combining the efficiency of RPN +with the visual clarity of a modern graphical interface. diff --git a/math/ised/pkg-descr b/math/ised/pkg-descr index 09a59104fa4e..8b5b60298904 100644 --- a/math/ised/pkg-descr +++ b/math/ised/pkg-descr @@ -1,10 +1,21 @@ -ised is a command-line tool for generating number sequences and -arithmetic evaluation. Unlike big gui-based software (e.g. Mathematica, -Derive, Matlab, Octave,...) it is intended for use in shell scripting, -together with gnu core utilities. +ised is a versatile command-line tool designed for generating number +sequences and performing arithmetic evaluations. Unlike large GUI-based +mathematical software, ised is specifically tailored for efficient use +within shell scripting environments, complementing GNU core utilities. -Its main advantage is that all functions are generalized to operate -on one-dimensional arrays. It can be used for loop indexing (much -like seq), line-by-line arithmetic processing of files, floating -point math for shells that don't support it natively, or interactively, -as extended calculator. +Its primary advantage lies in its ability to generalize all functions +to operate on one-dimensional arrays, making it highly flexible for +various tasks: + +- **Sequence Generation**: Functions similarly to `seq` for creating + numerical sequences, useful for loop indexing. +- **File Processing**: Enables line-by-line arithmetic processing of + data files. +- **Floating-Point Math**: Provides robust floating-point arithmetic + capabilities for shells that lack native support. +- **Interactive Calculator**: Can be used interactively as an extended + calculator for quick computations. + +ised is an invaluable utility for system administrators, developers, +and researchers who require a lightweight yet powerful tool for numerical +manipulation and scripting in command-line environments. diff --git a/math/jags/pkg-descr b/math/jags/pkg-descr index 6b90268b9334..a49c272e75fe 100644 --- a/math/jags/pkg-descr +++ b/math/jags/pkg-descr @@ -1,10 +1,22 @@ -JAGS is Just Another Gibbs Sampler -- a program for analysis of -Bayesian hierarchical models using Markov Chain Monte Carlo (MCMC) -simulation. +JAGS (Just Another Gibbs Sampler) is a program for analyzing Bayesian +hierarchical models using Markov Chain Monte Carlo (MCMC) simulation. +It provides a flexible framework for statistical modeling, especially +for complex models lacking analytical solutions. -The functionality of JAGS is based on the BUGS program created by the -MRC Biostatistics Unit (http://www.mrc-bsu.cam.ac.uk/). There is a short -manual that describes the differences between JAGS and BUGS. +JAGS builds upon the foundational concepts of the BUGS program, with +specific differences detailed in its documentation. -Some of the BUGS examples have been modified to run with JAGS, and have -been turned into a test suite. +Key features: + +- **Bayesian Modeling**: Facilitates specification and analysis of + Bayesian hierarchical models. +- **MCMC Simulation**: Employs Gibbs sampling for efficient exploration + of posterior distributions. +- **Extensibility**: Allows users to define custom distributions and + functions. +- **Compatibility**: Many BUGS examples are adapted to run with JAGS, + forming a robust test suite. + +JAGS is an invaluable tool for statisticians and researchers in fields +like epidemiology, ecology, and social sciences, where Bayesian inference +and MCMC methods are widely applied. diff --git a/math/jeuclid/pkg-descr b/math/jeuclid/pkg-descr index f3796b20eb5c..d965e7f9e3ae 100644 --- a/math/jeuclid/pkg-descr +++ b/math/jeuclid/pkg-descr @@ -1,4 +1,21 @@ -JEuclid is a complete MathML rendering solution, consisting of: a MathViewer -application, command line converters from MathML to other formats, an ant -task for autmated conversion, display components for AWT and Swing and a -component for Apache Cocoon. +JEuclid offers a comprehensive MathML rendering solution, providing +tools to display and convert mathematical expressions. MathML (Mathematical +Markup Language) is an XML-based standard for describing mathematical +notation, and JEuclid ensures its accurate and versatile presentation. + +This package includes several key components: + +- **MathViewer application**: A standalone viewer for MathML content. +- **Command-line converters**: Transform MathML into various other + formats for broader compatibility. +- **Ant task**: Facilitates automated conversion workflows, ideal for + build processes. +- **Display components for AWT and Swing**: Enables seamless integration + of MathML rendering into Java desktop applications. +- **Apache Cocoon component**: Supports dynamic generation and delivery + of MathML content within web applications. + +JEuclid is an invaluable resource for developers and content creators +working with mathematical content, providing flexible options for +rendering, conversion, and integration across different platforms and +applications. diff --git a/math/jlatexmath/pkg-descr b/math/jlatexmath/pkg-descr index a87b7ca1ed18..baff68705d0f 100644 --- a/math/jlatexmath/pkg-descr +++ b/math/jlatexmath/pkg-descr @@ -1,19 +1,24 @@ -The goal of this Java API is to display mathematical formulas written in -LaTeX. The default encoding is UTF-8. +JLaTeXMath is a Java API designed to render mathematical formulas +written in LaTeX. It provides a robust solution for displaying complex +mathematical expressions within Java applications, with UTF-8 as the +default encoding. -The most of LaTeX commands are available and : +The library supports a wide range of LaTeX commands and features, including: - 1) macros from amsmath and symbols from amssymb and stmaryrd; - 2) \includegraphics (without options); - 3) the TeX macro \over; - 4) accents from amsxtra package; - 5) the macros \definecolor, \textcolor, \colorbox and \fcolorbox from the - package color; - 6) the macros \rotatebox, \reflectbox and \scalebox from the package graphicx; - 7) the most of latin unicode characters are available and cyrillic or - greek characters are detected for the loading of the different fonts; - 8) the commands \newcommand and \newenvironment; - 9) the environments array, matrix, pmatrix,..., eqnarray, cases; -10) the fonts are embedded in the jar file to be used by fop 0.95 to generate - PDF, PS or EPS (SVG export with shaped fonts works fine too); -11) and probably other things I forgot... +- **Comprehensive Command Support**: Most standard LaTeX commands, + macros from `amsmath`, and symbols from `amssymb` and `stmaryrd`. +- **Graphics Integration**: Supports `\includegraphics` (without options) + and `\over` macro. +- **Extended Accents**: Includes accents from the `amsxtra` package. +- **Color/Graphics Manipulation**: Provides `\definecolor`, `\textcolor`, + `\colorbox`, `\fcolorbox` (from `color` package), and `\rotatebox`, + `\reflectbox`, `\scalebox` (from `graphicx`). +- **Unicode/Font Support**: Detects and loads fonts for Latin, Cyrillic, + and Greek Unicode characters. +- **Custom Commands/Environments**: Supports `\newcommand`, `\newenvironment`, + `array`, `matrix`, `pmatrix`, `eqnarray`, and `cases` environments. +- **Embedded Fonts**: Fonts embedded in JAR for PDF, PS, EPS generation + via FOP 0.95; SVG export also supported. + +JLaTeXMath is an invaluable tool for Java developers needing to integrate +high-quality mathematical typesetting into their applications. diff --git a/math/kfr/Makefile b/math/kfr/Makefile index d314966dedcb..397138bd652e 100644 --- a/math/kfr/Makefile +++ b/math/kfr/Makefile @@ -1,7 +1,11 @@ PORTNAME= kfr -DISTVERSION= 6.3.0 +DISTVERSION= 6.3.1 CATEGORIES= math +PATCH_SITES= https://github.com/kfrlib/kfr/commit/ +PATCHFILES= eb615703f5f15eb7794d6ec3f20d83130d9f5274.patch:-p1 \ + 6056e7d24723531e10484d63f6a9a5c58f976daa.patch:-p1 + MAINTAINER= yuri@FreeBSD.org COMMENT= C++ DSP framework, FFT, Sample Rate Conversion, FIR/IIR/Biquad Filters WWW= https://github.com/kfrlib/kfr diff --git a/math/kfr/distinfo b/math/kfr/distinfo index a5fdbd4e47ac..cfd873561e80 100644 --- a/math/kfr/distinfo +++ b/math/kfr/distinfo @@ -1,3 +1,7 @@ -TIMESTAMP = 1754130652 -SHA256 (kfrlib-kfr-6.3.0_GH0.tar.gz) = 3b2eb54edb9c1ba6d30648b47d11bd445cda4883052d592801bd5482f837162c -SIZE (kfrlib-kfr-6.3.0_GH0.tar.gz) = 11284158 +TIMESTAMP = 1757718446 +SHA256 (kfrlib-kfr-6.3.1_GH0.tar.gz) = 800f8e782fb514176c06526792ec766b718a7b91c73e9d07efe47dff6cb0816d +SIZE (kfrlib-kfr-6.3.1_GH0.tar.gz) = 11285494 +SHA256 (eb615703f5f15eb7794d6ec3f20d83130d9f5274.patch) = d25e5b0c01a0b2d0236c40a32d8a04c60c8e1bd2c64cd213ce9d6ffb79115ca0 +SIZE (eb615703f5f15eb7794d6ec3f20d83130d9f5274.patch) = 1173 +SHA256 (6056e7d24723531e10484d63f6a9a5c58f976daa.patch) = 07c76375fe9e97d3b7b7938a440bab63441ab5d6eee617374dececc92fd4f7f3 +SIZE (6056e7d24723531e10484d63f6a9a5c58f976daa.patch) = 6768 diff --git a/math/lcalc/pkg-descr b/math/lcalc/pkg-descr index 0ec4998fb03e..52cd08ff623e 100644 --- a/math/lcalc/pkg-descr +++ b/math/lcalc/pkg-descr @@ -1,4 +1,19 @@ -This program computes zeros and values of L-function. +Lcalc is a specialized program designed for computations involving +L-functions, which are fundamental objects in analytic number theory +with deep connections to prime numbers and other arithmetic properties. +This utility provides powerful capabilities for both calculating values +and finding zeros of these complex functions. -It installs the L-function c++ class library and, the command line program -lcalc. +The package offers a dual approach for users: + +- **lcalc command-line program**: A direct and efficient tool for + interactive computation and analysis of L-functions. +- **L-function C++ class library**: Provides a robust and flexible + interface for C++ programmers to integrate L-function computations + into their own applications, leveraging the library's optimized + algorithms. + +Lcalc is an invaluable resource for mathematicians, number theorists, +and researchers working on problems related to the Riemann Hypothesis, +elliptic curves, and other areas of advanced number theory, offering +precise numerical tools for exploring the intricate behavior of L-functions. diff --git a/math/ldouble/pkg-descr b/math/ldouble/pkg-descr index c53aea0789d0..aef898ccdb99 100644 --- a/math/ldouble/pkg-descr +++ b/math/ldouble/pkg-descr @@ -1,2 +1,20 @@ -Library of elementary mathematical functions, probability and elliptic -integrals in 80-bit (x86) or 128-bit long double precision. +The ldouble library provides a comprehensive collection of elementary +mathematical functions, probability functions, and elliptic integrals, +all implemented with extended precision. This library is specifically +designed for computations requiring higher accuracy than standard +double-precision floating-point numbers. + +It supports 80-bit long double precision on x86 architectures and +128-bit long double precision where available, offering enhanced +numerical stability and reduced round-off errors for demanding +scientific and engineering applications. This extended precision is +crucial for fields such as: + +- Computational physics and chemistry +- High-precision financial modeling +- Numerical analysis and algorithm development +- Any application where accumulated floating-point errors can lead + to significant inaccuracies. + +By leveraging ldouble, developers can achieve greater confidence in the +accuracy of their complex mathematical computations. diff --git a/math/lean4/Makefile b/math/lean4/Makefile index 08ab12311304..c6d417be8716 100644 --- a/math/lean4/Makefile +++ b/math/lean4/Makefile @@ -1,6 +1,6 @@ PORTNAME= lean4 DISTVERSIONPREFIX= v -DISTVERSION= 4.22.0 +DISTVERSION= 4.23.0 CATEGORIES= math lang devel # lean4 is primarily a math theorem prover, but it is also a language and a development environment MAINTAINER= yuri@FreeBSD.org @@ -61,8 +61,11 @@ post-install: bin/lean \ bin/leanc \ lib/lean/libInit_shared.so \ - lib/lean/libleanshared.so + lib/lean/libleanshared.so \ + lib/lean/libleanshared_1.so \ + lib/lean/libLake_shared.so -tests as of 4.20.0: 99% tests passed, 16 tests failed out of 2594, see https://github.com/leanprover/lean4/issues/8628 +# tests as of 4.20.0: 99% tests passed, 16 tests failed out of 2594, see https://github.com/leanprover/lean4/issues/8628 +# tests as of 4.23.0: 99% tests passed, 10 tests failed out of 2870 .include <bsd.port.mk> diff --git a/math/lean4/distinfo b/math/lean4/distinfo index 55b80a8bdc7c..da328bb6517b 100644 --- a/math/lean4/distinfo +++ b/math/lean4/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1755740882 -SHA256 (leanprover-lean4-v4.22.0_GH0.tar.gz) = 625aa7b9916b0dd9dd5c0a0f9b76d4921cc837528e799bd9ced8c6685c27651b -SIZE (leanprover-lean4-v4.22.0_GH0.tar.gz) = 38212555 +TIMESTAMP = 1758525947 +SHA256 (leanprover-lean4-v4.23.0_GH0.tar.gz) = 1820cc8fc09f439c448ea39cc14f90e73058c55b12b5aa5cf4d2ca86f0c89099 +SIZE (leanprover-lean4-v4.23.0_GH0.tar.gz) = 45087678 diff --git a/math/lean4/pkg-plist b/math/lean4/pkg-plist index a2d59c60ce54..20f5d941e24a 100644 --- a/math/lean4/pkg-plist +++ b/math/lean4/pkg-plist @@ -397,6 +397,11 @@ lib/lean/Init/Data/Char/Lemmas.ir lib/lean/Init/Data/Char/Lemmas.olean lib/lean/Init/Data/Char/Lemmas.olean.private lib/lean/Init/Data/Char/Lemmas.olean.server +lib/lean/Init/Data/Char/Order.ilean +lib/lean/Init/Data/Char/Order.ir +lib/lean/Init/Data/Char/Order.olean +lib/lean/Init/Data/Char/Order.olean.private +lib/lean/Init/Data/Char/Order.olean.server lib/lean/Init/Data/Fin.ilean lib/lean/Init/Data/Fin.ir lib/lean/Init/Data/Fin.olean @@ -677,6 +682,11 @@ lib/lean/Init/Data/Iterators/Consumers/Partial.ir lib/lean/Init/Data/Iterators/Consumers/Partial.olean lib/lean/Init/Data/Iterators/Consumers/Partial.olean.private lib/lean/Init/Data/Iterators/Consumers/Partial.olean.server +lib/lean/Init/Data/Iterators/Consumers/Stream.ilean +lib/lean/Init/Data/Iterators/Consumers/Stream.ir +lib/lean/Init/Data/Iterators/Consumers/Stream.olean +lib/lean/Init/Data/Iterators/Consumers/Stream.olean.private +lib/lean/Init/Data/Iterators/Consumers/Stream.olean.server lib/lean/Init/Data/Iterators/Internal.ilean lib/lean/Init/Data/Iterators/Internal.ir lib/lean/Init/Data/Iterators/Internal.olean @@ -1092,6 +1102,11 @@ lib/lean/Init/Data/Nat/Mod.ir lib/lean/Init/Data/Nat/Mod.olean lib/lean/Init/Data/Nat/Mod.olean.private lib/lean/Init/Data/Nat/Mod.olean.server +lib/lean/Init/Data/Nat/Order.ilean +lib/lean/Init/Data/Nat/Order.ir +lib/lean/Init/Data/Nat/Order.olean +lib/lean/Init/Data/Nat/Order.olean.private +lib/lean/Init/Data/Nat/Order.olean.server lib/lean/Init/Data/Nat/Power2.ilean lib/lean/Init/Data/Nat/Power2.ir lib/lean/Init/Data/Nat/Power2.olean @@ -1172,6 +1187,26 @@ lib/lean/Init/Data/Ord.ir lib/lean/Init/Data/Ord.olean lib/lean/Init/Data/Ord.olean.private lib/lean/Init/Data/Ord.olean.server +lib/lean/Init/Data/Order.ilean +lib/lean/Init/Data/Order.ir +lib/lean/Init/Data/Order.olean +lib/lean/Init/Data/Order.olean.private +lib/lean/Init/Data/Order.olean.server +lib/lean/Init/Data/Order/Classes.ilean +lib/lean/Init/Data/Order/Classes.ir +lib/lean/Init/Data/Order/Classes.olean +lib/lean/Init/Data/Order/Classes.olean.private +lib/lean/Init/Data/Order/Classes.olean.server +lib/lean/Init/Data/Order/Factories.ilean +lib/lean/Init/Data/Order/Factories.ir +lib/lean/Init/Data/Order/Factories.olean +lib/lean/Init/Data/Order/Factories.olean.private +lib/lean/Init/Data/Order/Factories.olean.server +lib/lean/Init/Data/Order/Lemmas.ilean +lib/lean/Init/Data/Order/Lemmas.ir +lib/lean/Init/Data/Order/Lemmas.olean +lib/lean/Init/Data/Order/Lemmas.olean.private +lib/lean/Init/Data/Order/Lemmas.olean.server lib/lean/Init/Data/PLift.ilean lib/lean/Init/Data/PLift.ir lib/lean/Init/Data/PLift.olean @@ -1252,6 +1287,11 @@ lib/lean/Init/Data/Range/Polymorphic/RangeIterator.ir lib/lean/Init/Data/Range/Polymorphic/RangeIterator.olean lib/lean/Init/Data/Range/Polymorphic/RangeIterator.olean.private lib/lean/Init/Data/Range/Polymorphic/RangeIterator.olean.server +lib/lean/Init/Data/Range/Polymorphic/Stream.ilean +lib/lean/Init/Data/Range/Polymorphic/Stream.ir +lib/lean/Init/Data/Range/Polymorphic/Stream.olean +lib/lean/Init/Data/Range/Polymorphic/Stream.olean.private +lib/lean/Init/Data/Range/Polymorphic/Stream.olean.server lib/lean/Init/Data/Range/Polymorphic/UpwardEnumerable.ilean lib/lean/Init/Data/Range/Polymorphic/UpwardEnumerable.ir lib/lean/Init/Data/Range/Polymorphic/UpwardEnumerable.olean @@ -1367,6 +1407,21 @@ lib/lean/Init/Data/Subtype.ir lib/lean/Init/Data/Subtype.olean lib/lean/Init/Data/Subtype.olean.private lib/lean/Init/Data/Subtype.olean.server +lib/lean/Init/Data/Subtype/Basic.ilean +lib/lean/Init/Data/Subtype/Basic.ir +lib/lean/Init/Data/Subtype/Basic.olean +lib/lean/Init/Data/Subtype/Basic.olean.private +lib/lean/Init/Data/Subtype/Basic.olean.server +lib/lean/Init/Data/Subtype/Order.ilean +lib/lean/Init/Data/Subtype/Order.ir +lib/lean/Init/Data/Subtype/Order.olean +lib/lean/Init/Data/Subtype/Order.olean.private +lib/lean/Init/Data/Subtype/Order.olean.server +lib/lean/Init/Data/Subtype/OrderExtra.ilean +lib/lean/Init/Data/Subtype/OrderExtra.ir +lib/lean/Init/Data/Subtype/OrderExtra.olean +lib/lean/Init/Data/Subtype/OrderExtra.olean.private +lib/lean/Init/Data/Subtype/OrderExtra.olean.server lib/lean/Init/Data/Sum.ilean lib/lean/Init/Data/Sum.ir lib/lean/Init/Data/Sum.olean @@ -1437,6 +1492,11 @@ lib/lean/Init/Data/Vector.ir lib/lean/Init/Data/Vector.olean lib/lean/Init/Data/Vector.olean.private lib/lean/Init/Data/Vector.olean.server +lib/lean/Init/Data/Vector/Algebra.ilean +lib/lean/Init/Data/Vector/Algebra.ir +lib/lean/Init/Data/Vector/Algebra.olean +lib/lean/Init/Data/Vector/Algebra.olean.private +lib/lean/Init/Data/Vector/Algebra.olean.server lib/lean/Init/Data/Vector/Attach.ilean lib/lean/Init/Data/Vector/Attach.ir lib/lean/Init/Data/Vector/Attach.olean @@ -1902,11 +1962,6 @@ lib/lean/Init/System/IOError.ir lib/lean/Init/System/IOError.olean lib/lean/Init/System/IOError.olean.private lib/lean/Init/System/IOError.olean.server -lib/lean/Init/System/Mutex.ilean -lib/lean/Init/System/Mutex.ir -lib/lean/Init/System/Mutex.olean -lib/lean/Init/System/Mutex.olean.private -lib/lean/Init/System/Mutex.olean.server lib/lean/Init/System/Platform.ilean lib/lean/Init/System/Platform.ir lib/lean/Init/System/Platform.olean @@ -2205,12 +2260,8 @@ lib/lean/Lake/Util/Casing.ilean lib/lean/Lake/Util/Casing.olean lib/lean/Lake/Util/Cli.ilean lib/lean/Lake/Util/Cli.olean -lib/lean/Lake/Util/Compare.ilean -lib/lean/Lake/Util/Compare.olean lib/lean/Lake/Util/Cycle.ilean lib/lean/Lake/Util/Cycle.olean -lib/lean/Lake/Util/DRBMap.ilean -lib/lean/Lake/Util/DRBMap.olean lib/lean/Lake/Util/Date.ilean lib/lean/Lake/Util/Date.olean lib/lean/Lake/Util/EStateT.ilean @@ -2274,2503 +2325,6334 @@ lib/lean/Lake/Version.olean lib/lean/LakeMain.ilean lib/lean/LakeMain.olean lib/lean/Lean.ilean +lib/lean/Lean.ir lib/lean/Lean.olean +lib/lean/Lean.olean.private +lib/lean/Lean.olean.server lib/lean/Lean/AddDecl.ilean +lib/lean/Lean/AddDecl.ir lib/lean/Lean/AddDecl.olean +lib/lean/Lean/AddDecl.olean.private +lib/lean/Lean/AddDecl.olean.server lib/lean/Lean/Attributes.ilean +lib/lean/Lean/Attributes.ir lib/lean/Lean/Attributes.olean +lib/lean/Lean/Attributes.olean.private +lib/lean/Lean/Attributes.olean.server lib/lean/Lean/AuxRecursor.ilean +lib/lean/Lean/AuxRecursor.ir lib/lean/Lean/AuxRecursor.olean +lib/lean/Lean/AuxRecursor.olean.private +lib/lean/Lean/AuxRecursor.olean.server lib/lean/Lean/BuiltinDocAttr.ilean +lib/lean/Lean/BuiltinDocAttr.ir lib/lean/Lean/BuiltinDocAttr.olean +lib/lean/Lean/BuiltinDocAttr.olean.private +lib/lean/Lean/BuiltinDocAttr.olean.server lib/lean/Lean/Class.ilean +lib/lean/Lean/Class.ir lib/lean/Lean/Class.olean +lib/lean/Lean/Class.olean.private +lib/lean/Lean/Class.olean.server lib/lean/Lean/Compiler.ilean +lib/lean/Lean/Compiler.ir lib/lean/Lean/Compiler.olean -lib/lean/Lean/Compiler/AtMostOnce.ilean -lib/lean/Lean/Compiler/AtMostOnce.olean +lib/lean/Lean/Compiler.olean.private +lib/lean/Lean/Compiler.olean.server lib/lean/Lean/Compiler/BorrowedAnnotation.ilean +lib/lean/Lean/Compiler/BorrowedAnnotation.ir lib/lean/Lean/Compiler/BorrowedAnnotation.olean +lib/lean/Lean/Compiler/BorrowedAnnotation.olean.private +lib/lean/Lean/Compiler/BorrowedAnnotation.olean.server lib/lean/Lean/Compiler/CSimpAttr.ilean +lib/lean/Lean/Compiler/CSimpAttr.ir lib/lean/Lean/Compiler/CSimpAttr.olean +lib/lean/Lean/Compiler/CSimpAttr.olean.private +lib/lean/Lean/Compiler/CSimpAttr.olean.server lib/lean/Lean/Compiler/ClosedTermCache.ilean +lib/lean/Lean/Compiler/ClosedTermCache.ir lib/lean/Lean/Compiler/ClosedTermCache.olean -lib/lean/Lean/Compiler/ConstFolding.ilean -lib/lean/Lean/Compiler/ConstFolding.olean +lib/lean/Lean/Compiler/ClosedTermCache.olean.private +lib/lean/Lean/Compiler/ClosedTermCache.olean.server lib/lean/Lean/Compiler/ExportAttr.ilean +lib/lean/Lean/Compiler/ExportAttr.ir lib/lean/Lean/Compiler/ExportAttr.olean +lib/lean/Lean/Compiler/ExportAttr.olean.private +lib/lean/Lean/Compiler/ExportAttr.olean.server lib/lean/Lean/Compiler/ExternAttr.ilean +lib/lean/Lean/Compiler/ExternAttr.ir lib/lean/Lean/Compiler/ExternAttr.olean +lib/lean/Lean/Compiler/ExternAttr.olean.private +lib/lean/Lean/Compiler/ExternAttr.olean.server lib/lean/Lean/Compiler/FFI.ilean +lib/lean/Lean/Compiler/FFI.ir lib/lean/Lean/Compiler/FFI.olean +lib/lean/Lean/Compiler/FFI.olean.private +lib/lean/Lean/Compiler/FFI.olean.server lib/lean/Lean/Compiler/IR.ilean +lib/lean/Lean/Compiler/IR.ir lib/lean/Lean/Compiler/IR.olean +lib/lean/Lean/Compiler/IR.olean.private +lib/lean/Lean/Compiler/IR.olean.server +lib/lean/Lean/Compiler/IR/AddExtern.ilean +lib/lean/Lean/Compiler/IR/AddExtern.ir +lib/lean/Lean/Compiler/IR/AddExtern.olean +lib/lean/Lean/Compiler/IR/AddExtern.olean.private +lib/lean/Lean/Compiler/IR/AddExtern.olean.server lib/lean/Lean/Compiler/IR/Basic.ilean +lib/lean/Lean/Compiler/IR/Basic.ir lib/lean/Lean/Compiler/IR/Basic.olean +lib/lean/Lean/Compiler/IR/Basic.olean.private +lib/lean/Lean/Compiler/IR/Basic.olean.server lib/lean/Lean/Compiler/IR/Borrow.ilean +lib/lean/Lean/Compiler/IR/Borrow.ir lib/lean/Lean/Compiler/IR/Borrow.olean +lib/lean/Lean/Compiler/IR/Borrow.olean.private +lib/lean/Lean/Compiler/IR/Borrow.olean.server lib/lean/Lean/Compiler/IR/Boxing.ilean +lib/lean/Lean/Compiler/IR/Boxing.ir lib/lean/Lean/Compiler/IR/Boxing.olean +lib/lean/Lean/Compiler/IR/Boxing.olean.private +lib/lean/Lean/Compiler/IR/Boxing.olean.server lib/lean/Lean/Compiler/IR/Checker.ilean +lib/lean/Lean/Compiler/IR/Checker.ir lib/lean/Lean/Compiler/IR/Checker.olean +lib/lean/Lean/Compiler/IR/Checker.olean.private +lib/lean/Lean/Compiler/IR/Checker.olean.server lib/lean/Lean/Compiler/IR/CompilerM.ilean +lib/lean/Lean/Compiler/IR/CompilerM.ir lib/lean/Lean/Compiler/IR/CompilerM.olean +lib/lean/Lean/Compiler/IR/CompilerM.olean.private +lib/lean/Lean/Compiler/IR/CompilerM.olean.server lib/lean/Lean/Compiler/IR/ElimDeadBranches.ilean +lib/lean/Lean/Compiler/IR/ElimDeadBranches.ir lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean +lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean.private +lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean.server lib/lean/Lean/Compiler/IR/ElimDeadVars.ilean +lib/lean/Lean/Compiler/IR/ElimDeadVars.ir lib/lean/Lean/Compiler/IR/ElimDeadVars.olean +lib/lean/Lean/Compiler/IR/ElimDeadVars.olean.private +lib/lean/Lean/Compiler/IR/ElimDeadVars.olean.server lib/lean/Lean/Compiler/IR/EmitC.ilean +lib/lean/Lean/Compiler/IR/EmitC.ir lib/lean/Lean/Compiler/IR/EmitC.olean +lib/lean/Lean/Compiler/IR/EmitC.olean.private +lib/lean/Lean/Compiler/IR/EmitC.olean.server lib/lean/Lean/Compiler/IR/EmitLLVM.ilean +lib/lean/Lean/Compiler/IR/EmitLLVM.ir lib/lean/Lean/Compiler/IR/EmitLLVM.olean +lib/lean/Lean/Compiler/IR/EmitLLVM.olean.private +lib/lean/Lean/Compiler/IR/EmitLLVM.olean.server lib/lean/Lean/Compiler/IR/EmitUtil.ilean +lib/lean/Lean/Compiler/IR/EmitUtil.ir lib/lean/Lean/Compiler/IR/EmitUtil.olean +lib/lean/Lean/Compiler/IR/EmitUtil.olean.private +lib/lean/Lean/Compiler/IR/EmitUtil.olean.server lib/lean/Lean/Compiler/IR/ExpandResetReuse.ilean +lib/lean/Lean/Compiler/IR/ExpandResetReuse.ir lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean +lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean.private +lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean.server lib/lean/Lean/Compiler/IR/Format.ilean +lib/lean/Lean/Compiler/IR/Format.ir lib/lean/Lean/Compiler/IR/Format.olean +lib/lean/Lean/Compiler/IR/Format.olean.private +lib/lean/Lean/Compiler/IR/Format.olean.server lib/lean/Lean/Compiler/IR/FreeVars.ilean +lib/lean/Lean/Compiler/IR/FreeVars.ir lib/lean/Lean/Compiler/IR/FreeVars.olean +lib/lean/Lean/Compiler/IR/FreeVars.olean.private +lib/lean/Lean/Compiler/IR/FreeVars.olean.server lib/lean/Lean/Compiler/IR/LLVMBindings.ilean +lib/lean/Lean/Compiler/IR/LLVMBindings.ir lib/lean/Lean/Compiler/IR/LLVMBindings.olean +lib/lean/Lean/Compiler/IR/LLVMBindings.olean.private +lib/lean/Lean/Compiler/IR/LLVMBindings.olean.server lib/lean/Lean/Compiler/IR/LiveVars.ilean +lib/lean/Lean/Compiler/IR/LiveVars.ir lib/lean/Lean/Compiler/IR/LiveVars.olean +lib/lean/Lean/Compiler/IR/LiveVars.olean.private +lib/lean/Lean/Compiler/IR/LiveVars.olean.server +lib/lean/Lean/Compiler/IR/Meta.ilean +lib/lean/Lean/Compiler/IR/Meta.ir +lib/lean/Lean/Compiler/IR/Meta.olean +lib/lean/Lean/Compiler/IR/Meta.olean.private +lib/lean/Lean/Compiler/IR/Meta.olean.server lib/lean/Lean/Compiler/IR/NormIds.ilean +lib/lean/Lean/Compiler/IR/NormIds.ir lib/lean/Lean/Compiler/IR/NormIds.olean +lib/lean/Lean/Compiler/IR/NormIds.olean.private +lib/lean/Lean/Compiler/IR/NormIds.olean.server lib/lean/Lean/Compiler/IR/PushProj.ilean +lib/lean/Lean/Compiler/IR/PushProj.ir lib/lean/Lean/Compiler/IR/PushProj.olean +lib/lean/Lean/Compiler/IR/PushProj.olean.private +lib/lean/Lean/Compiler/IR/PushProj.olean.server lib/lean/Lean/Compiler/IR/RC.ilean +lib/lean/Lean/Compiler/IR/RC.ir lib/lean/Lean/Compiler/IR/RC.olean +lib/lean/Lean/Compiler/IR/RC.olean.private +lib/lean/Lean/Compiler/IR/RC.olean.server lib/lean/Lean/Compiler/IR/ResetReuse.ilean +lib/lean/Lean/Compiler/IR/ResetReuse.ir lib/lean/Lean/Compiler/IR/ResetReuse.olean +lib/lean/Lean/Compiler/IR/ResetReuse.olean.private +lib/lean/Lean/Compiler/IR/ResetReuse.olean.server lib/lean/Lean/Compiler/IR/SimpCase.ilean +lib/lean/Lean/Compiler/IR/SimpCase.ir lib/lean/Lean/Compiler/IR/SimpCase.olean +lib/lean/Lean/Compiler/IR/SimpCase.olean.private +lib/lean/Lean/Compiler/IR/SimpCase.olean.server lib/lean/Lean/Compiler/IR/Sorry.ilean +lib/lean/Lean/Compiler/IR/Sorry.ir lib/lean/Lean/Compiler/IR/Sorry.olean +lib/lean/Lean/Compiler/IR/Sorry.olean.private +lib/lean/Lean/Compiler/IR/Sorry.olean.server lib/lean/Lean/Compiler/IR/ToIR.ilean +lib/lean/Lean/Compiler/IR/ToIR.ir lib/lean/Lean/Compiler/IR/ToIR.olean +lib/lean/Lean/Compiler/IR/ToIR.olean.private +lib/lean/Lean/Compiler/IR/ToIR.olean.server lib/lean/Lean/Compiler/IR/ToIRType.ilean +lib/lean/Lean/Compiler/IR/ToIRType.ir lib/lean/Lean/Compiler/IR/ToIRType.olean +lib/lean/Lean/Compiler/IR/ToIRType.olean.private +lib/lean/Lean/Compiler/IR/ToIRType.olean.server lib/lean/Lean/Compiler/IR/UnboxResult.ilean +lib/lean/Lean/Compiler/IR/UnboxResult.ir lib/lean/Lean/Compiler/IR/UnboxResult.olean +lib/lean/Lean/Compiler/IR/UnboxResult.olean.private +lib/lean/Lean/Compiler/IR/UnboxResult.olean.server lib/lean/Lean/Compiler/ImplementedByAttr.ilean +lib/lean/Lean/Compiler/ImplementedByAttr.ir lib/lean/Lean/Compiler/ImplementedByAttr.olean +lib/lean/Lean/Compiler/ImplementedByAttr.olean.private +lib/lean/Lean/Compiler/ImplementedByAttr.olean.server lib/lean/Lean/Compiler/InitAttr.ilean +lib/lean/Lean/Compiler/InitAttr.ir lib/lean/Lean/Compiler/InitAttr.olean +lib/lean/Lean/Compiler/InitAttr.olean.private +lib/lean/Lean/Compiler/InitAttr.olean.server lib/lean/Lean/Compiler/InlineAttrs.ilean +lib/lean/Lean/Compiler/InlineAttrs.ir lib/lean/Lean/Compiler/InlineAttrs.olean +lib/lean/Lean/Compiler/InlineAttrs.olean.private +lib/lean/Lean/Compiler/InlineAttrs.olean.server lib/lean/Lean/Compiler/LCNF.ilean +lib/lean/Lean/Compiler/LCNF.ir lib/lean/Lean/Compiler/LCNF.olean +lib/lean/Lean/Compiler/LCNF.olean.private +lib/lean/Lean/Compiler/LCNF.olean.server lib/lean/Lean/Compiler/LCNF/AlphaEqv.ilean +lib/lean/Lean/Compiler/LCNF/AlphaEqv.ir lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean +lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean.private +lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean.server lib/lean/Lean/Compiler/LCNF/AuxDeclCache.ilean +lib/lean/Lean/Compiler/LCNF/AuxDeclCache.ir lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean +lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean.private +lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean.server lib/lean/Lean/Compiler/LCNF/BaseTypes.ilean +lib/lean/Lean/Compiler/LCNF/BaseTypes.ir lib/lean/Lean/Compiler/LCNF/BaseTypes.olean +lib/lean/Lean/Compiler/LCNF/BaseTypes.olean.private +lib/lean/Lean/Compiler/LCNF/BaseTypes.olean.server lib/lean/Lean/Compiler/LCNF/Basic.ilean +lib/lean/Lean/Compiler/LCNF/Basic.ir lib/lean/Lean/Compiler/LCNF/Basic.olean +lib/lean/Lean/Compiler/LCNF/Basic.olean.private +lib/lean/Lean/Compiler/LCNF/Basic.olean.server lib/lean/Lean/Compiler/LCNF/Bind.ilean +lib/lean/Lean/Compiler/LCNF/Bind.ir lib/lean/Lean/Compiler/LCNF/Bind.olean +lib/lean/Lean/Compiler/LCNF/Bind.olean.private +lib/lean/Lean/Compiler/LCNF/Bind.olean.server lib/lean/Lean/Compiler/LCNF/CSE.ilean +lib/lean/Lean/Compiler/LCNF/CSE.ir lib/lean/Lean/Compiler/LCNF/CSE.olean +lib/lean/Lean/Compiler/LCNF/CSE.olean.private +lib/lean/Lean/Compiler/LCNF/CSE.olean.server lib/lean/Lean/Compiler/LCNF/Check.ilean +lib/lean/Lean/Compiler/LCNF/Check.ir lib/lean/Lean/Compiler/LCNF/Check.olean +lib/lean/Lean/Compiler/LCNF/Check.olean.private +lib/lean/Lean/Compiler/LCNF/Check.olean.server lib/lean/Lean/Compiler/LCNF/Closure.ilean +lib/lean/Lean/Compiler/LCNF/Closure.ir lib/lean/Lean/Compiler/LCNF/Closure.olean +lib/lean/Lean/Compiler/LCNF/Closure.olean.private +lib/lean/Lean/Compiler/LCNF/Closure.olean.server lib/lean/Lean/Compiler/LCNF/CompatibleTypes.ilean +lib/lean/Lean/Compiler/LCNF/CompatibleTypes.ir lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean +lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean.private +lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean.server lib/lean/Lean/Compiler/LCNF/CompilerM.ilean +lib/lean/Lean/Compiler/LCNF/CompilerM.ir lib/lean/Lean/Compiler/LCNF/CompilerM.olean +lib/lean/Lean/Compiler/LCNF/CompilerM.olean.private +lib/lean/Lean/Compiler/LCNF/CompilerM.olean.server lib/lean/Lean/Compiler/LCNF/ConfigOptions.ilean +lib/lean/Lean/Compiler/LCNF/ConfigOptions.ir lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean +lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean.private +lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean.server lib/lean/Lean/Compiler/LCNF/DeclHash.ilean +lib/lean/Lean/Compiler/LCNF/DeclHash.ir lib/lean/Lean/Compiler/LCNF/DeclHash.olean +lib/lean/Lean/Compiler/LCNF/DeclHash.olean.private +lib/lean/Lean/Compiler/LCNF/DeclHash.olean.server lib/lean/Lean/Compiler/LCNF/DependsOn.ilean +lib/lean/Lean/Compiler/LCNF/DependsOn.ir lib/lean/Lean/Compiler/LCNF/DependsOn.olean +lib/lean/Lean/Compiler/LCNF/DependsOn.olean.private +lib/lean/Lean/Compiler/LCNF/DependsOn.olean.server lib/lean/Lean/Compiler/LCNF/ElimDead.ilean +lib/lean/Lean/Compiler/LCNF/ElimDead.ir lib/lean/Lean/Compiler/LCNF/ElimDead.olean +lib/lean/Lean/Compiler/LCNF/ElimDead.olean.private +lib/lean/Lean/Compiler/LCNF/ElimDead.olean.server lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.ilean +lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.ir lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean +lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean.private +lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean.server lib/lean/Lean/Compiler/LCNF/ExtractClosed.ilean +lib/lean/Lean/Compiler/LCNF/ExtractClosed.ir lib/lean/Lean/Compiler/LCNF/ExtractClosed.olean +lib/lean/Lean/Compiler/LCNF/ExtractClosed.olean.private +lib/lean/Lean/Compiler/LCNF/ExtractClosed.olean.server lib/lean/Lean/Compiler/LCNF/FVarUtil.ilean +lib/lean/Lean/Compiler/LCNF/FVarUtil.ir lib/lean/Lean/Compiler/LCNF/FVarUtil.olean +lib/lean/Lean/Compiler/LCNF/FVarUtil.olean.private +lib/lean/Lean/Compiler/LCNF/FVarUtil.olean.server lib/lean/Lean/Compiler/LCNF/FixedParams.ilean +lib/lean/Lean/Compiler/LCNF/FixedParams.ir lib/lean/Lean/Compiler/LCNF/FixedParams.olean +lib/lean/Lean/Compiler/LCNF/FixedParams.olean.private +lib/lean/Lean/Compiler/LCNF/FixedParams.olean.server lib/lean/Lean/Compiler/LCNF/FloatLetIn.ilean +lib/lean/Lean/Compiler/LCNF/FloatLetIn.ir lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean +lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean.private +lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean.server lib/lean/Lean/Compiler/LCNF/InferType.ilean +lib/lean/Lean/Compiler/LCNF/InferType.ir lib/lean/Lean/Compiler/LCNF/InferType.olean +lib/lean/Lean/Compiler/LCNF/InferType.olean.private +lib/lean/Lean/Compiler/LCNF/InferType.olean.server lib/lean/Lean/Compiler/LCNF/Internalize.ilean +lib/lean/Lean/Compiler/LCNF/Internalize.ir lib/lean/Lean/Compiler/LCNF/Internalize.olean +lib/lean/Lean/Compiler/LCNF/Internalize.olean.private +lib/lean/Lean/Compiler/LCNF/Internalize.olean.server lib/lean/Lean/Compiler/LCNF/JoinPoints.ilean +lib/lean/Lean/Compiler/LCNF/JoinPoints.ir lib/lean/Lean/Compiler/LCNF/JoinPoints.olean +lib/lean/Lean/Compiler/LCNF/JoinPoints.olean.private +lib/lean/Lean/Compiler/LCNF/JoinPoints.olean.server lib/lean/Lean/Compiler/LCNF/LCtx.ilean +lib/lean/Lean/Compiler/LCNF/LCtx.ir lib/lean/Lean/Compiler/LCNF/LCtx.olean +lib/lean/Lean/Compiler/LCNF/LCtx.olean.private +lib/lean/Lean/Compiler/LCNF/LCtx.olean.server lib/lean/Lean/Compiler/LCNF/LambdaLifting.ilean +lib/lean/Lean/Compiler/LCNF/LambdaLifting.ir lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean +lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean.private +lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean.server lib/lean/Lean/Compiler/LCNF/Level.ilean +lib/lean/Lean/Compiler/LCNF/Level.ir lib/lean/Lean/Compiler/LCNF/Level.olean +lib/lean/Lean/Compiler/LCNF/Level.olean.private +lib/lean/Lean/Compiler/LCNF/Level.olean.server lib/lean/Lean/Compiler/LCNF/Main.ilean +lib/lean/Lean/Compiler/LCNF/Main.ir lib/lean/Lean/Compiler/LCNF/Main.olean +lib/lean/Lean/Compiler/LCNF/Main.olean.private +lib/lean/Lean/Compiler/LCNF/Main.olean.server lib/lean/Lean/Compiler/LCNF/MonadScope.ilean +lib/lean/Lean/Compiler/LCNF/MonadScope.ir lib/lean/Lean/Compiler/LCNF/MonadScope.olean +lib/lean/Lean/Compiler/LCNF/MonadScope.olean.private +lib/lean/Lean/Compiler/LCNF/MonadScope.olean.server lib/lean/Lean/Compiler/LCNF/MonoTypes.ilean +lib/lean/Lean/Compiler/LCNF/MonoTypes.ir lib/lean/Lean/Compiler/LCNF/MonoTypes.olean +lib/lean/Lean/Compiler/LCNF/MonoTypes.olean.private +lib/lean/Lean/Compiler/LCNF/MonoTypes.olean.server lib/lean/Lean/Compiler/LCNF/OtherDecl.ilean +lib/lean/Lean/Compiler/LCNF/OtherDecl.ir lib/lean/Lean/Compiler/LCNF/OtherDecl.olean +lib/lean/Lean/Compiler/LCNF/OtherDecl.olean.private +lib/lean/Lean/Compiler/LCNF/OtherDecl.olean.server lib/lean/Lean/Compiler/LCNF/PassManager.ilean +lib/lean/Lean/Compiler/LCNF/PassManager.ir lib/lean/Lean/Compiler/LCNF/PassManager.olean +lib/lean/Lean/Compiler/LCNF/PassManager.olean.private +lib/lean/Lean/Compiler/LCNF/PassManager.olean.server lib/lean/Lean/Compiler/LCNF/Passes.ilean +lib/lean/Lean/Compiler/LCNF/Passes.ir lib/lean/Lean/Compiler/LCNF/Passes.olean +lib/lean/Lean/Compiler/LCNF/Passes.olean.private +lib/lean/Lean/Compiler/LCNF/Passes.olean.server lib/lean/Lean/Compiler/LCNF/PhaseExt.ilean +lib/lean/Lean/Compiler/LCNF/PhaseExt.ir lib/lean/Lean/Compiler/LCNF/PhaseExt.olean +lib/lean/Lean/Compiler/LCNF/PhaseExt.olean.private +lib/lean/Lean/Compiler/LCNF/PhaseExt.olean.server lib/lean/Lean/Compiler/LCNF/PrettyPrinter.ilean +lib/lean/Lean/Compiler/LCNF/PrettyPrinter.ir lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean +lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean.private +lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean.server lib/lean/Lean/Compiler/LCNF/Probing.ilean +lib/lean/Lean/Compiler/LCNF/Probing.ir lib/lean/Lean/Compiler/LCNF/Probing.olean +lib/lean/Lean/Compiler/LCNF/Probing.olean.private +lib/lean/Lean/Compiler/LCNF/Probing.olean.server lib/lean/Lean/Compiler/LCNF/PullFunDecls.ilean +lib/lean/Lean/Compiler/LCNF/PullFunDecls.ir lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean +lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean.private +lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean.server lib/lean/Lean/Compiler/LCNF/PullLetDecls.ilean +lib/lean/Lean/Compiler/LCNF/PullLetDecls.ir lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean +lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean.private +lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean.server lib/lean/Lean/Compiler/LCNF/ReduceArity.ilean +lib/lean/Lean/Compiler/LCNF/ReduceArity.ir lib/lean/Lean/Compiler/LCNF/ReduceArity.olean +lib/lean/Lean/Compiler/LCNF/ReduceArity.olean.private +lib/lean/Lean/Compiler/LCNF/ReduceArity.olean.server lib/lean/Lean/Compiler/LCNF/ReduceJpArity.ilean +lib/lean/Lean/Compiler/LCNF/ReduceJpArity.ir lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean +lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean.private +lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean.server lib/lean/Lean/Compiler/LCNF/Renaming.ilean +lib/lean/Lean/Compiler/LCNF/Renaming.ir lib/lean/Lean/Compiler/LCNF/Renaming.olean +lib/lean/Lean/Compiler/LCNF/Renaming.olean.private +lib/lean/Lean/Compiler/LCNF/Renaming.olean.server lib/lean/Lean/Compiler/LCNF/ScopeM.ilean +lib/lean/Lean/Compiler/LCNF/ScopeM.ir lib/lean/Lean/Compiler/LCNF/ScopeM.olean +lib/lean/Lean/Compiler/LCNF/ScopeM.olean.private +lib/lean/Lean/Compiler/LCNF/ScopeM.olean.server lib/lean/Lean/Compiler/LCNF/Simp.ilean +lib/lean/Lean/Compiler/LCNF/Simp.ir lib/lean/Lean/Compiler/LCNF/Simp.olean +lib/lean/Lean/Compiler/LCNF/Simp.olean.private +lib/lean/Lean/Compiler/LCNF/Simp.olean.server lib/lean/Lean/Compiler/LCNF/Simp/Basic.ilean +lib/lean/Lean/Compiler/LCNF/Simp/Basic.ir lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean +lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean.server lib/lean/Lean/Compiler/LCNF/Simp/Config.ilean +lib/lean/Lean/Compiler/LCNF/Simp/Config.ir lib/lean/Lean/Compiler/LCNF/Simp/Config.olean +lib/lean/Lean/Compiler/LCNF/Simp/Config.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/Config.olean.server lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.ilean +lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.ir lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean +lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean.server lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.ilean +lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.ir lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean +lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean.server lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.ilean +lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.ir lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean +lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean.server lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.ilean +lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.ir lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean +lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean.server lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.ilean +lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.ir lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean +lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean.server lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.ilean +lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.ir lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean +lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean.server lib/lean/Lean/Compiler/LCNF/Simp/JpCases.ilean +lib/lean/Lean/Compiler/LCNF/Simp/JpCases.ir lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean +lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean.server lib/lean/Lean/Compiler/LCNF/Simp/Main.ilean +lib/lean/Lean/Compiler/LCNF/Simp/Main.ir lib/lean/Lean/Compiler/LCNF/Simp/Main.olean +lib/lean/Lean/Compiler/LCNF/Simp/Main.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/Main.olean.server lib/lean/Lean/Compiler/LCNF/Simp/SimpM.ilean +lib/lean/Lean/Compiler/LCNF/Simp/SimpM.ir lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean +lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean.server lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.ilean +lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.ir lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean +lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean.server lib/lean/Lean/Compiler/LCNF/Simp/Used.ilean +lib/lean/Lean/Compiler/LCNF/Simp/Used.ir lib/lean/Lean/Compiler/LCNF/Simp/Used.olean +lib/lean/Lean/Compiler/LCNF/Simp/Used.olean.private +lib/lean/Lean/Compiler/LCNF/Simp/Used.olean.server lib/lean/Lean/Compiler/LCNF/SpecInfo.ilean +lib/lean/Lean/Compiler/LCNF/SpecInfo.ir lib/lean/Lean/Compiler/LCNF/SpecInfo.olean +lib/lean/Lean/Compiler/LCNF/SpecInfo.olean.private +lib/lean/Lean/Compiler/LCNF/SpecInfo.olean.server lib/lean/Lean/Compiler/LCNF/Specialize.ilean +lib/lean/Lean/Compiler/LCNF/Specialize.ir lib/lean/Lean/Compiler/LCNF/Specialize.olean +lib/lean/Lean/Compiler/LCNF/Specialize.olean.private +lib/lean/Lean/Compiler/LCNF/Specialize.olean.server lib/lean/Lean/Compiler/LCNF/StructProjCases.ilean +lib/lean/Lean/Compiler/LCNF/StructProjCases.ir lib/lean/Lean/Compiler/LCNF/StructProjCases.olean +lib/lean/Lean/Compiler/LCNF/StructProjCases.olean.private +lib/lean/Lean/Compiler/LCNF/StructProjCases.olean.server lib/lean/Lean/Compiler/LCNF/Testing.ilean +lib/lean/Lean/Compiler/LCNF/Testing.ir lib/lean/Lean/Compiler/LCNF/Testing.olean +lib/lean/Lean/Compiler/LCNF/Testing.olean.private +lib/lean/Lean/Compiler/LCNF/Testing.olean.server lib/lean/Lean/Compiler/LCNF/ToDecl.ilean +lib/lean/Lean/Compiler/LCNF/ToDecl.ir lib/lean/Lean/Compiler/LCNF/ToDecl.olean +lib/lean/Lean/Compiler/LCNF/ToDecl.olean.private +lib/lean/Lean/Compiler/LCNF/ToDecl.olean.server lib/lean/Lean/Compiler/LCNF/ToExpr.ilean +lib/lean/Lean/Compiler/LCNF/ToExpr.ir lib/lean/Lean/Compiler/LCNF/ToExpr.olean +lib/lean/Lean/Compiler/LCNF/ToExpr.olean.private +lib/lean/Lean/Compiler/LCNF/ToExpr.olean.server lib/lean/Lean/Compiler/LCNF/ToLCNF.ilean +lib/lean/Lean/Compiler/LCNF/ToLCNF.ir lib/lean/Lean/Compiler/LCNF/ToLCNF.olean +lib/lean/Lean/Compiler/LCNF/ToLCNF.olean.private +lib/lean/Lean/Compiler/LCNF/ToLCNF.olean.server lib/lean/Lean/Compiler/LCNF/ToMono.ilean +lib/lean/Lean/Compiler/LCNF/ToMono.ir lib/lean/Lean/Compiler/LCNF/ToMono.olean +lib/lean/Lean/Compiler/LCNF/ToMono.olean.private +lib/lean/Lean/Compiler/LCNF/ToMono.olean.server lib/lean/Lean/Compiler/LCNF/Types.ilean +lib/lean/Lean/Compiler/LCNF/Types.ir lib/lean/Lean/Compiler/LCNF/Types.olean +lib/lean/Lean/Compiler/LCNF/Types.olean.private +lib/lean/Lean/Compiler/LCNF/Types.olean.server lib/lean/Lean/Compiler/LCNF/Util.ilean +lib/lean/Lean/Compiler/LCNF/Util.ir lib/lean/Lean/Compiler/LCNF/Util.olean +lib/lean/Lean/Compiler/LCNF/Util.olean.private +lib/lean/Lean/Compiler/LCNF/Util.olean.server +lib/lean/Lean/Compiler/LCNF/Visibility.ilean +lib/lean/Lean/Compiler/LCNF/Visibility.ir +lib/lean/Lean/Compiler/LCNF/Visibility.olean +lib/lean/Lean/Compiler/LCNF/Visibility.olean.private +lib/lean/Lean/Compiler/LCNF/Visibility.olean.server lib/lean/Lean/Compiler/Main.ilean +lib/lean/Lean/Compiler/Main.ir lib/lean/Lean/Compiler/Main.olean +lib/lean/Lean/Compiler/Main.olean.private +lib/lean/Lean/Compiler/Main.olean.server lib/lean/Lean/Compiler/MetaAttr.ilean +lib/lean/Lean/Compiler/MetaAttr.ir lib/lean/Lean/Compiler/MetaAttr.olean +lib/lean/Lean/Compiler/MetaAttr.olean.private +lib/lean/Lean/Compiler/MetaAttr.olean.server lib/lean/Lean/Compiler/NameMangling.ilean +lib/lean/Lean/Compiler/NameMangling.ir lib/lean/Lean/Compiler/NameMangling.olean +lib/lean/Lean/Compiler/NameMangling.olean.private +lib/lean/Lean/Compiler/NameMangling.olean.server lib/lean/Lean/Compiler/NeverExtractAttr.ilean +lib/lean/Lean/Compiler/NeverExtractAttr.ir lib/lean/Lean/Compiler/NeverExtractAttr.olean +lib/lean/Lean/Compiler/NeverExtractAttr.olean.private +lib/lean/Lean/Compiler/NeverExtractAttr.olean.server lib/lean/Lean/Compiler/NoncomputableAttr.ilean +lib/lean/Lean/Compiler/NoncomputableAttr.ir lib/lean/Lean/Compiler/NoncomputableAttr.olean +lib/lean/Lean/Compiler/NoncomputableAttr.olean.private +lib/lean/Lean/Compiler/NoncomputableAttr.olean.server lib/lean/Lean/Compiler/Old.ilean +lib/lean/Lean/Compiler/Old.ir lib/lean/Lean/Compiler/Old.olean +lib/lean/Lean/Compiler/Old.olean.private +lib/lean/Lean/Compiler/Old.olean.server lib/lean/Lean/Compiler/Options.ilean +lib/lean/Lean/Compiler/Options.ir lib/lean/Lean/Compiler/Options.olean +lib/lean/Lean/Compiler/Options.olean.private +lib/lean/Lean/Compiler/Options.olean.server lib/lean/Lean/Compiler/Specialize.ilean +lib/lean/Lean/Compiler/Specialize.ir lib/lean/Lean/Compiler/Specialize.olean +lib/lean/Lean/Compiler/Specialize.olean.private +lib/lean/Lean/Compiler/Specialize.olean.server lib/lean/Lean/CoreM.ilean +lib/lean/Lean/CoreM.ir lib/lean/Lean/CoreM.olean +lib/lean/Lean/CoreM.olean.private +lib/lean/Lean/CoreM.olean.server lib/lean/Lean/Data.ilean +lib/lean/Lean/Data.ir lib/lean/Lean/Data.olean +lib/lean/Lean/Data.olean.private +lib/lean/Lean/Data.olean.server lib/lean/Lean/Data/Array.ilean +lib/lean/Lean/Data/Array.ir lib/lean/Lean/Data/Array.olean +lib/lean/Lean/Data/Array.olean.private +lib/lean/Lean/Data/Array.olean.server lib/lean/Lean/Data/AssocList.ilean +lib/lean/Lean/Data/AssocList.ir lib/lean/Lean/Data/AssocList.olean +lib/lean/Lean/Data/AssocList.olean.private +lib/lean/Lean/Data/AssocList.olean.server lib/lean/Lean/Data/DeclarationRange.ilean +lib/lean/Lean/Data/DeclarationRange.ir lib/lean/Lean/Data/DeclarationRange.olean +lib/lean/Lean/Data/DeclarationRange.olean.private +lib/lean/Lean/Data/DeclarationRange.olean.server lib/lean/Lean/Data/Format.ilean +lib/lean/Lean/Data/Format.ir lib/lean/Lean/Data/Format.olean +lib/lean/Lean/Data/Format.olean.private +lib/lean/Lean/Data/Format.olean.server lib/lean/Lean/Data/FuzzyMatching.ilean +lib/lean/Lean/Data/FuzzyMatching.ir lib/lean/Lean/Data/FuzzyMatching.olean +lib/lean/Lean/Data/FuzzyMatching.olean.private +lib/lean/Lean/Data/FuzzyMatching.olean.server lib/lean/Lean/Data/Json.ilean +lib/lean/Lean/Data/Json.ir lib/lean/Lean/Data/Json.olean +lib/lean/Lean/Data/Json.olean.private +lib/lean/Lean/Data/Json.olean.server lib/lean/Lean/Data/Json/Basic.ilean +lib/lean/Lean/Data/Json/Basic.ir lib/lean/Lean/Data/Json/Basic.olean +lib/lean/Lean/Data/Json/Basic.olean.private +lib/lean/Lean/Data/Json/Basic.olean.server lib/lean/Lean/Data/Json/Elab.ilean +lib/lean/Lean/Data/Json/Elab.ir lib/lean/Lean/Data/Json/Elab.olean +lib/lean/Lean/Data/Json/Elab.olean.private +lib/lean/Lean/Data/Json/Elab.olean.server lib/lean/Lean/Data/Json/FromToJson.ilean +lib/lean/Lean/Data/Json/FromToJson.ir lib/lean/Lean/Data/Json/FromToJson.olean +lib/lean/Lean/Data/Json/FromToJson.olean.private +lib/lean/Lean/Data/Json/FromToJson.olean.server +lib/lean/Lean/Data/Json/FromToJson/Basic.ilean +lib/lean/Lean/Data/Json/FromToJson/Basic.ir +lib/lean/Lean/Data/Json/FromToJson/Basic.olean +lib/lean/Lean/Data/Json/FromToJson/Basic.olean.private +lib/lean/Lean/Data/Json/FromToJson/Basic.olean.server +lib/lean/Lean/Data/Json/FromToJson/Extra.ilean +lib/lean/Lean/Data/Json/FromToJson/Extra.ir +lib/lean/Lean/Data/Json/FromToJson/Extra.olean +lib/lean/Lean/Data/Json/FromToJson/Extra.olean.private +lib/lean/Lean/Data/Json/FromToJson/Extra.olean.server lib/lean/Lean/Data/Json/Parser.ilean +lib/lean/Lean/Data/Json/Parser.ir lib/lean/Lean/Data/Json/Parser.olean +lib/lean/Lean/Data/Json/Parser.olean.private +lib/lean/Lean/Data/Json/Parser.olean.server lib/lean/Lean/Data/Json/Printer.ilean +lib/lean/Lean/Data/Json/Printer.ir lib/lean/Lean/Data/Json/Printer.olean +lib/lean/Lean/Data/Json/Printer.olean.private +lib/lean/Lean/Data/Json/Printer.olean.server lib/lean/Lean/Data/Json/Stream.ilean +lib/lean/Lean/Data/Json/Stream.ir lib/lean/Lean/Data/Json/Stream.olean +lib/lean/Lean/Data/Json/Stream.olean.private +lib/lean/Lean/Data/Json/Stream.olean.server lib/lean/Lean/Data/JsonRpc.ilean +lib/lean/Lean/Data/JsonRpc.ir lib/lean/Lean/Data/JsonRpc.olean +lib/lean/Lean/Data/JsonRpc.olean.private +lib/lean/Lean/Data/JsonRpc.olean.server lib/lean/Lean/Data/KVMap.ilean +lib/lean/Lean/Data/KVMap.ir lib/lean/Lean/Data/KVMap.olean +lib/lean/Lean/Data/KVMap.olean.private +lib/lean/Lean/Data/KVMap.olean.server lib/lean/Lean/Data/LBool.ilean +lib/lean/Lean/Data/LBool.ir lib/lean/Lean/Data/LBool.olean +lib/lean/Lean/Data/LBool.olean.private +lib/lean/Lean/Data/LBool.olean.server lib/lean/Lean/Data/LOption.ilean +lib/lean/Lean/Data/LOption.ir lib/lean/Lean/Data/LOption.olean +lib/lean/Lean/Data/LOption.olean.private +lib/lean/Lean/Data/LOption.olean.server lib/lean/Lean/Data/Lsp.ilean +lib/lean/Lean/Data/Lsp.ir lib/lean/Lean/Data/Lsp.olean +lib/lean/Lean/Data/Lsp.olean.private +lib/lean/Lean/Data/Lsp.olean.server lib/lean/Lean/Data/Lsp/Basic.ilean +lib/lean/Lean/Data/Lsp/Basic.ir lib/lean/Lean/Data/Lsp/Basic.olean +lib/lean/Lean/Data/Lsp/Basic.olean.private +lib/lean/Lean/Data/Lsp/Basic.olean.server +lib/lean/Lean/Data/Lsp/BasicAux.ilean +lib/lean/Lean/Data/Lsp/BasicAux.ir +lib/lean/Lean/Data/Lsp/BasicAux.olean +lib/lean/Lean/Data/Lsp/BasicAux.olean.private +lib/lean/Lean/Data/Lsp/BasicAux.olean.server lib/lean/Lean/Data/Lsp/CancelParams.ilean +lib/lean/Lean/Data/Lsp/CancelParams.ir lib/lean/Lean/Data/Lsp/CancelParams.olean +lib/lean/Lean/Data/Lsp/CancelParams.olean.private +lib/lean/Lean/Data/Lsp/CancelParams.olean.server lib/lean/Lean/Data/Lsp/Capabilities.ilean +lib/lean/Lean/Data/Lsp/Capabilities.ir lib/lean/Lean/Data/Lsp/Capabilities.olean +lib/lean/Lean/Data/Lsp/Capabilities.olean.private +lib/lean/Lean/Data/Lsp/Capabilities.olean.server lib/lean/Lean/Data/Lsp/Client.ilean +lib/lean/Lean/Data/Lsp/Client.ir lib/lean/Lean/Data/Lsp/Client.olean +lib/lean/Lean/Data/Lsp/Client.olean.private +lib/lean/Lean/Data/Lsp/Client.olean.server lib/lean/Lean/Data/Lsp/CodeActions.ilean +lib/lean/Lean/Data/Lsp/CodeActions.ir lib/lean/Lean/Data/Lsp/CodeActions.olean +lib/lean/Lean/Data/Lsp/CodeActions.olean.private +lib/lean/Lean/Data/Lsp/CodeActions.olean.server lib/lean/Lean/Data/Lsp/Communication.ilean +lib/lean/Lean/Data/Lsp/Communication.ir lib/lean/Lean/Data/Lsp/Communication.olean +lib/lean/Lean/Data/Lsp/Communication.olean.private +lib/lean/Lean/Data/Lsp/Communication.olean.server lib/lean/Lean/Data/Lsp/Diagnostics.ilean +lib/lean/Lean/Data/Lsp/Diagnostics.ir lib/lean/Lean/Data/Lsp/Diagnostics.olean +lib/lean/Lean/Data/Lsp/Diagnostics.olean.private +lib/lean/Lean/Data/Lsp/Diagnostics.olean.server lib/lean/Lean/Data/Lsp/Extra.ilean +lib/lean/Lean/Data/Lsp/Extra.ir lib/lean/Lean/Data/Lsp/Extra.olean +lib/lean/Lean/Data/Lsp/Extra.olean.private +lib/lean/Lean/Data/Lsp/Extra.olean.server lib/lean/Lean/Data/Lsp/InitShutdown.ilean +lib/lean/Lean/Data/Lsp/InitShutdown.ir lib/lean/Lean/Data/Lsp/InitShutdown.olean +lib/lean/Lean/Data/Lsp/InitShutdown.olean.private +lib/lean/Lean/Data/Lsp/InitShutdown.olean.server lib/lean/Lean/Data/Lsp/Internal.ilean +lib/lean/Lean/Data/Lsp/Internal.ir lib/lean/Lean/Data/Lsp/Internal.olean +lib/lean/Lean/Data/Lsp/Internal.olean.private +lib/lean/Lean/Data/Lsp/Internal.olean.server lib/lean/Lean/Data/Lsp/Ipc.ilean +lib/lean/Lean/Data/Lsp/Ipc.ir lib/lean/Lean/Data/Lsp/Ipc.olean +lib/lean/Lean/Data/Lsp/Ipc.olean.private +lib/lean/Lean/Data/Lsp/Ipc.olean.server lib/lean/Lean/Data/Lsp/LanguageFeatures.ilean +lib/lean/Lean/Data/Lsp/LanguageFeatures.ir lib/lean/Lean/Data/Lsp/LanguageFeatures.olean +lib/lean/Lean/Data/Lsp/LanguageFeatures.olean.private +lib/lean/Lean/Data/Lsp/LanguageFeatures.olean.server lib/lean/Lean/Data/Lsp/TextSync.ilean +lib/lean/Lean/Data/Lsp/TextSync.ir lib/lean/Lean/Data/Lsp/TextSync.olean +lib/lean/Lean/Data/Lsp/TextSync.olean.private +lib/lean/Lean/Data/Lsp/TextSync.olean.server lib/lean/Lean/Data/Lsp/Utf16.ilean +lib/lean/Lean/Data/Lsp/Utf16.ir lib/lean/Lean/Data/Lsp/Utf16.olean +lib/lean/Lean/Data/Lsp/Utf16.olean.private +lib/lean/Lean/Data/Lsp/Utf16.olean.server lib/lean/Lean/Data/Lsp/Window.ilean +lib/lean/Lean/Data/Lsp/Window.ir lib/lean/Lean/Data/Lsp/Window.olean +lib/lean/Lean/Data/Lsp/Window.olean.private +lib/lean/Lean/Data/Lsp/Window.olean.server lib/lean/Lean/Data/Lsp/Workspace.ilean +lib/lean/Lean/Data/Lsp/Workspace.ir lib/lean/Lean/Data/Lsp/Workspace.olean +lib/lean/Lean/Data/Lsp/Workspace.olean.private +lib/lean/Lean/Data/Lsp/Workspace.olean.server lib/lean/Lean/Data/Name.ilean +lib/lean/Lean/Data/Name.ir lib/lean/Lean/Data/Name.olean +lib/lean/Lean/Data/Name.olean.private +lib/lean/Lean/Data/Name.olean.server lib/lean/Lean/Data/NameMap.ilean +lib/lean/Lean/Data/NameMap.ir lib/lean/Lean/Data/NameMap.olean +lib/lean/Lean/Data/NameMap.olean.private +lib/lean/Lean/Data/NameMap.olean.server +lib/lean/Lean/Data/NameMap/AdditionalOperations.ilean +lib/lean/Lean/Data/NameMap/AdditionalOperations.ir +lib/lean/Lean/Data/NameMap/AdditionalOperations.olean +lib/lean/Lean/Data/NameMap/AdditionalOperations.olean.private +lib/lean/Lean/Data/NameMap/AdditionalOperations.olean.server +lib/lean/Lean/Data/NameMap/Basic.ilean +lib/lean/Lean/Data/NameMap/Basic.ir +lib/lean/Lean/Data/NameMap/Basic.olean +lib/lean/Lean/Data/NameMap/Basic.olean.private +lib/lean/Lean/Data/NameMap/Basic.olean.server lib/lean/Lean/Data/NameTrie.ilean +lib/lean/Lean/Data/NameTrie.ir lib/lean/Lean/Data/NameTrie.olean +lib/lean/Lean/Data/NameTrie.olean.private +lib/lean/Lean/Data/NameTrie.olean.server lib/lean/Lean/Data/OpenDecl.ilean +lib/lean/Lean/Data/OpenDecl.ir lib/lean/Lean/Data/OpenDecl.olean +lib/lean/Lean/Data/OpenDecl.olean.private +lib/lean/Lean/Data/OpenDecl.olean.server lib/lean/Lean/Data/Options.ilean +lib/lean/Lean/Data/Options.ir lib/lean/Lean/Data/Options.olean +lib/lean/Lean/Data/Options.olean.private +lib/lean/Lean/Data/Options.olean.server lib/lean/Lean/Data/PersistentArray.ilean +lib/lean/Lean/Data/PersistentArray.ir lib/lean/Lean/Data/PersistentArray.olean +lib/lean/Lean/Data/PersistentArray.olean.private +lib/lean/Lean/Data/PersistentArray.olean.server lib/lean/Lean/Data/PersistentHashMap.ilean +lib/lean/Lean/Data/PersistentHashMap.ir lib/lean/Lean/Data/PersistentHashMap.olean +lib/lean/Lean/Data/PersistentHashMap.olean.private +lib/lean/Lean/Data/PersistentHashMap.olean.server lib/lean/Lean/Data/PersistentHashSet.ilean +lib/lean/Lean/Data/PersistentHashSet.ir lib/lean/Lean/Data/PersistentHashSet.olean +lib/lean/Lean/Data/PersistentHashSet.olean.private +lib/lean/Lean/Data/PersistentHashSet.olean.server lib/lean/Lean/Data/Position.ilean +lib/lean/Lean/Data/Position.ir lib/lean/Lean/Data/Position.olean +lib/lean/Lean/Data/Position.olean.private +lib/lean/Lean/Data/Position.olean.server lib/lean/Lean/Data/PrefixTree.ilean +lib/lean/Lean/Data/PrefixTree.ir lib/lean/Lean/Data/PrefixTree.olean +lib/lean/Lean/Data/PrefixTree.olean.private +lib/lean/Lean/Data/PrefixTree.olean.server lib/lean/Lean/Data/RArray.ilean +lib/lean/Lean/Data/RArray.ir lib/lean/Lean/Data/RArray.olean +lib/lean/Lean/Data/RArray.olean.private +lib/lean/Lean/Data/RArray.olean.server lib/lean/Lean/Data/RBMap.ilean +lib/lean/Lean/Data/RBMap.ir lib/lean/Lean/Data/RBMap.olean +lib/lean/Lean/Data/RBMap.olean.private +lib/lean/Lean/Data/RBMap.olean.server lib/lean/Lean/Data/RBTree.ilean +lib/lean/Lean/Data/RBTree.ir lib/lean/Lean/Data/RBTree.olean +lib/lean/Lean/Data/RBTree.olean.private +lib/lean/Lean/Data/RBTree.olean.server lib/lean/Lean/Data/SMap.ilean +lib/lean/Lean/Data/SMap.ir lib/lean/Lean/Data/SMap.olean +lib/lean/Lean/Data/SMap.olean.private +lib/lean/Lean/Data/SMap.olean.server lib/lean/Lean/Data/SSet.ilean +lib/lean/Lean/Data/SSet.ir lib/lean/Lean/Data/SSet.olean +lib/lean/Lean/Data/SSet.olean.private +lib/lean/Lean/Data/SSet.olean.server lib/lean/Lean/Data/Trie.ilean +lib/lean/Lean/Data/Trie.ir lib/lean/Lean/Data/Trie.olean +lib/lean/Lean/Data/Trie.olean.private +lib/lean/Lean/Data/Trie.olean.server lib/lean/Lean/Data/Xml.ilean +lib/lean/Lean/Data/Xml.ir lib/lean/Lean/Data/Xml.olean +lib/lean/Lean/Data/Xml.olean.private +lib/lean/Lean/Data/Xml.olean.server lib/lean/Lean/Data/Xml/Basic.ilean +lib/lean/Lean/Data/Xml/Basic.ir lib/lean/Lean/Data/Xml/Basic.olean +lib/lean/Lean/Data/Xml/Basic.olean.private +lib/lean/Lean/Data/Xml/Basic.olean.server lib/lean/Lean/Data/Xml/Parser.ilean +lib/lean/Lean/Data/Xml/Parser.ir lib/lean/Lean/Data/Xml/Parser.olean +lib/lean/Lean/Data/Xml/Parser.olean.private +lib/lean/Lean/Data/Xml/Parser.olean.server lib/lean/Lean/Declaration.ilean +lib/lean/Lean/Declaration.ir lib/lean/Lean/Declaration.olean +lib/lean/Lean/Declaration.olean.private +lib/lean/Lean/Declaration.olean.server lib/lean/Lean/DeclarationRange.ilean +lib/lean/Lean/DeclarationRange.ir lib/lean/Lean/DeclarationRange.olean +lib/lean/Lean/DeclarationRange.olean.private +lib/lean/Lean/DeclarationRange.olean.server lib/lean/Lean/DefEqAttrib.ilean +lib/lean/Lean/DefEqAttrib.ir lib/lean/Lean/DefEqAttrib.olean +lib/lean/Lean/DefEqAttrib.olean.private +lib/lean/Lean/DefEqAttrib.olean.server lib/lean/Lean/DocString.ilean +lib/lean/Lean/DocString.ir lib/lean/Lean/DocString.olean +lib/lean/Lean/DocString.olean.private +lib/lean/Lean/DocString.olean.server lib/lean/Lean/DocString/Add.ilean +lib/lean/Lean/DocString/Add.ir lib/lean/Lean/DocString/Add.olean +lib/lean/Lean/DocString/Add.olean.private +lib/lean/Lean/DocString/Add.olean.server lib/lean/Lean/DocString/Extension.ilean +lib/lean/Lean/DocString/Extension.ir lib/lean/Lean/DocString/Extension.olean +lib/lean/Lean/DocString/Extension.olean.private +lib/lean/Lean/DocString/Extension.olean.server lib/lean/Lean/DocString/Links.ilean +lib/lean/Lean/DocString/Links.ir lib/lean/Lean/DocString/Links.olean +lib/lean/Lean/DocString/Links.olean.private +lib/lean/Lean/DocString/Links.olean.server lib/lean/Lean/Elab.ilean +lib/lean/Lean/Elab.ir lib/lean/Lean/Elab.olean +lib/lean/Lean/Elab.olean.private +lib/lean/Lean/Elab.olean.server lib/lean/Lean/Elab/App.ilean +lib/lean/Lean/Elab/App.ir lib/lean/Lean/Elab/App.olean +lib/lean/Lean/Elab/App.olean.private +lib/lean/Lean/Elab/App.olean.server lib/lean/Lean/Elab/Arg.ilean +lib/lean/Lean/Elab/Arg.ir lib/lean/Lean/Elab/Arg.olean +lib/lean/Lean/Elab/Arg.olean.private +lib/lean/Lean/Elab/Arg.olean.server lib/lean/Lean/Elab/Attributes.ilean +lib/lean/Lean/Elab/Attributes.ir lib/lean/Lean/Elab/Attributes.olean +lib/lean/Lean/Elab/Attributes.olean.private +lib/lean/Lean/Elab/Attributes.olean.server lib/lean/Lean/Elab/AutoBound.ilean +lib/lean/Lean/Elab/AutoBound.ir lib/lean/Lean/Elab/AutoBound.olean +lib/lean/Lean/Elab/AutoBound.olean.private +lib/lean/Lean/Elab/AutoBound.olean.server lib/lean/Lean/Elab/AuxDef.ilean +lib/lean/Lean/Elab/AuxDef.ir lib/lean/Lean/Elab/AuxDef.olean +lib/lean/Lean/Elab/AuxDef.olean.private +lib/lean/Lean/Elab/AuxDef.olean.server lib/lean/Lean/Elab/BinderPredicates.ilean +lib/lean/Lean/Elab/BinderPredicates.ir lib/lean/Lean/Elab/BinderPredicates.olean +lib/lean/Lean/Elab/BinderPredicates.olean.private +lib/lean/Lean/Elab/BinderPredicates.olean.server lib/lean/Lean/Elab/Binders.ilean +lib/lean/Lean/Elab/Binders.ir lib/lean/Lean/Elab/Binders.olean +lib/lean/Lean/Elab/Binders.olean.private +lib/lean/Lean/Elab/Binders.olean.server lib/lean/Lean/Elab/BindersUtil.ilean +lib/lean/Lean/Elab/BindersUtil.ir lib/lean/Lean/Elab/BindersUtil.olean +lib/lean/Lean/Elab/BindersUtil.olean.private +lib/lean/Lean/Elab/BindersUtil.olean.server lib/lean/Lean/Elab/BuiltinCommand.ilean +lib/lean/Lean/Elab/BuiltinCommand.ir lib/lean/Lean/Elab/BuiltinCommand.olean +lib/lean/Lean/Elab/BuiltinCommand.olean.private +lib/lean/Lean/Elab/BuiltinCommand.olean.server lib/lean/Lean/Elab/BuiltinEvalCommand.ilean +lib/lean/Lean/Elab/BuiltinEvalCommand.ir lib/lean/Lean/Elab/BuiltinEvalCommand.olean +lib/lean/Lean/Elab/BuiltinEvalCommand.olean.private +lib/lean/Lean/Elab/BuiltinEvalCommand.olean.server lib/lean/Lean/Elab/BuiltinNotation.ilean +lib/lean/Lean/Elab/BuiltinNotation.ir lib/lean/Lean/Elab/BuiltinNotation.olean +lib/lean/Lean/Elab/BuiltinNotation.olean.private +lib/lean/Lean/Elab/BuiltinNotation.olean.server lib/lean/Lean/Elab/BuiltinTerm.ilean +lib/lean/Lean/Elab/BuiltinTerm.ir lib/lean/Lean/Elab/BuiltinTerm.olean +lib/lean/Lean/Elab/BuiltinTerm.olean.private +lib/lean/Lean/Elab/BuiltinTerm.olean.server lib/lean/Lean/Elab/Calc.ilean +lib/lean/Lean/Elab/Calc.ir lib/lean/Lean/Elab/Calc.olean +lib/lean/Lean/Elab/Calc.olean.private +lib/lean/Lean/Elab/Calc.olean.server lib/lean/Lean/Elab/CheckTactic.ilean +lib/lean/Lean/Elab/CheckTactic.ir lib/lean/Lean/Elab/CheckTactic.olean +lib/lean/Lean/Elab/CheckTactic.olean.private +lib/lean/Lean/Elab/CheckTactic.olean.server lib/lean/Lean/Elab/Command.ilean +lib/lean/Lean/Elab/Command.ir lib/lean/Lean/Elab/Command.olean +lib/lean/Lean/Elab/Command.olean.private +lib/lean/Lean/Elab/Command.olean.server lib/lean/Lean/Elab/ComputedFields.ilean +lib/lean/Lean/Elab/ComputedFields.ir lib/lean/Lean/Elab/ComputedFields.olean +lib/lean/Lean/Elab/ComputedFields.olean.private +lib/lean/Lean/Elab/ComputedFields.olean.server lib/lean/Lean/Elab/Config.ilean +lib/lean/Lean/Elab/Config.ir lib/lean/Lean/Elab/Config.olean +lib/lean/Lean/Elab/Config.olean.private +lib/lean/Lean/Elab/Config.olean.server lib/lean/Lean/Elab/DeclModifiers.ilean +lib/lean/Lean/Elab/DeclModifiers.ir lib/lean/Lean/Elab/DeclModifiers.olean +lib/lean/Lean/Elab/DeclModifiers.olean.private +lib/lean/Lean/Elab/DeclModifiers.olean.server lib/lean/Lean/Elab/DeclNameGen.ilean +lib/lean/Lean/Elab/DeclNameGen.ir lib/lean/Lean/Elab/DeclNameGen.olean +lib/lean/Lean/Elab/DeclNameGen.olean.private +lib/lean/Lean/Elab/DeclNameGen.olean.server lib/lean/Lean/Elab/DeclUtil.ilean +lib/lean/Lean/Elab/DeclUtil.ir lib/lean/Lean/Elab/DeclUtil.olean +lib/lean/Lean/Elab/DeclUtil.olean.private +lib/lean/Lean/Elab/DeclUtil.olean.server lib/lean/Lean/Elab/Declaration.ilean +lib/lean/Lean/Elab/Declaration.ir lib/lean/Lean/Elab/Declaration.olean +lib/lean/Lean/Elab/Declaration.olean.private +lib/lean/Lean/Elab/Declaration.olean.server lib/lean/Lean/Elab/DeclarationRange.ilean +lib/lean/Lean/Elab/DeclarationRange.ir lib/lean/Lean/Elab/DeclarationRange.olean +lib/lean/Lean/Elab/DeclarationRange.olean.private +lib/lean/Lean/Elab/DeclarationRange.olean.server lib/lean/Lean/Elab/DefView.ilean +lib/lean/Lean/Elab/DefView.ir lib/lean/Lean/Elab/DefView.olean +lib/lean/Lean/Elab/DefView.olean.private +lib/lean/Lean/Elab/DefView.olean.server lib/lean/Lean/Elab/Deriving.ilean +lib/lean/Lean/Elab/Deriving.ir lib/lean/Lean/Elab/Deriving.olean +lib/lean/Lean/Elab/Deriving.olean.private +lib/lean/Lean/Elab/Deriving.olean.server lib/lean/Lean/Elab/Deriving/BEq.ilean +lib/lean/Lean/Elab/Deriving/BEq.ir lib/lean/Lean/Elab/Deriving/BEq.olean +lib/lean/Lean/Elab/Deriving/BEq.olean.private +lib/lean/Lean/Elab/Deriving/BEq.olean.server lib/lean/Lean/Elab/Deriving/Basic.ilean +lib/lean/Lean/Elab/Deriving/Basic.ir lib/lean/Lean/Elab/Deriving/Basic.olean +lib/lean/Lean/Elab/Deriving/Basic.olean.private +lib/lean/Lean/Elab/Deriving/Basic.olean.server lib/lean/Lean/Elab/Deriving/DecEq.ilean +lib/lean/Lean/Elab/Deriving/DecEq.ir lib/lean/Lean/Elab/Deriving/DecEq.olean +lib/lean/Lean/Elab/Deriving/DecEq.olean.private +lib/lean/Lean/Elab/Deriving/DecEq.olean.server lib/lean/Lean/Elab/Deriving/FromToJson.ilean +lib/lean/Lean/Elab/Deriving/FromToJson.ir lib/lean/Lean/Elab/Deriving/FromToJson.olean +lib/lean/Lean/Elab/Deriving/FromToJson.olean.private +lib/lean/Lean/Elab/Deriving/FromToJson.olean.server lib/lean/Lean/Elab/Deriving/Hashable.ilean +lib/lean/Lean/Elab/Deriving/Hashable.ir lib/lean/Lean/Elab/Deriving/Hashable.olean +lib/lean/Lean/Elab/Deriving/Hashable.olean.private +lib/lean/Lean/Elab/Deriving/Hashable.olean.server lib/lean/Lean/Elab/Deriving/Inhabited.ilean +lib/lean/Lean/Elab/Deriving/Inhabited.ir lib/lean/Lean/Elab/Deriving/Inhabited.olean +lib/lean/Lean/Elab/Deriving/Inhabited.olean.private +lib/lean/Lean/Elab/Deriving/Inhabited.olean.server lib/lean/Lean/Elab/Deriving/Nonempty.ilean +lib/lean/Lean/Elab/Deriving/Nonempty.ir lib/lean/Lean/Elab/Deriving/Nonempty.olean +lib/lean/Lean/Elab/Deriving/Nonempty.olean.private +lib/lean/Lean/Elab/Deriving/Nonempty.olean.server lib/lean/Lean/Elab/Deriving/Ord.ilean +lib/lean/Lean/Elab/Deriving/Ord.ir lib/lean/Lean/Elab/Deriving/Ord.olean +lib/lean/Lean/Elab/Deriving/Ord.olean.private +lib/lean/Lean/Elab/Deriving/Ord.olean.server lib/lean/Lean/Elab/Deriving/Repr.ilean +lib/lean/Lean/Elab/Deriving/Repr.ir lib/lean/Lean/Elab/Deriving/Repr.olean +lib/lean/Lean/Elab/Deriving/Repr.olean.private +lib/lean/Lean/Elab/Deriving/Repr.olean.server lib/lean/Lean/Elab/Deriving/SizeOf.ilean +lib/lean/Lean/Elab/Deriving/SizeOf.ir lib/lean/Lean/Elab/Deriving/SizeOf.olean +lib/lean/Lean/Elab/Deriving/SizeOf.olean.private +lib/lean/Lean/Elab/Deriving/SizeOf.olean.server lib/lean/Lean/Elab/Deriving/ToExpr.ilean +lib/lean/Lean/Elab/Deriving/ToExpr.ir lib/lean/Lean/Elab/Deriving/ToExpr.olean +lib/lean/Lean/Elab/Deriving/ToExpr.olean.private +lib/lean/Lean/Elab/Deriving/ToExpr.olean.server lib/lean/Lean/Elab/Deriving/TypeName.ilean +lib/lean/Lean/Elab/Deriving/TypeName.ir lib/lean/Lean/Elab/Deriving/TypeName.olean +lib/lean/Lean/Elab/Deriving/TypeName.olean.private +lib/lean/Lean/Elab/Deriving/TypeName.olean.server lib/lean/Lean/Elab/Deriving/Util.ilean +lib/lean/Lean/Elab/Deriving/Util.ir lib/lean/Lean/Elab/Deriving/Util.olean +lib/lean/Lean/Elab/Deriving/Util.olean.private +lib/lean/Lean/Elab/Deriving/Util.olean.server lib/lean/Lean/Elab/Do.ilean +lib/lean/Lean/Elab/Do.ir lib/lean/Lean/Elab/Do.olean +lib/lean/Lean/Elab/Do.olean.private +lib/lean/Lean/Elab/Do.olean.server lib/lean/Lean/Elab/ElabRules.ilean +lib/lean/Lean/Elab/ElabRules.ir lib/lean/Lean/Elab/ElabRules.olean +lib/lean/Lean/Elab/ElabRules.olean.private +lib/lean/Lean/Elab/ElabRules.olean.server lib/lean/Lean/Elab/ErrorExplanation.ilean +lib/lean/Lean/Elab/ErrorExplanation.ir lib/lean/Lean/Elab/ErrorExplanation.olean +lib/lean/Lean/Elab/ErrorExplanation.olean.private +lib/lean/Lean/Elab/ErrorExplanation.olean.server lib/lean/Lean/Elab/Eval.ilean +lib/lean/Lean/Elab/Eval.ir lib/lean/Lean/Elab/Eval.olean +lib/lean/Lean/Elab/Eval.olean.private +lib/lean/Lean/Elab/Eval.olean.server lib/lean/Lean/Elab/Exception.ilean +lib/lean/Lean/Elab/Exception.ir lib/lean/Lean/Elab/Exception.olean +lib/lean/Lean/Elab/Exception.olean.private +lib/lean/Lean/Elab/Exception.olean.server lib/lean/Lean/Elab/Extra.ilean +lib/lean/Lean/Elab/Extra.ir lib/lean/Lean/Elab/Extra.olean +lib/lean/Lean/Elab/Extra.olean.private +lib/lean/Lean/Elab/Extra.olean.server lib/lean/Lean/Elab/Frontend.ilean +lib/lean/Lean/Elab/Frontend.ir lib/lean/Lean/Elab/Frontend.olean +lib/lean/Lean/Elab/Frontend.olean.private +lib/lean/Lean/Elab/Frontend.olean.server lib/lean/Lean/Elab/GenInjective.ilean +lib/lean/Lean/Elab/GenInjective.ir lib/lean/Lean/Elab/GenInjective.olean +lib/lean/Lean/Elab/GenInjective.olean.private +lib/lean/Lean/Elab/GenInjective.olean.server lib/lean/Lean/Elab/GuardMsgs.ilean +lib/lean/Lean/Elab/GuardMsgs.ir lib/lean/Lean/Elab/GuardMsgs.olean +lib/lean/Lean/Elab/GuardMsgs.olean.private +lib/lean/Lean/Elab/GuardMsgs.olean.server lib/lean/Lean/Elab/Import.ilean +lib/lean/Lean/Elab/Import.ir lib/lean/Lean/Elab/Import.olean +lib/lean/Lean/Elab/Import.olean.private +lib/lean/Lean/Elab/Import.olean.server lib/lean/Lean/Elab/Inductive.ilean +lib/lean/Lean/Elab/Inductive.ir lib/lean/Lean/Elab/Inductive.olean +lib/lean/Lean/Elab/Inductive.olean.private +lib/lean/Lean/Elab/Inductive.olean.server lib/lean/Lean/Elab/InfoTree.ilean +lib/lean/Lean/Elab/InfoTree.ir lib/lean/Lean/Elab/InfoTree.olean +lib/lean/Lean/Elab/InfoTree.olean.private +lib/lean/Lean/Elab/InfoTree.olean.server lib/lean/Lean/Elab/InfoTree/InlayHints.ilean +lib/lean/Lean/Elab/InfoTree/InlayHints.ir lib/lean/Lean/Elab/InfoTree/InlayHints.olean +lib/lean/Lean/Elab/InfoTree/InlayHints.olean.private +lib/lean/Lean/Elab/InfoTree/InlayHints.olean.server lib/lean/Lean/Elab/InfoTree/Main.ilean +lib/lean/Lean/Elab/InfoTree/Main.ir lib/lean/Lean/Elab/InfoTree/Main.olean +lib/lean/Lean/Elab/InfoTree/Main.olean.private +lib/lean/Lean/Elab/InfoTree/Main.olean.server lib/lean/Lean/Elab/InfoTree/Types.ilean +lib/lean/Lean/Elab/InfoTree/Types.ir lib/lean/Lean/Elab/InfoTree/Types.olean +lib/lean/Lean/Elab/InfoTree/Types.olean.private +lib/lean/Lean/Elab/InfoTree/Types.olean.server lib/lean/Lean/Elab/InfoTrees.ilean +lib/lean/Lean/Elab/InfoTrees.ir lib/lean/Lean/Elab/InfoTrees.olean +lib/lean/Lean/Elab/InfoTrees.olean.private +lib/lean/Lean/Elab/InfoTrees.olean.server lib/lean/Lean/Elab/InheritDoc.ilean +lib/lean/Lean/Elab/InheritDoc.ir lib/lean/Lean/Elab/InheritDoc.olean +lib/lean/Lean/Elab/InheritDoc.olean.private +lib/lean/Lean/Elab/InheritDoc.olean.server lib/lean/Lean/Elab/LetRec.ilean +lib/lean/Lean/Elab/LetRec.ir lib/lean/Lean/Elab/LetRec.olean +lib/lean/Lean/Elab/LetRec.olean.private +lib/lean/Lean/Elab/LetRec.olean.server lib/lean/Lean/Elab/Level.ilean +lib/lean/Lean/Elab/Level.ir lib/lean/Lean/Elab/Level.olean +lib/lean/Lean/Elab/Level.olean.private +lib/lean/Lean/Elab/Level.olean.server lib/lean/Lean/Elab/Macro.ilean +lib/lean/Lean/Elab/Macro.ir lib/lean/Lean/Elab/Macro.olean +lib/lean/Lean/Elab/Macro.olean.private +lib/lean/Lean/Elab/Macro.olean.server lib/lean/Lean/Elab/MacroArgUtil.ilean +lib/lean/Lean/Elab/MacroArgUtil.ir lib/lean/Lean/Elab/MacroArgUtil.olean +lib/lean/Lean/Elab/MacroArgUtil.olean.private +lib/lean/Lean/Elab/MacroArgUtil.olean.server lib/lean/Lean/Elab/MacroRules.ilean +lib/lean/Lean/Elab/MacroRules.ir lib/lean/Lean/Elab/MacroRules.olean +lib/lean/Lean/Elab/MacroRules.olean.private +lib/lean/Lean/Elab/MacroRules.olean.server lib/lean/Lean/Elab/Match.ilean +lib/lean/Lean/Elab/Match.ir lib/lean/Lean/Elab/Match.olean +lib/lean/Lean/Elab/Match.olean.private +lib/lean/Lean/Elab/Match.olean.server lib/lean/Lean/Elab/MatchAltView.ilean +lib/lean/Lean/Elab/MatchAltView.ir lib/lean/Lean/Elab/MatchAltView.olean +lib/lean/Lean/Elab/MatchAltView.olean.private +lib/lean/Lean/Elab/MatchAltView.olean.server lib/lean/Lean/Elab/MatchExpr.ilean +lib/lean/Lean/Elab/MatchExpr.ir lib/lean/Lean/Elab/MatchExpr.olean +lib/lean/Lean/Elab/MatchExpr.olean.private +lib/lean/Lean/Elab/MatchExpr.olean.server lib/lean/Lean/Elab/Mixfix.ilean +lib/lean/Lean/Elab/Mixfix.ir lib/lean/Lean/Elab/Mixfix.olean +lib/lean/Lean/Elab/Mixfix.olean.private +lib/lean/Lean/Elab/Mixfix.olean.server lib/lean/Lean/Elab/MutualDef.ilean +lib/lean/Lean/Elab/MutualDef.ir lib/lean/Lean/Elab/MutualDef.olean +lib/lean/Lean/Elab/MutualDef.olean.private +lib/lean/Lean/Elab/MutualDef.olean.server lib/lean/Lean/Elab/MutualInductive.ilean +lib/lean/Lean/Elab/MutualInductive.ir lib/lean/Lean/Elab/MutualInductive.olean +lib/lean/Lean/Elab/MutualInductive.olean.private +lib/lean/Lean/Elab/MutualInductive.olean.server lib/lean/Lean/Elab/Notation.ilean +lib/lean/Lean/Elab/Notation.ir lib/lean/Lean/Elab/Notation.olean +lib/lean/Lean/Elab/Notation.olean.private +lib/lean/Lean/Elab/Notation.olean.server lib/lean/Lean/Elab/Open.ilean +lib/lean/Lean/Elab/Open.ir lib/lean/Lean/Elab/Open.olean +lib/lean/Lean/Elab/Open.olean.private +lib/lean/Lean/Elab/Open.olean.server lib/lean/Lean/Elab/ParseImportsFast.ilean +lib/lean/Lean/Elab/ParseImportsFast.ir lib/lean/Lean/Elab/ParseImportsFast.olean +lib/lean/Lean/Elab/ParseImportsFast.olean.private +lib/lean/Lean/Elab/ParseImportsFast.olean.server lib/lean/Lean/Elab/PatternVar.ilean +lib/lean/Lean/Elab/PatternVar.ir lib/lean/Lean/Elab/PatternVar.olean +lib/lean/Lean/Elab/PatternVar.olean.private +lib/lean/Lean/Elab/PatternVar.olean.server lib/lean/Lean/Elab/PreDefinition.ilean +lib/lean/Lean/Elab/PreDefinition.ir lib/lean/Lean/Elab/PreDefinition.olean +lib/lean/Lean/Elab/PreDefinition.olean.private +lib/lean/Lean/Elab/PreDefinition.olean.server lib/lean/Lean/Elab/PreDefinition/Basic.ilean +lib/lean/Lean/Elab/PreDefinition/Basic.ir lib/lean/Lean/Elab/PreDefinition/Basic.olean +lib/lean/Lean/Elab/PreDefinition/Basic.olean.private +lib/lean/Lean/Elab/PreDefinition/Basic.olean.server lib/lean/Lean/Elab/PreDefinition/EqUnfold.ilean +lib/lean/Lean/Elab/PreDefinition/EqUnfold.ir lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean +lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean.private +lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean.server lib/lean/Lean/Elab/PreDefinition/Eqns.ilean +lib/lean/Lean/Elab/PreDefinition/Eqns.ir lib/lean/Lean/Elab/PreDefinition/Eqns.olean +lib/lean/Lean/Elab/PreDefinition/Eqns.olean.private +lib/lean/Lean/Elab/PreDefinition/Eqns.olean.server lib/lean/Lean/Elab/PreDefinition/FixedParams.ilean +lib/lean/Lean/Elab/PreDefinition/FixedParams.ir lib/lean/Lean/Elab/PreDefinition/FixedParams.olean +lib/lean/Lean/Elab/PreDefinition/FixedParams.olean.private +lib/lean/Lean/Elab/PreDefinition/FixedParams.olean.server lib/lean/Lean/Elab/PreDefinition/Main.ilean +lib/lean/Lean/Elab/PreDefinition/Main.ir lib/lean/Lean/Elab/PreDefinition/Main.olean +lib/lean/Lean/Elab/PreDefinition/Main.olean.private +lib/lean/Lean/Elab/PreDefinition/Main.olean.server lib/lean/Lean/Elab/PreDefinition/MkInhabitant.ilean +lib/lean/Lean/Elab/PreDefinition/MkInhabitant.ir lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean +lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean.private +lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean.server lib/lean/Lean/Elab/PreDefinition/Mutual.ilean +lib/lean/Lean/Elab/PreDefinition/Mutual.ir lib/lean/Lean/Elab/PreDefinition/Mutual.olean +lib/lean/Lean/Elab/PreDefinition/Mutual.olean.private +lib/lean/Lean/Elab/PreDefinition/Mutual.olean.server lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.ilean +lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.ir lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean +lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean.private +lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean.server lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.ilean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.ir lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean.private +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean.server lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.ilean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.ir lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean.private +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean.server lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.ilean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.ir lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean.private +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean.server lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.ilean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.ir lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean.private +lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean.server lib/lean/Lean/Elab/PreDefinition/Structural.ilean +lib/lean/Lean/Elab/PreDefinition/Structural.ir lib/lean/Lean/Elab/PreDefinition/Structural.olean +lib/lean/Lean/Elab/PreDefinition/Structural.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.ir lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean +lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/Basic.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/Basic.ir lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean +lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.ir lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean +lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.ir lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean +lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.ir lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean +lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.ir lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean +lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/Main.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/Main.ir lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean +lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.ir lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean +lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.ir lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean +lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean.server lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.ilean +lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.ir lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean +lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean.private +lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean.server lib/lean/Lean/Elab/PreDefinition/TerminationHint.ilean +lib/lean/Lean/Elab/PreDefinition/TerminationHint.ir lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean +lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean.private +lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean.server lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.ilean +lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.ir lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean +lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean.private +lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean.server lib/lean/Lean/Elab/PreDefinition/WF.ilean +lib/lean/Lean/Elab/PreDefinition/WF.ir lib/lean/Lean/Elab/PreDefinition/WF.olean +lib/lean/Lean/Elab/PreDefinition/WF.olean.private +lib/lean/Lean/Elab/PreDefinition/WF.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Basic.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Basic.ir lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean +lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Eqns.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Eqns.ir lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean +lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Fix.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Fix.ir lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean +lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean.server lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.ilean +lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.ir lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean +lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean.server lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.ilean +lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.ir lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean +lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Main.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Main.ir lib/lean/Lean/Elab/PreDefinition/WF/Main.olean +lib/lean/Lean/Elab/PreDefinition/WF/Main.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Main.olean.server lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.ilean +lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.ir lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean +lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.ir lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean +lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Rel.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Rel.ir lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean +lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean.server lib/lean/Lean/Elab/PreDefinition/WF/Unfold.ilean +lib/lean/Lean/Elab/PreDefinition/WF/Unfold.ir lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean +lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean.private +lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean.server lib/lean/Lean/Elab/Print.ilean +lib/lean/Lean/Elab/Print.ir lib/lean/Lean/Elab/Print.olean +lib/lean/Lean/Elab/Print.olean.private +lib/lean/Lean/Elab/Print.olean.server lib/lean/Lean/Elab/Quotation.ilean +lib/lean/Lean/Elab/Quotation.ir lib/lean/Lean/Elab/Quotation.olean +lib/lean/Lean/Elab/Quotation.olean.private +lib/lean/Lean/Elab/Quotation.olean.server lib/lean/Lean/Elab/Quotation/Precheck.ilean +lib/lean/Lean/Elab/Quotation/Precheck.ir lib/lean/Lean/Elab/Quotation/Precheck.olean +lib/lean/Lean/Elab/Quotation/Precheck.olean.private +lib/lean/Lean/Elab/Quotation/Precheck.olean.server lib/lean/Lean/Elab/Quotation/Util.ilean +lib/lean/Lean/Elab/Quotation/Util.ir lib/lean/Lean/Elab/Quotation/Util.olean +lib/lean/Lean/Elab/Quotation/Util.olean.private +lib/lean/Lean/Elab/Quotation/Util.olean.server lib/lean/Lean/Elab/RecAppSyntax.ilean +lib/lean/Lean/Elab/RecAppSyntax.ir lib/lean/Lean/Elab/RecAppSyntax.olean +lib/lean/Lean/Elab/RecAppSyntax.olean.private +lib/lean/Lean/Elab/RecAppSyntax.olean.server lib/lean/Lean/Elab/RecommendedSpelling.ilean +lib/lean/Lean/Elab/RecommendedSpelling.ir lib/lean/Lean/Elab/RecommendedSpelling.olean +lib/lean/Lean/Elab/RecommendedSpelling.olean.private +lib/lean/Lean/Elab/RecommendedSpelling.olean.server lib/lean/Lean/Elab/SetOption.ilean +lib/lean/Lean/Elab/SetOption.ir lib/lean/Lean/Elab/SetOption.olean +lib/lean/Lean/Elab/SetOption.olean.private +lib/lean/Lean/Elab/SetOption.olean.server lib/lean/Lean/Elab/StructInst.ilean +lib/lean/Lean/Elab/StructInst.ir lib/lean/Lean/Elab/StructInst.olean +lib/lean/Lean/Elab/StructInst.olean.private +lib/lean/Lean/Elab/StructInst.olean.server +lib/lean/Lean/Elab/StructInstHint.ilean +lib/lean/Lean/Elab/StructInstHint.ir +lib/lean/Lean/Elab/StructInstHint.olean +lib/lean/Lean/Elab/StructInstHint.olean.private +lib/lean/Lean/Elab/StructInstHint.olean.server lib/lean/Lean/Elab/Structure.ilean +lib/lean/Lean/Elab/Structure.ir lib/lean/Lean/Elab/Structure.olean +lib/lean/Lean/Elab/Structure.olean.private +lib/lean/Lean/Elab/Structure.olean.server lib/lean/Lean/Elab/Syntax.ilean +lib/lean/Lean/Elab/Syntax.ir lib/lean/Lean/Elab/Syntax.olean +lib/lean/Lean/Elab/Syntax.olean.private +lib/lean/Lean/Elab/Syntax.olean.server lib/lean/Lean/Elab/SyntheticMVars.ilean +lib/lean/Lean/Elab/SyntheticMVars.ir lib/lean/Lean/Elab/SyntheticMVars.olean +lib/lean/Lean/Elab/SyntheticMVars.olean.private +lib/lean/Lean/Elab/SyntheticMVars.olean.server lib/lean/Lean/Elab/Tactic.ilean +lib/lean/Lean/Elab/Tactic.ir lib/lean/Lean/Elab/Tactic.olean +lib/lean/Lean/Elab/Tactic.olean.private +lib/lean/Lean/Elab/Tactic.olean.server lib/lean/Lean/Elab/Tactic/AsAuxLemma.ilean +lib/lean/Lean/Elab/Tactic/AsAuxLemma.ir lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean +lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean.private +lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean.server lib/lean/Lean/Elab/Tactic/BVDecide.ilean +lib/lean/Lean/Elab/Tactic/BVDecide.ir lib/lean/Lean/Elab/Tactic/BVDecide.olean +lib/lean/Lean/Elab/Tactic/BVDecide.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/External.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/External.ir lib/lean/Lean/Elab/Tactic/BVDecide/External.olean +lib/lean/Lean/Elab/Tactic/BVDecide/External.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/External.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.ir lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.ir lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean.server lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.ilean +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.ir lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean.private +lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean.server lib/lean/Lean/Elab/Tactic/Basic.ilean +lib/lean/Lean/Elab/Tactic/Basic.ir lib/lean/Lean/Elab/Tactic/Basic.olean +lib/lean/Lean/Elab/Tactic/Basic.olean.private +lib/lean/Lean/Elab/Tactic/Basic.olean.server lib/lean/Lean/Elab/Tactic/BoolToPropSimps.ilean +lib/lean/Lean/Elab/Tactic/BoolToPropSimps.ir lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean +lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean.private +lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean.server lib/lean/Lean/Elab/Tactic/BuiltinTactic.ilean +lib/lean/Lean/Elab/Tactic/BuiltinTactic.ir lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean +lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean.private +lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean.server lib/lean/Lean/Elab/Tactic/Calc.ilean +lib/lean/Lean/Elab/Tactic/Calc.ir lib/lean/Lean/Elab/Tactic/Calc.olean +lib/lean/Lean/Elab/Tactic/Calc.olean.private +lib/lean/Lean/Elab/Tactic/Calc.olean.server lib/lean/Lean/Elab/Tactic/Change.ilean +lib/lean/Lean/Elab/Tactic/Change.ir lib/lean/Lean/Elab/Tactic/Change.olean +lib/lean/Lean/Elab/Tactic/Change.olean.private +lib/lean/Lean/Elab/Tactic/Change.olean.server lib/lean/Lean/Elab/Tactic/Classical.ilean +lib/lean/Lean/Elab/Tactic/Classical.ir lib/lean/Lean/Elab/Tactic/Classical.olean +lib/lean/Lean/Elab/Tactic/Classical.olean.private +lib/lean/Lean/Elab/Tactic/Classical.olean.server lib/lean/Lean/Elab/Tactic/Config.ilean +lib/lean/Lean/Elab/Tactic/Config.ir lib/lean/Lean/Elab/Tactic/Config.olean +lib/lean/Lean/Elab/Tactic/Config.olean.private +lib/lean/Lean/Elab/Tactic/Config.olean.server lib/lean/Lean/Elab/Tactic/Congr.ilean +lib/lean/Lean/Elab/Tactic/Congr.ir lib/lean/Lean/Elab/Tactic/Congr.olean +lib/lean/Lean/Elab/Tactic/Congr.olean.private +lib/lean/Lean/Elab/Tactic/Congr.olean.server lib/lean/Lean/Elab/Tactic/Conv.ilean +lib/lean/Lean/Elab/Tactic/Conv.ir lib/lean/Lean/Elab/Tactic/Conv.olean +lib/lean/Lean/Elab/Tactic/Conv.olean.private +lib/lean/Lean/Elab/Tactic/Conv.olean.server lib/lean/Lean/Elab/Tactic/Conv/Basic.ilean +lib/lean/Lean/Elab/Tactic/Conv/Basic.ir lib/lean/Lean/Elab/Tactic/Conv/Basic.olean +lib/lean/Lean/Elab/Tactic/Conv/Basic.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Basic.olean.server lib/lean/Lean/Elab/Tactic/Conv/Change.ilean +lib/lean/Lean/Elab/Tactic/Conv/Change.ir lib/lean/Lean/Elab/Tactic/Conv/Change.olean +lib/lean/Lean/Elab/Tactic/Conv/Change.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Change.olean.server lib/lean/Lean/Elab/Tactic/Conv/Congr.ilean +lib/lean/Lean/Elab/Tactic/Conv/Congr.ir lib/lean/Lean/Elab/Tactic/Conv/Congr.olean +lib/lean/Lean/Elab/Tactic/Conv/Congr.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Congr.olean.server lib/lean/Lean/Elab/Tactic/Conv/Delta.ilean +lib/lean/Lean/Elab/Tactic/Conv/Delta.ir lib/lean/Lean/Elab/Tactic/Conv/Delta.olean +lib/lean/Lean/Elab/Tactic/Conv/Delta.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Delta.olean.server lib/lean/Lean/Elab/Tactic/Conv/Lets.ilean +lib/lean/Lean/Elab/Tactic/Conv/Lets.ir lib/lean/Lean/Elab/Tactic/Conv/Lets.olean +lib/lean/Lean/Elab/Tactic/Conv/Lets.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Lets.olean.server lib/lean/Lean/Elab/Tactic/Conv/Pattern.ilean +lib/lean/Lean/Elab/Tactic/Conv/Pattern.ir lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean +lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean.server lib/lean/Lean/Elab/Tactic/Conv/Rewrite.ilean +lib/lean/Lean/Elab/Tactic/Conv/Rewrite.ir lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean +lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean.server lib/lean/Lean/Elab/Tactic/Conv/Simp.ilean +lib/lean/Lean/Elab/Tactic/Conv/Simp.ir lib/lean/Lean/Elab/Tactic/Conv/Simp.olean +lib/lean/Lean/Elab/Tactic/Conv/Simp.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Simp.olean.server lib/lean/Lean/Elab/Tactic/Conv/Unfold.ilean +lib/lean/Lean/Elab/Tactic/Conv/Unfold.ir lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean +lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean.private +lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean.server lib/lean/Lean/Elab/Tactic/Delta.ilean +lib/lean/Lean/Elab/Tactic/Delta.ir lib/lean/Lean/Elab/Tactic/Delta.olean +lib/lean/Lean/Elab/Tactic/Delta.olean.private +lib/lean/Lean/Elab/Tactic/Delta.olean.server lib/lean/Lean/Elab/Tactic/DiscrTreeKey.ilean +lib/lean/Lean/Elab/Tactic/DiscrTreeKey.ir lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean +lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean.private +lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean.server lib/lean/Lean/Elab/Tactic/Do.ilean +lib/lean/Lean/Elab/Tactic/Do.ir lib/lean/Lean/Elab/Tactic/Do.olean +lib/lean/Lean/Elab/Tactic/Do.olean.private +lib/lean/Lean/Elab/Tactic/Do.olean.server lib/lean/Lean/Elab/Tactic/Do/Attr.ilean +lib/lean/Lean/Elab/Tactic/Do/Attr.ir lib/lean/Lean/Elab/Tactic/Do/Attr.olean +lib/lean/Lean/Elab/Tactic/Do/Attr.olean.private +lib/lean/Lean/Elab/Tactic/Do/Attr.olean.server lib/lean/Lean/Elab/Tactic/Do/LetElim.ilean +lib/lean/Lean/Elab/Tactic/Do/LetElim.ir lib/lean/Lean/Elab/Tactic/Do/LetElim.olean +lib/lean/Lean/Elab/Tactic/Do/LetElim.olean.private +lib/lean/Lean/Elab/Tactic/Do/LetElim.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Assumption.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Assumption.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Assumption.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Assumption.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Assumption.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Basic.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Basic.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Basic.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Basic.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Basic.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Cases.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Cases.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Cases.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Cases.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Cases.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Clear.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Clear.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Clear.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Clear.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Clear.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Constructor.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Constructor.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Constructor.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Constructor.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Constructor.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Delab.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Delab.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Delab.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Delab.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Delab.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exact.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exact.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exact.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exact.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exact.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exfalso.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exfalso.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exfalso.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exfalso.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Exfalso.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Focus.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Focus.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Focus.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Focus.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Focus.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Frame.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Frame.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Frame.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Frame.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Frame.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Have.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Have.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Have.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Have.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Have.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Intro.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Intro.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Intro.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Intro.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Intro.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/LeftRight.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/LeftRight.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/LeftRight.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/LeftRight.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/LeftRight.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.olean.server +lib/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.ir +lib/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.olean.server lib/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.ilean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.ir lib/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.olean +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.olean.private +lib/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.olean.server lib/lean/Lean/Elab/Tactic/Do/Spec.ilean +lib/lean/Lean/Elab/Tactic/Do/Spec.ir lib/lean/Lean/Elab/Tactic/Do/Spec.olean +lib/lean/Lean/Elab/Tactic/Do/Spec.olean.private +lib/lean/Lean/Elab/Tactic/Do/Spec.olean.server lib/lean/Lean/Elab/Tactic/Do/Syntax.ilean +lib/lean/Lean/Elab/Tactic/Do/Syntax.ir lib/lean/Lean/Elab/Tactic/Do/Syntax.olean +lib/lean/Lean/Elab/Tactic/Do/Syntax.olean.private +lib/lean/Lean/Elab/Tactic/Do/Syntax.olean.server lib/lean/Lean/Elab/Tactic/Do/VCGen.ilean +lib/lean/Lean/Elab/Tactic/Do/VCGen.ir lib/lean/Lean/Elab/Tactic/Do/VCGen.olean +lib/lean/Lean/Elab/Tactic/Do/VCGen.olean.private +lib/lean/Lean/Elab/Tactic/Do/VCGen.olean.server +lib/lean/Lean/Elab/Tactic/Do/VCGen/Basic.ilean +lib/lean/Lean/Elab/Tactic/Do/VCGen/Basic.ir +lib/lean/Lean/Elab/Tactic/Do/VCGen/Basic.olean +lib/lean/Lean/Elab/Tactic/Do/VCGen/Basic.olean.private +lib/lean/Lean/Elab/Tactic/Do/VCGen/Basic.olean.server +lib/lean/Lean/Elab/Tactic/Do/VCGen/Split.ilean +lib/lean/Lean/Elab/Tactic/Do/VCGen/Split.ir +lib/lean/Lean/Elab/Tactic/Do/VCGen/Split.olean +lib/lean/Lean/Elab/Tactic/Do/VCGen/Split.olean.private +lib/lean/Lean/Elab/Tactic/Do/VCGen/Split.olean.server lib/lean/Lean/Elab/Tactic/Doc.ilean +lib/lean/Lean/Elab/Tactic/Doc.ir lib/lean/Lean/Elab/Tactic/Doc.olean +lib/lean/Lean/Elab/Tactic/Doc.olean.private +lib/lean/Lean/Elab/Tactic/Doc.olean.server lib/lean/Lean/Elab/Tactic/ElabTerm.ilean +lib/lean/Lean/Elab/Tactic/ElabTerm.ir lib/lean/Lean/Elab/Tactic/ElabTerm.olean +lib/lean/Lean/Elab/Tactic/ElabTerm.olean.private +lib/lean/Lean/Elab/Tactic/ElabTerm.olean.server lib/lean/Lean/Elab/Tactic/ExposeNames.ilean +lib/lean/Lean/Elab/Tactic/ExposeNames.ir lib/lean/Lean/Elab/Tactic/ExposeNames.olean +lib/lean/Lean/Elab/Tactic/ExposeNames.olean.private +lib/lean/Lean/Elab/Tactic/ExposeNames.olean.server lib/lean/Lean/Elab/Tactic/Ext.ilean +lib/lean/Lean/Elab/Tactic/Ext.ir lib/lean/Lean/Elab/Tactic/Ext.olean +lib/lean/Lean/Elab/Tactic/Ext.olean.private +lib/lean/Lean/Elab/Tactic/Ext.olean.server lib/lean/Lean/Elab/Tactic/FalseOrByContra.ilean +lib/lean/Lean/Elab/Tactic/FalseOrByContra.ir lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean +lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean.private +lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean.server lib/lean/Lean/Elab/Tactic/Generalize.ilean +lib/lean/Lean/Elab/Tactic/Generalize.ir lib/lean/Lean/Elab/Tactic/Generalize.olean +lib/lean/Lean/Elab/Tactic/Generalize.olean.private +lib/lean/Lean/Elab/Tactic/Generalize.olean.server lib/lean/Lean/Elab/Tactic/Grind.ilean +lib/lean/Lean/Elab/Tactic/Grind.ir lib/lean/Lean/Elab/Tactic/Grind.olean +lib/lean/Lean/Elab/Tactic/Grind.olean.private +lib/lean/Lean/Elab/Tactic/Grind.olean.server lib/lean/Lean/Elab/Tactic/Guard.ilean +lib/lean/Lean/Elab/Tactic/Guard.ir lib/lean/Lean/Elab/Tactic/Guard.olean +lib/lean/Lean/Elab/Tactic/Guard.olean.private +lib/lean/Lean/Elab/Tactic/Guard.olean.server lib/lean/Lean/Elab/Tactic/Induction.ilean +lib/lean/Lean/Elab/Tactic/Induction.ir lib/lean/Lean/Elab/Tactic/Induction.olean +lib/lean/Lean/Elab/Tactic/Induction.olean.private +lib/lean/Lean/Elab/Tactic/Induction.olean.server lib/lean/Lean/Elab/Tactic/Injection.ilean +lib/lean/Lean/Elab/Tactic/Injection.ir lib/lean/Lean/Elab/Tactic/Injection.olean +lib/lean/Lean/Elab/Tactic/Injection.olean.private +lib/lean/Lean/Elab/Tactic/Injection.olean.server lib/lean/Lean/Elab/Tactic/Lets.ilean +lib/lean/Lean/Elab/Tactic/Lets.ir lib/lean/Lean/Elab/Tactic/Lets.olean +lib/lean/Lean/Elab/Tactic/Lets.olean.private +lib/lean/Lean/Elab/Tactic/Lets.olean.server lib/lean/Lean/Elab/Tactic/LibrarySearch.ilean +lib/lean/Lean/Elab/Tactic/LibrarySearch.ir lib/lean/Lean/Elab/Tactic/LibrarySearch.olean +lib/lean/Lean/Elab/Tactic/LibrarySearch.olean.private +lib/lean/Lean/Elab/Tactic/LibrarySearch.olean.server lib/lean/Lean/Elab/Tactic/Location.ilean +lib/lean/Lean/Elab/Tactic/Location.ir lib/lean/Lean/Elab/Tactic/Location.olean +lib/lean/Lean/Elab/Tactic/Location.olean.private +lib/lean/Lean/Elab/Tactic/Location.olean.server lib/lean/Lean/Elab/Tactic/Match.ilean +lib/lean/Lean/Elab/Tactic/Match.ir lib/lean/Lean/Elab/Tactic/Match.olean +lib/lean/Lean/Elab/Tactic/Match.olean.private +lib/lean/Lean/Elab/Tactic/Match.olean.server lib/lean/Lean/Elab/Tactic/Meta.ilean +lib/lean/Lean/Elab/Tactic/Meta.ir lib/lean/Lean/Elab/Tactic/Meta.olean +lib/lean/Lean/Elab/Tactic/Meta.olean.private +lib/lean/Lean/Elab/Tactic/Meta.olean.server lib/lean/Lean/Elab/Tactic/Monotonicity.ilean +lib/lean/Lean/Elab/Tactic/Monotonicity.ir lib/lean/Lean/Elab/Tactic/Monotonicity.olean +lib/lean/Lean/Elab/Tactic/Monotonicity.olean.private +lib/lean/Lean/Elab/Tactic/Monotonicity.olean.server lib/lean/Lean/Elab/Tactic/NormCast.ilean +lib/lean/Lean/Elab/Tactic/NormCast.ir lib/lean/Lean/Elab/Tactic/NormCast.olean +lib/lean/Lean/Elab/Tactic/NormCast.olean.private +lib/lean/Lean/Elab/Tactic/NormCast.olean.server lib/lean/Lean/Elab/Tactic/Omega.ilean +lib/lean/Lean/Elab/Tactic/Omega.ir lib/lean/Lean/Elab/Tactic/Omega.olean +lib/lean/Lean/Elab/Tactic/Omega.olean.private +lib/lean/Lean/Elab/Tactic/Omega.olean.server lib/lean/Lean/Elab/Tactic/Omega/Core.ilean +lib/lean/Lean/Elab/Tactic/Omega/Core.ir lib/lean/Lean/Elab/Tactic/Omega/Core.olean +lib/lean/Lean/Elab/Tactic/Omega/Core.olean.private +lib/lean/Lean/Elab/Tactic/Omega/Core.olean.server lib/lean/Lean/Elab/Tactic/Omega/Frontend.ilean +lib/lean/Lean/Elab/Tactic/Omega/Frontend.ir lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean +lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean.private +lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean.server lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.ilean +lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.ir lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean +lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean.private +lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean.server lib/lean/Lean/Elab/Tactic/Omega/OmegaM.ilean +lib/lean/Lean/Elab/Tactic/Omega/OmegaM.ir lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean +lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean.private +lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean.server lib/lean/Lean/Elab/Tactic/RCases.ilean +lib/lean/Lean/Elab/Tactic/RCases.ir lib/lean/Lean/Elab/Tactic/RCases.olean +lib/lean/Lean/Elab/Tactic/RCases.olean.private +lib/lean/Lean/Elab/Tactic/RCases.olean.server lib/lean/Lean/Elab/Tactic/Repeat.ilean +lib/lean/Lean/Elab/Tactic/Repeat.ir lib/lean/Lean/Elab/Tactic/Repeat.olean +lib/lean/Lean/Elab/Tactic/Repeat.olean.private +lib/lean/Lean/Elab/Tactic/Repeat.olean.server lib/lean/Lean/Elab/Tactic/Rewrite.ilean +lib/lean/Lean/Elab/Tactic/Rewrite.ir lib/lean/Lean/Elab/Tactic/Rewrite.olean +lib/lean/Lean/Elab/Tactic/Rewrite.olean.private +lib/lean/Lean/Elab/Tactic/Rewrite.olean.server lib/lean/Lean/Elab/Tactic/Rewrites.ilean +lib/lean/Lean/Elab/Tactic/Rewrites.ir lib/lean/Lean/Elab/Tactic/Rewrites.olean +lib/lean/Lean/Elab/Tactic/Rewrites.olean.private +lib/lean/Lean/Elab/Tactic/Rewrites.olean.server lib/lean/Lean/Elab/Tactic/Rfl.ilean +lib/lean/Lean/Elab/Tactic/Rfl.ir lib/lean/Lean/Elab/Tactic/Rfl.olean +lib/lean/Lean/Elab/Tactic/Rfl.olean.private +lib/lean/Lean/Elab/Tactic/Rfl.olean.server lib/lean/Lean/Elab/Tactic/Show.ilean +lib/lean/Lean/Elab/Tactic/Show.ir lib/lean/Lean/Elab/Tactic/Show.olean +lib/lean/Lean/Elab/Tactic/Show.olean.private +lib/lean/Lean/Elab/Tactic/Show.olean.server lib/lean/Lean/Elab/Tactic/ShowTerm.ilean +lib/lean/Lean/Elab/Tactic/ShowTerm.ir lib/lean/Lean/Elab/Tactic/ShowTerm.olean +lib/lean/Lean/Elab/Tactic/ShowTerm.olean.private +lib/lean/Lean/Elab/Tactic/ShowTerm.olean.server lib/lean/Lean/Elab/Tactic/Simp.ilean +lib/lean/Lean/Elab/Tactic/Simp.ir lib/lean/Lean/Elab/Tactic/Simp.olean +lib/lean/Lean/Elab/Tactic/Simp.olean.private +lib/lean/Lean/Elab/Tactic/Simp.olean.server lib/lean/Lean/Elab/Tactic/SimpArith.ilean +lib/lean/Lean/Elab/Tactic/SimpArith.ir lib/lean/Lean/Elab/Tactic/SimpArith.olean +lib/lean/Lean/Elab/Tactic/SimpArith.olean.private +lib/lean/Lean/Elab/Tactic/SimpArith.olean.server lib/lean/Lean/Elab/Tactic/SimpTrace.ilean +lib/lean/Lean/Elab/Tactic/SimpTrace.ir lib/lean/Lean/Elab/Tactic/SimpTrace.olean +lib/lean/Lean/Elab/Tactic/SimpTrace.olean.private +lib/lean/Lean/Elab/Tactic/SimpTrace.olean.server lib/lean/Lean/Elab/Tactic/Simpa.ilean +lib/lean/Lean/Elab/Tactic/Simpa.ir lib/lean/Lean/Elab/Tactic/Simpa.olean +lib/lean/Lean/Elab/Tactic/Simpa.olean.private +lib/lean/Lean/Elab/Tactic/Simpa.olean.server lib/lean/Lean/Elab/Tactic/Simproc.ilean +lib/lean/Lean/Elab/Tactic/Simproc.ir lib/lean/Lean/Elab/Tactic/Simproc.olean +lib/lean/Lean/Elab/Tactic/Simproc.olean.private +lib/lean/Lean/Elab/Tactic/Simproc.olean.server lib/lean/Lean/Elab/Tactic/SolveByElim.ilean +lib/lean/Lean/Elab/Tactic/SolveByElim.ir lib/lean/Lean/Elab/Tactic/SolveByElim.olean +lib/lean/Lean/Elab/Tactic/SolveByElim.olean.private +lib/lean/Lean/Elab/Tactic/SolveByElim.olean.server lib/lean/Lean/Elab/Tactic/Split.ilean +lib/lean/Lean/Elab/Tactic/Split.ir lib/lean/Lean/Elab/Tactic/Split.olean +lib/lean/Lean/Elab/Tactic/Split.olean.private +lib/lean/Lean/Elab/Tactic/Split.olean.server lib/lean/Lean/Elab/Tactic/Symm.ilean +lib/lean/Lean/Elab/Tactic/Symm.ir lib/lean/Lean/Elab/Tactic/Symm.olean +lib/lean/Lean/Elab/Tactic/Symm.olean.private +lib/lean/Lean/Elab/Tactic/Symm.olean.server lib/lean/Lean/Elab/Tactic/TreeTacAttr.ilean +lib/lean/Lean/Elab/Tactic/TreeTacAttr.ir lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean +lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean.private +lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean.server lib/lean/Lean/Elab/Tactic/Try.ilean +lib/lean/Lean/Elab/Tactic/Try.ir lib/lean/Lean/Elab/Tactic/Try.olean +lib/lean/Lean/Elab/Tactic/Try.olean.private +lib/lean/Lean/Elab/Tactic/Try.olean.server lib/lean/Lean/Elab/Tactic/Unfold.ilean +lib/lean/Lean/Elab/Tactic/Unfold.ir lib/lean/Lean/Elab/Tactic/Unfold.olean +lib/lean/Lean/Elab/Tactic/Unfold.olean.private +lib/lean/Lean/Elab/Tactic/Unfold.olean.server lib/lean/Lean/Elab/Term.ilean +lib/lean/Lean/Elab/Term.ir lib/lean/Lean/Elab/Term.olean +lib/lean/Lean/Elab/Term.olean.private +lib/lean/Lean/Elab/Term.olean.server lib/lean/Lean/Elab/Time.ilean +lib/lean/Lean/Elab/Time.ir lib/lean/Lean/Elab/Time.olean +lib/lean/Lean/Elab/Time.olean.private +lib/lean/Lean/Elab/Time.olean.server lib/lean/Lean/Elab/Util.ilean +lib/lean/Lean/Elab/Util.ir lib/lean/Lean/Elab/Util.olean +lib/lean/Lean/Elab/Util.olean.private +lib/lean/Lean/Elab/Util.olean.server lib/lean/Lean/Elab/WhereFinally.ilean +lib/lean/Lean/Elab/WhereFinally.ir lib/lean/Lean/Elab/WhereFinally.olean +lib/lean/Lean/Elab/WhereFinally.olean.private +lib/lean/Lean/Elab/WhereFinally.olean.server lib/lean/Lean/EnvExtension.ilean +lib/lean/Lean/EnvExtension.ir lib/lean/Lean/EnvExtension.olean +lib/lean/Lean/EnvExtension.olean.private +lib/lean/Lean/EnvExtension.olean.server lib/lean/Lean/Environment.ilean +lib/lean/Lean/Environment.ir lib/lean/Lean/Environment.olean +lib/lean/Lean/Environment.olean.private +lib/lean/Lean/Environment.olean.server lib/lean/Lean/ErrorExplanation.ilean +lib/lean/Lean/ErrorExplanation.ir lib/lean/Lean/ErrorExplanation.olean +lib/lean/Lean/ErrorExplanation.olean.private +lib/lean/Lean/ErrorExplanation.olean.server lib/lean/Lean/ErrorExplanations.ilean +lib/lean/Lean/ErrorExplanations.ir lib/lean/Lean/ErrorExplanations.olean +lib/lean/Lean/ErrorExplanations.olean.private +lib/lean/Lean/ErrorExplanations.olean.server lib/lean/Lean/ErrorExplanations/CtorResultingTypeMismatch.ilean +lib/lean/Lean/ErrorExplanations/CtorResultingTypeMismatch.ir lib/lean/Lean/ErrorExplanations/CtorResultingTypeMismatch.olean +lib/lean/Lean/ErrorExplanations/CtorResultingTypeMismatch.olean.private +lib/lean/Lean/ErrorExplanations/CtorResultingTypeMismatch.olean.server lib/lean/Lean/ErrorExplanations/DependsOnNoncomputable.ilean +lib/lean/Lean/ErrorExplanations/DependsOnNoncomputable.ir lib/lean/Lean/ErrorExplanations/DependsOnNoncomputable.olean +lib/lean/Lean/ErrorExplanations/DependsOnNoncomputable.olean.private +lib/lean/Lean/ErrorExplanations/DependsOnNoncomputable.olean.server lib/lean/Lean/ErrorExplanations/InductiveParamMismatch.ilean +lib/lean/Lean/ErrorExplanations/InductiveParamMismatch.ir lib/lean/Lean/ErrorExplanations/InductiveParamMismatch.olean +lib/lean/Lean/ErrorExplanations/InductiveParamMismatch.olean.private +lib/lean/Lean/ErrorExplanations/InductiveParamMismatch.olean.server lib/lean/Lean/ErrorExplanations/InductiveParamMissing.ilean +lib/lean/Lean/ErrorExplanations/InductiveParamMissing.ir lib/lean/Lean/ErrorExplanations/InductiveParamMissing.olean +lib/lean/Lean/ErrorExplanations/InductiveParamMissing.olean.private +lib/lean/Lean/ErrorExplanations/InductiveParamMissing.olean.server +lib/lean/Lean/ErrorExplanations/InferBinderTypeFailed.ilean +lib/lean/Lean/ErrorExplanations/InferBinderTypeFailed.ir +lib/lean/Lean/ErrorExplanations/InferBinderTypeFailed.olean +lib/lean/Lean/ErrorExplanations/InferBinderTypeFailed.olean.private +lib/lean/Lean/ErrorExplanations/InferBinderTypeFailed.olean.server +lib/lean/Lean/ErrorExplanations/InferDefTypeFailed.ilean +lib/lean/Lean/ErrorExplanations/InferDefTypeFailed.ir +lib/lean/Lean/ErrorExplanations/InferDefTypeFailed.olean +lib/lean/Lean/ErrorExplanations/InferDefTypeFailed.olean.private +lib/lean/Lean/ErrorExplanations/InferDefTypeFailed.olean.server lib/lean/Lean/ErrorExplanations/InvalidDottedIdent.ilean +lib/lean/Lean/ErrorExplanations/InvalidDottedIdent.ir lib/lean/Lean/ErrorExplanations/InvalidDottedIdent.olean +lib/lean/Lean/ErrorExplanations/InvalidDottedIdent.olean.private +lib/lean/Lean/ErrorExplanations/InvalidDottedIdent.olean.server +lib/lean/Lean/ErrorExplanations/ProjNonPropFromProp.ilean +lib/lean/Lean/ErrorExplanations/ProjNonPropFromProp.ir +lib/lean/Lean/ErrorExplanations/ProjNonPropFromProp.olean +lib/lean/Lean/ErrorExplanations/ProjNonPropFromProp.olean.private +lib/lean/Lean/ErrorExplanations/ProjNonPropFromProp.olean.server +lib/lean/Lean/ErrorExplanations/PropRecLargeElim.ilean +lib/lean/Lean/ErrorExplanations/PropRecLargeElim.ir +lib/lean/Lean/ErrorExplanations/PropRecLargeElim.olean +lib/lean/Lean/ErrorExplanations/PropRecLargeElim.olean.private +lib/lean/Lean/ErrorExplanations/PropRecLargeElim.olean.server lib/lean/Lean/ErrorExplanations/RedundantMatchAlt.ilean +lib/lean/Lean/ErrorExplanations/RedundantMatchAlt.ir lib/lean/Lean/ErrorExplanations/RedundantMatchAlt.olean +lib/lean/Lean/ErrorExplanations/RedundantMatchAlt.olean.private +lib/lean/Lean/ErrorExplanations/RedundantMatchAlt.olean.server +lib/lean/Lean/ErrorExplanations/UnknownIdentifier.ilean +lib/lean/Lean/ErrorExplanations/UnknownIdentifier.ir +lib/lean/Lean/ErrorExplanations/UnknownIdentifier.olean +lib/lean/Lean/ErrorExplanations/UnknownIdentifier.olean.private +lib/lean/Lean/ErrorExplanations/UnknownIdentifier.olean.server lib/lean/Lean/Exception.ilean +lib/lean/Lean/Exception.ir lib/lean/Lean/Exception.olean +lib/lean/Lean/Exception.olean.private +lib/lean/Lean/Exception.olean.server lib/lean/Lean/Expr.ilean +lib/lean/Lean/Expr.ir lib/lean/Lean/Expr.olean +lib/lean/Lean/Expr.olean.private +lib/lean/Lean/Expr.olean.server lib/lean/Lean/HeadIndex.ilean +lib/lean/Lean/HeadIndex.ir lib/lean/Lean/HeadIndex.olean +lib/lean/Lean/HeadIndex.olean.private +lib/lean/Lean/HeadIndex.olean.server lib/lean/Lean/Hygiene.ilean +lib/lean/Lean/Hygiene.ir lib/lean/Lean/Hygiene.olean +lib/lean/Lean/Hygiene.olean.private +lib/lean/Lean/Hygiene.olean.server lib/lean/Lean/ImportingFlag.ilean +lib/lean/Lean/ImportingFlag.ir lib/lean/Lean/ImportingFlag.olean +lib/lean/Lean/ImportingFlag.olean.private +lib/lean/Lean/ImportingFlag.olean.server lib/lean/Lean/InternalExceptionId.ilean +lib/lean/Lean/InternalExceptionId.ir lib/lean/Lean/InternalExceptionId.olean +lib/lean/Lean/InternalExceptionId.olean.private +lib/lean/Lean/InternalExceptionId.olean.server lib/lean/Lean/KeyedDeclsAttribute.ilean +lib/lean/Lean/KeyedDeclsAttribute.ir lib/lean/Lean/KeyedDeclsAttribute.olean +lib/lean/Lean/KeyedDeclsAttribute.olean.private +lib/lean/Lean/KeyedDeclsAttribute.olean.server lib/lean/Lean/LabelAttribute.ilean +lib/lean/Lean/LabelAttribute.ir lib/lean/Lean/LabelAttribute.olean +lib/lean/Lean/LabelAttribute.olean.private +lib/lean/Lean/LabelAttribute.olean.server lib/lean/Lean/Language/Basic.ilean +lib/lean/Lean/Language/Basic.ir lib/lean/Lean/Language/Basic.olean +lib/lean/Lean/Language/Basic.olean.private +lib/lean/Lean/Language/Basic.olean.server lib/lean/Lean/Language/Lean.ilean +lib/lean/Lean/Language/Lean.ir lib/lean/Lean/Language/Lean.olean +lib/lean/Lean/Language/Lean.olean.private +lib/lean/Lean/Language/Lean.olean.server lib/lean/Lean/Language/Lean/Types.ilean +lib/lean/Lean/Language/Lean/Types.ir lib/lean/Lean/Language/Lean/Types.olean +lib/lean/Lean/Language/Lean/Types.olean.private +lib/lean/Lean/Language/Lean/Types.olean.server lib/lean/Lean/Language/Util.ilean +lib/lean/Lean/Language/Util.ir lib/lean/Lean/Language/Util.olean +lib/lean/Lean/Language/Util.olean.private +lib/lean/Lean/Language/Util.olean.server lib/lean/Lean/Level.ilean +lib/lean/Lean/Level.ir lib/lean/Lean/Level.olean +lib/lean/Lean/Level.olean.private +lib/lean/Lean/Level.olean.server lib/lean/Lean/Linter.ilean +lib/lean/Lean/Linter.ir lib/lean/Lean/Linter.olean +lib/lean/Lean/Linter.olean.private +lib/lean/Lean/Linter.olean.server lib/lean/Lean/Linter/Basic.ilean +lib/lean/Lean/Linter/Basic.ir lib/lean/Lean/Linter/Basic.olean +lib/lean/Lean/Linter/Basic.olean.private +lib/lean/Lean/Linter/Basic.olean.server lib/lean/Lean/Linter/Builtin.ilean +lib/lean/Lean/Linter/Builtin.ir lib/lean/Lean/Linter/Builtin.olean +lib/lean/Lean/Linter/Builtin.olean.private +lib/lean/Lean/Linter/Builtin.olean.server lib/lean/Lean/Linter/ConstructorAsVariable.ilean +lib/lean/Lean/Linter/ConstructorAsVariable.ir lib/lean/Lean/Linter/ConstructorAsVariable.olean +lib/lean/Lean/Linter/ConstructorAsVariable.olean.private +lib/lean/Lean/Linter/ConstructorAsVariable.olean.server lib/lean/Lean/Linter/Deprecated.ilean +lib/lean/Lean/Linter/Deprecated.ir lib/lean/Lean/Linter/Deprecated.olean +lib/lean/Lean/Linter/Deprecated.olean.private +lib/lean/Lean/Linter/Deprecated.olean.server lib/lean/Lean/Linter/List.ilean +lib/lean/Lean/Linter/List.ir lib/lean/Lean/Linter/List.olean +lib/lean/Lean/Linter/List.olean.private +lib/lean/Lean/Linter/List.olean.server lib/lean/Lean/Linter/MissingDocs.ilean +lib/lean/Lean/Linter/MissingDocs.ir lib/lean/Lean/Linter/MissingDocs.olean +lib/lean/Lean/Linter/MissingDocs.olean.private +lib/lean/Lean/Linter/MissingDocs.olean.server lib/lean/Lean/Linter/Omit.ilean +lib/lean/Lean/Linter/Omit.ir lib/lean/Lean/Linter/Omit.olean +lib/lean/Lean/Linter/Omit.olean.private +lib/lean/Lean/Linter/Omit.olean.server lib/lean/Lean/Linter/Sets.ilean +lib/lean/Lean/Linter/Sets.ir lib/lean/Lean/Linter/Sets.olean +lib/lean/Lean/Linter/Sets.olean.private +lib/lean/Lean/Linter/Sets.olean.server lib/lean/Lean/Linter/UnusedSimpArgs.ilean +lib/lean/Lean/Linter/UnusedSimpArgs.ir lib/lean/Lean/Linter/UnusedSimpArgs.olean +lib/lean/Lean/Linter/UnusedSimpArgs.olean.private +lib/lean/Lean/Linter/UnusedSimpArgs.olean.server lib/lean/Lean/Linter/UnusedVariables.ilean +lib/lean/Lean/Linter/UnusedVariables.ir lib/lean/Lean/Linter/UnusedVariables.olean +lib/lean/Lean/Linter/UnusedVariables.olean.private +lib/lean/Lean/Linter/UnusedVariables.olean.server lib/lean/Lean/Linter/Util.ilean +lib/lean/Lean/Linter/Util.ir lib/lean/Lean/Linter/Util.olean +lib/lean/Lean/Linter/Util.olean.private +lib/lean/Lean/Linter/Util.olean.server lib/lean/Lean/LoadDynlib.ilean +lib/lean/Lean/LoadDynlib.ir lib/lean/Lean/LoadDynlib.olean +lib/lean/Lean/LoadDynlib.olean.private +lib/lean/Lean/LoadDynlib.olean.server lib/lean/Lean/LocalContext.ilean +lib/lean/Lean/LocalContext.ir lib/lean/Lean/LocalContext.olean +lib/lean/Lean/LocalContext.olean.private +lib/lean/Lean/LocalContext.olean.server lib/lean/Lean/Log.ilean +lib/lean/Lean/Log.ir lib/lean/Lean/Log.olean +lib/lean/Lean/Log.olean.private +lib/lean/Lean/Log.olean.server lib/lean/Lean/Message.ilean +lib/lean/Lean/Message.ir lib/lean/Lean/Message.olean +lib/lean/Lean/Message.olean.private +lib/lean/Lean/Message.olean.server lib/lean/Lean/Meta.ilean +lib/lean/Lean/Meta.ir lib/lean/Lean/Meta.olean +lib/lean/Lean/Meta.olean.private +lib/lean/Lean/Meta.olean.server lib/lean/Lean/Meta/ACLt.ilean +lib/lean/Lean/Meta/ACLt.ir lib/lean/Lean/Meta/ACLt.olean +lib/lean/Lean/Meta/ACLt.olean.private +lib/lean/Lean/Meta/ACLt.olean.server lib/lean/Lean/Meta/AbstractMVars.ilean +lib/lean/Lean/Meta/AbstractMVars.ir lib/lean/Lean/Meta/AbstractMVars.olean +lib/lean/Lean/Meta/AbstractMVars.olean.private +lib/lean/Lean/Meta/AbstractMVars.olean.server lib/lean/Lean/Meta/AbstractNestedProofs.ilean +lib/lean/Lean/Meta/AbstractNestedProofs.ir lib/lean/Lean/Meta/AbstractNestedProofs.olean +lib/lean/Lean/Meta/AbstractNestedProofs.olean.private +lib/lean/Lean/Meta/AbstractNestedProofs.olean.server lib/lean/Lean/Meta/AppBuilder.ilean +lib/lean/Lean/Meta/AppBuilder.ir lib/lean/Lean/Meta/AppBuilder.olean +lib/lean/Lean/Meta/AppBuilder.olean.private +lib/lean/Lean/Meta/AppBuilder.olean.server lib/lean/Lean/Meta/ArgsPacker.ilean +lib/lean/Lean/Meta/ArgsPacker.ir lib/lean/Lean/Meta/ArgsPacker.olean +lib/lean/Lean/Meta/ArgsPacker.olean.private +lib/lean/Lean/Meta/ArgsPacker.olean.server lib/lean/Lean/Meta/ArgsPacker/Basic.ilean +lib/lean/Lean/Meta/ArgsPacker/Basic.ir lib/lean/Lean/Meta/ArgsPacker/Basic.olean +lib/lean/Lean/Meta/ArgsPacker/Basic.olean.private +lib/lean/Lean/Meta/ArgsPacker/Basic.olean.server lib/lean/Lean/Meta/Basic.ilean +lib/lean/Lean/Meta/Basic.ir lib/lean/Lean/Meta/Basic.olean +lib/lean/Lean/Meta/Basic.olean.private +lib/lean/Lean/Meta/Basic.olean.server lib/lean/Lean/Meta/BinderNameHint.ilean +lib/lean/Lean/Meta/BinderNameHint.ir lib/lean/Lean/Meta/BinderNameHint.olean +lib/lean/Lean/Meta/BinderNameHint.olean.private +lib/lean/Lean/Meta/BinderNameHint.olean.server lib/lean/Lean/Meta/Canonicalizer.ilean +lib/lean/Lean/Meta/Canonicalizer.ir lib/lean/Lean/Meta/Canonicalizer.olean +lib/lean/Lean/Meta/Canonicalizer.olean.private +lib/lean/Lean/Meta/Canonicalizer.olean.server lib/lean/Lean/Meta/Check.ilean +lib/lean/Lean/Meta/Check.ir lib/lean/Lean/Meta/Check.olean +lib/lean/Lean/Meta/Check.olean.private +lib/lean/Lean/Meta/Check.olean.server lib/lean/Lean/Meta/CheckTactic.ilean +lib/lean/Lean/Meta/CheckTactic.ir lib/lean/Lean/Meta/CheckTactic.olean +lib/lean/Lean/Meta/CheckTactic.olean.private +lib/lean/Lean/Meta/CheckTactic.olean.server lib/lean/Lean/Meta/Closure.ilean +lib/lean/Lean/Meta/Closure.ir lib/lean/Lean/Meta/Closure.olean +lib/lean/Lean/Meta/Closure.olean.private +lib/lean/Lean/Meta/Closure.olean.server lib/lean/Lean/Meta/Coe.ilean +lib/lean/Lean/Meta/Coe.ir lib/lean/Lean/Meta/Coe.olean +lib/lean/Lean/Meta/Coe.olean.private +lib/lean/Lean/Meta/Coe.olean.server lib/lean/Lean/Meta/CoeAttr.ilean +lib/lean/Lean/Meta/CoeAttr.ir lib/lean/Lean/Meta/CoeAttr.olean +lib/lean/Lean/Meta/CoeAttr.olean.private +lib/lean/Lean/Meta/CoeAttr.olean.server lib/lean/Lean/Meta/CollectFVars.ilean +lib/lean/Lean/Meta/CollectFVars.ir lib/lean/Lean/Meta/CollectFVars.olean +lib/lean/Lean/Meta/CollectFVars.olean.private +lib/lean/Lean/Meta/CollectFVars.olean.server lib/lean/Lean/Meta/CollectMVars.ilean +lib/lean/Lean/Meta/CollectMVars.ir lib/lean/Lean/Meta/CollectMVars.olean +lib/lean/Lean/Meta/CollectMVars.olean.private +lib/lean/Lean/Meta/CollectMVars.olean.server lib/lean/Lean/Meta/CompletionName.ilean +lib/lean/Lean/Meta/CompletionName.ir lib/lean/Lean/Meta/CompletionName.olean +lib/lean/Lean/Meta/CompletionName.olean.private +lib/lean/Lean/Meta/CompletionName.olean.server lib/lean/Lean/Meta/CongrTheorems.ilean +lib/lean/Lean/Meta/CongrTheorems.ir lib/lean/Lean/Meta/CongrTheorems.olean +lib/lean/Lean/Meta/CongrTheorems.olean.private +lib/lean/Lean/Meta/CongrTheorems.olean.server lib/lean/Lean/Meta/Constructions.ilean +lib/lean/Lean/Meta/Constructions.ir lib/lean/Lean/Meta/Constructions.olean +lib/lean/Lean/Meta/Constructions.olean.private +lib/lean/Lean/Meta/Constructions.olean.server lib/lean/Lean/Meta/Constructions/BRecOn.ilean +lib/lean/Lean/Meta/Constructions/BRecOn.ir lib/lean/Lean/Meta/Constructions/BRecOn.olean +lib/lean/Lean/Meta/Constructions/BRecOn.olean.private +lib/lean/Lean/Meta/Constructions/BRecOn.olean.server lib/lean/Lean/Meta/Constructions/CasesOn.ilean +lib/lean/Lean/Meta/Constructions/CasesOn.ir lib/lean/Lean/Meta/Constructions/CasesOn.olean +lib/lean/Lean/Meta/Constructions/CasesOn.olean.private +lib/lean/Lean/Meta/Constructions/CasesOn.olean.server lib/lean/Lean/Meta/Constructions/NoConfusion.ilean +lib/lean/Lean/Meta/Constructions/NoConfusion.ir lib/lean/Lean/Meta/Constructions/NoConfusion.olean +lib/lean/Lean/Meta/Constructions/NoConfusion.olean.private +lib/lean/Lean/Meta/Constructions/NoConfusion.olean.server lib/lean/Lean/Meta/Constructions/NoConfusionLinear.ilean +lib/lean/Lean/Meta/Constructions/NoConfusionLinear.ir lib/lean/Lean/Meta/Constructions/NoConfusionLinear.olean +lib/lean/Lean/Meta/Constructions/NoConfusionLinear.olean.private +lib/lean/Lean/Meta/Constructions/NoConfusionLinear.olean.server lib/lean/Lean/Meta/Constructions/RecOn.ilean +lib/lean/Lean/Meta/Constructions/RecOn.ir lib/lean/Lean/Meta/Constructions/RecOn.olean +lib/lean/Lean/Meta/Constructions/RecOn.olean.private +lib/lean/Lean/Meta/Constructions/RecOn.olean.server lib/lean/Lean/Meta/CtorRecognizer.ilean +lib/lean/Lean/Meta/CtorRecognizer.ir lib/lean/Lean/Meta/CtorRecognizer.olean +lib/lean/Lean/Meta/CtorRecognizer.olean.private +lib/lean/Lean/Meta/CtorRecognizer.olean.server lib/lean/Lean/Meta/DecLevel.ilean +lib/lean/Lean/Meta/DecLevel.ir lib/lean/Lean/Meta/DecLevel.olean +lib/lean/Lean/Meta/DecLevel.olean.private +lib/lean/Lean/Meta/DecLevel.olean.server lib/lean/Lean/Meta/Diagnostics.ilean +lib/lean/Lean/Meta/Diagnostics.ir lib/lean/Lean/Meta/Diagnostics.olean +lib/lean/Lean/Meta/Diagnostics.olean.private +lib/lean/Lean/Meta/Diagnostics.olean.server lib/lean/Lean/Meta/DiscrTree.ilean +lib/lean/Lean/Meta/DiscrTree.ir lib/lean/Lean/Meta/DiscrTree.olean +lib/lean/Lean/Meta/DiscrTree.olean.private +lib/lean/Lean/Meta/DiscrTree.olean.server lib/lean/Lean/Meta/DiscrTreeTypes.ilean +lib/lean/Lean/Meta/DiscrTreeTypes.ir lib/lean/Lean/Meta/DiscrTreeTypes.olean +lib/lean/Lean/Meta/DiscrTreeTypes.olean.private +lib/lean/Lean/Meta/DiscrTreeTypes.olean.server lib/lean/Lean/Meta/Eqns.ilean +lib/lean/Lean/Meta/Eqns.ir lib/lean/Lean/Meta/Eqns.olean +lib/lean/Lean/Meta/Eqns.olean.private +lib/lean/Lean/Meta/Eqns.olean.server lib/lean/Lean/Meta/Eval.ilean +lib/lean/Lean/Meta/Eval.ir lib/lean/Lean/Meta/Eval.olean +lib/lean/Lean/Meta/Eval.olean.private +lib/lean/Lean/Meta/Eval.olean.server lib/lean/Lean/Meta/ExprDefEq.ilean +lib/lean/Lean/Meta/ExprDefEq.ir lib/lean/Lean/Meta/ExprDefEq.olean +lib/lean/Lean/Meta/ExprDefEq.olean.private +lib/lean/Lean/Meta/ExprDefEq.olean.server lib/lean/Lean/Meta/ExprLens.ilean +lib/lean/Lean/Meta/ExprLens.ir lib/lean/Lean/Meta/ExprLens.olean +lib/lean/Lean/Meta/ExprLens.olean.private +lib/lean/Lean/Meta/ExprLens.olean.server lib/lean/Lean/Meta/ExprTraverse.ilean +lib/lean/Lean/Meta/ExprTraverse.ir lib/lean/Lean/Meta/ExprTraverse.olean +lib/lean/Lean/Meta/ExprTraverse.olean.private +lib/lean/Lean/Meta/ExprTraverse.olean.server lib/lean/Lean/Meta/ForEachExpr.ilean +lib/lean/Lean/Meta/ForEachExpr.ir lib/lean/Lean/Meta/ForEachExpr.olean +lib/lean/Lean/Meta/ForEachExpr.olean.private +lib/lean/Lean/Meta/ForEachExpr.olean.server lib/lean/Lean/Meta/FunInfo.ilean +lib/lean/Lean/Meta/FunInfo.ir lib/lean/Lean/Meta/FunInfo.olean +lib/lean/Lean/Meta/FunInfo.olean.private +lib/lean/Lean/Meta/FunInfo.olean.server lib/lean/Lean/Meta/GeneralizeTelescope.ilean +lib/lean/Lean/Meta/GeneralizeTelescope.ir lib/lean/Lean/Meta/GeneralizeTelescope.olean +lib/lean/Lean/Meta/GeneralizeTelescope.olean.private +lib/lean/Lean/Meta/GeneralizeTelescope.olean.server lib/lean/Lean/Meta/GeneralizeVars.ilean +lib/lean/Lean/Meta/GeneralizeVars.ir lib/lean/Lean/Meta/GeneralizeVars.olean +lib/lean/Lean/Meta/GeneralizeVars.olean.private +lib/lean/Lean/Meta/GeneralizeVars.olean.server lib/lean/Lean/Meta/GetUnfoldableConst.ilean +lib/lean/Lean/Meta/GetUnfoldableConst.ir lib/lean/Lean/Meta/GetUnfoldableConst.olean +lib/lean/Lean/Meta/GetUnfoldableConst.olean.private +lib/lean/Lean/Meta/GetUnfoldableConst.olean.server lib/lean/Lean/Meta/GlobalInstances.ilean +lib/lean/Lean/Meta/GlobalInstances.ir lib/lean/Lean/Meta/GlobalInstances.olean +lib/lean/Lean/Meta/GlobalInstances.olean.private +lib/lean/Lean/Meta/GlobalInstances.olean.server lib/lean/Lean/Meta/Hint.ilean +lib/lean/Lean/Meta/Hint.ir lib/lean/Lean/Meta/Hint.olean +lib/lean/Lean/Meta/Hint.olean.private +lib/lean/Lean/Meta/Hint.olean.server lib/lean/Lean/Meta/IndPredBelow.ilean +lib/lean/Lean/Meta/IndPredBelow.ir lib/lean/Lean/Meta/IndPredBelow.olean +lib/lean/Lean/Meta/IndPredBelow.olean.private +lib/lean/Lean/Meta/IndPredBelow.olean.server lib/lean/Lean/Meta/Inductive.ilean +lib/lean/Lean/Meta/Inductive.ir lib/lean/Lean/Meta/Inductive.olean +lib/lean/Lean/Meta/Inductive.olean.private +lib/lean/Lean/Meta/Inductive.olean.server lib/lean/Lean/Meta/InferType.ilean +lib/lean/Lean/Meta/InferType.ir lib/lean/Lean/Meta/InferType.olean +lib/lean/Lean/Meta/InferType.olean.private +lib/lean/Lean/Meta/InferType.olean.server lib/lean/Lean/Meta/Injective.ilean +lib/lean/Lean/Meta/Injective.ir lib/lean/Lean/Meta/Injective.olean +lib/lean/Lean/Meta/Injective.olean.private +lib/lean/Lean/Meta/Injective.olean.server lib/lean/Lean/Meta/Instances.ilean +lib/lean/Lean/Meta/Instances.ir lib/lean/Lean/Meta/Instances.olean +lib/lean/Lean/Meta/Instances.olean.private +lib/lean/Lean/Meta/Instances.olean.server lib/lean/Lean/Meta/IntInstTesters.ilean +lib/lean/Lean/Meta/IntInstTesters.ir lib/lean/Lean/Meta/IntInstTesters.olean +lib/lean/Lean/Meta/IntInstTesters.olean.private +lib/lean/Lean/Meta/IntInstTesters.olean.server lib/lean/Lean/Meta/Iterator.ilean +lib/lean/Lean/Meta/Iterator.ir lib/lean/Lean/Meta/Iterator.olean +lib/lean/Lean/Meta/Iterator.olean.private +lib/lean/Lean/Meta/Iterator.olean.server lib/lean/Lean/Meta/KAbstract.ilean +lib/lean/Lean/Meta/KAbstract.ir lib/lean/Lean/Meta/KAbstract.olean +lib/lean/Lean/Meta/KAbstract.olean.private +lib/lean/Lean/Meta/KAbstract.olean.server lib/lean/Lean/Meta/KExprMap.ilean +lib/lean/Lean/Meta/KExprMap.ir lib/lean/Lean/Meta/KExprMap.olean +lib/lean/Lean/Meta/KExprMap.olean.private +lib/lean/Lean/Meta/KExprMap.olean.server lib/lean/Lean/Meta/LazyDiscrTree.ilean +lib/lean/Lean/Meta/LazyDiscrTree.ir lib/lean/Lean/Meta/LazyDiscrTree.olean +lib/lean/Lean/Meta/LazyDiscrTree.olean.private +lib/lean/Lean/Meta/LazyDiscrTree.olean.server lib/lean/Lean/Meta/LetToHave.ilean +lib/lean/Lean/Meta/LetToHave.ir lib/lean/Lean/Meta/LetToHave.olean +lib/lean/Lean/Meta/LetToHave.olean.private +lib/lean/Lean/Meta/LetToHave.olean.server lib/lean/Lean/Meta/LevelDefEq.ilean +lib/lean/Lean/Meta/LevelDefEq.ir lib/lean/Lean/Meta/LevelDefEq.olean +lib/lean/Lean/Meta/LevelDefEq.olean.private +lib/lean/Lean/Meta/LevelDefEq.olean.server lib/lean/Lean/Meta/LitValues.ilean +lib/lean/Lean/Meta/LitValues.ir lib/lean/Lean/Meta/LitValues.olean +lib/lean/Lean/Meta/LitValues.olean.private +lib/lean/Lean/Meta/LitValues.olean.server lib/lean/Lean/Meta/Match.ilean +lib/lean/Lean/Meta/Match.ir lib/lean/Lean/Meta/Match.olean +lib/lean/Lean/Meta/Match.olean.private +lib/lean/Lean/Meta/Match.olean.server lib/lean/Lean/Meta/Match/Basic.ilean +lib/lean/Lean/Meta/Match/Basic.ir lib/lean/Lean/Meta/Match/Basic.olean +lib/lean/Lean/Meta/Match/Basic.olean.private +lib/lean/Lean/Meta/Match/Basic.olean.server lib/lean/Lean/Meta/Match/CaseArraySizes.ilean +lib/lean/Lean/Meta/Match/CaseArraySizes.ir lib/lean/Lean/Meta/Match/CaseArraySizes.olean +lib/lean/Lean/Meta/Match/CaseArraySizes.olean.private +lib/lean/Lean/Meta/Match/CaseArraySizes.olean.server lib/lean/Lean/Meta/Match/CaseValues.ilean +lib/lean/Lean/Meta/Match/CaseValues.ir lib/lean/Lean/Meta/Match/CaseValues.olean +lib/lean/Lean/Meta/Match/CaseValues.olean.private +lib/lean/Lean/Meta/Match/CaseValues.olean.server lib/lean/Lean/Meta/Match/MVarRenaming.ilean +lib/lean/Lean/Meta/Match/MVarRenaming.ir lib/lean/Lean/Meta/Match/MVarRenaming.olean +lib/lean/Lean/Meta/Match/MVarRenaming.olean.private +lib/lean/Lean/Meta/Match/MVarRenaming.olean.server lib/lean/Lean/Meta/Match/Match.ilean +lib/lean/Lean/Meta/Match/Match.ir lib/lean/Lean/Meta/Match/Match.olean +lib/lean/Lean/Meta/Match/Match.olean.private +lib/lean/Lean/Meta/Match/Match.olean.server lib/lean/Lean/Meta/Match/MatchEqs.ilean +lib/lean/Lean/Meta/Match/MatchEqs.ir lib/lean/Lean/Meta/Match/MatchEqs.olean +lib/lean/Lean/Meta/Match/MatchEqs.olean.private +lib/lean/Lean/Meta/Match/MatchEqs.olean.server lib/lean/Lean/Meta/Match/MatchEqsExt.ilean +lib/lean/Lean/Meta/Match/MatchEqsExt.ir lib/lean/Lean/Meta/Match/MatchEqsExt.olean +lib/lean/Lean/Meta/Match/MatchEqsExt.olean.private +lib/lean/Lean/Meta/Match/MatchEqsExt.olean.server lib/lean/Lean/Meta/Match/MatchPatternAttr.ilean +lib/lean/Lean/Meta/Match/MatchPatternAttr.ir lib/lean/Lean/Meta/Match/MatchPatternAttr.olean +lib/lean/Lean/Meta/Match/MatchPatternAttr.olean.private +lib/lean/Lean/Meta/Match/MatchPatternAttr.olean.server lib/lean/Lean/Meta/Match/MatcherApp.ilean +lib/lean/Lean/Meta/Match/MatcherApp.ir lib/lean/Lean/Meta/Match/MatcherApp.olean +lib/lean/Lean/Meta/Match/MatcherApp.olean.private +lib/lean/Lean/Meta/Match/MatcherApp.olean.server lib/lean/Lean/Meta/Match/MatcherApp/Basic.ilean +lib/lean/Lean/Meta/Match/MatcherApp/Basic.ir lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean +lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean.private +lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean.server lib/lean/Lean/Meta/Match/MatcherApp/Transform.ilean +lib/lean/Lean/Meta/Match/MatcherApp/Transform.ir lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean +lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean.private +lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean.server lib/lean/Lean/Meta/Match/MatcherInfo.ilean +lib/lean/Lean/Meta/Match/MatcherInfo.ir lib/lean/Lean/Meta/Match/MatcherInfo.olean +lib/lean/Lean/Meta/Match/MatcherInfo.olean.private +lib/lean/Lean/Meta/Match/MatcherInfo.olean.server lib/lean/Lean/Meta/Match/Value.ilean +lib/lean/Lean/Meta/Match/Value.ir lib/lean/Lean/Meta/Match/Value.olean +lib/lean/Lean/Meta/Match/Value.olean.private +lib/lean/Lean/Meta/Match/Value.olean.server lib/lean/Lean/Meta/MatchUtil.ilean +lib/lean/Lean/Meta/MatchUtil.ir lib/lean/Lean/Meta/MatchUtil.olean +lib/lean/Lean/Meta/MatchUtil.olean.private +lib/lean/Lean/Meta/MatchUtil.olean.server lib/lean/Lean/Meta/NatInstTesters.ilean +lib/lean/Lean/Meta/NatInstTesters.ir lib/lean/Lean/Meta/NatInstTesters.olean +lib/lean/Lean/Meta/NatInstTesters.olean.private +lib/lean/Lean/Meta/NatInstTesters.olean.server lib/lean/Lean/Meta/Offset.ilean +lib/lean/Lean/Meta/Offset.ir lib/lean/Lean/Meta/Offset.olean +lib/lean/Lean/Meta/Offset.olean.private +lib/lean/Lean/Meta/Offset.olean.server lib/lean/Lean/Meta/Order.ilean +lib/lean/Lean/Meta/Order.ir lib/lean/Lean/Meta/Order.olean +lib/lean/Lean/Meta/Order.olean.private +lib/lean/Lean/Meta/Order.olean.server lib/lean/Lean/Meta/PPGoal.ilean +lib/lean/Lean/Meta/PPGoal.ir lib/lean/Lean/Meta/PPGoal.olean +lib/lean/Lean/Meta/PPGoal.olean.private +lib/lean/Lean/Meta/PPGoal.olean.server lib/lean/Lean/Meta/PProdN.ilean +lib/lean/Lean/Meta/PProdN.ir lib/lean/Lean/Meta/PProdN.olean +lib/lean/Lean/Meta/PProdN.olean.private +lib/lean/Lean/Meta/PProdN.olean.server lib/lean/Lean/Meta/RecursorInfo.ilean +lib/lean/Lean/Meta/RecursorInfo.ir lib/lean/Lean/Meta/RecursorInfo.olean +lib/lean/Lean/Meta/RecursorInfo.olean.private +lib/lean/Lean/Meta/RecursorInfo.olean.server lib/lean/Lean/Meta/Reduce.ilean +lib/lean/Lean/Meta/Reduce.ir lib/lean/Lean/Meta/Reduce.olean +lib/lean/Lean/Meta/Reduce.olean.private +lib/lean/Lean/Meta/Reduce.olean.server lib/lean/Lean/Meta/ReduceEval.ilean +lib/lean/Lean/Meta/ReduceEval.ir lib/lean/Lean/Meta/ReduceEval.olean +lib/lean/Lean/Meta/ReduceEval.olean.private +lib/lean/Lean/Meta/ReduceEval.olean.server lib/lean/Lean/Meta/SizeOf.ilean +lib/lean/Lean/Meta/SizeOf.ir lib/lean/Lean/Meta/SizeOf.olean +lib/lean/Lean/Meta/SizeOf.olean.private +lib/lean/Lean/Meta/SizeOf.olean.server lib/lean/Lean/Meta/Sorry.ilean +lib/lean/Lean/Meta/Sorry.ir lib/lean/Lean/Meta/Sorry.olean +lib/lean/Lean/Meta/Sorry.olean.private +lib/lean/Lean/Meta/Sorry.olean.server lib/lean/Lean/Meta/Structure.ilean +lib/lean/Lean/Meta/Structure.ir lib/lean/Lean/Meta/Structure.olean +lib/lean/Lean/Meta/Structure.olean.private +lib/lean/Lean/Meta/Structure.olean.server lib/lean/Lean/Meta/SynthInstance.ilean +lib/lean/Lean/Meta/SynthInstance.ir lib/lean/Lean/Meta/SynthInstance.olean +lib/lean/Lean/Meta/SynthInstance.olean.private +lib/lean/Lean/Meta/SynthInstance.olean.server lib/lean/Lean/Meta/Tactic.ilean +lib/lean/Lean/Meta/Tactic.ir lib/lean/Lean/Meta/Tactic.olean +lib/lean/Lean/Meta/Tactic.olean.private +lib/lean/Lean/Meta/Tactic.olean.server lib/lean/Lean/Meta/Tactic/AC.ilean +lib/lean/Lean/Meta/Tactic/AC.ir lib/lean/Lean/Meta/Tactic/AC.olean +lib/lean/Lean/Meta/Tactic/AC.olean.private +lib/lean/Lean/Meta/Tactic/AC.olean.server lib/lean/Lean/Meta/Tactic/AC/Main.ilean +lib/lean/Lean/Meta/Tactic/AC/Main.ir lib/lean/Lean/Meta/Tactic/AC/Main.olean +lib/lean/Lean/Meta/Tactic/AC/Main.olean.private +lib/lean/Lean/Meta/Tactic/AC/Main.olean.server lib/lean/Lean/Meta/Tactic/Acyclic.ilean +lib/lean/Lean/Meta/Tactic/Acyclic.ir lib/lean/Lean/Meta/Tactic/Acyclic.olean +lib/lean/Lean/Meta/Tactic/Acyclic.olean.private +lib/lean/Lean/Meta/Tactic/Acyclic.olean.server lib/lean/Lean/Meta/Tactic/Apply.ilean +lib/lean/Lean/Meta/Tactic/Apply.ir lib/lean/Lean/Meta/Tactic/Apply.olean +lib/lean/Lean/Meta/Tactic/Apply.olean.private +lib/lean/Lean/Meta/Tactic/Apply.olean.server lib/lean/Lean/Meta/Tactic/Assert.ilean +lib/lean/Lean/Meta/Tactic/Assert.ir lib/lean/Lean/Meta/Tactic/Assert.olean +lib/lean/Lean/Meta/Tactic/Assert.olean.private +lib/lean/Lean/Meta/Tactic/Assert.olean.server lib/lean/Lean/Meta/Tactic/Assumption.ilean +lib/lean/Lean/Meta/Tactic/Assumption.ir lib/lean/Lean/Meta/Tactic/Assumption.olean +lib/lean/Lean/Meta/Tactic/Assumption.olean.private +lib/lean/Lean/Meta/Tactic/Assumption.olean.server lib/lean/Lean/Meta/Tactic/AuxLemma.ilean +lib/lean/Lean/Meta/Tactic/AuxLemma.ir lib/lean/Lean/Meta/Tactic/AuxLemma.olean +lib/lean/Lean/Meta/Tactic/AuxLemma.olean.private +lib/lean/Lean/Meta/Tactic/AuxLemma.olean.server lib/lean/Lean/Meta/Tactic/Backtrack.ilean +lib/lean/Lean/Meta/Tactic/Backtrack.ir lib/lean/Lean/Meta/Tactic/Backtrack.olean +lib/lean/Lean/Meta/Tactic/Backtrack.olean.private +lib/lean/Lean/Meta/Tactic/Backtrack.olean.server lib/lean/Lean/Meta/Tactic/Cases.ilean +lib/lean/Lean/Meta/Tactic/Cases.ir lib/lean/Lean/Meta/Tactic/Cases.olean +lib/lean/Lean/Meta/Tactic/Cases.olean.private +lib/lean/Lean/Meta/Tactic/Cases.olean.server lib/lean/Lean/Meta/Tactic/Cleanup.ilean +lib/lean/Lean/Meta/Tactic/Cleanup.ir lib/lean/Lean/Meta/Tactic/Cleanup.olean +lib/lean/Lean/Meta/Tactic/Cleanup.olean.private +lib/lean/Lean/Meta/Tactic/Cleanup.olean.server lib/lean/Lean/Meta/Tactic/Clear.ilean +lib/lean/Lean/Meta/Tactic/Clear.ir lib/lean/Lean/Meta/Tactic/Clear.olean +lib/lean/Lean/Meta/Tactic/Clear.olean.private +lib/lean/Lean/Meta/Tactic/Clear.olean.server lib/lean/Lean/Meta/Tactic/Congr.ilean +lib/lean/Lean/Meta/Tactic/Congr.ir lib/lean/Lean/Meta/Tactic/Congr.olean +lib/lean/Lean/Meta/Tactic/Congr.olean.private +lib/lean/Lean/Meta/Tactic/Congr.olean.server lib/lean/Lean/Meta/Tactic/Constructor.ilean +lib/lean/Lean/Meta/Tactic/Constructor.ir lib/lean/Lean/Meta/Tactic/Constructor.olean +lib/lean/Lean/Meta/Tactic/Constructor.olean.private +lib/lean/Lean/Meta/Tactic/Constructor.olean.server lib/lean/Lean/Meta/Tactic/Contradiction.ilean +lib/lean/Lean/Meta/Tactic/Contradiction.ir lib/lean/Lean/Meta/Tactic/Contradiction.olean +lib/lean/Lean/Meta/Tactic/Contradiction.olean.private +lib/lean/Lean/Meta/Tactic/Contradiction.olean.server lib/lean/Lean/Meta/Tactic/Delta.ilean +lib/lean/Lean/Meta/Tactic/Delta.ir lib/lean/Lean/Meta/Tactic/Delta.olean +lib/lean/Lean/Meta/Tactic/Delta.olean.private +lib/lean/Lean/Meta/Tactic/Delta.olean.server lib/lean/Lean/Meta/Tactic/ElimInfo.ilean +lib/lean/Lean/Meta/Tactic/ElimInfo.ir lib/lean/Lean/Meta/Tactic/ElimInfo.olean +lib/lean/Lean/Meta/Tactic/ElimInfo.olean.private +lib/lean/Lean/Meta/Tactic/ElimInfo.olean.server lib/lean/Lean/Meta/Tactic/ExposeNames.ilean +lib/lean/Lean/Meta/Tactic/ExposeNames.ir lib/lean/Lean/Meta/Tactic/ExposeNames.olean +lib/lean/Lean/Meta/Tactic/ExposeNames.olean.private +lib/lean/Lean/Meta/Tactic/ExposeNames.olean.server lib/lean/Lean/Meta/Tactic/Ext.ilean +lib/lean/Lean/Meta/Tactic/Ext.ir lib/lean/Lean/Meta/Tactic/Ext.olean +lib/lean/Lean/Meta/Tactic/Ext.olean.private +lib/lean/Lean/Meta/Tactic/Ext.olean.server lib/lean/Lean/Meta/Tactic/FVarSubst.ilean +lib/lean/Lean/Meta/Tactic/FVarSubst.ir lib/lean/Lean/Meta/Tactic/FVarSubst.olean +lib/lean/Lean/Meta/Tactic/FVarSubst.olean.private +lib/lean/Lean/Meta/Tactic/FVarSubst.olean.server lib/lean/Lean/Meta/Tactic/FunInd.ilean +lib/lean/Lean/Meta/Tactic/FunInd.ir lib/lean/Lean/Meta/Tactic/FunInd.olean +lib/lean/Lean/Meta/Tactic/FunInd.olean.private +lib/lean/Lean/Meta/Tactic/FunInd.olean.server lib/lean/Lean/Meta/Tactic/FunIndCollect.ilean +lib/lean/Lean/Meta/Tactic/FunIndCollect.ir lib/lean/Lean/Meta/Tactic/FunIndCollect.olean +lib/lean/Lean/Meta/Tactic/FunIndCollect.olean.private +lib/lean/Lean/Meta/Tactic/FunIndCollect.olean.server lib/lean/Lean/Meta/Tactic/FunIndInfo.ilean +lib/lean/Lean/Meta/Tactic/FunIndInfo.ir lib/lean/Lean/Meta/Tactic/FunIndInfo.olean +lib/lean/Lean/Meta/Tactic/FunIndInfo.olean.private +lib/lean/Lean/Meta/Tactic/FunIndInfo.olean.server lib/lean/Lean/Meta/Tactic/Generalize.ilean +lib/lean/Lean/Meta/Tactic/Generalize.ir lib/lean/Lean/Meta/Tactic/Generalize.olean +lib/lean/Lean/Meta/Tactic/Generalize.olean.private +lib/lean/Lean/Meta/Tactic/Generalize.olean.server lib/lean/Lean/Meta/Tactic/Grind.ilean +lib/lean/Lean/Meta/Tactic/Grind.ir lib/lean/Lean/Meta/Tactic/Grind.olean +lib/lean/Lean/Meta/Tactic/Grind.olean.private +lib/lean/Lean/Meta/Tactic/Grind.olean.server lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.ilean +lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.ir lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.olean +lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.olean.private +lib/lean/Lean/Meta/Tactic/Grind/AlphaShareCommon.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith.ir lib/lean/Lean/Meta/Tactic/Grind/Arith.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/DenoteExpr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/EqCnstr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Internalize.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Inv.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/PP.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Poly.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Proof.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Reify.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/RingId.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/SafePoly.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/SafePoly.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/SafePoly.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/SafePoly.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/SafePoly.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/ToExpr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Util.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/CommRing/Var.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/CommRing.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/CommRing.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/CommRing.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/CommRing.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/CommRing.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ReorderVars.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ReorderVars.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ReorderVars.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ReorderVars.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ReorderVars.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToInt.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToInt.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToInt.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToInt.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToInt.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToIntInfo.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToIntInfo.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToIntInfo.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToIntInfo.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/ToIntInfo.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean.server +lib/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.ir +lib/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.olean.server +lib/lean/Lean/Meta/Tactic/Grind/Arith/Insts.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Insts.ir +lib/lean/Lean/Meta/Tactic/Grind/Arith/Insts.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Insts.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Insts.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/DenoteExpr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/DenoteExpr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/DenoteExpr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/DenoteExpr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/DenoteExpr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/IneqCnstr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/IneqCnstr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/IneqCnstr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/IneqCnstr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/IneqCnstr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Internalize.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Internalize.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Internalize.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Internalize.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Internalize.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Inv.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Inv.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Inv.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Inv.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Inv.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/MBTC.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/MBTC.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/MBTC.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/MBTC.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/MBTC.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Model.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Model.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Model.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Model.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Model.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PP.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PP.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PP.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PP.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PP.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Proof.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Proof.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Proof.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Proof.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Proof.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PropagateEq.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PropagateEq.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PropagateEq.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PropagateEq.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/PropagateEq.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Reify.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Reify.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Reify.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Reify.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Reify.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Search.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Search.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Search.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Search.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Search.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/SearchM.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/SearchM.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/SearchM.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/SearchM.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/SearchM.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/StructId.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/StructId.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/StructId.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/StructId.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/StructId.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/ToExpr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/ToExpr.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/ToExpr.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/ToExpr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/ToExpr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Util.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Var.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Var.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Var.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Var.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Linear/Var.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/ModelUtil.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/ModelUtil.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/ModelUtil.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/ModelUtil.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/ModelUtil.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/ProofUtil.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Simproc.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Simproc.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Simproc.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Simproc.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Simproc.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean.server lib/lean/Lean/Meta/Tactic/Grind/Attr.ilean +lib/lean/Lean/Meta/Tactic/Grind/Attr.ir lib/lean/Lean/Meta/Tactic/Grind/Attr.olean +lib/lean/Lean/Meta/Tactic/Grind/Attr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Attr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Beta.ilean +lib/lean/Lean/Meta/Tactic/Grind/Beta.ir lib/lean/Lean/Meta/Tactic/Grind/Beta.olean +lib/lean/Lean/Meta/Tactic/Grind/Beta.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Beta.olean.server lib/lean/Lean/Meta/Tactic/Grind/Canon.ilean +lib/lean/Lean/Meta/Tactic/Grind/Canon.ir lib/lean/Lean/Meta/Tactic/Grind/Canon.olean +lib/lean/Lean/Meta/Tactic/Grind/Canon.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Canon.olean.server lib/lean/Lean/Meta/Tactic/Grind/Cases.ilean +lib/lean/Lean/Meta/Tactic/Grind/Cases.ir lib/lean/Lean/Meta/Tactic/Grind/Cases.olean +lib/lean/Lean/Meta/Tactic/Grind/Cases.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Cases.olean.server lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.ilean +lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.ir lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean +lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean.private +lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean.server lib/lean/Lean/Meta/Tactic/Grind/Core.ilean +lib/lean/Lean/Meta/Tactic/Grind/Core.ir lib/lean/Lean/Meta/Tactic/Grind/Core.olean +lib/lean/Lean/Meta/Tactic/Grind/Core.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Core.olean.server lib/lean/Lean/Meta/Tactic/Grind/Ctor.ilean +lib/lean/Lean/Meta/Tactic/Grind/Ctor.ir lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean +lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean.server lib/lean/Lean/Meta/Tactic/Grind/Diseq.ilean +lib/lean/Lean/Meta/Tactic/Grind/Diseq.ir lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean +lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean.server lib/lean/Lean/Meta/Tactic/Grind/EMatch.ilean +lib/lean/Lean/Meta/Tactic/Grind/EMatch.ir lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean +lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean.private +lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean.server lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.ilean +lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.ir lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean +lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean.private +lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean.server lib/lean/Lean/Meta/Tactic/Grind/EqResolution.ilean +lib/lean/Lean/Meta/Tactic/Grind/EqResolution.ir lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean +lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean.private +lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean.server lib/lean/Lean/Meta/Tactic/Grind/ExprPtr.ilean +lib/lean/Lean/Meta/Tactic/Grind/ExprPtr.ir lib/lean/Lean/Meta/Tactic/Grind/ExprPtr.olean +lib/lean/Lean/Meta/Tactic/Grind/ExprPtr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/ExprPtr.olean.server lib/lean/Lean/Meta/Tactic/Grind/Ext.ilean +lib/lean/Lean/Meta/Tactic/Grind/Ext.ir lib/lean/Lean/Meta/Tactic/Grind/Ext.olean +lib/lean/Lean/Meta/Tactic/Grind/Ext.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Ext.olean.server lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.ilean +lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.ir lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.olean +lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/ExtAttr.olean.server lib/lean/Lean/Meta/Tactic/Grind/ForallProp.ilean +lib/lean/Lean/Meta/Tactic/Grind/ForallProp.ir lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean +lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean.private +lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean.server lib/lean/Lean/Meta/Tactic/Grind/Injection.ilean +lib/lean/Lean/Meta/Tactic/Grind/Injection.ir lib/lean/Lean/Meta/Tactic/Grind/Injection.olean +lib/lean/Lean/Meta/Tactic/Grind/Injection.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Injection.olean.server lib/lean/Lean/Meta/Tactic/Grind/Internalize.ilean +lib/lean/Lean/Meta/Tactic/Grind/Internalize.ir lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean +lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean.server lib/lean/Lean/Meta/Tactic/Grind/Intro.ilean +lib/lean/Lean/Meta/Tactic/Grind/Intro.ir lib/lean/Lean/Meta/Tactic/Grind/Intro.olean +lib/lean/Lean/Meta/Tactic/Grind/Intro.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Intro.olean.server lib/lean/Lean/Meta/Tactic/Grind/Inv.ilean +lib/lean/Lean/Meta/Tactic/Grind/Inv.ir lib/lean/Lean/Meta/Tactic/Grind/Inv.olean +lib/lean/Lean/Meta/Tactic/Grind/Inv.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Inv.olean.server lib/lean/Lean/Meta/Tactic/Grind/LawfulEqCmp.ilean +lib/lean/Lean/Meta/Tactic/Grind/LawfulEqCmp.ir lib/lean/Lean/Meta/Tactic/Grind/LawfulEqCmp.olean +lib/lean/Lean/Meta/Tactic/Grind/LawfulEqCmp.olean.private +lib/lean/Lean/Meta/Tactic/Grind/LawfulEqCmp.olean.server lib/lean/Lean/Meta/Tactic/Grind/Lookahead.ilean +lib/lean/Lean/Meta/Tactic/Grind/Lookahead.ir lib/lean/Lean/Meta/Tactic/Grind/Lookahead.olean +lib/lean/Lean/Meta/Tactic/Grind/Lookahead.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Lookahead.olean.server lib/lean/Lean/Meta/Tactic/Grind/MBTC.ilean +lib/lean/Lean/Meta/Tactic/Grind/MBTC.ir lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean +lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean.private +lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean.server lib/lean/Lean/Meta/Tactic/Grind/Main.ilean +lib/lean/Lean/Meta/Tactic/Grind/Main.ir lib/lean/Lean/Meta/Tactic/Grind/Main.olean -lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.ilean -lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean +lib/lean/Lean/Meta/Tactic/Grind/Main.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Main.olean.server +lib/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.ilean +lib/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.ir +lib/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.olean +lib/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.olean.private +lib/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.olean.server lib/lean/Lean/Meta/Tactic/Grind/MatchCond.ilean +lib/lean/Lean/Meta/Tactic/Grind/MatchCond.ir lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean +lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean.private +lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean.server lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.ilean +lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.ir lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean +lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean.private +lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean.server lib/lean/Lean/Meta/Tactic/Grind/PP.ilean +lib/lean/Lean/Meta/Tactic/Grind/PP.ir lib/lean/Lean/Meta/Tactic/Grind/PP.olean +lib/lean/Lean/Meta/Tactic/Grind/PP.olean.private +lib/lean/Lean/Meta/Tactic/Grind/PP.olean.server lib/lean/Lean/Meta/Tactic/Grind/Parser.ilean +lib/lean/Lean/Meta/Tactic/Grind/Parser.ir lib/lean/Lean/Meta/Tactic/Grind/Parser.olean +lib/lean/Lean/Meta/Tactic/Grind/Parser.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Parser.olean.server lib/lean/Lean/Meta/Tactic/Grind/Proj.ilean +lib/lean/Lean/Meta/Tactic/Grind/Proj.ir lib/lean/Lean/Meta/Tactic/Grind/Proj.olean +lib/lean/Lean/Meta/Tactic/Grind/Proj.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Proj.olean.server lib/lean/Lean/Meta/Tactic/Grind/Proof.ilean +lib/lean/Lean/Meta/Tactic/Grind/Proof.ir lib/lean/Lean/Meta/Tactic/Grind/Proof.olean +lib/lean/Lean/Meta/Tactic/Grind/Proof.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Proof.olean.server lib/lean/Lean/Meta/Tactic/Grind/Propagate.ilean +lib/lean/Lean/Meta/Tactic/Grind/Propagate.ir lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean +lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean.server lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.ilean +lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.ir lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean +lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean.private +lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean.server lib/lean/Lean/Meta/Tactic/Grind/ProveEq.ilean +lib/lean/Lean/Meta/Tactic/Grind/ProveEq.ir lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean +lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean.private +lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean.server lib/lean/Lean/Meta/Tactic/Grind/ReflCmp.ilean +lib/lean/Lean/Meta/Tactic/Grind/ReflCmp.ir lib/lean/Lean/Meta/Tactic/Grind/ReflCmp.olean +lib/lean/Lean/Meta/Tactic/Grind/ReflCmp.olean.private +lib/lean/Lean/Meta/Tactic/Grind/ReflCmp.olean.server lib/lean/Lean/Meta/Tactic/Grind/RevertAll.ilean +lib/lean/Lean/Meta/Tactic/Grind/RevertAll.ir lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean +lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean.private +lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean.server lib/lean/Lean/Meta/Tactic/Grind/SearchM.ilean +lib/lean/Lean/Meta/Tactic/Grind/SearchM.ir lib/lean/Lean/Meta/Tactic/Grind/SearchM.olean +lib/lean/Lean/Meta/Tactic/Grind/SearchM.olean.private +lib/lean/Lean/Meta/Tactic/Grind/SearchM.olean.server lib/lean/Lean/Meta/Tactic/Grind/Simp.ilean +lib/lean/Lean/Meta/Tactic/Grind/Simp.ir lib/lean/Lean/Meta/Tactic/Grind/Simp.olean +lib/lean/Lean/Meta/Tactic/Grind/Simp.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Simp.olean.server lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.ilean +lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.ir lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean +lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean.private +lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean.server lib/lean/Lean/Meta/Tactic/Grind/Solve.ilean +lib/lean/Lean/Meta/Tactic/Grind/Solve.ir lib/lean/Lean/Meta/Tactic/Grind/Solve.olean +lib/lean/Lean/Meta/Tactic/Grind/Solve.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Solve.olean.server lib/lean/Lean/Meta/Tactic/Grind/Split.ilean +lib/lean/Lean/Meta/Tactic/Grind/Split.ir lib/lean/Lean/Meta/Tactic/Grind/Split.olean +lib/lean/Lean/Meta/Tactic/Grind/Split.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Split.olean.server +lib/lean/Lean/Meta/Tactic/Grind/SynthInstance.ilean +lib/lean/Lean/Meta/Tactic/Grind/SynthInstance.ir +lib/lean/Lean/Meta/Tactic/Grind/SynthInstance.olean +lib/lean/Lean/Meta/Tactic/Grind/SynthInstance.olean.private +lib/lean/Lean/Meta/Tactic/Grind/SynthInstance.olean.server lib/lean/Lean/Meta/Tactic/Grind/Types.ilean +lib/lean/Lean/Meta/Tactic/Grind/Types.ir lib/lean/Lean/Meta/Tactic/Grind/Types.olean +lib/lean/Lean/Meta/Tactic/Grind/Types.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Types.olean.server lib/lean/Lean/Meta/Tactic/Grind/Util.ilean +lib/lean/Lean/Meta/Tactic/Grind/Util.ir lib/lean/Lean/Meta/Tactic/Grind/Util.olean +lib/lean/Lean/Meta/Tactic/Grind/Util.olean.private +lib/lean/Lean/Meta/Tactic/Grind/Util.olean.server lib/lean/Lean/Meta/Tactic/IndependentOf.ilean +lib/lean/Lean/Meta/Tactic/IndependentOf.ir lib/lean/Lean/Meta/Tactic/IndependentOf.olean +lib/lean/Lean/Meta/Tactic/IndependentOf.olean.private +lib/lean/Lean/Meta/Tactic/IndependentOf.olean.server lib/lean/Lean/Meta/Tactic/Induction.ilean +lib/lean/Lean/Meta/Tactic/Induction.ir lib/lean/Lean/Meta/Tactic/Induction.olean +lib/lean/Lean/Meta/Tactic/Induction.olean.private +lib/lean/Lean/Meta/Tactic/Induction.olean.server lib/lean/Lean/Meta/Tactic/Injection.ilean +lib/lean/Lean/Meta/Tactic/Injection.ir lib/lean/Lean/Meta/Tactic/Injection.olean +lib/lean/Lean/Meta/Tactic/Injection.olean.private +lib/lean/Lean/Meta/Tactic/Injection.olean.server lib/lean/Lean/Meta/Tactic/Intro.ilean +lib/lean/Lean/Meta/Tactic/Intro.ir lib/lean/Lean/Meta/Tactic/Intro.olean +lib/lean/Lean/Meta/Tactic/Intro.olean.private +lib/lean/Lean/Meta/Tactic/Intro.olean.server lib/lean/Lean/Meta/Tactic/Lets.ilean +lib/lean/Lean/Meta/Tactic/Lets.ir lib/lean/Lean/Meta/Tactic/Lets.olean +lib/lean/Lean/Meta/Tactic/Lets.olean.private +lib/lean/Lean/Meta/Tactic/Lets.olean.server lib/lean/Lean/Meta/Tactic/LibrarySearch.ilean +lib/lean/Lean/Meta/Tactic/LibrarySearch.ir lib/lean/Lean/Meta/Tactic/LibrarySearch.olean +lib/lean/Lean/Meta/Tactic/LibrarySearch.olean.private +lib/lean/Lean/Meta/Tactic/LibrarySearch.olean.server lib/lean/Lean/Meta/Tactic/NormCast.ilean +lib/lean/Lean/Meta/Tactic/NormCast.ir lib/lean/Lean/Meta/Tactic/NormCast.olean +lib/lean/Lean/Meta/Tactic/NormCast.olean.private +lib/lean/Lean/Meta/Tactic/NormCast.olean.server lib/lean/Lean/Meta/Tactic/Refl.ilean +lib/lean/Lean/Meta/Tactic/Refl.ir lib/lean/Lean/Meta/Tactic/Refl.olean +lib/lean/Lean/Meta/Tactic/Refl.olean.private +lib/lean/Lean/Meta/Tactic/Refl.olean.server lib/lean/Lean/Meta/Tactic/Rename.ilean +lib/lean/Lean/Meta/Tactic/Rename.ir lib/lean/Lean/Meta/Tactic/Rename.olean +lib/lean/Lean/Meta/Tactic/Rename.olean.private +lib/lean/Lean/Meta/Tactic/Rename.olean.server lib/lean/Lean/Meta/Tactic/Repeat.ilean +lib/lean/Lean/Meta/Tactic/Repeat.ir lib/lean/Lean/Meta/Tactic/Repeat.olean +lib/lean/Lean/Meta/Tactic/Repeat.olean.private +lib/lean/Lean/Meta/Tactic/Repeat.olean.server lib/lean/Lean/Meta/Tactic/Replace.ilean +lib/lean/Lean/Meta/Tactic/Replace.ir lib/lean/Lean/Meta/Tactic/Replace.olean +lib/lean/Lean/Meta/Tactic/Replace.olean.private +lib/lean/Lean/Meta/Tactic/Replace.olean.server lib/lean/Lean/Meta/Tactic/Revert.ilean +lib/lean/Lean/Meta/Tactic/Revert.ir lib/lean/Lean/Meta/Tactic/Revert.olean +lib/lean/Lean/Meta/Tactic/Revert.olean.private +lib/lean/Lean/Meta/Tactic/Revert.olean.server lib/lean/Lean/Meta/Tactic/Rewrite.ilean +lib/lean/Lean/Meta/Tactic/Rewrite.ir lib/lean/Lean/Meta/Tactic/Rewrite.olean +lib/lean/Lean/Meta/Tactic/Rewrite.olean.private +lib/lean/Lean/Meta/Tactic/Rewrite.olean.server lib/lean/Lean/Meta/Tactic/Rewrites.ilean +lib/lean/Lean/Meta/Tactic/Rewrites.ir lib/lean/Lean/Meta/Tactic/Rewrites.olean +lib/lean/Lean/Meta/Tactic/Rewrites.olean.private +lib/lean/Lean/Meta/Tactic/Rewrites.olean.server lib/lean/Lean/Meta/Tactic/Rfl.ilean +lib/lean/Lean/Meta/Tactic/Rfl.ir lib/lean/Lean/Meta/Tactic/Rfl.olean +lib/lean/Lean/Meta/Tactic/Rfl.olean.private +lib/lean/Lean/Meta/Tactic/Rfl.olean.server lib/lean/Lean/Meta/Tactic/Simp.ilean +lib/lean/Lean/Meta/Tactic/Simp.ir lib/lean/Lean/Meta/Tactic/Simp.olean +lib/lean/Lean/Meta/Tactic/Simp.olean.private +lib/lean/Lean/Meta/Tactic/Simp.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith.ir lib/lean/Lean/Meta/Tactic/Simp/Arith.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean.server lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.ilean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.ir lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean +lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean.server lib/lean/Lean/Meta/Tactic/Simp/Attr.ilean +lib/lean/Lean/Meta/Tactic/Simp/Attr.ir lib/lean/Lean/Meta/Tactic/Simp/Attr.olean +lib/lean/Lean/Meta/Tactic/Simp/Attr.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Attr.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean.server lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.ilean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.ir lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean.private +lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean.server lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.ilean +lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.ir lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean +lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean.server lib/lean/Lean/Meta/Tactic/Simp/LoopProtection.ilean +lib/lean/Lean/Meta/Tactic/Simp/LoopProtection.ir lib/lean/Lean/Meta/Tactic/Simp/LoopProtection.olean +lib/lean/Lean/Meta/Tactic/Simp/LoopProtection.olean.private +lib/lean/Lean/Meta/Tactic/Simp/LoopProtection.olean.server lib/lean/Lean/Meta/Tactic/Simp/Main.ilean +lib/lean/Lean/Meta/Tactic/Simp/Main.ir lib/lean/Lean/Meta/Tactic/Simp/Main.olean +lib/lean/Lean/Meta/Tactic/Simp/Main.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Main.olean.server lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.ilean +lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.ir lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean +lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean.private +lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean.server lib/lean/Lean/Meta/Tactic/Simp/Rewrite.ilean +lib/lean/Lean/Meta/Tactic/Simp/Rewrite.ir lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean +lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean.server lib/lean/Lean/Meta/Tactic/Simp/SimpAll.ilean +lib/lean/Lean/Meta/Tactic/Simp/SimpAll.ir lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean +lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean.private +lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean.server lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.ilean +lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.ir lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean +lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean.private +lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean.server lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.ilean +lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.ir lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean +lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean.private +lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean.server lib/lean/Lean/Meta/Tactic/Simp/Simproc.ilean +lib/lean/Lean/Meta/Tactic/Simp/Simproc.ir lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean +lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean.server lib/lean/Lean/Meta/Tactic/Simp/Types.ilean +lib/lean/Lean/Meta/Tactic/Simp/Types.ir lib/lean/Lean/Meta/Tactic/Simp/Types.olean +lib/lean/Lean/Meta/Tactic/Simp/Types.olean.private +lib/lean/Lean/Meta/Tactic/Simp/Types.olean.server lib/lean/Lean/Meta/Tactic/SolveByElim.ilean +lib/lean/Lean/Meta/Tactic/SolveByElim.ir lib/lean/Lean/Meta/Tactic/SolveByElim.olean +lib/lean/Lean/Meta/Tactic/SolveByElim.olean.private +lib/lean/Lean/Meta/Tactic/SolveByElim.olean.server lib/lean/Lean/Meta/Tactic/Split.ilean +lib/lean/Lean/Meta/Tactic/Split.ir lib/lean/Lean/Meta/Tactic/Split.olean +lib/lean/Lean/Meta/Tactic/Split.olean.private +lib/lean/Lean/Meta/Tactic/Split.olean.server lib/lean/Lean/Meta/Tactic/SplitIf.ilean +lib/lean/Lean/Meta/Tactic/SplitIf.ir lib/lean/Lean/Meta/Tactic/SplitIf.olean +lib/lean/Lean/Meta/Tactic/SplitIf.olean.private +lib/lean/Lean/Meta/Tactic/SplitIf.olean.server lib/lean/Lean/Meta/Tactic/Subst.ilean +lib/lean/Lean/Meta/Tactic/Subst.ir lib/lean/Lean/Meta/Tactic/Subst.olean +lib/lean/Lean/Meta/Tactic/Subst.olean.private +lib/lean/Lean/Meta/Tactic/Subst.olean.server lib/lean/Lean/Meta/Tactic/Symm.ilean +lib/lean/Lean/Meta/Tactic/Symm.ir lib/lean/Lean/Meta/Tactic/Symm.olean +lib/lean/Lean/Meta/Tactic/Symm.olean.private +lib/lean/Lean/Meta/Tactic/Symm.olean.server lib/lean/Lean/Meta/Tactic/Try.ilean +lib/lean/Lean/Meta/Tactic/Try.ir lib/lean/Lean/Meta/Tactic/Try.olean +lib/lean/Lean/Meta/Tactic/Try.olean.private +lib/lean/Lean/Meta/Tactic/Try.olean.server lib/lean/Lean/Meta/Tactic/Try/Collect.ilean +lib/lean/Lean/Meta/Tactic/Try/Collect.ir lib/lean/Lean/Meta/Tactic/Try/Collect.olean +lib/lean/Lean/Meta/Tactic/Try/Collect.olean.private +lib/lean/Lean/Meta/Tactic/Try/Collect.olean.server lib/lean/Lean/Meta/Tactic/TryThis.ilean +lib/lean/Lean/Meta/Tactic/TryThis.ir lib/lean/Lean/Meta/Tactic/TryThis.olean +lib/lean/Lean/Meta/Tactic/TryThis.olean.private +lib/lean/Lean/Meta/Tactic/TryThis.olean.server lib/lean/Lean/Meta/Tactic/Unfold.ilean +lib/lean/Lean/Meta/Tactic/Unfold.ir lib/lean/Lean/Meta/Tactic/Unfold.olean +lib/lean/Lean/Meta/Tactic/Unfold.olean.private +lib/lean/Lean/Meta/Tactic/Unfold.olean.server lib/lean/Lean/Meta/Tactic/UnifyEq.ilean +lib/lean/Lean/Meta/Tactic/UnifyEq.ir lib/lean/Lean/Meta/Tactic/UnifyEq.olean +lib/lean/Lean/Meta/Tactic/UnifyEq.olean.private +lib/lean/Lean/Meta/Tactic/UnifyEq.olean.server lib/lean/Lean/Meta/Tactic/Util.ilean +lib/lean/Lean/Meta/Tactic/Util.ir lib/lean/Lean/Meta/Tactic/Util.olean +lib/lean/Lean/Meta/Tactic/Util.olean.private +lib/lean/Lean/Meta/Tactic/Util.olean.server lib/lean/Lean/Meta/Transform.ilean +lib/lean/Lean/Meta/Transform.ir lib/lean/Lean/Meta/Transform.olean +lib/lean/Lean/Meta/Transform.olean.private +lib/lean/Lean/Meta/Transform.olean.server lib/lean/Lean/Meta/TransparencyMode.ilean +lib/lean/Lean/Meta/TransparencyMode.ir lib/lean/Lean/Meta/TransparencyMode.olean +lib/lean/Lean/Meta/TransparencyMode.olean.private +lib/lean/Lean/Meta/TransparencyMode.olean.server lib/lean/Lean/Meta/TryThis.ilean +lib/lean/Lean/Meta/TryThis.ir lib/lean/Lean/Meta/TryThis.olean +lib/lean/Lean/Meta/TryThis.olean.private +lib/lean/Lean/Meta/TryThis.olean.server lib/lean/Lean/Meta/UnificationHint.ilean +lib/lean/Lean/Meta/UnificationHint.ir lib/lean/Lean/Meta/UnificationHint.olean +lib/lean/Lean/Meta/UnificationHint.olean.private +lib/lean/Lean/Meta/UnificationHint.olean.server lib/lean/Lean/Meta/WHNF.ilean +lib/lean/Lean/Meta/WHNF.ir lib/lean/Lean/Meta/WHNF.olean +lib/lean/Lean/Meta/WHNF.olean.private +lib/lean/Lean/Meta/WHNF.olean.server lib/lean/Lean/MetavarContext.ilean +lib/lean/Lean/MetavarContext.ir lib/lean/Lean/MetavarContext.olean +lib/lean/Lean/MetavarContext.olean.private +lib/lean/Lean/MetavarContext.olean.server lib/lean/Lean/Modifiers.ilean +lib/lean/Lean/Modifiers.ir lib/lean/Lean/Modifiers.olean +lib/lean/Lean/Modifiers.olean.private +lib/lean/Lean/Modifiers.olean.server lib/lean/Lean/MonadEnv.ilean +lib/lean/Lean/MonadEnv.ir lib/lean/Lean/MonadEnv.olean +lib/lean/Lean/MonadEnv.olean.private +lib/lean/Lean/MonadEnv.olean.server lib/lean/Lean/Namespace.ilean +lib/lean/Lean/Namespace.ir lib/lean/Lean/Namespace.olean +lib/lean/Lean/Namespace.olean.private +lib/lean/Lean/Namespace.olean.server lib/lean/Lean/Parser.ilean +lib/lean/Lean/Parser.ir lib/lean/Lean/Parser.olean +lib/lean/Lean/Parser.olean.private +lib/lean/Lean/Parser.olean.server lib/lean/Lean/Parser/Attr.ilean +lib/lean/Lean/Parser/Attr.ir lib/lean/Lean/Parser/Attr.olean +lib/lean/Lean/Parser/Attr.olean.private +lib/lean/Lean/Parser/Attr.olean.server lib/lean/Lean/Parser/Basic.ilean +lib/lean/Lean/Parser/Basic.ir lib/lean/Lean/Parser/Basic.olean +lib/lean/Lean/Parser/Basic.olean.private +lib/lean/Lean/Parser/Basic.olean.server lib/lean/Lean/Parser/Command.ilean +lib/lean/Lean/Parser/Command.ir lib/lean/Lean/Parser/Command.olean +lib/lean/Lean/Parser/Command.olean.private +lib/lean/Lean/Parser/Command.olean.server lib/lean/Lean/Parser/Do.ilean +lib/lean/Lean/Parser/Do.ir lib/lean/Lean/Parser/Do.olean +lib/lean/Lean/Parser/Do.olean.private +lib/lean/Lean/Parser/Do.olean.server lib/lean/Lean/Parser/Extension.ilean +lib/lean/Lean/Parser/Extension.ir lib/lean/Lean/Parser/Extension.olean +lib/lean/Lean/Parser/Extension.olean.private +lib/lean/Lean/Parser/Extension.olean.server lib/lean/Lean/Parser/Extra.ilean +lib/lean/Lean/Parser/Extra.ir lib/lean/Lean/Parser/Extra.olean +lib/lean/Lean/Parser/Extra.olean.private +lib/lean/Lean/Parser/Extra.olean.server lib/lean/Lean/Parser/Level.ilean +lib/lean/Lean/Parser/Level.ir lib/lean/Lean/Parser/Level.olean +lib/lean/Lean/Parser/Level.olean.private +lib/lean/Lean/Parser/Level.olean.server lib/lean/Lean/Parser/Module.ilean +lib/lean/Lean/Parser/Module.ir lib/lean/Lean/Parser/Module.olean +lib/lean/Lean/Parser/Module.olean.private +lib/lean/Lean/Parser/Module.olean.server lib/lean/Lean/Parser/StrInterpolation.ilean +lib/lean/Lean/Parser/StrInterpolation.ir lib/lean/Lean/Parser/StrInterpolation.olean +lib/lean/Lean/Parser/StrInterpolation.olean.private +lib/lean/Lean/Parser/StrInterpolation.olean.server lib/lean/Lean/Parser/Syntax.ilean +lib/lean/Lean/Parser/Syntax.ir lib/lean/Lean/Parser/Syntax.olean +lib/lean/Lean/Parser/Syntax.olean.private +lib/lean/Lean/Parser/Syntax.olean.server lib/lean/Lean/Parser/Tactic.ilean +lib/lean/Lean/Parser/Tactic.ir lib/lean/Lean/Parser/Tactic.olean +lib/lean/Lean/Parser/Tactic.olean.private +lib/lean/Lean/Parser/Tactic.olean.server lib/lean/Lean/Parser/Tactic/Doc.ilean +lib/lean/Lean/Parser/Tactic/Doc.ir lib/lean/Lean/Parser/Tactic/Doc.olean +lib/lean/Lean/Parser/Tactic/Doc.olean.private +lib/lean/Lean/Parser/Tactic/Doc.olean.server lib/lean/Lean/Parser/Term.ilean +lib/lean/Lean/Parser/Term.ir lib/lean/Lean/Parser/Term.olean +lib/lean/Lean/Parser/Term.olean.private +lib/lean/Lean/Parser/Term.olean.server lib/lean/Lean/Parser/Term/Doc.ilean +lib/lean/Lean/Parser/Term/Doc.ir lib/lean/Lean/Parser/Term/Doc.olean +lib/lean/Lean/Parser/Term/Doc.olean.private +lib/lean/Lean/Parser/Term/Doc.olean.server lib/lean/Lean/Parser/Types.ilean +lib/lean/Lean/Parser/Types.ir lib/lean/Lean/Parser/Types.olean +lib/lean/Lean/Parser/Types.olean.private +lib/lean/Lean/Parser/Types.olean.server lib/lean/Lean/ParserCompiler.ilean +lib/lean/Lean/ParserCompiler.ir lib/lean/Lean/ParserCompiler.olean +lib/lean/Lean/ParserCompiler.olean.private +lib/lean/Lean/ParserCompiler.olean.server lib/lean/Lean/ParserCompiler/Attribute.ilean +lib/lean/Lean/ParserCompiler/Attribute.ir lib/lean/Lean/ParserCompiler/Attribute.olean +lib/lean/Lean/ParserCompiler/Attribute.olean.private +lib/lean/Lean/ParserCompiler/Attribute.olean.server lib/lean/Lean/PremiseSelection.ilean +lib/lean/Lean/PremiseSelection.ir lib/lean/Lean/PremiseSelection.olean +lib/lean/Lean/PremiseSelection.olean.private +lib/lean/Lean/PremiseSelection.olean.server lib/lean/Lean/PrettyPrinter.ilean +lib/lean/Lean/PrettyPrinter.ir lib/lean/Lean/PrettyPrinter.olean +lib/lean/Lean/PrettyPrinter.olean.private +lib/lean/Lean/PrettyPrinter.olean.server lib/lean/Lean/PrettyPrinter/Basic.ilean +lib/lean/Lean/PrettyPrinter/Basic.ir lib/lean/Lean/PrettyPrinter/Basic.olean +lib/lean/Lean/PrettyPrinter/Basic.olean.private +lib/lean/Lean/PrettyPrinter/Basic.olean.server lib/lean/Lean/PrettyPrinter/Delaborator.ilean +lib/lean/Lean/PrettyPrinter/Delaborator.ir lib/lean/Lean/PrettyPrinter/Delaborator.olean +lib/lean/Lean/PrettyPrinter/Delaborator.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.ir lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean +lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/Basic.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/Basic.ir lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean +lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.ir lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean +lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.ir lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean +lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/Options.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/Options.ir lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean +lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.ir lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean +lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean.server lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.ilean +lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.ir lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean +lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean.private +lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean.server lib/lean/Lean/PrettyPrinter/Formatter.ilean +lib/lean/Lean/PrettyPrinter/Formatter.ir lib/lean/Lean/PrettyPrinter/Formatter.olean +lib/lean/Lean/PrettyPrinter/Formatter.olean.private +lib/lean/Lean/PrettyPrinter/Formatter.olean.server lib/lean/Lean/PrettyPrinter/Parenthesizer.ilean +lib/lean/Lean/PrettyPrinter/Parenthesizer.ir lib/lean/Lean/PrettyPrinter/Parenthesizer.olean +lib/lean/Lean/PrettyPrinter/Parenthesizer.olean.private +lib/lean/Lean/PrettyPrinter/Parenthesizer.olean.server lib/lean/Lean/PrivateName.ilean +lib/lean/Lean/PrivateName.ir lib/lean/Lean/PrivateName.olean +lib/lean/Lean/PrivateName.olean.private +lib/lean/Lean/PrivateName.olean.server lib/lean/Lean/ProjFns.ilean +lib/lean/Lean/ProjFns.ir lib/lean/Lean/ProjFns.olean +lib/lean/Lean/ProjFns.olean.private +lib/lean/Lean/ProjFns.olean.server lib/lean/Lean/ReducibilityAttrs.ilean +lib/lean/Lean/ReducibilityAttrs.ir lib/lean/Lean/ReducibilityAttrs.olean +lib/lean/Lean/ReducibilityAttrs.olean.private +lib/lean/Lean/ReducibilityAttrs.olean.server lib/lean/Lean/Replay.ilean +lib/lean/Lean/Replay.ir lib/lean/Lean/Replay.olean +lib/lean/Lean/Replay.olean.private +lib/lean/Lean/Replay.olean.server lib/lean/Lean/ReservedNameAction.ilean +lib/lean/Lean/ReservedNameAction.ir lib/lean/Lean/ReservedNameAction.olean +lib/lean/Lean/ReservedNameAction.olean.private +lib/lean/Lean/ReservedNameAction.olean.server lib/lean/Lean/ResolveName.ilean +lib/lean/Lean/ResolveName.ir lib/lean/Lean/ResolveName.olean +lib/lean/Lean/ResolveName.olean.private +lib/lean/Lean/ResolveName.olean.server lib/lean/Lean/Runtime.ilean +lib/lean/Lean/Runtime.ir lib/lean/Lean/Runtime.olean +lib/lean/Lean/Runtime.olean.private +lib/lean/Lean/Runtime.olean.server lib/lean/Lean/ScopedEnvExtension.ilean +lib/lean/Lean/ScopedEnvExtension.ir lib/lean/Lean/ScopedEnvExtension.olean +lib/lean/Lean/ScopedEnvExtension.olean.private +lib/lean/Lean/ScopedEnvExtension.olean.server lib/lean/Lean/Server.ilean +lib/lean/Lean/Server.ir lib/lean/Lean/Server.olean +lib/lean/Lean/Server.olean.private +lib/lean/Lean/Server.olean.server lib/lean/Lean/Server/AsyncList.ilean +lib/lean/Lean/Server/AsyncList.ir lib/lean/Lean/Server/AsyncList.olean +lib/lean/Lean/Server/AsyncList.olean.private +lib/lean/Lean/Server/AsyncList.olean.server lib/lean/Lean/Server/CodeActions.ilean +lib/lean/Lean/Server/CodeActions.ir lib/lean/Lean/Server/CodeActions.olean +lib/lean/Lean/Server/CodeActions.olean.private +lib/lean/Lean/Server/CodeActions.olean.server lib/lean/Lean/Server/CodeActions/Attr.ilean +lib/lean/Lean/Server/CodeActions/Attr.ir lib/lean/Lean/Server/CodeActions/Attr.olean +lib/lean/Lean/Server/CodeActions/Attr.olean.private +lib/lean/Lean/Server/CodeActions/Attr.olean.server lib/lean/Lean/Server/CodeActions/Basic.ilean +lib/lean/Lean/Server/CodeActions/Basic.ir lib/lean/Lean/Server/CodeActions/Basic.olean +lib/lean/Lean/Server/CodeActions/Basic.olean.private +lib/lean/Lean/Server/CodeActions/Basic.olean.server lib/lean/Lean/Server/CodeActions/Provider.ilean +lib/lean/Lean/Server/CodeActions/Provider.ir lib/lean/Lean/Server/CodeActions/Provider.olean +lib/lean/Lean/Server/CodeActions/Provider.olean.private +lib/lean/Lean/Server/CodeActions/Provider.olean.server lib/lean/Lean/Server/CodeActions/UnknownIdentifier.ilean +lib/lean/Lean/Server/CodeActions/UnknownIdentifier.ir lib/lean/Lean/Server/CodeActions/UnknownIdentifier.olean +lib/lean/Lean/Server/CodeActions/UnknownIdentifier.olean.private +lib/lean/Lean/Server/CodeActions/UnknownIdentifier.olean.server lib/lean/Lean/Server/Completion.ilean +lib/lean/Lean/Server/Completion.ir lib/lean/Lean/Server/Completion.olean +lib/lean/Lean/Server/Completion.olean.private +lib/lean/Lean/Server/Completion.olean.server lib/lean/Lean/Server/Completion/CompletionCollectors.ilean +lib/lean/Lean/Server/Completion/CompletionCollectors.ir lib/lean/Lean/Server/Completion/CompletionCollectors.olean +lib/lean/Lean/Server/Completion/CompletionCollectors.olean.private +lib/lean/Lean/Server/Completion/CompletionCollectors.olean.server lib/lean/Lean/Server/Completion/CompletionInfoSelection.ilean +lib/lean/Lean/Server/Completion/CompletionInfoSelection.ir lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean +lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean.private +lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean.server lib/lean/Lean/Server/Completion/CompletionItemData.ilean +lib/lean/Lean/Server/Completion/CompletionItemData.ir lib/lean/Lean/Server/Completion/CompletionItemData.olean +lib/lean/Lean/Server/Completion/CompletionItemData.olean.private +lib/lean/Lean/Server/Completion/CompletionItemData.olean.server lib/lean/Lean/Server/Completion/CompletionResolution.ilean +lib/lean/Lean/Server/Completion/CompletionResolution.ir lib/lean/Lean/Server/Completion/CompletionResolution.olean +lib/lean/Lean/Server/Completion/CompletionResolution.olean.private +lib/lean/Lean/Server/Completion/CompletionResolution.olean.server lib/lean/Lean/Server/Completion/CompletionUtils.ilean +lib/lean/Lean/Server/Completion/CompletionUtils.ir lib/lean/Lean/Server/Completion/CompletionUtils.olean +lib/lean/Lean/Server/Completion/CompletionUtils.olean.private +lib/lean/Lean/Server/Completion/CompletionUtils.olean.server lib/lean/Lean/Server/Completion/EligibleHeaderDecls.ilean +lib/lean/Lean/Server/Completion/EligibleHeaderDecls.ir lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean +lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean.private +lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean.server lib/lean/Lean/Server/Completion/ImportCompletion.ilean +lib/lean/Lean/Server/Completion/ImportCompletion.ir lib/lean/Lean/Server/Completion/ImportCompletion.olean +lib/lean/Lean/Server/Completion/ImportCompletion.olean.private +lib/lean/Lean/Server/Completion/ImportCompletion.olean.server lib/lean/Lean/Server/Completion/SyntheticCompletion.ilean +lib/lean/Lean/Server/Completion/SyntheticCompletion.ir lib/lean/Lean/Server/Completion/SyntheticCompletion.olean +lib/lean/Lean/Server/Completion/SyntheticCompletion.olean.private +lib/lean/Lean/Server/Completion/SyntheticCompletion.olean.server lib/lean/Lean/Server/FileSource.ilean +lib/lean/Lean/Server/FileSource.ir lib/lean/Lean/Server/FileSource.olean +lib/lean/Lean/Server/FileSource.olean.private +lib/lean/Lean/Server/FileSource.olean.server lib/lean/Lean/Server/FileWorker.ilean +lib/lean/Lean/Server/FileWorker.ir lib/lean/Lean/Server/FileWorker.olean +lib/lean/Lean/Server/FileWorker.olean.private +lib/lean/Lean/Server/FileWorker.olean.server lib/lean/Lean/Server/FileWorker/ExampleHover.ilean +lib/lean/Lean/Server/FileWorker/ExampleHover.ir lib/lean/Lean/Server/FileWorker/ExampleHover.olean +lib/lean/Lean/Server/FileWorker/ExampleHover.olean.private +lib/lean/Lean/Server/FileWorker/ExampleHover.olean.server lib/lean/Lean/Server/FileWorker/InlayHints.ilean +lib/lean/Lean/Server/FileWorker/InlayHints.ir lib/lean/Lean/Server/FileWorker/InlayHints.olean +lib/lean/Lean/Server/FileWorker/InlayHints.olean.private +lib/lean/Lean/Server/FileWorker/InlayHints.olean.server lib/lean/Lean/Server/FileWorker/RequestHandling.ilean +lib/lean/Lean/Server/FileWorker/RequestHandling.ir lib/lean/Lean/Server/FileWorker/RequestHandling.olean +lib/lean/Lean/Server/FileWorker/RequestHandling.olean.private +lib/lean/Lean/Server/FileWorker/RequestHandling.olean.server lib/lean/Lean/Server/FileWorker/SemanticHighlighting.ilean +lib/lean/Lean/Server/FileWorker/SemanticHighlighting.ir lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean +lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean.private +lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean.server lib/lean/Lean/Server/FileWorker/SetupFile.ilean +lib/lean/Lean/Server/FileWorker/SetupFile.ir lib/lean/Lean/Server/FileWorker/SetupFile.olean +lib/lean/Lean/Server/FileWorker/SetupFile.olean.private +lib/lean/Lean/Server/FileWorker/SetupFile.olean.server lib/lean/Lean/Server/FileWorker/SignatureHelp.ilean +lib/lean/Lean/Server/FileWorker/SignatureHelp.ir lib/lean/Lean/Server/FileWorker/SignatureHelp.olean +lib/lean/Lean/Server/FileWorker/SignatureHelp.olean.private +lib/lean/Lean/Server/FileWorker/SignatureHelp.olean.server lib/lean/Lean/Server/FileWorker/Utils.ilean +lib/lean/Lean/Server/FileWorker/Utils.ir lib/lean/Lean/Server/FileWorker/Utils.olean +lib/lean/Lean/Server/FileWorker/Utils.olean.private +lib/lean/Lean/Server/FileWorker/Utils.olean.server lib/lean/Lean/Server/FileWorker/WidgetRequests.ilean +lib/lean/Lean/Server/FileWorker/WidgetRequests.ir lib/lean/Lean/Server/FileWorker/WidgetRequests.olean +lib/lean/Lean/Server/FileWorker/WidgetRequests.olean.private +lib/lean/Lean/Server/FileWorker/WidgetRequests.olean.server lib/lean/Lean/Server/GoTo.ilean +lib/lean/Lean/Server/GoTo.ir lib/lean/Lean/Server/GoTo.olean +lib/lean/Lean/Server/GoTo.olean.private +lib/lean/Lean/Server/GoTo.olean.server lib/lean/Lean/Server/InfoUtils.ilean +lib/lean/Lean/Server/InfoUtils.ir lib/lean/Lean/Server/InfoUtils.olean +lib/lean/Lean/Server/InfoUtils.olean.private +lib/lean/Lean/Server/InfoUtils.olean.server lib/lean/Lean/Server/References.ilean +lib/lean/Lean/Server/References.ir lib/lean/Lean/Server/References.olean +lib/lean/Lean/Server/References.olean.private +lib/lean/Lean/Server/References.olean.server lib/lean/Lean/Server/RequestCancellation.ilean +lib/lean/Lean/Server/RequestCancellation.ir lib/lean/Lean/Server/RequestCancellation.olean +lib/lean/Lean/Server/RequestCancellation.olean.private +lib/lean/Lean/Server/RequestCancellation.olean.server lib/lean/Lean/Server/Requests.ilean +lib/lean/Lean/Server/Requests.ir lib/lean/Lean/Server/Requests.olean +lib/lean/Lean/Server/Requests.olean.private +lib/lean/Lean/Server/Requests.olean.server lib/lean/Lean/Server/Rpc.ilean +lib/lean/Lean/Server/Rpc.ir lib/lean/Lean/Server/Rpc.olean +lib/lean/Lean/Server/Rpc.olean.private +lib/lean/Lean/Server/Rpc.olean.server lib/lean/Lean/Server/Rpc/Basic.ilean +lib/lean/Lean/Server/Rpc/Basic.ir lib/lean/Lean/Server/Rpc/Basic.olean +lib/lean/Lean/Server/Rpc/Basic.olean.private +lib/lean/Lean/Server/Rpc/Basic.olean.server lib/lean/Lean/Server/Rpc/Deriving.ilean +lib/lean/Lean/Server/Rpc/Deriving.ir lib/lean/Lean/Server/Rpc/Deriving.olean +lib/lean/Lean/Server/Rpc/Deriving.olean.private +lib/lean/Lean/Server/Rpc/Deriving.olean.server lib/lean/Lean/Server/Rpc/RequestHandling.ilean +lib/lean/Lean/Server/Rpc/RequestHandling.ir lib/lean/Lean/Server/Rpc/RequestHandling.olean +lib/lean/Lean/Server/Rpc/RequestHandling.olean.private +lib/lean/Lean/Server/Rpc/RequestHandling.olean.server lib/lean/Lean/Server/ServerTask.ilean +lib/lean/Lean/Server/ServerTask.ir lib/lean/Lean/Server/ServerTask.olean +lib/lean/Lean/Server/ServerTask.olean.private +lib/lean/Lean/Server/ServerTask.olean.server lib/lean/Lean/Server/Snapshots.ilean +lib/lean/Lean/Server/Snapshots.ir lib/lean/Lean/Server/Snapshots.olean +lib/lean/Lean/Server/Snapshots.olean.private +lib/lean/Lean/Server/Snapshots.olean.server lib/lean/Lean/Server/Test.ilean +lib/lean/Lean/Server/Test.ir lib/lean/Lean/Server/Test.olean +lib/lean/Lean/Server/Test.olean.private +lib/lean/Lean/Server/Test.olean.server lib/lean/Lean/Server/Test/Cancel.ilean +lib/lean/Lean/Server/Test/Cancel.ir lib/lean/Lean/Server/Test/Cancel.olean +lib/lean/Lean/Server/Test/Cancel.olean.private +lib/lean/Lean/Server/Test/Cancel.olean.server lib/lean/Lean/Server/Test/Runner.ilean +lib/lean/Lean/Server/Test/Runner.ir lib/lean/Lean/Server/Test/Runner.olean +lib/lean/Lean/Server/Test/Runner.olean.private +lib/lean/Lean/Server/Test/Runner.olean.server lib/lean/Lean/Server/Utils.ilean +lib/lean/Lean/Server/Utils.ir lib/lean/Lean/Server/Utils.olean +lib/lean/Lean/Server/Utils.olean.private +lib/lean/Lean/Server/Utils.olean.server lib/lean/Lean/Server/Watchdog.ilean +lib/lean/Lean/Server/Watchdog.ir lib/lean/Lean/Server/Watchdog.olean +lib/lean/Lean/Server/Watchdog.olean.private +lib/lean/Lean/Server/Watchdog.olean.server lib/lean/Lean/Setup.ilean +lib/lean/Lean/Setup.ir lib/lean/Lean/Setup.olean +lib/lean/Lean/Setup.olean.private +lib/lean/Lean/Setup.olean.server lib/lean/Lean/Shell.ilean +lib/lean/Lean/Shell.ir lib/lean/Lean/Shell.olean +lib/lean/Lean/Shell.olean.private +lib/lean/Lean/Shell.olean.server lib/lean/Lean/Structure.ilean +lib/lean/Lean/Structure.ir lib/lean/Lean/Structure.olean +lib/lean/Lean/Structure.olean.private +lib/lean/Lean/Structure.olean.server lib/lean/Lean/SubExpr.ilean +lib/lean/Lean/SubExpr.ir lib/lean/Lean/SubExpr.olean +lib/lean/Lean/SubExpr.olean.private +lib/lean/Lean/SubExpr.olean.server lib/lean/Lean/Syntax.ilean +lib/lean/Lean/Syntax.ir lib/lean/Lean/Syntax.olean +lib/lean/Lean/Syntax.olean.private +lib/lean/Lean/Syntax.olean.server lib/lean/Lean/ToExpr.ilean +lib/lean/Lean/ToExpr.ir lib/lean/Lean/ToExpr.olean +lib/lean/Lean/ToExpr.olean.private +lib/lean/Lean/ToExpr.olean.server lib/lean/Lean/ToLevel.ilean +lib/lean/Lean/ToLevel.ir lib/lean/Lean/ToLevel.olean +lib/lean/Lean/ToLevel.olean.private +lib/lean/Lean/ToLevel.olean.server lib/lean/Lean/Util.ilean +lib/lean/Lean/Util.ir lib/lean/Lean/Util.olean +lib/lean/Lean/Util.olean.private +lib/lean/Lean/Util.olean.server lib/lean/Lean/Util/CollectAxioms.ilean +lib/lean/Lean/Util/CollectAxioms.ir lib/lean/Lean/Util/CollectAxioms.olean +lib/lean/Lean/Util/CollectAxioms.olean.private +lib/lean/Lean/Util/CollectAxioms.olean.server lib/lean/Lean/Util/CollectFVars.ilean +lib/lean/Lean/Util/CollectFVars.ir lib/lean/Lean/Util/CollectFVars.olean +lib/lean/Lean/Util/CollectFVars.olean.private +lib/lean/Lean/Util/CollectFVars.olean.server lib/lean/Lean/Util/CollectLevelMVars.ilean +lib/lean/Lean/Util/CollectLevelMVars.ir lib/lean/Lean/Util/CollectLevelMVars.olean +lib/lean/Lean/Util/CollectLevelMVars.olean.private +lib/lean/Lean/Util/CollectLevelMVars.olean.server lib/lean/Lean/Util/CollectLevelParams.ilean +lib/lean/Lean/Util/CollectLevelParams.ir lib/lean/Lean/Util/CollectLevelParams.olean +lib/lean/Lean/Util/CollectLevelParams.olean.private +lib/lean/Lean/Util/CollectLevelParams.olean.server lib/lean/Lean/Util/CollectLooseBVars.ilean +lib/lean/Lean/Util/CollectLooseBVars.ir lib/lean/Lean/Util/CollectLooseBVars.olean +lib/lean/Lean/Util/CollectLooseBVars.olean.private +lib/lean/Lean/Util/CollectLooseBVars.olean.server lib/lean/Lean/Util/CollectMVars.ilean +lib/lean/Lean/Util/CollectMVars.ir lib/lean/Lean/Util/CollectMVars.olean +lib/lean/Lean/Util/CollectMVars.olean.private +lib/lean/Lean/Util/CollectMVars.olean.server lib/lean/Lean/Util/Diff.ilean +lib/lean/Lean/Util/Diff.ir lib/lean/Lean/Util/Diff.olean +lib/lean/Lean/Util/Diff.olean.private +lib/lean/Lean/Util/Diff.olean.server lib/lean/Lean/Util/FVarSubset.ilean +lib/lean/Lean/Util/FVarSubset.ir lib/lean/Lean/Util/FVarSubset.olean +lib/lean/Lean/Util/FVarSubset.olean.private +lib/lean/Lean/Util/FVarSubset.olean.server lib/lean/Lean/Util/FindExpr.ilean +lib/lean/Lean/Util/FindExpr.ir lib/lean/Lean/Util/FindExpr.olean +lib/lean/Lean/Util/FindExpr.olean.private +lib/lean/Lean/Util/FindExpr.olean.server lib/lean/Lean/Util/FindLevelMVar.ilean +lib/lean/Lean/Util/FindLevelMVar.ir lib/lean/Lean/Util/FindLevelMVar.olean +lib/lean/Lean/Util/FindLevelMVar.olean.private +lib/lean/Lean/Util/FindLevelMVar.olean.server lib/lean/Lean/Util/FindMVar.ilean +lib/lean/Lean/Util/FindMVar.ir lib/lean/Lean/Util/FindMVar.olean +lib/lean/Lean/Util/FindMVar.olean.private +lib/lean/Lean/Util/FindMVar.olean.server lib/lean/Lean/Util/FoldConsts.ilean +lib/lean/Lean/Util/FoldConsts.ir lib/lean/Lean/Util/FoldConsts.olean +lib/lean/Lean/Util/FoldConsts.olean.private +lib/lean/Lean/Util/FoldConsts.olean.server lib/lean/Lean/Util/ForEachExpr.ilean +lib/lean/Lean/Util/ForEachExpr.ir lib/lean/Lean/Util/ForEachExpr.olean +lib/lean/Lean/Util/ForEachExpr.olean.private +lib/lean/Lean/Util/ForEachExpr.olean.server lib/lean/Lean/Util/ForEachExprWhere.ilean +lib/lean/Lean/Util/ForEachExprWhere.ir lib/lean/Lean/Util/ForEachExprWhere.olean +lib/lean/Lean/Util/ForEachExprWhere.olean.private +lib/lean/Lean/Util/ForEachExprWhere.olean.server lib/lean/Lean/Util/HasConstCache.ilean +lib/lean/Lean/Util/HasConstCache.ir lib/lean/Lean/Util/HasConstCache.olean +lib/lean/Lean/Util/HasConstCache.olean.private +lib/lean/Lean/Util/HasConstCache.olean.server lib/lean/Lean/Util/Heartbeats.ilean +lib/lean/Lean/Util/Heartbeats.ir lib/lean/Lean/Util/Heartbeats.olean +lib/lean/Lean/Util/Heartbeats.olean.private +lib/lean/Lean/Util/Heartbeats.olean.server lib/lean/Lean/Util/InstantiateLevelParams.ilean +lib/lean/Lean/Util/InstantiateLevelParams.ir lib/lean/Lean/Util/InstantiateLevelParams.olean +lib/lean/Lean/Util/InstantiateLevelParams.olean.private +lib/lean/Lean/Util/InstantiateLevelParams.olean.server lib/lean/Lean/Util/LakePath.ilean +lib/lean/Lean/Util/LakePath.ir lib/lean/Lean/Util/LakePath.olean +lib/lean/Lean/Util/LakePath.olean.private +lib/lean/Lean/Util/LakePath.olean.server lib/lean/Lean/Util/LeanOptions.ilean +lib/lean/Lean/Util/LeanOptions.ir lib/lean/Lean/Util/LeanOptions.olean +lib/lean/Lean/Util/LeanOptions.olean.private +lib/lean/Lean/Util/LeanOptions.olean.server lib/lean/Lean/Util/MonadBacktrack.ilean +lib/lean/Lean/Util/MonadBacktrack.ir lib/lean/Lean/Util/MonadBacktrack.olean +lib/lean/Lean/Util/MonadBacktrack.olean.private +lib/lean/Lean/Util/MonadBacktrack.olean.server lib/lean/Lean/Util/MonadCache.ilean +lib/lean/Lean/Util/MonadCache.ir lib/lean/Lean/Util/MonadCache.olean +lib/lean/Lean/Util/MonadCache.olean.private +lib/lean/Lean/Util/MonadCache.olean.server lib/lean/Lean/Util/NumApps.ilean +lib/lean/Lean/Util/NumApps.ir lib/lean/Lean/Util/NumApps.olean +lib/lean/Lean/Util/NumApps.olean.private +lib/lean/Lean/Util/NumApps.olean.server lib/lean/Lean/Util/NumObjs.ilean +lib/lean/Lean/Util/NumObjs.ir lib/lean/Lean/Util/NumObjs.olean +lib/lean/Lean/Util/NumObjs.olean.private +lib/lean/Lean/Util/NumObjs.olean.server lib/lean/Lean/Util/OccursCheck.ilean +lib/lean/Lean/Util/OccursCheck.ir lib/lean/Lean/Util/OccursCheck.olean +lib/lean/Lean/Util/OccursCheck.olean.private +lib/lean/Lean/Util/OccursCheck.olean.server lib/lean/Lean/Util/PPExt.ilean +lib/lean/Lean/Util/PPExt.ir lib/lean/Lean/Util/PPExt.olean +lib/lean/Lean/Util/PPExt.olean.private +lib/lean/Lean/Util/PPExt.olean.server lib/lean/Lean/Util/Path.ilean +lib/lean/Lean/Util/Path.ir lib/lean/Lean/Util/Path.olean +lib/lean/Lean/Util/Path.olean.private +lib/lean/Lean/Util/Path.olean.server lib/lean/Lean/Util/Profile.ilean +lib/lean/Lean/Util/Profile.ir lib/lean/Lean/Util/Profile.olean +lib/lean/Lean/Util/Profile.olean.private +lib/lean/Lean/Util/Profile.olean.server lib/lean/Lean/Util/Profiler.ilean +lib/lean/Lean/Util/Profiler.ir lib/lean/Lean/Util/Profiler.olean +lib/lean/Lean/Util/Profiler.olean.private +lib/lean/Lean/Util/Profiler.olean.server lib/lean/Lean/Util/PtrSet.ilean +lib/lean/Lean/Util/PtrSet.ir lib/lean/Lean/Util/PtrSet.olean +lib/lean/Lean/Util/PtrSet.olean.private +lib/lean/Lean/Util/PtrSet.olean.server lib/lean/Lean/Util/RecDepth.ilean +lib/lean/Lean/Util/RecDepth.ir lib/lean/Lean/Util/RecDepth.olean +lib/lean/Lean/Util/RecDepth.olean.private +lib/lean/Lean/Util/RecDepth.olean.server lib/lean/Lean/Util/Recognizers.ilean +lib/lean/Lean/Util/Recognizers.ir lib/lean/Lean/Util/Recognizers.olean +lib/lean/Lean/Util/Recognizers.olean.private +lib/lean/Lean/Util/Recognizers.olean.server lib/lean/Lean/Util/ReplaceExpr.ilean +lib/lean/Lean/Util/ReplaceExpr.ir lib/lean/Lean/Util/ReplaceExpr.olean +lib/lean/Lean/Util/ReplaceExpr.olean.private +lib/lean/Lean/Util/ReplaceExpr.olean.server lib/lean/Lean/Util/ReplaceLevel.ilean +lib/lean/Lean/Util/ReplaceLevel.ir lib/lean/Lean/Util/ReplaceLevel.olean +lib/lean/Lean/Util/ReplaceLevel.olean.private +lib/lean/Lean/Util/ReplaceLevel.olean.server lib/lean/Lean/Util/SCC.ilean +lib/lean/Lean/Util/SCC.ir lib/lean/Lean/Util/SCC.olean +lib/lean/Lean/Util/SCC.olean.private +lib/lean/Lean/Util/SCC.olean.server lib/lean/Lean/Util/SafeExponentiation.ilean +lib/lean/Lean/Util/SafeExponentiation.ir lib/lean/Lean/Util/SafeExponentiation.olean +lib/lean/Lean/Util/SafeExponentiation.olean.private +lib/lean/Lean/Util/SafeExponentiation.olean.server lib/lean/Lean/Util/SearchPath.ilean +lib/lean/Lean/Util/SearchPath.ir lib/lean/Lean/Util/SearchPath.olean +lib/lean/Lean/Util/SearchPath.olean.private +lib/lean/Lean/Util/SearchPath.olean.server lib/lean/Lean/Util/ShareCommon.ilean +lib/lean/Lean/Util/ShareCommon.ir lib/lean/Lean/Util/ShareCommon.olean +lib/lean/Lean/Util/ShareCommon.olean.private +lib/lean/Lean/Util/ShareCommon.olean.server lib/lean/Lean/Util/Sorry.ilean +lib/lean/Lean/Util/Sorry.ir lib/lean/Lean/Util/Sorry.olean +lib/lean/Lean/Util/Sorry.olean.private +lib/lean/Lean/Util/Sorry.olean.server lib/lean/Lean/Util/SortExprs.ilean +lib/lean/Lean/Util/SortExprs.ir lib/lean/Lean/Util/SortExprs.olean +lib/lean/Lean/Util/SortExprs.olean.private +lib/lean/Lean/Util/SortExprs.olean.server lib/lean/Lean/Util/TestExtern.ilean +lib/lean/Lean/Util/TestExtern.ir lib/lean/Lean/Util/TestExtern.olean +lib/lean/Lean/Util/TestExtern.olean.private +lib/lean/Lean/Util/TestExtern.olean.server lib/lean/Lean/Util/Trace.ilean +lib/lean/Lean/Util/Trace.ir lib/lean/Lean/Util/Trace.olean +lib/lean/Lean/Util/Trace.olean.private +lib/lean/Lean/Util/Trace.olean.server lib/lean/Lean/Widget.ilean +lib/lean/Lean/Widget.ir lib/lean/Lean/Widget.olean +lib/lean/Lean/Widget.olean.private +lib/lean/Lean/Widget.olean.server lib/lean/Lean/Widget/Basic.ilean +lib/lean/Lean/Widget/Basic.ir lib/lean/Lean/Widget/Basic.olean +lib/lean/Lean/Widget/Basic.olean.private +lib/lean/Lean/Widget/Basic.olean.server lib/lean/Lean/Widget/Diff.ilean +lib/lean/Lean/Widget/Diff.ir lib/lean/Lean/Widget/Diff.olean +lib/lean/Lean/Widget/Diff.olean.private +lib/lean/Lean/Widget/Diff.olean.server lib/lean/Lean/Widget/InteractiveCode.ilean +lib/lean/Lean/Widget/InteractiveCode.ir lib/lean/Lean/Widget/InteractiveCode.olean +lib/lean/Lean/Widget/InteractiveCode.olean.private +lib/lean/Lean/Widget/InteractiveCode.olean.server lib/lean/Lean/Widget/InteractiveDiagnostic.ilean +lib/lean/Lean/Widget/InteractiveDiagnostic.ir lib/lean/Lean/Widget/InteractiveDiagnostic.olean +lib/lean/Lean/Widget/InteractiveDiagnostic.olean.private +lib/lean/Lean/Widget/InteractiveDiagnostic.olean.server lib/lean/Lean/Widget/InteractiveGoal.ilean +lib/lean/Lean/Widget/InteractiveGoal.ir lib/lean/Lean/Widget/InteractiveGoal.olean +lib/lean/Lean/Widget/InteractiveGoal.olean.private +lib/lean/Lean/Widget/InteractiveGoal.olean.server lib/lean/Lean/Widget/TaggedText.ilean +lib/lean/Lean/Widget/TaggedText.ir lib/lean/Lean/Widget/TaggedText.olean +lib/lean/Lean/Widget/TaggedText.olean.private +lib/lean/Lean/Widget/TaggedText.olean.server lib/lean/Lean/Widget/Types.ilean +lib/lean/Lean/Widget/Types.ir lib/lean/Lean/Widget/Types.olean +lib/lean/Lean/Widget/Types.olean.private +lib/lean/Lean/Widget/Types.olean.server lib/lean/Lean/Widget/UserWidget.ilean +lib/lean/Lean/Widget/UserWidget.ir lib/lean/Lean/Widget/UserWidget.olean +lib/lean/Lean/Widget/UserWidget.olean.private +lib/lean/Lean/Widget/UserWidget.olean.server lib/lean/Leanc.ilean lib/lean/Leanc.olean lib/lean/Std.ilean lib/lean/Std.olean lib/lean/Std/Classes.ilean +lib/lean/Std/Classes.ir lib/lean/Std/Classes.olean +lib/lean/Std/Classes.olean.private +lib/lean/Std/Classes.olean.server lib/lean/Std/Classes/Ord.ilean +lib/lean/Std/Classes/Ord.ir lib/lean/Std/Classes/Ord.olean +lib/lean/Std/Classes/Ord.olean.private +lib/lean/Std/Classes/Ord.olean.server lib/lean/Std/Classes/Ord/Basic.ilean +lib/lean/Std/Classes/Ord/Basic.ir lib/lean/Std/Classes/Ord/Basic.olean +lib/lean/Std/Classes/Ord/Basic.olean.private +lib/lean/Std/Classes/Ord/Basic.olean.server lib/lean/Std/Classes/Ord/BitVec.ilean +lib/lean/Std/Classes/Ord/BitVec.ir lib/lean/Std/Classes/Ord/BitVec.olean +lib/lean/Std/Classes/Ord/BitVec.olean.private +lib/lean/Std/Classes/Ord/BitVec.olean.server lib/lean/Std/Classes/Ord/SInt.ilean +lib/lean/Std/Classes/Ord/SInt.ir lib/lean/Std/Classes/Ord/SInt.olean +lib/lean/Std/Classes/Ord/SInt.olean.private +lib/lean/Std/Classes/Ord/SInt.olean.server lib/lean/Std/Classes/Ord/String.ilean +lib/lean/Std/Classes/Ord/String.ir lib/lean/Std/Classes/Ord/String.olean +lib/lean/Std/Classes/Ord/String.olean.private +lib/lean/Std/Classes/Ord/String.olean.server lib/lean/Std/Classes/Ord/UInt.ilean +lib/lean/Std/Classes/Ord/UInt.ir lib/lean/Std/Classes/Ord/UInt.olean +lib/lean/Std/Classes/Ord/UInt.olean.private +lib/lean/Std/Classes/Ord/UInt.olean.server lib/lean/Std/Classes/Ord/Vector.ilean +lib/lean/Std/Classes/Ord/Vector.ir lib/lean/Std/Classes/Ord/Vector.olean +lib/lean/Std/Classes/Ord/Vector.olean.private +lib/lean/Std/Classes/Ord/Vector.olean.server lib/lean/Std/Data.ilean +lib/lean/Std/Data.ir lib/lean/Std/Data.olean +lib/lean/Std/Data.olean.private +lib/lean/Std/Data.olean.server lib/lean/Std/Data/DHashMap.ilean +lib/lean/Std/Data/DHashMap.ir lib/lean/Std/Data/DHashMap.olean +lib/lean/Std/Data/DHashMap.olean.private +lib/lean/Std/Data/DHashMap.olean.server lib/lean/Std/Data/DHashMap/AdditionalOperations.ilean +lib/lean/Std/Data/DHashMap/AdditionalOperations.ir lib/lean/Std/Data/DHashMap/AdditionalOperations.olean +lib/lean/Std/Data/DHashMap/AdditionalOperations.olean.private +lib/lean/Std/Data/DHashMap/AdditionalOperations.olean.server lib/lean/Std/Data/DHashMap/Basic.ilean +lib/lean/Std/Data/DHashMap/Basic.ir lib/lean/Std/Data/DHashMap/Basic.olean +lib/lean/Std/Data/DHashMap/Basic.olean.private +lib/lean/Std/Data/DHashMap/Basic.olean.server lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.ilean +lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.ir lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean +lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean.private +lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean.server lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.ilean +lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.ir lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean +lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean.private +lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean.server lib/lean/Std/Data/DHashMap/Internal/Defs.ilean +lib/lean/Std/Data/DHashMap/Internal/Defs.ir lib/lean/Std/Data/DHashMap/Internal/Defs.olean +lib/lean/Std/Data/DHashMap/Internal/Defs.olean.private +lib/lean/Std/Data/DHashMap/Internal/Defs.olean.server lib/lean/Std/Data/DHashMap/Internal/HashesTo.ilean +lib/lean/Std/Data/DHashMap/Internal/HashesTo.ir lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean +lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean.private +lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean.server lib/lean/Std/Data/DHashMap/Internal/Index.ilean +lib/lean/Std/Data/DHashMap/Internal/Index.ir lib/lean/Std/Data/DHashMap/Internal/Index.olean +lib/lean/Std/Data/DHashMap/Internal/Index.olean.private +lib/lean/Std/Data/DHashMap/Internal/Index.olean.server lib/lean/Std/Data/DHashMap/Internal/Model.ilean +lib/lean/Std/Data/DHashMap/Internal/Model.ir lib/lean/Std/Data/DHashMap/Internal/Model.olean +lib/lean/Std/Data/DHashMap/Internal/Model.olean.private +lib/lean/Std/Data/DHashMap/Internal/Model.olean.server lib/lean/Std/Data/DHashMap/Internal/Raw.ilean +lib/lean/Std/Data/DHashMap/Internal/Raw.ir lib/lean/Std/Data/DHashMap/Internal/Raw.olean +lib/lean/Std/Data/DHashMap/Internal/Raw.olean.private +lib/lean/Std/Data/DHashMap/Internal/Raw.olean.server lib/lean/Std/Data/DHashMap/Internal/RawLemmas.ilean +lib/lean/Std/Data/DHashMap/Internal/RawLemmas.ir lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean +lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean.private +lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean.server lib/lean/Std/Data/DHashMap/Internal/WF.ilean +lib/lean/Std/Data/DHashMap/Internal/WF.ir lib/lean/Std/Data/DHashMap/Internal/WF.olean +lib/lean/Std/Data/DHashMap/Internal/WF.olean.private +lib/lean/Std/Data/DHashMap/Internal/WF.olean.server lib/lean/Std/Data/DHashMap/Lemmas.ilean +lib/lean/Std/Data/DHashMap/Lemmas.ir lib/lean/Std/Data/DHashMap/Lemmas.olean +lib/lean/Std/Data/DHashMap/Lemmas.olean.private +lib/lean/Std/Data/DHashMap/Lemmas.olean.server lib/lean/Std/Data/DHashMap/Raw.ilean +lib/lean/Std/Data/DHashMap/Raw.ir lib/lean/Std/Data/DHashMap/Raw.olean +lib/lean/Std/Data/DHashMap/Raw.olean.private +lib/lean/Std/Data/DHashMap/Raw.olean.server lib/lean/Std/Data/DHashMap/RawDef.ilean +lib/lean/Std/Data/DHashMap/RawDef.ir lib/lean/Std/Data/DHashMap/RawDef.olean +lib/lean/Std/Data/DHashMap/RawDef.olean.private +lib/lean/Std/Data/DHashMap/RawDef.olean.server lib/lean/Std/Data/DHashMap/RawLemmas.ilean +lib/lean/Std/Data/DHashMap/RawLemmas.ir lib/lean/Std/Data/DHashMap/RawLemmas.olean +lib/lean/Std/Data/DHashMap/RawLemmas.olean.private +lib/lean/Std/Data/DHashMap/RawLemmas.olean.server lib/lean/Std/Data/DTreeMap.ilean +lib/lean/Std/Data/DTreeMap.ir lib/lean/Std/Data/DTreeMap.olean +lib/lean/Std/Data/DTreeMap.olean.private +lib/lean/Std/Data/DTreeMap.olean.server lib/lean/Std/Data/DTreeMap/AdditionalOperations.ilean +lib/lean/Std/Data/DTreeMap/AdditionalOperations.ir lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean +lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean.private +lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean.server lib/lean/Std/Data/DTreeMap/Basic.ilean +lib/lean/Std/Data/DTreeMap/Basic.ir lib/lean/Std/Data/DTreeMap/Basic.olean +lib/lean/Std/Data/DTreeMap/Basic.olean.private +lib/lean/Std/Data/DTreeMap/Basic.olean.server lib/lean/Std/Data/DTreeMap/Internal/Balanced.ilean +lib/lean/Std/Data/DTreeMap/Internal/Balanced.ir lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean +lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean.server lib/lean/Std/Data/DTreeMap/Internal/Balancing.ilean +lib/lean/Std/Data/DTreeMap/Internal/Balancing.ir lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean +lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean.server lib/lean/Std/Data/DTreeMap/Internal/Cell.ilean +lib/lean/Std/Data/DTreeMap/Internal/Cell.ir lib/lean/Std/Data/DTreeMap/Internal/Cell.olean +lib/lean/Std/Data/DTreeMap/Internal/Cell.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Cell.olean.server lib/lean/Std/Data/DTreeMap/Internal/Def.ilean +lib/lean/Std/Data/DTreeMap/Internal/Def.ir lib/lean/Std/Data/DTreeMap/Internal/Def.olean +lib/lean/Std/Data/DTreeMap/Internal/Def.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Def.olean.server lib/lean/Std/Data/DTreeMap/Internal/Lemmas.ilean +lib/lean/Std/Data/DTreeMap/Internal/Lemmas.ir lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean +lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean.server lib/lean/Std/Data/DTreeMap/Internal/Model.ilean +lib/lean/Std/Data/DTreeMap/Internal/Model.ir lib/lean/Std/Data/DTreeMap/Internal/Model.olean +lib/lean/Std/Data/DTreeMap/Internal/Model.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Model.olean.server lib/lean/Std/Data/DTreeMap/Internal/Operations.ilean +lib/lean/Std/Data/DTreeMap/Internal/Operations.ir lib/lean/Std/Data/DTreeMap/Internal/Operations.olean +lib/lean/Std/Data/DTreeMap/Internal/Operations.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Operations.olean.server lib/lean/Std/Data/DTreeMap/Internal/Ordered.ilean +lib/lean/Std/Data/DTreeMap/Internal/Ordered.ir lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean +lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean.server lib/lean/Std/Data/DTreeMap/Internal/Queries.ilean +lib/lean/Std/Data/DTreeMap/Internal/Queries.ir lib/lean/Std/Data/DTreeMap/Internal/Queries.olean +lib/lean/Std/Data/DTreeMap/Internal/Queries.olean.private +lib/lean/Std/Data/DTreeMap/Internal/Queries.olean.server lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.ilean +lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.ir lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean +lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean.private +lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean.server lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.ilean +lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.ir lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean +lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean.private +lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean.server lib/lean/Std/Data/DTreeMap/Lemmas.ilean +lib/lean/Std/Data/DTreeMap/Lemmas.ir lib/lean/Std/Data/DTreeMap/Lemmas.olean +lib/lean/Std/Data/DTreeMap/Lemmas.olean.private +lib/lean/Std/Data/DTreeMap/Lemmas.olean.server lib/lean/Std/Data/DTreeMap/Raw.ilean +lib/lean/Std/Data/DTreeMap/Raw.ir lib/lean/Std/Data/DTreeMap/Raw.olean +lib/lean/Std/Data/DTreeMap/Raw.olean.private +lib/lean/Std/Data/DTreeMap/Raw.olean.server lib/lean/Std/Data/DTreeMap/Raw/AdditionalOperations.ilean +lib/lean/Std/Data/DTreeMap/Raw/AdditionalOperations.ir lib/lean/Std/Data/DTreeMap/Raw/AdditionalOperations.olean +lib/lean/Std/Data/DTreeMap/Raw/AdditionalOperations.olean.private +lib/lean/Std/Data/DTreeMap/Raw/AdditionalOperations.olean.server lib/lean/Std/Data/DTreeMap/Raw/Basic.ilean +lib/lean/Std/Data/DTreeMap/Raw/Basic.ir lib/lean/Std/Data/DTreeMap/Raw/Basic.olean +lib/lean/Std/Data/DTreeMap/Raw/Basic.olean.private +lib/lean/Std/Data/DTreeMap/Raw/Basic.olean.server lib/lean/Std/Data/DTreeMap/Raw/Lemmas.ilean +lib/lean/Std/Data/DTreeMap/Raw/Lemmas.ir lib/lean/Std/Data/DTreeMap/Raw/Lemmas.olean +lib/lean/Std/Data/DTreeMap/Raw/Lemmas.olean.private +lib/lean/Std/Data/DTreeMap/Raw/Lemmas.olean.server lib/lean/Std/Data/DTreeMap/Raw/WF.ilean +lib/lean/Std/Data/DTreeMap/Raw/WF.ir lib/lean/Std/Data/DTreeMap/Raw/WF.olean +lib/lean/Std/Data/DTreeMap/Raw/WF.olean.private +lib/lean/Std/Data/DTreeMap/Raw/WF.olean.server lib/lean/Std/Data/ExtDHashMap.ilean +lib/lean/Std/Data/ExtDHashMap.ir lib/lean/Std/Data/ExtDHashMap.olean +lib/lean/Std/Data/ExtDHashMap.olean.private +lib/lean/Std/Data/ExtDHashMap.olean.server lib/lean/Std/Data/ExtDHashMap/Basic.ilean +lib/lean/Std/Data/ExtDHashMap/Basic.ir lib/lean/Std/Data/ExtDHashMap/Basic.olean +lib/lean/Std/Data/ExtDHashMap/Basic.olean.private +lib/lean/Std/Data/ExtDHashMap/Basic.olean.server lib/lean/Std/Data/ExtDHashMap/Lemmas.ilean +lib/lean/Std/Data/ExtDHashMap/Lemmas.ir lib/lean/Std/Data/ExtDHashMap/Lemmas.olean +lib/lean/Std/Data/ExtDHashMap/Lemmas.olean.private +lib/lean/Std/Data/ExtDHashMap/Lemmas.olean.server lib/lean/Std/Data/ExtDTreeMap.ilean +lib/lean/Std/Data/ExtDTreeMap.ir lib/lean/Std/Data/ExtDTreeMap.olean +lib/lean/Std/Data/ExtDTreeMap.olean.private +lib/lean/Std/Data/ExtDTreeMap.olean.server lib/lean/Std/Data/ExtDTreeMap/Basic.ilean +lib/lean/Std/Data/ExtDTreeMap/Basic.ir lib/lean/Std/Data/ExtDTreeMap/Basic.olean +lib/lean/Std/Data/ExtDTreeMap/Basic.olean.private +lib/lean/Std/Data/ExtDTreeMap/Basic.olean.server lib/lean/Std/Data/ExtDTreeMap/Lemmas.ilean +lib/lean/Std/Data/ExtDTreeMap/Lemmas.ir lib/lean/Std/Data/ExtDTreeMap/Lemmas.olean +lib/lean/Std/Data/ExtDTreeMap/Lemmas.olean.private +lib/lean/Std/Data/ExtDTreeMap/Lemmas.olean.server lib/lean/Std/Data/ExtHashMap.ilean +lib/lean/Std/Data/ExtHashMap.ir lib/lean/Std/Data/ExtHashMap.olean +lib/lean/Std/Data/ExtHashMap.olean.private +lib/lean/Std/Data/ExtHashMap.olean.server lib/lean/Std/Data/ExtHashMap/Basic.ilean +lib/lean/Std/Data/ExtHashMap/Basic.ir lib/lean/Std/Data/ExtHashMap/Basic.olean +lib/lean/Std/Data/ExtHashMap/Basic.olean.private +lib/lean/Std/Data/ExtHashMap/Basic.olean.server lib/lean/Std/Data/ExtHashMap/Lemmas.ilean +lib/lean/Std/Data/ExtHashMap/Lemmas.ir lib/lean/Std/Data/ExtHashMap/Lemmas.olean +lib/lean/Std/Data/ExtHashMap/Lemmas.olean.private +lib/lean/Std/Data/ExtHashMap/Lemmas.olean.server lib/lean/Std/Data/ExtHashSet.ilean +lib/lean/Std/Data/ExtHashSet.ir lib/lean/Std/Data/ExtHashSet.olean +lib/lean/Std/Data/ExtHashSet.olean.private +lib/lean/Std/Data/ExtHashSet.olean.server lib/lean/Std/Data/ExtHashSet/Basic.ilean +lib/lean/Std/Data/ExtHashSet/Basic.ir lib/lean/Std/Data/ExtHashSet/Basic.olean +lib/lean/Std/Data/ExtHashSet/Basic.olean.private +lib/lean/Std/Data/ExtHashSet/Basic.olean.server lib/lean/Std/Data/ExtHashSet/Lemmas.ilean +lib/lean/Std/Data/ExtHashSet/Lemmas.ir lib/lean/Std/Data/ExtHashSet/Lemmas.olean +lib/lean/Std/Data/ExtHashSet/Lemmas.olean.private +lib/lean/Std/Data/ExtHashSet/Lemmas.olean.server lib/lean/Std/Data/ExtTreeMap.ilean +lib/lean/Std/Data/ExtTreeMap.ir lib/lean/Std/Data/ExtTreeMap.olean +lib/lean/Std/Data/ExtTreeMap.olean.private +lib/lean/Std/Data/ExtTreeMap.olean.server lib/lean/Std/Data/ExtTreeMap/Basic.ilean +lib/lean/Std/Data/ExtTreeMap/Basic.ir lib/lean/Std/Data/ExtTreeMap/Basic.olean +lib/lean/Std/Data/ExtTreeMap/Basic.olean.private +lib/lean/Std/Data/ExtTreeMap/Basic.olean.server lib/lean/Std/Data/ExtTreeMap/Lemmas.ilean +lib/lean/Std/Data/ExtTreeMap/Lemmas.ir lib/lean/Std/Data/ExtTreeMap/Lemmas.olean +lib/lean/Std/Data/ExtTreeMap/Lemmas.olean.private +lib/lean/Std/Data/ExtTreeMap/Lemmas.olean.server lib/lean/Std/Data/ExtTreeSet.ilean +lib/lean/Std/Data/ExtTreeSet.ir lib/lean/Std/Data/ExtTreeSet.olean +lib/lean/Std/Data/ExtTreeSet.olean.private +lib/lean/Std/Data/ExtTreeSet.olean.server lib/lean/Std/Data/ExtTreeSet/Basic.ilean +lib/lean/Std/Data/ExtTreeSet/Basic.ir lib/lean/Std/Data/ExtTreeSet/Basic.olean +lib/lean/Std/Data/ExtTreeSet/Basic.olean.private +lib/lean/Std/Data/ExtTreeSet/Basic.olean.server lib/lean/Std/Data/ExtTreeSet/Lemmas.ilean +lib/lean/Std/Data/ExtTreeSet/Lemmas.ir lib/lean/Std/Data/ExtTreeSet/Lemmas.olean +lib/lean/Std/Data/ExtTreeSet/Lemmas.olean.private +lib/lean/Std/Data/ExtTreeSet/Lemmas.olean.server lib/lean/Std/Data/HashMap.ilean +lib/lean/Std/Data/HashMap.ir lib/lean/Std/Data/HashMap.olean +lib/lean/Std/Data/HashMap.olean.private +lib/lean/Std/Data/HashMap.olean.server lib/lean/Std/Data/HashMap/AdditionalOperations.ilean +lib/lean/Std/Data/HashMap/AdditionalOperations.ir lib/lean/Std/Data/HashMap/AdditionalOperations.olean +lib/lean/Std/Data/HashMap/AdditionalOperations.olean.private +lib/lean/Std/Data/HashMap/AdditionalOperations.olean.server lib/lean/Std/Data/HashMap/Basic.ilean +lib/lean/Std/Data/HashMap/Basic.ir lib/lean/Std/Data/HashMap/Basic.olean +lib/lean/Std/Data/HashMap/Basic.olean.private +lib/lean/Std/Data/HashMap/Basic.olean.server lib/lean/Std/Data/HashMap/Lemmas.ilean +lib/lean/Std/Data/HashMap/Lemmas.ir lib/lean/Std/Data/HashMap/Lemmas.olean +lib/lean/Std/Data/HashMap/Lemmas.olean.private +lib/lean/Std/Data/HashMap/Lemmas.olean.server lib/lean/Std/Data/HashMap/Raw.ilean +lib/lean/Std/Data/HashMap/Raw.ir lib/lean/Std/Data/HashMap/Raw.olean +lib/lean/Std/Data/HashMap/Raw.olean.private +lib/lean/Std/Data/HashMap/Raw.olean.server lib/lean/Std/Data/HashMap/RawLemmas.ilean +lib/lean/Std/Data/HashMap/RawLemmas.ir lib/lean/Std/Data/HashMap/RawLemmas.olean +lib/lean/Std/Data/HashMap/RawLemmas.olean.private +lib/lean/Std/Data/HashMap/RawLemmas.olean.server lib/lean/Std/Data/HashSet.ilean +lib/lean/Std/Data/HashSet.ir lib/lean/Std/Data/HashSet.olean +lib/lean/Std/Data/HashSet.olean.private +lib/lean/Std/Data/HashSet.olean.server lib/lean/Std/Data/HashSet/Basic.ilean +lib/lean/Std/Data/HashSet/Basic.ir lib/lean/Std/Data/HashSet/Basic.olean +lib/lean/Std/Data/HashSet/Basic.olean.private +lib/lean/Std/Data/HashSet/Basic.olean.server lib/lean/Std/Data/HashSet/Lemmas.ilean +lib/lean/Std/Data/HashSet/Lemmas.ir lib/lean/Std/Data/HashSet/Lemmas.olean +lib/lean/Std/Data/HashSet/Lemmas.olean.private +lib/lean/Std/Data/HashSet/Lemmas.olean.server lib/lean/Std/Data/HashSet/Raw.ilean +lib/lean/Std/Data/HashSet/Raw.ir lib/lean/Std/Data/HashSet/Raw.olean +lib/lean/Std/Data/HashSet/Raw.olean.private +lib/lean/Std/Data/HashSet/Raw.olean.server lib/lean/Std/Data/HashSet/RawLemmas.ilean +lib/lean/Std/Data/HashSet/RawLemmas.ir lib/lean/Std/Data/HashSet/RawLemmas.olean +lib/lean/Std/Data/HashSet/RawLemmas.olean.private +lib/lean/Std/Data/HashSet/RawLemmas.olean.server lib/lean/Std/Data/Internal/Cut.ilean +lib/lean/Std/Data/Internal/Cut.ir lib/lean/Std/Data/Internal/Cut.olean +lib/lean/Std/Data/Internal/Cut.olean.private +lib/lean/Std/Data/Internal/Cut.olean.server lib/lean/Std/Data/Internal/List/Associative.ilean +lib/lean/Std/Data/Internal/List/Associative.ir lib/lean/Std/Data/Internal/List/Associative.olean +lib/lean/Std/Data/Internal/List/Associative.olean.private +lib/lean/Std/Data/Internal/List/Associative.olean.server lib/lean/Std/Data/Internal/List/Defs.ilean +lib/lean/Std/Data/Internal/List/Defs.ir lib/lean/Std/Data/Internal/List/Defs.olean +lib/lean/Std/Data/Internal/List/Defs.olean.private +lib/lean/Std/Data/Internal/List/Defs.olean.server lib/lean/Std/Data/Iterators.ilean +lib/lean/Std/Data/Iterators.ir lib/lean/Std/Data/Iterators.olean +lib/lean/Std/Data/Iterators.olean.private +lib/lean/Std/Data/Iterators.olean.server lib/lean/Std/Data/Iterators/Combinators.ilean +lib/lean/Std/Data/Iterators/Combinators.ir lib/lean/Std/Data/Iterators/Combinators.olean +lib/lean/Std/Data/Iterators/Combinators.olean.private +lib/lean/Std/Data/Iterators/Combinators.olean.server lib/lean/Std/Data/Iterators/Combinators/Drop.ilean +lib/lean/Std/Data/Iterators/Combinators/Drop.ir lib/lean/Std/Data/Iterators/Combinators/Drop.olean +lib/lean/Std/Data/Iterators/Combinators/Drop.olean.private +lib/lean/Std/Data/Iterators/Combinators/Drop.olean.server lib/lean/Std/Data/Iterators/Combinators/DropWhile.ilean +lib/lean/Std/Data/Iterators/Combinators/DropWhile.ir lib/lean/Std/Data/Iterators/Combinators/DropWhile.olean +lib/lean/Std/Data/Iterators/Combinators/DropWhile.olean.private +lib/lean/Std/Data/Iterators/Combinators/DropWhile.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic.ir lib/lean/Std/Data/Iterators/Combinators/Monadic.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/Drop.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Drop.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/Drop.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Drop.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/Drop.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/DropWhile.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/DropWhile.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/DropWhile.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/DropWhile.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/DropWhile.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/StepSize.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/StepSize.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/StepSize.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/StepSize.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/StepSize.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/Take.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Take.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/Take.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Take.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/Take.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/TakeWhile.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/TakeWhile.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/TakeWhile.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/TakeWhile.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/TakeWhile.olean.server lib/lean/Std/Data/Iterators/Combinators/Monadic/Zip.ilean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Zip.ir lib/lean/Std/Data/Iterators/Combinators/Monadic/Zip.olean +lib/lean/Std/Data/Iterators/Combinators/Monadic/Zip.olean.private +lib/lean/Std/Data/Iterators/Combinators/Monadic/Zip.olean.server lib/lean/Std/Data/Iterators/Combinators/StepSize.ilean +lib/lean/Std/Data/Iterators/Combinators/StepSize.ir lib/lean/Std/Data/Iterators/Combinators/StepSize.olean +lib/lean/Std/Data/Iterators/Combinators/StepSize.olean.private +lib/lean/Std/Data/Iterators/Combinators/StepSize.olean.server lib/lean/Std/Data/Iterators/Combinators/Take.ilean +lib/lean/Std/Data/Iterators/Combinators/Take.ir lib/lean/Std/Data/Iterators/Combinators/Take.olean +lib/lean/Std/Data/Iterators/Combinators/Take.olean.private +lib/lean/Std/Data/Iterators/Combinators/Take.olean.server lib/lean/Std/Data/Iterators/Combinators/TakeWhile.ilean +lib/lean/Std/Data/Iterators/Combinators/TakeWhile.ir lib/lean/Std/Data/Iterators/Combinators/TakeWhile.olean +lib/lean/Std/Data/Iterators/Combinators/TakeWhile.olean.private +lib/lean/Std/Data/Iterators/Combinators/TakeWhile.olean.server lib/lean/Std/Data/Iterators/Combinators/Zip.ilean +lib/lean/Std/Data/Iterators/Combinators/Zip.ir lib/lean/Std/Data/Iterators/Combinators/Zip.olean +lib/lean/Std/Data/Iterators/Combinators/Zip.olean.private +lib/lean/Std/Data/Iterators/Combinators/Zip.olean.server lib/lean/Std/Data/Iterators/Lemmas.ilean +lib/lean/Std/Data/Iterators/Lemmas.ir lib/lean/Std/Data/Iterators/Lemmas.olean +lib/lean/Std/Data/Iterators/Lemmas.olean.private +lib/lean/Std/Data/Iterators/Lemmas.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Drop.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Drop.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Drop.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Drop.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Drop.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/DropWhile.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/DropWhile.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/DropWhile.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/DropWhile.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/DropWhile.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Drop.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Drop.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Drop.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Drop.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Drop.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/DropWhile.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/DropWhile.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/DropWhile.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/DropWhile.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/DropWhile.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/FilterMap.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/FilterMap.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/FilterMap.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/FilterMap.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/FilterMap.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Take.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Take.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Take.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Take.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Take.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/TakeWhile.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/TakeWhile.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/TakeWhile.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/TakeWhile.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/TakeWhile.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Zip.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Zip.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Zip.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Zip.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Monadic/Zip.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Take.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Take.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Take.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Take.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Take.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/TakeWhile.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/TakeWhile.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/TakeWhile.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/TakeWhile.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/TakeWhile.olean.server lib/lean/Std/Data/Iterators/Lemmas/Combinators/Zip.ilean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Zip.ir lib/lean/Std/Data/Iterators/Lemmas/Combinators/Zip.olean +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Zip.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Combinators/Zip.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers/Collect.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Collect.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers/Collect.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Collect.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Collect.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers/Loop.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Loop.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers/Loop.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Loop.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Loop.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Collect.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Collect.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Collect.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Collect.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Collect.olean.server lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Loop.ilean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Loop.ir lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Loop.olean +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Loop.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Consumers/Monadic/Loop.olean.server lib/lean/Std/Data/Iterators/Lemmas/Equivalence.ilean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence.ir lib/lean/Std/Data/Iterators/Lemmas/Equivalence.olean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Equivalence.olean.server lib/lean/Std/Data/Iterators/Lemmas/Equivalence/Basic.ilean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/Basic.ir lib/lean/Std/Data/Iterators/Lemmas/Equivalence/Basic.olean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/Basic.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/Basic.olean.server lib/lean/Std/Data/Iterators/Lemmas/Equivalence/HetT.ilean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/HetT.ir lib/lean/Std/Data/Iterators/Lemmas/Equivalence/HetT.olean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/HetT.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/HetT.olean.server lib/lean/Std/Data/Iterators/Lemmas/Equivalence/StepCongr.ilean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/StepCongr.ir lib/lean/Std/Data/Iterators/Lemmas/Equivalence/StepCongr.olean +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/StepCongr.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Equivalence/StepCongr.olean.server lib/lean/Std/Data/Iterators/Lemmas/Monadic.ilean +lib/lean/Std/Data/Iterators/Lemmas/Monadic.ir lib/lean/Std/Data/Iterators/Lemmas/Monadic.olean +lib/lean/Std/Data/Iterators/Lemmas/Monadic.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Monadic.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers.ir lib/lean/Std/Data/Iterators/Lemmas/Producers.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Array.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Array.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Array.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Array.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Array.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Empty.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Empty.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Empty.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Empty.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Empty.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/List.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/List.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/List.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/List.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/List.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Array.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Array.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Array.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Array.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Array.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Empty.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Empty.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Empty.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Empty.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/Empty.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/List.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/List.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/List.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/List.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Monadic/List.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Range.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Range.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Range.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Range.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Range.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Repeat.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Repeat.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Repeat.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Repeat.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Repeat.olean.server lib/lean/Std/Data/Iterators/Lemmas/Producers/Slice.ilean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Slice.ir lib/lean/Std/Data/Iterators/Lemmas/Producers/Slice.olean +lib/lean/Std/Data/Iterators/Lemmas/Producers/Slice.olean.private +lib/lean/Std/Data/Iterators/Lemmas/Producers/Slice.olean.server lib/lean/Std/Data/Iterators/Producers.ilean +lib/lean/Std/Data/Iterators/Producers.ir lib/lean/Std/Data/Iterators/Producers.olean +lib/lean/Std/Data/Iterators/Producers.olean.private +lib/lean/Std/Data/Iterators/Producers.olean.server lib/lean/Std/Data/Iterators/Producers/Array.ilean +lib/lean/Std/Data/Iterators/Producers/Array.ir lib/lean/Std/Data/Iterators/Producers/Array.olean +lib/lean/Std/Data/Iterators/Producers/Array.olean.private +lib/lean/Std/Data/Iterators/Producers/Array.olean.server lib/lean/Std/Data/Iterators/Producers/Empty.ilean +lib/lean/Std/Data/Iterators/Producers/Empty.ir lib/lean/Std/Data/Iterators/Producers/Empty.olean +lib/lean/Std/Data/Iterators/Producers/Empty.olean.private +lib/lean/Std/Data/Iterators/Producers/Empty.olean.server lib/lean/Std/Data/Iterators/Producers/List.ilean +lib/lean/Std/Data/Iterators/Producers/List.ir lib/lean/Std/Data/Iterators/Producers/List.olean +lib/lean/Std/Data/Iterators/Producers/List.olean.private +lib/lean/Std/Data/Iterators/Producers/List.olean.server lib/lean/Std/Data/Iterators/Producers/Monadic.ilean +lib/lean/Std/Data/Iterators/Producers/Monadic.ir lib/lean/Std/Data/Iterators/Producers/Monadic.olean +lib/lean/Std/Data/Iterators/Producers/Monadic.olean.private +lib/lean/Std/Data/Iterators/Producers/Monadic.olean.server lib/lean/Std/Data/Iterators/Producers/Monadic/Array.ilean +lib/lean/Std/Data/Iterators/Producers/Monadic/Array.ir lib/lean/Std/Data/Iterators/Producers/Monadic/Array.olean +lib/lean/Std/Data/Iterators/Producers/Monadic/Array.olean.private +lib/lean/Std/Data/Iterators/Producers/Monadic/Array.olean.server lib/lean/Std/Data/Iterators/Producers/Monadic/Empty.ilean +lib/lean/Std/Data/Iterators/Producers/Monadic/Empty.ir lib/lean/Std/Data/Iterators/Producers/Monadic/Empty.olean +lib/lean/Std/Data/Iterators/Producers/Monadic/Empty.olean.private +lib/lean/Std/Data/Iterators/Producers/Monadic/Empty.olean.server lib/lean/Std/Data/Iterators/Producers/Monadic/List.ilean +lib/lean/Std/Data/Iterators/Producers/Monadic/List.ir lib/lean/Std/Data/Iterators/Producers/Monadic/List.olean +lib/lean/Std/Data/Iterators/Producers/Monadic/List.olean.private +lib/lean/Std/Data/Iterators/Producers/Monadic/List.olean.server lib/lean/Std/Data/Iterators/Producers/Range.ilean +lib/lean/Std/Data/Iterators/Producers/Range.ir lib/lean/Std/Data/Iterators/Producers/Range.olean +lib/lean/Std/Data/Iterators/Producers/Range.olean.private +lib/lean/Std/Data/Iterators/Producers/Range.olean.server lib/lean/Std/Data/Iterators/Producers/Repeat.ilean +lib/lean/Std/Data/Iterators/Producers/Repeat.ir lib/lean/Std/Data/Iterators/Producers/Repeat.olean +lib/lean/Std/Data/Iterators/Producers/Repeat.olean.private +lib/lean/Std/Data/Iterators/Producers/Repeat.olean.server lib/lean/Std/Data/Iterators/Producers/Slice.ilean +lib/lean/Std/Data/Iterators/Producers/Slice.ir lib/lean/Std/Data/Iterators/Producers/Slice.olean +lib/lean/Std/Data/Iterators/Producers/Slice.olean.private +lib/lean/Std/Data/Iterators/Producers/Slice.olean.server lib/lean/Std/Data/TreeMap.ilean +lib/lean/Std/Data/TreeMap.ir lib/lean/Std/Data/TreeMap.olean +lib/lean/Std/Data/TreeMap.olean.private +lib/lean/Std/Data/TreeMap.olean.server lib/lean/Std/Data/TreeMap/AdditionalOperations.ilean +lib/lean/Std/Data/TreeMap/AdditionalOperations.ir lib/lean/Std/Data/TreeMap/AdditionalOperations.olean +lib/lean/Std/Data/TreeMap/AdditionalOperations.olean.private +lib/lean/Std/Data/TreeMap/AdditionalOperations.olean.server lib/lean/Std/Data/TreeMap/Basic.ilean +lib/lean/Std/Data/TreeMap/Basic.ir lib/lean/Std/Data/TreeMap/Basic.olean +lib/lean/Std/Data/TreeMap/Basic.olean.private +lib/lean/Std/Data/TreeMap/Basic.olean.server lib/lean/Std/Data/TreeMap/Lemmas.ilean +lib/lean/Std/Data/TreeMap/Lemmas.ir lib/lean/Std/Data/TreeMap/Lemmas.olean +lib/lean/Std/Data/TreeMap/Lemmas.olean.private +lib/lean/Std/Data/TreeMap/Lemmas.olean.server lib/lean/Std/Data/TreeMap/Raw.ilean +lib/lean/Std/Data/TreeMap/Raw.ir lib/lean/Std/Data/TreeMap/Raw.olean +lib/lean/Std/Data/TreeMap/Raw.olean.private +lib/lean/Std/Data/TreeMap/Raw.olean.server lib/lean/Std/Data/TreeMap/Raw/AdditionalOperations.ilean +lib/lean/Std/Data/TreeMap/Raw/AdditionalOperations.ir lib/lean/Std/Data/TreeMap/Raw/AdditionalOperations.olean +lib/lean/Std/Data/TreeMap/Raw/AdditionalOperations.olean.private +lib/lean/Std/Data/TreeMap/Raw/AdditionalOperations.olean.server lib/lean/Std/Data/TreeMap/Raw/Basic.ilean +lib/lean/Std/Data/TreeMap/Raw/Basic.ir lib/lean/Std/Data/TreeMap/Raw/Basic.olean +lib/lean/Std/Data/TreeMap/Raw/Basic.olean.private +lib/lean/Std/Data/TreeMap/Raw/Basic.olean.server lib/lean/Std/Data/TreeMap/Raw/Lemmas.ilean +lib/lean/Std/Data/TreeMap/Raw/Lemmas.ir lib/lean/Std/Data/TreeMap/Raw/Lemmas.olean +lib/lean/Std/Data/TreeMap/Raw/Lemmas.olean.private +lib/lean/Std/Data/TreeMap/Raw/Lemmas.olean.server lib/lean/Std/Data/TreeMap/Raw/WF.ilean +lib/lean/Std/Data/TreeMap/Raw/WF.ir lib/lean/Std/Data/TreeMap/Raw/WF.olean +lib/lean/Std/Data/TreeMap/Raw/WF.olean.private +lib/lean/Std/Data/TreeMap/Raw/WF.olean.server lib/lean/Std/Data/TreeSet.ilean +lib/lean/Std/Data/TreeSet.ir lib/lean/Std/Data/TreeSet.olean +lib/lean/Std/Data/TreeSet.olean.private +lib/lean/Std/Data/TreeSet.olean.server lib/lean/Std/Data/TreeSet/AdditionalOperations.ilean +lib/lean/Std/Data/TreeSet/AdditionalOperations.ir lib/lean/Std/Data/TreeSet/AdditionalOperations.olean +lib/lean/Std/Data/TreeSet/AdditionalOperations.olean.private +lib/lean/Std/Data/TreeSet/AdditionalOperations.olean.server lib/lean/Std/Data/TreeSet/Basic.ilean +lib/lean/Std/Data/TreeSet/Basic.ir lib/lean/Std/Data/TreeSet/Basic.olean +lib/lean/Std/Data/TreeSet/Basic.olean.private +lib/lean/Std/Data/TreeSet/Basic.olean.server lib/lean/Std/Data/TreeSet/Lemmas.ilean +lib/lean/Std/Data/TreeSet/Lemmas.ir lib/lean/Std/Data/TreeSet/Lemmas.olean +lib/lean/Std/Data/TreeSet/Lemmas.olean.private +lib/lean/Std/Data/TreeSet/Lemmas.olean.server lib/lean/Std/Data/TreeSet/Raw.ilean +lib/lean/Std/Data/TreeSet/Raw.ir lib/lean/Std/Data/TreeSet/Raw.olean +lib/lean/Std/Data/TreeSet/Raw.olean.private +lib/lean/Std/Data/TreeSet/Raw.olean.server lib/lean/Std/Data/TreeSet/Raw/Basic.ilean +lib/lean/Std/Data/TreeSet/Raw/Basic.ir lib/lean/Std/Data/TreeSet/Raw/Basic.olean +lib/lean/Std/Data/TreeSet/Raw/Basic.olean.private +lib/lean/Std/Data/TreeSet/Raw/Basic.olean.server lib/lean/Std/Data/TreeSet/Raw/Lemmas.ilean +lib/lean/Std/Data/TreeSet/Raw/Lemmas.ir lib/lean/Std/Data/TreeSet/Raw/Lemmas.olean +lib/lean/Std/Data/TreeSet/Raw/Lemmas.olean.private +lib/lean/Std/Data/TreeSet/Raw/Lemmas.olean.server lib/lean/Std/Data/TreeSet/Raw/WF.ilean +lib/lean/Std/Data/TreeSet/Raw/WF.ir lib/lean/Std/Data/TreeSet/Raw/WF.olean +lib/lean/Std/Data/TreeSet/Raw/WF.olean.private +lib/lean/Std/Data/TreeSet/Raw/WF.olean.server lib/lean/Std/Do.ilean +lib/lean/Std/Do.ir lib/lean/Std/Do.olean +lib/lean/Std/Do.olean.private +lib/lean/Std/Do.olean.server lib/lean/Std/Do/PostCond.ilean +lib/lean/Std/Do/PostCond.ir lib/lean/Std/Do/PostCond.olean +lib/lean/Std/Do/PostCond.olean.private +lib/lean/Std/Do/PostCond.olean.server lib/lean/Std/Do/PredTrans.ilean +lib/lean/Std/Do/PredTrans.ir lib/lean/Std/Do/PredTrans.olean +lib/lean/Std/Do/PredTrans.olean.private +lib/lean/Std/Do/PredTrans.olean.server lib/lean/Std/Do/SPred.ilean +lib/lean/Std/Do/SPred.ir lib/lean/Std/Do/SPred.olean +lib/lean/Std/Do/SPred.olean.private +lib/lean/Std/Do/SPred.olean.server lib/lean/Std/Do/SPred/DerivedLaws.ilean +lib/lean/Std/Do/SPred/DerivedLaws.ir lib/lean/Std/Do/SPred/DerivedLaws.olean +lib/lean/Std/Do/SPred/DerivedLaws.olean.private +lib/lean/Std/Do/SPred/DerivedLaws.olean.server lib/lean/Std/Do/SPred/Laws.ilean +lib/lean/Std/Do/SPred/Laws.ir lib/lean/Std/Do/SPred/Laws.olean +lib/lean/Std/Do/SPred/Laws.olean.private +lib/lean/Std/Do/SPred/Laws.olean.server lib/lean/Std/Do/SPred/Notation.ilean +lib/lean/Std/Do/SPred/Notation.ir lib/lean/Std/Do/SPred/Notation.olean +lib/lean/Std/Do/SPred/Notation.olean.private +lib/lean/Std/Do/SPred/Notation.olean.server lib/lean/Std/Do/SPred/SPred.ilean +lib/lean/Std/Do/SPred/SPred.ir lib/lean/Std/Do/SPred/SPred.olean +lib/lean/Std/Do/SPred/SPred.olean.private +lib/lean/Std/Do/SPred/SPred.olean.server lib/lean/Std/Do/SPred/SVal.ilean +lib/lean/Std/Do/SPred/SVal.ir lib/lean/Std/Do/SPred/SVal.olean +lib/lean/Std/Do/SPred/SVal.olean.private +lib/lean/Std/Do/SPred/SVal.olean.server lib/lean/Std/Do/Triple.ilean +lib/lean/Std/Do/Triple.ir lib/lean/Std/Do/Triple.olean +lib/lean/Std/Do/Triple.olean.private +lib/lean/Std/Do/Triple.olean.server lib/lean/Std/Do/Triple/Basic.ilean +lib/lean/Std/Do/Triple/Basic.ir lib/lean/Std/Do/Triple/Basic.olean +lib/lean/Std/Do/Triple/Basic.olean.private +lib/lean/Std/Do/Triple/Basic.olean.server lib/lean/Std/Do/Triple/SpecLemmas.ilean +lib/lean/Std/Do/Triple/SpecLemmas.ir lib/lean/Std/Do/Triple/SpecLemmas.olean +lib/lean/Std/Do/Triple/SpecLemmas.olean.private +lib/lean/Std/Do/Triple/SpecLemmas.olean.server lib/lean/Std/Do/WP.ilean +lib/lean/Std/Do/WP.ir lib/lean/Std/Do/WP.olean +lib/lean/Std/Do/WP.olean.private +lib/lean/Std/Do/WP.olean.server lib/lean/Std/Do/WP/Basic.ilean +lib/lean/Std/Do/WP/Basic.ir lib/lean/Std/Do/WP/Basic.olean +lib/lean/Std/Do/WP/Basic.olean.private +lib/lean/Std/Do/WP/Basic.olean.server lib/lean/Std/Do/WP/IO.ilean +lib/lean/Std/Do/WP/IO.ir lib/lean/Std/Do/WP/IO.olean +lib/lean/Std/Do/WP/IO.olean.private +lib/lean/Std/Do/WP/IO.olean.server lib/lean/Std/Do/WP/Monad.ilean +lib/lean/Std/Do/WP/Monad.ir lib/lean/Std/Do/WP/Monad.olean +lib/lean/Std/Do/WP/Monad.olean.private +lib/lean/Std/Do/WP/Monad.olean.server lib/lean/Std/Do/WP/SimpLemmas.ilean +lib/lean/Std/Do/WP/SimpLemmas.ir lib/lean/Std/Do/WP/SimpLemmas.olean +lib/lean/Std/Do/WP/SimpLemmas.olean.private +lib/lean/Std/Do/WP/SimpLemmas.olean.server lib/lean/Std/Internal.ilean +lib/lean/Std/Internal.ir lib/lean/Std/Internal.olean +lib/lean/Std/Internal.olean.private +lib/lean/Std/Internal.olean.server lib/lean/Std/Internal/Async.ilean +lib/lean/Std/Internal/Async.ir lib/lean/Std/Internal/Async.olean +lib/lean/Std/Internal/Async.olean.private +lib/lean/Std/Internal/Async.olean.server lib/lean/Std/Internal/Async/Basic.ilean +lib/lean/Std/Internal/Async/Basic.ir lib/lean/Std/Internal/Async/Basic.olean +lib/lean/Std/Internal/Async/Basic.olean.private +lib/lean/Std/Internal/Async/Basic.olean.server lib/lean/Std/Internal/Async/DNS.ilean +lib/lean/Std/Internal/Async/DNS.ir lib/lean/Std/Internal/Async/DNS.olean +lib/lean/Std/Internal/Async/DNS.olean.private +lib/lean/Std/Internal/Async/DNS.olean.server lib/lean/Std/Internal/Async/Process.ilean +lib/lean/Std/Internal/Async/Process.ir lib/lean/Std/Internal/Async/Process.olean +lib/lean/Std/Internal/Async/Process.olean.private +lib/lean/Std/Internal/Async/Process.olean.server lib/lean/Std/Internal/Async/Select.ilean +lib/lean/Std/Internal/Async/Select.ir lib/lean/Std/Internal/Async/Select.olean +lib/lean/Std/Internal/Async/Select.olean.private +lib/lean/Std/Internal/Async/Select.olean.server lib/lean/Std/Internal/Async/System.ilean +lib/lean/Std/Internal/Async/System.ir lib/lean/Std/Internal/Async/System.olean +lib/lean/Std/Internal/Async/System.olean.private +lib/lean/Std/Internal/Async/System.olean.server lib/lean/Std/Internal/Async/TCP.ilean +lib/lean/Std/Internal/Async/TCP.ir lib/lean/Std/Internal/Async/TCP.olean +lib/lean/Std/Internal/Async/TCP.olean.private +lib/lean/Std/Internal/Async/TCP.olean.server lib/lean/Std/Internal/Async/Timer.ilean +lib/lean/Std/Internal/Async/Timer.ir lib/lean/Std/Internal/Async/Timer.olean +lib/lean/Std/Internal/Async/Timer.olean.private +lib/lean/Std/Internal/Async/Timer.olean.server lib/lean/Std/Internal/Async/UDP.ilean +lib/lean/Std/Internal/Async/UDP.ir lib/lean/Std/Internal/Async/UDP.olean +lib/lean/Std/Internal/Async/UDP.olean.private +lib/lean/Std/Internal/Async/UDP.olean.server lib/lean/Std/Internal/Parsec.ilean +lib/lean/Std/Internal/Parsec.ir lib/lean/Std/Internal/Parsec.olean +lib/lean/Std/Internal/Parsec.olean.private +lib/lean/Std/Internal/Parsec.olean.server lib/lean/Std/Internal/Parsec/Basic.ilean +lib/lean/Std/Internal/Parsec/Basic.ir lib/lean/Std/Internal/Parsec/Basic.olean +lib/lean/Std/Internal/Parsec/Basic.olean.private +lib/lean/Std/Internal/Parsec/Basic.olean.server lib/lean/Std/Internal/Parsec/ByteArray.ilean +lib/lean/Std/Internal/Parsec/ByteArray.ir lib/lean/Std/Internal/Parsec/ByteArray.olean +lib/lean/Std/Internal/Parsec/ByteArray.olean.private +lib/lean/Std/Internal/Parsec/ByteArray.olean.server lib/lean/Std/Internal/Parsec/String.ilean +lib/lean/Std/Internal/Parsec/String.ir lib/lean/Std/Internal/Parsec/String.olean +lib/lean/Std/Internal/Parsec/String.olean.private +lib/lean/Std/Internal/Parsec/String.olean.server lib/lean/Std/Internal/Rat.ilean +lib/lean/Std/Internal/Rat.ir lib/lean/Std/Internal/Rat.olean +lib/lean/Std/Internal/Rat.olean.private +lib/lean/Std/Internal/Rat.olean.server lib/lean/Std/Internal/UV.ilean +lib/lean/Std/Internal/UV.ir lib/lean/Std/Internal/UV.olean +lib/lean/Std/Internal/UV.olean.private +lib/lean/Std/Internal/UV.olean.server lib/lean/Std/Internal/UV/DNS.ilean +lib/lean/Std/Internal/UV/DNS.ir lib/lean/Std/Internal/UV/DNS.olean +lib/lean/Std/Internal/UV/DNS.olean.private +lib/lean/Std/Internal/UV/DNS.olean.server lib/lean/Std/Internal/UV/Loop.ilean +lib/lean/Std/Internal/UV/Loop.ir lib/lean/Std/Internal/UV/Loop.olean +lib/lean/Std/Internal/UV/Loop.olean.private +lib/lean/Std/Internal/UV/Loop.olean.server lib/lean/Std/Internal/UV/System.ilean +lib/lean/Std/Internal/UV/System.ir lib/lean/Std/Internal/UV/System.olean +lib/lean/Std/Internal/UV/System.olean.private +lib/lean/Std/Internal/UV/System.olean.server lib/lean/Std/Internal/UV/TCP.ilean +lib/lean/Std/Internal/UV/TCP.ir lib/lean/Std/Internal/UV/TCP.olean +lib/lean/Std/Internal/UV/TCP.olean.private +lib/lean/Std/Internal/UV/TCP.olean.server lib/lean/Std/Internal/UV/Timer.ilean +lib/lean/Std/Internal/UV/Timer.ir lib/lean/Std/Internal/UV/Timer.olean +lib/lean/Std/Internal/UV/Timer.olean.private +lib/lean/Std/Internal/UV/Timer.olean.server lib/lean/Std/Internal/UV/UDP.ilean +lib/lean/Std/Internal/UV/UDP.ir lib/lean/Std/Internal/UV/UDP.olean +lib/lean/Std/Internal/UV/UDP.olean.private +lib/lean/Std/Internal/UV/UDP.olean.server lib/lean/Std/Net.ilean +lib/lean/Std/Net.ir lib/lean/Std/Net.olean +lib/lean/Std/Net.olean.private +lib/lean/Std/Net.olean.server lib/lean/Std/Net/Addr.ilean +lib/lean/Std/Net/Addr.ir lib/lean/Std/Net/Addr.olean +lib/lean/Std/Net/Addr.olean.private +lib/lean/Std/Net/Addr.olean.server lib/lean/Std/Sat.ilean +lib/lean/Std/Sat.ir lib/lean/Std/Sat.olean +lib/lean/Std/Sat.olean.private +lib/lean/Std/Sat.olean.server lib/lean/Std/Sat/AIG.ilean +lib/lean/Std/Sat/AIG.ir lib/lean/Std/Sat/AIG.olean +lib/lean/Std/Sat/AIG.olean.private +lib/lean/Std/Sat/AIG.olean.server lib/lean/Std/Sat/AIG/Basic.ilean +lib/lean/Std/Sat/AIG/Basic.ir lib/lean/Std/Sat/AIG/Basic.olean +lib/lean/Std/Sat/AIG/Basic.olean.private +lib/lean/Std/Sat/AIG/Basic.olean.server lib/lean/Std/Sat/AIG/CNF.ilean +lib/lean/Std/Sat/AIG/CNF.ir lib/lean/Std/Sat/AIG/CNF.olean +lib/lean/Std/Sat/AIG/CNF.olean.private +lib/lean/Std/Sat/AIG/CNF.olean.server lib/lean/Std/Sat/AIG/Cached.ilean +lib/lean/Std/Sat/AIG/Cached.ir lib/lean/Std/Sat/AIG/Cached.olean +lib/lean/Std/Sat/AIG/Cached.olean.private +lib/lean/Std/Sat/AIG/Cached.olean.server lib/lean/Std/Sat/AIG/CachedGates.ilean +lib/lean/Std/Sat/AIG/CachedGates.ir lib/lean/Std/Sat/AIG/CachedGates.olean +lib/lean/Std/Sat/AIG/CachedGates.olean.private +lib/lean/Std/Sat/AIG/CachedGates.olean.server lib/lean/Std/Sat/AIG/CachedGatesLemmas.ilean +lib/lean/Std/Sat/AIG/CachedGatesLemmas.ir lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean +lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean.private +lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean.server lib/lean/Std/Sat/AIG/CachedLemmas.ilean +lib/lean/Std/Sat/AIG/CachedLemmas.ir lib/lean/Std/Sat/AIG/CachedLemmas.olean +lib/lean/Std/Sat/AIG/CachedLemmas.olean.private +lib/lean/Std/Sat/AIG/CachedLemmas.olean.server lib/lean/Std/Sat/AIG/If.ilean +lib/lean/Std/Sat/AIG/If.ir lib/lean/Std/Sat/AIG/If.olean +lib/lean/Std/Sat/AIG/If.olean.private +lib/lean/Std/Sat/AIG/If.olean.server lib/lean/Std/Sat/AIG/LawfulOperator.ilean +lib/lean/Std/Sat/AIG/LawfulOperator.ir lib/lean/Std/Sat/AIG/LawfulOperator.olean +lib/lean/Std/Sat/AIG/LawfulOperator.olean.private +lib/lean/Std/Sat/AIG/LawfulOperator.olean.server lib/lean/Std/Sat/AIG/LawfulVecOperator.ilean +lib/lean/Std/Sat/AIG/LawfulVecOperator.ir lib/lean/Std/Sat/AIG/LawfulVecOperator.olean +lib/lean/Std/Sat/AIG/LawfulVecOperator.olean.private +lib/lean/Std/Sat/AIG/LawfulVecOperator.olean.server lib/lean/Std/Sat/AIG/Lemmas.ilean +lib/lean/Std/Sat/AIG/Lemmas.ir lib/lean/Std/Sat/AIG/Lemmas.olean +lib/lean/Std/Sat/AIG/Lemmas.olean.private +lib/lean/Std/Sat/AIG/Lemmas.olean.server lib/lean/Std/Sat/AIG/RefVec.ilean +lib/lean/Std/Sat/AIG/RefVec.ir lib/lean/Std/Sat/AIG/RefVec.olean +lib/lean/Std/Sat/AIG/RefVec.olean.private +lib/lean/Std/Sat/AIG/RefVec.olean.server lib/lean/Std/Sat/AIG/RefVecOperator.ilean +lib/lean/Std/Sat/AIG/RefVecOperator.ir lib/lean/Std/Sat/AIG/RefVecOperator.olean +lib/lean/Std/Sat/AIG/RefVecOperator.olean.private +lib/lean/Std/Sat/AIG/RefVecOperator.olean.server lib/lean/Std/Sat/AIG/RefVecOperator/Fold.ilean +lib/lean/Std/Sat/AIG/RefVecOperator/Fold.ir lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean +lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean.private +lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean.server lib/lean/Std/Sat/AIG/RefVecOperator/Map.ilean +lib/lean/Std/Sat/AIG/RefVecOperator/Map.ir lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean +lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean.private +lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean.server lib/lean/Std/Sat/AIG/RefVecOperator/Zip.ilean +lib/lean/Std/Sat/AIG/RefVecOperator/Zip.ir lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean +lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean.private +lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean.server lib/lean/Std/Sat/AIG/Relabel.ilean +lib/lean/Std/Sat/AIG/Relabel.ir lib/lean/Std/Sat/AIG/Relabel.olean +lib/lean/Std/Sat/AIG/Relabel.olean.private +lib/lean/Std/Sat/AIG/Relabel.olean.server lib/lean/Std/Sat/AIG/RelabelNat.ilean +lib/lean/Std/Sat/AIG/RelabelNat.ir lib/lean/Std/Sat/AIG/RelabelNat.olean +lib/lean/Std/Sat/AIG/RelabelNat.olean.private +lib/lean/Std/Sat/AIG/RelabelNat.olean.server lib/lean/Std/Sat/CNF.ilean +lib/lean/Std/Sat/CNF.ir lib/lean/Std/Sat/CNF.olean +lib/lean/Std/Sat/CNF.olean.private +lib/lean/Std/Sat/CNF.olean.server lib/lean/Std/Sat/CNF/Basic.ilean +lib/lean/Std/Sat/CNF/Basic.ir lib/lean/Std/Sat/CNF/Basic.olean +lib/lean/Std/Sat/CNF/Basic.olean.private +lib/lean/Std/Sat/CNF/Basic.olean.server lib/lean/Std/Sat/CNF/Dimacs.ilean +lib/lean/Std/Sat/CNF/Dimacs.ir lib/lean/Std/Sat/CNF/Dimacs.olean +lib/lean/Std/Sat/CNF/Dimacs.olean.private +lib/lean/Std/Sat/CNF/Dimacs.olean.server lib/lean/Std/Sat/CNF/Literal.ilean +lib/lean/Std/Sat/CNF/Literal.ir lib/lean/Std/Sat/CNF/Literal.olean +lib/lean/Std/Sat/CNF/Literal.olean.private +lib/lean/Std/Sat/CNF/Literal.olean.server lib/lean/Std/Sat/CNF/Relabel.ilean +lib/lean/Std/Sat/CNF/Relabel.ir lib/lean/Std/Sat/CNF/Relabel.olean +lib/lean/Std/Sat/CNF/Relabel.olean.private +lib/lean/Std/Sat/CNF/Relabel.olean.server lib/lean/Std/Sat/CNF/RelabelFin.ilean +lib/lean/Std/Sat/CNF/RelabelFin.ir lib/lean/Std/Sat/CNF/RelabelFin.olean +lib/lean/Std/Sat/CNF/RelabelFin.olean.private +lib/lean/Std/Sat/CNF/RelabelFin.olean.server lib/lean/Std/Sync.ilean +lib/lean/Std/Sync.ir lib/lean/Std/Sync.olean +lib/lean/Std/Sync.olean.private +lib/lean/Std/Sync.olean.server lib/lean/Std/Sync/Barrier.ilean +lib/lean/Std/Sync/Barrier.ir lib/lean/Std/Sync/Barrier.olean +lib/lean/Std/Sync/Barrier.olean.private +lib/lean/Std/Sync/Barrier.olean.server lib/lean/Std/Sync/Basic.ilean +lib/lean/Std/Sync/Basic.ir lib/lean/Std/Sync/Basic.olean +lib/lean/Std/Sync/Basic.olean.private +lib/lean/Std/Sync/Basic.olean.server lib/lean/Std/Sync/Channel.ilean +lib/lean/Std/Sync/Channel.ir lib/lean/Std/Sync/Channel.olean +lib/lean/Std/Sync/Channel.olean.private +lib/lean/Std/Sync/Channel.olean.server lib/lean/Std/Sync/Mutex.ilean +lib/lean/Std/Sync/Mutex.ir lib/lean/Std/Sync/Mutex.olean +lib/lean/Std/Sync/Mutex.olean.private +lib/lean/Std/Sync/Mutex.olean.server lib/lean/Std/Sync/RecursiveMutex.ilean +lib/lean/Std/Sync/RecursiveMutex.ir lib/lean/Std/Sync/RecursiveMutex.olean +lib/lean/Std/Sync/RecursiveMutex.olean.private +lib/lean/Std/Sync/RecursiveMutex.olean.server lib/lean/Std/Sync/SharedMutex.ilean +lib/lean/Std/Sync/SharedMutex.ir lib/lean/Std/Sync/SharedMutex.olean +lib/lean/Std/Sync/SharedMutex.olean.private +lib/lean/Std/Sync/SharedMutex.olean.server lib/lean/Std/Tactic.ilean +lib/lean/Std/Tactic.ir lib/lean/Std/Tactic.olean +lib/lean/Std/Tactic.olean.private +lib/lean/Std/Tactic.olean.server lib/lean/Std/Tactic/BVDecide.ilean +lib/lean/Std/Tactic/BVDecide.ir lib/lean/Std/Tactic/BVDecide.olean +lib/lean/Std/Tactic/BVDecide.olean.private +lib/lean/Std/Tactic/BVDecide.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast.ir lib/lean/Std/Tactic/BVDecide/Bitblast.olean +lib/lean/Std/Tactic/BVDecide/Bitblast.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Clz.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Clz.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Clz.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Clz.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Clz.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Reverse.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Clz.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Clz.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Clz.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Clz.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Clz.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Reverse.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean.server lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.ilean +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.ir lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean.private +lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean.server lib/lean/Std/Tactic/BVDecide/LRAT.ilean +lib/lean/Std/Tactic/BVDecide/LRAT.ir lib/lean/Std/Tactic/BVDecide/LRAT.olean +lib/lean/Std/Tactic/BVDecide/LRAT.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Actions.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Actions.ir lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Checker.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Checker.ir lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.ir lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean.server lib/lean/Std/Tactic/BVDecide/LRAT/Parser.ilean +lib/lean/Std/Tactic/BVDecide/LRAT/Parser.ir lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean +lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean.private +lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean.server lib/lean/Std/Tactic/BVDecide/Normalize.ilean +lib/lean/Std/Tactic/BVDecide/Normalize.ir lib/lean/Std/Tactic/BVDecide/Normalize.olean +lib/lean/Std/Tactic/BVDecide/Normalize.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize.olean.server lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.ilean +lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.ir lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean +lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean.server lib/lean/Std/Tactic/BVDecide/Normalize/Bool.ilean +lib/lean/Std/Tactic/BVDecide/Normalize/Bool.ir lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean +lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean.server lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.ilean +lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.ir lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean +lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean.server lib/lean/Std/Tactic/BVDecide/Normalize/Equal.ilean +lib/lean/Std/Tactic/BVDecide/Normalize/Equal.ir lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean +lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean.server lib/lean/Std/Tactic/BVDecide/Normalize/Prop.ilean +lib/lean/Std/Tactic/BVDecide/Normalize/Prop.ir lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean +lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean.private +lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean.server lib/lean/Std/Tactic/BVDecide/Reflect.ilean +lib/lean/Std/Tactic/BVDecide/Reflect.ir lib/lean/Std/Tactic/BVDecide/Reflect.olean +lib/lean/Std/Tactic/BVDecide/Reflect.olean.private +lib/lean/Std/Tactic/BVDecide/Reflect.olean.server lib/lean/Std/Tactic/BVDecide/Syntax.ilean +lib/lean/Std/Tactic/BVDecide/Syntax.ir lib/lean/Std/Tactic/BVDecide/Syntax.olean +lib/lean/Std/Tactic/BVDecide/Syntax.olean.private +lib/lean/Std/Tactic/BVDecide/Syntax.olean.server lib/lean/Std/Tactic/Do.ilean +lib/lean/Std/Tactic/Do.ir lib/lean/Std/Tactic/Do.olean +lib/lean/Std/Tactic/Do.olean.private +lib/lean/Std/Tactic/Do.olean.server lib/lean/Std/Tactic/Do/ProofMode.ilean +lib/lean/Std/Tactic/Do/ProofMode.ir lib/lean/Std/Tactic/Do/ProofMode.olean +lib/lean/Std/Tactic/Do/ProofMode.olean.private +lib/lean/Std/Tactic/Do/ProofMode.olean.server lib/lean/Std/Tactic/Do/Syntax.ilean +lib/lean/Std/Tactic/Do/Syntax.ir lib/lean/Std/Tactic/Do/Syntax.olean +lib/lean/Std/Tactic/Do/Syntax.olean.private +lib/lean/Std/Tactic/Do/Syntax.olean.server lib/lean/Std/Time.ilean +lib/lean/Std/Time.ir lib/lean/Std/Time.olean +lib/lean/Std/Time.olean.private +lib/lean/Std/Time.olean.server lib/lean/Std/Time/Date.ilean +lib/lean/Std/Time/Date.ir lib/lean/Std/Time/Date.olean +lib/lean/Std/Time/Date.olean.private +lib/lean/Std/Time/Date.olean.server lib/lean/Std/Time/Date/Basic.ilean +lib/lean/Std/Time/Date/Basic.ir lib/lean/Std/Time/Date/Basic.olean +lib/lean/Std/Time/Date/Basic.olean.private +lib/lean/Std/Time/Date/Basic.olean.server lib/lean/Std/Time/Date/PlainDate.ilean +lib/lean/Std/Time/Date/PlainDate.ir lib/lean/Std/Time/Date/PlainDate.olean +lib/lean/Std/Time/Date/PlainDate.olean.private +lib/lean/Std/Time/Date/PlainDate.olean.server lib/lean/Std/Time/Date/Unit/Basic.ilean +lib/lean/Std/Time/Date/Unit/Basic.ir lib/lean/Std/Time/Date/Unit/Basic.olean +lib/lean/Std/Time/Date/Unit/Basic.olean.private +lib/lean/Std/Time/Date/Unit/Basic.olean.server lib/lean/Std/Time/Date/Unit/Day.ilean +lib/lean/Std/Time/Date/Unit/Day.ir lib/lean/Std/Time/Date/Unit/Day.olean +lib/lean/Std/Time/Date/Unit/Day.olean.private +lib/lean/Std/Time/Date/Unit/Day.olean.server lib/lean/Std/Time/Date/Unit/Month.ilean +lib/lean/Std/Time/Date/Unit/Month.ir lib/lean/Std/Time/Date/Unit/Month.olean +lib/lean/Std/Time/Date/Unit/Month.olean.private +lib/lean/Std/Time/Date/Unit/Month.olean.server lib/lean/Std/Time/Date/Unit/Week.ilean +lib/lean/Std/Time/Date/Unit/Week.ir lib/lean/Std/Time/Date/Unit/Week.olean +lib/lean/Std/Time/Date/Unit/Week.olean.private +lib/lean/Std/Time/Date/Unit/Week.olean.server lib/lean/Std/Time/Date/Unit/Weekday.ilean +lib/lean/Std/Time/Date/Unit/Weekday.ir lib/lean/Std/Time/Date/Unit/Weekday.olean +lib/lean/Std/Time/Date/Unit/Weekday.olean.private +lib/lean/Std/Time/Date/Unit/Weekday.olean.server lib/lean/Std/Time/Date/Unit/Year.ilean +lib/lean/Std/Time/Date/Unit/Year.ir lib/lean/Std/Time/Date/Unit/Year.olean +lib/lean/Std/Time/Date/Unit/Year.olean.private +lib/lean/Std/Time/Date/Unit/Year.olean.server lib/lean/Std/Time/Date/ValidDate.ilean +lib/lean/Std/Time/Date/ValidDate.ir lib/lean/Std/Time/Date/ValidDate.olean +lib/lean/Std/Time/Date/ValidDate.olean.private +lib/lean/Std/Time/Date/ValidDate.olean.server lib/lean/Std/Time/DateTime.ilean +lib/lean/Std/Time/DateTime.ir lib/lean/Std/Time/DateTime.olean +lib/lean/Std/Time/DateTime.olean.private +lib/lean/Std/Time/DateTime.olean.server lib/lean/Std/Time/DateTime/PlainDateTime.ilean +lib/lean/Std/Time/DateTime/PlainDateTime.ir lib/lean/Std/Time/DateTime/PlainDateTime.olean +lib/lean/Std/Time/DateTime/PlainDateTime.olean.private +lib/lean/Std/Time/DateTime/PlainDateTime.olean.server lib/lean/Std/Time/DateTime/Timestamp.ilean +lib/lean/Std/Time/DateTime/Timestamp.ir lib/lean/Std/Time/DateTime/Timestamp.olean +lib/lean/Std/Time/DateTime/Timestamp.olean.private +lib/lean/Std/Time/DateTime/Timestamp.olean.server lib/lean/Std/Time/Duration.ilean +lib/lean/Std/Time/Duration.ir lib/lean/Std/Time/Duration.olean +lib/lean/Std/Time/Duration.olean.private +lib/lean/Std/Time/Duration.olean.server lib/lean/Std/Time/Format.ilean +lib/lean/Std/Time/Format.ir lib/lean/Std/Time/Format.olean +lib/lean/Std/Time/Format.olean.private +lib/lean/Std/Time/Format.olean.server lib/lean/Std/Time/Format/Basic.ilean +lib/lean/Std/Time/Format/Basic.ir lib/lean/Std/Time/Format/Basic.olean +lib/lean/Std/Time/Format/Basic.olean.private +lib/lean/Std/Time/Format/Basic.olean.server lib/lean/Std/Time/Internal.ilean +lib/lean/Std/Time/Internal.ir lib/lean/Std/Time/Internal.olean +lib/lean/Std/Time/Internal.olean.private +lib/lean/Std/Time/Internal.olean.server lib/lean/Std/Time/Internal/Bounded.ilean +lib/lean/Std/Time/Internal/Bounded.ir lib/lean/Std/Time/Internal/Bounded.olean +lib/lean/Std/Time/Internal/Bounded.olean.private +lib/lean/Std/Time/Internal/Bounded.olean.server lib/lean/Std/Time/Internal/UnitVal.ilean +lib/lean/Std/Time/Internal/UnitVal.ir lib/lean/Std/Time/Internal/UnitVal.olean +lib/lean/Std/Time/Internal/UnitVal.olean.private +lib/lean/Std/Time/Internal/UnitVal.olean.server lib/lean/Std/Time/Notation.ilean +lib/lean/Std/Time/Notation.ir lib/lean/Std/Time/Notation.olean +lib/lean/Std/Time/Notation.olean.private +lib/lean/Std/Time/Notation.olean.server lib/lean/Std/Time/Notation/Spec.ilean +lib/lean/Std/Time/Notation/Spec.ir lib/lean/Std/Time/Notation/Spec.olean +lib/lean/Std/Time/Notation/Spec.olean.private +lib/lean/Std/Time/Notation/Spec.olean.server lib/lean/Std/Time/Time.ilean +lib/lean/Std/Time/Time.ir lib/lean/Std/Time/Time.olean +lib/lean/Std/Time/Time.olean.private +lib/lean/Std/Time/Time.olean.server lib/lean/Std/Time/Time/Basic.ilean +lib/lean/Std/Time/Time/Basic.ir lib/lean/Std/Time/Time/Basic.olean +lib/lean/Std/Time/Time/Basic.olean.private +lib/lean/Std/Time/Time/Basic.olean.server lib/lean/Std/Time/Time/HourMarker.ilean +lib/lean/Std/Time/Time/HourMarker.ir lib/lean/Std/Time/Time/HourMarker.olean +lib/lean/Std/Time/Time/HourMarker.olean.private +lib/lean/Std/Time/Time/HourMarker.olean.server lib/lean/Std/Time/Time/PlainTime.ilean +lib/lean/Std/Time/Time/PlainTime.ir lib/lean/Std/Time/Time/PlainTime.olean +lib/lean/Std/Time/Time/PlainTime.olean.private +lib/lean/Std/Time/Time/PlainTime.olean.server lib/lean/Std/Time/Time/Unit/Basic.ilean +lib/lean/Std/Time/Time/Unit/Basic.ir lib/lean/Std/Time/Time/Unit/Basic.olean +lib/lean/Std/Time/Time/Unit/Basic.olean.private +lib/lean/Std/Time/Time/Unit/Basic.olean.server lib/lean/Std/Time/Time/Unit/Hour.ilean +lib/lean/Std/Time/Time/Unit/Hour.ir lib/lean/Std/Time/Time/Unit/Hour.olean +lib/lean/Std/Time/Time/Unit/Hour.olean.private +lib/lean/Std/Time/Time/Unit/Hour.olean.server lib/lean/Std/Time/Time/Unit/Millisecond.ilean +lib/lean/Std/Time/Time/Unit/Millisecond.ir lib/lean/Std/Time/Time/Unit/Millisecond.olean +lib/lean/Std/Time/Time/Unit/Millisecond.olean.private +lib/lean/Std/Time/Time/Unit/Millisecond.olean.server lib/lean/Std/Time/Time/Unit/Minute.ilean +lib/lean/Std/Time/Time/Unit/Minute.ir lib/lean/Std/Time/Time/Unit/Minute.olean +lib/lean/Std/Time/Time/Unit/Minute.olean.private +lib/lean/Std/Time/Time/Unit/Minute.olean.server lib/lean/Std/Time/Time/Unit/Nanosecond.ilean +lib/lean/Std/Time/Time/Unit/Nanosecond.ir lib/lean/Std/Time/Time/Unit/Nanosecond.olean +lib/lean/Std/Time/Time/Unit/Nanosecond.olean.private +lib/lean/Std/Time/Time/Unit/Nanosecond.olean.server lib/lean/Std/Time/Time/Unit/Second.ilean +lib/lean/Std/Time/Time/Unit/Second.ir lib/lean/Std/Time/Time/Unit/Second.olean +lib/lean/Std/Time/Time/Unit/Second.olean.private +lib/lean/Std/Time/Time/Unit/Second.olean.server lib/lean/Std/Time/Zoned.ilean +lib/lean/Std/Time/Zoned.ir lib/lean/Std/Time/Zoned.olean +lib/lean/Std/Time/Zoned.olean.private +lib/lean/Std/Time/Zoned.olean.server lib/lean/Std/Time/Zoned/Database.ilean +lib/lean/Std/Time/Zoned/Database.ir lib/lean/Std/Time/Zoned/Database.olean +lib/lean/Std/Time/Zoned/Database.olean.private +lib/lean/Std/Time/Zoned/Database.olean.server lib/lean/Std/Time/Zoned/Database/Basic.ilean +lib/lean/Std/Time/Zoned/Database/Basic.ir lib/lean/Std/Time/Zoned/Database/Basic.olean +lib/lean/Std/Time/Zoned/Database/Basic.olean.private +lib/lean/Std/Time/Zoned/Database/Basic.olean.server lib/lean/Std/Time/Zoned/Database/TZdb.ilean +lib/lean/Std/Time/Zoned/Database/TZdb.ir lib/lean/Std/Time/Zoned/Database/TZdb.olean +lib/lean/Std/Time/Zoned/Database/TZdb.olean.private +lib/lean/Std/Time/Zoned/Database/TZdb.olean.server lib/lean/Std/Time/Zoned/Database/TzIf.ilean +lib/lean/Std/Time/Zoned/Database/TzIf.ir lib/lean/Std/Time/Zoned/Database/TzIf.olean +lib/lean/Std/Time/Zoned/Database/TzIf.olean.private +lib/lean/Std/Time/Zoned/Database/TzIf.olean.server lib/lean/Std/Time/Zoned/Database/Windows.ilean +lib/lean/Std/Time/Zoned/Database/Windows.ir lib/lean/Std/Time/Zoned/Database/Windows.olean +lib/lean/Std/Time/Zoned/Database/Windows.olean.private +lib/lean/Std/Time/Zoned/Database/Windows.olean.server lib/lean/Std/Time/Zoned/DateTime.ilean +lib/lean/Std/Time/Zoned/DateTime.ir lib/lean/Std/Time/Zoned/DateTime.olean +lib/lean/Std/Time/Zoned/DateTime.olean.private +lib/lean/Std/Time/Zoned/DateTime.olean.server lib/lean/Std/Time/Zoned/Offset.ilean +lib/lean/Std/Time/Zoned/Offset.ir lib/lean/Std/Time/Zoned/Offset.olean +lib/lean/Std/Time/Zoned/Offset.olean.private +lib/lean/Std/Time/Zoned/Offset.olean.server lib/lean/Std/Time/Zoned/TimeZone.ilean +lib/lean/Std/Time/Zoned/TimeZone.ir lib/lean/Std/Time/Zoned/TimeZone.olean +lib/lean/Std/Time/Zoned/TimeZone.olean.private +lib/lean/Std/Time/Zoned/TimeZone.olean.server lib/lean/Std/Time/Zoned/ZoneRules.ilean +lib/lean/Std/Time/Zoned/ZoneRules.ir lib/lean/Std/Time/Zoned/ZoneRules.olean +lib/lean/Std/Time/Zoned/ZoneRules.olean.private +lib/lean/Std/Time/Zoned/ZoneRules.olean.server lib/lean/Std/Time/Zoned/ZonedDateTime.ilean +lib/lean/Std/Time/Zoned/ZonedDateTime.ir lib/lean/Std/Time/Zoned/ZonedDateTime.olean +lib/lean/Std/Time/Zoned/ZonedDateTime.olean.private +lib/lean/Std/Time/Zoned/ZonedDateTime.olean.server lib/lean/libInit.a lib/lean/libInit_shared.so lib/lean/libLake.a @@ -4862,6 +8744,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/Char.lean %%DATADIR%%/src/lean/Init/Data/Char/Basic.lean %%DATADIR%%/src/lean/Init/Data/Char/Lemmas.lean +%%DATADIR%%/src/lean/Init/Data/Char/Order.lean %%DATADIR%%/src/lean/Init/Data/Fin.lean %%DATADIR%%/src/lean/Init/Data/Fin/Basic.lean %%DATADIR%%/src/lean/Init/Data/Fin/Bitwise.lean @@ -4918,6 +8801,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/Iterators/Consumers/Monadic/Loop.lean %%DATADIR%%/src/lean/Init/Data/Iterators/Consumers/Monadic/Partial.lean %%DATADIR%%/src/lean/Init/Data/Iterators/Consumers/Partial.lean +%%DATADIR%%/src/lean/Init/Data/Iterators/Consumers/Stream.lean %%DATADIR%%/src/lean/Init/Data/Iterators/Internal.lean %%DATADIR%%/src/lean/Init/Data/Iterators/Internal/LawfulMonadLiftFunction.lean %%DATADIR%%/src/lean/Init/Data/Iterators/Internal/Termination.lean @@ -5001,6 +8885,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/Nat/Log2.lean %%DATADIR%%/src/lean/Init/Data/Nat/MinMax.lean %%DATADIR%%/src/lean/Init/Data/Nat/Mod.lean +%%DATADIR%%/src/lean/Init/Data/Nat/Order.lean %%DATADIR%%/src/lean/Init/Data/Nat/Power2.lean %%DATADIR%%/src/lean/Init/Data/Nat/SOM.lean %%DATADIR%%/src/lean/Init/Data/Nat/Simproc.lean @@ -5017,6 +8902,10 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/Option/List.lean %%DATADIR%%/src/lean/Init/Data/Option/Monadic.lean %%DATADIR%%/src/lean/Init/Data/Ord.lean +%%DATADIR%%/src/lean/Init/Data/Order.lean +%%DATADIR%%/src/lean/Init/Data/Order/Classes.lean +%%DATADIR%%/src/lean/Init/Data/Order/Factories.lean +%%DATADIR%%/src/lean/Init/Data/Order/Lemmas.lean %%DATADIR%%/src/lean/Init/Data/PLift.lean %%DATADIR%%/src/lean/Init/Data/Prod.lean %%DATADIR%%/src/lean/Init/Data/Queue.lean @@ -5033,6 +8922,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/Range/Polymorphic/NatLemmas.lean %%DATADIR%%/src/lean/Init/Data/Range/Polymorphic/PRange.lean %%DATADIR%%/src/lean/Init/Data/Range/Polymorphic/RangeIterator.lean +%%DATADIR%%/src/lean/Init/Data/Range/Polymorphic/Stream.lean %%DATADIR%%/src/lean/Init/Data/Range/Polymorphic/UpwardEnumerable.lean %%DATADIR%%/src/lean/Init/Data/Repr.lean %%DATADIR%%/src/lean/Init/Data/SInt.lean @@ -5056,6 +8946,9 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/String/Extra.lean %%DATADIR%%/src/lean/Init/Data/String/Lemmas.lean %%DATADIR%%/src/lean/Init/Data/Subtype.lean +%%DATADIR%%/src/lean/Init/Data/Subtype/Basic.lean +%%DATADIR%%/src/lean/Init/Data/Subtype/Order.lean +%%DATADIR%%/src/lean/Init/Data/Subtype/OrderExtra.lean %%DATADIR%%/src/lean/Init/Data/Sum.lean %%DATADIR%%/src/lean/Init/Data/Sum/Basic.lean %%DATADIR%%/src/lean/Init/Data/Sum/Lemmas.lean @@ -5070,6 +8963,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/Data/UInt/Log2.lean %%DATADIR%%/src/lean/Init/Data/ULift.lean %%DATADIR%%/src/lean/Init/Data/Vector.lean +%%DATADIR%%/src/lean/Init/Data/Vector/Algebra.lean %%DATADIR%%/src/lean/Init/Data/Vector/Attach.lean %%DATADIR%%/src/lean/Init/Data/Vector/Basic.lean %%DATADIR%%/src/lean/Init/Data/Vector/Count.lean @@ -5163,7 +9057,6 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Init/System/FilePath.lean %%DATADIR%%/src/lean/Init/System/IO.lean %%DATADIR%%/src/lean/Init/System/IOError.lean -%%DATADIR%%/src/lean/Init/System/Mutex.lean %%DATADIR%%/src/lean/Init/System/Platform.lean %%DATADIR%%/src/lean/Init/System/Promise.lean %%DATADIR%%/src/lean/Init/System/ST.lean @@ -5183,15 +9076,14 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/BuiltinDocAttr.lean %%DATADIR%%/src/lean/Lean/Class.lean %%DATADIR%%/src/lean/Lean/Compiler.lean -%%DATADIR%%/src/lean/Lean/Compiler/AtMostOnce.lean %%DATADIR%%/src/lean/Lean/Compiler/BorrowedAnnotation.lean %%DATADIR%%/src/lean/Lean/Compiler/CSimpAttr.lean %%DATADIR%%/src/lean/Lean/Compiler/ClosedTermCache.lean -%%DATADIR%%/src/lean/Lean/Compiler/ConstFolding.lean %%DATADIR%%/src/lean/Lean/Compiler/ExportAttr.lean %%DATADIR%%/src/lean/Lean/Compiler/ExternAttr.lean %%DATADIR%%/src/lean/Lean/Compiler/FFI.lean %%DATADIR%%/src/lean/Lean/Compiler/IR.lean +%%DATADIR%%/src/lean/Lean/Compiler/IR/AddExtern.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/Basic.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/Borrow.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/Boxing.lean @@ -5207,6 +9099,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Compiler/IR/FreeVars.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/LLVMBindings.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/LiveVars.lean +%%DATADIR%%/src/lean/Lean/Compiler/IR/Meta.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/NormIds.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/PushProj.lean %%DATADIR%%/src/lean/Lean/Compiler/IR/RC.lean @@ -5284,6 +9177,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Compiler/LCNF/ToMono.lean %%DATADIR%%/src/lean/Lean/Compiler/LCNF/Types.lean %%DATADIR%%/src/lean/Lean/Compiler/LCNF/Util.lean +%%DATADIR%%/src/lean/Lean/Compiler/LCNF/Visibility.lean %%DATADIR%%/src/lean/Lean/Compiler/Main.lean %%DATADIR%%/src/lean/Lean/Compiler/MetaAttr.lean %%DATADIR%%/src/lean/Lean/Compiler/NameMangling.lean @@ -5303,6 +9197,8 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Data/Json/Basic.lean %%DATADIR%%/src/lean/Lean/Data/Json/Elab.lean %%DATADIR%%/src/lean/Lean/Data/Json/FromToJson.lean +%%DATADIR%%/src/lean/Lean/Data/Json/FromToJson/Basic.lean +%%DATADIR%%/src/lean/Lean/Data/Json/FromToJson/Extra.lean %%DATADIR%%/src/lean/Lean/Data/Json/Parser.lean %%DATADIR%%/src/lean/Lean/Data/Json/Printer.lean %%DATADIR%%/src/lean/Lean/Data/Json/Stream.lean @@ -5312,6 +9208,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Data/LOption.lean %%DATADIR%%/src/lean/Lean/Data/Lsp.lean %%DATADIR%%/src/lean/Lean/Data/Lsp/Basic.lean +%%DATADIR%%/src/lean/Lean/Data/Lsp/BasicAux.lean %%DATADIR%%/src/lean/Lean/Data/Lsp/CancelParams.lean %%DATADIR%%/src/lean/Lean/Data/Lsp/Capabilities.lean %%DATADIR%%/src/lean/Lean/Data/Lsp/Client.lean @@ -5329,6 +9226,8 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Data/Lsp/Workspace.lean %%DATADIR%%/src/lean/Lean/Data/Name.lean %%DATADIR%%/src/lean/Lean/Data/NameMap.lean +%%DATADIR%%/src/lean/Lean/Data/NameMap/AdditionalOperations.lean +%%DATADIR%%/src/lean/Lean/Data/NameMap/Basic.lean %%DATADIR%%/src/lean/Lean/Data/NameTrie.lean %%DATADIR%%/src/lean/Lean/Data/OpenDecl.lean %%DATADIR%%/src/lean/Lean/Data/Options.lean @@ -5468,6 +9367,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Elab/RecommendedSpelling.lean %%DATADIR%%/src/lean/Lean/Elab/SetOption.lean %%DATADIR%%/src/lean/Lean/Elab/StructInst.lean +%%DATADIR%%/src/lean/Lean/Elab/StructInstHint.lean %%DATADIR%%/src/lean/Lean/Elab/Structure.lean %%DATADIR%%/src/lean/Lean/Elab/Syntax.lean %%DATADIR%%/src/lean/Lean/Elab/SyntheticMVars.lean @@ -5543,11 +9443,14 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/MGoal.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/Pure.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/Refine.lean +%%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/RenameI.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/Revert.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/ProofMode/Specialize.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/Spec.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/Syntax.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/VCGen.lean +%%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/VCGen/Basic.lean +%%DATADIR%%/src/lean/Lean/Elab/Tactic/Do/VCGen/Split.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/Doc.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/ElabTerm.lean %%DATADIR%%/src/lean/Lean/Elab/Tactic/ExposeNames.lean @@ -5600,9 +9503,14 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/ErrorExplanations/DependsOnNoncomputable.lean %%DATADIR%%/src/lean/Lean/ErrorExplanations/InductiveParamMismatch.lean %%DATADIR%%/src/lean/Lean/ErrorExplanations/InductiveParamMissing.lean +%%DATADIR%%/src/lean/Lean/ErrorExplanations/InferBinderTypeFailed.lean +%%DATADIR%%/src/lean/Lean/ErrorExplanations/InferDefTypeFailed.lean %%DATADIR%%/src/lean/Lean/ErrorExplanations/InvalidDottedIdent.lean +%%DATADIR%%/src/lean/Lean/ErrorExplanations/ProjNonPropFromProp.lean +%%DATADIR%%/src/lean/Lean/ErrorExplanations/PropRecLargeElim.lean %%DATADIR%%/src/lean/Lean/ErrorExplanations/README.md %%DATADIR%%/src/lean/Lean/ErrorExplanations/RedundantMatchAlt.lean +%%DATADIR%%/src/lean/Lean/ErrorExplanations/UnknownIdentifier.lean %%DATADIR%%/src/lean/Lean/Exception.lean %%DATADIR%%/src/lean/Lean/Expr.lean %%DATADIR%%/src/lean/Lean/HeadIndex.lean @@ -5775,6 +9683,8 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.lean +%%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/EvalNum.lean +%%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Insts.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Inv.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Arith/Linear.lean @@ -5831,7 +9741,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Lookahead.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/MBTC.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Main.lean -%%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.lean +%%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/MarkNestedSubsingletons.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/MatchCond.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/PP.lean @@ -5848,6 +9758,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/SimpUtil.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Solve.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Split.lean +%%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/SynthInstance.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Types.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/Grind/Util.lean %%DATADIR%%/src/lean/Lean/Meta/Tactic/IndependentOf.lean @@ -6547,9 +10458,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/lake/Lake/Util/Binder.lean %%DATADIR%%/src/lean/lake/Lake/Util/Casing.lean %%DATADIR%%/src/lean/lake/Lake/Util/Cli.lean -%%DATADIR%%/src/lean/lake/Lake/Util/Compare.lean %%DATADIR%%/src/lean/lake/Lake/Util/Cycle.lean -%%DATADIR%%/src/lean/lake/Lake/Util/DRBMap.lean %%DATADIR%%/src/lean/lake/Lake/Util/Date.lean %%DATADIR%%/src/lean/lake/Lake/Util/EStateT.lean %%DATADIR%%/src/lean/lake/Lake/Util/EquipT.lean @@ -6601,7 +10510,9 @@ share/lean/lean.mk %%DATADIR%%/src/lean/lake/tests/buildArgs/foo.lean %%DATADIR%%/src/lean/lake/tests/buildArgs/lakefile.lean %%DATADIR%%/src/lean/lake/tests/cache/Main.lean +%%DATADIR%%/src/lean/lake/tests/cache/Module.lean %%DATADIR%%/src/lean/lake/tests/cache/Test.lean +%%DATADIR%%/src/lean/lake/tests/cache/Test/Imported.lean %%DATADIR%%/src/lean/lake/tests/clone/test/Main.lean %%DATADIR%%/src/lean/lake/tests/clone/test/lakefile.lean %%DATADIR%%/src/lean/lake/tests/driver/Test.lean @@ -6635,6 +10546,7 @@ share/lean/lean.mk %%DATADIR%%/src/lean/lake/tests/kinds/lakefile.lean %%DATADIR%%/src/lean/lake/tests/lean/Lib.lean %%DATADIR%%/src/lean/lake/tests/lean/Lib/Basic.lean +%%DATADIR%%/src/lean/lake/tests/lean/Lib/Foo.Bar.lean %%DATADIR%%/src/lean/lake/tests/lean/Test.lean %%DATADIR%%/src/lean/lake/tests/lean/lakefile.lean %%DATADIR%%/src/lean/lake/tests/llvm-bitcode-gen/LlvmBitcodeGen.lean @@ -6654,6 +10566,25 @@ share/lean/lean.mk %%DATADIR%%/src/lean/lake/tests/manifest/foo/lakefile.lean %%DATADIR%%/src/lean/lake/tests/manifest/lakefile.lean %%DATADIR%%/src/lean/lake/tests/meta/lakefile.lean +%%DATADIR%%/src/lean/lake/tests/module/ErrorTest/CrossPackageImportAll.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/Import.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportAll.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportAllImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportAllImportAll.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportAllMetaImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportImportAll.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportMetaImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/ImportPublicMetaImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/MetaImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/MetaImportPublicImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/PromoteImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/PromoteTransImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/PublicImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/Module/PublicMetaImport.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/NonModule/Import.lean +%%DATADIR%%/src/lean/lake/tests/module/Test/NonModule/ImportModuleImport.lean +%%DATADIR%%/src/lean/lake/tests/module/dep/Dep/Module.lean %%DATADIR%%/src/lean/lake/tests/noBuild/ImportTest.lean %%DATADIR%%/src/lean/lake/tests/noBuild/Test.lean %%DATADIR%%/src/lean/lake/tests/noBuild/lakefile.lean @@ -6709,7 +10640,9 @@ share/lean/lean.mk %%DATADIR%%/src/lean/lake/tests/reversion/Main.lean %%DATADIR%%/src/lean/lake/tests/reversion/lakefile.lean %%DATADIR%%/src/lean/lake/tests/setupFile/ImportFoo.lean +%%DATADIR%%/src/lean/lake/tests/setupFile/ImportTest.lean %%DATADIR%%/src/lean/lake/tests/setupFile/Test.lean +%%DATADIR%%/src/lean/lake/tests/setupFile/Test/Foo.Bar.lean %%DATADIR%%/src/lean/lake/tests/setupFile/invalid.lean %%DATADIR%%/src/lean/lake/tests/toml/README.md %%DATADIR%%/src/lean/lake/tests/toml/Test.lean diff --git a/math/libbraiding/pkg-descr b/math/libbraiding/pkg-descr index 9ebe3e74d4cd..db445dce1c0c 100644 --- a/math/libbraiding/pkg-descr +++ b/math/libbraiding/pkg-descr @@ -1,7 +1,22 @@ -This is a project to expose the functionalitis of the Braiding program as a -shared library. The original goal is to include it as a component of SageMath, -but it can be used in any other c++ program. +libbraiding is a C++ shared library that exposes the functionalities +of the Braiding program, a tool for computations within braid groups. +Braid groups are fundamental mathematical objects in topology and algebra, +used to describe the intertwining of strands. -It allows various computations on braid groups, such as normal forms. +This library provides a robust and efficient framework for performing +various computations on braid groups, including: -See also: https://github.com/miguelmarco/libbraiding +- **Normal Forms**: Calculating canonical representations of braids, + essential for comparison and analysis. +- **Other Computations**: Facilitating a range of algebraic operations + and manipulations within braid groups. + +While initially conceived for integration as a component of SageMath, +a comprehensive open-source mathematics software system, libbraiding +is designed to be a standalone library. This allows any C++ program +to leverage its powerful capabilities for braid group computations. + +libbraiding is an invaluable resource for mathematicians, computer +scientists, and researchers working in topology, group theory, and +related fields, offering a flexible and high-performance solution +for exploring the intricate world of braids. diff --git a/math/libhomfly/pkg-descr b/math/libhomfly/pkg-descr index 346e677d7a2d..968289414460 100644 --- a/math/libhomfly/pkg-descr +++ b/math/libhomfly/pkg-descr @@ -1,6 +1,21 @@ -Library to compute the homfly polynomial of a link +libhomfly is a specialized C library designed to compute the HOMFLY +polynomial of a link. The HOMFLY polynomial is a powerful invariant +in knot theory, used to distinguish different knots and links, providing +crucial information about their topological properties. -This is basically a conversion of the program written by Robert J Jenkins Jr -into a shared library. It accepts as entry a character string, formatted in the -same way as the input files that the original code used. The returned value is -the string that the original program would print on screen. +This library is a robust conversion of the original program by +Robert J. Jenkins Jr., refactored into a shared library for broader +applicability and ease of integration. It offers a straightforward +interface: + +- **Input**: Accepts a character string formatted identically to the + input files used by the original standalone program, representing + the link's structure. +- **Output**: Returns a string containing the computed HOMFLY polynomial, + mirroring the output format of the original utility. + +libhomfly is an invaluable resource for mathematicians, researchers, +and developers working in knot theory, topology, and related fields. +It provides a reliable and efficient computational engine for analyzing +the complex structures of knots and links, enabling further research +and application development. diff --git a/math/libocas/pkg-descr b/math/libocas/pkg-descr index 3647dd5e18da..f5a6f5cfb723 100644 --- a/math/libocas/pkg-descr +++ b/math/libocas/pkg-descr @@ -1,8 +1,21 @@ -libocas implements an Optimized Cutting Plane Algorithm (OCAS) for training -linear SVM classifiers from large-scale data. The computational effort of -OCAS scales with O(m log m) where m is the sample size. In an extensive -empirical evaluation, OCAS significantly outperforms current state-of-the-art -SVM solvers. +libocas implements the Optimized Cutting Plane Algorithm (OCAS), a +highly efficient method for training linear Support Vector Machine (SVM) +classifiers on large-scale datasets. SVMs are powerful supervised +learning models used for classification and regression analysis. -libocas also implements the COFFIN framework for efficient training of -translation invariant image classifiers from virtual examples. +OCAS is specifically designed to handle big data, offering exceptional +computational efficiency that scales with O(m log m), where 'm' is the +sample size. Empirical evaluations demonstrate that OCAS significantly +outperforms many current state-of-the-art SVM solvers, making it ideal +for applications requiring fast and accurate classification. + +Beyond core SVM training, libocas also includes the COFFIN framework, +which enables efficient training of translation-invariant image classifiers +from virtual examples. This feature is particularly useful for computer +vision tasks where robust image classification is needed, even with +limited real-world training data. + +libocas is an invaluable library for machine learning practitioners, +data scientists, and researchers who need high-performance tools for +large-scale classification problems, especially in areas like image +recognition and pattern detection. diff --git a/math/libranlip/pkg-descr b/math/libranlip/pkg-descr index 3e104d52d64a..2f475a42f002 100644 --- a/math/libranlip/pkg-descr +++ b/math/libranlip/pkg-descr @@ -1,5 +1,17 @@ -libranlip is a C++ library created by G. Beliakov, which generates random -variates with arbitrary Lipschitz-continuous densities via the acceptance / -rejection method. The density should have a dimension of no more than about -five. The user needs to supply the density function using a simple syntax, and -then call the methods of construction and generation provided in libranlip. +libranlip is a C++ library by G. Beliakov for generating random variates +from distributions with arbitrary Lipschitz-continuous densities. It +produces random numbers following smooth probability distributions, +essential for advanced simulations and statistical modeling. + +The library uses the efficient acceptance/rejection method for sampling, +effective for densities up to approximately five dimensions. Users provide +their desired density function via a simple syntax. + +libranlip is invaluable for researchers and developers in: + +- **Monte Carlo simulations**: For complex systems. +- **Statistical inference**: Generating samples for Bayesian methods. +- **Numerical analysis**: Exploring probability distributions. + +It offers a flexible and powerful solution for high-fidelity random +number generation in C++ applications. diff --git a/math/linpack/pkg-descr b/math/linpack/pkg-descr index 29253078121f..da6d1ea6ad84 100644 --- a/math/linpack/pkg-descr +++ b/math/linpack/pkg-descr @@ -1,4 +1,20 @@ -Developed by Jack Dongarra, Jim Bunch, Cleve Moler and Pete Stewart. - 1 Feb 84 -Used as part of Matlab, and often used to benchmark machines. -Otherwise it is a very good linear algebra package. +LINPACK is a foundational software library for performing numerical +linear algebra. Developed by a distinguished team including Jack Dongarra, +Jim Bunch, Cleve Moler, and Pete Stewart, it was released on February 1, 1984. + +Despite its age, LINPACK remains highly significant in the field of +high-performance computing. It provides a robust collection of Fortran +subroutines for solving common problems in linear algebra, such as: + +- Solving systems of linear equations +- Least squares solutions +- Eigenvalue problems +- Matrix factorization (e.g., LU, Cholesky, QR) + +Historically, LINPACK has been a cornerstone for benchmarking the +performance of supercomputers (via the LINPACK Benchmark). It also +formed a critical component of early numerical software environments, +including MATLAB. While more modern libraries exist, LINPACK's +algorithms are still widely respected for their accuracy and efficiency, +making it a valuable resource for understanding and implementing core +linear algebra operations. diff --git a/math/lll_spect/pkg-descr b/math/lll_spect/pkg-descr index 288be09eac13..cc8a319fb3d0 100644 --- a/math/lll_spect/pkg-descr +++ b/math/lll_spect/pkg-descr @@ -1,6 +1,21 @@ -This software calculates a normalized version of the classical spectral test for -linear congruential pseudorandom number generators (LCGs), where the shortest -vector is replaced by an approximation obtained with the Lenstra-Lenstra-Lovasz -basis reduction algorithm, which can be calculated in polynomial time. The code -is able to test in up to 24 dimensions, and includes an example of how to use -the test to search for good LCG parameters. +lll_spect evaluates Linear Congruential Pseudorandom Number Generators +(LCGs) using a normalized spectral test. This test measures an LCG's +statistical randomness. + +It employs the Lenstra-Lenstra-Lovasz (LLL) basis reduction algorithm +to approximate the shortest vector, enabling efficient calculation in +polynomial time. This makes the spectral test practical for higher +dimensions. + +Key features: + +- **LCG Quality Assessment**: Robust method for LCG statistical + properties. +- **High-Dimensional Testing**: Tests up to 24 dimensions for modern + simulations. +- **Parameter Optimization**: Includes examples for finding optimal + LCG parameters. + +lll_spect is invaluable for researchers and developers working with PRNGs, +helping select and validate LCGs for applications requiring strong +statistical properties. diff --git a/math/lrng/pkg-descr b/math/lrng/pkg-descr index 1cef25662d44..154a3176a74d 100644 --- a/math/lrng/pkg-descr +++ b/math/lrng/pkg-descr @@ -1,3 +1,9 @@ -lrng is a collection of uniform pseudorandom number -generators, written in C, and based on algorithms by Francois -Panneton, Pierre L'Ecuyer, and Makoto Matsumoto. +LRNG (Lightweight Random Number Generator) is a comprehensive collection of +high-quality, uniform pseudorandom number generators (PRNGs). Implemented in C, +LRNG is built upon robust algorithms developed by prominent researchers +Francois Panneton, Pierre L'Ecuyer, and Makoto Matsumoto. + +This library provides a reliable and efficient solution for applications +requiring statistically sound random numbers, such as simulations, +cryptography, and scientific computing. Its lightweight nature makes it +suitable for integration into various projects without significant overhead. diff --git a/math/m4ri/pkg-descr b/math/m4ri/pkg-descr index 066f20310840..523688e9107f 100644 --- a/math/m4ri/pkg-descr +++ b/math/m4ri/pkg-descr @@ -1,5 +1,24 @@ -M4RI is a library for fast arithmetic with dense matrices over F2. The name M4RI -comes from the first implemented algorithm: The "Method of the Four Russians" -inversion algorithm published by Gregory Bard. This algorithm in turn is named -after the "Method of the Four Russians" multiplication algorithm which is -probably better referred to as Kronrod's method. +M4RI is a high-performance library designed for rapid arithmetic operations +with dense matrices over the finite field F2 (GF(2)). F2, the field with +two elements (0 and 1), is fundamental in areas like coding theory, +cryptography, and computational algebra. + +The library's name, M4RI, originates from its core implementation of the +"Method of the Four Russians" inversion algorithm, a technique published +by Gregory Bard. This algorithm, inspired by Kronrod's multiplication +method, provides significant speedups for matrix operations over F2. + +M4RI offers optimized routines for various matrix manipulations, including: + +- **Multiplication**: Efficiently computes products of dense matrices. +- **Inversion**: Fast calculation of matrix inverses. +- **Gaussian Elimination**: Solves systems of linear equations. + +This makes M4RI an invaluable tool for: + +- **Error-correcting codes**: Implementing and analyzing binary codes. +- **Cryptography**: Developing and testing algorithms based on binary fields. +- **Computational Algebra**: Solving problems in linear algebra over F2. + +M4RI provides researchers and developers with a powerful and efficient +solution for numerical computations in specialized algebraic structures. diff --git a/math/m4rie/pkg-descr b/math/m4rie/pkg-descr index 1ad7f9e56440..b20784e6debb 100644 --- a/math/m4rie/pkg-descr +++ b/math/m4rie/pkg-descr @@ -1,4 +1,21 @@ -M4RIE is a library for fast arithmetic with dense matrices over GF(2^e) for -2<=e<=16. The name stems from the fact that is relies heavily on M4RI. +M4RIE is a high-performance library dedicated to fast arithmetic operations +with dense matrices over finite fields of the form GF(2^e), where 'e' +ranges from 2 to 16. Finite fields, also known as Galois fields, are +fundamental in areas like coding theory, cryptography, and computational +algebra. -See also: https://github.com/malb/m4rie +Building upon the capabilities of the M4RI library, M4RIE extends its +functionality to support these larger finite fields, providing optimized +routines for matrix manipulations such as multiplication, inversion, +and Gaussian elimination. This makes it an invaluable tool for: + +- **Error-correcting codes**: Designing and implementing robust codes + for data transmission and storage. +- **Cryptography**: Developing and analyzing cryptographic algorithms + that rely on finite field arithmetic. +- **Computational Algebra**: Solving systems of linear equations and + performing other algebraic computations over specific finite fields. + +M4RIE offers researchers and developers a powerful and efficient solution +for numerical computations in specialized algebraic structures, crucial +for various advanced scientific and engineering applications. diff --git a/math/math77/pkg-descr b/math/math77/pkg-descr index 0713b02ab1ac..fed52e2276fe 100644 --- a/math/math77/pkg-descr +++ b/math/math77/pkg-descr @@ -1,2 +1,17 @@ -Mathematical subprogram libraries for Fortran 77. -Created by CalTech. +MATH77 provides a foundational collection of mathematical subprogram +libraries specifically designed for use with Fortran 77. Developed by +CalTech, these libraries offer a robust and historically significant +suite of routines for various numerical computations. + +Fortran 77 has been a cornerstone of scientific and engineering computing +for decades, and MATH77 complements this by offering optimized and +reliable implementations of common mathematical operations. These +subprograms typically cover areas such as: + +- Linear algebra (e.g., matrix operations, solving linear systems) +- Numerical analysis (e.g., root finding, integration, differentiation) +- Special functions (e.g., Bessel functions, error functions) + +This package is particularly valuable for maintaining and developing +applications that rely on established Fortran 77 codebases, ensuring +accuracy and performance in numerical tasks. diff --git a/math/mbasecalc/pkg-descr b/math/mbasecalc/pkg-descr index d8d60adacc17..0fbae66b4b05 100644 --- a/math/mbasecalc/pkg-descr +++ b/math/mbasecalc/pkg-descr @@ -1,3 +1,15 @@ -basecalc came with Xlib Programming Manual from O'Reilly as an -example of X lib programming. mbasecalc is an immitation of basecalc -which is available on different platforms. +mbasecalc is a versatile base calculator, inspired by the original +'basecalc' example from the Xlib Programming Manual by O'Reilly. +It provides a convenient tool for performing arithmetic operations +and conversions across different numerical bases. + +Unlike its predecessor, mbasecalc is designed to be cross-platform, +making it accessible and functional on various operating systems +and environments. Users can effortlessly switch between common bases +such as binary, octal, decimal, and hexadecimal, facilitating tasks +involving low-level programming, network protocols, or digital logic. + +This utility is particularly useful for developers, students, and +anyone who frequently needs to work with numbers in different bases, +offering a straightforward and efficient solution for base conversions +and calculations. diff --git a/math/minorminer/Makefile b/math/minorminer/Makefile index 33c5a146e73b..0777a36fd02b 100644 --- a/math/minorminer/Makefile +++ b/math/minorminer/Makefile @@ -1,5 +1,5 @@ PORTNAME= minorminer -DISTVERSION= 0.2.16 +DISTVERSION= 0.2.19 CATEGORIES= math MAINTAINER= yuri@FreeBSD.org @@ -26,4 +26,6 @@ do-install: # workaround for https://github.com/dwavesystems/minorminer/issues/2 post-test: @cd ${BUILD_WRKSRC}/tests && ./run_tests +# tests as of 0.2.19: 34 tests from 4 test suites ran. (5 ms total) + .include <bsd.port.mk> diff --git a/math/minorminer/distinfo b/math/minorminer/distinfo index 89c27dfb3055..219afc25b2fc 100644 --- a/math/minorminer/distinfo +++ b/math/minorminer/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1731038646 -SHA256 (dwavesystems-minorminer-0.2.16_GH0.tar.gz) = 0945862971d6d5e37b5cdb91950758843d919e898d7e62259c9049ee13dcca74 -SIZE (dwavesystems-minorminer-0.2.16_GH0.tar.gz) = 1281256 +TIMESTAMP = 1758997399 +SHA256 (dwavesystems-minorminer-0.2.19_GH0.tar.gz) = f4207bed0a74bbe89fd5a1d8657bc611106a67ac733aa034877d27f306afdf6a +SIZE (dwavesystems-minorminer-0.2.19_GH0.tar.gz) = 1290750 diff --git a/math/miracl/pkg-descr b/math/miracl/pkg-descr index 390b1d04931a..3e94ad7657de 100644 --- a/math/miracl/pkg-descr +++ b/math/miracl/pkg-descr @@ -1,16 +1,21 @@ -[ excerpt from developer's web site ] +MIRACL (Multiprecision Integer and Rational Arithmetic C/C++ Library) +is a powerful Big Number Library for implementing cryptographic systems. +It provides primitives for integrating advanced number-theoretic +cryptography into real-world applications. -MIRACL is a Big Number Library which implements all of the primitives -necessary to design Big Number Cryptography into your real-world -application. It is primarily a tool for cryptographic system -implementors. RSA public key cryptography, Diffie-Hellman Key -exchange, DSA digital signature, they are all just a few procedure -calls away. Support is also included for even more esoteric Elliptic -Curves and Lucas function based schemes. The latest version offers -full support for Elliptic Curve Cryptography over GF(p) and GF(2m). -Less well-known techniques can also be implemented as MIRACL allows -you to work directly and efficiently with the big numbers that are -the building blocks of number-theoretic cryptography. Although -implemented as a C library, a well-thought out C++ wrapper is -provided, which greatly simplifies program development. Most example -programs (25+ of them) are provided in both C and C++ versions. +Primarily a tool for cryptographic system implementers, MIRACL offers +robust support for: + +- **Public Key Cryptography**: RSA, Diffie-Hellman Key Exchange, DSA. +- **Elliptic Curve Cryptography (ECC)**: Full support over GF(p) + and GF(2m), including esoteric ECC schemes. +- **Lucas Function Based Schemes**: Support for less common techniques. + +MIRACL enables efficient work with large numbers foundational to modern +cryptography. It's a C library with a C++ wrapper that simplifies +program development, with examples in both languages. + +This library is invaluable for security researchers, cryptographers, +and developers building secure communication protocols, digital +signature systems, and other applications requiring high-assurance +cryptographic primitives. diff --git a/math/mtrxmath/pkg-descr b/math/mtrxmath/pkg-descr index 3880b306adb9..938dc6919807 100644 --- a/math/mtrxmath/pkg-descr +++ b/math/mtrxmath/pkg-descr @@ -1,4 +1,20 @@ -Matrix Math is software to quickly and easily compute functions of -matrices of any size. It supports addition, subtraction, -multiplication, inversion, division, and will support whatever else is -necessary. +Matrix Math (mtrxmath) is a dedicated software tool designed for the +rapid and straightforward computation of various matrix functions and +operations. It provides a user-friendly environment for manipulating +matrices of arbitrary size, making complex linear algebra tasks +accessible and efficient. + +Key functionalities include: + +- **Fundamental Operations**: Addition, subtraction, and multiplication + of matrices. +- **Advanced Operations**: Matrix inversion and division, crucial for + solving systems of linear equations and other analytical tasks. +- **Extensibility**: Designed to support a comprehensive and growing + suite of matrix operations, adapting to diverse mathematical needs. + +Mtrxmath is an invaluable resource for students, engineers, scientists, +and anyone requiring quick and accurate matrix calculations. It +streamlines the process of working with linear systems, data transformations, +and other matrix-dependent computations, offering a reliable and efficient +solution for numerical analysis. diff --git a/math/mumps4/pkg-descr b/math/mumps4/pkg-descr index 3e06b7e0a5c3..d1f92de0a118 100644 --- a/math/mumps4/pkg-descr +++ b/math/mumps4/pkg-descr @@ -1,16 +1,22 @@ -MUMPS is a Distributed Multifrontal Solver (F90, MPI based) with Dynamic -Distributed Scheduling to accomodate both numerical fill-in and multi-user -environment. +MUMPS (MUltifrontal Massively Parallel sparse direct Solver) is a +Fortran 90 and MPI-based software package for efficiently solving +large sparse linear systems. It uses dynamic distributed scheduling +to handle numerical fill-in and multi-user environments. -- Solution of large linear systems with symmetric positive definite -matrices; general symmetric matrices; general unsymmetric matrices. -- Version for complex arithmetic. -- Parallel factorization and solve phases (uniprocessor version also -available). -- Iterative refinement and backward error analysis. -- Various matrix input formats: assembled format; distributed assembled -format; elemental format. -- Partial factorization and Schur complement matrix. -- Several orderings interfaced : AMD, AMF, PORD +Key capabilities: -Note: This is the last version released under Public Domain. +- **Solution of Large Linear Systems**: Supports symmetric positive + definite, general symmetric, and general unsymmetric matrices. +- **Complex Arithmetic**: Version available for complex computations. +- **Parallel/Uniprocessor Modes**: Offers both parallel (MPI) and + uniprocessor factorization and solve phases. +- **Enhanced Accuracy**: Includes iterative refinement and backward + error analysis. +- **Flexible Matrix Input**: Supports assembled, distributed assembled, + and elemental formats. +- **Advanced Features**: Partial factorization, Schur complement matrix. +- **Integrated Orderings**: Interfaces with AMD, AMF, and PORD. + +This Public Domain version of MUMPS is invaluable for researchers and +engineers in scientific computing and finite element analysis, requiring +high-performance sparse direct solvers. diff --git a/math/nfft/pkg-descr b/math/nfft/pkg-descr index 5b23f6420926..48a1939d323f 100644 --- a/math/nfft/pkg-descr +++ b/math/nfft/pkg-descr @@ -1,16 +1,23 @@ -NFFT is a software library, written in C, for computing non-equispaced fast -Fourier transforms and related variations. It implements the following -transforms: +NFFT is a C software library for computing Non-Equispaced Fast Fourier +Transforms (NFFT) and their various generalizations. It provides efficient +algorithms for scenarios where data points are not uniformly spaced, +a common occurrence in many scientific and engineering applications. -1. Non-equispaced fast Fourier transform (NFFT) - - forward transform (NFFT), i.e. frequency to time/space domain - - adjoint transform (adjoint NFFT), i.e. time/space to frequency domain +The library implements a comprehensive set of transforms, including: -2. Generalisations - - to arbitrary nodes in time and frequency domain (NNFFT) - - to real-valued data, i.e. (co)sine transforms, (NFCT, NFST) - - to the sphere S^2 (NFSFT) - - to the rotation group (NFSOFT) - - to the hyperbolic cross (NSFFT) -3. Generalised inverse transformations based on iterative methods, e.g. - CGNR/CGNE +- **Non-Equispaced Fast Fourier Transform (NFFT)**: + - Forward transform (frequency to time/space domain). + - Adjoint transform (time/space to frequency domain). +- **Generalizations**: + - NNFFT: For arbitrary nodes in both time and frequency domains. + - NFCT, NFST: Real-valued data, including (co)sine transforms. + - NFSFT: Transforms on the sphere S^2. + - NFSOFT: Transforms on the rotation group. + - NSFFT: Transforms on the hyperbolic cross. +- **Generalized Inverse Transformations**: Based on iterative methods + like CGNR/CGNE. + +NFFT is an invaluable tool for researchers and developers in fields +such as medical imaging, radio astronomy, geophysics, and signal +processing, where non-uniform sampling is prevalent and efficient +Fourier analysis is critical. diff --git a/math/ngraph/pkg-descr b/math/ngraph/pkg-descr index 72cb3b16d174..37125e44a9d4 100644 --- a/math/ngraph/pkg-descr +++ b/math/ngraph/pkg-descr @@ -1,30 +1,19 @@ -Ngraph is prepared to plot 2-dimensional graph for students, -scientists and engineers. The program reads numerical data from -general ASCII text files, and plot to graph. +Ngraph is a versatile 2D plotting tool designed for students, scientists, +and engineers. It specializes in visualizing numerical data read from +general ASCII text files, providing a straightforward way to generate +graphs for analysis and presentation. -** Tips ** +Key features include: - - This program support Kanji font. If you want to use it, - please set environment variable LANG to ja_JP.EUC. +- **Data Visualization**: Creates 2-dimensional plots from numerical + data stored in ASCII text files. +- **User-Friendly Interface**: Designed for ease of use, catering to + users in scientific and engineering disciplines. +- **Kanji Font Support**: (Optional) Supports Kanji fonts for Japanese + language display, configurable via environment variables and specific + font installations (e.g., `ja-ngraph-fonts`, `ja-kanji18`, `ja-kanji26`). + Users can also customize font settings in `Ngraph.ini`. - (cf, under csh/tcsh) - % setenv LANG ja_JP.EUC - - and you need.... - - kinput2 - - X True Type or X True Type Font server[best], - or kanji18 and kanji26 fonts, these fonts are in below ports[better], - - ja-ngraph-fonts (japanese/ngraph-fonts) - - ja-kanji18 (japanese/kanji18) - - ja-kanji26 (japanese/kanji26) - or to change font name in Ngraph.ini as below[poor]. - -font_map=Mincho,1,-*-fixed-medium-r-normal--*-*-75-75-c-*-jisx0208.1983-0 -font_map=Gothic,1,-*-fixed-medium-r-normal--*-*-75-75-c-*-jisx0208.1983-0 - - - You can get documentation in Japanese from below URL. - -** Acknowledgements to this ports file ** - Special thanks to: - Satoshi Ishizaka <isizaka@msa.biglobe.ne.jp> - Nobuhiro Yasutomi <nobu@rd.isac.co.jp> +Ngraph provides a practical and accessible solution for generating +scientific plots, making it a valuable utility for data analysis and +graphical representation of experimental or simulated results. diff --git a/math/numdiff/pkg-descr b/math/numdiff/pkg-descr index 1a99d16b3f93..95dfd74060da 100644 --- a/math/numdiff/pkg-descr +++ b/math/numdiff/pkg-descr @@ -1,8 +1,21 @@ -Numdiff is a little program that can be used to compare putatively -similar files line by line and field by field, ignoring small numeric -differences or/and different numeric formats. +Numdiff is a specialized command-line utility designed for intelligent +comparison of files containing numerical data. Unlike standard `diff` +tools, Numdiff excels at identifying semantic differences between files +by intelligently handling numerical variations and formatting discrepancies. -Equivalently, Numdiff is a program with the capability to appropriately -compare files containing numerical fields (and not only). +Its core functionality allows users to compare putatively similar files +line by line and field by field, with key features including: -% numdiff file1 file2 +- **Tolerance for Numeric Differences**: Ignores small numerical + variations, focusing on significant changes. +- **Format Agnostic Comparison**: Accommodates different numerical + formats (e.g., scientific notation, varying precision), ensuring + accurate comparisons regardless of presentation. +- **Mixed Content Handling**: Capable of comparing files that contain + both numerical fields and other types of data. + +Numdiff is an invaluable tool for scientists, engineers, and developers +who frequently work with simulation outputs, experimental data, or +configuration files where minor numerical fluctuations or formatting +differences should not be flagged as significant changes. It streamlines +the process of verifying data integrity and tracking meaningful updates. diff --git a/math/ocamlgsl/pkg-descr b/math/ocamlgsl/pkg-descr index f75b59966238..157319abbd30 100644 --- a/math/ocamlgsl/pkg-descr +++ b/math/ocamlgsl/pkg-descr @@ -1,2 +1,22 @@ -ocamlgsl is an interface to GSL (GNU scientific library), for the -Objective Caml langage. +OCamlGSL provides a robust and comprehensive interface to the GNU +Scientific Library (GSL) for the Objective Caml (OCaml) programming +language. The GSL is a vast collection of numerical routines for +scientific computing, offering a wide range of mathematical functions +and algorithms. + +By bridging OCaml with GSL, OCamlGSL empowers OCaml developers to +leverage high-performance, well-tested numerical capabilities directly +within their functional programming environment. This integration is +particularly beneficial for applications requiring: + +- **Numerical Analysis**: Solving differential equations, integration, + differentiation, root finding. +- **Linear Algebra**: Matrix operations, eigenvalue problems, linear systems. +- **Statistics**: Random number generation, probability distributions, + statistical tests. +- **Special Functions**: Bessel functions, Gamma functions, error functions. +- **Optimization**: Minimization and maximization algorithms. + +OCamlGSL allows OCaml programmers to perform complex scientific and +mathematical computations with the efficiency and reliability of GSL, +while retaining the expressiveness and safety features of OCaml. diff --git a/math/octave-forge-datatypes/Makefile b/math/octave-forge-datatypes/Makefile index 88680220a89d..90333448a04f 100644 --- a/math/octave-forge-datatypes/Makefile +++ b/math/octave-forge-datatypes/Makefile @@ -1,6 +1,6 @@ PORTNAME= octave-forge-datatypes DISTVERSIONPREFIX= release- -DISTVERSION= 1.0.7 +DISTVERSION= 1.0.8 PORTEPOCH= 1 CATEGORIES= math diff --git a/math/octave-forge-datatypes/distinfo b/math/octave-forge-datatypes/distinfo index 9bf754b94c55..82aeea7faae7 100644 --- a/math/octave-forge-datatypes/distinfo +++ b/math/octave-forge-datatypes/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1753473679 -SHA256 (octave-forge/pr0m1th3as-datatypes-release-1.0.7_GH0.tar.gz) = b9c60ef0c51b4aff2f032d385d7d6797ee948e5ff29e934b178952f97b83d113 -SIZE (octave-forge/pr0m1th3as-datatypes-release-1.0.7_GH0.tar.gz) = 300497 +TIMESTAMP = 1758834882 +SHA256 (octave-forge/pr0m1th3as-datatypes-release-1.0.8_GH0.tar.gz) = 9713acb33fcdb3f5c7870dbf2c3b1ecb361507a4e6cd4668af3078fff7807263 +SIZE (octave-forge/pr0m1th3as-datatypes-release-1.0.8_GH0.tar.gz) = 298765 diff --git a/math/octave-forge-pkg-octave-doc/Makefile b/math/octave-forge-pkg-octave-doc/Makefile index 94ab6b4d858c..4f1c9946b462 100644 --- a/math/octave-forge-pkg-octave-doc/Makefile +++ b/math/octave-forge-pkg-octave-doc/Makefile @@ -1,6 +1,6 @@ PORTNAME= octave-forge-pkg-octave-doc DISTVERSIONPREFIX= release- -DISTVERSION= 0.6.4 +DISTVERSION= 0.6.5 CATEGORIES= math MAINTAINER= stephen@FreeBSD.org diff --git a/math/octave-forge-pkg-octave-doc/distinfo b/math/octave-forge-pkg-octave-doc/distinfo index 0b67f2f9b6b0..8443b9d5e5c0 100644 --- a/math/octave-forge-pkg-octave-doc/distinfo +++ b/math/octave-forge-pkg-octave-doc/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1754614694 -SHA256 (octave-forge/gnu-octave-pkg-octave-doc-release-0.6.4_GH0.tar.gz) = 6f13b269610cb21be00919e552300aed549afd1d457589a0bf3996aba12ab536 -SIZE (octave-forge/gnu-octave-pkg-octave-doc-release-0.6.4_GH0.tar.gz) = 161147 +TIMESTAMP = 1758909544 +SHA256 (octave-forge/gnu-octave-pkg-octave-doc-release-0.6.5_GH0.tar.gz) = 653641995044ae810372cebe00ca0683a7710d26eceb0d1a91f3b08d8bed5a81 +SIZE (octave-forge/gnu-octave-pkg-octave-doc-release-0.6.5_GH0.tar.gz) = 161205 diff --git a/math/physcalc/pkg-descr b/math/physcalc/pkg-descr index de80c9e4e23a..250a1ceeaa36 100644 --- a/math/physcalc/pkg-descr +++ b/math/physcalc/pkg-descr @@ -1,4 +1,21 @@ -Physcalc is a neat mathematical calculator that does conversions -from many different units in many forms, and is extremely flexible -as far as specifying math problems go. You can also add your own -types of conversions. +Physcalc is an exceptionally flexible and powerful mathematical calculator +designed for a wide range of scientific and engineering computations. +Its primary strength lies in its extensive unit conversion capabilities +and highly adaptable problem-solving interface. + +Key features include: + +- **Comprehensive Unit Conversions**: Seamlessly convert between numerous + units across various domains, such as length, mass, time, temperature, + energy, and more. +- **Flexible Math Problem Specification**: Allows users to input and + solve mathematical problems with remarkable versatility, accommodating + complex expressions and scientific notation. +- **User-Extensible Conversions**: Empowering users to define and add + their own custom unit conversions, tailoring the calculator to specific + needs and specialized fields. + +Physcalc is an invaluable tool for physicists, engineers, students, and +anyone who frequently deals with unit conversions and intricate mathematical +problems. It streamlines calculations and enhances productivity by providing +a highly customizable and efficient computational environment. diff --git a/math/plplot/pkg-descr b/math/plplot/pkg-descr index 894b1fad6833..e91b127997ae 100644 --- a/math/plplot/pkg-descr +++ b/math/plplot/pkg-descr @@ -1,13 +1,24 @@ -PLplot is a library of C functions that are useful for making scientific -plots from a program written in C, C++, or Fortran. The PLplot library -can be used to create standard x-y plots, semilog plots, log-log plots, -contour plots, 3D plots, mesh plots, bar charts and pie charts. Multiple -graphs (of the same or different sizes) may be placed on a single page -with multiple lines in each graph. Different line styles, widths and -colors are supported. A virtually infinite number of distinct area fill -patterns may be used. There are almost 1000 characters in the extended -character set. This includes four different fonts, the Greek alphabet and -a host of mathematical, musical, and other symbols. The fonts can be -scaled to any desired size. A variety of output devices are supported and -new devices can be easily added by writing a small number of device -dependent routines. +PLplot is a powerful and versatile library of C functions designed for +generating high-quality scientific plots from programs written in C, +C++, or Fortran. It provides a comprehensive set of tools for visualizing +data across various scientific and engineering disciplines. + +Key plotting capabilities include: + +- **Diverse Plot Types**: Supports standard x-y plots, semilog plots, + log-log plots, contour plots, 3D plots, mesh plots, bar charts, and + pie charts. +- **Multi-Graph Layouts**: Allows multiple graphs (of varying sizes) + on a single page, with multiple lines per graph. +- **Extensive Customization**: Offers different line styles, widths, + and colors. Features a virtually infinite number of distinct area + fill patterns. +- **Rich Character Set**: Includes an extended character set with four + fonts, the Greek alphabet, and a wide array of mathematical, musical, + and other symbols. Fonts are scalable to any desired size. +- **Device Agnostic Output**: Supports a variety of output devices, + with an extensible architecture for easily adding new device drivers. + +PLplot is an invaluable resource for scientists, engineers, and researchers +who need to create precise, customizable, and visually appealing plots +directly from their numerical applications. diff --git a/math/primegen/pkg-descr b/math/primegen/pkg-descr index 9cc1d855552d..20a649df779b 100644 --- a/math/primegen/pkg-descr +++ b/math/primegen/pkg-descr @@ -1,7 +1,23 @@ -primegen is a small, fast library to generate prime numbers in order. -It generates the 50847534 primes up to 1000000000 in just 8 seconds -on a Pentium II-350; it prints them in decimal in just 35 seconds. +primegen is a highly optimized and fast library designed for generating +prime numbers in sequential order. It provides an efficient solution +for applications requiring lists of primes, particularly for numbers +within the 32-bit range. -primegen can generate primes up to 1000000000000000, although it -is not optimized for primes past 32 bits. It uses the Sieve of Atkin -instead of the traditional Sieve of Eratosthenes. +A key feature of primegen is its use of the Sieve of Atkin, an advanced +algorithm that significantly outperforms the traditional Sieve of +Eratosthenes for generating primes up to a given limit. This optimization +results in impressive performance: + +- Generates 50,847,534 primes up to 1,000,000,000 in approximately + 8 seconds on a Pentium II-350. +- Prints these primes in decimal format in about 35 seconds on the + same hardware. + +While primegen can theoretically generate primes up to 10^15, its +performance is specifically optimized for primes that fit within 32-bit +integers. It is an invaluable tool for: + +- **Number Theory Research**: Exploring properties of prime numbers. +- **Cryptography**: Generating primes for key creation or testing. +- **Computational Mathematics**: Any application requiring efficient + prime number generation. diff --git a/math/prng/pkg-descr b/math/prng/pkg-descr index bb6fc45b5ab2..dbe213caafa0 100644 --- a/math/prng/pkg-descr +++ b/math/prng/pkg-descr @@ -1,4 +1,22 @@ -PRNG is a collection of portable, high-performance ANSI-C implementations of -pseudorandom number generators such as linear congruential, inversive -congruential, and explicit inversive congruential random number generators (LCG, -ICG and EICG, respectively) created by Otmar Lendl and Josef Leydold. +PRNG (Pseudorandom Number Generators) is a robust collection of portable, +high-performance ANSI-C implementations of various pseudorandom number +generators. Developed by Otmar Lendl and Josef Leydold, this library +is designed to provide statistically sound and efficient random number +sequences for a wide range of applications. + +The collection includes implementations of: + +- **Linear Congruential Generators (LCG)**: A classic and widely + understood method for generating pseudorandom numbers. +- **Inversive Congruential Generators (ICG)**: Offers improved + statistical properties compared to LCGs, particularly in terms of + period length and lattice structure. +- **Explicit Inversive Congruential Generators (EICG)**: Further + enhances the quality of pseudorandom sequences, often used in + more demanding simulations. + +PRNG is an invaluable resource for researchers, statisticians, and +developers in fields such as Monte Carlo simulations, cryptography, +and scientific modeling, where the quality and performance of random +number generation are critical. Its ANSI-C implementation ensures +broad compatibility and efficient execution across different platforms. diff --git a/math/py-claripy/pkg-descr b/math/py-claripy/pkg-descr index e86866b3cfa6..5cda9d5601d7 100644 --- a/math/py-claripy/pkg-descr +++ b/math/py-claripy/pkg-descr @@ -1,3 +1,21 @@ -Claripy is an abstracted constraint-solving wrapper for Python. +Claripy is a powerful and abstracted constraint-solving wrapper for Python, +designed to simplify the interaction with various underlying constraint +solvers. It provides a unified and high-level interface for defining +and solving complex symbolic constraints, making it an invaluable tool +for program analysis, symbolic execution, and security research. -It is being developed by the Angr project. +Developed as a core component of the Angr project, a well-known binary +analysis platform, Claripy is built to handle intricate symbolic expressions +and manage solver states efficiently. Its abstraction layer allows +developers to focus on defining the problem rather than the specifics +of individual solver APIs. + +Key applications include: +- Symbolic execution of binaries +- Automated exploit generation +- Program verification and bug finding +- Solving SMT (Satisfiability Modulo Theories) problems + +By providing a flexible and robust framework for symbolic reasoning, +Claripy empowers Python developers to tackle challenging problems in +computer science and security with greater ease and effectiveness. diff --git a/math/py-contourpy/Makefile b/math/py-contourpy/Makefile index 9d62149f5910..3543d32c9ab5 100644 --- a/math/py-contourpy/Makefile +++ b/math/py-contourpy/Makefile @@ -1,5 +1,5 @@ PORTNAME= contourpy -PORTVERSION= 1.3.2 +PORTVERSION= 1.3.3 CATEGORIES= math python MASTER_SITES= PYPI PKGNAMEPREFIX= ${PYTHON_PKGNAMEPREFIX} diff --git a/math/py-contourpy/distinfo b/math/py-contourpy/distinfo index 631f62ac693f..160cd3bb8ad3 100644 --- a/math/py-contourpy/distinfo +++ b/math/py-contourpy/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1744938446 -SHA256 (contourpy-1.3.2.tar.gz) = b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54 -SIZE (contourpy-1.3.2.tar.gz) = 13466130 +TIMESTAMP = 1759134905 +SHA256 (contourpy-1.3.3.tar.gz) = 083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880 +SIZE (contourpy-1.3.3.tar.gz) = 13466174 diff --git a/math/py-fvcore/pkg-descr b/math/py-fvcore/pkg-descr index edfc1da7d7eb..f7526eff106d 100644 --- a/math/py-fvcore/pkg-descr +++ b/math/py-fvcore/pkg-descr @@ -1,4 +1,21 @@ -fvcore is a light-weight core library that provides the most common and -essential functionality shared in various computer vision frameworks -developed in FAIR, such as Detectron2, PySlowFast, and ClassyVision. All -components in this library are type-annotated, tested, and benchmarked. +fvcore is a lightweight and highly optimized core library designed to +provide essential functionalities shared across various computer vision +frameworks developed at FAIR (Facebook AI Research). It serves as a +foundational toolkit, streamlining the development of advanced vision +models and applications. + +This library encapsulates common utilities and building blocks, such as: + +- **Configuration Management**: Tools for handling model configurations. +- **Logging and Monitoring**: Utilities for tracking experiment progress. +- **Data Structures**: Efficient data representations for computer + vision tasks. +- **Performance Benchmarking**: Integrated tools for evaluating and + optimizing code performance. + +A key strength of fvcore lies in its commitment to quality: all components +are meticulously type-annotated for clarity, thoroughly tested for +reliability, and rigorously benchmarked for optimal performance. It acts +as a crucial dependency for prominent FAIR projects like Detectron2, +PySlowFast, and ClassyVision, enabling developers to build robust and +efficient computer vision systems with confidence. diff --git a/math/py-luminol/pkg-descr b/math/py-luminol/pkg-descr index 474f02748a1d..7cb63e301904 100644 --- a/math/py-luminol/pkg-descr +++ b/math/py-luminol/pkg-descr @@ -1,3 +1,23 @@ -Luminol is a light weight python library for time series data analysis. -The two major functionalities it supports are anomaly detection and -correlation. It can be used to investigate possible causes of anomaly. +Luminol is an efficient and lightweight Python library specifically +designed for comprehensive time series data analysis. It provides +powerful functionalities for two critical aspects of time series +investigation: anomaly detection and correlation analysis. + +As a lightweight library, Luminol is optimized for performance and +resource efficiency, making it suitable for integration into various +data pipelines and applications without significant overhead. + +Its core capabilities include: +- **Anomaly Detection**: Identifying unusual patterns or outliers in + time series data that deviate significantly from expected behavior. + This is crucial for monitoring systems, detecting fraudulent activities, + or pinpointing performance issues. +- **Correlation Analysis**: Discovering relationships and dependencies + between different time series. This feature is particularly useful + for investigating the root causes of detected anomalies, allowing + users to understand which factors might be contributing to unusual events. + +Luminol empowers data scientists, engineers, and analysts to gain deeper +insights from their time series data, enabling proactive problem-solving +and informed decision-making by effectively pinpointing and diagnosing +anomalous behavior. diff --git a/math/py-minorminer/Makefile b/math/py-minorminer/Makefile index 5e5f453de108..17c8d881369a 100644 --- a/math/py-minorminer/Makefile +++ b/math/py-minorminer/Makefile @@ -1,6 +1,5 @@ PORTNAME= minorminer -DISTVERSION= 0.2.16 -PORTREVISION= 2 +DISTVERSION= 0.2.19 CATEGORIES= math python PKGNAMEPREFIX= ${PYTHON_PKGNAMEPREFIX} @@ -11,13 +10,13 @@ WWW= https://docs.ocean.dwavesys.com/projects/minorminer/en/latest/ LICENSE= APACHE20 LICENSE_FILE= ${WRKSRC}/LICENSE -PY_DEPENDS= ${PYTHON_PKGNAMEPREFIX}fasteners>=0.15:devel/py-fasteners@${PY_FLAVOR} \ +PY_DEPENDS= ${PYTHON_PKGNAMEPREFIX}fasteners>=0.19:devel/py-fasteners@${PY_FLAVOR} \ ${PYTHON_PKGNAMEPREFIX}homebase>=1.0.1:devel/py-homebase@${PY_FLAVOR} \ - ${PYTHON_PKGNAMEPREFIX}networkx>=2.4:math/py-networkx@${PY_FLAVOR} \ - ${PYTHON_PKGNAMEPREFIX}dwave-networkx>=0.8.10:science/py-dwave-networkx@${PY_FLAVOR} \ + ${PYTHON_PKGNAMEPREFIX}networkx>=3.2.1:math/py-networkx@${PY_FLAVOR} \ + ${PYTHON_PKGNAMEPREFIX}dwave-networkx>=0.8.15:science/py-dwave-networkx@${PY_FLAVOR} \ ${PYNUMPY} \ ${PYTHON_PKGNAMEPREFIX}rectangle-packer>=2.0.1:math/py-rectangle-packer@${PY_FLAVOR} \ - ${PYTHON_PKGNAMEPREFIX}scipy>=1.7.3:science/py-scipy@${PY_FLAVOR} + ${PYTHON_PKGNAMEPREFIX}scipy>=1.13.1:science/py-scipy@${PY_FLAVOR} BUILD_DEPENDS= ${PY_DEPENDS} RUN_DEPENDS= ${PY_DEPENDS} diff --git a/math/py-minorminer/distinfo b/math/py-minorminer/distinfo index 0b3334cc62bf..adeb280676d3 100644 --- a/math/py-minorminer/distinfo +++ b/math/py-minorminer/distinfo @@ -1,6 +1,6 @@ -TIMESTAMP = 1731038865 -SHA256 (dwavesystems-minorminer-0.2.16_GH0.tar.gz) = 0945862971d6d5e37b5cdb91950758843d919e898d7e62259c9049ee13dcca74 -SIZE (dwavesystems-minorminer-0.2.16_GH0.tar.gz) = 1281256 +TIMESTAMP = 1758997678 +SHA256 (dwavesystems-minorminer-0.2.19_GH0.tar.gz) = f4207bed0a74bbe89fd5a1d8657bc611106a67ac733aa034877d27f306afdf6a +SIZE (dwavesystems-minorminer-0.2.19_GH0.tar.gz) = 1290750 SHA256 (boothby-glasgow-subgraph-solver-568c45f_GH0.tar.gz) = efe3971ee56bc5acf8d64a9e9f98e38962f9c4514b4356e1f7f662873a9fc8b9 SIZE (boothby-glasgow-subgraph-solver-568c45f_GH0.tar.gz) = 80856 SHA256 (nemequ-portable-snippets-84abba9_GH0.tar.gz) = 934157a2892aa9afcab81229b089b0255fdba45727ccec7a017e270fa32f7e4f diff --git a/math/py-pytorchvideo/pkg-descr b/math/py-pytorchvideo/pkg-descr index b92cab0a19bc..a8dd0b918d86 100644 --- a/math/py-pytorchvideo/pkg-descr +++ b/math/py-pytorchvideo/pkg-descr @@ -1,5 +1,23 @@ -PyTorchVideo is a deeplearning library with a focus on video understanding -work. PytorchVideo provides reusable, modular and efficient components needed -to accelerate the video understanding research. PyTorchVideo is developed using -PyTorch and supports different deeplearning video components like video models, -video datasets, and video-specific transforms. +PyTorchVideo is a comprehensive deep learning library specifically +designed to accelerate research and development in video understanding. +Built upon the popular PyTorch framework, it offers a rich collection +of reusable, modular, and highly efficient components tailored for +video-centric deep learning tasks. + +This library streamlines the process of building and deploying video +understanding models by providing: + +- **Pre-trained Video Models**: A diverse set of state-of-the-art + architectures optimized for video data. +- **Video Datasets**: Tools and utilities for handling and processing + various video datasets. +- **Video-Specific Transforms**: Efficient data augmentation and + preprocessing techniques adapted for temporal and spatial video + characteristics. + +PyTorchVideo empowers researchers and developers to tackle challenging +problems such as action recognition, video classification, and object +tracking in videos with greater ease and efficiency. Its modular design +fosters rapid experimentation and allows for seamless integration into +existing PyTorch workflows, making it an invaluable resource for the +computer vision community. diff --git a/math/py-roman/Makefile b/math/py-roman/Makefile index 3223f660cca4..09981e890786 100644 --- a/math/py-roman/Makefile +++ b/math/py-roman/Makefile @@ -1,6 +1,5 @@ PORTNAME= roman -PORTVERSION= 5.0 -PORTREVISION= 1 +PORTVERSION= 5.1 CATEGORIES= math python MASTER_SITES= PYPI PKGNAMEPREFIX= ${PYTHON_PKGNAMEPREFIX} diff --git a/math/py-roman/distinfo b/math/py-roman/distinfo index e0125de71044..cc01a8ef817a 100644 --- a/math/py-roman/distinfo +++ b/math/py-roman/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1738332001 -SHA256 (roman-5.0.tar.gz) = cb35293c1c4046105fd899194f4f2985f78c955a8b05937f7ab93f3be1660697 -SIZE (roman-5.0.tar.gz) = 7664 +TIMESTAMP = 1759134408 +SHA256 (roman-5.1.tar.gz) = 3a86572e9bc9183e771769601189e5fa32f1620ffeceebb9eca836affb409986 +SIZE (roman-5.1.tar.gz) = 8066 diff --git a/math/py-svgmath/pkg-descr b/math/py-svgmath/pkg-descr index d3d4663027eb..f5a80bb1f657 100644 --- a/math/py-svgmath/pkg-descr +++ b/math/py-svgmath/pkg-descr @@ -1,2 +1,20 @@ -SVGMath is a command-line utility to convert MathML expressions -to SVG, written entirely in Python. +SVGMath is a specialized command-line utility written entirely in Python +that facilitates the conversion of MathML (Mathematical Markup Language) +expressions into SVG (Scalable Vector Graphics) format. + +MathML is an XML-based markup language for describing mathematical +notation, while SVG is an XML-based vector image format for two-dimensional +graphics. The conversion provided by SVGMath is highly beneficial for: + +- **High-quality rendering**: SVG ensures that mathematical equations + are rendered sharply and clearly at any resolution, making them ideal + for web display, print, and presentations. +- **Web integration**: Easily embed complex mathematical formulas into + web pages and other digital documents without relying on raster images + or specialized fonts. +- **Accessibility**: Vector graphics maintain their quality when scaled, + improving readability for users with varying display needs. + +As a pure Python implementation, SVGMath offers a portable and easily +integrable solution for developers and content creators who need to +present mathematical content in a visually appealing and scalable format. diff --git a/math/qtiplot-doc/pkg-descr b/math/qtiplot-doc/pkg-descr index 15600819239d..59b9caf0649f 100644 --- a/math/qtiplot-doc/pkg-descr +++ b/math/qtiplot-doc/pkg-descr @@ -1,3 +1,22 @@ -QtiPlot is a free (GPL) platform independent data analysis and -visualization application similar to the non-free Windows program -Origin. +This package provides the comprehensive documentation for QtiPlot, +a powerful and platform-independent application for data analysis +and visualization. QtiPlot is a free (GPL) software often compared +to commercial alternatives like Origin, offering extensive capabilities +for scientific plotting, data manipulation, and statistical analysis. + +The documentation included in this package is an essential resource +for both new and experienced QtiPlot users. It covers: + +- **Getting Started**: Installation, interface overview, and basic + operations. +- **Data Handling**: Importing, organizing, and manipulating datasets. +- **Plotting**: Creating 2D and 3D plots, customizing graphs, and + exporting results. +- **Analysis**: Performing statistical tests, curve fitting, and + signal processing. +- **Scripting**: Utilizing QtiPlot's scripting capabilities for + automation. + +By providing detailed guides, tutorials, and reference materials, this +documentation package ensures users can fully leverage QtiPlot's +features to effectively analyze and visualize their scientific data. diff --git a/math/randlib/pkg-descr b/math/randlib/pkg-descr index e42d51236e6b..ba80a16b1a4e 100644 --- a/math/randlib/pkg-descr +++ b/math/randlib/pkg-descr @@ -1,20 +1,21 @@ -This library provides routines that return: - (1) Beta random deviates - (2) Chi-square random deviates - (3) Exponential random deviates - (4) F random deviates - (5) Gamma random deviates - (6) Multivariate normal random deviates (mean and covariance - matrix specified) - (7) Noncentral chi-square random deviates - (8) Noncentral F random deviates - (9) Univariate normal random deviates - (10) Random permutations of an integer array - (11) Real uniform random deviates between specif - (12) Binomial random deviates - (13) Negative Binomial random deviates - (14) Multinomial random deviates - (15) Poisson random deviates - (16) Integer uniform deviates between specified limits - (17) Seeds for the random number generator calculated from a - character string +RANDLIB is a comprehensive library of routines for generating various +types of random numbers and permutations. It provides a robust set of +functions for statistical simulations and modeling, making it a valuable +tool for researchers and developers. + +The library offers routines to return: + +- **Continuous Random Deviates**: Beta, Chi-square, Exponential, F, + Gamma, Noncentral Chi-square, Noncentral F, and Univariate Normal. +- **Discrete Random Deviates**: Binomial, Negative Binomial, Multinomial, + and Poisson. +- **Uniform Random Deviates**: Real uniform deviates between specified + limits, and integer uniform deviates between specified limits. +- **Multivariate Normal Deviates**: With specified mean and covariance matrix. +- **Random Permutations**: Generates random permutations of an integer array. +- **Seed Generation**: Calculates seeds for the random number generator + from a character string. + +RANDLIB ensures a wide range of random number generation capabilities, +essential for Monte Carlo methods, statistical analysis, and other +applications requiring diverse and reliable random variates. diff --git a/math/reduce-psl/pkg-descr b/math/reduce-psl/pkg-descr index a5ed5582beda..80b2ef76dd7f 100644 --- a/math/reduce-psl/pkg-descr +++ b/math/reduce-psl/pkg-descr @@ -1,17 +1,23 @@ - REDUCE Portable Standard Lisp (PSL) +REDUCE Portable Standard Lisp (PSL) is an interactive system for +general algebraic computations. It is designed to assist mathematicians, +scientists, and engineers with symbolic manipulation and numerical tasks. -REDUCE is an interactive system for general algebraic computations of -interest to mathematicians, scientists and engineers. +REDUCE, powered by PSL, is particularly adept at handling complex +calculations that are not feasible to perform by hand. PSL, originally +the implementation of Standard Lisp, has evolved to include numerous +facilities and is optimized for algebraic computation. -PSL was the original implementation of Standard Lisp, but now contains -many more facilities. It is quite efficient in its use of both space and -time, and has been optimized for algebraic computation. All PSL versions -of REDUCE are distributed with sufficient PSL support to run on the given -computing system. PSL is supported on many architectures and is an ideal -system for those wanting to run REDUCE as a stand-alone system. The -principal developer of PSL before it became Open Source was the Konrad -Zuse Center, Berlin (ZIB). +Key features and benefits: -It is often used as an algebraic calculator for problems that are possible -to do by hand. However, REDUCE is designed to support calculations that -are not feasible by hand. +- **General Algebraic Computations**: Performs symbolic manipulation, + simplification, differentiation, integration, and equation solving. +- **Efficiency**: Optimized for both space and time, making it efficient + for algebraic workloads. +- **Stand-alone System**: PSL provides all necessary support to run + REDUCE as a self-contained system. +- **Broad Architecture Support**: Available on many architectures, + ensuring wide compatibility. + +REDUCE-PSL is an invaluable tool for academic and industrial users +requiring a powerful and efficient computer algebra system for research, +development, and problem-solving in various scientific and engineering domains. diff --git a/math/rngstreams/pkg-descr b/math/rngstreams/pkg-descr index e8b1e5a88668..78af90b3a080 100644 --- a/math/rngstreams/pkg-descr +++ b/math/rngstreams/pkg-descr @@ -1,11 +1,23 @@ -RngStreams is a C implementation of a high-quality uniform random number -generator that supports multiple "independent" streams of uniform random -numbers. +RngStreams is a C implementation of a high-quality uniform random +number generator (RNG) that provides support for multiple "independent" +streams of random numbers. This feature is crucial for parallel and +distributed simulations, ensuring that different parts of a simulation +can draw from distinct, non-overlapping sequences of random numbers. -It was written by Pierre L'Ecuyer and Richard Simard, who have a website -at: +Developed by Pierre L'Ecuyer and Richard Simard, RngStreams is designed +to offer statistically sound and reproducible random number sequences. +Its core strength lies in managing multiple streams, which is essential +for: -http://www.iro.umontreal.ca/~simardr/indexe.html +- **Parallel Simulations**: Running independent simulation replicates + concurrently. +- **Distributed Computing**: Ensuring unique random number sequences + across different processors or nodes. +- **Reproducibility**: Allowing for the exact replication of simulation + results by controlling the state of each stream. -This GNU-style package is compiled and maintained by Josef Leydold and -released under the GNU Public License (GPL). +This GNU-style package is compiled and maintained by Josef Leydold, +and is released under the GNU Public License (GPL). RngStreams is an +invaluable tool for researchers and developers in Monte Carlo methods, +statistical modeling, and any application requiring robust and manageable +random number generation. diff --git a/math/sc/pkg-descr b/math/sc/pkg-descr index d0ed9f7ad3c2..6dbe2aa24631 100644 --- a/math/sc/pkg-descr +++ b/math/sc/pkg-descr @@ -1,7 +1,22 @@ -The spreadsheet calculator sc is based on rectangular tables much like -a financial spreadsheet. When invoked it presents you with a table -organized as rows and columns of cells. If invoked without a file -argument, the table is initially empty. Each cell may have associated -with it a numeric value, a label string, and/or an expression (formula) -which evaluates to a numeric value or label string, often based on other -cell values. +sc (spreadsheet calculator) is a powerful and flexible terminal-based +spreadsheet program. It operates on rectangular tables, providing a +familiar interface of rows and columns for data organization and analysis. +Unlike graphical spreadsheets, sc is designed for efficiency and accessibility +within text-based environments. + +Upon invocation, sc presents an organized table of cells. If no file +argument is provided, it starts with an empty table, ready for user input. +Each cell in the spreadsheet can store and display various types of data: + +- **Numeric Values**: Direct numerical entries. +- **Label Strings**: Textual descriptions or headers. +- **Expressions (Formulas)**: Dynamic calculations that evaluate to + either a numeric value or a label string. These formulas can + reference other cell values, enabling complex inter-cell dependencies + and powerful data manipulation. + +sc is an invaluable tool for users who prefer a command-line interface +for data management, financial calculations, or any task requiring +spreadsheet functionality without the overhead of a graphical environment. +Its robust formula support and cell-based operations make it a versatile +choice for data analysis and reporting. diff --git a/math/scilab-toolbox-swt/pkg-descr b/math/scilab-toolbox-swt/pkg-descr index 6bfc6c6303b4..ed8fa452af6a 100644 --- a/math/scilab-toolbox-swt/pkg-descr +++ b/math/scilab-toolbox-swt/pkg-descr @@ -1,15 +1,23 @@ -Scilab Wavelet Toolbox (SWT) +The Scilab Wavelet Toolbox (SWT) is a free software package designed +to provide comprehensive wavelet analysis tools within the Scilab +environment. Wavelet analysis is a powerful signal processing technique +used for analyzing signals and images across various scales. -Wavelet is a powerful signal processing tool developed and developing -in the last two decades. Scilab Wavelet Toolbox is a free software package -to enable you using wavelet analysis tools freely in Scilab on most OSes -including GNU/Linux, BSD and Windows. Scilab Wavelet Toolbox is designed -to work with any Scilab Image Processing Toolbox like SIP -for displaying 2-D results. +SWT enables users to perform a wide range of wavelet-based operations +on both 1-D signals and 2-D images. Key functionalities include: -What Scilab Wavelet Toolbox supposed to do: -Discrete Fast Wavelet Transform, daubechies wavelets -1-D single level signal decomposition and reconstruction -1-D multi-level signal decomposition and reconstruction -2-D single level image decomposition and reconstruction -2-D multi-level image decomposition and reconstruction. +- **Discrete Fast Wavelet Transform (DFWT)**: Efficient computation + of wavelet transforms. +- **Daubechies Wavelets**: Support for a popular family of wavelets. +- **1-D Signal Decomposition and Reconstruction**: + - Single-level decomposition and reconstruction. + - Multi-level decomposition and reconstruction. +- **2-D Image Decomposition and Reconstruction**: + - Single-level decomposition and reconstruction. + - Multi-level decomposition and reconstruction. + +SWT is compatible with most operating systems, including GNU/Linux, BSD, +and Windows. It is designed to integrate seamlessly with Scilab Image +Processing Toolboxes (e.g., SIP) for displaying 2-D results. This toolbox +is an invaluable resource for engineers, researchers, and students working +in signal and image processing, data compression, and feature extraction. diff --git a/math/scilab/pkg-descr b/math/scilab/pkg-descr index 98ef3c7949d2..ad036b47262c 100644 --- a/math/scilab/pkg-descr +++ b/math/scilab/pkg-descr @@ -1,34 +1,24 @@ -Scilab is a scientific software package for numerical computations in a -user-friendly environment. +Scilab is a powerful, open-source scientific software package for +numerical computations, offering a user-friendly environment for +engineers, scientists, and students. It provides a high-level +programming language and a rich set of functionalities. -Main features - * Hundreds of mathematical functions - * High level programming language - * 2-D and 3-D graphics - * Advanced data structures and user defined data types - * Xcos: hybrid dynamic systems modeler and simulator -2-D and 3-D visualization - * Lines - * Pie charts - * Histograms - * Surfaces - * Animations - * Graphics export in many formats: GIF, BMP, JPEG, SVG, PDF... -Numerical computation - * Linear algebra - * Sparse matrices - * Polynomials and rational functions - * Simulation: explicit and implicit systems of differential - equations solvers - * Classic and robust control - * Differentiable and non-differentiable optimization -Data analysis - * Interpolation, approximation - * Signal Processing - * Statistics -Extended features - * Graphs and Networks - * Interface with Fortran, C, C++, Java - * Functions for calling Scilab from C, C++, Fortran and Java - * LabVIEW Gateway - * A large number of modules available via ATOMS +Key features: + +- **Mathematical Functions**: Hundreds of built-in functions. +- **High-Level Programming Language**: For scripting and automation. +- **2-D and 3-D Graphics**: Comprehensive visualization, including + lines, charts, histograms, surfaces, and animations. Exports to + GIF, BMP, JPEG, SVG, PDF. +- **Xcos**: Hybrid dynamic systems modeler and simulator. +- **Numerical Computation**: Linear algebra, sparse matrices, + polynomials, rational functions, differential equation solvers, + control, optimization. +- **Data Analysis**: Interpolation, approximation, signal processing, + and statistics. +- **Extensibility**: Interfaces with Fortran, C, C++, Java; numerous + modules via ATOMS. + +Scilab is an invaluable tool for numerical analysis, data processing, +and scientific visualization, a free and powerful alternative to +commercial mathematical software. diff --git a/math/sfft/pkg-descr b/math/sfft/pkg-descr index 5901f6f19f9c..6c02233b3f3b 100644 --- a/math/sfft/pkg-descr +++ b/math/sfft/pkg-descr @@ -1,6 +1,19 @@ -sfft is a library to compute discrete Fourier transforms of signals with -a sparse frequency domain, using an algorithm that is more efficient than -other known FFT algorithms. It was developed by Haitham Hassanieh, Piotr -Indyk, Dina Katabi, and Eric Price at the Computer Science and Artifical -Intelligence Lab at MIT. Performance optimizations were developed by J. -Schumacher at the Computer Science Department of ETH Zurich in 2013. +sfft is an optimized library for computing Discrete Fourier Transforms +(DFTs) of signals with a sparse frequency domain. It exploits this +sparsity for significantly more efficient computations than traditional +FFT algorithms. + +Developed by a team at MIT CSAIL (Hassanieh, Indyk, Katabi, Price), +sfft represents a breakthrough in sparse Fourier transform techniques. +Further performance optimizations were contributed by J. Schumacher at +ETH Zurich. + +This library is beneficial for applications where: + +- **Signals have few dominant frequencies**: E.g., compressed sensing, + spectral analysis of sparse signals. +- **Computational speed is critical**: Offering faster processing. +- **Resource efficiency is desired**: Reducing computational load. + +sfft provides a powerful tool for researchers and engineers working with +sparse spectral data, enabling faster analysis and processing. diff --git a/math/slatec/pkg-descr b/math/slatec/pkg-descr index d222e326629c..a6f7421565cd 100644 --- a/math/slatec/pkg-descr +++ b/math/slatec/pkg-descr @@ -1,2 +1,22 @@ -SLATEC is a comprehensive software library containing over 1400 general -purpose mathematical and statistical routines written in Fortran 77. +SLATEC (Scientific Library for Advanced Technology Exchange) is a +comprehensive and historically significant software library, offering +over 1400 general-purpose mathematical and statistical routines. +Originally developed by a consortium of U.S. government laboratories, +these routines are primarily written in Fortran 77, reflecting their +proven reliability and efficiency in numerical computation. + +This extensive collection covers a broad spectrum of numerical methods, +including but not limited to: + +- Linear algebra (e.g., solving systems of equations, eigenvalue problems) +- Special functions (e.g., Bessel functions, Gamma functions) +- Numerical integration and differentiation +- Interpolation and approximation +- Statistical analysis and probability distributions +- Optimization techniques + +SLATEC serves as a robust foundation for scientific and engineering +applications requiring high-quality, well-tested numerical algorithms. +It remains a valuable resource for researchers, engineers, and developers +working with Fortran-based projects or those needing a reliable suite +of established numerical methods. diff --git a/math/snns/pkg-descr b/math/snns/pkg-descr index 70b4f67de61e..cec2ff3352a8 100644 --- a/math/snns/pkg-descr +++ b/math/snns/pkg-descr @@ -1,24 +1,23 @@ -SNNS (Stuttgart Neural Network Simulator) is a software simulator for neural -networks on Unix workstations developed at the Institute for Parallel and -Distributed High Performance Systems (IPVR) at the University of Stuttgart. -The goal of the SNNS project is to create an efficient and flexible -simulation environment for research on and application of neural nets. +SNNS (Stuttgart Neural Network Simulator) is a comprehensive software +simulator for neural networks, developed at the Institute for Parallel +and Distributed High Performance Systems (IPVR) at the University of +Stuttgart. It provides an efficient and flexible environment for +research and application of neural networks. -The SNNS simulator consists of two main components: +SNNS comprises two main components: -1) simulator kernel written in C -2) graphical user interface under X +1. **Simulator Kernel (C-based)**: This core component handles internal + network data structures, learning, and recall operations. It supports + arbitrary network topologies and the concept of sites. The kernel + can be extended with user-defined activation functions, output + functions, site functions, and learning procedures written in C. + It can also be embedded in custom applications. +2. **Graphical User Interface (XGUI)**: Built on top of the kernel, + XGUI provides 2D and 3D graphical representations of neural networks. + It controls the kernel during simulation and includes an integrated + network editor for creating, manipulating, and visualizing neural + nets interactively. -The simulator kernel operates on the internal network data structures of the -neural nets and performs all operations of learning and recall. It can also -be used without the other parts as a C program embedded in custom -applications. It supports arbitrary network topologies and the concept of -sites. SNNS can be extended by the user with user defined activation -functions, output functions, site functions and learning procedures, which -are written as simple C programs and linked to the simulator kernel. - -The graphical user interface XGUI (X Graphical User Interface), built on top -of the kernel, gives a 2D and a 3D graphical representation of the neural -networks and controls the kernel during the simulation run. In addition, the -2D user interface has an integrated network editor which can be used to -directly create, manipulate and visualize neural nets in various ways. +SNNS is an invaluable tool for researchers, students, and developers +working with neural networks, offering a powerful platform for +experimentation, simulation, and understanding of complex neural models. diff --git a/math/solitaire/pkg-descr b/math/solitaire/pkg-descr index 056ca6c86725..7e9341f2e1d6 100644 --- a/math/solitaire/pkg-descr +++ b/math/solitaire/pkg-descr @@ -1,7 +1,22 @@ -Solitaire is an encryption system based on a deck of cards by Bruce -Schneier. Although it is designed to be worked out by a human, it can -work on computers. This is the reference implementation programmed in -Perl. The program itself is installed as 'solitaire', and the source -code and test vectors are installed in share/doc/solitaire. +Solitaire is a unique encryption system designed by renowned cryptographer +Bruce Schneier, based on the manipulation of a deck of playing cards. +While ingeniously crafted for manual execution by a human, this system +can also be implemented computationally. -Please read the web site below before relying on this for real security. +This package provides the reference implementation of the Solitaire +encryption algorithm, programmed in Perl. It serves as a faithful +digital representation of Schneier's original design, allowing for +both study and practical application. + +Key components installed: + +- **solitaire executable**: The primary program for performing + encryption and decryption. +- **Source code and test vectors**: Located in share/doc/solitaire, + these resources are invaluable for understanding the algorithm's + mechanics and verifying its correctness. + +**IMPORTANT SECURITY NOTE**: Before relying on this implementation for +any real-world security applications, it is strongly advised to +thoroughly read the official website and understand the nuances and +limitations of the Solitaire algorithm. diff --git a/math/spblas/pkg-descr b/math/spblas/pkg-descr index 8fb8a077acc3..a0903b17e7e0 100644 --- a/math/spblas/pkg-descr +++ b/math/spblas/pkg-descr @@ -1,7 +1,24 @@ -This is an ANSI C++ implementation of the complete ANSI C specification of -Chapter 3 of the BLAS Technical Forum Standard. The distribution is quite -small and it is meant as a starting point for developing an optimized and -architecture-dependent version. (C++ was used, rather than C, as it has support -for complex arithmetic and templates to facilitate to creation of various -precision codes.) The library includes support for all four precision types -(single, double precision, real, and complex) and Level 1, 2, and 3 operations. +SPBLAS is an ANSI C++ implementation of Chapter 3 of the BLAS (Basic +Linear Algebra Subprograms) Technical Forum Standard. BLAS routines are +fundamental building blocks for high-performance numerical linear algebra, +widely used in scientific computing, engineering, and data analysis. + +This library serves as a robust starting point for developing optimized +and architecture-dependent BLAS implementations. Its C++ design offers +several advantages: + +- **Complex Arithmetic Support**: Facilitates computations involving + complex numbers directly. +- **Templates**: Enables the creation of various precision codes, + supporting single, double precision, real, and complex data types. + +SPBLAS provides comprehensive coverage of BLAS operations, including: + +- **Level 1**: Vector-vector operations (e.g., dot product, vector scaling). +- **Level 2**: Matrix-vector operations (e.g., matrix-vector multiplication). +- **Level 3**: Matrix-matrix operations (e.g., matrix-matrix multiplication), + which are crucial for many high-performance computing tasks. + +This library is an invaluable resource for developers and researchers +who need a portable, standard-compliant, and extensible foundation for +implementing efficient linear algebra routines in C++. diff --git a/math/tomsfastmath/pkg-descr b/math/tomsfastmath/pkg-descr index ec56fac59dc4..19be5c899bfe 100644 --- a/math/tomsfastmath/pkg-descr +++ b/math/tomsfastmath/pkg-descr @@ -1,2 +1,18 @@ -TomsFastMath is a portable fixed precision math library designed for -very fast exponentiations. +TomsFastMath (TFM) is a highly optimized and portable fixed-precision +mathematics library, specifically engineered for exceptionally fast +exponentiation operations. Designed for environments where performance +is critical, TFM provides a robust solution for cryptographic applications, +large number arithmetic, and other computational tasks demanding rapid +modular exponentiation. + +The library's fixed-precision nature means it operates on integers of +a predetermined size, offering predictable performance characteristics +and efficient memory usage. Its primary strength lies in its ability +to perform modular exponentiation (e.g., a^b mod n) with remarkable speed, +a fundamental operation in public-key cryptography algorithms like RSA +and Diffie-Hellman. + +TFM's portability ensures it can be easily integrated into various +projects across different platforms, making it a valuable asset for +developers building secure communication protocols, digital signatures, +or any system requiring high-speed, fixed-precision arithmetic. diff --git a/math/trlan/pkg-descr b/math/trlan/pkg-descr index c9299a9f54da..175406fb5c76 100644 --- a/math/trlan/pkg-descr +++ b/math/trlan/pkg-descr @@ -1,7 +1,24 @@ -This portable, modular Fortran 90 software package implements the thick-restart -Lanczos method, for use with real symmetric or complex Hermitian eigenvalue -problems where a small number of eigevalues and eigenvectors are needed, and -the matrices involved may be too large to store in computer memory. Most of -the arithmetic computations in the software are done through calls to BLAS -and LAPACK. The software can be instructed to write checkpoint files so that -it can be restarted is a later time. +TRLAN is a portable and modular Fortran 90 software package that +implements the thick-restart Lanczos method. This advanced numerical +technique is specifically designed for efficiently solving large-scale +eigenvalue problems, particularly when only a small subset of eigenvalues +and their corresponding eigenvectors are required. + +TRLAN excels in scenarios involving real symmetric or complex Hermitian +matrices that are too large to be stored entirely in computer memory. +Its key features include: + +- **Memory Efficiency**: Handles very large matrices by avoiding full + storage, making it suitable for high-performance computing. +- **Targeted Eigenvalue Computation**: Focuses on finding a few desired + eigenvalues and eigenvectors, rather than the entire spectrum. +- **BLAS and LAPACK Integration**: Leverages highly optimized Basic + Linear Algebra Subprograms (BLAS) and Linear Algebra Package (LAPACK) + routines for core arithmetic computations, ensuring high performance. +- **Checkpointing Capability**: Supports writing checkpoint files, + allowing computations to be paused and restarted later, which is + crucial for long-running simulations or in case of system interruptions. + +TRLAN is an invaluable tool for researchers and engineers in fields +such as quantum chemistry, structural analysis, and materials science, +where efficient and robust solutions to large eigenvalue problems are essential. diff --git a/math/tvmet/pkg-descr b/math/tvmet/pkg-descr index 3b3a45f3757b..c2a673651c07 100644 --- a/math/tvmet/pkg-descr +++ b/math/tvmet/pkg-descr @@ -1,4 +1,24 @@ -This Tiny Vector and Matrix template library uses Meta and Expression -Templates to evaluate results at compile time, thus making it fast for -low-end systems. Temporaries are avoided because of this. The dimensions -are static and bounded at compile time. +TVMet (Tiny Vector and Matrix template library) is a high-performance +C++ library designed for efficient linear algebra operations, particularly +suited for resource-constrained or performance-critical applications. +It leverages advanced C++ features like Meta-programming and Expression +Templates to achieve remarkable speed and memory efficiency. + +The core innovation of TVMet lies in its ability to evaluate many +mathematical expressions involving vectors and matrices at compile time. +This approach eliminates the creation of costly temporary objects during +runtime, leading to: + +- **Exceptional Performance**: Significantly faster execution compared + to traditional approaches. +- **Minimal Memory Footprint**: Reduced memory consumption, making it + ideal for embedded systems or applications with strict memory budgets. +- **Static Dimensioning**: Vector and matrix dimensions are fixed at + compile time, allowing for aggressive optimizations and compile-time + error checking. + +TVMet is an excellent choice for developers working on scientific simulations, +game development, embedded systems, or any project where fast and +memory-efficient linear algebra is paramount. It provides a robust and +optimized solution for numerical computations without compromising on +performance or resource usage. diff --git a/math/ump/pkg-descr b/math/ump/pkg-descr index b8b22400d0fb..20c0a7833fd7 100644 --- a/math/ump/pkg-descr +++ b/math/ump/pkg-descr @@ -1,2 +1,16 @@ -ump is a graphical, easy to use math program, which works with complex -numbers, matrices, functions and much more. +UMP (Universal Math Program) is an intuitive and powerful graphical +mathematics program designed for ease of use. It provides a comprehensive +environment for performing a wide range of mathematical operations, +making complex calculations accessible to students, educators, and +professionals alike. + +Key features include robust support for: +- Complex numbers: Perform arithmetic and functions with complex values. +- Matrices: Handle matrix operations, inversions, and determinants. +- Functions: Define, plot, and analyze mathematical functions. +- Advanced calculations: Solve equations, perform calculus operations, + and work with various mathematical expressions. + +With its user-friendly graphical interface, UMP simplifies the process +of exploring mathematical concepts and solving intricate problems, +offering a visual and interactive approach to mathematics. diff --git a/math/xplot/pkg-descr b/math/xplot/pkg-descr index cb23a6e43f97..aa11ebcce82f 100644 --- a/math/xplot/pkg-descr +++ b/math/xplot/pkg-descr @@ -1 +1,9 @@ -An X11 graphing utility. Commonly used to display TCP traces. +Xplot is a versatile and efficient graphing utility specifically designed +for the X11 windowing system. It provides a robust platform for visualizing +various types of data, making it particularly useful for scientific, +engineering, and network analysis applications. + +Commonly employed to display TCP traces, Xplot can also handle other +time-series data, scatter plots, and more. Its interactive features allow +users to zoom, pan, and inspect data points directly within the X11 +environment, offering a dynamic approach to data exploration and analysis. diff --git a/math/xspread/pkg-descr b/math/xspread/pkg-descr index 4555690ac340..f335c25c1f3e 100644 --- a/math/xspread/pkg-descr +++ b/math/xspread/pkg-descr @@ -1,3 +1,15 @@ -The program xspread is a public domain spreadsheet which runs under -X Window system or ascii terminals. Xspread uses the X Window system -if available or curses and term[cap/info] for ascii displays. +Xspread is a versatile and robust public domain spreadsheet program +designed for broad accessibility. It offers a flexible user experience, +operating seamlessly in both graphical X Window System environments and +text-based ASCII terminals. + +When running under the X Window System, xspread leverages its graphical +capabilities to provide an intuitive and interactive interface. For users +in command-line or remote environments, it gracefully falls back to +curses and termcap/terminfo for ASCII displays, ensuring functionality +across a wide range of setups. + +As a public domain tool, xspread provides a free and open solution for +data organization, calculation, and analysis. It's an excellent choice +for users seeking a lightweight yet powerful spreadsheet application +that adapts to various computing environments. |