shatter

Data Driven Programming


Keywords
algorithm, data-driven, deep-learning, machine-learning, programming-language, python-3
License
MulanPSL-2.0
Install
pip install shatter==0.6.2.1

Documentation

BooleanSolver

Introduction

A picture is worth a thousand words and a vid is worth a thousand pictures, so watch a short intro or continue reading...

This is a python 2 project to speed up boolean expression coding. Sometimes we need to crack a problem by combining boolean operators such as: and, or & not. We as humans are prone to err, specially when expressions get big. But there is an algorithm (Quine-McCluskey) to get this expressions with zero error. Just specify your specs in a test and set a dummy function on your code. When you run your tests a solver will take your specs and code them into a simple boolean expression, enjoy :).

This same boolean logic is being expanded to a broader range of problems check other coding capabilities below.

Package Setup

  1. Install Boolean-Solver package:

    $ pip install Boolean-Solver
    

Short Example

Add new script(start.py) with a mock function:

from boolean_solver import solver as s

@s.solve()
def and_function(a, b):
    pass

Add a unittest(test.py) with specs:

import unittest
from boolean_solver import solver
import start


class MyTest(unittest.TestCase):
    """
    1. Set conditions of your boolean function (for True outputs)
    2. Run solver.execute(self, callable, table) where callable is the boolean function
     with the decorator=@solve().
     See examples below:
    """
    def test_AND_function(self):

        # The output is explicitly set to true
        cond = solver.Conditions(a=True, b=True, output=True)
        solver.execute(self, start.and_function, cond)

Then run $ python -m unittest test. In start.py the result should be:

def and_function(a, b):
    return a and b

Non-Boolean outputs

What if the output for a given logical condition is not a boolean. In that case a programmer would use an if. In the next example this package solves this case automatically:

Add if_function(a, b) to start.py:

@s.solve()
def if_function(a, b):
    pass

Add test_ifs(self) to MyTest(unittest.TestCase) class in test.py:

def test_ifs(self):
    """
    Testing ifs.
    """
    cond = solver.Conditions(a=False, b=True, output=1)  # non-boolean output
    cond.add(a=True, b=False, output=0)  # non-boolean output
    solver.execute(self, start.if_function, cond)

Then run $ python -m unittest test, the result should be:

def if_function(a, b):

    if not a and b:
        return 1

    if a and not b:
        return 0

    return False

Now, some cool coding

Add recursive(a) to start.py:

@s.solve()
def recursive(a):
    pass

Add test_recursive_function(self) to MyTest(unittest.TestCase) class in test.py:

def test_recursive_function(self):
    """
    Will do recursion, extremely cool!!!
    """
    args = {'a': solver.Code('not a')}
    out = solver.Output(start.recursive, args)

    cond = solver.Conditions(a=False, output=0, default=out)
    solver.execute(self, start.recursive, cond)

The result this time will be a recursive function :)

def recursive(a):

    if not a:
        return 0

    return recursive(not a)

Expression behaving like boolean inputs

Say you want to add a piece of code that evaluates to boolean, then:

Add with_internal_code(a) to start.py:

@s.solve()
def with_internal_code(a):
    pass

Add test_internal_code(self) to MyTest(unittest.TestCase) class in test.py:

def test_internal_code(self):
    """
    Testing internal pieces of code
    """
    cond = solver.Conditions(any_non_input_name=solver.Code('isinstance(a, str)'), output=2)
    solver.execute(self, start.internal_code, cond)

The result should be:

def internal_code(a):

    if isinstance(a, str):
        return 2

    return False

Source Code

Setup with source code

  1. Clone repository: git clone git@github.com:jisazaTappsi/BooleanSolver.git

Intro Example with source code

  1. Enter boolean_solver: cd boolean_solver

  2. Run: python start_sample.py

    Sorry, run:
    python -m unittest test_sample
    first, to solve the riddle :)
    
  3. So, run test with: python -m unittest test_sample

    Solved and tested and_function_3_variables
    .Solved and tested and_function
    .Solved and tested or_function
    .Solved and tested xor_function
    .
    ----------------------------------------------------------------------
    Ran 4 tests in 0.006s
    
    OK
    
  4. Run: python start_sample.py

      You made it, Congrats !!!
      Now, see the functions, enjoy :)
    

You just solved 4 boolean expressions: and, or, xor & and3. Specs for these functions are in test_sample.py.

How does Boolean Solver works?

Takes a function and a truth_table which is processed using the Quine-McCluskey Algorithm. Then finds a optimal boolean expression. This expression is inserted in the method definition with the decorator @boolean_solver().

Arguments of solver.execute(test, function, conditions)

  1. The test case itself, to be able to perform tests, eg: self

  2. A function to optimize, passed as a callable (with no arguments). This function needs a 3 mock line definition with: line 1: decorator = @solve() line 2: signature eg: def my_function(a, b) line 3: body: only one line, eg: return False. This line will be replaced by the boolean expression.

  3. a. solver.Conditions() instance: An object that can handle logical conditions with named arguments eg:

    cond = solver.Conditions(a=True, b=False)
    
    cond.add(a=True, b=True)
    

    The reserved word output allows:

    cond.add(a=False, b=False, output=False)
    

    Meaning that when a=False, b=False I want the output to be False

    b. Truth table: Alternatively a truth table can be specified (as a set containing tuples). Where each row is a tuple, the general form is:

    {tuple_row(tuple_inputs(a, b, ...), output), ...}
    

    or with a implicit True output:

    {tuple_inputs(a, b, ...), ...}
    

Arguments of solver.Conditions() and cond.add()

These are specified as a dictionary containing certain keywords as well as the function inputs.

Keywords are:

output: Determines the value to be returned when the given condition is True.

output_args: Dictionary with the values for the arguments when output is a function.

default: Value returned when non of the conditions are True.

Helper Classes

solver.Output: Class that helps define a function with arguments as an output. Has fields:

  • function: A callable object.
  • arguments Dictionary with the function inputs.

solver.Code: Class that helps output pieces of code. The code is given as a String.

solver.Solution: Class that contains the solution of the problem it includes:

  • conditions: The information given by the user.
  • implementation: Plain code.
  • ast: Abstract syntax tree