mathlib documentation

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.

source
meta def linarith.linarith_trace {α : Type u_1} [has_to_tactic_format α] (s : α) :
tactic unit

A shorthand for tracing when the trace.linarith option is set to true.

source
meta def linarith.linarith_trace_proofs (s : string := "") (l : list expr) :
tactic unit

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

Linear expressions #

source
def linarith.linexp  :
Type

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 : ℕ 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
source
meta def linarith.linexp.add  :
linarith.linexp → linarith.linexp → linarith.linexp

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

source
def linarith.linexp.scale (c : ℤ) (l : linarith.linexp) :
linarith.linexp

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

Equations
source
def linarith.linexp.get (n : ℕ) :
linarith.linexp → option ℤ

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
source
def linarith.linexp.contains (n : ℕ) :
linarith.linexp → bool

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

Equations
source
def linarith.linexp.zfind (n : ℕ) (l : linarith.linexp) :
ℤ

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

Equations
source
def linarith.linexp.vars (l : linarith.linexp) :
list ℕ

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

Equations
source
def linarith.linexp.cmp  :
linarith.linexp → linarith.linexp → ordering

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

Equations

Inequalities #

source
inductive linarith.ineq  :
Type

The three-element type ineq is used to represent the strength of a comparison between terms.

source
@[protected, instance]
def linarith.ineq.decidable_eq  :
decidable_eq linarith.ineq
source
@[protected, instance]
def linarith.ineq.inhabited  :
inhabited linarith.ineq
source
def linarith.ineq.max  :
linarith.ineq → linarith.ineq → linarith.ineq

max R1 R2 computes the strength of the sum of two inequalities. If t1 R1 0 and t2 R2 0, then t1 + t2 (max R1 R2) 0.

Equations
source
def linarith.ineq.cmp  :
linarith.ineq → linarith.ineq → ordering

ineq is ordered eq < le < lt.

Equations
source
def linarith.ineq.to_string  :
linarith.ineq → string

Prints an ineq as the corresponding infix symbol.

Equations
source
meta def linarith.ineq.to_const_mul_nm  :
linarith.ineq → name

Finds the name of a multiplicative lemma corresponding to an inequality strength.

source
@[protected, instance]
def linarith.ineq.has_to_string  :
has_to_string linarith.ineq
Equations
source
@[protected, instance]
meta def linarith.ineq.has_to_format  :
has_to_format linarith.ineq

Comparisons with 0 #

source
structure linarith.comp  :
Type

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 (λ ⟨k, v⟩, v * Var[k]). str determines the strength of the comparison -- is it < 0, ≤ 0, or = 0?

source
@[protected, instance]
def linarith.comp.inhabited  :
inhabited linarith.comp
source
def linarith.comp.vars  :
linarith.comp → list ℕ

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

Equations
source
def linarith.comp.coeff_of (c : linarith.comp) (a : ℕ) :
ℤ

comp.coeff_of c a projects the coefficient of variable a out of c.

Equations
source
def linarith.comp.scale (c : linarith.comp) (n : ℕ) :
linarith.comp

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

Equations
source
meta def linarith.comp.add (c1 c2 : linarith.comp) :
linarith.comp

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.

source
meta def linarith.comp.cmp  :
linarith.comp → linarith.comp → ordering

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

source
meta def linarith.comp.is_contr (c : linarith.comp) :
bool

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

source
@[protected, instance]
meta def linarith.comp.to_format  :
has_to_format linarith.comp

Parsing into linear form #

Control #

source
meta structure linarith.preprocessor  :
Type

A preprocessor transforms a proof of a proposition into a proof of a different propositon. 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.

source
meta structure linarith.global_preprocessor  :
Type

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

source
meta def linarith.branch  :
Type

Some preprocessors perform branching case splits. A branch is used to track one of these case splits. The first component, an expr, 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. Every expr in this list should be type correct in the context of the associated goal.

source
meta structure linarith.global_branching_preprocessor  :
Type

Some preprocessors perform branching case splits. A global_branching_preprocessor 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.

source
meta def linarith.preprocessor.globalize (pp : linarith.preprocessor) :
linarith.global_preprocessor

A preprocessor lifts to a global_preprocessor by folding it over the input list.

source
meta def linarith.global_preprocessor.branching (pp : linarith.global_preprocessor) :
linarith.global_branching_preprocessor

A global_preprocessor lifts to a global_branching_preprocessor by producing only one branch.

source
meta def linarith.global_branching_preprocessor.process (pp : linarith.global_branching_preprocessor) (l : list expr) :
tactic (list linarith.branch)

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

source
@[protected, instance]
meta def linarith.preprocessor_to_gb_preprocessor  :
has_coe linarith.preprocessor linarith.global_branching_preprocessor
source
@[protected, instance]
meta def linarith.global_preprocessor_to_gb_preprocessor  :
has_coe linarith.global_preprocessor linarith.global_branching_preprocessor
source
meta def linarith.certificate_oracle  :
Type

A certificate_oracle is a function produce_certificate : list comp → ℕ → tactic (rb_map ℕ ℕ). produce_certificate 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 : ℕ → ℕ as a certificate. This map represents that we can find a contradiction by taking the sum ∑ (coeff i) * hyps[i].

The default certificate_oracle used by linarith is linarith.fourier_motzkin.produce_certificate.

source
meta structure linarith.linarith_config  :
Type

A configuration object for linarith.

source
meta def linarith.linarith_config.update_reducibility (cfg : linarith.linarith_config) (reduce_semi : bool) :
linarith.linarith_config

cfg.update_reducibility reduce_semi will change the transparency setting of cfg to semireducible if reduce_semi is true. In this case, it also sets the discharger to ring!, since this is typically needed when using stronger unification.

Auxiliary functions #

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

source
meta def linarith.get_rel_sides  :
expr → tactic (expr × expr)

get_rel_sides e returns the left and right hand sides of e if e is a comparison, and fails otherwise. This function is more naturally in the option monad, but it is convenient to put in tactic for compositionality.

source
meta def linarith.parse_into_comp_and_expr  :
expr → option (linarith.ineq × expr)

parse_into_comp_and_expr 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.

source
meta def linarith.mk_single_comp_zero_pf (c : ℕ) (h : expr) :
tactic (linarith.ineq × expr)

mk_single_comp_zero_pf 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.