_L      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !!!"""""""""""""""""""""## # # # $ $$$$$%&&&&&&&&&&&&& &!&"&#&$&%&&'''(())*)+),*-*.*/*0+1+2+3+4+5+6+7+8+9+:+;+<+=+>+?+@,A,B-C-D-E-F-G.H.I.J.K.0None +NSTVa:Unique Int -----------------------------------------------:Edit Distance --------------------------------------------@!If loud, write a string to stdoutP   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTP   !"#$%&'()*+,-./0123567894:;<=>?@ABCDEFGHIJKLMNOPQRST None;<=fYImplement either Z or [dTop-level pretty printergPlease do not alter this.UVWXY[Z\]^_`abcdefghijkl3b_`acvutsrqponm\]^YZ[defghi~}|{zyxwWXUVjklUVWXYZ[\]^_`aNone16;=VkBA Reusable SrcSpan Type ------------------------------------------Start Position End PositionBLocated Values ---------------------------------------------------BRetrofitting instances to SourcePos ------------------------------None%016;=FOTV}9 $Values that can be viewed as SymbolsELocated Symbols ----------------------------------------------------- Invariant: a L is made up of: '0'..'9'++ [ 'a'...'z'] ++ ['A'..'Z'] ++ M?If the original text has ANY other chars, it is represented as:lq$i+where i is a unique integer (for each text)FDecoding Symbols -----------------------------------------------------NFEncoding Symbols -----------------------------------------------------ORJ: We allow the extra  unsafeChars to allow parsing encoded symbols. e.g. the raw string "This#is%$inval!d" may get encoded as "enc%12" and serialized as such in the fq/bfq file. We want to allow the parser to then be able to read the above back in.HUse this **EXCLUSIVELY** when you want to add stuff in front of a Symbol'testSymbol c' creates the `is-c`& symbol for the adt-constructor named c. NOTE: SymbolTextUse 1 if you want it to machine-readable, but ) if you want it to be human-readable.!:Symbols --------------------------------------------------Q   Q   PQRSTUNone&'16;<=>?KN&Name of defined datatype'Number of type variables(Datatype Ctors+ Ctor Name, Ctor Fields/ Field Name0 Field Sort1KSorts ---------------------------------------------------------------------4numeric kind for Num tyvars5"numeric kind for Fractional tyvars6uninterpreted type7fixpoint type variable8function9type-abstraction;constructed typeOfApp' (FApp (FApp Map key) val) ===> [Map, key, val] That is, fApp'E is used to split a type application into the FTyCon and its args.[DExported Basic Sorts -----------------------------------------------\DExported Basic Sorts -----------------------------------------------]DExported Basic Sorts -----------------------------------------------^DExported Basic Sorts -----------------------------------------------_DExported Basic Sorts -----------------------------------------------D"#$%&'()*+,-./01;79234:856<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeD123456789:;"#=<R?@ABCEFd]^[\_`abDGHT>IKcJNLMQOPeSXYUVWZ-./0)*+,$%&'("#$%&'()*+,-./01 23456789:;VWXYZ=[None&'13456;<=>?KOd5DClass Predicates for Valid Refinements -----------------------------\DTODO: This doesn't seem to merit a TC ------------------------------'Values that can be viewed as PredicatesCGeneralizing Symbol, Expression, Predicate into Classes -----------&Values that can be viewed as Constants(Values that can be viewed as ExpressionsParsed refinement of Symbol as Expr# e.g. in '{v: _ | e }' v is the Symbol and e the ExprKExpressions ---------------------------------------------------------------EUninterpreted constants that are embedded as "constant symbol : Str"KSubstitutions -------------------------------------------------------------KKvars ---------------------------------------------------------------------]Wrap the enclosed ^, in parentheses only if the condition holds.KPredicates ----------------------------------------------------------------':Refinements ----------------------------------------------+7Gradual Type Manipulation -----------------------------7Generally Useful Refinements --------------------------AKString Constants ----------------------------------------------------------Replace all symbol-representations-of-string-literals with string-literal Used to transform parsed output from fixpoint back into fq.k,The symbol may be an encoding of a SymConst. parameters for Reft, vv + othersS      !"#$%&'()*+,-./01234   /%012 !"-.#$)*'S(34 &+, \None 013456;=V@Result ---------------------------------------------------------KA BareBones Error Type ----------------------------------------------------@Catalogue of Errors --------------------------------------------_`a NoneybKTODO: Rewrite using visitor ----------------------------------------------- None&'13456;<=>?KKConstraint Pack Sets ------------------------------------------------------'Functions for Global Binder Environment-&Functions for Indexed Bind Environment8      !"#$%&'(8     &!$"# %'(cdefgh None16O֌TA Refinement of 1 that describes SMTLIB Sorts^^/ describes the SMT semantics for a given symbol_ for UDF: len, height, append`for ADT constructor and tests: cons, nilafor ADT tests :  `is$cons`bfor ADT field: hd, tlc for theory ops: mem, cup, selectdd3 represents the information about each interpreted fnamegserialized SMTLIB2 namehsorti>TRUE = defined (interpreted), FALSE = declared (uninterpreted)jj is used to resolve the 1 and ^ of each lSorts of *all* defined symbolsm)Information about theory-specific SymbolsnUser-defined data-declarationsoDistinct Constant symbolspTypes at which apply/ was used; see [NOTE:apply-monomorphization]qq/ is the low-level representation for SMT valuesi These are BUILT-inx polymorphic functions which are UNININTERPRETED but POLYMORPHIC, hence need to go through the apply-defunc stuff.jsmtSortsP attempts to compute a list of all the input-output sorts at which applications occur. This is a gross hack; as during unfolding we may create _new_ terms with wierd new sorts. Ideally, we MUST allow for EXTENDING the apply-sorts with those newly created terms. the solution is perhaps to *preface* each VC query of the form-push assert p check-sat pop%with the declarations needed to make p3 well-sorted under SMT, i.e. change the above toGdeclare apply-sorts push assert p check-sat popssuch a strategy would NUKE the entire apply-sort machinery from the CODE base. [TODO]: dynamic-apply-declarationyThe poly parameter is True when we are *declaring* sorts, and so we need to leave type variables be; it is False when we are declaring variables etc., and there, we serialize them using kb (though really, there SHOULD BE NO floating tyVars... 'smtSort True msg t' serializes a sort tB using type variables, 'smtSort False msg t' serializes a sort t using k instead of tyvars.&TUVWXYZ[\]^`_abcdefghijklmnopqrstuvwxy&qdefghi^_`abcTUVWXYZ[\]yxjklmnoprtsuvwT UVWXYZ[\]^_`abcdefghijklmnop None136؄ NoneV!Constraint Generation Information&Input to constraint solving (fixpoint))Output from constraint solving (fixpoint)(HTML file with inferred type annotationsText file with inferred typesVim annotation fileHaskell sourceHaskell sourceLiterate Haskell sourceJavaScript sourceTypescript source%Spec file (e.g. include/Prelude.spec)DLifted-Spec file, containing automatically generated specifications -Qualifiers file (e.g. include/Prelude.hquals)Final result: SAFE/UNSAFEHTML file with templates?8Markdown file (temporarily generated from .Lhs + annots)-JSON file containing result (annots + errors)*Previous source (for incremental checking)*Previous output (for incremental checking)Constraint Graph Partition0SMTLIB2 queries for automatically created proofs$Binary representation of .fq / FInfoSMTLIB2 query file#filter constraints with delta debug"filter qualifiers with delta debugfilter kvars with delta debug7Hardwired Paths and Files -----------------------------++None16;=^"Eliminate describes the number of KVars to eliminate: None = use PA/Quals for ALL k-vars, i.e. no eliminate Some = use PA/Quals for CUT k-vars, i.e. eliminate non-cuts All = eliminate ALL k-vars, solve cut-vars to TRUE1src file (*.hs, *.ts, *.c, or even *.fq or *.bfq))number of cores used to solve constraintsMinimum size of a partition2Maximum size of a partition. Overrides minPartSizewhich SMT solver to use not interpret div and mul in SMT&interpretation of string theory by SMTdefunctionalize (use apply$ for all uninterpreted applications)3allow higher order binders in the logic environmentallow higher order qualifierseliminate non-cut KVars)maximum length of KVar chain to eliminateprint eliminate statsprint solver stats+print meta-data associated with constraintscompute constraint statistics&partition FInfo into separate fq filessave FInfo as .bfq and .fq file3min .fq by delta debug (unsat with min constraints)0min .fq by delta debug (sat with min qualifiers)+min .fq by delta debug (sat with min kvars)Bshrink final solution by pruning redundant qualfiers from fixpointsolve "gradual" constraintsinteractive gradual solvingallow function extensionality%allow lambda alpha equivalence axioms$allow lambda beta equivalence axioms+allow lambda normal-form equivalence axiomsignore given kut variablesTreat non-linear vars as cuts!Disable non-concrete KVar slicing'allow axiom instantiation via rewriting KConfiguration Options -----------------------------------------------------2     2     !None&'136;<=>?KO"(name of reflected function)names of parameters*definition of body+ sort of body,is this a recursive definition-FAxiom Instantiation Information --------------------------------------2FTop level Solvers ----------------------------------------------------5cst id |-> Horn Constraint6%Kvar |-> WfC defining its scope/args7Bind |-> (Symbol, SortedReft)8Global Constant symbols9Distinct Constant symbols:Set of KVars *not* to eliminate;Abstract domain<Metadata about binders=User-defined data declarations>Higher Order infoC+Allow higher order binds in the environemntDAllow higher order qualsGTop-level QueriesKKConstraint Cut Sets -------------------------------------------------------NKQualifiers ----------------------------------------------------------------PNameQ ParametersR PredicateSSource LocationZSolutions and ResultsgId of lhs/rhs binder|KConstraints ---------------------------------------------------------------F"Smart Constructors" for Constraints ---------------------------------constructing qualifiersConstructing QueriesRendering Queries!Query Conversions: FInfo to SInfoz !"#$%&'()*+,-./0123467589:;<>?@=ABCDEFGHIJKLMNOPQRSTUVWXYZ[_a`^\]bcdefghijlkmnopqrstuvwxyz{|}~FE3456789:;<=>?@GHIJ2tuvwxywxyz{~jklm]\kl^bcdefghi|[\]^_`a`a_}nopqrsNOPQRSYZTUVWXKLMABCD-./01&'()*+, !"#$% !"#$%&'()*+,-./013 456789:;<=>?@ABCDGHIJKLMNOPQRSTUVWXlm[\]^_`abcdefghijnoklpqrnopqrst uvwxywxyz{NonelCompute the domain of a kvarFree variables of a refinement8Split a SortedReft into its concrete and KVar components/NoneNUVWXYZ[\^]_a`bcdefghijkl   "#$%&'()*+,-./01;79234:856<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcde      !"#$%&'()*+,-./01234      !"#$%&'(TUVWXYZ[\]^`_abcdefghijklmnopqrstuvwxy !"#$%&'()*+,-./0123467589:;<>?@=ABCDEFGHIJKLMNOPQRSTUVWXYZ[]\^`a_bcdefghijklmnopqrstuvwxyz{|}~None;<=KNO0:String Constants -----------------------------------------CoSub is a map from (coercion) ty-vars represented as 'FObj s' to the ty-vars that they should be substituted with. Note the domain and range are both Symbol and not the Int used for real ty-vars. Context ctx8 is built in a "top-down" fashion; not "across" siblings Transforms can access current ctx !Accumulations can access current ctx; acc value is monoidal Visitors over Sort!      !"!      !"st   None3uui ignores the actual refinements as they are not relevant in the kvar parameters (as suggested by BLC.)33None;<=;+4KAST Conversion: Types that can be serialized ------------------------------6*Information about the external SMT process=-flag to enable function extentionality axioms>*flag to enable lambda a-equivalence axioms?*flag to enable lambda b-equivalence axioms@4flag to enable lambda normal form equivalence axiomsB"Responses received from SMT engineIKTypes ---------------------------------------------------------------------Commands issued to SMT engine"456789:;<=>?@ABFHCDEGIJKLMNOPQRSTU"IJKLMNOPQRSTBCDEFGH45U6789:;<=>?@A456 789:;<=>?@ABCDEFGHI JKLMNOPQRSTNone16?cConstruct the bitvector 1 from its ^e4Apply some bitvector operator to a list of argumentsf Construct an / using a raw string, e.g. (Bv S32 "#x02000000") [\]^_`abcde ab^_`[\]ced[\]^_`abNone6;<=NOv@Parsing Constraints (.fq files) --------------------------------IntegerString Haskell infix IdArbitrary Symbols(Integer) ConstantswUsed as input to &Text.Parsec.Expr.buildExpressionParser to create exprP ExpressionsFunction Applicationsx9BitVector literal: lit "#x00000001" (BitVec (Size32 obj))SortBit-Vector SortyKPredicates ----------------------------------------------------------------KBareTypes -----------------------------------------------------------------Refa2(Sorted) Refinements with configurable sub-parsersBinder (lowerIdP <* colon)(Sorted) Refinements((Sorted) Refinements with default binderKParsing Data Declarations -------------------------------------------------KParsing Qualifiers -------------------------------------------------------- Qualifiersz@Axioms for Symbolic Evaluation ---------------------------------{@Interacting with Fixpoint --------------------------------------Bqsrtuvwxyz{|}~Gqrs~}tuvwxyz{xy|xy|qrsv|}~t uvwxyz{xy|xy|}None+RNone;=Om!  NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------ NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------ NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------KExported API --------------------------------------------------------------Theory Symbols :  uninterpSEnv should be disjoint from see  interpSEnv) to avoid duplicate SMT definitions.  uninterpSEnv& is for uninterpreted symbols, and  interpSEnv is for interpreted symbols.X contains the list of ALL SMT symbols with interpretations, i.e. which are given via  `define-fun` (as opposed to  `declare-fun`)'Constructors, Selectors and Tests from $ arations.('selfSort d' returns the _self-sort_ of d :: $%. See [NOTE:DataDecl] for details.)'fldSort d t' returns the _real-sort_ of d if t- is the _self-sort_ and otherwise returns t". See [NOTE:DataDecl] for details. converts the 1 into a full dHyyHNone ;<=>?NOijKAPI for manipulating Sort Substitutions -----------------------------------KChecking Refinements ------------------------------------------------------Types used throughout checkerElaborate: make polymorphic instantiation explicit via casts, make applications monomorphic for SMTLIB. This deals with polymorphism by l-ing all refinements except for KVars. THIS IS NOW MANDATORY as sort-variables can be instantiated to  and bool.KPredicates on Sorts -------------------------------------------------------: adds "casts" to decorate polymorphic instantiation sites.7 replaces all direct function calls indirect calls via KSort Inference ------------------------------------------------------------KChecking Refinements ------------------------------------------------------KChecking Expressions ------------------------------------------------------LElaborate expressions with types to make polymorphic instantiation explicit./defuncEApp monomorphizes function applications. NOTE:apply-monomorphization^Because SMTLIB does not support higher-order functions, all _non-theory_ function applications EApp e1 e2are represented, in SMTLIB, as(Eapp (EApp apply e1) e2)where & is 'ECst (EVar "apply") t' and t is 'FFunc a b' a,b are the sorts of e2 and 'e1 e2' respectively.9Note that *all polymorphism* goes through this machinery.7Just before sending to the SMT solver, we use the cast t to generate a special  apply_at_t symbol.$To let us do the above, we populate j& with the _set_ of all sorts at which  is used, computed by .KExpressions sort ---------------------------------------------------------&Helper for checking symbol occurrences,Helper for checking if-then-else expressions$Helper for checking cast expressionsHelper for checking uninterpreted function applications | Checking function application should be curried, e.g. | fromJust :: Maybe a -> a, f :: Maybe (b -> b), x: c |- fromJust f x RJ: The above comment makes no sense to me :(/Helper for checking binary (numeric) operationsKChecking Predicates -------------------------------------------------------Checking RelationsSort Unification on ExpressionsSort Unification3Fast Unification; `unifyFast True` is just equalityKApplying a Type Substitution ----------------------------------------------KDeconstruct a function-sort -----------------------------------------------KError messages ------------------------------------------------------------T[\[\TNone&'16;<=>?NOSTA Index is a suitably indexed version of the cosntraints that lets us 1. CREATE a monolithic "background formula" representing all constraints, 2. ASSERT each lhs via bits for the subc-id and formulas for dependent cut KVarsBindPred for each BindIdDefinition of each Constraints defining each Binders of each Subc,Transitive closure oof all dependent bindersSorts for all symbols , bindPrev :: !(BIndex |-> BIndex) -- ^ "parent" (immediately dominating) binder , kvDeps :: !(CMap [KIndex]) -- ^ List of (Cut) KVars on which a SubC dependsEach # corresponds to a conjunction of a  and bpKVarsConcrete predicate (PTrue o)KVar-Subst pairs7A BIndex is created for each LHS Bind or RHS constraintDA KIndex uniquely identifies each *use* of a KVar in an (LHS) binder KInstantiated Qualifiers ---------------------------------------------------A - is an association list indexed by predicatesBinders from defining EnvSubstitutions from cstrs Rhs Id of defining Cstr(Tag of defining Cstr (DEBUG)A C is a single constraint defining a KVar ---------------------------A Y contains the various indices needed to compute a solution, in particular, to compute lhsPred for any given constraint.'Environment used to elaborate solutionsActual solution (for cut kvar)Solution for gradual variables"Defining cubes (for non-cut kvar)set of allowed binders for kvarThe = data type --------------------------------------------------KUpdate Solution -----------------------------------------------------------,KCreate a Solution ---------------------------------------------------------.KRead / Write Solution at KVar ---------------------------------------------@      !"#$%&'()*+,-./012A)      21#$%&",.0/!-('*+      None6VVx contains all the stuff needed to produce a result, and is the the essential ingredient of the state needed by solve_Xthe initial solutionYthe whole input queryZ+dependencies between constraints/ranks etc.["set of KVars to actually solve for\KRanks ---------------------------------------------------------------------^ SCC number with ALL dependencies_#SCC number without CUT dependencies`The constraint's TagaKConstraint Dependencies ---------------------------------------------------c!Constraints *written by* a SubcIdd!(Cut) KVars *read by* a SubcIdeSCC rank of a SubcIdfTotal number of Sccso)F.SubcIds that transitively "reach" belowpF.SubcIds with Concrete RHSqDependencies between slKVarCssDramatis Personae{real kvar vertex|)dummy to ensure each kvar has a successor}(constraint-id which creates a dependencyFCMap API -------------------------------------------------------------.mVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{}|~.z{|}vwxyut~msrmnopqghijkl\]^_`abcdefVWXYZ[VWXYZ[\]^_`abcdefghijklmnopqwxyz{|}None? is representation of the KVGraph with a fast succ, pred lookupout-edges of a zin-edges of a z  None);<=O>hSMTLIB/Z3 don't like "unused" type variables; they get pruned away and cause wierd hassles. See testspos$adt_poly_dead.fq for an example. ] adds a junk constructor that "uses" up all the tyvars just to avoid this pruning problem.\smt2Cast uses the 'as x T' pattern needed for polymorphic ADT constructors like Nil, see `tests/pos/adt_list_1.fq`None6The main data typesNone "#;=Vޒ xtype ClosedPred E = {v:Pred | subset (vars v) (keys E) } checkValid :: e:Env -> ClosedPred e -> ClosedPred e -> IO Bool~If you already HAVE a context, where all the variables have declared types (e.g. if you want to make MANY repeated Queries)KSMT IO --------------------------------------------------------------------ESMT Context ---------------------------------------------------------HSMT Commands -----------------------------------------------------------HSMT Commands -----------------------------------------------------------b returns {0, 1, 2} where: 0 = Theory-Definition, 1 = Theory-Declaration, 2 = Query-Binder is used solely to determine the set of literals (of each sort) that are *disequal* to each other, e.g. EQ, LT, GT, or string literals "cat", "dog", "mouse". These should only include non-function sorted values.Z sorts the data declarations such that each declarations only refers to preceding ones.7456789:;<=>?@ABFHCDEGIJKLMNOPQRST7IJKLMNOPQRSTBCDEFGH456789:;<=>?@ANone"#+NST20number of kvars whose removal makes deps acyclic,number of kvars that appear >= 2 in some LHSnumber of kvarsis dep-graph reducibleset of non-linear kvarsKGeneric Dependencies ------------------------------------------------------mCompute constraints that transitively affect target constraints, and delete everything else from F.SInfo aDO NOT DELETE! sliceCSucc :: Slice -> CSucc sliceCSucc sl = i -> M.lookupDefault [] i im where im = M.fromList [(i, is) | (i,_,is) <- slEdges sl]KConstraint Graph ----------------------------------------------------------KRanks from Graph ----------------------------------------------------------KDependencies --------------------------------------------------------------Eliminated Dependencies0 "eliminates" a kvar k by replacing every "path"ki -> ci -> k -> c with an edgeki ------------> cKCompute Dependencies and Cuts --------------------------------------------- returns an t that renders the dependency graph acyclic by picking _at least one_ kvar from each non-trivial SCC in the graph extends the input  by adding kuts that ensure that the *maximum distance* between an eliminated KVar and a cut KVar is *upper bounded* by a given threshold.  None+NType alias for a function to construct a partition. mkPartition and mkPartition' are the two primary functions that conform to this interfaceKMulticore info ------------------------------------------------------------KConstraint Partition Container --------------------------------------------Partition an FInfo into multiple disjoint FInfos. Info is Nothing to produce the maximum possible number of partitions. Or a MultiCore Info to control the partitioningYPartition an FInfo into a specific number of partitions of roughly equal amounts of workfReturn the "size" of a CPart. Used to determine if it's substantial enough to be worth parallelizing.Convert a CPart to an FInfoConvert an FInfo to a CPart"typically a F.FInfo a or F.CPart a)describes thresholds and partiton amountsThe originial FInfo&A list of the smallest possible CParts,At most N partitions of at least thresh workmkPartition or mkPartition'  F.FInfo aor [F.CPart a]0NoneHmVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{}|~ NoneN l  Constraint IdTime at which insertedRank of constraintFWorkItems ------------------------------------------------------------KWorklist ------------------------------------------------------------------KInitialize worklist and slice out irrelevant constraints ------------------FCandidate Constraints to be checked AFTER computing Fixpoint --------- Pending APIFSet API -------------------------------------------------------------- !NoneN+w computes the "real" domain of each kvar, which is a SUBSET of the input domain, in which we KILL the parameters x@ which appear in substitutions of the form `K[x := y]` where y is not in the env.dropAdtMeasures removes all the measure definitions that correspond to constructor, selector or test names for declared datatypes, as these are now "natively" handled by the SMT solver.S traverses the constraints to find (string) literals that are then added to the dLits field.See issue liquid-fixpoint issue #230. This checks that whenever we have, G1 |- K.su1 G2, K.su2 |- rhs then G1 cap G2 subseteq wenv(k) removes dead `K[x := e]` where x NOT in the domain of K.z updates the kvar-domains in the wf constraints to a subset of the original binders, where we DELETE the parameters x= which appear in substitutions of the form `K[x := y]` where y is not in the env.*`restrictWf kve k w` restricts the env of w to the parameters in `kve k`.;check that no constraint has free variables (ignores kvars)*check that no qualifier has free variables=check that each constraint has RHS of form [k1,...,kn] or [p]1symbol |-> sort for EVERY variable in the SInfo;  can ONLY be called with **sanitized** environments (post the uniqification etc.) or else you get duplicate sorts and other such errors.Drop func-sorted bind that are shadowed by constant (if same type, else error)-Drop irrelevant binders from WfC Environments nonDerivedLH* keeps a bind x if it does not start with M which is used typically for names that are automatically "derived" by GHC (and which can) blow up the environments thereby clogging instantiation, etc. NOTE: This is an LH specific hack and should be moved there.+Generic API for Deleting Binders from FInfo0Replace KVars that do not have a WfC with PFalse"None&'16;<=>?NOST1\ISubstitute Gradual Solution ---------------------------------------------JThe Unique Monad ---------------------------------------------------------IMake each gradual appearence unique -------------------------------------JexpandWF -----------------------------------------------------------------#None6O;FA e maps an old name and sort to new name, represented by a hashmap containing association lists. 3 as new name means the name is the same as the old.An  stores for each constraint and BindId the set of other BindIds that it references, i.e. those where it needs to know when their names gets changedBind identifierConstraint identifier?G replaces the refinements of "unused" binders with "true". see testspos5unused.fq for an example of why this phase is needed.] seems to do the actual work of renaming all the binders to use their sort-specific names.$None;=NQHInformation about size of formula corresponding to an "eliminated" KVar. KInitial Solution (from Qualifiers and WF constraints) --------------------- @Predicate corresponding to LHS of constraint in current solution/`cubePred g s k su c` returns the predicate for(k . su)defined by using cubec := [b1,...,bn] |- (k . su')in the binder environment g.Dbs' := the subset of "extra" binders in [b1...bn] that are *not* in gB p' := the predicate corresponding to the "extra" binders  cubePredExc computes the predicate for the subset of binders bs'. The output is a tuple, `(xts, psu, p, kI)` such that the actual predicate we want is `Exists xts. (psu / p)`.  substElim returns the binders that must be existentially quantified, and the equality predicate relating the kvar-"parameters" and their actual values. i.e. givenK[x1 := e1]...[xn := en]Awhere e1 ... en have types t1 ... tn we want to quantify outx1:t1 ... xn:tnand generate the equality predicate && [x1 ~~ e1, ... , xn ~~ en] we use ~~ because the param and value may have different sorts, see:testsposkvar-param-poly-00.hs*Finally, we filter out binders if they are Y"free" in e1...en i.e. in the outer environment. (Hmm, that shouldn't happen...?)hare binders corresponding to sorts (e.g. `a : num`, currently used to hack typeclasses current.)       %None;=NRKInitial Gradual Solution (from Qualifiers and WF constraints) -------------&None;<=NOanormalize lamsenable extensionality axiomsenable alpha equivalence axiomsenable beta equivalence axiomsenable normal form axioms'allow higher order thus defunctionalize/lambda expressions appearing in the expressions$redexes appearing in the expressionssorts of new lambda-bindersKContainers defunctionalization --------------------------------------------XExpressions defunctionalization --------------------------------------------------------KAlpha Equivalence ---------------------------------------------------------KNormalizations ------------------------------------------------------------KBeta Equivalence ----------------------------------------------------------KLow level monad manipulation ----------------------------------------------getLams and getRedexes return the (previously seen) lambdas and redexes, after "closing" them by quantifying out free vars corresponding to the fresh binders in . !"#'None %;=CNOVegN$Symbolic Evaluation with SMT%Knowledge (SMT Interaction)&Instantiate Axioms&Creating Measure Info'' unfolds or instantiates an equation at a particular list of argument values. We must also substitute the sort-variables that appear as coercions. See testsproofple1.fq&&()*$+,-./0%123456(None<j7 Map each 6 to the list of constraints on which it appears on RHS(( constructs a V\ comprising the Solution and various indices needed by the worklist-based refinement loop(()NoneVj)*+)*+*NonekI,-./,-./+None6uq 8# Horn Constraints1# Refine Iterations9 # smtBracket calls (push/pop):# smtCheckUnsat calls;# times SMT said RHS Valid<SMT Solver Context=All variables and types>Solver Statistics2KSolver Monadic API --------------------------------------------------------5KSMT Interface -------------------------------------------------------------Z`filterRequired [(x1, p1),...,(xn, pn)] q` returns a minimal list [xi] s.t. / [pi] => q6J`filterValid p [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]`7o`filterValidGradual ps [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]` | for some p in the list ps 0123456789:; 2345679801;:10?819:;@A<=>,None;<=NO4B Progress BarCtidyResult ensures we replace the temporary kVarArg names introduced to ensure uniqueness with the original names in the given WF constraints.DFSingle Step Refinement -----------------------------------------------EKConvert Solution into Result ----------------------------------------------FF\ transforms each KVar's result by removing conjuncts that are implied by others. That is,<minimizeConjuncts :: ps:[Pred] -> {qs:[Pred] | subset qs ps}ssuch that `minimizeConjuncts ps` is a minimal subset of ps where no is implied by /_{q' in qs qs} see: testsposmin00.fq for an example.G@Predicate corresponding to RHS of constraint in current solutionHJInteraction with the user when Solving -----------------------------------@A@A-None6BBIJKLMNOP.NoneVm GFSolve an .fq file ----------------------------------------------------HKSolve FInfo system of horn-clause constraints -----------------------------QCSolve in parallel after partitioning an FInfo to indepdendant partsRCSolve in parallel after partitioning an FInfo to indepdendant partsSESolve a list of FInfos using the provided solver function in parallelTKNative Haskell Solver -----------------------------------------------------UKNative Haskell Solver -----------------------------------------------------JKExtract ExitCode from Solver Result ---------------------------------------KKParse External Qualifiers -------------------------------------------------2GHIJKH2GJKIV1231241251261789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                               ! " # $ % % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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{|}~      !"#$%&'()*++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd<efghijklmnopqrstuvwxyz{|}~q      !""#$%&'()*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyz{|}~)!                !!!"""""" " " " " """""""""""#####$$$$ $!$"%&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5'6'7(8)9):);*<*=*>*?++@+A+B+C+D+E+F+G+H+!+I++J++K,L,8-M-N-J--K.O.L.P.Q.RSTUVWXYZ[\]^__`abcdefghii j k l m n o p q rstuvwxyz{{|}~}fg2Y                     !!!!!!!!!!!!!!!""""""""""""""#TU######$$$$$$$$ & & & & &&&&&&-&&&&&&&&&&&'''' '!'"'#''$'%'&'''(')'*'+','-'.("+/+0+1+2+3+4+5++6+,7,8,9,F,:,;,<---=->-?-@-A-B.C.D.E.F.GH.liquid-fixpoint-0.7.0.7-DC7X7gzBmY2Ic8PTKxWTVgLanguage.Fixpoint.ParseLanguage.Fixpoint.Types.SpansLanguage.Fixpoint.Misc#Language.Fixpoint.Types.PrettyPrintLanguage.Fixpoint.Types.NamesLanguage.Fixpoint.Types.Sorts#Language.Fixpoint.Types.RefinementsLanguage.Fixpoint.Types.Errors%Language.Fixpoint.Types.Substitutions$Language.Fixpoint.Types.Environments Language.Fixpoint.Types.Theories Language.Fixpoint.Types.TriggersLanguage.Fixpoint.Utils.FilesLanguage.Fixpoint.Types.Config#Language.Fixpoint.Types.ConstraintsLanguage.Fixpoint.Types.UtilsLanguage.Fixpoint.Types.Visitor%Language.Fixpoint.Solver.UniqifyKVarsLanguage.Fixpoint.Smt.TypesLanguage.Fixpoint.Smt.Bitvector!Language.Fixpoint.Graph.ReducibleLanguage.Fixpoint.Smt.TheoriesLanguage.Fixpoint.SortCheck!Language.Fixpoint.Types.SolutionsLanguage.Fixpoint.Graph.TypesLanguage.Fixpoint.Graph.IndexedLanguage.Fixpoint.Smt.Serialize$Language.Fixpoint.Solver.TrivialSortLanguage.Fixpoint.Smt.InterfaceLanguage.Fixpoint.Graph.Deps!Language.Fixpoint.Graph.Partition!Language.Fixpoint.Solver.Worklist!Language.Fixpoint.Solver.Sanitize Language.Fixpoint.Types.Graduals%Language.Fixpoint.Solver.UniqifyBinds!Language.Fixpoint.Solver.Solution(Language.Fixpoint.Solver.GradualSolution!Language.Fixpoint.Defunctionalize$Language.Fixpoint.Solver.Instantiate"Language.Fixpoint.Solver.EliminateLanguage.Fixpoint.Minimize Language.Fixpoint.Utils.ProgressLanguage.Fixpoint.Solver.MonadLanguage.Fixpoint.Solver.Solve"Language.Fixpoint.Utils.StatisticsLanguage.Fixpoint.SolverLanguage.Fixpoint.TypesLanguage.Fixpoint.Graph$parsec-3.1.11-Jx0X6lpzdHgC5NMoYR1Rc5Text.Parsec.Expr AssocRight AssocLeft AssocNoneAssocText.Parsec.Pos SourcePosEqHashListNEMoodsOkLoudSadHappyAngry|-> firstMaybe asyncMapM traceShowhashMapToAscList getUniqueInt editDistance moodColor wrapStars withColor colorStrLn colorPhaseLn startPhasedoneLine donePhase putBlankLnwraprepeats errorstarfst3snd3thd3secondMmlookup safeLookup mfromJustinsertsremovescountgroup groupBase groupListgroupMapallMaphashNubsortNub duplicatessafeZip safeZipWith safeFromListsafeHeadsafeLastsafeInit safeUncons safeUnsnocexecuteShellCommand applyNonNullarrowdcolon interspersetshow writeLoud ensurePath singletonpairtriplefMwhenM mapEithercomponentsWith topoSortWithexTopocoalesce coalesceEdgesmapFstmapSndallCombinationspowerset=>><<=<$$>revMapMPTableptableDocTablePPrint pprintTidy pprintPrecTidyLossyFullFixpointtoFixsimplifytraceFixshowFixpprintshowpp showTabletracepp notracepp pprintKVsboxHSepboxDocdocBox$fFixpointDouble$fFixpointInteger $fFixpointInt$fFixpointBool$fFixpoint(,,) $fFixpoint(,) $fFixpoint[]$fFixpointMaybe $fFixpoint()$fFixpointHashSet $fPPrintText$fPPrintInteger $fPPrintInt $fPPrint() $fPPrintFloat $fPPrintBool $fPPrint(,)$fPPrint(,,,,) $fPPrint(,,,) $fPPrint(,,)$fPPrintHashMap$fPPrintHashSet $fPPrint[] $fPPrintMaybe $fPPrintDoc$fPPrintDocTable$fMonoidDocTable$fEqTidy $fOrdTidySrcSpanSSsp_startsp_stopLocatedLocloclocEvalsrcSpan toSourcePos sourcePosElts dummySpan panicSpanatLoclocAtdummyLocdummyPos$fFixpointSourcePos$fHashableSourcePos$fPPrintSourcePos$fSerializeSourcePos$fBinarySourcePos$fNFDataSourcePos$fIsStringLocated$fHashableLocated$fBinaryLocated $fOrdLocated $fEqLocated$fPPrintLocated $fShowLocated$fTraversableLocated$fFoldableLocated$fFunctorLocated$fFixpointLocated$fNFDataLocated$fHashableSrcSpan$fPPrintSrcSpan$fSerializeSrcSpan$fLoc() $fLocLocated $fDataLocated$fGenericLocated $fEqSrcSpan $fOrdSrcSpan $fShowSrcSpan $fDataSrcSpan$fGenericSrcSpanSymbolicsymbolLocText LocSymbolSymbolisDummy symbolText symbolStringsymbolSafeTextsymbolSafeStringsymChars isPrefixOfSym isSuffixOfSymheadSymconsSym unconsSym lengthSymdropSym stripPrefix suffixSymbolvvisNontrivialVVvvCon dummySymbol testSymbol isTestSymbol litSymbol isLitSymbol unLitSymbol intSymbol tempSymbol renameSymbol kArgSymbol existSymbol gradIntSymbol tempPrefix anfPrefix tidySymbol nonSymbol isNonSymbolsymbolicString symbolBuilder buildMany lambdaName lamArgSymbolisLamArgSymbol setToIntNamebitVecToIntName mapToIntName realToIntName toIntName boolToIntName setApplyNamebitVecApplyName mapApplyName boolApplyName realApplyName intApplyName applyName preludeName dummyName boolConName funConName listConName listLConName tupConName setConName mapConNamevvName propConName strConNamenilNameconsName size32Name size64Name bitVecNamebvOrName bvAndName mulFuncName divFuncNameprims$fFixpointText$fFixpointSymbol$fPPrintSymbol $fShowSymbol$fIsStringSymbol$fBinarySymbol$fNFDataSymbol$fHashableSymbol$fHashableDescription$fUninternableSymbol$fInternedSymbol $fOrdSymbol $fEqSymbol$fSymbolicSymbol $fSymbolic[]$fSymbolicText$fSymbolicLocated$fEqDescription $fDataSymbol$fGenericSymbol$fGenericInternedText$fDataInternedTextSubDataDeclDDeclddTyConddVarsddCtorsDataCtorDCtordcNamedcFields DataFieldDFielddfNamedfSortSortFIntFRealFNumFFracFObjFVarFFuncFAbsFTCFAppTCEmbFTycon mappendFTC intFTyCon boolFTyCon realFTyCon numFTyCon strFTyCon listFTyCon setFTyCon mapFTyConisListTCsizeBv fTyconSymbolsymbolNumInfoFTyCon symbolFTyconfAppfAppTCfTyconSelfSortunFAppunAbsfObj sortFTycon functionSort isFirstOrder isNumericisRealisStringmkFFuncbkFFunc isPolyInstboolSortstrSortintSortrealSortfuncSortsetSort bitVecSortmapSort fTyconSort basicSorts sortSubst$fNFDataTCInfo$fBinaryTCInfo$fMonoidTCInfo$fNFDataFTycon$fBinaryFTycon$fPPrintFTycon$fFixpointFTycon $fLocFTycon$fHashableFTycon $fEqFTycon$fSymbolicFTycon $fMonoidSort $fNFDataSort $fBinarySort$fFixpointSort$fHashableSort$fNFDataDataField$fBinaryDataField$fPPrintDataField$fFixpointDataField$fSymbolicDataField$fNFDataDataCtor$fBinaryDataCtor$fPPrintDataCtor$fFixpointDataCtor$fSymbolicDataCtor$fNFDataDataDecl$fBinaryDataDecl$fPPrintDataDecl$fFixpointDataDecl$fSymbolicDataDecl $fNFDataSub $fBinarySub $fEqTCInfo $fOrdTCInfo $fShowTCInfo $fDataTCInfo$fGenericTCInfo $fOrdFTycon $fShowFTycon $fDataFTycon$fGenericFTycon$fEqSort $fOrdSort $fShowSort $fDataSort $fGenericSort $fEqDataField$fOrdDataField$fShowDataField$fDataDataField$fGenericDataField $fEqDataCtor $fOrdDataCtor$fShowDataCtor$fDataDataCtor$fGenericDataCtor $fEqDataDecl $fOrdDataDecl$fShowDataDecl$fDataDataDecl$fGenericDataDecl $fGenericSubReftableisTautoppTytopbotmeettoReftofReftparamsSubablesymssubstasubstfsubstsubst1isFalse Predicateprop Expressionexpr SortedReftRRsr_sortsr_reftReftGradInfogsrcgusedPredExprESymEConEVarEAppENegEBinEIteECstELamETAppETAbsPAndPOrPNotPImpPIffPAtomPKVarPAllPExistPGradECoercBopPlusMinusTimesDivModRTimesRDivBrelEqNeGtGeLtLeUeqUneConstantIRLSymConstSLKVSubKVSksuVVksuSortksuKVarksuSubstSubstSuKVarKVkv HasGradual isGradualgVarsungradERDivEDivERTimesETimesEEqEBotPFalsePTopPTrue reftConjunctsintKvar srcGradInfomkEAppeApps splitEAppeAppC debruijnIndexelit isContraPred isTautoPred pprintRefteVareProppAndpOr&.&|.|pItepExistmkPropisSingletonReftexprReft notExprReft uexprReftpropReftpredReftreft mapPredReftisFunctionSortedReft isNonTrivialreftPredreftBindpGAndspGAnd symbolReft usymbolReftvv_trueSortedRefttrueReft falseReft flattenRefas conjuncts $fPPrintSort$fBinarySrcSpan$fBinaryHashMap$fNFDataSrcSpan $fPPrintKVar$fFixpointKVar$fHashableKVar $fShowKVar $fBinaryKVar $fNFDataKVar$fPPrintSymConst$fFixpointSymConst$fSymbolicSymConst$fHashableSymConst$fBinarySymConst$fNFDataSymConst$fPPrintConstant$fFixpointConstant$fHashableConstant$fBinaryConstant$fNFDataConstant $fPPrintBrel$fFixpointBrel$fHashableBrel $fBinaryBrel $fNFDataBrel $fPPrintBop $fFixpointBop $fHashableBop $fBinaryBop $fNFDataBop$fBinaryGradInfo$fNFDataGradInfo $fPPrintExpr$fFixpointExpr $fPPrintSubst$fFixpointSubst $fShowSubst$fHasGradualExpr $fBinaryExpr $fBinarySubst $fNFDataExpr $fNFDataSubst $fPPrintKVSub$fHasGradualReft $fBinaryReft $fNFDataReft$fHasGradualSortedReft$fBinarySortedReft$fNFDataSortedReft$fExpressionLocated$fExpressionInt$fExpressionInteger$fExpressionText$fExpressionSymbol$fExpressionExpr$fExpressionReft$fExpressionSortedReft$fPredicateBool$fPredicateExpr$fPredicateSymbol$fFalseableReft$fFalseableExpr$fSubableLocated$fEqKVar $fOrdKVar $fDataKVar $fGenericKVar$fIsStringKVar $fEqSymConst $fOrdSymConst$fShowSymConst$fDataSymConst$fGenericSymConst $fEqConstant $fOrdConstant$fShowConstant$fDataConstant$fGenericConstant$fEqBrel $fOrdBrel $fShowBrel $fDataBrel $fGenericBrel$fEqBop$fOrdBop $fShowBop $fDataBop $fGenericBop $fEqGradInfo$fShowGradInfo$fDataGradInfo$fGenericGradInfo$fEqExpr $fShowExpr $fDataExpr $fGenericExpr $fEqSubst $fDataSubst$fGenericSubst $fEqKVSub $fDataKVSub$fGenericKVSub $fShowKVSub$fEqReft $fDataReft $fGenericReft$fEqSortedReft$fDataSortedReft$fGenericSortedReft FixResultCrashSafeUnsafeerrLocerrMsgErrorcatError catErrorserrpanicdiedieAtexit resultDoc colorResulterrFreeVarInQualerrFreeVarInConstrainterrIllScopedKVar$fSerializeDoc$fSerializeTextDetails$fSerializeDoc0$fSerializeAnnotDetails$fFixpointError1$fPPrintError1 $fOrdError1$fSerializeError1$fExceptionError $fPPrintError$fSerializeError$fFunctorFixResult$fMonoidFixResult $fEqFixResult$fNFDataFixResult$fExceptionFixResult$fBinaryFixResult$fSerializeFixResult $fEqError1 $fShowError1$fGenericError1 $fEqError $fOrdError $fShowError$fGenericError$fDataFixResult$fFoldableFixResult$fTraversableFixResult$fShowFixResult$fGenericFixResult$fGenericAnnotDetails filterSubstmkSubst isEmptySubsttargetSubstSyms subst1Except substfExcept substExcept$fShowSortedReft $fShowReft$fFixpointSortedReft$fFixpointReft$fPPrintSortedReft $fPPrintReft$fReftableSortedReft$fReftableReft $fReftable()$fSubableSortedReft $fSubableReft$fMonoidSortedReft $fMonoidReft $fMonoidExpr $fSubableExpr$fSubableSymbol$fSubableHashMap $fSubable[] $fSubable(,) $fSubable() $fMonoidSubstPackspackmSESearchFoundAltsSolEnvsoeBindsBindEnvbeBindsSEnvIBindEnvBindMapBindId toListSEnv fromListSEnv fromMapSEnvmapSEnvmapMSEnvmapSEnvWithKey deleteSEnv insertSEnv lookupSEnv emptySEnv memberSEnvintersectWithSEnvdifferenceSEnv filterSEnv unionSEnv unionSEnv'lookupSEnvWithDistance emptyIBindEnvdeleteIBindEnvmemberIBindEnvinsertsIBindEnv elemsIBindEnvfromListIBindEnv insertBindEnv emptyBindEnv filterBindEnvbindEnvFromList elemsBindEnv bindEnvToList mapBindEnvmapWithKeyMBindEnv lookupBindEnvfilterIBindEnv unionIBindEnvintersectionIBindEnv nullIBindEnv diffIBindEnv adjustBindEnvenvCsgetPackmakePack$fBinaryHashSet$fBinaryIBindEnv$fNFDataIBindEnv$fFixpointIBindEnv$fMonoidIBindEnv$fPPrintIBindEnv $fBinarySEnv $fNFDataSEnv $fMonoidSEnv $fShowSEnv$fFixpointSEnv $fFunctorSEnv $fPPrintSEnv$fPPrintSizedEnv$fBinarySizedEnv$fNFDataSizedEnv$fMonoidSizedEnv$fFixpointSizedEnv $fMonoidPacks $fPPrintPacks$fFixpointPacks $fBinaryPacks $fNFDataPacks $fEqIBindEnv$fDataIBindEnv$fGenericIBindEnv$fEqSEnv $fDataSEnv $fGenericSEnv$fFoldableSEnv$fTraversableSEnv $fEqSizedEnv$fShowSizedEnv$fFunctorSizedEnv$fFoldableSizedEnv$fGenericSizedEnv$fTraversableSizedEnv $fEqSolEnv $fShowSolEnv$fGenericSolEnv $fEqPacks $fShowPacks$fGenericPacksSmtSortSIntSBoolSRealSStringSSetSMapSBitVecSVarSDataSemUninterpCtorTestFieldTheory TheorySymbolThytsSymtsRawtsSorttsInterpSymEnvseSortseTheoryseDataseLitsseApplsRawsymEnv symEnvTheory symEnvSort insertSymEnv symbolAtNamesymbolAtSmtName isIntSmtSort sortSmtSort $fBinarySem $fPPrintSem $fNFDataSem$fPPrintTheorySymbol$fFixpointTheorySymbol$fBinaryTheorySymbol$fNFDataTheorySymbol$fPPrintSmtSort$fBinarySmtSort$fNFDataSmtSort$fHashableSmtSort$fMonoidSymEnv$fBinarySymEnv$fNFDataSymEnv$fEqSem$fOrdSem $fShowSem $fDataSem $fGenericSem$fEqTheorySymbol$fOrdTheorySymbol$fShowTheorySymbol$fDataTheorySymbol$fGenericTheorySymbol $fEqSmtSort $fOrdSmtSort $fShowSmtSort $fDataSmtSort$fGenericSmtSort $fEqSymEnv $fShowSymEnv $fDataSymEnv$fGenericSymEnvTrigger NoTrigger LeftHandSide TriggeredTR noTriggerdefaultTrigger makeTriggers$fNFDataTrigger$fBinaryTrigger$fPPrintTrigger$fNFDataTriggered$fBinaryTriggered$fPPrintTriggered $fEqTrigger $fShowTrigger$fGenericTrigger $fEqTriggered$fShowTriggered$fFunctorTriggered$fGenericTriggeredExtCgiFqOutHtmlAnnotVimHsHsBootLHsJsTsSpecBinSpecHqualsResultCstMkdnJsonSavedCacheDotPartAutoPAssDatBinFqSmt2MinMinQualsMinKVarsgetFixpointPath getZ3LibPathwithExt extFileName tempDirectory extFileNameR isExtFile extModuleName copyFiles getFileInDirsisBinary$fEqExt$fOrdExt $fShowExt EliminateNoneSomeAll SMTSolverZ3Cvc4MathsatConfigsrcFilecores minPartSize maxPartSizesolverlinear stringTheory defunctionallowHO allowHOqs eliminate elimBound elimStats solverStatsmetadatastatspartssaveminimize minimizeQs minimizeKs minimalSolgradual ginteractiveextensionalityalphaEquivalencebetaEquivalence normalFormautoKuts nonLinCutsnoslice rewriteAxioms withPragmasdefaultMinPartSizedefaultMaxPartSizeuseElim defConfiggetOpts multicore queryFile$fShowSMTSolver$fDefaultSMTSolver$fShowEliminate$fDefaultEliminate$fSerializeEliminate$fDefaultConfig $fEqSMTSolver$fDataSMTSolver$fGenericSMTSolver $fEqEliminate$fDataEliminate$fGenericEliminate $fEqConfig $fDataConfig $fShowConfig$fGenericConfigRewriteSMeasuresmNamesmDCsmArgssmBodyEquationEqueqNameeqArgseqBodyeqSorteqRecAxiomEnvAEnvaenvEqs aenvSimpl aenvExpandSolverGInfoFIcmwsbsgLitsdLitskutsqualsbindInfoddeclshoInfoassertsaeHOInfoHOIhoBindshoQualsSInfoFInfo FInfoWithOptsFIOfioFIfioOptsKutsKSksVars QualifierQqNameqParamsqBodyqPos resStatus resSolution gresSolution FixSolution GFixSolutionTaggedCsenvsidstagsinfoclhscrhsSimpC_cenv_crhs_cid_cbind_ctag_cinfoSubCslhssrhsSubcIdGWInfogsymgsortgexprginfoWfCGWfCwenvwrftwinfowexprwlocTaggwInfo updateWfCExprisGWfc strengthenHypsubcId toGFixSolunsafesafeisSafeisUnsafewfCmkSubCsubCshiftVVaddIdstrueQual qualifier remakeQualmkQual substVarsksMemberfi allowHOquals toFixpoint writeFInfo convertFormat saveQuery mkEquation $fFixpointDoc$fNFDataEliminate$fNFDataSMTSolver$fBinaryEliminate$fBinarySMTSolver $fNFDataWfC $fBinaryWfC $fFixpointWfC $fPPrintWfC $fShowWfC$fHasGradualWfC$fNFDataGWInfo$fBinaryGWInfo $fNFDataSubC $fBinarySubC $fPPrintSubC $fShowSubC$fFixpointFixResult $fNFDataSimpC $fBinarySimpC $fPPrintSimpC $fShowSimpC$fFixpointSimpC$fFixpointSubC$fTaggedCSubCa$fTaggedCSimpCa$fNFDataGFixSol$fBinaryGFixSol $fShowGFixSol$fPPrintGFixSol$fNFDataResult$fMonoidResult$fPPrintQualifier$fFixpointQualifier$fLocQualifier$fNFDataQualifier$fBinaryQualifier $fMonoidKuts$fFixpointKuts $fNFDataKuts $fBinaryKuts$fMonoidHOInfo$fNFDataHOInfo$fBinaryHOInfo$fFixpointEquation$fPPrintEquation$fSubableEquation$fNFDataEquation$fBinaryEquation$fPPrintRewrite$fFixpointRewrite$fNFDataRewrite$fBinaryRewrite$fFixpointAxiomEnv$fPPrintAxiomEnv$fMonoidAxiomEnv$fNFDataAxiomEnv$fBinaryAxiomEnv $fMonoidGInfo$fHasGradualGInfo $fNFDataGInfo $fBinaryGInfo $fPTableGInfo$fEqWfC $fGenericWfC $fFunctorWfC $fEqGWInfo$fGenericGWInfo$fEqSubC $fGenericSubC $fFunctorSubC$fGenericSimpC$fFunctorSimpC$fGenericGFixSol$fMonoidGFixSol$fFunctorGFixSol$fGenericResult $fShowResult $fEqQualifier$fShowQualifier$fDataQualifier$fGenericQualifier$fEqKuts $fShowKuts $fGenericKuts $fEqHOInfo $fShowHOInfo$fGenericHOInfo $fEqEquation$fShowEquation$fGenericEquation $fEqRewrite $fShowRewrite$fGenericRewrite $fEqAxiomEnv$fShowAxiomEnv$fGenericAxiomEnv $fEqGInfo $fShowGInfo$fFunctorGInfo$fGenericGInfo kvarDomain reftFreeVarssortedReftConcKVars SymConsts symConstsCoSub VisitablevisitVisitorctxExprtxExpraccExprdefaultVisitorfoldtransmapKVars mapKVars' mapGVars'mapExprmapMExpr mapKVarSubstssizelamSizeeappskvarsenvKVars envKVarsNrhsKVarsisKvarCisConcC stripCasts applyCoSubfoldSort foldDataDecl$fVisitableGInfo$fVisitableSubC$fVisitableSimpC$fVisitableSizedEnv$fVisitable(,)$fVisitableSortedReft$fVisitableReft$fVisitableExpr $fMonoidMInt$fSymConstsExpr$fSymConstsReft$fSymConstsSortedReft$fSymConstsSimpC$fSymConstsSubC$fSymConstsSizedEnv$fSymConstsGInfo wfcUniqifySMTLIB2smt2ContextCtxctxPidctxCinctxCoutctxLog ctxVerbosectxExtctxAeqctxBeqctxNorm ctxSymEnvResponseSatUnsatUnknownValuesCommandPushPopCheckSatDeclDataDeclareDefineAssertAssertAxDistinctGetValueCManyrunSmt2$fPPrintCommand $fEqCommand $fShowCommand $fEqResponse$fShowResponseBvOpBvAndBvOrBvSizeS32S64BvmkSortbvTyConeOp$fExpressionBv $fEqBvSize $fOrdBvSize $fShowBvSize $fDataBvSize$fGenericBvSize$fEqBvOp $fOrdBvOp $fShowBvOp $fDataBvOp $fGenericBvOp Inputablerrrr'FixityFInfixFPrefixFPostfixfpredfnamefop2fassocfop1PStateParserlexerreserved reservedOpparensbracketsanglesbracessemicoloncomma whiteSpaceblanksinteger locParserPcondIdPupperIdPlowerIdP isNotReservedinfixIdPisSmall locLowerIdP locUpperIdPsymbolP constantPexpr0PexprP addOperatorPfunAppPsortPbvSortPpredPrefaPrefBindPbindPrefPrefDefP dataFieldP dataCtorP dataDeclP qualifierPpairP remainderP initPStatedoParse' parseFromFile freshIntP $fInputable[]$fInputableCommand$fInputableFInfoWithOpts$fInputableGInfo$fInputable(,)$fInputableFixResult$fInputableExpr$fInputableConstant$fInputableSymbol $fShowDef $fGenericDef isReduciblesetEmptysetEmpsetCapsetSubsetAddsetMemsetComsetCupsetDifsetSngmapSelmapStomapCupmapDef smt2Symbolsmt2App isSmt2Apppreamble theorySymbols maxLamArg axiomLiteralsdataDeclSymbols$fSMTLIB2SmtSortTVSubstEnv Elaborate elaborateisMonosortExpr checkSortExprcheckSortedReftcheckSortedReftFull checkSortFull checkSortedpruneUnsortedRefttoInt unApplyAt applySortsexprSortexprSort_maybe unifySorts unifyFastapply$fElaborateSimpC$fElaborateSizedEnv$fElaborateSortedReft $fElaborate[]$fElaborate(,)$fElaborateExpr$fElaborateSort$fElaborateMaybe$fElaborateTriggered$fElaborateGInfo$fCheckableSortedReft$fCheckableExpr$fMonoidTVSubst $fShowTVSubstCMapIndexFastIdxbindExprkvUsekvDefenvBindsenvTxenvSortsBindPredBPbpConcbpKVarBIndexRootBindCstrKIndexkiBIndexkiPoskiKVarEQualEQL_eqQualeqPred_eqArgsCandCubecuBindscuSubstcuIdcuTagHypSolsEnvgMapsScpGBindQBind GSolutionSolutionupdate emptyGMapupdateGMapWithKeyqbqbExprsqbToGbgbToQbsgbEqualsequalsGb gbFilterMqbFilter updateGMapresult resultGradualfromListqbPreds lookupQBindglookuplookup trueEqualeQual $fShowCube $fPPrintCube $fPPrintSol $fFunctorSol $fMonoidSol $fNFDataEQual $fPPrintEQual $fNFDataGBind $fPPrintQBind $fNFDataQBind$fPPrintKIndex$fHashableKIndex$fPPrintBIndex$fHashableBIndex$fPPrintBindPred $fEqEQual $fShowEQual $fDataEQual$fGenericEQual $fShowGBind $fDataGBind$fGenericGBind $fShowQBind $fDataQBind$fGenericQBind $fEqQBind $fEqKIndex $fOrdKIndex $fShowKIndex$fGenericKIndex $fEqBIndex $fOrdBIndex $fShowBIndex$fGenericBIndex$fShowBindPred SolverInfoSIsiSolsiQuerysiDepssiVarsRankrSccrIccrTagCDepsCDscSucccPrevcRankcNumSccCGraphgEdgesgRanksgSuccgSccsSliceslKVarCsslConcCsslEdgesDepEdgeKVReadKVCompsCompsCEdgeKVGraphkvgEdgesCVertexDKVar writeGraph writeEdges isRealEdge lookupCMap$fHashableCVertex$fPPrintCVertex$fPPrintKVGraph $fPPrintRank $fEqCVertex $fOrdCVertex $fShowCVertex$fGenericCVertex $fEqSlice $fShowSlice$fEqRank $fShowRankIKVGraphigSuccigPredaddLinksdelNodes edgesIkvg ikvgEdgesgetSuccsgetPreds$fShowIKVGraph smt2SortMono$fSMTLIB2Triggered$fSMTLIB2Command $fSMTLIB2Expr $fSMTLIB2Brel $fSMTLIB2Bop$fSMTLIB2Constant$fSMTLIB2SymConst$fSMTLIB2Located$fSMTLIB2Symbol $fSMTLIB2(,) nontrivsorts $fHashableNTV$fEqNTV$fOrdNTV $fShowNTV $fGenericNTVcheckValidWithContext checkValid checkValid' checkValidscommandsmtWrite makeContextmakeContextWithSEnvmakeContextNoLogcleanupContextsmtPushsmtPopsmtDeclssmtDecl smtFuncDecl smtCheckSat smtAssertsmtAssertAxiom smtDistinct smtCheckUnsat smtBracketAt smtBracketElimsDepsdepCuts depNonCutssliceisTarget decomposekvEdgeselimDepselimVarsgraphStatistics $fMonoidElims $fPPrintElims $fPTableStats $fShowElimsMCInfomcCores mcMinPartSize mcMaxPartSizeCPartpwspcmmcInfo partition partition' partitionNdumpPartitions $fMonoidCPart $fShowMCInfoStatsWorklistwRanksinitunsatCandidatespoppush $fOrdWorkItem$fPPrintWorkItem$fPTableWorklist$fPPrintWorklist $fEqStats $fShowStats $fEqWorkItem$fShowWorkItemsanitizedropDeadSubsts symbolEnvGradualgsubstGSol makeSolutionsuniquify $fShowGSol $fMonoidGSol $fUniqueExpr $fUniqueReft$fUniqueSortedReft $fUniqueInt$fUniqueIBindEnv $fUniqueSimpC$fUniqueHashMap$fGradualGInfo$fGradualHashMap$fGradualSizedEnv$fGradualSimpC$fGradualSortedReft $fGradualReft $fGradualExpr renameAll $fHashableRef $fNFDataRef$fEqRef $fGenericReflhsPred $fMonoidKInfo $fEqKInfo $fOrdKInfo $fShowKInfoDefuncdefuncdefunctionalize defuncAny defuncAxioms$fDefuncHashMap $fDefunc[] $fDefuncSort$fDefuncSizedEnv $fDefuncSEnv $fDefuncExpr $fDefuncReft $fDefunc(,) $fDefunc(,)0$fDefuncSortedReft $fDefuncWfC $fDefuncSimpC$fDefuncTriggered $fDefuncGInfo instantiate$fExpression(,) solverInfominQueryminQualsminKvars withProgress progressInit progressTick progressClosenumIterSolveM runSolverMgetBindsfilterRequired filterValidfilterValidGradual smtEnablembqicheckSattickIter $fNFDataStats$fGenericStatssolve statistics $fPPrintStatssolveFQ simplifyFInfo resultExit parseFInfoSafeTextbaseGHC.Base$ textSymbol alphaCharsS _symbolId symbolRaw symbolEncodedD:R:DescriptionSymbol0DTTCInfotc_isNum tc_isReal tc_isStringTC FalseableparensIfpretty-1.1.3.3Text.PrettyPrint.HughesPJDocError1 exprSymbolsSizedEnvBE_beSizeSEseBindsFB wiredInEnv funcSortsghc-prim GHC.TypesIntGFixSol_senv_sid_stag_sinfoMInt newTopBindDefexpr1PlitPpred0PdefineP fixResultPSrtAxmWfcConDisQulKutPackIBindOptMatExpandAdt fixityTableeltsetmapselfSortfldSorttheorifyCheckMintelabExpr elabApply checkExprelab defuncEAppcheckSymcheckItecheckCst checkApp'checkNeg checkPredcheckRel unifyExprunify checkFunSort errElabExprTh Checkablecheck checkSortsMapsHypGBQB padDataDeclsmt2Cast NonTrivSortsNTVKPolarityLhsRhssymKinddistinctLiteralsorderDeclarations stNumKVCuts stNumKVNonLin stNumKVTotal stIsReducible stSetKVNonLincGraph graphRankskvSucc graphElimsccElims boundElims PartitionCtor cpartSize cpartToFinfo finfoToCpartpartitionByConstraintswiCIdwiTimewiRankWorkSetaddPendssAddsWorkItem numKvarCs numConcCs_numSccsWLwCswPendwDepswCmwRankmwLastwTimewConcCsKvDom safeKvarEnv_dropAdtMeasures addLiterals_banIllScopedKvarsrestrictKVarDomain restrictWfbanConstraintFreeVarsbanQualifFreeVars banMixedRhsdropFuncSortedShadowedBinders sanitizeWfC _nonDerivedLH dropBindersreplaceDeadKvarsUniqueMexpandWFUniqueSTfreshIdkmapchangecacheulocubsbenvUniqueuniq RenameMapNothingIdMapRBRIdropUnusedBinds renameVarsRefKInfo elabExist cubePredExc substElimKIkiTagskiDepthkiCubesdfLamdfExtdfAEqdfBEqdfNormdfHOdfLamsdfRedexdfBindsmakeAlphaAxioms normalizemakeBetaAxiomsfreshSymgetLamsDFSTdfFreshdfEnvdfBEnvdfLNormEvalEnv KnowledgeassertSelectorssubstEqSubstOpPopIfNormalevId evSequence_evAEnvevEnv_evCfgKNknSimsknAms knContextknPredsknLamsnumCstrnumBrktnumChcknumValdssCtxssBindsssStats SolverStatewithProgressFI tidyResultrefineCminimizeResultrhsPred_iMergePartitionscSizescFreqcTotalcMeancMaxcSpeed solveSeqWith solveParWithinParallelUsing solveNative solveNative'