El2      !"#$%&'()*+,-./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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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.0None2323None *LQRT:Unique Int -----------------------------------------------:Edit Distance --------------------------------------------D!If loud, write a string to stdoutN  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVN  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVN  !"#$%&'()*+,-./01234567 9:;<=8>?@ABCDEFGHIJKLMN OPQRSTUVI   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVNone9:;[Implement either \ or ]fTop-level pretty printeriPlease do not alter this.3WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~WXYZ[\]^`_acbdefghijklmn3dabce^_`[\]fghij~}|{kzyxwvutsrqYZpWXolmn+WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None059;TBA Reusable SrcSpan Type ------------------------------------------Start Position End PositionBLocated Values ---------------------------------------------------BRetrofitting instances to SourcePos ------------------------------+456#456None /023459;T@Result ---------------------------------------------------------KA BareBones Error Type ----------------------------------------------------@Catalogue of Errors --------------------------------------------*789:;#789:;None$/059;DMRT$Values that can be viewed as SymbolsELocated Symbols ----------------------------------------------------- Invariant: a < is made up of: '0'..'9'++ [ 'a'...'z'] ++ ['A'..'Z'] ++ =?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 ----------------------------------------------------->FEncoding Symbols -----------------------------------------------------?RJ: 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.@ABC<DEFG>HIJKLMNOPQ?RST     UVWXYZ[\] !"#$%&'()*+,-./01^_2`3456789:;<=>?@ABCDEFGHIJaKLMP      !"#$%&'()*+,-./0123456789:;HIJKLMNOPQ?RST     UVWXYZ[\] !"#$%&'()*+,-./01^_2`3456789:;<=>?@ABCDEFGHIJKaDLMNone%&059:;<=ILWName of defined datatypeXNumber of type variablesYDatatype Ctors\ Ctor Name] Ctor Fields` Field Namea Field SortbKSorts ---------------------------------------------------------------------enumeric kind for Num tyvarsf"numeric kind for Fractional tyvarsguninterpreted typehfixpoint type variableifunctionjtype-abstractionlconstructed typefApp' (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 -----------------------------------------------{STUVWXYZ[\]^_`abcdefghijklbcdefmngohijklmnpqrsotupvwqxyz{|}~rstuvwxyzBSTUVWXYZ[\]^_`abljcdekifghmnopqrstuvwxyz{|}~BbcdefghijklSTnmpqrstvwuxyoz|{}~^_`aZ[\]UVWXYaSTUVWXYZ[\]^_`ab cdefghijklbcdefmngohijklmnpqrsotupvwqxyz{|}~rstuvwxyz None%&023459:;<=IMbDClass 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.LKPredicates ----------------------------------------------------------------T:Refinements ----------------------------------------------X7Gradual Type Manipulation ----------------------------Z7Generally Useful Refinements --------------------------l,The symbol may be an encoding of a SymConst.|KString Constants ----------------------------------------------------------Replace all symbol-representations-of-string-literals with string-literal Used to transform parsed output from fixpoint back into fq.{      !"#$%&'()*+,-./01234567~89:;<=>?@A|BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a     654310/.2'()%& !"#$C?DEFIGHJ:K8\R]^_MNOZ[PQVWTU@AL`a;=<7SB>XY*+,-9{      !"#$%&'()*+,-./01234567~89:;<=>?@A|BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NoneKTODO: Rewrite using visitor -----------------------------------------------(( None%&023459:;<=IKConstraint Pack Sets ------------------------------------------------------'Functions for Global Binder Environment7&Functions for Indexed Bind EnvironmentU      !"#$%&'()*+,-./0123456789:8      !"#8   !   "#I      !"#$%&'()*+,-./0123456789: None05MOA Refinement of b that describes SMTLIB SortsYY/ describes the SMT semantics for a given symbolZ for UDF: len, height, append[for ADT ctors & accessor: cons, nil, \ for theory ops: mem, cup, select]]3 represents the information about each interpreted _name`serialized SMTLIB2 nameasortb>TRUE = defined (interpreted), FALSE = declared (uninterpreted)cc is used to resolve the b and Y of each eSorts of *all* defined symbolsf)Information about theory-specific SymbolsgUser-defined data-declarationshDistinct Constant symbolsiTypes at which apply/ was used; see [NOTE:apply-monomorphization]jj/ is the low-level representation for SMT values These are BUILT-inx polymorphic functions which are UNININTERPRETED but POLYMORPHIC, hence need to go through the apply-defunc stuff.smtSortsP 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-declarationr('smtSort True msg t' serializes a sort tB using type variables, 'smtSort False msg t' serializes a sort t using  instead of tyvars.;OPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~$OPQRSTUVWXY[Z\]^_`abcdefghijklmnopqr$j]^_`abYZ[\OPQRSTUVWXrqcdefghikmlnop$O PQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None025 NoneT!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 -----------------------------/++None059;#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 rewriting3allow axiom instantiation on arithmetic expressionsKConfiguration Options -----------------------------------------------------<     3 3 "     None%&0259:;<=IM%FAxiom Instantiation Information --------------------------------------,FTop level Solvers ----------------------------------------------------/cst id |-> Horn Constraint0%Kvar |-> WfC defining its scope/args1Bind |-> (Symbol, SortedReft)2Global Constant symbols3Distinct Constant symbols4Set of KVars *not* to eliminate5Abstract domain6Metadata about binders7User-defined data declarations8Higher Order info=+Allow higher order binds in the environemnt>Allow higher order qualsATop-level QueriesEKConstraint Cut Sets -------------------------------------------------------HKQualifiers ----------------------------------------------------------------JNameK ParametersL PredicateMSource LocationTSolutions and ResultsaId of lhs/rhs bindervKConstraints ---------------------------------------------------------------F"Smart Constructors" for Constraints ---------------------------------constructing qualifiersConstructing QueriesRendering Queries!Query Conversions: FInfo to SInfo !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~y !"#$%&'()*+,-.01/2345689:7;<=>?@ABCDEFGHIJKLMNOPQRSTUY[ZXVW\]^_`abcdfeghijklmnopqrstuvwxyz{|}~@?-./0123456789:ABCD,nopqrsqrstuyxdefg{WVefX\]^_`abcvUVWXYZ[Z[zYwhijklmHIJKLMST|NOPQR}~EFG;<=>%&'()*+ !"#$ !"#$%&'()*+,- ./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn opqrsqrstuvwxyz{|}~NoneCompute the domain of a kvarFree variables of a refinement8Split a SortedReft into its concrete and KVar components/NoneEWXYZ[\]^`_acbdefghijklmn      !"#$%&'()*+,-./0123456789:;<STUVWXYZ[\]^_`abljcdekifghmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a      !"#OPQRSTUVWXY[Z\]^_`abcdefghijklmnopqr !"#$%&'()*+,-.01/2345689:7;<=>?@ABCDEFGHIJKLMNOPQRSTUWVXZ[Y\]^_`abcdefghijklmnopqrstuvwxyz{|}~None05Construct the bitvector b from its 4Apply some bitvector operator to a list of arguments Construct an / using a raw string, e.g. (Bv S32 "#x02000000")   None9:; KAST Conversion: Types that can be serialized ------------------------------*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 axioms4flag to enable lambda normal form equivalence axioms"Responses received from SMT engine!KTypes ---------------------------------------------------------------------Commands issued to SMT engine$   !"#$%&'()*+,-."   !"#$%&'()*+,-"!"#$%&'()*+,   -    ! "#$%&'()*+,-.None59:;L@Parsing Constraints (.fq files) --------------------------------MIntegerPLower-case identifiersQLower-case identifiersRString Haskell infix IdVArbitrary SymbolsW(Integer) ConstantsUsed as input to &Text.Parsec.Expr.buildExpressionParser to create exprPY Expressions[Function Applications9BitVector literal: lit "#x00000001" (BitVec (Size32 obj))]Sort^Bit-Vector SortKPredicates ----------------------------------------------------------------`KBareTypes -----------------------------------------------------------------Refaa2(Sorted) Refinements with configurable sub-parsersbBinder (lowerIdP <* colon)c(Sorted) Refinementsd((Sorted) Refinements with default bindereKParsing Data Declarations -------------------------------------------------hKParsing Qualifiers -------------------------------------------------------- Qualifiers@Axioms for Symbolic Evaluation ---------------------------------@Interacting with Fixpoint --------------------------------------3456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]    ^ _`abcdefghi !"#$%&'()*jkl+mn,-.opqrstuvwA3546789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnF345@ABCDEFGHJI\KLiQPRVWMb]Y_[h`cda^ONTUnlmjSk?6789:;<=:;>:;>ZXefg3456 789:;<=:;>:;>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]    ^ _`abcdefghi !"#$%&'()*jkl+mn,-.opqrstuvwNone9;M /ESet Theory ----------------------------------------------------------0ESet Theory ----------------------------------------------------------1ESet Theory ----------------------------------------------------------KExported API --------------------------------------------------------------2KConverting Non-Int types to Int -------------------------------------------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`)3'Constructors, Selectors and Tests from U arations.4('selfSort d' returns the _self-sort_ of d :: U%. See [NOTE:DataDecl] for details.5)'fldSort d t' returns the _real-sort_ of d if t- is the _self-sort_ and otherwise returns t". See [NOTE:DataDecl] for details.66 converts the b into a full ]B/01789:;<=>?@z{|}~ABCDEFGHIJKLMNOPQ2RST3456UVWXYZ[\yrz{|}~ryz{|}~B/01789:;<=>?@z{|}~ABCDEFGHIJKLMNOPQ2RST3456UVWXYZ[\None9:;ILM:String Constants -----------------------------------------Context ctx8 is built in a "top-down" fashion; not "across" siblingsTransforms can access current ctx!Accumulations can access current ctx; acc value is monoidalVisitors over Sort8]^_`abcdef1]^_`abcdefNone5gThe main data types&hijklmnopqgrstuvwxyz{|}~!hijklmnopqgrstuvwxyz{|}~Nonei ignores the actual refinements as they are not relevant in the kvar parameters (as suggested by BLC.)  None 9:;<=LMghKAPI 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 -------------------------------------------------------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 c& 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 Unification3Fast Unification; `unifyFast True` is just equalityKApplying a Type Substitution ----------------------------------------------KDeconstruct a function-sort -----------------------------------------------KError messages ------------------------------------------------------------lhNone(9:;M\smt2Cast uses the 'as x T' pattern needed for polymorphic ADT constructors like Nil, see `tests/pos/adt_list_1.fq`None !"9;T 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)ESMT 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.=                       7   !"#$%&'()*+,7!"#$%&'()*+,   =                       None%&059:;<=LMQRA 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 binders Sorts for all symbols , bindPrev :: !(BIndex |-> BIndex) -- ^ "parent" (immediately dominating) binder , kvDeps :: !(CMap [KIndex]) -- ^ List of (Cut) KVars on which a SubC depends Each # 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) binderKInstantiated Qualifiers ---------------------------------------------------A - is an association list indexed by predicates"Binders from defining Env#Substitutions 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 solutions Actual solution (for cut kvar))Solution for gradual variables "Defining cubes (for non-cut kvar)*set of allowed binders for kvar.The .= data type --------------------------------------------------/KUpdate Solution -----------------------------------------------------------=KCreate a Solution ---------------------------------------------------------?KRead / Write Solution at KVar ---------------------------------------------\      !"#$%&' ( ) *+ , -./ ! " #012 $345678 %9: &;<=>?@A ' (BCDEFGHIJKLMNOPQR@      !"#$%&'*)(+,-./0123456789:;<=>?@ABCA.-'()*:1*& !"#$%,+CB456703=/?A@2>98;<     :      !"#$%&' ( ) *+ , -./ ! " #012 $345678 %9: &;<=>?@A ' (BCDEFGHIJKLMNOPQRNone9;LgKInitial Gradual Solution (from Qualifiers and WF constraints) ------------- g ) * + , - . / 0 1 2gg g ) * + , - . / 0 1 2None5hhx contains all the stuff needed to produce a result, and is the the essential ingredient of the state needed by solve_jthe initial solutionkthe whole input queryl+dependencies between constraints/ranks etc.m"set of KVars to actually solve fornKRanks ---------------------------------------------------------------------p SCC number with ALL dependenciesq#SCC number without CUT dependenciesrThe constraint's TagsKConstraint Dependencies ---------------------------------------------------u!Constraints *written by* a SubcIdv!(Cut) KVars *read by* a SubcIdwSCC rank of a SubcIdxTotal number of Sccs)F.SubcIds that transitively "reach" belowF.SubcIds with Concrete RHSDependencies between slKVarCsDramatis Personaereal kvar vertex)dummy to ensure each kvar has a successor(constraint-id which creates a dependencyFCMap API -------------------------------------------------------------2hijklmnopqrstuvwxyz{|}~ 3 4.ghijklmnopqrstuvwxyz{|}~.gyz{|}~nopqrstuvwxhijklmhijklmnopqrstuvwxyz{|}~ 3 4None* 5 6 7 8 9 : 5 6 7 8 9 :None? is representation of the KVGraph with a fast succ, pred lookupout-edges of a in-edges of a  ; < = > ? @ A B C D E   ; < = > ? @ A B C D E None!"*LQR F0number of kvars whose removal makes deps acyclic G,number of kvars that appear >= 2 in some LHS Hnumber of kvars Iis dep-graph reducible Jset 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] KKConstraint Graph ---------------------------------------------------------- LKRanks from Graph ---------------------------------------------------------- MKDependencies --------------------------------------------------------------Eliminated Dependencies N N0 "eliminates" a kvar k by replacing every "path"ki -> ci -> k -> c with an edgeki ------------> cKCompute Dependencies and Cuts --------------------------------------------- O O returns an t that renders the dependency graph acyclic by picking _at least one_ kvar from each non-trivial SCC in the graph P P 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.H Q R F G H I J S T U V W X Y Z K L M [ \ ] ^ _ ` a N b c d e f g h i j k l m O n o p q P r s t u v w x y z { | } ~   ? Q R F G H I J S T U V W X Y Z K L M [ \ ] ^ _ ` a N b c d e f g h i j k l m O n o p q P r s t u v w x y z { | } ~ !None* Type 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 work fReturn the "size" of a CPart. Used to determine if it's substantial enough to be worth parallelizing. Convert a CPart to an FInfo Convert 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 work  mkPartition or mkPartition'  F.FInfo aor [F.CPart a]    0NoneHghijklmnopqrstuvwxyz{|}~"NoneT    #NoneL  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.  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 = 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 FInfo 0Replace KVars that do not have a WfC with PFalse=    =    $None:  Map each '6 to the list of constraints on which it appears on RHS constructs a h\ comprising the Solution and various indices needed by the worklist-based refinement loop    %None5 # Horn Constraints# Refine Iterations  # smtBracket calls (push/pop) # smtCheckUnsat calls # times SMT said RHS Valid SMT Solver Context All variables and types Solver StatisticsKSolver Monadic API --------------------------------------------------------KSMT Interface -------------------------------------------------------------Z`filterRequired [(x1, p1),...,(xn, pn)] q` returns a minimal list [xi] s.t. / [pi] => qJ`filterValid p [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]`o`filterValidGradual ps [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]` | for some p in the list ps&                   &None9;L HInformation 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.),                 //(                  'None5M A  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 changed Bind identifier Constraint 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%&059:;<=LMQRISubstitute Gradual Solution --------------------------------------------- )JThe Unique Monad ---------------------------------------------------------IMake each gradual appearence unique ------------------------------------- *JexpandWF -----------------------------------------------------------------/ + , - . / 0 1 2 3 ) 4 5 6 7 8 9 : ; < = > ? @ A B *$ + , - . / 0 1 2 3 ) 4 5 6 7 8 9 : ; < = > ? @ A B *)NoneL C Constraint Id DTime at which inserted ERank of constraint FFWorkItems ------------------------------------------------------------KWorklist ------------------------------------------------------------------KInitialize worklist and slice out irrelevant constraints ------------------FCandidate Constraints to be checked AFTER computing Fixpoint --------- G Pending API HFSet API --------------------------------------------------------------* I J C D E F K L M N O P Q R S T U V W X Y Z [ \ G ] ^ _ H `      I J C D E F K L M N O P Q R S T U V W X Y Z [ \ G ] ^ _ H `     *None9:;LM a Progress Bar btidyResult ensures we replace the temporary kVarArg names introduced to ensure uniqueness with the original names in the given WF constraints. cFSingle Step Refinement ----------------------------------------------- dKConvert Solution into Result ---------------------------------------------- e e\ 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. f@Predicate corresponding to RHS of constraint in current solution gJInteraction with the user when Solving -----------------------------------" h i j k l m n a o p q r b s t u c v w d x y e z { | f } ~ g  " h i j k l m n a o p q r b s t u c v w d x y e z { | f } ~ g  +None5     ,None9:;LM normalize lams enable extensionality axioms enable alpha equivalence axioms enable beta equivalence axioms enable normal form axioms 'allow higher order thus defunctionalize /lambda expressions appearing in the expressions $redexes appearing in the expressions sorts 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  .B   !"#$%&'()*3    !"#$%&'()*-None $9;ALMTc Symbolic Evaluation with SMT Knowledge (SMT Interaction)+Instantiate Axioms Creating Measure Info< + ,++,    + ,.NoneT .FSolve an .fq file ----------------------------------------------------/KSolve FInfo system of horn-clause constraints ----------------------------- CSolve in parallel after partitioning an FInfo to indepdendant parts CSolve in parallel after partitioning an FInfo to indepdendant parts ESolve a list of FInfos using the provided solver function in parallel KNative Haskell Solver ----------------------------------------------------- KNative Haskell Solver -----------------------------------------------------0KExtract ExitCode from Solver Result ---------------------------------------1KParse External Qualifiers -------------------------------------------------. /      01  ,./01/,.01. /      01   1231241251261789:;<=>?@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 { | } ~                                                                                                                                                                     ! " # $ % & ' ( ) * + , - . / 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{|u}~      !"#$%&'()*+,-./01233456789:;<==>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~V2               !!!!!!!!!!!!!!!!"""###$%%%%%%%%%%%%%%%%&&&&&&'''''((((((((((((( ( ( ( ( (((())))))))))))))))*++ +++,!,",#,$,%,&,',(,),*,+,,,-,.,/,0,1,2,3-4-5-6.7..8.9:;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnopqrstuvwxyz{|}~                                   C           `      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_J`abccdefghijkklHmnopqrstuvwxyz{|}~4w                         C         ! " # $ % & ' ( ) * + , - . / 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! {! |! }" ~" " " " " " " # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #A$3$ $ $ $ $ $ $ $ $ % % % % % % % %% %% % % % % % % % % % % % % % & & & & & & & & & & & & & $& %& && '& (& )& *& +& ,&& & & & & & && & & & & & & & & & & & ' CD ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( (( ( ( ( ( ( !( "( #( $( %( &( ') () )) *) +) ,) -) .) .)) /) 0) 1) 2) 3) 4) 5) 6) 7) 8) 9) :) ;) <) =) >)) ?) @) A) B* C* D* E*W* 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, x, y, z, {, |, }, ~, ,, , , , , , , , , , ,4, , , , , , , , , , , - - - - - - - - - -- - - - - - - - - - - - - - - - - - - - - - [- - - - - - - - - - - - - - - - - - - - - - - - - - . . . . . . . . . . . . . .W. . . .liquid-fixpoint-0.7.0.2-3repHVQ2bkqGganvJ6cFNPLanguage.Fixpoint.ParseLanguage.Fixpoint.Types.Spans Language.Fixpoint.Utils.ProgressLanguage.Fixpoint.Misc#Language.Fixpoint.Types.PrettyPrintLanguage.Fixpoint.Types.ErrorsLanguage.Fixpoint.Types.NamesLanguage.Fixpoint.Types.Sorts#Language.Fixpoint.Types.Refinements%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.Smt.BitvectorLanguage.Fixpoint.Smt.TypesLanguage.Fixpoint.Smt.TheoriesLanguage.Fixpoint.Types.Visitor$Language.Fixpoint.Solver.TrivialSort%Language.Fixpoint.Solver.UniqifyKVarsLanguage.Fixpoint.SortCheckLanguage.Fixpoint.Smt.SerializeLanguage.Fixpoint.Smt.Interface!Language.Fixpoint.Types.Solutions(Language.Fixpoint.Solver.GradualSolutionLanguage.Fixpoint.Graph.Types!Language.Fixpoint.Graph.ReducibleLanguage.Fixpoint.Graph.IndexedLanguage.Fixpoint.Graph.Deps!Language.Fixpoint.Graph.PartitionLanguage.Fixpoint.Minimize!Language.Fixpoint.Solver.Sanitize"Language.Fixpoint.Solver.EliminateLanguage.Fixpoint.Solver.Monad!Language.Fixpoint.Solver.Solution%Language.Fixpoint.Solver.UniqifyBinds Language.Fixpoint.Types.Graduals!Language.Fixpoint.Solver.WorklistLanguage.Fixpoint.Solver.Solve"Language.Fixpoint.Utils.Statistics!Language.Fixpoint.Defunctionalize$Language.Fixpoint.Solver.InstantiateLanguage.Fixpoint.SolverLanguage.Fixpoint.TypesLanguage.Fixpoint.Graph$parsec-3.1.11-DytKT37FVYQJRVdRwnazC8Text.Parsec.Expr AssocRight AssocLeft AssocNoneAssocText.Parsec.Pos SourcePos withProgress progressInit progressTick progressCloseEqHashListNEMoodsOkLoudSadHappyAngry|-> 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$fPPrintDocTable$fMonoidDocTable $fPPrintText$fPPrintInteger $fPPrintInt $fPPrint() $fPPrintFloat $fPPrintBool $fPPrint(,)$fPPrint(,,,,) $fPPrint(,,,) $fPPrint(,,)$fPPrintHashMap$fPPrintHashSet $fPPrint[] $fPPrintMaybe $fPPrintDoc$fFixpointDouble$fFixpointInteger $fFixpointInt$fFixpointBool$fFixpoint(,,) $fFixpoint(,) $fFixpoint[]$fFixpointMaybe $fFixpoint()$fFixpointHashSet$fEqTidy $fOrdTidySrcSpanSSsp_startsp_stopLocatedLocloclocEvalsrcSpan sourcePosElts dummySpanatLoclocAtdummyLocdummyPos$fLoc()$fHashableSrcSpan$fPPrintSrcSpan$fSerializeSrcSpan$fIsStringLocated$fHashableLocated$fBinaryLocated $fOrdLocated $fEqLocated$fPPrintLocated $fShowLocated$fTraversableLocated$fFoldableLocated$fFunctorLocated$fFixpointLocated$fNFDataLocated $fLocLocated$fFixpointSourcePos$fHashableSourcePos$fPPrintSourcePos$fSerializeSourcePos$fBinarySourcePos$fNFDataSourcePos $fDataLocated$fGenericLocated $fEqSrcSpan $fOrdSrcSpan $fShowSrcSpan $fDataSrcSpan$fGenericSrcSpan FixResultCrashSafeUnsafeerrLocerrMsgErrorcatError catErrorserrpanicdiedieAtexit resultDoc colorResulterrFreeVarInQualerrFreeVarInConstrainterrIllScopedKVar$fFunctorFixResult$fMonoidFixResult $fEqFixResult$fNFDataFixResult$fExceptionFixResult$fExceptionError$fFixpointError1 $fPPrintError$fPPrintError1 $fOrdError1$fBinaryFixResult$fSerializeFixResult$fSerializeError$fSerializeDoc$fSerializeTextDetails$fSerializeError1$fSerializeDoc0$fSerializeAnnotDetails $fEqError1 $fShowError1$fGenericError1 $fEqError $fOrdError $fShowError$fGenericError$fDataFixResult$fFoldableFixResult$fTraversableFixResult$fShowFixResult$fGenericFixResult$fGenericAnnotDetailsSymbolicsymbolLocText 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 strConNamenilNameconsName size32Name size64Name bitVecNamebvOrName bvAndName mulFuncName divFuncNameprims$fSymbolicSymbol $fSymbolic[]$fSymbolicText$fSymbolicLocated$fFixpointSymbol$fFixpointText$fPPrintSymbol $fShowSymbol$fIsStringSymbol$fBinarySymbol$fNFDataSymbol$fHashableSymbol$fHashableDescription$fUninternableSymbol$fInternedSymbol $fOrdSymbol $fEqSymbol$fEqDescription $fDataSymbol$fGenericSymbol$fGenericInternedText$fDataInternedTextSubDataDeclDDeclddTyConddVarsddCtorsDataCtorDCtordcNamedcFields DataFieldDFielddfNamedfSortSortFIntFRealFNumFFracFObjFVarFFuncFAbsFTCFAppTCEmbFTycon mappendFTC intFTyCon boolFTyCon realFTyCon numFTyCon strFTyCon listFTyCon setFTyCon mapFTyConisListTCsizeBv fTyconSymbolsymbolNumInfoFTyCon symbolFTyconfAppfAppTCunFAppunAbsfObj sortFTycon functionSort isFirstOrder isNumericisRealisStringmkFFuncbkFFuncboolSortstrSortintSortrealSortfuncSortsetSort bitVecSortmapSort fTyconSort basicSorts sortSubst $fMonoidSort $fNFDataSub$fNFDataDataDecl$fNFDataDataCtor$fNFDataDataField $fNFDataSort$fNFDataTCInfo$fNFDataFTycon $fBinarySub$fBinaryDataDecl$fBinaryDataCtor$fBinaryDataField $fBinarySort$fBinaryTCInfo$fBinaryFTycon$fPPrintDataDecl$fPPrintDataCtor$fPPrintDataField$fPPrintFTycon$fFixpointDataDecl$fFixpointDataCtor$fFixpointDataField$fFixpointFTycon$fFixpointSort$fHashableSort$fHashableFTycon$fSymbolicDataCtor$fSymbolicDataField$fSymbolicDataDecl$fMonoidTCInfo $fEqFTycon$fSymbolicFTycon $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_reftReftGradInfogsrcgusedPredExprESymEConEVarEAppENegEBinEIteECstELamETAppETAbsPAndPOrPNotPImpPIffPAtomPKVarPAllPExistPGradBopPlusMinusTimesDivModRTimesRDivBrelEqNeGtGeLtLeUeqUneConstantIRLSymConstSLKVSubKVSksuVVksuSortksuKVarksuSubstSubstSuKVarKVkv HasGradual isGradualgVarsungradERDivEDivERTimesETimesEEqEBotPFalsePTopPTrue reftConjunctsintKvar srcGradInfomkEAppeApps splitEAppeAppC debruijnIndexelit isContraPred isTautoPred pprintRefteVareProppAndpOr&.&|.|pItepExistmkPropisSingletonReftexprReft notExprReft uexprReftpropReftpredReftreft mapPredReftisFunctionSortedReft isNonTrivialreftPredreftBindpGAndspGAnd symbolReft usymbolReftvv_trueSortedRefttrueReft falseReft flattenRefas conjuncts$fSubableLocated$fFalseableReft$fFalseableExpr$fExpressionLocated$fPredicateBool$fPredicateExpr$fPredicateSymbol$fExpressionInt$fExpressionInteger$fExpressionText$fExpressionSymbol$fExpressionExpr$fExpressionReft$fExpressionSortedReft $fPPrintExpr$fPPrintSymConst $fPPrintKVar $fPPrintSort $fPPrintBop $fPPrintBrel$fPPrintConstant$fFixpointExpr $fFixpointBop$fFixpointBrel$fFixpointKVar$fFixpointSymConst$fSymbolicSymConst$fFixpointConstant $fPPrintKVSub $fPPrintSubst$fFixpointSubst $fShowSubst$fHashableConstant$fHashableSymConst $fHashableBop$fHashableBrel$fHashableKVar $fShowKVar$fHasGradualSortedReft$fHasGradualReft$fHasGradualExpr$fBinarySortedReft $fBinaryReft $fBinaryExpr $fBinaryBop $fBinaryBrel$fBinarySymConst$fBinaryConstant$fBinaryGradInfo $fBinarySubst $fBinaryKVar$fBinarySrcSpan$fBinaryHashMap$fNFDataSortedReft $fNFDataReft $fNFDataExpr $fNFDataBop $fNFDataBrel$fNFDataSymConst$fNFDataConstant$fNFDataGradInfo $fNFDataSubst$fNFDataSrcSpan $fNFDataKVar$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 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 $fMonoidPacks $fPPrintPacks$fFixpointPacks$fBinaryHashSet $fBinarySEnv$fBinarySizedEnv$fBinaryIBindEnv $fBinaryPacks $fNFDataSEnv$fNFDataSizedEnv$fNFDataIBindEnv $fNFDataPacks$fFixpointIBindEnv$fMonoidSizedEnv $fMonoidSEnv $fShowSEnv$fFixpointSEnv$fFixpointSizedEnv $fFunctorSEnv$fMonoidIBindEnv $fPPrintSEnv$fPPrintSizedEnv$fPPrintIBindEnv $fEqIBindEnv$fDataIBindEnv$fGenericIBindEnv$fEqSEnv $fDataSEnv $fGenericSEnv$fFoldableSEnv$fTraversableSEnv $fEqSizedEnv$fShowSizedEnv$fFunctorSizedEnv$fFoldableSizedEnv$fGenericSizedEnv$fTraversableSizedEnv $fEqSolEnv $fShowSolEnv$fGenericSolEnv $fEqPacks $fShowPacks$fGenericPacksSmtSortSIntSBoolSRealSStringSSetSMapSBitVecSVarSDataSemUninterpDataTheory TheorySymbolThytsSymtsRawtsSorttsInterpSymEnvseSortseTheoryseDataseLitsseApplsRawsymEnv symEnvTheory symEnvSort insertSymEnv symbolAtNamesymbolAtSmtName isIntSmtSort sortSmtSort$fPPrintSmtSort$fBinarySmtSort$fNFDataSmtSort$fHashableSmtSort $fBinarySem$fPPrintTheorySymbol$fFixpointTheorySymbol $fPPrintSem$fBinaryTheorySymbol$fNFDataTheorySymbol $fNFDataSem$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$fNFDataTriggered$fBinaryTriggered$fNFDataTrigger$fBinaryTrigger$fPPrintTriggered$fPPrintTrigger $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 rewriteAxiomsarithmeticAxioms withPragmasdefaultMinPartSizedefaultMaxPartSizeuseElim defConfiggetOpts multicore queryFile$fShowEliminate$fDefaultEliminate$fSerializeEliminate$fShowSMTSolver$fDefaultSMTSolver$fDefaultConfig $fEqSMTSolver$fDataSMTSolver$fGenericSMTSolver $fEqEliminate$fDataEliminate$fGenericEliminate $fEqConfig $fDataConfig $fShowConfig$fGenericConfigRewriteSMeasuresmNamesmDCsmArgssmBodyEquationEqueqNameeqArgseqBodyAxiomEnvAEnvaenvSymsaenvEqs aenvSimplaenvFuel aenvExpandSolverGInfoFIcmwsbsgLitsdLitskutsqualsbindInfoddeclshoInfoassertsaeHOInfoHOIhoBindshoQualsSInfoFInfo FInfoWithOptsFIOfioFIfioOptsKutsKSksVars QualifierQqNameqParamsqBodyqPos resStatus resSolution gresSolution FixSolution GFixSolutionTaggedCsenvsidstagsinfoclhscrhsSimpC_cenv_crhs_cid_cbind_ctag_cinfoSubCslhssrhsSubcIdGWInfogsymgsortgexprginfoWfCGWfCwenvwrftwinfowexprwlocTaggwInfo updateWfCExprisGWfc strengthenHypsubcId toGFixSolunsafesafeisUnsafewfCmkSubCsubCshiftVVaddIdstrueQual qualifier remakeQualmkQual substVarsksMemberfi allowHOquals toFixpoint writeFInfo convertFormat saveQuery getEqBody$fFixpointRewrite$fFixpointEquation $fFixpointDoc$fFixpointAxiomEnv$fPPrintEquation$fMonoidAxiomEnv$fNFDataEliminate$fNFDataSMTSolver$fNFDataEquation$fNFDataRewrite$fNFDataAxiomEnv$fBinaryEliminate$fBinarySMTSolver$fBinaryEquation$fBinaryRewrite$fBinaryAxiomEnv $fPTableGInfo $fMonoidGInfo$fMonoidHOInfo $fMonoidKuts$fFixpointKuts$fPPrintQualifier$fFixpointQualifier$fLocQualifier$fNFDataResult $fNFDataGInfo $fNFDataSimpC $fNFDataWfC $fNFDataSubC$fNFDataGWInfo$fNFDataGFixSol$fNFDataHOInfo $fNFDataKuts$fNFDataQualifier $fBinaryGInfo $fBinarySimpC $fBinaryWfC $fBinarySubC$fBinaryGFixSol$fBinaryGWInfo$fBinaryHOInfo $fBinaryKuts$fBinaryQualifier $fShowGFixSol$fPPrintGFixSol $fFixpointWfC$fFixpointSimpC$fFixpointSubC $fPPrintWfC $fPPrintSimpC $fPPrintSubC $fShowSimpC $fShowSubC $fShowWfC$fFixpointFixResult$fMonoidResult$fTaggedCSubCa$fTaggedCSimpCa$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 reftFreeVarssortedReftConcKVarsBvOpBvAndBvOrBvSizeS32S64BvmkSortbvTyConeOp$fExpressionBv $fEqBvSize $fOrdBvSize $fShowBvSize $fDataBvSize$fGenericBvSize$fEqBvOp $fOrdBvOp $fShowBvOp $fDataBvOp $fGenericBvOpSMTLIB2smt2ContextCtxctxPidctxCinctxCoutctxLog ctxVerbosectxExtctxAeqctxBeqctxNorm ctxSymEnvResponseSatUnsatUnknownValuesCommandPushPopCheckSatDeclDataDeclareDefineAssertAssertAxDistinctGetValueCManyrunSmt2$fPPrintCommand $fEqCommand $fShowCommand $fEqResponse$fShowResponse Inputablerrrr'FixityFInfixFPrefixFPostfixfpredfnamefop2fassocfop1PStateParserlexerreserved reservedOpparensbracketsanglesbracessemicoloncomma whiteSpaceblanksinteger locParserPcondIdPupperIdPlowerIdPinfixIdPisSmall locLowerIdP locUpperIdPsymbolP constantPexpr0PexprP addOperatorPfunAppPsortPbvSortPpredPrefaPrefBindPbindPrefPrefDefP dataFieldP dataCtorP dataDeclP qualifierPpairP remainderP initPStatedoParse' parseFromFile freshIntP $fInputable[]$fInputableCommand$fInputableFInfoWithOpts$fInputableGInfo$fInputable(,)$fInputableFixResult$fInputableExpr$fInputableConstant$fInputableSymbol $fShowDef $fGenericDefsetEmptysetEmpsetCapsetSubsetAddsetMemsetComsetCupsetDifsetSngmapSelmapSto smt2Symbolsmt2App isSmt2Apppreamble theorySymbols maxLamArg axiomLiterals$fSMTLIB2SmtSort SymConsts symConsts VisitablevisitVisitorctxExprtxExpraccExprdefaultVisitorfoldtransmapKVars mapKVars' mapGVars'mapExprmapMExpr mapKVarSubstssizelamSizeeappskvarsenvKVars envKVarsNrhsKVarsisKvarCisConcC stripCastsfoldSort$fSymConstsExpr$fSymConstsReft$fSymConstsSortedReft$fSymConstsSimpC$fSymConstsSubC$fSymConstsSizedEnv$fSymConstsGInfo $fMonoidMInt$fVisitableGInfo$fVisitableSubC$fVisitableSimpC$fVisitableSizedEnv$fVisitable(,)$fVisitableSortedReft$fVisitableReft$fVisitableExpr nontrivsorts $fHashableNTV$fEqNTV$fOrdNTV $fShowNTV $fGenericNTV wfcUniqifyTVSubstEnv Elaborate elaborateisMonosortExpr checkSortExprcheckSortedReftcheckSortedReftFull checkSortFull checkSortedpruneUnsortedRefttoInt unApplyAt applySortsexprSort unifySorts unifyFastapply$fCheckableSortedReft$fCheckableExpr$fElaborateSimpC$fElaborateSizedEnv$fElaborateSortedReft $fElaborate[]$fElaborate(,)$fElaborateExpr$fElaborateSort$fElaborateMaybe$fElaborateTriggered$fElaborateGInfo $fShowTVSubst smt2SortMono$fSMTLIB2Triggered$fSMTLIB2Command $fSMTLIB2Expr $fSMTLIB2Brel $fSMTLIB2Bop$fSMTLIB2Constant$fSMTLIB2SymConst$fSMTLIB2Located$fSMTLIB2Symbol $fSMTLIB2(,)checkValidWithContext checkValid checkValid' checkValidscommandsmtWrite makeContextmakeContextWithSEnvmakeContextNoLogcleanupContextsmtPushsmtPopsmtDeclssmtDecl smtFuncDecl smtCheckSat smtAssertsmtAssertAxiom smtDistinct smtCheckUnsat smtBracketAt smtBracketCMapIndexFastIdxbindExprkvUsekvDefenvBindsenvTxenvSortsBindPredBPbpConcbpKVarBIndexRootBindCstrKIndexkiBIndexkiPoskiKVarEQualEQL_eqQualeqPred_eqArgsCandCubecuBindscuSubstcuIdcuTagHypSolsEnvgMapsScpGBindQBind GSolutionSolutionupdate emptyGMapupdateGMapWithKeyqbqbExprsqbToGbgbToQbsgbEqualsequalsGb gbFilterMqbFilter updateGMapresult resultGradualfromListqbPreds lookupQBindglookuplookup trueEqualeQual$fPPrintBindPred$fPPrintBIndex$fHashableBIndex$fPPrintKIndex$fHashableKIndex $fNFDataEQual $fPPrintEQual $fShowCube $fPPrintCube $fPPrintSol $fFunctorSol $fMonoidSol $fPPrintQBind $fNFDataGBind $fNFDataQBind $fEqEQual $fShowEQual $fDataEQual$fGenericEQual $fShowGBind $fDataGBind$fGenericGBind $fShowQBind $fDataQBind$fGenericQBind $fEqQBind $fEqKIndex $fOrdKIndex $fShowKIndex$fGenericKIndex $fEqBIndex $fOrdBIndex $fShowBIndex$fGenericBIndex$fShowBindPredinit SolverInfoSIsiSolsiQuerysiDepssiVarsRankrSccrIccrTagCDepsCDscSucccPrevcRankcNumSccCGraphgEdgesgRanksgSuccgSccsSliceslKVarCsslConcCsslEdgesDepEdgeKVReadKVCompsCompsCEdgeKVGraphkvgEdgesCVertexDKVar writeGraph writeEdges isRealEdge lookupCMap $fPPrintRank$fPPrintKVGraph$fHashableCVertex$fPPrintCVertex $fEqCVertex $fOrdCVertex $fShowCVertex$fGenericCVertex $fEqSlice $fShowSlice$fEqRank $fShowRank isReducibleIKVGraphigSuccigPredaddLinksdelNodes edgesIkvg ikvgEdgesgetSuccsgetPreds$fShowIKVGraphElimsDepsdepCuts depNonCutssliceisTarget decomposekvEdgeselimDepselimVarsgraphStatistics $fPTableStats $fMonoidElims $fPPrintElims $fShowElimsMCInfomcCores mcMinPartSize mcMaxPartSizeCPartpwspcmmcInfo partition partition' partitionNdumpPartitions $fMonoidCPart $fShowMCInfominQueryminQualsminKvarssanitizedropDeadSubsts symbolEnv solverInfoStatsnumIterSolveM runSolverMgetBindsfilterRequired filterValidfilterValidGradual smtEnablembqicheckSattickIter $fNFDataStats $fShowStats$fGenericStatslhsPred $fMonoidKInfo $fEqKInfo $fOrdKInfo $fShowKInfo renameAll $fHashableRef $fNFDataRef$fEqRef $fGenericRefGradualgsubstGSol makeSolutionsuniquify$fGradualGInfo$fGradualHashMap$fGradualSizedEnv$fGradualSimpC$fGradualSortedReft $fGradualReft $fGradualExpr $fUniqueExpr $fUniqueReft$fUniqueSortedReft $fUniqueInt$fUniqueIBindEnv $fUniqueSimpC$fUniqueHashMap $fShowGSol $fMonoidGSolWorklistwRanksunsatCandidatespoppush $fOrdWorkItem$fPPrintWorkItem$fPTableWorklist$fPPrintWorklist $fEqStats $fEqWorkItem$fShowWorkItemsolve statistics $fPPrintStatsDefuncdefuncdefunctionalize defuncAny defuncAxioms$fDefuncHashMap $fDefunc[] $fDefuncSort$fDefuncSizedEnv $fDefuncSEnv $fDefuncExpr $fDefuncReft $fDefunc(,) $fDefunc(,)0$fDefuncSortedReft $fDefuncWfC $fDefuncSimpC$fDefuncTriggered $fDefuncGInfo instantiate$fExpression(,)$fShowOccurencesolveFQ resultExit parseFInfopbRefmkPB ofSourcePos toSourcePos ppSrcSpanError1panicMsgputDocLnSafeTextbaseGHC.Base$ textSymbol alphaCharsS _symbolId symbolRaw symbolEncodedDTsCache mappendSym checkedTextencodeisFixKey encodeUnsafe prefixAlphaisAlpha0 joinChunkspadNull splitChunks isUnsafeCharkeywordsnumChars safeChars okSymChars renamePrefix litPrefix gradPrefix testPrefix kArgPrefix existPrefixunPrefixSymbolunSuffixSymbol lamArgPrefix _propConName _hpropConName symSepNameD:R:DescriptionSymbol0TCInfotc_isNum tc_isReal tc_isStringTC defTcInfo numTcInfo realTcInfo strTcInfo defNumInfo defRealInfo defStrInfo funcFTyCon charFTyCon isListConName isFunctionisListisCharbkAbsbkFun toFixSort toFixAbsApp toFixFApp symbolFTycon' FalseableparensIfpretty-1.1.3.3Text.PrettyPrint.HughesPJDocisKvar refaConjunctsencodeSymConst_decodeSymConstisEqopPrec pprintQuanttrueDfalseDandDorD pprintBin vIntersperseisSingletonExprrelReft exprSymbols emptySubstcatSubstappSubst subSymbol substfLam removeSubstdisjointmeetReftpprReft pprReftPredppRasSizedEnvBE_beSizeSEseBindsFBGHC.Listhead wiredInEnv funcSortsghc-prim GHC.TypesIntFuncSort funcSortIndex ffuncSort applySmtSort fappSmtSort symEnvDatappParensgetLeftHandSide defaltPatterextMap tmpDirNametestM findFirst withPragmaconfigbannerBindMGFixSol_senv_sid_stag_sinfosubcBindstrengthenBindsstrengthenSortedReftsortedReftBind pprSinfos toFixMetapprIdpprintTidyGradual ppLocOfKVar ppNonTautomkVVpprQualenvSortgSortssortVarsmapSort' foldSort'$++$sEnvDoc subcToSimpcoutVVsaveBinaryQuery saveTextQuerydomaingetWfC sizeTyConsizeNameopNameppCmdDefexpr1PlitPpred0PdefineP fixResultPSrtAxmWfcConDisQulKutPackIBindOptMatFuelExpandSymsAdtOpTable fixityTableParserTemptyDef languageDef stringLiteraldouble symCharsP locSymbolP symconstP exprCastP charsExprfastIfP addOperatormakePrec makeInfixFun makePrefixFuninsertOperator initOpTablebopslamPvarSortP funcSortPsortsPsortArgPsortP'singletvarPfTyConPmakeUniquePGradtruePfalseP kvarPredPkvarPsubstPpredsPpredrPbrelPoptBindPmatchPpairsP fInfoOptPfInfoPdefP sortedReftPwfCPsubCPsubC'tagPenvPintPboolP defsFInfocrashPpredSolPiQualP solution1P solutionP solutionFileP errorSpan commandsPcommandPcmdVarPeltsetmap_toIntdataDeclSymbolsselfSortfldSorttheorifyempaddcupcapmemdifsubcomselstostrLen strSubstr strConcatz3strlen z3strsubstr z3strconcat strLenSort substrSort concatstrSortstring z3PreambleuifDef cvc4PreamblesmtlibPreamblestringPreamble smt2SmtSort smt2SmtSortscastWith interpSymbols interpSym ctorSymbolsctorSort testSymbols testTheory selectSymbols ctorSelectors fieldSelectorMIntVisitM execVisitMaccum visitExprisConc getSymConsts NonTrivSortsNTVKNTGTrivInfoPolarityLhsRhsKVarMap simplify'mkNonTrivSorts nonTrivSortsntGraphntEdgestrivInfo updTISubCs updTISubC updTIBindsupdTIaddNTSaddKVsaddSortisNTRtrivR trivOrSingRtrivPsingP simplifyFInfosimplifyBindEnv simplifyWfCs simplifySubCs simplifySubCsimplifySortedReftisNonTrivialSort newTopBind remakeSubsts remakeSubst updateSubst updateWfcs updateWfcaccumBindsIfValid accumBindsisValidInRefinementsCheckMint checkExprelab defuncEAppcheckSymcheckItecheckCst checkApp'checkNeg checkPredcheckRelunify checkFunSort errElabExprTh Checkablecheck checkSortElabEnvChStateChError elabNumericelabExpr elabApplysubEnv withErrorrunCM0fresh checkPred'addEnv elabAddEnvcastelabAs elabAppAselabEApp elabAppSorttakeArgsmakeApplicationapplyAtisInttoIntAt splitArgsgenSortunite checkIteTycheckApp checkExprAscheckOp checkOpTycheckFractional checkNumeric checkBoolSort checkRelTyunifys unifyManyunify1_unAbs _sortSizeunifyVar lookupVar updateVarerrUnify unifyExpr errUnifyManyerrRelerrOperrIteerrCasterrUnboundAltserrNonFunction errNonNumericerrNonNumericserrNonFractional errBoolSortsmt2Cast smt2SortPolysmt2Sortsmt2datasmt2ctor smt2fieldsmt2Var smtLamArg smt2VarAs isPolyInstisPolysmt2LamunCast splitEApp'mkRelmkNesmt2ssmt2manysymKinddistinctLiteralsorderDeclarations SmtParser _theoryDeclssmtRead responsePsexpPerrorPvaluesPvalueP negativeP smtWriteRaw smtReadRaw hPutStrLnNow makeProcesshCloseMesmtCmd smtPreamblecheckValidStringFlagnoStringversionGreaterEq smtDataDecl deconSortrespSat interact'makeMbqiz3_432_options z3_optionsdeclaredataDeclarations funcSortVars dataDeclDepsdataDeclFTyconsdataCtorFTyconsdataFieldFTycons sortFTyconssMapsHypGBQBfoldsgroupKsupdate1qbEQualsqbSizemapGMap lookupElabupdateKrefineGrefine instConstantsrefineKinstKinstKQ instCandsmatch candidatesokInstppEdgestxEdgesisReducibleWithStartconvertToGraph isDescendantcontains isBackEdge subcEdges'addLinkdelNodeemptytxManyaddSuccaddPreddelSuccdelPreddelVtx stNumKVCuts stNumKVNonLin stNumKVTotal stIsReducible stSetKVNonLincGraph graphRankskvSucc graphElimsccElims boundElimsCutableCutterEdgeRank sliceKVars subcKVarsmkSlicemkSlice_ sliceEdgessuccs kvWriteBykvReadBykvGraph edgeGraphfiKVars subcEdgeselimKdNonCutdCutremoveKutEdgescutVars forceKutsedgeDeps edgeDeps' sMapMaybeedgeRank edgeRankCutgElims sccsToDepssccDepcycleDepaddCutbElimsdistVtopoSortripKuts invertEdges maximumDef graphDepscGraphCEcSuccMrankFinRanks graphStatsnonLinearKVarsnlKVarsC PartitionCtor cpartSize cpartToFinfo finfoToCpartpartitionByConstraints mkPartition mkPartition'groupFunOracle deltaDebug deltaDebug1 commonDebug removeOtherKsisSafeaddExtmkOracleKvDom safeKvarEnv addLiterals_banIllScopedKvarsrestrictKVarDomain restrictWfbanConstraintFreeVarsbanQualifFreeVars banMixedRhsdropFuncSortedShadowedBinders sanitizeWfC _nonDerivedLH dropBindersreplaceDeadKvars KeepSortF KeepBindFSymBindsKSubKvBadsKvDefs KvConstrM SanitizeMbadKs checkIllScope isIllScope subcBinds kvarBinds kvarDefUses dropKvarEnv dropBadParams badParamsbadArg subcKSubs initKvarEnvinitEnvknown cNoFreeVarsbadCsbadQualsnubDiffbadRhsbadRhs1 symbolSorts symbolSorts'unShadow defuncSortcompact bindSorts multiSorted dupBindErrorssymBindsbindersconjKF nonConstantF nonFunctionFdeleteSubCBindsdeleteWfCBindskvScopescutSInfokutVarskIndex nonCutHyps nonCutHyp nonCutCuberhsSubstgetSubCnumCstrnumBrktnumChcknumValdssCtxssBindsssStats SolverStatestats0getIterincIterincBrktincChckincVald withContext getContext modifyStats filterValid_filterValidGradual_filterValidOne_ assumesAxiomsprogIterKInfo elabExist cubePredExc substElimKIkiTagskiDepthkiCubesBindersExprInfo CombinedEnvCid envConcKVars applyKVars applyKVarhypPredcubePred substSort elabToIntisClass combinedSEnvaddCEnvdelCEnvsymSorts_noKvarsmplus mconcatPlus appendTags extendKInfo mrExprInfos RenameMapNothingIdMapRBRIdropUnusedBinds renameVarsRefmkIdMap updateIdMapinsertIdIdLinks namesToIds mkRenameMapaddIdaddDupId updateRef mkSubUsingapplySub renameBinds renameBindUniqueMexpandWFUniqueSTfreshIdkmapchangecacheulocubsbenvUniqueuniq uniquifyCS updateLoc withCache emptyCacheaddCache updateBEnv setChange resetChange initUniqueSTfreshKfreshK'addKwiCIdwiTimewiRankWorkSetaddPendssAddsWorkItem numKvarCs numConcCs_numSccsWLwCswPendwDepswCmwRankmwLastwTimewConcCspopWnewSCCrank workItemsAtaddPendremPendisPendsPopwithProgressFI tidyResultrefineCminimizeResultrhsPred_iMergePartitions solveGradual iSolveGradualsolveGradualOne gradualLoopmakeLocalLatticemakeLocalLatticeOne printStatssiKvarssolve_ tidySolutiontidyPredrhsCandspredKs solResultresult_minimizeConjunctsisUnsat showUnsatisValidcstrSpangetMergePartitionmergePartitions partitionInfocSizescFreqcTotalcMeancMaxcSpeedpartitionStatsmkStats frequencymeandfLamdfExtdfAEqdfBEqdfNormdfHOdfLamsdfRedexdfBindsmakeAlphaAxioms normalizemakeBetaAxiomsfreshSymgetLamsDFSTdfFreshdfEnvdfBEnvdfLNormDF defuncExprreBind makeAxioms validAxiom makeAlphaEqshiftLam normalizeLamsnormalizeLamsFromTomakeEq makeEqForAllcloseLam splitPAllchoices makeDFStatemakeInitDFStatelogLamlogRedexputLamisRedex getRedexesgetClosedField closeLams freeBindsEvalEnv KnowledgeassertSelectors OccurenceOcc_ofun_oargsofuelFuelMapEvalSTevId evSequence_evAEnvKNknSelsknEqsknSimsknAms knContextknPredsknLams~> instantiate' instSimpC cstrBindExprsunElabunApplyemptyKnowledgelookupKnowledge makeKnowledgemakeSimplifications getDCEquality splitPAndaddSMTEqualityevaluate grepTopAppsmakeLamevalevalArgsevalApp substPopIfevalRecApplicationaddApplicationEqevalIteevalIte'η goodFuelMaphasFuel makeFuelMap instances instancesLoop findNewEqsmakeInitOccurencesgrepOccurencesunfold solveSeqWith solveParWithinParallelUsing solveNative solveNative' errorExitsolveFQ'ignoreQualifierssolve'configSW readFInforeadFq readBinFqloudDumpparseFI saveSolution