?EH      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !!!""""""""####$%%%%%%%%%%&&&&&&&&&&&&&''(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))** * * * * *******+++,-.////// /!0"1#2$2%2&2'2(2)2*2+2,2-2.2/202122232425262728292:2;2<2=2>2?2@2A2B3C3D3E3F3G3H3I3J3K4L4M4N4O4P4Q4R4S4T4U4V4W4X5Y5Z5[5\5]5^5_5`5a5b5c5d5e5f5g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5w5x5y5z5{6|6}6~6666666677778899999999999::::::::::::;<<<===============>>>>>>>>?????????@@@@AAAAAAAAAABBBBBBBBBBBBBBBCCDEFGGGGGGHHHHHHHHHHIIIIIIIIIIIIIIII I I I I IIIJJJJJJJJJJJKKKLL L!L"L#L$L%L&L'L(L)L*M+M,M-M.M/M0M1M2M3M4M5M6M7M8M9M:M;M<M=M>M?M@NANBNCNDNENFNGNHNINJNKNLNMNNNONPNQNRNSNTNUNVNWNXNYNZN[N\N]O^O_O`OaObOcOdOeOfOgOhOiOjOkOlOmOnOoOpOqPrPsPtPuPvPwPxPyPzP{P|P}P~PPPPQQQQQQQRRRRRRRRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTUVVVWWWWWWWWWWWWWWWWXXYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYZZZZZZZZZZ[ [ [ [ [ [[[\\\\\\\\\]]]^^^^ ^!^"^#_$`%`&a'a(b)b*b+b,b-b.b/b0b1b2b3b4b5b6b7b8b9b:b;b<b=c>c?c@cAcBcCcDcEdFdGdle Safe-Inferred HIJKLMNOPQRSNOPQRS HIJKLMNOPQRS Safe-Inferred(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisional7non-portable (FlexibleInstances, MultiParamTypeClasses) Safe-Inferred246TUVWX     TUVWX(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferred (the block strcuture vector (bLOCKsTRUCT)Constant VectorConstraint Matrices%the number of primal variables (mDim)the number of blocks (nBLOCK)$"Parse a SDPA format (.dat) string.% Parse a SDPA format file (.dat).&+Parse a SDPA sparse format (.dat-s) string.')Parse a SDPA sparse format file (.dat-s).& !"#$%&'YZ[\]^_`abcd()efghi !"#$%&'() "!#()$%&'" !"#$%&'YZ[\]^_`abcd()efghi Safe-Inferred*+*+*+*+(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (FlexibleContexts)None3,j-./0,-./0,-./0,j-./0(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalBnon-portable (BangPatterns, FlexibleContexts, ScopedTypeVariables)None3M6%Get the internal representation arrayB%Get the internal representation arrayC%Get the internal representation arrayD!Pre-allocate internal buffer for n elements.1234k56789:;<=>?@ABCDlm123456789:;<=>?@ABCD43215A6789:;<=>?@BCD1234k56789:;<=>?@ABCDlm(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisional[non-portable (MultiParamTypeClasses, FlexibleInstances, BangPatterns, TypeSynonymInstances)None246; E6Priority queue implemented as array-based binary heap.H7Build a priority queue with default ordering ('(<)' of n class)I$Build a priority queue with a given  less than operator.o$Build a priority queue with a given  less than operator.JCReturn a list of all the elements of a priority queue. (not sorted)K*Remove all elements from a priority queue.L"Create a copy of a priority queue.O:Get the internal representation of a given priority queue.P:Get the internal representation of a given priority queue.Q!Pre-allocate internal buffer for n elements.R!Pre-allocate internal buffer for [0..n-1] values.EpqrsFGHIotJKLMNuvOPQRwxyz{|} EFGHIJKLMNOPQREFGHIJKL  MNOPQREpqrsFGHIotJKLMNuvOPQRwxyz{|} (c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalZnon-portable (MultiParamTypeClasses, FlexibleInstances, BangPatterns, ScopedTypeVariables)None246M S6Priority queue implemented as array-based binary heap.U7Build a priority queue with default ordering ('(<)' of n class)V$Build a priority queue with a given  less than operator.WCReturn a list of all the elements of a priority queue. (not sorted)X*Remove all elements from a priority queue.Y"Create a copy of a priority queue.Z:Get the internal representation of a given priority queue.[:Get the internal representation of a given priority queue.\!Pre-allocate internal buffer for n elements.S~TUVWXYZ[\ STUVWXYZ[\STUVWXY  Z[\S~TUVWXYZ[\f(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (ScopedTypeVariables, FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies, TypeFamilies, BangPatterns, DeriveDataTypeable, CPP)None +2468=KM/_Monic monomialsc Variable "x"e.Univariate polynomials over commutative ring rq(Square-free factorization of polynomialsrfactor a polynomial p into p1 ^ n1 * p2 ^ n2 * .. and return a list [(p1,n1), (p2,n2), ..].s"Prime factorization of polynomialstfactor a polynomial p into p1 ^ n1 * p2 ^ n2 * .. and return a list [(p1,n1), (p2,n2), ..].vContent of a polynomial wPrimitive part of a polynomialx"Polynomial over commutative ring rz"total degree of a given polynomial&construct a polynomial from a constant+construct a polynomial from a list of terms*construct a polynomial from a singlet term list of terms3leading term with respect to a given monomial order:leading coefficient with respect to a given monomial order7leading monomial with respect to a given monomial orderPLook up a coefficient for a given monomial. If no such term exists, it returns 0.PLook up a coefficient for a given monomial. If no such term exists, it returns Nothing.Ya polynomial is called primitive if the greatest common divisor of its coefficients is 1. Formal derivative of polynomialsFormal integral of polynomials EvaluationSubstitution or bind"Transform polynomial coefficients.XTransform a polynomial into a monic polynomial with respect to the given monomial order.Convert  K[x,x1,x2, &] into  K[x1,x2, &][x].Multivariate division algorithmdivModMP cmp f [g1,g2,..] returns a pair  ([q1,q2, &],r) such thatf = g1*q1 + g2*q2 + .. + r and g1, g2, .. do not divide r.Multivariate division algorithm )reduce cmp f gs = snd (divModMP cmp f gs)Natural ordering x^0 < x^1 < x^2 ..: is the unique monomial order for univariate polynomials."division of univariate polynomials"division of univariate polynomials"division of univariate polynomialsGCD of univariate polynomialsLCM of univariate polynomialsExtended GCD algorithmpseudo divisionpseudo quotientpseudo reminderGCD of univariate polynomials'Is the number a root of the polynomial?Is the polynomial square free?Lexicographic orderReverse lexicographic order.Note that revlex is NOT a monomial order.Graded lexicographic order"Graded reverse lexicographic order]^_`abcdefghijklmnopqrstuvwxyz{|}~_]^_`abcdefghijklmnopqrstuvwxyz{|}~{]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) Masahiro Sakai 2013-2014 BSD-stylemasahiro.sakai@gmail.com provisional0non-portable (ScopedTypeVariables, BangPatterns)NoneMg(c) Masahiro Sakai 2013-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone (c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com provisionalDnon-portable (BangPatterns, TypeSynonymInstances, FlexibleInstances)None24USquare-free decomposition of univariate polynomials over a field of characteristic 0. (c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (BangPatterns) Safe-Inferred allocate too many intermediate . Therefore we use this optimized implementation instead. Many intermediate values in this implementation will be optimized away by worker-wrapper transformation and unboxing.(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone&SOS (special ordered sets) constraints/types of SOS (special ordered sets) constraintsType 2 SOS constraintType 1 SOS constraintrelational operators4type for representing lower/upper bound of variablesvariablelabel4type for representing lower/upper bound of variables constraintobjective functionterms expressionsProblemdefault boundsdefault lower bound (0)default upper bound (+") convert a string into a variable convert a variable into a string$looking up attributes for a variable looking up bounds for a variable looking up bounds for a variableEAA'(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (TypeFamilies)None=KwParse a string containing MPS file data. The source name is only | used in error messages and may be the empty string.&Parse a file containing MPS file data.MPS file parser;0 (c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferred&Lifted Bool type. It has three values , , .lifted true valuelifted false valueundefined truth value F lnot lTrue == lFalse lnot lFalse == lTrue lnot lUndef == lUndef  4 liftBool True == lTrue liftBool False == lFalse  a unliftBool lTrue == Just True unliftBool lFalse == Just False unliftBool lUndef == Nothing (c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone    (c) Masahiro Sakai 2013-2014 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone         Safe-Inferred24M  XOR clause.'([l1,l2..ln], b)' means l1 " l2 " " " ln = b. Note that:&True can be represented as ([], False)&False can be represented as ([], True)Disjunction of .kPositive (resp. negative) literals are represented as positive (resp. negative) integers. (DIMACS format).AA model is represented as a mapping from variables to its values.=Variable is represented as positive integers (DIMACS format).7Construct a literal from a variable and its polarity.   (resp  *) means positive (resp. negative) literal. Negation of the .!Underlying variable of the "Polarity of the .   means positive literal and   means negative literal.$Normalizing clause ! if the clause is trivially true., normalizing PB term of the form c1 x1 + c2 x2 ... cn xn + c into d1 x1 + d2 x2 ... dm xm + d where d1,...,dm "e 1.-&normalizing PB constraint of the form c1 x1 + c2 cn ... cn xn >= b..&normalizing PB constraint of the form c1 x1 + c2 cn ... cn xn = b.:Normalize XOR clause4  variablepolarity !"#$%&'()*+,-./0123456789:;<  1   !"#$%&'()*+,-./0123456789:;<1 !"#$%&'()*+ ,-./0123456789 :;<3   !"#$%&'()*+,-./0123456789:;<  (c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone==== Safe-Inferred>?@ABCDE>?@ABCDE>?@ABCDE>?@ABCDE(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredF!Maximal Satisfiable Subset (MSS).~A subset S " C is an MSS if S is satisfiable and "C_i " U\S, S"*{C_i} is unsatisfiable [CAMUS]. A MSS is the complement of an H.GSatisfiable Subset (SS).IA subset S " C is a SS if S is satisfiable. A SS is the complement of a I.H/Minimal Correction Subset of constraints (MCS).A subset M " C is an MCS if C\M is satisfiable and "C_i " M, C\(M\{C_i}) is unsatisfiable [CAMUS]. A MCS is the complement of an F and also known as a CoMSS.I&Correction Subset of constraints (CS).KA subset M " C is a CS if C\M is satisfiable. A CS is the complement of a G.J2Minimal Unsatisfiable Subset of constraints (MUS).]A subset U " C is an MUS if U is unsatisfiable and "C_i " U, U\{C_i} is satisfiable [CAMUS]. K)Unsatisfiable Subset of constraints (US)./A subset U " C is an US if U is unsatisfiable. FGHIJKFGHIJKKJIHGFFGHIJK Safe-Inferred$LMNOPQRSTUVWXYZ[\]^_`aLMNOPQRSTUVWXYZ[\]^_`aNOPQRSTUVWXYZ[\M]^_`LaLMNOPQRSTUVWXYZ[\]^_`a(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredbPrint a . in a way specified for SAT Competition. See  ,http://www.satcompetition.org/2011/rules.pdf for details.cPrint a 1 in a way specified for Max-SAT Evaluation. See  &http://maxsat.ia.udl.cat/requirements/ for details.dPrint a 9 in a way specified for Pseudo-Boolean Competition. See  .http://www.cril.univ-artois.fr/PB12/format.pdf for details.bcdebcdebcdebcde(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferredfghijklmno ! fghijklmno hijklmgfno fghijklmno !(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredpBWeigths must be greater than or equal to 1, and smaller than 2^63.pqrstuvwxy"#$z%&'() pqrstuvwxyz rstuvwqpxyzpqrstuvwxy"#$z%&'()(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone{{{{(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone||||(c) Masahiro Sakai 2011-2012 BSD-stylemasahiro.sakai@gmail.com experimentalportable Safe-Inferred}~}~}~}~(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone*}~}~* (c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferred+,+,!(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredM"(c) Masahiro Sakai 2015 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferred -xhi n ** xhi n == n.Find xs such that xs  (f,g) unless / f g. F tests whether F contains redundant implicants..Removes redundant implicants from a given DNF.occurFreq x F computes |{I"F | x"I}| / |F|areDualDNFs f g/ checks whether two monotone boolean functions f and g are mutually dual (i.e. f(x1, &,xn) = g(x1, &,xn)).?Note that this function does not care about redundancy of DNFs. Complexity:  O(n^o(log n)) where n = 0 f + 0 g. Synonym for .checkDualityA f g/ checks whether two monotone boolean functions f and g are mutually dual (i.e.L f(x1, &,xn) = g(x1, &,xn)) using Algorithm A  of [FredmanKhachiyan1996].,If they are indeed mutually dual it returns Nothing, otherwise it returns Just csi such that {xi ! (if xi"cs then True else False) | i"{1 &n}} is a solution of f(x1, &,xn) = g(x1, &,xn)).?Note that this function does not care about redundancy of DNFs. Complexity: O(n^O(log^2 n)) where n = 0 f + 0 g.checkDualityB f g/ checks whether two monotone boolean functions f and gc are mutually dual (i.e. f(x1, &,xn) = g(x1, &,xn)) using Algorithm B  of [FredmanKhachiyan1996].,If they are indeed mutually dual it returns Nothing, otherwise it returns Just csh such that {xi ! (if xi"cs then True else False) | i"{1 &n}} is a solution of f(x1, &,xn) = g(x1, &,xn)).?Note that this function does not care about redundancy of DNFs. Complexity:  O(n^o(log n)) where n = 1 f + 1 g.$-234567/.89:;<= a variable xa DNF Fa monotone boolean function f given in DNFa monotone boolean function g given in DNFa monotone boolean function f given in DNFa monotone boolean function g given in DNF>?a monotone boolean function f given in DNFa monotone boolean function f given in DNF@ABCDEFGHIJ$-234567/.89:;<=>?@ABCDEFGHIJ#(c) Masahiro Sakai 2015 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferred(Find a new prime implicant or implicate.Let f6 be a monotone boolean function over set of variables SZ. Let "'_{I"C} "(_{i"I} x_i and "(_{I"D} "'_{i"I} x_i be the irredundant CNF representation f and DNF representation of f respectively.Given a subset C' " C and D' " D,  S f C' D' returns Just (Left I) where I " C \ C',Just (Right I) where J " D \ D', orNothing if C'=C and D'=D.BCompute the irredundant CNF representation and DNF representation.Let f6 be a monotone boolean function over set of variables S. This function returns C and D[ where "'_{I"C} "(_{i"I} x_i and "(_{I"D} "'_{i"I} x_i are the irredundant CNF representation f and DNF representation of f respectively.Set of variables VA monotone boolean function f from {0,1}^|V| "E P(V) to BoolSubset C' of prime implicates C of fSubset D' of prime implicants D of fKSet of variables VA monotone boolean function f from {0,1}^|V| "E P(V) to BoolSubset C' of prime implicates C of fSubset D' of prime implicants D of fLMSet of variables VA monotone boolean function f from {0,1}^|V| "E P(V) to BoolSubset C' of prime implicates C of fSubset D' of prime implicants D of fNOPQRSTUVKLMNOPQRSTUV$(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (CPP) Safe-Inferred Filename of the executable (see W for details) any argumentsstandard inputAcallback function which is called when a line is read from stdoutAcallback function which is called when a line is read from stderrXYXY%(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisional!non-portable (DeriveDataTypeable) Safe-Inferred+ Z[\  Z[\&(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisional!non-portable (DeriveDataTypeable) Safe-Inferred+]^_`   ]^_`'(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredMabcdabcd((c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalVnon-portable (BangPatterns, ScopedTypeVariables, CPP, DeriveDataTypeable, RecursiveDo)None+;CMFeAinvoked with the watched literal when the literal is falsified. watch 0g  toConstraint+ 0T|0sQ0W0f heap allocation 0Lvzu0Y00n0 0Q00_00k0QC0n f 0n!0W0f0J0O0gdeduce a clause C"(l from the constraint and return C. C and l should be false and true respectively under the current assignment.Solver instancehAInverse of the variable activity decay factor. (default 1 / 0.95)i"Amount to bump next variable with.j<Inverse of the constraint activity decay factor. (1 / 0.999)k$Amount to bump next constraint with.l(The initial restart limit. (default 100)mTThe factor with which the restart limit is multiplied in each restart. (default 1.5)n)The initial limit for learnt constraints.o[The limit for learnt constraints is multiplied with this factor periodically. (default 1.1)pHControls conflict constraint minimization (0=none, 1=local, 2=recursive)q.will be invoked when this literal is falsifiedr2will be invoked once when the variable is assignedsFRegister the constraint to be notified when the literal becames false.tERegister the constraint to be notified when the variable is assigned.u:Returns list of constraints that are watching the literal.#number of variables of the problem.#number of variables of the problem.vnumber of assigned number of assigned variables.number of constraints.number of constraints.number of learnt constrints.number of learnt constrints.Create a new Solver instance.Add a new variableAdd variables. /newVars solver n = replicateM n (newVar solver)Add variables. 1newVars_ solver n = newVars solver n >> return ()!Pre-allocate internal buffer for n variables.Add a clause to the solver.Add a cardinality constraints atleast({l1,l2,..},n).Add a cardinality constraints atmost({l1,l2,..},n).Add a cardinality constraints exactly({l1,l2,..},n).!Add a pseudo boolean constraints c1*l1 + c2*l2 + & "e n.wSee documentation of .!Add a pseudo boolean constraints c1*l1 + c2*l2 + & "d n.!Add a pseudo boolean constraints c1*l1 + c2*l2 + & = n.&Add a soft pseudo boolean constraints sel ! c1*l1 + c2*l2 + & "e n.&Add a soft pseudo boolean constraints sel ! c1*l1 + c2*l2 + & "d n.&Add a soft pseudo boolean constraints sel ! c1*l1 + c2*l2 + & = n.Add a parity constraint l1 " l2 " & " ln = rhsAdd a soft parity constraint sel ! l1 " l2 " & " ln = rhsSolve constraints. Returns  ) if the problem is SATISFIABLE. Returns  ! if the problem is UNSATISFIABLE.-Solve constraints under assuptions. Returns  ) if the problem is SATISFIABLE. Returns  ! if the problem is UNSATISFIABLE.After 3 returns True, it returns an satisfying assignment.After  returns False, it returns a set of assumptions that leads to contradiction. In particular, if it returns an empty set, the problem is unsatisiable without any assumptions.xNSimplify the constraint database according to the current top-level assigment.default value for RestartStrategy._The initial restart limit. (default 100) Zero and negative values are used to disable restart.default value for  RestartFirst.TThe factor with which the restart limit is multiplied in each restart. (default 1.5) This must be >1.default value for  RestartInc.%The initial limit for learnt clauses.CNegative value means computing default value from problem instance.default value for LearntSizeFirst.WThe limit for learnt clauses is multiplied with this factor each restart. (default 1.1) This must be >1.default value for  LearntSizeInc.?Controls conflict clause minimization (0=none, 1=basic, 2=deep)default value for CCMin.#The default polarity of a variable.QThe frequency with which the decision heuristic tries to choose a random variable:Set random generator used by the random variable selection:Get random generator used by the random variable selection6Split PB-constraints into a PB part and a clause part.Example from minisat+ paper:-4 x1 + 4 x2 + 4 x3 + 4 x4 + 2y1 + y2 + y3 "e 4would be split into(x1 + x2 + x3 + x4 + z "e 1 (clause part)"2 y1 + y2 + y3 + 4 z "e 4 (PB part)Lwhere z is a newly introduced variable, not present in any other constraint. Reference:^N . Een and N. Srensson. Translating Pseudo-Boolean Constraints into SAT. JSAT 2:1 26, 2006.See documentation of .See documentation of .y?Revert to the state at given level (keeping all assignment at level but not beyond).z?invoked with the watched literal when the literal is falsified.{deduce a clause C"(l from the constraint and return C. C and l should be false and true respectively under the current assignment.-set callback function for receiving messages.V|}~feghijklmnopqrstu  v  The  argument.set of literals  {l1,l2,..}" (duplicated elements are ignored)n.The  argumentset of literals  {l1,l2,..}" (duplicated elements are ignored)nThe  argumentset of literals  {l1,l2,..}" (duplicated elements are ignored)nThe  argument. set of terms [(c1,l1),(c2,l2), &]nwThe  argument.list of [(c1,l1),(c2,l2), &]nThe  argument.list of terms [(c1,l1),(c2,l2), &]nThe  argument.Selector literal sel set of terms [(c1,l1),(c2,l2), &]nThe  argument.Selector literal sel set of terms [(c1,l1),(c2,l2), &]nThe  argument.Selector literal sel set of terms [(c1,l1),(c2,l2), &]nThe  argument. literals [l1, l2, &, ln]rhsThe  argument.Selector literal sel literals [l1, l2, &, ln]rhs Assumptions x !"y#$%&'()*+,z{-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghZ !"Z !"|}~feg.hijklmnopq rstu  v  w x !"y#$%&'()*+,z{-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh)(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisional non-portableNone Options for  functiondefault  valuedFind a minimal set of assumptions that causes a conflict. Initial set of assumptions is taken from .i FGHIJKi*(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone Options for , , `MCS candidates (see HYCAM paper for details). A MCS candidate must be a superset of a real MCS.default  value     jFGHIJK                j+(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNoneFGHIJK           ,(c) Masahiro Sakai 2015 BSD-stylemasahiro.sakai@gmail.com provisional non-portableNonedFind a minimal set of assumptions that causes a conflict. Initial set of assumptions is taken from . FGHIJK-(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNonekk.(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone lmnopqrslmnopqrs/(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNonet"The smallest integer greater than n- that can be obtained by summing a subset of ws.uvwx yt ws nz  uvwx ytz0(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (BangPatterns)None!{!!!{1(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone"|"""|2(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone*#}~$%&'()*+,-./0123456789:;<=>?@A#$%&'()*+,-./0123456789:;<=>?@A#./;<=>?@A$,+*)('&%-0123456789:#}~$,+*)('&%-./0123456789:;<=>?@A3(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredBCDEFGHIJ BCDEFGHIJ BFCEDGHIJBCEDFGHIJ4(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredK3types that can be combined with boolean operations.Otypes that can be negated.KLMNOPQRSTUVW KLMNOPQRSTUVW QRSTUVWOPKLMN KLMNOPQRSTUVWLMTU5(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalKnon-portable (TypeSynonymInstances, FlexibleInstances, ScopedTypeVariables)None24M ]Element of model. Shallow atom Shallow termnTermq3Generalized literal type parameterized by atom typetPredicate SymboluFunction SymbolvVariablew.normalize a formula into a skolem normal form.TODO:Tseitin encodingx print entityLXYZ[\]^_`abcdefghijklmnopqrstuvwxyz#XYZ[\]^_`abcdefghijklmnopqrstuvwxyz#vutqsrnpolmkji^hgfedcba`_wXYZ[\]yxz4XYZ[\]^ hgfedcba`_ijklmnpoqsrtuvwxyz6(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisional"non-portable (ScopedTypeVariables)NoneM|$sugar strategy (not implemented yet){|}~ {|}~ ~{}| {}|~7(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalYnon-portable (ScopedTypeVariables, BangPatterns, TypeSynonymInstances, FlexibleInstances)None24MHSquare-free decomposition of univariate polynomials over a finite field.1Berlekamp algorithm for polynomial factorization.8Input polynomial is assumed to be monic and square-free.8(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisional0non-portable (BangPatterns, ScopedTypeVariables)NoneMf|^2h(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisional6non-portable (TypeSynonymInstances, FlexibleInstances)None24iNone24 (c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone_]^_`abcdefghijklmnopqrstuvwxyz{|}~axy~yz{|}stqruvwecda^b_``]klmnophijfg9(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (Rank2Types)NoneHM    :(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone Sturm's chain (Sturm's sequence) Sturm's sequence of a polynomial%The number of distinct real roots of p in a given interval%The number of distinct real roots of p+ in a given interval. This function takes p's sturm chain instead of p itself.KClosed interval that contains all real roots of a given polynomial. h90nPuL =http://aozoragakuen.sakura.ne.jp/taiwa/taiwaNch02/node26.htmlYDisjoint intervals each of which contains exactly one real roots of the given polynoimal p,. The intervals can be further narrowed by  or .YDisjoint intervals each of which contains exactly one real roots of the given polynoimal p,. The intervals can be further narrowed by  or . This function takes p's sturm chain instead of p itself.  ;Nonej(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone<(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredDisjunctive normal formlist of conjunction of literals=(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (Rank2Types)NoneHMAlgebraic real numbers.0Real roots of the polynomial in ascending order.0Real roots of the polynomial in ascending order.-Returns approximate rational value such that %abs (a - approx a epsilon) <= epsilon.'Returns approximate interval such that +width (approxInterval a epsilon) <= epsilon.Same as .Same as .Same as .Same as .Same as .The n th root of a9Same algebraic real, but represented using finer grained .5The polynomial of which the algebraic number is root.@Isolating interval that separate the number from other roots of  of it.+Whether the algebraic number is a rational.kWhether the algebraic number is a root of a polynomial with integer coefficients with leading coefficient 1 (a monic polynomial).Height of the algebraic number.The height of an algebraic number is the greatest absolute value of the coefficients of the irreducible and primitive polynomial with integral rational coefficients.root index, satisfying  ( a) !! rootIndex a == a  Golden ratio Degree of the algebraic number.If the algebraic number's  has degree n2, then the algebraic number is said to be degree n.&aepsilonaepsilon%>(c) Masahiro Sakai 2011-2012 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredCombining two Maybe values using given function.is the number integral? , isInteger x = fromInteger (round x) == x fractional part ) fracPart x = x - fromInteger (floor x) ?(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (TypeFamilies)None=K Delta r k: represents r + k for symbolic infinitesimal parameter .#symbolic infinitesimal parameter .Conversion from a base r value to Delta r.Extracts the real part..Extracts the  part.. version of .  x/ returns the greatest integer not greater than x version of .  x) returns the least integer not less than xIs this a integer?       @(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNonevParse a string containing LP file data. The source name is only | used in error messages and may be the empty string.%Parse a file containing LP file data.LP file parserRender a problem into a string.8    !"#$%&'()*+,-./0123456789:;<=>8    !"#$%&'()*+,-./0123456789:;<=>A(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone.Parse .lp or .mps file based on file extension%Parse a file containing LP file data.&Parse a file containing MPS file data.'Parse a string containing LP file data.(Parse a string containing MPS file data. K  B(c) Masahiro Sakai 2012-2014 BSD-stylemasahiro.sakai@gmail.com experimentalportableNone(?@ABCDEFGHIJKLMNOPQRSTUVW?@ABCDEFGHIJKLMNOPQRSTUVWC(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com experimentalportableNoneXYZ[\XYZ[\D(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com experimentalportableNoneE(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com experimentalportableNoneF(c) Masahiro Sakai 2012-2013 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (BangPatterns)None ]^_`abcde ]^_`abcdeG(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-InferredA Model# is a map from variables to values.collecting free variablesMap from variablesSet of variables2Variables are represented as non-negative integersffH(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone+-Boolean expression over a given type of atomsghijklmnopqrstuvwxy  ghijklmnopqrstuvwxyI(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone Encoder instance'Arbitrary formula not restricted to CNF Create a Encoder instance.Use pseudo boolean constraints or use only clauses.KAssert a given formula to underlying SAT solver by using Tseitin encoding.=Return an literal which is equivalent to a given conjunction.  encodeConj encoder =  encoder  eReturn an literal which is equivalent to a given conjunction which occurs only in specified polarity.=Return an literal which is equivalent to a given disjunction.  encodeDisj encoder =  encoder  eReturn an literal which is equivalent to a given disjunction which occurs only in specified polarity.>Return an literal which is equivalent to a given if-then-else.  encodeITE encoder =   encoder   fReturn an literal which is equivalent to a given if-then-else which occurs only in specified polarity.z{|}~               z{|}~     J(c) Masahiro Sakai 2015 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone,Add a non-linear pseudo boolean constraints c1*ls1 + c2*ls2 + & "e n.,Add a non-linear pseudo boolean constraints c1*ls1 + c2*ls2 + & "e n.,Add a non-linear pseudo boolean constraints c1*ls1 + c2*ls2 + & = n.1Add a soft non-linear pseudo boolean constraints sel ! c1*ls1 + c2*ls2 + & "e n.1Add a soft non-linear pseudo boolean constraints sel ! c1*ls1 + c2*ls2 + & "d n.1Add a soft non-linear pseudo boolean constraints lit ! c1*ls1 + c2*ls2 + & = n.Encode a non-linear  into a lienar .linearizePBSum enc s is equivalent to +linearizePBSumWithPolarity enc polarityBoth.Linearize a non-linear  into a lienar . The input 0 is assumed to occur only in specified polarity.If  p, the value of resulting  is  greater than or equal to the value of original .If  p, the value of resulting  is  lesser than or equal to the value of original .  [(c1,ls1),(c2,ls2), &]n [(c1,ls1),(c2,ls2), &]n [(c1,ls1),(c2,ls2), &]nSelector literal sel [(c1,ls1),(c2,ls2), &]nSelector literal sel [(c1,ls1),(c2,ls2), &]n indicator lit [(c1,ls1),(c2,ls2), &]n   KNoneL(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportable Safe-Inferredformulas of first order logic)+convert a formula into negation normal form !"#$%&'()KLMNOPQRSTUVW !"#$%&'() ('&%$#"! ) ('&%$#"! )M(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisionalOnon-portable (FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies) Safe-Inferred2468 *Atomic formula,.type class for constructing relational formula.relational operators5flipping relational operatorrel (flipOp op) a b is equivalent to  rel op b a6negating relational operatorrel (negOp op) a b is equivalent to notB (rel op a b)7operator symbol80evaluate an operator into a comparision function9constructing relational formula:constructing relational formula;constructing relational formula<constructing relational formula=constructing relational formula>constructing relational formula*+,-./0123456789:;<=>?*+,-./0123456789:;<=>?.43210/5678*+?,-9:<;=>*+,-.43210/56789:;<=>?9:;<=>N(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisionalnon-portable (TypeFamilies)None=KA$Atomic Formula of Linear ArithmeticsBnLinear combination of variables and constants. Non-negative keys are used for variables's coefficients. key G is used for constants.C(a mapping from variables to coefficientsD Create a Expr/ from a mapping from variables to coefficients.E"terms contained in the expression.F Create a Expr from a list of terms.G6Special variable that should always be evaluated to 1.IvariableJconstantKmap coefficients.Lmap coefficients.M(evaluate the expression under the model.N(evaluate the expression under the model.QapplySubst1 x e e1 == e1[e/x]R'lookup a coefficient of the variable. $ coeff v e == fst (extract v e) S2lookup a coefficient of the variable. It returns Nothing$ if the expression does not contain v. 4 lookupCoeff v e == fmap fst (extractMaybe v e) T extract v e returns (c, e') such that e == c *^ v ^+^ e'UextractMaybe v e returns  Just (c, e') such that e == c *^ v ^+^ e' if e contains v, and returns Nothing otherwise.X%evaluate the formula under the model.ZapplySubst1 x e phi == phi[e/x][1Solve linear (in)equation for the given variable. solveFor a v returns  Just (op, e) such that  Atom v op e is equivalent to a.\compute bounds for a Expr with respect to  BoundsEnv.'@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\3*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\BCIJEFCDGHRSTUKLMNOPQVAWXYZ[@\%@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\O(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional"non-portable (ScopedTypeVariables)NoneM^Non-basic variables_Basic variablesdLookup a row by basic variable$]^_`abcdefghijklmnop]^_`abcdefghijklmnop`_^]abcdefghjklmnoip]^_`abcdefghijklmnopP(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisional0non-portable (ScopedTypeVariables, BangPatterns)NoneMBqrstuvwxyz{|}~qrstuvwxyz{|}~uxwvrts}y~qz{|=qrtsuxwvyz{|}~Q(c) Masahiro Sakai 2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone&Complex numbers are an algebraic type.For a complex number z,  z# is a number with the magnitude of z8, but oriented in the positive real direction, whereas  z has the phase of z, but unit magnitude.+Extracts the real part of a complex number.0Extracts the imaginary part of a complex number."The conjugate of a complex number..The nonnegative magnitude of a complex number.5The polynomial of which the algebraic number is root.Roots of the polynomialR(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisional7non-portable (FlexibleInstances, MultiParamTypeClasses) Safe-Inferred246"results of satisfiability checkingAtomic formulaArithmetic expressionssingle variable expression evaluate an  with respect to a =KLMNOPQRSTUVW !"#$%&'()*+,-./0123456789:;<=>? SNoneT(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone Atomic constrainte = 0e > 0e "e 0'(t,c) represents t/c, and c must be >0.Simplify conjunction of s. It returns  " when a inconsistency is detected. x  returns ![(_1, lift_1), &, (_m, lift_m)] such that:+"_LRA "y1, &, yn. ("x. ) ! (_1 "( & "( _m) where {y1, &, yn} = FV() \ {x}, andif  M "_LRA _i then lift_i M "_LRA . {x1, &,xm}  returns ![(_1, lift_1), &, (_n, lift_n)] such that:+"_LRA "y1, &, yp. ("x. ) ! (_1 "( & "( _n) where {y1, &, yp} = FV() \ {x1, &,xm}, andif  M "_LRA _i then lift_i M "_LRA . {x1, &,xn}  returns Just M that  M "_LRA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}."U(c) Masahiro Sakai 2014-2015 BSD-stylemasahiro.sakai@gmail.com provisionalportableNoneoptimize dir obj  returns  (I, lift) whereI' is convex hull of feasible region, andlift is a function, that takes x " I8 and returns the feasible solution with objective value better than or equal to x.Note: i (resp.  iD) is the optimal value in case of minimization (resp. maximization).If I* is empty, then the problem is INFEASIBLE.VNone {x1, &,xm}  returns Sat M such that  M "_LRA  when such M exists,returns Unsat when such M does not exists, andreturns Unknown when  is beyond LRA.EEliminate quantifiers and returns equivalent quantifier-free formula.  returns  (, lift) such that:# is a quantifier-free formula and LRA " "y1, &, yn.  !  where {y1, &, yn} = FV() " FV(), andif  M "_LRA  then lift M "_LRA .% may or may not be a closed formula.k(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone  W(c) Masahiro Sakai 2011-2014 BSD-stylemasahiro.sakai@gmail.com provisional7non-portable (MultiParamTypeClasses, FlexibleInstances)None2461Quantifier-free formula of Presburger arithmetic."Literals of Presburger arithmetic.Divisible True d e means e can be divided by d (i.e. d | e)Divisible False d e means e can not be divided by d (i.e. (d | e))IsPos e means e > 0'(t,c) represents t/c, and c must be >0.+Linear arithmetic expression over integers.d | e means e can be divided by d. M  returns whether  M "_LIA  or not. x  returns  (, lift) such that:"_LIA "y1, &, yn. ("x. ) !  where {y1, &, yn} = FV() \ {x}, andif  M "_LIA  then lift M "_LIA . {x1, &,xm}  returns  (, lift) such that:%"_LIA "y1, &, yn. ("x1, &, xm. ) !  where {y1, &, yn} = FV() \ {x1, &,xm}, andif  M "_LIA  then lift M "_LIA . x  returns ![(_1, lift_1), &, (_m, lift_m)] such that:+"_LIA "y1, &, yn. ("x. ) ! (_1 "( & "( _m) where {y1, &, yn} = FV() \ {x}, andif  M "_LIA _i then lift_i M "_LIA . {x1, &,xm}  returns ![(_1, lift_1), &, (_n, lift_n)] such that:+"_LIA "y1, &, yp. ("x. ) ! (_1 "( & "( _n) where {y1, &, yp} = FV() \ {x1, &,xm}, andif  M "_LIA _i then lift_i M "_LIA . {x1, &,xn}  returns Just M that  M "_LIA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}. {x1, &,xn}  returns Just M that  M "_LIA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}. {x1, &,xn}  I returns Just M that  M "_LIRA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}.I7 is a set of integer variables and must be a subset of  {x1, &,xn}.)     #     X(c) Masahiro Sakai 2011-2013 BSD-stylemasahiro.sakai@gmail.com provisionalportableNoneEEliminate quantifiers and returns equivalent quantifier-free formula.  returns  (, lift) such that:# is a quantifier-free formula and LIA " "y1, &, yn.  !  where {y1, &, yn} = FV() " FV(), andif  M "_LIA  then lift M "_LIA .% may or may not be a closed formula.  {x1, &,xm} returns Sat M such that  M "_LIA  when such M exists,returns Unsat when such M does not exists, andreturns Unknown when  is beyond LIA.l(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional non-portable (FlexibleInstances)NoneY(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalInon-portable (TypeSynonymInstances, FlexibleInstances, TypeFamilies, CPP)None24=Kresults of optimization0feasibility 0O0a0d0d non-basic variable xj 0nP$0Y'0M0O0Y00feasibility 0O0a0d0d non-basic variable xj 0nP$0\0U0O0Y0-set callback function for receiving messages.p !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHG./012349:;<=AG.43210/:<=9;AU  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHZ(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisional.non-portable (ScopedTypeVariables, Rank2Types)NoneHM-set callback function for receiving messages.IJKLMNOPQRSTUVWXYZ[\]  IJKLMNOPQRSTUVWXYZ[\][(c) Masahiro Sakai 2014 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone Quantifier-free formula of LRA   M  returns whether  M "_LRA  or not.   x  returns  (, lift) such that:"_LRA "y1, &, yn. ("x. ) !  where {y1, &, yn} = FV() \ {x}, andif  M "_LRA  then  lift M " .   {x1, &,xm}  returns  (, lift) such that:%"_LRA "y1, &, yn. ("x1, &, xm. ) !  where {y1, &, yn} = FV() \ {x1, &,xm}, andif  M "_LRA  then lift M "_LRA .   x  returns ![(_1, lift_1), &, (_m, lift_m)] such that:+"_LRA "y1, &, yn. ("x. ) ! (_1 "( & "( _m) where {y1, &, yn} = FV() \ {x}, andif  M "_LRA _i then lift_i M "_LRA .^  x  returns ![(_1, lift_1), &, (_m, lift_m)] such that:+"_LRA "y1, &, yn. ("x. ) ! (_1 "( & "( _m) where {y1, &, yn} = FV() \ {x}, andif  M "_LRA _i then lift_i M "_LRA . Note that ("x. (x)) ! "(_{t"S} (t) where  = {a_i x - b_i _i 0 | i " I, _i " {=, "`, "d, <}} the set of atomic subformulas in (x) S = { b_i / a_i, b_i / a_i + 1, b_i / a_i - 1 | i"I } "* {1/2 (b_i / a_i + b_j / a_j) | i,j"I, i"`j}   {x1, &,xm}  returns ![(_1, lift_1), &, (_n, lift_n)] such that:+"_LRA "y1, &, yp. ("x. ) ! (_1 "( & "( _n) where {y1, &, yp} = FV() \ {x1, &,xm}, andif  M "_LRA _i then lift_i M "_LRA . {x1, &,xn}  returns Just M such that  M "_LRA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}. {x1, &,xn}  returns Just M such that  M "_LRA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}.    ^ _`abc              ^ _`abc\(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisionalportableNoned'(t,c) represents t/c, and c must be >0.eAtomic constraintfe = 0ge "e 0EoptCheckReal is used for checking whether real shadow is satisfiable.If it returns True0, the real shadow may or may not be satisfiable.If it returns False', the real shadow must be unsatisfiable opt {x1, &,xn}  returns Just M that  M "_LIA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}. {x1, &,xn}  I returns Just M that  M "_LIRA  when such M exists, returns Nothing otherwise.FV() must be a subset of  {x1, &,xn}.I7 is a set of integer variables and must be a subset of  {x1, &,xn}.(hidefgjklmnopqrstuvwxyz{|}~  $hidegfjklmnopqrstuvwxyz{|}~](c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone  ^None=K  !" !" !"  !"_(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional0non-portable (ScopedTypeVariables, BangPatterns)NoneM#5tightening variable bounds by constraint propagation.Gtightening intervals by ceiling lower bounds and flooring upper bounds.#initial bounds constraintsintegral variableslimit of iterations@\#@#\#`None$%$%$%$%a(c) Masahiro Sakai 2012 BSD-stylemasahiro.sakai@gmail.com provisionalportableNone&'&'&'&'b(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional"non-portable (ScopedTypeVariables)NoneM(results of optimization/Allocate a new  non-negative variable.3eAdd a contraint and maintain feasibility condition by introducing artificial variable (if necessary).Disequality is not supported.Unlike 4F, an equality contstraint becomes one row with an artificial variable.4FAdd a contraint, without maintaining feasibilty condition of tableaus.Disequality is not supported.Unlike 3*, an equality constraint becomes two rows.()*+,-./0123456789:;<()*+,-./0123456789:;<-.,01/4352789(+*):;6<(+*),-./0123456789:;<c(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional"non-portable (ScopedTypeVariables)NoneM=results of optimization=>?@ABCD=>?@ABCD=@?>BADC=@?>ABCDd(c) Masahiro Sakai 2011 BSD-stylemasahiro.sakai@gmail.com provisional"non-portable (ScopedTypeVariables)NoneMEFG =>?@EFG=@?>FEGEFGmnomnpmnqrstrsursvrswxyzxy{xy|xy}xy~xyxyxyxyxye   fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff f f f f ffffffffffffff      !"##$%&'()*+,-./011234567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]]]]^_`abcdefghijklmnopqrstuvwxyz{|}~]STTS]]   !!!""""""""####$%%%%%%%%%%&&&&&&&&&&&&&''(((((((((((((((((((((((((((((((((((((((((((( ( ( ( ( ((((((((((((((((((( (!("(#($(%(&('((()(*(+(,(-(.()))/)0)1))2***/*3*4*5*6*7**8*9*:*;+9+:+<,2-.///=/>/?//012@2A2B2C2D2E2F2G2H2I2J2K2L2M2N2O2P2Q2R2S2T222222222233U3V3W3333X3Y4Z4[4\4]4^4_4`4a4b4c4d4e4f555g5h5i5j5k5l5m5n5o5p5q5r5s5t5u5v5e5h5s5w55x5y5z5{5|5}5~555556666666666677778899999999999::::::::::::;<<<===============>>>>>>>>?????????@S@T@U@AAAAAAAAAABBBBBBBBBBBBBBB]C]C^D]E]FGG"GGkGlGHHHnHoHpHqHrHsHHIIIIIIIvIIIIIIIIIIIIIIIIJJJJJJJJJJJKKvKLvLlLmLnLoLpLqLrLsLtLuLMMMMM*MM+MM,M-MMMMMMMMMM M M N NsN?NNNNN NNNNNNNNNNNNNNNNNNNNNOOO O!O"O#O$O%O&O'O(O)O*O+O,O-O.O/O0O1PP2P3P4P4PwP5PvP6P7P8P9P:P;P<PP=Q>Q?QQ@QAQBQRCRDRERFRsR?RGRHRIRRJRRRSKSLSMSNT0TOTPTQTRTSTTTUTVTTWTXTYTZT[T\T:T6T;T<TT=ULV]V^V_W`WhWaWQWTWWWbWcWtW:W;WdWeWfWWgX^X]YYhYYYiYjYkYlYEYmYnYoYpYqYrYsY YYtYYYuYvYwYxYYyYzY{Y|YY}Y~YYYYY+Y,YYYLY.YYYYYYYYYYYYZZZLZZZZZZZ[`[c[:[;[d[e[f[\\\\\\\\g\]]]^?^?^^^^^_``aa=bjblbEbmbbbbbbbbbbb b/b-b.bb0bcjcmclcccccLdddLeeeeeeeeeeee           ffffffffffffffffffffffffffffffffffffffffffffffff        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMsNOPVQRSTUVWXWY Z[\]^_`abcdefghijklmnolpnqrstou v w"x"y"z{|}{~}"""""""""""""""""""""""""###### ######$$%%%&&&&''''((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((( ( ( ( ( ((((((((((((((((((( (!("("(#($($(%(&('((()(*(+(,(-(.(/(0(1(2(3(4(5(6(7(8(9(:(;(<(=(>(?(@(A(B(C(D(E(F(G(H(I(J(K(O(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(Z([(\(](^(_(`(a(b(c(d(e(f(g(h(i(j(k(l(m(n(o(p(q(r(s(t(u(v(w(x(y(z({(|(}(~((((((((((((((((((((((((((((((((((((((((((()*-........///////012@2222222222333333333333333444444444555555555555555555555555555555w5555555555566666666666777 7888O88hi::::j j j j j jjw< < <= = = = = =========== =!="=#=$=%=&='?(?)@@*@+@,@-@.@0@3@/@0@1@2@@@3@4@5@6@7@8@:@A@9@:@;@<@=@>@C@?@@@@A@B@C@5@H@I@J@D@K@E@s@F@G@H@I@J@K@L@M@NBOBBBPBQBRBSBTBUBVBWBXBYBZB[B6B\BB]B^B_B`BBaBCbCcCdCeCfFFgFhFiFjFkFlFmFnGHoHoHpHqHrHsHtHuHvHwHxHyHzH{H|H}H~HHIIIIIIIKKLLLLMMMMN?NNNNNNNNNOOOOOOOOOOOOOOOOPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP  QQvQwQQQQQQRRRRRTTTTTTTTTTTTUUVWSWWWWWWWUWWWWWWWWWWWWWWWWWY Y Y Y Y Y YtYYYYYYYYYYYYYYYYYYYYYYY Y!Y"Y#Y$YY$Y%Y;Y&Y'Y(YOY)Y*Y+YYYYYY,Y-Y.Y/YY0Y1Z2Z2Z3Z4Z5Z6Z7Z8Z9Z:Z;Z<Z=Z>Z?Z$ZsZZZ@ZA[[[[B[[\S\O\P\R\C\D\T\\\\\\\\E\\F\G\=\H\X\I\J\K\L\M\N\\O\\^^^_P_Q_ _R`aSaTaUbVbWbXbYbZb[b\b]b^b_c`cacbcccdcecfcgchcicjckclcmcncocpcqcrdsdtdud2d2dvd4dwdxdydzd{d|d}d~dvdddwtoysolver-0.3.0ToySolver.Data.MIP.Base ToySolver.Internal.Data.SeqQueueToySolver.VersionToySolver.Text.SDPFileToySolver.Text.GurobiSolToySolver.Internal.Data.IOURefToySolver.Internal.Data.Vec,ToySolver.Internal.Data.IndexedPriorityQueue%ToySolver.Internal.Data.PriorityQueueToySolver.Data.Polynomial7ToySolver.Data.Polynomial.Factorization.Hensel.Internal2ToySolver.Data.Polynomial.Factorization.SquareFreeToySolver.Internal.TextUtilToySolver.Data.MIP.MPSFileToySolver.Data.LBoolToySolver.Converter.SAT2PBToySolver.Converter.PB2SMPToySolver.Converter.PB2WBOToySolver.Converter.PB2LSPToySolver.SAT.TypesToySolver.Converter.WBO2PBToySolver.SAT.TheorySolverToySolver.SAT.MUS.TypesToySolver.SAT.PBO.ContextToySolver.SAT.PrinterToySolver.Text.GCNFToySolver.Text.MaxSATToySolver.Converter.MaxSAT2WBOToySolver.Converter.MaxSAT2NLPBToySolver.Converter.ObjTypeToySolver.Converter.PBSetObj#ToySolver.Combinatorial.Knapsack.DP#ToySolver.Combinatorial.Knapsack.BB7ToySolver.Combinatorial.HittingSet.FredmanKhachiyan19967ToySolver.Combinatorial.HittingSet.GurvichKhachiyan1999ToySolver.Internal.ProcessUtil&ToySolver.Combinatorial.HittingSet.SHD)ToySolver.Combinatorial.HittingSet.HTCBDD)ToySolver.Combinatorial.HittingSet.Simple ToySolver.SATToySolver.SAT.MUSToySolver.SAT.MUS.CAMUSToySolver.SAT.MUS.DAAToySolver.SAT.MUS.QuickXplainToySolver.SAT.PBO.BCToySolver.SAT.PBO.BCDToySolver.SAT.PBO.BCD2ToySolver.SAT.PBO.UnsatBasedToySolver.SAT.PBO.MSU4ToySolver.SAT.PBOToySolver.CongruenceClosureToySolver.Data.BooleanToySolver.FOLModelFinder'ToySolver.Data.Polynomial.GroebnerBasis3ToySolver.Data.Polynomial.Factorization.FiniteField2ToySolver.Data.Polynomial.Factorization.Zassenhaus#ToySolver.Data.AlgebraicNumber.Root$ToySolver.Data.AlgebraicNumber.Sturm0ToySolver.Data.Polynomial.Interpolation.LagrangeToySolver.Data.DNF#ToySolver.Data.AlgebraicNumber.RealToySolver.Internal.UtilToySolver.Data.DeltaToySolver.Data.MIP.LPFileToySolver.Data.MIPToySolver.Converter.MIP2SMTToySolver.Converter.PB2IPToySolver.Converter.MaxSAT2IPToySolver.Converter.SAT2IP1ToySolver.Data.Polynomial.Factorization.KroneckerToySolver.Data.VarToySolver.Data.BoolExprToySolver.SAT.TseitinEncoderToySolver.SAT.PBNLCToySolver.WangToySolver.Data.FOL.FormulaToySolver.Data.ArithRelToySolver.Data.LAToySolver.Arith.SimplexToySolver.Arith.CAD&ToySolver.Data.AlgebraicNumber.ComplexToySolver.Data.FOL.ArithToySolver.Data.LA.FOL#ToySolver.Arith.FourierMotzkin.Base+ToySolver.Arith.FourierMotzkin.Optimization"ToySolver.Arith.FourierMotzkin.FOLToySolver.Arith.Cooper.BaseToySolver.Arith.Cooper.FOLToySolver.Arith.Simplex2ToySolver.Arith.MIPSolver2#ToySolver.Arith.VirtualSubstitutionToySolver.Arith.OmegaTest.BaseToySolver.Arith.OmegaTestToySolver.SAT.IntegerToySolver.Arith.BoundsInferenceToySolver.Arith.LPUtilToySolver.Arith.ContiTraversoToySolver.Arith.LPSolverToySolver.Arith.LPSolverHLToySolver.Arith.MIPSolverHLPaths_toysolverToySolver.Data.Polynomial.Base.ToySolver.Data.Polynomial.Factorization.Hensel/ToySolver.Data.Polynomial.Factorization.Integer0ToySolver.Data.Polynomial.Factorization.Rational&ToySolver.Data.AlgebraicNumber.GraeffeToySolver.Arith.FourierMotzkinToySolver.Arith.Cooper OptDir-0.0.3 Data.OptDirOptMinOptMaxOptDirextended-reals-0.2.1.0Data.ExtendedRealExtendedFiniteNegInfPosInf queue-0.1.2Data.Queue.ClassesnewFifoNewFifo enqueueBatchenqueueEnqueue dequeueBatchdequeueDequeue queueSize QueueSizeversionpackageVersionsSeqQueueclear DenseBlock DenseMatrixBlockMatrixProblem blockStructcostsmatricesmDimnBlock blockElem denseBlock denseMatrix diagBlockparseDataString parseDataFileparseSparseDataStringparseSparseDataFilerender renderSparseModelIOURef newIOURef readIOURef writeIOURef modifyIOURefIndexUVecVec GenericVecnewgetSizereadwrite unsafeRead unsafeWriteresizegrowTopush unsafePopgetElemsclonegetArray getCapacityresizeCapacity PriorityQueueValuenewPriorityQueuenewPriorityQueueBymemberupdate getHeapArray getHeapVecresizeHeapCapacityresizeTableCapacity MonomialOrder UMonomialMonomial mindicesMapUTermTermX UPolynomial PrettyVar pPrintVar PrettyCoeff pPrintCoeffisNegativeCoeff PrintOptions pOptPrintVarpOptPrintCoeffpOptIsNegativeCoeffpOptMonomialOrderSQFreesqfreeFactorfactorContPPcontpp PolynomialcoeffMapDegreedegVarsvarsVarvarconstant fromTerms fromCoeffMapfromTermtermsltlclmcoeff lookupCoeff isPrimitivederivintegralevalsubstmapCoefftoMonictoUPolynomialOfdivModMPreducedefaultPrintOptions prettyPrintnatdivmoddivModdividesgcdlcmexgcdpdivModpdivpmodgcd'isRootOf isSquareFreetdegtscaletmulttdividestdivtderiv tintegralmone mfromIndicesmfromIndicesMapmindicesmmultmpowmdividesmdivmderiv mintegralmlcmmgcdmcoprimelexrevlexgrlexgrevlexhenselcabook_proposition_5_10cabook_proposition_5_11 sqfreeChar0readIntreadUnsignedInteger Variables SOSConstraintsosLabelsosTypesosBodySOSTypeS2S1RelOpEqlGeLe BoundExprLabelBoundsVarInfovarType varBoundsVarTypeSemiIntegerVariableSemiContinuousVariableIntegerVariableContinuousVariable Constraint constrLabelconstrIndicator constrBody constrIsLazyObjectiveFunctionExprdirobjectiveFunction constraintssosConstraintsuserCutsvarInfo defaultBounds defaultLB defaultUBtoVarfromVar getVarInfo getVarType getBoundsintersectBounds variablesintegerVariablessemiContinuousVariablessemiIntegerVariables parseString parseFileparserLBoollTruelFalselUndeflnotliftBool unliftBoolconvert convertWBO XORClause PBLinExactly PBLinAtLeastPBLinSum PBLinTermAtLeastClauseLitMapLitSetLitIModelevalVarVarMapVarSetvalidVarlitUndefvalidLitliterallitNotlitVar litPolarityevalLitnormalizeClauseinstantiateClause clauseSubsume evalClauseclauseToPBLinAtLeastnormalizeAtLeastinstantiateAtLeast evalAtLeastnormalizePBLinSumnormalizePBLinAtLeastnormalizePBLinExactlyinstantiatePBLinAtLeastinstantiatePBLinExactly cutResolvecardinalityReductionnegatePBLinAtLeast evalPBLinSumevalPBLinAtLeastevalPBLinExactly pbLowerBound pbUpperBound pbSubsumenormalizeXORClauseinstantiateXORClause evalXORClause TheorySolver thAssertLitthCheck thExplainthPushBacktrackPointthPopBacktrackPoint emptyTheoryMSSSSMCSCSMUSUS Normalized SimpleContextContextgetObjectiveFunctionisUnsatgetBestSolution getLowerBoundsetUnsat addSolution addLowerBound logMessage getBestValue getBestModel isOptimum isFinishedgetSearchUpperBound setFinishednewSimpleContextsetOnUpdateBestSolutionsetOnUpdateLowerBound setLogger normalize satPrintModelmaxsatPrintModel pbPrintModel musPrintSolGClause GroupIndexGCNFnumVars numClauseslastGroupIndexclausesWeightWeightedClauseWCNFtopCostparseByteStringObjType ObjMaxZero ObjMaxOneObjNonesetObjsolveisCounterExampleOf isRedundantdeleteRedundancy occurFreq areDualDNFs checkDuality checkDualityA checkDualityB"findPrimeImplicateOrPrimeImplicantgenerateCNFAndDNFminimalHittingSetsenumMinimalHittingSetsrunProcessWithOutputCallbackFailureOptions optSHDCommand optSHDArgs optOnGetLineoptOnGetErrorLinedefaultOptionsMethod MethodKnuth MethodTodaoptHTCBDDCommand optMethodRestartStrategy LubyRestarts ArminRestartsMiniSATRestarts PBHandlerTypePBHandlerTypePuebloPBHandlerTypeCounterLearningStrategyLearningHybridLearningClauseBudgetExceededSolver getVarFixed getLitFixedvarDecayActivityvarBumpActivitygetNVarsnVarsnAssignsgetNConstraints nConstraintsgetNLearntConstraintsnLearnt newSolvernewVarnewVarsnewVars_resizeVarCapacity addClause addAtLeast addAtMost addExactly addPBAtLeast addPBAtMost addPBExactlyaddPBAtLeastSoftaddPBAtMostSoftaddPBExactlySoft addXORClauseaddXORClauseSoft solveWithgetModelgetFailedAssumptionssetRestartStrategydefaultRestartStrategysetRestartFirstdefaultRestartFirst setRestartIncdefaultRestartIncsetLearningStrategydefaultLearningStrategysetLearntSizeFirstdefaultLearntSizeFirstsetLearntSizeIncdefaultLearntSizeIncsetCCMin defaultCCMinsetVarPolarity setCheckModel setRandomFreqdefaultRandomFreq setRandomGen getRandomGen setConfBudgetdefaultPBHandlerTypesetPBHandlerTypesetPBSplitClausePartgetPBSplitClausePartdefaultPBSplitClausePartsetEnablePhaseSavinggetEnablePhaseSavingdefaultEnablePhaseSaving"setEnableForwardSubsumptionRemoval"getEnableForwardSubsumptionRemoval&defaultEnableForwardSubsumptionRemoval#setEnableBackwardSubsumptionRemoval#getEnableBackwardSubsumptionRemoval'defaultEnableBackwardSubsumptionRemoval setTheory optLogger optUpdateBest optLitPrinterfindMUSAssumptions optOnMCSFound optOnMUSFound optKnownMCSes optKnownMUSes optKnownCSesenumMCSAssumptionsallMCSAssumptionsallMUSAssumptionscamusdaaoptEnableHardeningoptEnableBiasedSearchoptSolvingNormalFirst OptimizerSearchStrategyBCD2BCDBCMSU4 UnsatBasedAdaptiveSearch BinarySearch LinearSearchdefaultSearchStrategy newOptimizeroptimizegetSearchStrategysetSearchStrategy!defaultEnableObjFunVarsHeuristicsgetEnableObjFunVarsHeuristicssetEnableObjFunVarsHeuristicsdefaultTrialLimitConfgetTrialLimitConfsetTrialLimitConfFlatTermFTAppFTConstmerge areCongruentBoolean.=>..<=>.ite ComplementnotBMonotoneBooleantruefalse.&&..||.andBorB mUniverse mRelations mFunctionsEntity GenFormulaExistsForallEquivImplyNotOrAndAtomFTFormulaPAppTmVarTmAppGenLitNegPosPSymFSym toSkolemNF showEntity showModel findModelStrategy SugarStrategyNormalStrategy optStrategy spolynomialbasisbasis' reduceGBasis berlekampbasisOfBerlekampSubalgebra zassenhaus normalizePolyrootAddrootMul rootShift rootScale rootRecip rootSimpPoly rootNthRootlift2findPoly SturmChain sturmChainnumRoots numRoots'separate separate'halvehalve'narrownarrow'approxapprox' interpolateDNFunDNFAReal realRoots realRootsExapproxIntervalnthRootrefineIsolatingIntervalminimalPolynomialisolatingInterval isRationalisAlgebraicIntegerheight rootIndex simpARealPoly goldenRatio combineMaybe isIntegerfracPart showRationalshowRationalAsFiniteDecimal revSequencerevMapMrevForMDeltadeltafromRealrealPart deltaPartfloor'ceiling' isInteger'readFile readLPFile readMPSFile parseLPStringparseMPSString writeFile writeLPFile writeMPSFile toLPString toMPSString YicesVersionYices2Yices1LanguageYICESSMTLIB2 optLanguage optSetLogic optCheckSAToptProduceModel optOptimizeBoolExprITEfoldsimplifyPolaritypolarityPosOccurspolarityNegOccursEncoder encSolver evalFormula newEncodersetUsePB addFormula encodeConjencodeConjWithPolarity encodeDisjencodeDisjWithPolarity encodeITEencodeITEWithPolaritygetDefinitionsnegatePolarity polarityPos polarityNeg polarityBoth polarityNonePBSumPBTermlinearizePBSumlinearizePBSumWithPolarity evalPBSumSequentisValidpushNotArithRel IsArithRelarithRelNEqGtLtflipOpnegOpshowOpevalOp.<..<=..>..>=..==../=. fromArithRel BoundsEnvunitVarasConstmapCoeffWithVarevalExpr evalLinearlift1 applySubst applySubst1extract extractMaybeshowExprshowAtomevalAtomapplySubstAtomapplySubst1AtomsolveForcomputeIntervalRowColIndexRowIndexTableau emptyTableau objRowIndexpivot lookupRowaddRow setObjFun currentValuecurrentObjValueisValidTableau isFeasible isOptimalsimplex dualSimplexphaseIprimalDualSimplextoCSVCellIntervalPointRootOfproject' findSampleevalCell evalPointprojectprojectN projectN'solve'AComplex:+imagPart conjugate magnitude SatResultSatUnsatUnknown:/::*::+:Const fromFOLAtom toFOLFormula fromFOLExpr toFOLExprConstrIsZeroIsPosIsNonnegRatExprZtoRateqR fromLAAtomtoLAAtomconstraintsToDNF evalBoundsboundsToConstrs collectBounds solveFormulaeliminateQuantifierseliminateQuantifiers' QFFormula Divisible.|. evalQFFormula projectCases projectCasesNsolveQFFormulasolveQFLIRAConjRawModelobjLimit OptResultObjLimit UnboundedOptimum PivotStrategyPivotStrategyLargestCoefficientPivotStrategyBlandRule SolverValuetoValue showValue GenericSolver cloneSolversetPivotStrategypushBacktrackPointpopBacktrackPoint assertAtom assertAtomEx assertLower assertUppergetObj setOptDir getOptDirisBasicVariableisNonBasicVariablecheck getRawModel getObjValuegetLBgetUB getTableaugetValuegetRowgetColgetCoeff clearLoggerdumpsetShowRational setNThread optCheckRealcheckRealNoCheck checkRealByFMzmodcheckRealByCAD checkRealByVScheckRealBySimplex linearize addConstraintaddConstraintSoft inferBoundstoStandardFormtoStandardForm'LP emptySolver putTableaudefine#addConstraintWithArtificialVariabletableautwoPhaseSimplexcollectNonnegVarsOptUnsatmaximizeminimizecatchIObindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName$fQueueSizeSeqQueueIO$fDequeueSeqQueueIOa$fEnqueueSeqQueueIOa$fNewFifoSeqQueueIO pDataFilepSparseDataFilepComment pBlockStructpCostspDenseMatricespSparseMatricesnat_lineintrealsign renderImpl renderVecshowRatconcatSsepByS cloneArraycopyToghc-prim GHC.ClassesOrdnewPriorityQueueBy#lt#heaptableupdownleftrightparent$fQueueSizePriorityQueueIO$fDequeuePriorityQueueIOInt$fEnqueuePriorityQueueIOInt$fNewFifoPriorityQueueIO$fDequeuePriorityQueueIOa$fEnqueuePriorityQueueIOa asConstantscalezeroplusnegmultisZerocontIppIprettyPrintTermaddPrecmulPrecratPrecexpPrecappPrecmfromIndicesMap'$fHashableMonomial$fVarsMonomialv$fVarMonomialv$fDegreeMonomial$fNFDataMonomial$fIsStringMonomial$fShowMonomial $fHashableX $fNFDataX $fPrettyVarX$fPrettyVarInt$fPrettyCoeffPolynomial$fPrettyCoeffPrimeField$fPrettyCoeffRatio$fPrettyCoeffInteger$fPrettyPolynomial$fDefaultPrintOptions $fContPPRatio$fContPPInteger$fDegreePolynomial$fVarsPolynomialv$fVarPolynomialv$fHashablePolynomial$fNFDataPolynomial$fShowPolynomial$fVectorSpacePolynomial$fAdditiveGroupPolynomial$fIsStringPolynomial$fNumPolynomialf$fSQFreePolynomial$fSQFreePolynomial0base Text.Read integer-gmpGHC.Integer.TypeIntegerreadUnsignedIntdefaultVarInfo$fVariablesSOSConstraint$fVariablesConstraint$fVariablesTerm$fVariablesProblem$fVariablesEither $fVariables[]$fDefaultVarInfo$fDefaultVarType$fDefaultConstraint$fDefaultProblemM BoundTypeSISCUILIBVPLMIFRFXUPLOColumnspace'spaces'spaces1' commentlinenewline'tokrowcolumnidentstringLnnumber nameSectionobjSenseSectionobjNameSection rowsSectionuserCutsSectionlazyConsSectionrowsBody colsSection rowAndVal rhsSection rangesSection boundsSection boundType sosSectionquadObjSectionqMatrixSectionqcMatrixSectionindicatorsSectionexecM writeString writeCharrender'writeSectionHeader writeFieldsnameRows quadMatrixcheckAtMostQuadratic $fShowLBool showConstrsum'showSumshowTermshowLit GHC.TypesTrueFalse Data.MaybeNothing $fIModel(->) $fIModelArray$fIModelUArraynBasenObjectiveFunctionnOffsetscGetObjectiveFunction scUnsatRefscBestSolutionRefscLowerBoundRefscOnUpdateBestSolutionRefscOnUpdateLowerBoundRef scLoggerRef$fContextNormalized$fContextSimpleContextsplit isComment parseLine parseCNFLineseqList parseWCNFLineparseWCNFLineBSparseCNFLineBS parseClauseBS isCommentBSgenObjtest1test2xhicondition_1_2_solve condition_1_2containers-0.5.5.1Data.IntSet.Basesize Data.Set.Basedisjoint intersectisHittingSetOfvolume condition_1_1condition_1_1_solve condition_1_3condition_1_3_solvee condition_2_1condition_2_1_solve isIrredundantcheckDualityA' solveSmallcheckDualityB'test_condition_1_1_solve_Ltest_condition_1_1_solve_Rtest_condition_1_2_solve_Ltest_condition_1_2_solve_Rtest_condition_1_3_solve_Ltest_condition_1_3_solve_Rtest_condition_2_1_solve_Ltest_condition_2_1_solve_Rtest_checkDualityAtest_checkDualityBfindImplicateOrImplicantminimizeImplicantminimizeImplicateevalDNFevalCNFgtestA1testA2testA3testA4testB1process-1.2.0.0System.Processproc withForkWait ignoreSigPipeexecSHD$fExceptionFailure$fDefaultOptions execHTCBDD$fDefaultMethodminimalHittingSets'propagateChoicemaintainNoSupersetsnubOrdconstrPropagateSomeConstraintHandlerconstrReasonOf svVarDecaysvVarInc svConstrDecay svConstrIncsvRestartFirst svRestartIncsvLearntSizeFirstsvLearntSizeIncsvCCMin ldWatches vdWatcheswatchLitwatchVarwatches getNAssignedpbSplitClausePart backtrackTo propagatereasonOf TheoryHandlerXORClauseHandlerxorLits xorActivityxorHashPBHandlerPueblo puebloTerms puebloDegreepuebloMaxSlack puebloWatchespuebloWatchSumpuebloActivity puebloHashPBHandlerCounterpbTermspbDegree pbCoeffMap pbMaxSlackpbSlack pbActivitypbHashAtLeastHandler atLeastLits atLeastNumatLeastActivity atLeastHash ClauseHandlerclaLits claActivityclaHashCHTheory CHXORClause CHPBPueblo CHPBCounter CHAtLeastCHClauseConstraintHandlertoConstraintHandlershowConstraintHandler constrAttach constrDetachconstrIsLockedconstrOnUnassignedisPBRepresentabletoPBLinAtLeast isSatisfiedconstrIsProtected constrWeightconstrReadActivityconstrWriteActivity SearchResultSRBudgetExceeded SRRestart SRFinished VarActivitysvOk svVarQueuesvTrail svTrailLimitsvTrailNPropagated svVarData svConstrDB svLearntDBsvTheorySolversvTheoryCheckedsvModelsvFailedAssumptions svNDecisionsvNRandomDecision svNConflict svNRestart svNLearntGCsvNRemovedConstrsvRestartStrategysvEnablePhaseSaving!svEnableForwardSubsumptionRemovalsvLearningStrategysvPBHandlerTypesvPBSplitClausePart"svEnableBackwardSubsumptionRemoval svCheckModel svRandomFreq svRandomGen svConfBudgetsvLogger svStartWC svLastStatWC svAssumptions svLearntLimsvLearntLimAdjCntsvLearntLimSeqLitData ldOccurListVarData vdPolarity vdPosLitData vdNegLitData vdActivityvdValue vdTrailIndexvdLevelvdReasonvdOnUnassignedLevel levelRoot newVarData newLitDatavarDatalitDatavarValuelitValue getNFixedvarLevellitLevel varReason varAssignNomarkBad bcpDequeue bcpIsEmpty bcpCheckEmptybcpClearassignByassignassign_unassignaddOnUnassigned unwatchLit unwatchVaraddToDB addToLearntDBreduceDB varActivityvarRescaleAllActivitylearntConstraintsltVarsolve_searchcheckForwardSubsumptionremoveBackwardSubsumedBybackwardSubsumedByremoveConstraintHandlers pickBranchLitdecidededucededuceBanalyzeConflict analyzeFinalanalyzeConflictHybridpbBacktrackLevelminimizeConflictClauseminimizeConflictClauseLocalminimizeConflictClauseRecursive peekTrailpopTrailgetDecisionLevelpushDecisionLevelpopDecisionLevelconstructModelconstrDecayActivityconstrBumpActivityconstrRescaleAllActivity resetStatprintStatHeader printStat showTimeDiffattachdetachisLocked isReasonOf findForWatch findForWatch2 claGetSizenewClauseHandlerbasicAttachClauseHandlernewAtLeastHandlerbasicAttachAtLeastHandler newPBHandlernewPBHandlerPromoted pbOverSAT pbToAtLeastnewPBHandlerCounter puebloAMaxnewPBHandlerPueblopuebloGetWatchSum puebloWatch puebloUnwatchpuebloPropagatepuebloUpdateWatchSumnewXORClauseHandlerbasicAttachXORClauseHandler getTheorydeduceT mkRestartSeqminiSatRestartSeqarminRestartSeqlubyRestartSeqlubyallManyMshiftdefaultHashWithSalt debugModecheckSatisfieddumpVarActivitydumpConstrActivityloglogIO $fConstraintHandlerTheoryHandler$fHashableTheoryHandler#$fConstraintHandlerXORClauseHandler$fHashableXORClauseHandler$fEqXORClauseHandler"$fConstraintHandlerPBHandlerPueblo$fHashablePBHandlerPueblo$fEqPBHandlerPueblo#$fConstraintHandlerPBHandlerCounter$fHashablePBHandlerCounter$fEqPBHandlerCounter!$fConstraintHandlerAtLeastHandler$fHashableAtLeastHandler$fEqAtLeastHandler $fConstraintHandlerClauseHandler$fHashableClauseHandler$fEqClauseHandler($fConstraintHandlerSomeConstraintHandler$fHashableSomeConstraintHandler$fExceptionBudgetExceededsolveWBOCoreInfocoreLitscoreLBcoreUB coreMidValue coreUnionrefine optContext optSolveroptSearchStrategyRef optEnableObjFunVarsHeuristicsRefoptTrialLimitConfRef linSearch binSearchadaptiveSearch tweakParams$fDefaultSearchStrategy svVarCounter svPendingsvRepresentativeTable svClassList svUseList svLookupTable PendingEqnEqn1lookup setLookup addToPendinggetRepresentative $fBooleanBool$fMonotoneBooleanBool$fComplementBool $fBoolean(->)$fMonotoneBoolean(->)$fComplement(->) $fBoolean(,)$fMonotoneBoolean(,)$fComplement(,)SGenAtomSGenTermSubst GroundClause GroundLit GroundAtom GroundTermSClauseSLitSAtomSTermSEqSPAppSTmVarSTmApptoNNFtest_toSkolemNFflatten test_flattenshowEntityTuple enumSubstsimplifyGroundClause collectFSym collectPSymtest$fVarsSGenAtom$fVarsSGenTerm$fVarsGenFormula$fBooleanGenFormula$fComplementGenFormula$fMonotoneBooleanGenFormula $fVarsAtom $fVarsTerm $fVarsGenLit$fComplementGenLit$fVars[]ItemiFstiSndiCmpiLCMitempairs$fEqItem $fOrdItemsqfree' polyPthRoot$fFactorPolynomialnorm2sqliftdiv'combboundscountSignChanges countChanges boundIntervalNthRootgraeffesMethodf' $fBooleanDNF$fMonotoneBooleanDNF$fComplementDNFproperFraction'GHC.RealproperFraction truncate'truncateround'roundceilingfloor $fDegreeARealRealRoot realRoots'realRoot realRoot' scaleAReal shiftARealnthRoots$fPrettyCoeffAReal $fPrettyAReal$fRealFracAReal $fRealAReal$fFractionalAReal $fNumAReal $fOrdAReal $fEqAReal$fVectorSpaceDelta$fAdditiveGroupDeltaBounds2char'string'sepcommentvariablelabelreservedproblemendconstraintSection subjectTo constraintrelOplazyConstraintsSectionbound boundExprinfgeneralSection binarySection semiSectionexprtermqexprqtermqfactorwriteVar renderExpr showCoeff showConstTerm renderLabelrenderOprenderConstraintrenderBoundExprrenderVariableListfillremoveEmptyExprEnvunlinesSlistand'or'not'intExprrealExprintNumrealNumreltoRealassert conditionsnonAdjacentPairsencodeisInttestFiletestdataconvExprconvVarrelaxGErelaxLEmtransfactor'factor2isUPolyZtoZxvalues interleavefactors primeFactorsSimplify runSimplifyisTrueisFalse$fBooleanSimplify$fMonotoneBooleanSimplify$fComplementSimplify$fVariablesBoolExpr$fBooleanBoolExpr$fMonotoneBooleanBoolExpr$fComplementBoolExpr$fHashableBoolExpr$fNFDataBoolExpr$fTraversableBoolExpr$fFoldableBoolExpr$fMonadBoolExpr$fApplicativeBoolExpr$fFunctorBoolExprencUsePB encConjTable encITETableencodeToClause encodeToLitencodeToLitWithPolarityisValid'pick$fBooleanFormula$fMonotoneBooleanFormula$fComplementFormula$fVariablesFormula$fFunctorArithRel$fVariablesArithRel$fIsArithReleArithRel$fComplementArithRel normalizeExpr showExprWith$fVectorSpaceExpr$fAdditiveGroupExpr $fNFDataExpr $fReadExpr $fShowExpr$fVariablesExprPDResult PDUnbounded PDOptimalPDUnsat PivotResult PivotSuccess PivotFinishedPivotUnbounded normalizeRowsetRow copyObjRow isImproving primalPivot dualPivotremoveArtificialVariablespdPivot AssumptionCoeffSignConfshowCell showPoint emptySignConf showSignConfnormalizeSignConfKeylookupSignConfmr test_mr_1 test_mr_2runMassume buildSignConfcollectPolynomialsrefineSignConfemptyAssumption propagateEq propagateSignisOkay dropConstantsassumption2condcomputeSignSetshowDNFdumpProjection dumpSignConftest1atest1btest1ctest2atest2b test_projecttest_project_printtest_project_2test_project_3_print test_solvetest_collectPolynomialstest_collectPolynomials_printtest_buildSignConftest_buildSignConf_printtest_buildSignConf_2test_buildSignConf_2_printtest_buildSignConf_3test_buildSignConf_3_printGHC.Numabssignumrootstest3test4test5test6$fFractionalAComplex $fNumAComplex$fIsArithRelExprFormula $fFunctorExpr$fFractionalExpr $fNumExprfromRatevalRatleRltRgeRgtR subst1Constr evalConstrfindEq$fVariablesConstrdata-interval-1.2.0 Data.Interval lowerBound upperBound projectToObj' projectTo'negateDNFConstrLCMgetLCMWitnessWCase2WCase1leZltZgeZgtZeqZsubst1 simplifyLit evalWitness projectCases' checkedDiv testHagiya $fMonoidLCM$fIsArithRelExprBoolExpr$fComplementLit$fVariablesLit increaseNB decreaseNBBacktrackPoint bpSavedLB bpSavedUB svTableausvLBsvUBsvVCntsvOptDirsvDefDBsvPivotStrategysvNPivotsvBacktrackPointsobjVarcloneBacktrackPointwithBacktrackpointbpSaveLBbpSaveUB simplifyAtomselectViolatingBasicVariableselectEnteringVariable canIncrease canDecrease canIncrease1 canDecrease1 dualRTestprunepivotAndUpdatefindMtestLBtestUBbasicVariables recordTime showDeltadumpSizecheckFeasibilitycheckNBFeasibilitycheckOptimality$fSolverValueDelta$fSolverValueRatioNodendLPndDepthndValueMIP mipRootLPmipIVsmipBest mipNThread mipLoggermipOnUpdateBestSolutionmipShowRationalbranchAndBoundviolatedderiveGomoryCutcanDeriveGomoryCutcollect IntervalZBoundsZapplySubst1Constr evalBoundsZcollectBoundsZisExactchooseVariable extractEq eliminateEqunivZ intersectZpickupZpickuptightenToIntegerCstrictmkModel costOrdering elimOrderingaddArtificialVariablegetArtificialVariablesclearArtificialVariablesgetDefs isSingleVarisSingleNegatedVar expandDefs expandDefs'introduceArtificialVariablesnormalizeConstraint example_3_2test_3_2 example_3_5test_3_5 example_4_1test_4_1 example_4_2test_4_2 example_4_3test_4_3 example_4_5test_4_5 example_4_6test_4_6 example_4_7test_4_7kuhn_7_3 test_kuhn_7_3testAllErrErrUnsat ErrUnboundedndSolver ndTableau ndLowerBoundtableau'conv mkInitialNodeisStrictlyBettertraverseBBTreeexample1test1'example2