SPARSE

Stands for Symbolic logic PARSEr. This is a program that leverages python lambda functions to parse and perform basic tasks with symbolic logic.

Using SPARSE

SPARSE is a command line program executed by typing python3 sparsein the sparse directory. You can also double click the sparse file on a Windows machine if you have it so configured. You can also use the --verbose and --devmode command line arguments to add more description of what SPARSE is up to if you would like.

If you do not have git installed on your machine, you can dowload and extract the zip files from this webpage.

I hate it when software vendors demonize their customers and prevent good use of their software through excessive fees and usage contracts, but I also recognize and share the desire to profit off of one's hard work. In that spirit, I provide this software free of charge and free to distribute, but I ask that you keep this message attached. I am also providing a link to my venmo account below. If you use this program and think it has given you value, I would be grateful if you would pay me for that value. Thanks!

Syntax

The sparse syntax is very basic and can be summed up in the following way:

Basic symbols:

• ^ -> boolean AND
• v -> boolean OR
• ! -> boolean NOT

Function definition

Functions are defined by typing the function name and then the function definition using logic symbols. An example would be G = (p^q), where G is defined as boolean (p and q). You can also compose functions with one another to create larger functions. For example, using the previous function G, you could make another function H where H = !G, which would define H as boolean !(p^q). It is important to note when combining functions that the variables from the sub-function are reused directly. For example, if I define A = p and B = A^!p, the resulting function would be defined as B = p^!p, because it inherited the p variable from the function A. Also, it is extremely important to ensure that you do not attempt to use the arguments T,F,t or f in your functions or as function names because these are reserved for inputs to functions and are mapped to true false values directly. Here are some example function definitions:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> -> = !pvq
sparse> table ->
+-----+-----------+
| p,q | (->) !pvq |
+-----+-----------+
| F,F | True |
| F,T | True |
| T,F | False |
| T,T | True |
+-----+-----------+
sparse> nand = !(p^q)
sparse> table nand
+-----+---------------+
| p,q | (nand) !(p^q) |
+-----+---------------+
| F,F | True |
| F,T | True |
| T,F | True |
| T,T | False |
+-----+---------------+
sparse> xor = (pvq)^!(p^q)
sparse> table xor
+-----+--------------------+
| p,q | (xor) (pvq)^!(p^q) |
+-----+--------------------+
| F,F | False |
| F,T | True |
| T,F | True |
| T,T | False |
+-----+--------------------+

Comparing functions

You can compare logical functions with the == operator. typing f1 == f2 in the sparse terminal will print True if the functions are logically equivalent (if their truth tables are equal) and False if not. You can also compare several functions at once, but if any of the comparisons are false, the entire statement will evaluate to false. Here are some examples of function comparison:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> p == p
True
sparse> p == q
True
sparse> p == !p
False
sparse> (pvq) == !(!p^!q)
True
sparse> (pvq) == !(!p^!q) == (p^q)
False
sparse> (pvq) == !(!p^!q) == !!(pvq)
True

As you can see here, the arguments are intrinsic to each term in the comparison: the sparse interpreter defines a new logical function for each term. This is why p == q is True; their truth tables are equivalent and the names of the arguments used (p in function 1 and q in function 2) don't impact their truth tables. Here are the truth tables for these functions generated by the sparse table command:

sparse> table p
+---+----------+
| p | (anon) p |
+---+----------+
| F | False |
| T | True |
+---+----------+
sparse> table q
+---+----------+
| q | (anon) q |
+---+----------+
| F | False |
| T | True |
+---+----------+

It's clear from this that they are equal even though the names of the arguments are different.

Evaluating functions at given truth values

You can evaluate sparse functions with the { and } operators. These allow you to feed sparse specific arguments for the function to use when it runs. You can use 0, 1, T, F, t, or f as arguments. Here is an example:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> nand = !(p^q)
sparse> table nand
+-----+---------------+
| p,q | (nand) !(p^q) |
+-----+---------------+
| F,F | True |
| F,T | True |
| T,F | True |
| T,T | False |
+-----+---------------+
sparse> nand{0,0}
True
sparse> nand{0,1}
True
sparse> nand{1,1}
False
sparse> nand{F,F}
True
sparse> nand{F,T}
True
sparse> nand{T,T}
False
sparse> nand{T,t}
False
sparse> nand{T,1}
False
sparse> nand{T,0}
True
sparse> nand{f,t}
True

Composing functions

SPARSE has a powerful mechanism for defining new functions based off of other predefined functions. You can again use the { and } operators to feed functions different variable names as arguments, or even different functions as arguments. Let's say you want to see what the truth table for this function is: p -> q or q -> p. Here's how you would go about that in sparse:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> -> = !pvq
sparse> func = ->{p,q} v ->{q,p}
sparse> print func
Function Name User Definition Fully Substituted Definition Lambda Function Definition ------------- --------------- ---------------------------- -------------------------- func ->{p,q} v ->{q,p} ( !pvq) v ( !qvp) f = lambda p,q: ( not p or q) or ( not q or p) sparse> table func
+-----+--------------------------+
| p,q | (func) ->{p,q} v ->{q,p} |
+-----+--------------------------+
| F,F | True |
| F,T | True |
| T,F | True |
| T,T | True |
+-----+--------------------------+

Now let's say you want to define an or function from only nand functions. Here's how you could do that:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> nand = !(p^q)
sparse> table nand
+-----+---------------+
| p,q | (nand) !(p^q) |
+-----+---------------+
| F,F | True |
| F,T | True |
| T,F | True |
| T,T | False |
+-----+---------------+
sparse> or = nand{nand{p,p},nand{q,q}}
sparse> table or
+-----+--------------------------------+
| p,q | (or) nand{nand{p,p},nand{q,q}} |
+-----+--------------------------------+
| F,F | False |
| F,T | True |
| T,F | True |
| T,T | True |
+-----+--------------------------------+

This same idea can be used for pretty much any function composition you want. You can even compose functions with fixed values as one of their arguments. For example:

Welcome to SPARSE (Symbolic logic PARSEr) version 2.0. Type 'help' for a list of commands and uses.
Read the README.md for explanation of syntax and usage. Enjoy!
AUTHOR: James Burkett (Xtreme Software Developers) ; (xtremesoftwaredev@gmail.com)
sparse> -> = !pvq
sparse> table ->
+-----+-----------+
| p,q | (->) !pvq |
+-----+-----------+
| F,F | True |
| F,T | True |
| T,F | False |
| T,T | True |
+-----+-----------+
sparse> alwaysTrue = ->{f,p}
sparse> print alwaysTrue
Function Name User Definition Fully Substituted Definition Lambda Function Definition ------------- --------------- ---------------------------- -------------------------- alwaysTrue ->{f,p} ( !fvp) f = lambda p: ( not False or p) sparse> table alwaysTrue
+---+----------------------+
| p | (alwaysTrue) ->{f,p} |
+---+----------------------+
| F | True |
| T | True |
+---+----------------------+

In this example, alwaysTrue is defined as False -> p and takes one argument, p. This is always true, which the truth table of alwaysTrue reflects.

WARNING: Function composition is the part of SPARSE I am least confident in. If you find a bug, see message at the bottom of this readme.

Basic commands

Typing help in the sparse terminal will list commands, what they do, and how to use them.

Support

If you have new feature requests or bug reports, feel free to create an issue on the github page and/or email me at xtremesoftwaredev@gmail.com. For the time being I am actively supporting this project. If this ever changes I will change this message to let you know.

you are free to copy the cone from this project and make edits yourself, but this repo is a push mirror of a private repo of mine, so external edits made here will not stick around.