Documentation

Mathlib.Tactic.Linarith.Datatypes

Datatypes for linarith #

Some of the data structures here are used in multiple parts of the tactic. We split them into their own file.

This file also contains a few convenient auxiliary functions.

A shorthand for tracing the types of a list of proof terms when the trace.linarith option is set to true.

Equations
  • One or more equations did not get rendered due to their size.
Instances For

    Linear expressions #

    @[reducible, inline]

    A linear expression is a list of pairs of variable indices and coefficients, representing the sum of the products of each coefficient with its corresponding variable.

    Some functions on Linexp assume that n : Nat occurs at most once as the first element of a pair, and that the list is sorted in decreasing order of the first argument. This is not enforced by the type but the operations here preserve it.

    Equations
    Instances For

      Add two Linexps together componentwise. Preserves sorting and uniqueness of the first argument.

      l.scale c scales the values in l by c without modifying the order or keys.

      Equations
      Instances For

        l.get n returns the value in l associated with key n, if it exists, and none otherwise. This function assumes that l is sorted in decreasing order of the first argument, that is, it will return none as soon as it finds a key smaller than n.

        Equations
        Instances For

          l.contains n is true iff n is the first element of a pair in l.

          Equations
          Instances For

            l.zfind n returns the value associated with key n if there is one, and 0 otherwise.

            Equations
            Instances For

              l.vars returns the list of variables that occur in l.

              Equations
              Instances For

                Defines a lex ordering on Linexp. This function is performance critical.

                Equations
                Instances For

                  Comparisons with 0 #

                  structure Linarith.Comp :

                  The main datatype for FM elimination. Variables are represented by natural numbers, each of which has an integer coefficient. Index 0 is reserved for constants, i.e. coeffs.find 0 is the coefficient of 1. The represented term is coeffs.sum (fun ⟨k, v⟩ ↦ v * Var[k]). str determines the strength of the comparison -- is it < 0, ≤ 0, or = 0?

                  • The strength of the comparison, <, , or =.

                  • The coefficients of the comparison, stored as list of pairs (i, a), where i is the index of a recorded atom, and a is the coefficient.

                  Instances For
                    Equations

                    c.vars returns the list of variables that appear in the linear expression contained in c.

                    Equations
                    Instances For

                      c.coeffOf a projects the coefficient of variable a out of c.

                      Equations
                      Instances For

                        c.scale n scales the coefficients of c by n.

                        Equations
                        Instances For

                          Comp.add c1 c2 adds the expressions represented by c1 and c2. The coefficient of variable a in c1.add c2 is the sum of the coefficients of a in c1 and c2.

                          Equations
                          • c1.add c2 = { str := c1.str.max c2.str, coeffs := c1.coeffs.add c2.coeffs }
                          Instances For

                            Comp has a lex order. First the ineqs are compared, then the coeffs.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For

                              A Comp represents a contradiction if its expression has no coefficients and its strength is <, that is, it represents the fact 0 < 0.

                              Equations
                              Instances For

                                Parsing into linear form #

                                Control #

                                A preprocessor transforms a proof of a proposition into a proof of a different proposition. The return type is List Expr, since some preprocessing steps may create multiple new hypotheses, and some may remove a hypothesis from the list. A "no-op" preprocessor should return its input as a singleton list.

                                • name : String

                                  The name of the preprocessor, used in trace output.

                                • Replace a hypothesis by a list of hypotheses. These expressions are the proof terms.

                                Instances For

                                  Some preprocessors need to examine the full list of hypotheses instead of working item by item. As with Preprocessor, the input to a GlobalPreprocessor is replaced by, not added to, its output.

                                  • name : String

                                    The name of the global preprocessor, used in trace output.

                                  • Replace the collection of all hypotheses with new hypotheses. These expressions are proof terms.

                                  Instances For

                                    Some preprocessors perform branching case splits. A Branch is used to track one of these case splits. The first component, an MVarId, is the goal corresponding to this branch of the split, given as a metavariable. The List Expr component is the list of hypotheses for linarith in this branch.

                                    Equations
                                    Instances For

                                      Some preprocessors perform branching case splits. A GlobalBranchingPreprocessor produces a list of branches to run. Each branch is independent, so hypotheses that appear in multiple branches should be duplicated. The preprocessor is responsible for making sure that each branch contains the correct goal metavariable.

                                      Instances For

                                        A Preprocessor lifts to a GlobalPreprocessor by folding it over the input list.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For

                                          A GlobalPreprocessor lifts to a GlobalBranchingPreprocessor by producing only one branch.

                                          Equations
                                          • pp.branching = { name := pp.name, transform := fun (g : Lean.MVarId) (l : List Lean.Expr) => do let __do_liftpp.transform l pure [(g, __do_lift)] }
                                          Instances For

                                            process pp l runs pp.transform on l and returns the result, tracing the result if trace.linarith is on.

                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For

                                              A CertificateOracle provides a function produceCertificate : List CompNat → MetaM (HashMap Nat Nat).

                                              The default CertificateOracle used by linarith is Linarith.CertificateOracle.simplexAlgorithmSparse. Linarith.CertificateOracle.simplexAlgorithmDense and Linarith.CertificateOracle.fourierMotzkin are also available (though the Fourier-Motzkin oracle has some bugs).

                                              • produceCertificate : List Linarith.CompLean.MetaM (Std.HashMap )

                                                produceCertificate hyps max_var tries to derive a contradiction from the comparisons in hyps by eliminating all variables ≤ max_var. If successful, it returns a map coeff : NatNat as a certificate. This map represents that we can find a contradiction by taking the sum ∑ (coeff i) * hyps[i].

                                              Instances For

                                                Auxiliary functions #

                                                These functions are used by multiple modules, so we put them here for accessibility.

                                                parseCompAndExpr e checks if e is of the form t < 0, t ≤ 0, or t = 0. If it is, it returns the comparison along with t.

                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For

                                                  mkSingleCompZeroOf c h assumes that h is a proof of t R 0. It produces a pair (R', h'), where h' is a proof of c*t R' 0. Typically R and R' will be the same, except when c = 0, in which case R' is =. If c = 1, h' is the same as h -- specifically, it does not change the type to 1*t R 0.

                                                  Equations
                                                  • One or more equations did not get rendered due to their size.
                                                  Instances For