The Vital Development Kit (VDK) provides development tools and an API for Artificial Intelligence (AI) applications and data processing. This includes a “Domain Specific Language” (DSL) for working with data.

To this DSL we’ve recently added an extension to the venerable “If” statement in the JVM to handle Truth Values. (Truth Values, see: Beyond True and False: Introducing Truth to the JVM )

The “If” statement is the workhorse of computer programming. If this, do that. If something is so, then do some action. The “If” statement evaluates if some condition is “True”, and if so, takes some action. If the condition is “False”, then it may take some other action.

The condition of an “If” statement yields a Boolean True or False and typically involves tests of variables, such as: height > 72, speed < 50, name == “John”.

The “If” statement is a special case of the “switch” statement, such that:

if(name == "John") { do something } else { do something different }

is the same as:

switch (name == "John") { case true: { do something; break } case false: { do something different; break } }

In the VDK we have an extension of Boolean in the JVM called Truth. Truth may take four values: YES, NO, UNKNOWN, or MU compared to the Boolean TRUE or FALSE. YES and NO are the familiar TRUE and FALSE, with UNKNOWN providing a value for when a condition cannot be determined because of unknown inputs, and MU providing a value for when a condition is unknowable because it contains a false premise.

For example, for UNKNOWN, the color of a traffic light might be red, green, or yellow but its value is currently UNKNOWN. And for MU, the favorite color of a traffic light is MU because inanimate objects don’t have favorite colors.

UNKNOWN and MU are part of the familiar Boolean Truth Tables. For instance True AND True yields True, whereas True AND Unknown yields Unknown.

Details of the Truth implementation in the JVM can be found in the blog post: Beyond True and False: Introducing Truth to the JVM

Because Truth has four values, we need a way to handle four cases when we test a condition.

As above, we could use a “switch” statement like so:

switch (Truth Condition) { case YES: { handle YES; break } case NO: { handle NO; break } case UNKNOWN: { handle UNKNOWN; break } case MU: { handle MU; break } }

This is a little verbose, so we’ve introduced a friendlier statement: consider.

consider (Truth Condition) { YES: { handle YES } NO: { handle NO } UNKNOWN: { handle UNKNOWN } MU: { handle MU } }

So we can have code like:

consider (trafficlight.color == GREEN) { YES: { car.drive() } NO: { car.stop() } UNKNOWN: { car.stop() } // better be safe and look around MU: { car.stop(); runDiagnostics(); } // error! error! }

In the above code, if evaluating our truth condition results in an UNKNOWN value (perhaps a sensor cannot “see” the Traffic Light), we can take some safe action. If we get a MU value, then we have some significant error, such the “trafficlight” object not actually being a trafficlight — perhaps some variable mixup. We can also take some defensive measures in this case.

We can also stick with using “If” and use exceptions for the cases of UNKNOWN and MU:

try { if(trafficlight.color == GREEN) { car.drive() } else { car.stop() } } catch(Exception ex) { // handle UNKNOWN and MU }

This works because Truth values are coerced to Boolean True or False for the cases of YES or NO. This coercion throws an exception for the cases of UNKNOWN or MU. JVM exceptions are a bit ugly and should not be used for normal program control flow (exceptions as flow control is often an anti-pattern), so the consider statement is much preferred.

The logic of Truth is very helpful in defining Rules to process realtime dynamic data, and answer dynamic data queries. The consider statement allows such rules to be quite succinct and explicitly handle unknown data or queries with non-applicable conditions.

For instance, if we query an API for the status of traffic lights and ask how many are currently yellow, we might get back a reply of 0 (zero). We might wonder are there really zero traffic lights yellow presently, or is the API not functioning and always returning zero, or does it not track yellow lights? It would be better to get a reply of UNKNOWN if the API was not functioning. If we asked how many traffic lights were displaying Purple, a reply of zero would be correct but it would be better to get a reply of MU – there are no such thing as Purple traffic lights in a world of Red/Yellow/Green lights.

As AI and data-driven applications incorporate more dynamic data models and data sources, instances of missing or incorrect knowledge are more the rule rather than the exception, so the software flow should treat these as normal cases to consider rather than exceptions.

Hope you have enjoyed learning about how the Vital Development Kit has extended “If” to handle Truth Values. Please post and questions or comments below, or get in touch with us at info@vital.ai.