úÎ!Ñ`Å4¨      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§ ,Conflict-directed clause learning utilities.(c) Tom Harding, 2020MITNone%*;M_ R ¨holmesÛA set of rules. We use this to represent our global list of "no good" configurations. If any cell's provenance ever contains one of the rules in our global set, we know this computation will eventually end in failure.©holmes.A set of value identifiers and their settings.ªholmesThe index of the chosen value# of a parameter in our computation.«holmes,The index of a parameter in our computation.¬holmesoGenerate unique rules for a set of possible values for a given parameter. For example, if we assign parameter #1 possible values [1 .. 4]/, this function might generate something like: r[ ( -(1, 0) && -(1, 1), 1 ) , ( -(1, 0) && (1, 1), 2 ) , ( (1, 1) && -(1, 1), 3 ) , ( (1, 1) && (1, 1), 4 ) ] ­holmes List all the (Major, Minor) pairs in a ©.®holmesToggle the boolean switch of a (Major, Minor) pair.¯holmes Remove a (Major, Minor) pair from a ©.°holmesIf a group implies (A && B) and  (A && -B) then the B/ seems to be irrelevant, so we can refine the © to A). This hopefully means we can eliminate more' branches, and get to an answer faster!±holmes Does any © in this ¨ subsume the given ©?²holmesIf x ² y, then the set of switches in x is a strict subset of the switches in y. In other words, the x © will match  everything that y will.³holmes Add a new © to a ¨. Attempt to calculate any °" of the rule, and generalise the ¨ as far as possible.¨´µ©¶·ª«¬­®¯°±²³#Configuration for input parameters.(c) Tom Harding, 2020MITSafe"#HV6zholmesTThe simplest way of generating an input configuration is to say that a problem has m# variables that will all be one of n2 possible values. For example, a sudoku board is 81 variables of 9r possible values. This class allows us to generate these simple input configurations like a game of countdown: "81 from 1 .. 9, please, Carol!"holmesUDifferent parameter types will have different representations for their values. The  type means that I can say 81  [1 .. 9]?, and have the parameter type determine how it will represent 1­, for example. It's a little bit of syntactic sugar for the benefit of the user, so they don't need to know as much about how the parameter types work to use the library.holmes Generate m variables who are one of n values. 81  [1 .. 9], 5  [ True, False ] , and so on.holmesAn input configuration.This stores both an U configuration of input parameters, as well as a function that can look for ways to 7 an input. In other words, if the initial value is an Data.JoinSemilattice.Intersect of [1 .. 5], the refinements might be  ( values of every remaining possibility.holmes"For debugging purposes, produce a ¸% of all possible refinements that a N might produce for a given problem. This set could potentially be very large!.Values with differing levels of "definedness".(c) Tom Harding, 2020MITSafe *479;<HV_;Èholmes3Defines simple "levels of knowledge" about a value. holmes'Nothing has told me what this value is. holmes+Everyone who has told me this value agrees. holmes2Two sources disagree on what this value should be.  1Solving problems by reducing lists of candidates.(c) Tom Harding, 2020MITNone%*6;=?HMV_kHû holmes5A set type with intersection as the '(<>)' operation.!holmes Create an  from a list of candidates."holmes-Return a list of candidates stored within an .#holmesRun an action only if a single candidate remains.$holmesDelete a candidate from an .%holmes Return an  of all possible candidates except those in the given . The  of all candidates is assumed to be ¹.&holmes Filter an  with a predicate.'holmes Map over an  with a given function.(holmesCreate a singleton .)holmesCount the candidates in an .*holmes Merge two  values with set union.+holmes Produce a  with the given initial value, where the > function just tries each remaining candidate as a singleton. !"#$%&'()*+ !"#$%&'()*+ 4Performant join semilattice-based knowledge-merging.(c) Tom Harding, 2020MITNone4;HRá7holmesƒJoin semilattice '(<>)' specialised for propagator network needs. Allows types to implement the notion of "knowledge combination".8holmesmMerge the news (right) into the current value (left), returning an instruction on how to update the network.9holmes@The result of merging some news into a cell's current knowledge.:holmes6We've learnt nothing; no updates elsewhere are needed.;holmes-We've learnt something; fire the propagators!<holmes3We've hit a failure state; discard the computation.789;:< ,Relationships between values and their sums.(c) Tom Harding, 2020MITNone8HW=holmes0A relationship between two values and their sum.?holmes7A relationship between two values and their difference.@holmes0A relationship between a value and its negation.=>?@GAn interface for the primitive cell operations in a propagator network.(c) Tom Harding, 2020MITNone*HV®- Aholmes–The DSL for network construction primitives. The following interface provides the building blocks upon which the rest of the library is constructed.ÿsIf you are looking to implement the class yourself, you should note the lack of functionality for ambiguity/searching. This is deliberate: for backtracking search (as opposed to truth maintenance-based approaches), the ability to create computation branches dynamically makes it much harder to establish a reliable mechanism for tracking the effects of these choices.&For example: the approach used in the  ÿ& implementation is to separate the introduction of ambiguity into one definite, explicit step, and all parameters must be declared ahead of time so that they can be assigned indices. Other implementations should feel free to take other approaches, but these will be implementation-specific.BholmesgThe type of cells for this particular implementation. Typically, it's some sort of mutable reference (, \, or similar), but the implementation may attach further metadata to the individual cells.Cholmes Mark the current computation as failedÜ. For more advanced implementations that utilise backtracking and branching, this is an indication that we should begin a different branch of the search. Otherwise, the computation should simply fail without a result.Dholmes‡Create a new cell with the given value. Although this value's type has no constraints, it will be immutable unless it also implements 7, which exists to enforce  monotonic updates.EholmesŠCreate a callback that is fired whenever the value in a given cell is updated. Typically, this callback will involve potential writes to otherc cells based on the current value of the given cell. If such a write occurs, we say that we have  propagated. information from the first cell to the next.Fholmes<Execute a callback with the current value of a cell. Unlike EG, this will only fire once, and subsequent changes to the cell should not\ re-trigger this callback. This callback should therefore not be "registered" on any cell.Gholmes Write an updateÿ to a cell. This update should be merged into the current value using the '(Data.JoinSemilattice.Merge.<<-)' operation, which should behave the same way as '(<>)' for commutative and idempotent monoids. This therefore preserves the monotonic behaviour: updates can only refine a value. The result of a G must be  more refined+ than the value before, with no exception.HholmesOIn our regular Haskell coding, a binary function usually looks something like  x -> y -> z. When we view it as a  relationship4, we see that it's actually a relationship between three values: x, y, and z.*Given a function that takes everything we  currentlyø know about these three values, and returns three "updates" based on what each can learn from the others, we can lift our three-way relationship (which, again, we can intuit as a multi-directional binary function) into a network as a three-way  propagatorW. As an illustrative example, we might convert the '(+)' function into something like: VaddR :: (Int, Int, Int) -> (Int, Int, Int) addR ( a, b, c ) = ( c - b, c - a, a + b ) In practice, these values must be 7 values (unlike º), and so any of them could be ¹K, or less-than-well-defined. This function will take the three results as updates, and 78 it into the cell, so they will only make a difference if we've learnt something new.Iholmes;Create a cell with "no information", which we represent as ¹=. When we evaluate propagator computations written with the a abstraction, this function is used to create the result cells at each node of the computation.#It's therefore important that your ¹… value is reasonably efficient to compute, as larger computations may involve producing many of these values as intermediaries. An  of all º2 values, for example, is going to make things run very slowly.JholmesýThis function takes two cells, and establishes propagators between them in both directions. These propagators simply copy across any updates that either cell receives, which means that the two cells end up holding exactly the same value at all times.¬After calling this function, the two cells are entirely indistinguishable, as they will always be equivalent. We can intuit this function as "merging two cells into one".Kholmes˜A standard unary function goes from an input value to an output value. However, in the world of propagators, it is more powerful to rethink this as a  relationship between two values.A good example is the »Ð function. It doesn't matter whether you know the input or the output; it's always possible to figure out the one you're missing. Why, then, should our program only run in one direction? We could rephrase »* from 'Int -> Int' to something more like: WnegateR :: ( Maybe Int, Maybe Int ) -> ( Maybe Int, Maybe Int ) negateR ( x, y ) = ( x  | fmap negate y, y  | fmap negate x ) Now, if we're missing oneD of the values, we can calculate it using the other! This, and the H_ function's description above, give us an idea of how functions and relationships differ. The K] function simply lifts one of these expressions into a two-way propagator between two cells.The 7" constraint means that we can use ¹1 to represent "knowing nothing" rather than the ¼L in the above example, which makes this function a little more generalised. AECDGFBHIJK AECDGFBHIJK.Lift "regular functions" over parameter types.(c) Tom Harding, 2020MITNone %,-8@ACHXq²QLholmes€Lift a relationship between two values over some type constructor. Typically, this type constructor will be the parameter type.LM-Computing knowledge from multiple parameters.(c) Tom Harding, 2020MITNone%*,8@ACHµUNholmes3Lift a relationship between three values over some f (usually a parameter type).NOCRelationships between values and their (integral) division results.(c) Tom Harding, 2020MITNone8H¼ÍPholmes A four-way ½r relationship between two values, the result of integral division, and the result of the first modulo the second.¾holmes)Integral multiplication implemented as a Q5 relationship in which the remainder is fixed to be 0.¿holmes/Integal division as a three-value relationship.Àholmes:Modulo operator implemented as a three-value relationship.PQ¾¿ÀERelationships between values and their (floating/fractional) product.(c) Tom Harding, 2020MITNone8HĽRholmes}Reversible (fractional or floating-point) multiplication as a three-value relationship between two values and their product.ÁholmesYA three-way division relationships implemented as a flipped multiplication relationship.Âholmes”A two-way relationship between a value and its reciprocal, implemented with a multiplication relationship in which the third value is fixed to be 1.RSÁÂ)Refine parameters using their raw values.(c) Tom Harding, 2020MITNone*,@ACHÏçTholmesSome types, such as H, contain multiple "candidate values". This function allows us to take eachG candidate, apply a function, and then union all the results. Perhaps fanOuts would have been a better name for this function, but we use `(>>=)` to lend an intuition when we lift this into Prop via `(Data.Propagator..>>=)`.’There's not normally much reverse-flow information here, sadly, as it typically requires us to have a way to generate an "empty candidate" a la ¹c. It's quite hard to articulate this in a succinct way, but try implementing the reverse flow for  or , and see what happens.TU(Relationships between boolean variables.(c) Tom Harding, 2020MITNone*=?H`ÜVholmesRather than the Ã, Ä, and Å" functions we know and love, the V class presents  relationships that are analogous to these. The main difference is that relationships are not one-way. For example, if I tell you that the output of x && y is Æ\, you can tell me what the inputs are, even if your computer can't. The implementations of VA should be such that all directions of inference are considered.WholmesAn overloaded Ç value.XholmesAn overloaded Æ value.Yholmes8A relationship between a boolean value and its opposite.Zholmes@A relationship between two boolean values and their conjunction.[holmes@A relationship between two boolean values and their disjunction.V[ZYXWEquality relationships.(c) Tom Harding, 2020MITNone=?@ACH`äÛ\holmesòEquality between two variables as a relationship between them and their result. The hope here is that, if we learn the output before the inputs, we can often "work backwards" to learn something about them. If we know the result is exactly true(, for example, we can effectively then L the two input cells, as we know that their values will always be the same.^holmes]A relationship between two variables and the result of a not-equals comparison between them.\]^:Relationships between values and their comparison results.(c) Tom Harding, 2020MITNone=?@ACH`ìX_holmesHComparison relationships between two values and their comparison result.`holmes[A relationship between two values and whether the left is less than or equal to the right.aholmes5Comparison between two values and their '(>)' result.bholmes6Comparison between two values and their '(>=)' result.cholmes5Comparison between two values and their '(<)' result._`abc1Relationships between values and their absolutes.(c) Tom Harding, 2020MITNone8Hôjdholmes Unlike the È we know, which is a function& from a value to its absolute value, e is a  relationship" between a value and its absolute.1For some types, while we can't truly reverse the È* function, we can say that there are two possible( inputs to consider, and so we can push some' information in the reverse direction.eholmesLGiven a value and its absolute, try to learn something in either direction.de&The high-level propagator abstraction.(c) Tom Harding, 2020MITNone &'*,HSX_bd'fholmes‰A propagator network with a "focus" on a particular cell. The focus is the cell that typically holds the result we're trying to compute.gholmesGLift a cell into a propagator network. Mostly for internal library use.hholmesZLower a propagator network's focal point down to a cell. Mostly for internal library use.iholmesFLift a regular value into a propagator network. This is analogous to É for some Ê type.jholmes}Lift a regular function into a propagator network. The function is lifted into a relationship with one-way information flow.kholmes<Lift a unary relationship into a propagator network. Unlike j8, this allows information to travel in both directions.lholmes^Lift a binary relationship into a propagator network. This allows three-way information flow.mholmes­Lift a regular binary function into a propagator network. The function is lifted into a relationship between three variables where information only flows in one direction.nholmesBDifferent parameter types come with different representations for Ë . This function takes two propagator networks focusing on boolean values, and produces a new network in which the focus is the conjunction of the two values.EIt's a lot of words, but the intuition is, "'(&&)' over propagators".oholmes¿Run a predicate on all values in a list, producing a list of propagator networks focusing on boolean values. Then, produce a new network with a focus on the conjunction of all these values.In other words, "Ì over propagators".pholmesThe same as the o‹ function, but with access to the index of the element within the array. Typically, this is useful when trying to relate each element to other elements within the array.JFor example, cells "surrounding" the current cell in a conceptual "board".qholmesŽGiven a list of propagator networks with a focus on boolean values, create a new network with a focus on the conjugation of all these values.In other words, "Ä over propagators".rholmes¿Run a predicate on all values in a list, producing a list of propagator networks focusing on boolean values. Then, produce a new network with a focus on the disjunction of all these values.In other words, "Í over propagators".sholmesThe same as the r‹ function, but with access to the index of the element within the array. Typically, this is useful when trying to relate each element to other elements within the array.JFor example, cells "surrounding" the current cell in a conceptual "board".tholmesBDifferent parameter types come with different representations for ËT. This value is a propagator network with a focus on a polymorphic "falsey" value.uholmeslGiven a propagator network with a focus on a boolean value, produce a network with a focus on its negation. ... It's "à over propagators".vholmesŽGiven a list of propagator networks with a focus on boolean values, create a new network with a focus on the disjunction of all these values.In other words, "Å over propagators".wholmesBDifferent parameter types come with different representations for ËT. This value is a propagator network with a focus on a polymorphic "truthy" value.xholmesCCalculate the disjunction of two boolean propagator network values.yholmesqGiven two propagator networks, produce a new propagator network with the result of testing the two for equality..In other words, "it's '(==)' for propagators".zholmessGiven two propagator networks, produce a new propagator network with the result of testing the two for inequality..In other words, "it's '(/=)' for propagators".{holmesÒGiven a list of networks, produce the conjunction of '(./=)' applied to every possible pair. The resulting network's focus is the answer to whether every propagator network's focus is different to the others.)Are all the values in this list distinct?|holmesƒGiven two propagator networks, produce a new network that calculates whether the first network's focus be greater than the second.-In other words, "it's '(>)' for propagators".}holmesGiven two propagator networks, produce a new network that calculates whether the first network's focus be greater than or equal to the second..In other words, "it's '(>=)' for propagators".~holmes€Given two propagator networks, produce a new network that calculates whether the first network's focus be less than the second.-In other words, "it's '(<)' for propagators".holmesŒGiven two propagator networks, produce a new network that calculates whether the first network's focus be less than or equal to the second..In other words, "it's '(<=)' for propagators".€holmesnGiven two propagator networks, produce a new network that focuses on the sum of the two given networks' foci./... It's '(+)' lifted over propagator networks.holmes&Produce a network that focuses on the negation of another network's focus. ... It's »! lifted over propagator networks.‚holmeszGiven two propagator networks, produce a new network that focuses on the difference between the two given networks' foci./... It's '(-)' lifted over propagator networks.ƒholmesrGiven two propagator networks, produce a new network that focuses on the product between the two given networks' integral foci./... It's '(*)' lifted over propagator networks./ Crucially, the reverse information flow uses integral division%, which should work the same way as Î.„holmesnGiven two propagator networks, produce a new network that focuses on the division of the two given networks' integral foci. ... It's Î! lifted over propagator networks.…holmeslGiven two propagator networks, produce a new network that focuses on the modulo of the two given networks' integral foci. ... It's Ï! lifted over propagator networks.†holmesrGiven two propagator networks, produce a new network that focuses on the product of the two given networks' foci./... It's '(*)' lifted over propagator networks.= The reverse information flow is fractional division, '(/)'.‡holmessGiven two propagator networks, produce a new network that focuses on the division of the two given networks' foci./... It's '(/)' lifted over propagator networks.ˆholmes&Produce a network that focuses on the  reciprocal of another network's focus. ... It's Ð! lifted over propagator networks.‰holmes&Produce a network that focuses on the absolute value of another network's focus. ... It's È! lifted over propagator networks.Šholmes2Lift a regular function over a propagator network and its parameter type. Unlike jV, this function abstracts away the specific behaviour of the parameter type (such as ).‹holmesLift a three-way relationship over two propagator networks' foci to produce a third propagator network with a focus on the third value in the relationship. ... It's  ! for propagators.Œholmes£Produce a network in which the raw values of a given network are used to produce new parameter types. See the "wave function collapse" demo for an example usage.'fghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ'fghijmklnopqxrsvtuwyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œn3x2y4z4|4}4~44€6‚6ƒ7„7…7†7‡7 ?My horror at his crimes was lost in my admiration at his skill.(c) Tom Harding, 2020MITNone "#*;<HMSVXzËÑholmes]The constraint-solving monad transformer. We implement the current computation context with Ò(, and the current "no goods" list with Ó.3This transformer exposes its internals through the Ò, Ó, Ô, and Õ# interfaces, and should therefore noty be used directly. The reason is simply that misuse of any of these will break the computation, so the library provides Control.Monad.Holmes and Control.Monad.Watson, who do their best to thwart Ñ.Öholmesÿ0Unsafely read from a cell. This operation is unsafe because it doesn't factor this cell into the provenance of any subsequent writes. If this value ends up causing a contradiction, we may end up removing branches of the search tree that are totally valid! This operation is safe as long as it is the very last thing+ you do in a computation, and its value is never* used to influence any writes in any way.×holmesRun a Ñ$ computation and return the list of allF valid branches' results, in the order in which they were discovered.ØholmesRun a Ñ computation and return the first valid branch's result.Ùholmes·Given an input configuration, and a predicate on those input variables, compute the configurations that satisfy the predicate. This result (or these results) can be extracted using Ø or ×.ÑÚÛÖ×ØÙA much purer soul than Holmes.(c) Tom Harding, 2020MITNone *HMSVXk˜Õholmes5A monad capable of solving constraint problems using Ü6 as the evaluation type. Cells are represented using  references, and  provenanceF is tracked to optimise backtracking search across multiple branches.holmesÿ0Unsafely read from a cell. This operation is unsafe because it doesn't factor this cell into the provenance of any subsequent writes. If this value ends up causing a contradiction, we may end up removing branches of the search tree that are totally valid! This operation is safe as long as it is the very last thing+ you do in a computation, and its value is never* used to influence any writes in any way.‘holmes—Run a function between propagators "backwards", writing the given value as the output and then trying to push information backwards to the input cell.’holmesRun a function between propagators with a raw value, writing the given value to the "input" cell and reading the result from the "output" cell.“holmes Interpret a ˆ program, returning a list of all successful branches' outputs. It's unlikely that you want to call this directly, though; typically, • or –% are more likely the things you want.”holmes Interpret a : program, returning the first successful branch's result if] any branch succeeds. It's unlikely that you want to call this directly, though; typically, • or –& are more likely the things you want.•holmesTGiven an input configuration, and a predicate on those input variables, return the first, configuration that satisfies the predicate.–holmesPGiven an input configuration, and a predicate on those input variables, return all configurationsÀ that satisfy the predicate. It should be noted that there's nothing lazy about this; if your problem has a lot of solutions, or your search space is very big, you'll be waiting a long time!ABFGDCE‘’“”•–ABFGDCE‘’“”•–TA monad for constructing constraint-solving computations, and executing them inside Ý.(c) Tom Harding, 2020MITNone "#%*HMSVXkÀw ›holmes5A monad capable of solving constraint problems using Ý6 as the evaluation type. Cells are represented using  references, and  provenanceF is tracked to optimise backtracking search across multiple branches.œholmesÿ0Unsafely read from a cell. This operation is unsafe because it doesn't factor this cell into the provenance of any subsequent writes. If this value ends up causing a contradiction, we may end up removing branches of the search tree that are totally valid! This operation is safe as long as it is the very last thing+ you do in a computation, and its value is never* used to influence any writes in any way.holmes—Run a function between propagators "backwards", writing the given value as the output and then trying to push information backwards to the input cell.žholmesRun a function between propagators with a raw value, writing the given value to the "input" cell and reading the result from the "output" cell.Ÿholmes Interpret a › program into Ý€, returning a list of all successful branches' outputs. It's unlikely that you want to call this directly, though; typically, ¡ or £& are more likely the things you want. holmes Interpret a › program into Ý2, returning the first successful branch's result if] any branch succeeds. It's unlikely that you want to call this directly, though; typically, ¡ or £& are more likely the things you want.¡holmesTGiven an input configuration, and a predicate on those input variables, return the first, configuration that satisfies the predicate.¢holmesMShuffle the refinements in a configuration. If we make a configuration like 100 from [1 .. 10]., the first configuration will be one hundred 1> values. Sometimes, we might find we get to a first solution faster‡ by randomising the order in which refinements are given. This is similar to the "random restart" strategy in hill-climbing problems.•Another nice use for this function is procedural generation: often, your results will look more "natural" if you introduce an element of randomness.£holmesPGiven an input configuration, and a predicate on those input variables, return all configurationsÀ that satisfy the predicate. It should be noted that there's nothing lazy about this; if your problem has a lot of solutions, or your search space is very big, you'll be waiting a long time! A›œžŸ ¡¢£ ›AœžŸ ¡¢£The public API for the holmes library.(c) Tom Harding, 2020MITNone *;<HMSVXÂX[ +789<:;=>?@ALMNOPQRSTUVWXYZ[\]^_`abcdefnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹Œ‘’›¡¢£[›A’‘¡¢£deVWXYZ[\]^TURSPQLM_`cab=>@?NO789<:; +fŠŒ‹nopqxrsvutw†‡€‚~|}yz{…ƒ„‰ˆÞ"#$%%&'()*+,-./0123456789:;<=>?@ABCDE FGHIJKLMNOPQRS T U V W X Y Z [ \ ]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…ge>†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³¨©ª«¬­´®µ¶·¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä ¹ Å º ÆÇÈÉÊËÌÍÎÏÊÐÑÊÒÓÊÔÕÖ×ØÙÚÍÛÜÊÝÞÊÝßÍÎàÍÎáÊÐâÊËãÊËäÍÎåÊÝæÊÝçÊÔèÊÔéÊÔê ëìíëîïðñòÊóô ¨ « ¬ õ  öÊ÷øÍÎùú%holmes-0.1.0.1-CghJRrKr1HAJcmez9ZnNsQData.Input.ConfigData.JoinSemilattice.DefinedData.JoinSemilattice.Intersect Data.HolmesControl.Monad.Cell.ClassData.PropagatorControl.Monad.WatsonControl.Monad.Holmes Data.CDCL singleton Data.JoinSemilattice.Class.MergeData.JoinSemilattice.Class.SumControl.Monad.MoriarTMoriarT Data.STRefSTRef Data.IORefIORefProp Intersect"Data.JoinSemilattice.Class.Mapping"Data.JoinSemilattice.Class.Zipping#Data.JoinSemilattice.Class.Integral%Data.JoinSemilattice.Class.Fractional&Data.JoinSemilattice.Class.FlatMapping"Data.JoinSemilattice.Class.BooleanData.JoinSemilattice.Class.EqunifyData.JoinSemilattice.Class.OrdData.JoinSemilattice.Class.AbsDefinedControl.ApplicativeliftA2InputRawfromConfiginitialrefinepermuteUnknownExactlyConflict$fInputDefined$fFractionalDefined$fIntegralDefined $fRealDefined$fMonoidDefined$fSemigroupDefined$fApplicativeDefined $fEnumDefined $fEqDefined $fOrdDefined $fShowDefined$fFunctorDefined$fGenericDefined$fHashableDefined$fBoundedDefined $fNumDefined Intersectable toHashSetlift2fromListtoListdecideddeleteexceptfiltermapsizeunionusing$fSemigroupIntersect$fInputIntersect$fFractionalIntersect$fNumIntersect$fMonoidIntersect$fIntersectablecontent $fEqIntersect$fOrdIntersect$fShowIntersect$fFoldableIntersect$fHashableIntersectMerge<<-Result UnchangedChangedFailureSumRaddRsubRnegateR MonadCellCelldiscardfillwatchwithwritebinarymakeunaryMappingmapRZippingzipWithR IntegralRdivModR FractionalR multiplyR FlatMappingflatMapRBooleanRfalseRtrueRnotRandRorREqReqRneROrdRlteRgtRgteRltRAbsRabsRupdownliftover.&&all' allWithIndex'and'any' anyWithIndex'falsenot'or'true.||.==./=distinct.>.>=.<.<=.+negate'.-.*../..%..*./recip'abs'.$zipWith'.>>=$fFractionalProp $fNumPropWatson unsafeReadbackwardforwardrunAllrunOne satisfyingwhenever$fMonadCellWatson$fFunctorWatson$fApplicativeWatson $fMonadWatsonHolmesshuffle$fMonadCellHolmes$fFunctorHolmes$fApplicativeHolmes $fMonadHolmesGroupRuleMinorMajorindex variablesinvertremove refinementsimpliessubsumesresolvetoSet toHashMap3unordered-containers-0.2.10.0-b9YJCQLkMeLUf311RZkQDData.HashSet.BaseHashSetbaseGHC.Basememptyghc-prim GHC.TypesIntGHC.Numnegate GHC.MaybeMaybeGHC.RealdivModtimesRdivRmodRdivideRrecipR GHC.Classesnot Data.FoldableandorTrueFalseabspure ApplicativeBoolallanydivmodrecip mtl-2.2.2Control.Monad.Reader.Class MonadReaderControl.Monad.State.Class MonadState%logict-0.7.0.2-BZmYqWjl84nB8IYAe6sthBControl.Monad.Logic.Class MonadLogicControl.Monad.IO.ClassMonadIOsolve unMoriarTGHC.STSTIO