https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Logic and Boolean Algebra with no replies sorted by active. https://community.wolfram.com/groups/-/m/t/3647733 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/e2114695-21c4-4686-8107-a2ecaa8fe58f Tigran Nersissian 2026-03-02T11:53:13Z https://community.wolfram.com/groups/-/m/t/3515517 Hi Mathematica Expert; In order to get a better understanding of 3 sets of data, I created a Venn diagram. Now, I would like to convert the Venn diagram into a statement that describes the sets of data, which I am having trouble - see attached notebook. I would like to know if there is a Mathematica function or procedure that will take my Venn Diagram and convert it into a logic statement. I have searched the documentation and tried a bunch of things and cannot find a function that will perform the task. Additionally, I find it odd that I cannot create a Venn Diagram using Union and Intersections but need to use logical && or || operators which I have demonstrated in my attached notebook. Since I am new to these types of functions in Mathematica, my issues are most likely of my misunderstanding, so I would certainly appreciate any assistance. Thanks, Mitch Sandlin &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/5e364dea-0957-4e16-a401-ca4bc0602cc2 Mitchell Sandlin 2025-07-19T19:43:54Z https://community.wolfram.com/groups/-/m/t/3106345 Hello there, I have tried to use the image input of the phone app many times and it almost always fails me. The initial Math Preview is always correct but the WolframAlpha Input always gets messed up. Is this a known issue? ![This is a screenshot for example][1] Thank you in advance [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=IMG_5920.PNG&userId=3106330 Arthur Duron 2024-01-19T20:21:01Z https://community.wolfram.com/groups/-/m/t/2707515 Have you heard? We are hosting another [Wolfram R&D Live][1] **Q&A session** on Twitch and YouTube featuring developers from the Calculus and Algebra team! Join us Wednesday November 30th at 11 AM CST. [Devendra Kapadia][2] and [Daniel Lichtblau][3] will be answering your questions. You can help us narrow down topics interesting to you by discussing them on this thread. Here are some examples of topics: - Continuous Calculus (integration, differential equations...) - Discrete Calculus (summation, transforms, ...) - Algebra (polynomials, algebraic equations, ...) - Special Functions (BesselJ, MeijerG, ...) Find out more about Calculus and Algebra [here][4]. Post your questions ahead of time below! [1]: https://wolfr.am/RDlive [2]: https://community.wolfram.com/web/dkapadia [3]: https://community.wolfram.com/web/danl [4]: https://wolfr.am/calculus Keren Garcia 2022-11-21T17:18:00Z https://community.wolfram.com/groups/-/m/t/2182847 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/2963d00d-bd08-412f-83b9-c83fa0796f92 José Manuel Rodríguez Caballero 2021-02-03T11:19:38Z https://community.wolfram.com/groups/-/m/t/2132192 I am having problem with checking the results of the following expression.![enter image description here][1] [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2020-12-07at9.14.45PM.png&userId=2132178 What should I have to type in Wolfram for getting the answer of this equation? Thanks! Okin Swaum 2020-12-08T02:16:42Z https://community.wolfram.com/groups/-/m/t/2104590 In the embedded notebook below, I develop a computational essay concerning the implementation of a part of the [spi-calculus][1] in the Wolfram language. The notebook is based on these [slides][2]. &[Wolfram Notebook][3] [1]: https://www.sciencedirect.com/science/article/pii/S0890540198927407 [2]: https://www.wolframcloud.com/obj/jose.manuel.rodriguez.caballero/Published/TCSTalk%28October30_2020%29.nb [3]: https://www.wolframcloud.com/obj/6425a353-b00d-40d7-bca2-2fae3a5a1fb3 José Manuel Rodríguez Caballero 2020-10-30T03:11:47Z https://community.wolfram.com/groups/-/m/t/2099249 Is there a list of logical rectangular (over-determined) matrices where the pseudoinverse can be solved by a simple algorithm rather than the Mathematica Function PseudoInverse (Moore-Penrose method)? I seem to recall a page on Wikipedia that listed overdetermined logical (or binary) matrices that have a simple, formula-based solution not requiring Moore-Penrose. I can no longer find that page. Perhaps one of you has a good linear algebra textbook with such examples. Douglas Youvan 2020-10-21T18:43:26Z https://community.wolfram.com/groups/-/m/t/1950054 Good evening, I' hope you're all doing well in this rough COVID time. I'm actually trying to do a super simple logic operation on www.wolframalpha.com/. I want to (at least) output the list of the nearest department/region of a list of two department, and plot them on a geographical map. > <neighbor> of <Area 1> and <Area 2> I tried for one element and it worked :![enter image description here][1] But when I'm trying with a logical operator <AND> the system is not behaving as expected. ![With a logical operator][2]¨ ![With a Listw][3] I've looked online for similar example (wit two or more non mathematical variable), but I did not find any relevant example. Is it possible to solve such question in Wolfram Alpha, and without going Pro, nor using another wolfram service (like a notebook)? All the best Kosen [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2020-04-2201_04_31-neighborofArd%C3%A8che-Wolfram_Alpha.png&userId=1949499 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2020-04-2201_12_44-neighborArd%C3%A8cheandDr%C3%B4me-Wolfram_Alpha.png&userId=1949499 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=2020-04-2201_12_55-neighborof%7BArd%C3%A8che;Dr%C3%B4me%7D-Wolfram_Alpha.png&userId=1949499 Kosen Hitatchi 2020-04-21T23:39:20Z https://community.wolfram.com/groups/-/m/t/1822378 I heard Wolfram mention in a Twitch stream that Wolfram Research might be looking into making some kind of “human speakable” version of The Wolfram Language. Well, I’ve had an interest in constructed so called “logical languages” like Lojban for a while. Recently, as a project for myself on my free time, I worked on making up my own syntax for a language that’s kind of a mix between a specific natural language that I happen to know well, English, and a syntax more like a log like Lojban. I will jump in with am example text, then go back with a description I wrote up recently in attempt to describe how it all works. "Atrus stepped out of the air into a huge, conical bowl of darkness. And in the middle of that bowl, at the precise center of the massive, mile-wide hole that pierced it, a powerful column of water-as broad as a river-thundered straight up into the darkness until it was lost from sight, a great spike of brilliant, crystalline light glowing like a fierce flame at its center where it emerged from the glowing depths." steped named@atrus, air, huge conical full(darkness, #) bowl. inside@ri & very near(#, center very(huge & similar(#, planckLengths(2^160), width)) hole(#, t bowl), forceful@column <made(%, water) & similar(%, width #, river) & while(similar(%, thunder, sound), very quickly moved %, up & toward@darkness><until !possible see _, t@column <huge(magnificent spike %) & madeOf %, brilliant & similar(#, crystal, appearTo) light <glow <similar fierce@flame>> <near(%, center part t column) & mostly %, near(#, locationOf(emerge ri, glow deep. The second part is an attempted translation by me of a couple sentences which I happen to like, from the opening of a chapter of The Book of Atrus by Robyn and Rand Miller and David Wingrove. It's a good book, related to the Myst video games, I recommend it. Notes on the language: This is my attempt to describe a syntax for a logical language that sounds a lot like English (just to make it easier to learn for some people.) (Why English? Because it's my first language. Feel free to substitute English words for words from your own language. Know Esperanto? Be my guest :-) To express a predicate with arguments, simply state the predicate, plus the arguments in parenthesis separated by commas, like this: The person walked from the house to the school. walked(person, house, school) Predicate slots are defined as being the same way they are in a corresponding Lojban predicate. nonrestrictive clauses are like this: I broke a bowl that you used. broke(i, bowl<used(you, %)> Periods can be used to close all open parenthesis or brackets or anything at once like this: broke(i, bowl<used(you, %. restrictive clauses are similar: I broke the bowl which you used. broke(i, bowl{used(you, %. Both of these also work where, if the first argument in the relative clause is the relative pronoun, one can leave out the blank for the relative pronoun, like this: I broke a bowl made of clay broke(i, bowl<madeOf(clay. is the same as broke(i, bowl<madeOf(%, clay. because that relative pronoun, the %, is the first argument it can be left out in this case and is taken to have the same meaning. One can leave predicate spaces open by using a blank like this: "_" I walked from my home to school walked(I, my(home), school. I walked to school walked(I, _ ,school. To switch predicates around, you can do something like this: I ate the apple Ate(i apple) The apple was eaten by me Ate(# apple)(i) Also, I jumped down and yelled a curse jumped(#, down) & yelled(#, curse) (i) & means and, | means or, ! means not. Right grouping of parenthesis can often be implicitly assumed, so the can be eliminated sometimes, like ate(i, big(red(tasty(apple. can actually be just ate i, big red tasty apple. due to the right grouping of parenthesis. “@” can be used to group two words more tightly. If you want to mention again something you already mentioned, "t" is a predicate which means "the previously mentioned": English: I went to the store. Then I left the store. This language: then(went(i, store), left(i, t store. One can also use "t" with just the first letter, or the first few letters, of the thing you are mentioning, such as: then(went(i, store) left(i, t s. then(went(i, store) left(i, t sto. If one is mixing different kinds of parethesis / brackets, one can close all of one kind of bracket by closing another, in a manner like this: I hit the car which was near the middle of the road with my truck hit(i, car<near middle(_, road>, my(truck. fully expanded syntax: hit(i, car<near(%, middle(_, road))>, my(truck)) You can also use brackets to group things together arbitrarily if other rules aren’t working in some specific case. I'm experimenting with throwing a few lojban cmavo in, like "ri" refers to the most recently mentioned predicate argument of any kind. I’m actually still working out how this should all actually be *pronounced*. Lojban like words could be used to pronounce all the symbols. Or perhaps much of the grammar implied by the symbols could be shown in a tonal way like another interesting loglang called “Toaq” does. Also: semi related project: I’m working on translating some English vocabulary into predicate logic, which I posted about, earlier, [here][1]. I’m certainly very curious to see what kind of natural language / Wolfram language mixes Wolfram Research might come with some day! [1]: https://community.wolfram.com/groups/-/m/t/1533854?p_p_auth=I3nz50oC%20%E2%80%9Chere%E2%80%9D Eric Parfitt 2019-11-10T02:39:18Z https://community.wolfram.com/groups/-/m/t/1732842 #Introduction I attended the Wolfram High School Summer Camp in the 2019 session. For my project, I attempted to implement a framework for creating, training, applying, and inspecting Tsetlin Machines. Tsetlin Machines are unique when compared with other methods of machine learning because they operate using Boolean operations on binary data, and the individual building blocks only require a single integer in memory. Compare this to the Neural Net, which operates by applying Calculus to floating point numbers, and where each neuron requires multiple pieces in memory corresponding to their activation function, bias, connections, weights of connections, etc. Tsetlin Machines also have the advantage that they are interpretable: once a Tsetlin Machine has been taught, it can be interpreted as a propositional formula, whereas Neural Networks, once taught, are famously "black boxes" that no one knows what's really happening inside. Furthermore, Tsetlin Machines can be used in mathematical research to produce satisfactory propositional formulas. This community post will provide an overview about how Tsetlin Machines work. The only code in this community post will be at the very end, where I give a short example of how a Tsetlin Machine is created and trained using my framework. My full Wolfram Language implementation can be on my github account, a link to which can found at the bottom of this community post. # Tsetlin Automata Tsetlin Machines are a kind of machine learning based on combining Tsetlin Automata to assemble a propositional formula. So, what is a Tsetlin Automaton? A Tsetlin Automaton is an extremely simple automaton that has a finite number of states ($2n$) (image below). Based on it's state, a Tsetlin Automaton can chose between 2 actions ($a_1$ and $a_2$). ("Action" here is an abstract concept that can basically represents a choice between two things.) It chooses the first action if it's current state is equal to a certain value ($n$) that I call the state identifier, and chooses the second action if it's state is above the value. So, when does a Tsetlin Automaton make this choice? Both when giving output and training. The only output ever given by a Tsetlin Automaton is its' current action. So, whenever a Tsetlin Automaton has to do pretty much anything, it starts by choosing an action and outputting it. ![tsetlin automaton][1] <sub>Image reproduced from https://arxiv.org/pdf/1804.01508.pdf</sub> Now, how does an individual Tsetlin Automaton learn? Via punishment and reward. It's pretty simple: when a Tsetlin Automaton makes a good choice, it gets rewarded (and it's current state moves farther from the point at which it would chose the other action). When it makes a bad choice, it is punished (and it's current state moves closer to the point at which it would chose the other action). Who rewards and punishes the Tsetlin Automaton? The environment. For example, imagine that a Tsetlin Automaton (let's call him Steve) has to chose between eating two kinds of chocolate, 1 and 2. Steve has 6 states ($n=3$). He starts randomly selects one to start with, and chooses the action of eating chocolate 2 (so his current state is 4). Eating this chocolate boosted his cognitive power, so he is rewarded (and his current state goes to 5). He takes another bite, but this time there is no effect, so he is punished (state goes back to 4). Another bite, and another failure leads to another punishment (his state goes to 3). Because Steve's state crossed the "action border" between eating chocolate 2 (state $>3)$) and eating chocolate 1 (state $\leq3$), his next choice is to eat chocolate 1. This does boost his cognitive power, so he is rewarded (state goes to 2). Another bite boosts his cognitive power again, and again he is rewarded (state goes to 1). At this point, Steve is pretty confident that chocolate 1 is the better option because it boosts his cognitive power more often, so he decides to stop training and stick with chocolate 1. Below is a graph of Steve's state (blue) as he learns (yellow is the "action tipping point"). <sub>The above story a work of fiction. Any resemblance to actual events or locales or persons, living or dead, is entirely coincidental.</sub> ![steve learn path][2] # Tsetlin Machines ![tsetlin machine full structure][3] <sub>Image reproduced from https://arxiv.org/pdf/1804.01508.pdf</sub> So, how do Tsetlin Automata work together to form a full Tsetlin Machine? By learning which inputs to a Tsetlin Machine are important. But before learning can be explained, the process of how a Tsetlin Machine calculates its' outputs must be explained. For this purpose, consider a Tsetlin Machine that has not yet been trained, trying to learn the simple 2-input XOR operation: ![xor operation][4] Input to a Tsetlin Machine is a list of Booleans (in this case, the list is length 2 because the goal is to emulate XOR, which takes 2 inputs). After the input is taken, it is duplicated and inverted. So, the complete input ends up taking the form `{{a, b}, {NOT a, NOT b}}`. For example, an input of `{True, False}` would produce `{{True, False}, {False, True}}`. Once the complete input is calculated, it is fed to a team of Tsetlin Automata (which are randomly initialized). There are a number of Tsetlin Automata equal to length of the input-- that is, each Automata corresponds to one input value. Based on its current state, each Automata chooses either to include or exclude the input (if the current state is less than or equal to the state identifier, the input is excluded. Otherwise, it is included). ![single clause calculate included][5] Any included inputs in the team are then ANDed together. There actually can be multiple teams of Tsetlin Automata, each of which chooses which inputs to include and exclude independently of the other teams (as well as ANDs the results independently). ![all clause final outputs][6] Once each team of Tsetlin Automata has calculated their final, joint result, the outputs from that result is sent to an output function. There are many different output functions, the two most common of which are OR and the Alternating Sum. For this example, I will use OR. ![output function][7] The final output from this Tsetlin Machine given the input of `{True, False}` is True, which happens to be correct. However, this machine will fail on an input of {False, True}, and will output, instead of the expected `True`, a `False`. So how does the Tsetlin Machine learn that this is wrong? Through feedback. There are 2 different kinds of feedback that a Tsetlin Machine can provide back to its' Automata: Type 1 and Type 2. Although the exact details of the types of feedback are rather complicated, the point of each is simple: Type 1 feedback combats false negative output (when the machine outputted a False when it should have outputted a True), and Type 2 feedback combats false positive output (when the machine outputted a True when it should have outputted a False). Feedback is given to a clause at a time, based on a function provided by the user (at least in my implementation) called a "feedback decider" which takes a series of arguments that contain information about the current state of the machine . Each kind of output function requires a different kind of feedback decider, to make sure the feedback is correctly assigned. At the automata level, feedback takes the form of a weighted reward or punishment (a reward or punishment that probabilistically happens), based on an s-value (which controls precision) specified by the person training the machine. There is more information in the original paper and in my implementation about how feedback works. In short, feedback punishes or rewards automata to make them more likely to include or exclude inputs correctly. After feedback is given, then a new input is given to the machine and the process repeats. One detail that is important to note is that Tsetlin Machines can have multiple outputs, each of which is trained independently and has their own Tsetlin Automata teams. # Using the Framework The following chunk of code shows how one would train a Tsetlin Machine from scratch to learn the XOR operation using my framework: TsetlinMachineTrain[ (* function that trains a Tsetlin Machine *) TsetlinMachineInitialize[ (* make a new Tsetlin Machine *) 3, (* state identifier 3 *) 2, (* 2 inputs *) 2, (* 2 clauses *) {TsetlinUtilityOr}], (* one output that uses the function TsetlinUtilityOr *) {{False, False}, {False, True}, {True, False}, {True, True}}, (* training input data *) {{False}, {True}, {True}, {False}}, (* training output data *) {{False, False}, {False, True}, {True, False}, {True, True}}, (* testing input data *) {{False}, {True}, {True}, {False}}, (* testing output data *) 9, (* s-value (precision) *) TsetlinUtilityOrFeedbackDecider[#1, #2, #3, #4, #5, #6, 2] &, (* feedback decider with threshold set to 2, more info in paper *) 1.00] (* train until it has 100% accuracy *) # Further Resources * https://github.com/ComradeSparklePony/WL-Tsetlin-Machine (my Wolfram Language implementation of a Tsetlin Machine) * https://arxiv.org/pdf/1804.01508.pdf (the original paper) * https://github.com/cair/TsetlinMachine (the original implementation of a Tsetlin Machine) [1]: https://community.wolfram.com//c/portal/getImageAttachment?filename=fixed_deterministic_run_1.png&userId=1684084 [2]: https://community.wolfram.com//c/portal/getImageAttachment?filename=stevelearnpath.png&userId=1684084 [3]: https://community.wolfram.com//c/portal/getImageAttachment?filename=Overall_Architecture.png&userId=1684084 [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=xor.png&userId=1684084 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=ta-choice.png&userId=1684084 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=clauseoutput.png&userId=1684084 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=outputoutput.png&userId=1684084 Dmitri Volkov 2019-07-12T01:39:04Z https://community.wolfram.com/groups/-/m/t/1382823 The goal of this project has been to explore NAND expressions and look for expressions equivalent to XOR. The Wolfram Language can already simplify XOR expressions with NANDs by using the following function but it only simplifies to a two level tree. By using more than two levels there is a possibility of finding a simpler version of three or four input XOR expressions. The reason that I chose to use NAND gates is that they are universal gates (any expression can be represented with a combination of NAND gates). Other universal gates like NOR would work but it seemed simplest to just stick with NAND to keep things consistent. `BooleanMinimize[Xor[a, b, c], "NAND"] // TreeForm` ![NAND simplification for XOR[a,b,c] in Tree Form][1] ## Two Input Trees ## The first thing I implemented was a recursive function that creates all of the different NAND trees possible with a given amount of NAND gates. It works by assuming that each NAND gate only has two inputs. From this it runs through the possibilities for the NAND gate configurations on each input. ![Nand Tree Logic][2] The code starts by defining the first case of the recursive function and then on the next gates it runs through the different combinations with tuples to generate all of the outcomes. It also creates NAND trees with half of the amount of NAND implemented and it doesn't know what to do with an odd amount of gates so "nandTreeCreate" was implemented to fix that by multiplying the input by two. Additionally it uses a new NAND function that get's rid of trivial cases that aren't worth computing (Ex. Xor[a, !a]). nand[a_, a_] := Null; nand[a_, ! a_] := Null; nand[! a_, a_] := Null; nand[a_, b_] /; OrderedQ[{a, b}] := Sow@Nand[a, b]; nand[a_, b_] := Null; nandTreeGenerate[0] := {a, b, c, ! a, ! b, ! c} nandTuples[list1_, list2_] := Replace[Reap[ Do[nand[a, b], {a, list1}, {b, list2}]], {{_, {x_}} :> x, _ :> {}}] nandTreeGenerate[ 0] := {a,b,c,!a,!b,!c}; nandTreeGenerate[nGates_] := nandTreeGenerate[nGates] = Module[{subtrees = nandTreeGenerate /@ Range[0, nGates - 1]}, Join @@ Table[nandTuples[subtrees[[i]], subtrees[[nGates - i]]], {i, 1, nGates - 1}] ] nandTreeCreate[nGates_] := nandTreeGenerate[nGates*2] This turned out to be an effective set of functions but it wasn't very useful since it only generates two input NAND trees and no simpler forms of XOR were found by running tests with this function. The following function was used to compare it to XOR. Select[nandTreeCreate[5], TautologyQ[Equivalent[Xor[a, b, c], #]] &] ##Multi-Input Tree Generation ## By inputting the amount of leaves into the recursive function, I was able to expand it in order to account for more than two input NAND gates. This uses the same general structure as the two input NAND generate function except it is based on integer partitions to find all of the different combinations. nand[arg_] := Nand[arg]; nand[args___] /; Equivalent[args] := Null; nand[args___] /; OrderedQ[{args}] := Nand[args]; nand[args___] := Null; nandTuples[l_] := (nand @@ #) & /@ Tuples[l] nandTreeGenerate[1] := {a,b,c]}; nandTreeGenerate[nLeaves_] := nandTreeGenerate[nLeaves] DeleteCases[Module[{subtrees = nandTreeGenerate /@ Range[1, nLeaves - 1]}, Join @@ ((nandTuples[subtrees[[#]] & /@ #] & /@ (IntegerPartitions[nLeaves - 1])) ], Null] This works super well but it's still computationally intensive and I figured out later that some of the logic must be wrong since it misses a couple of cases every once and awhile. It's still good for getting a basic idea of the different cases that come from different leaf counts though. ## Random Generation ## It seems that the best way to generate expressions computationally comes from random generation. This is because it can be stopped and started within a time limit even though it doesn't get every possible expression. In order to implement this I used a function that inserts either a NAND gate or a variable at a random spot within the expression. varlist = {\[FormalA], \[FormalB], \[FormalC]}; addSomething[ex_] := Module[{positions}, positions = Position[ex, _myNand, {0, Infinity}]; Insert[ex, RandomChoice[{.2, .7, .7, .7} -> Join[{myNand[]}, varlist]], Append[RandomChoice[positions], 1]] ] makeTree[nLeaves_] := ( (Last@NestList[addSomething, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nor randTreeGenerate[nLeaves_, nTimes_] := makeTree /@ Table[nLeaves, nTimes] Although this is good for generating most functions, some cases become increasingly unlikely as it adds more terms. This makes it necessary to adjust the weights for NANDs and variables so that all of the cases have an equal chance of occurring. I didn't have enough time to find the right values so eventually I setup the weights as random integers so that it would have a good distribution for each of the different weight combinations. ##Visualizing the Data## At the end I made a couple of functions that could generate expressions for awhile and then put it in a form that's easy to analyze. There are two equivalents of the functions depending on if you want to input the iterations or the duration that it should run for. It also has the option to input what percentage of those expressions should use NOR gates if any variation is needed. Clear["Global`*"] counts = Table[0, {i, 0, 255}]; varlist = {a, b, c}; addSomething[ex_, nand_: 1, var_: 1] := Module[{positions}, positions = Position[ex, _myNand, {0, Infinity}]; Insert[ex, RandomChoice[{nand, var/3, var/3, var/3} -> Join[{myNand[]}, varlist]], Append[RandomChoice[positions], 1]] ] makeTreeNand[nLeaves_] := ( (Last@NestList[ addSomething[#, RandomInteger[{1, 20}], RandomInteger[{1, 20}]] &, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nand makeTreeNor[nLeaves_] := ( (Last@NestList[ addSomething[#, RandomInteger[{1, 20}], RandomInteger[{1, 20}]] &, myNand[], nLeaves - 1]) /. myNand[] :> RandomChoice[varlist]) /. myNand -> Nor visualizeCount[leaves_, iterations_, Nand_] := Module[{tree, counts = Table[0, {i, 0, 255}], c}, Monitor[Do[ c = 100*N@i/iterations; tree = makeTreeNand[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++; , {i, 1, iterations * (Nand/100)} ], c]; Monitor[Do[ c = 100*N@i/iterations; tree = makeTreeNor[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++; , {i, 1, iterations * (1 - (Nand/100))} ], c]; Print[ListLogPlot[Sort[counts[[#]] & /@ Range[0, 254]] + 1]]; Print[ArrayPlot[ IntegerDigits[#, 2, 8] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1], Mesh -> True, ColorRules -> {0 -> Red, 1 -> Darker@Green}]]; Print[Column[ FullForm /@ (FullSimplify[BooleanFunction[#, varlist]] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1])]]; Print[BarChart[counts[[#]] & /@ Range[0, 254]]] ] visualizeWhile[leaves_, time_, Nand_: 100] := Module[{tree, c, start = UnixTime[]}, Monitor[ While[UnixTime[] < (start + (time*(Nand/100))), c = UnixTime[] - start; Do[tree = makeTreeNand[RandomInteger[{1, leaves}]]; len += 1; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++;, {100}] ], c]; start = UnixTime[]; Monitor[ While[UnixTime[] < (start + (time*(1 - (Nand/100)))), c = UnixTime[] - start; Do[tree = makeTreeNand[RandomInteger[{1, leaves}]]; counts[[FromDigits[Boole[BooleanTable[tree]], 2]]]++;, {100}] ], c]; Print[ListLogPlot[Sort[counts[[#]] & /@ Range[0, 254]] + 1]]; Print[ArrayPlot[ IntegerDigits[#, 2, 8] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1], Mesh -> True, MeshStyle -> {Black, Thick}, Background -> Black, ColorRules -> {0 -> Red, 1 -> Darker@Green}]]; Print[Column[ FullForm /@ (FullSimplify[BooleanFunction[#, varlist]] & /@ Flatten[Position[counts[[#]] & /@ Range[0, 254], 0] - 1])]]; Print[BarChart[counts[[#]] & /@ Range[0, 254]]] ] Because there are only three variables being used, the amount of possible truth tables is 256. The function uses a list to keep track of the amount of times each of those truth tables occurred and at the end it creates a logarithmic line plot and a histogram. This particular test ran for 12 hours or so. The logarithmic plot is shifted up one to make it easier to analyze the data. ![Random Expression Logarithmic Plot][3] ![Random Expression Histogram][4] It also formats the truth tables that weren't generated into an array plot and lists the equivalent expressions for each of those truth tables. ![Expressions not generated][5] Xor[a,b,c,And[a,b,c]] Not[Xor[a,b,c,And[a,b],And[a,b,c]]] Not[Xor[a,b,c,And[a,c],And[a,b,c]]] Not[Xor[a,b,c,And[b,c],And[a,b,c]]] Not[Xor[a,b,c]] Not[Xor[a,b,And[a,c],And[b,c],And[a,b,c]]] Not[Xor[b,c,And[a,b],And[a,c],And[a,b,c]]] Xor[a,c,And[a,b],And[b,c],And[a,b,c]] Xor[a,b,c] Xor[a,b,c,And[b,c],And[a,b,c]] Xor[a,b,c,And[a,c],And[a,b,c]] Not[Xor[a,b,c,And[a,b,c]]] ##Conclusion## From random generation I was able to deduce to a reasonable degree of certainty that it is impossible to generate an equivalent NAND expression that's simpler than the one the Wolfram Language generates for three input XOR gates. There are most likely equivalent expressions out there for four or more input XOR expressions but that proves to be very computationally intensive and time consuming. It is pretty interesting how some expressions require significantly more NAND gates to be expressed because of their structure and the nature of NAND gates. It would be interesting to look into making expressions with NOR and XOR gates in the future and maybe putting more time into generating random expressions. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture2.PNG&userId=1371737 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Tree.png&userId=1371737 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture1.PNG&userId=1371737 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture3.PNG&userId=1371737 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Capture.PNG&userId=1371737 Ben Huenemann 2018-07-13T17:54:42Z https://community.wolfram.com/groups/-/m/t/1257404 Mathematica doesn't use the usual boolean notation with which circuit designers are familiar. The plan is to enter boolean expression as a c d + b d not a + a not b not c (a not c not d + b not c not d) and produce overbars on the complemented variables. I can't get the overbars to show as code, so I'll use images. A notebook is attached with all the code. ![enter image description here][1] The not is implemented as: $PreRead =. $PreRead = (ReplaceAll[#, "not" :> "OverBar@"] &) Boolean minimization is a Mathematica function, but it uses boolean expressions in the usual logical form. That is foreign to circuit designers. Here is the minimization converted to engineering format: boolmin[m_, opts_: "DNF"] := Module[{ans}, ans = BooleanMinimize[ m /. {Plus -> Or, Times -> And, OverBar -> Not}, opts]; ans = ans /. {Or -> Plus, And -> Times, Not -> OverBar}; ans /. {a_^_ -> a, _Integer a_ -> a} ] The engineering format is converted to logical format, minimized, and then converted back to engineering. {a_^_ -> a, _Integer a_ -> a} is necessary because the expression is arithmetic. Here it is applied to the expression above: ![enter image description here][2] There are options: ![enter image description here][3] Here is a truth table in engineering format: variables[ m_] := (Variables[m] /. OverBar -> Variables // Flatten // DeleteDuplicates // Sort) /. List -> Sequence truthTable[m_] := Module[{mm}, mm := variables[m]; TableForm[ Boole@BooleanTable[{variables[m], m /. Plus -> Or /. Times -> And /. OverBar -> Not}, {variables[ m]}], TableHeadings -> {None, {mm}}]] tt = truthTable ![enter image description here][4] Expressions can be checked for truth: ![enter image description here][5] Here are the boolean axioms applied to the above expression: ![enter image description here][6] This particular expression minimizes to the same expression as the default Mathematica minimization but that is an unfortunate choice. In general that is not so. DANGER!! The opening line in the first attached notebook removes all current work in your notebook. I can't replace the downloaded file with a new file. Use the corrected version, please. One error found and fixed. With some tweaking, the boole.nb notebook below resulted. It's pretty robust. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=5151boole131.png&userId=455211 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=boole132.png&userId=455211 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=boole133.png&userId=455211 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=boole134.png&userId=455211 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=boole135.png&userId=455211 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=boole136.png&userId=455211 Eric Johnstone 2018-01-02T15:15:44Z https://community.wolfram.com/groups/-/m/t/1140640 <h1>Introduction</h1><br> My name is Taha Shaikh and I attended the 2017 Wolfram Alpha High School Summer Camp. At this camp, I researched and created a project about many-valued logic. In this exploration, I implemented multivalued logic with the Wolfram language. Multivalued logic is a branch of propositional calculus in which there are more than two truth values. Multivalued logic contrasts with traditional two-valued logic in which only two truth values exist: <i>True</i> and <i>False</i>. The most popular types of many-valued logic are three-valued Kleene and Priest logic, which incorporate an additional <i>Indeterminate</i> value. The truth function for conjunction, for example, is given by: ![Ternary Logic Conjunction Table][1] <hr> <h2>Procedure</h2> <br> The first step in this project was understanding the aim of the investigation and doing research on the topics at hand. Next, support for the new truth value <i>Undecided</i> was added to the basic boolean operations. I used Kleene and Priest logic tables to redefine the boolean operations. ![Different Logic Tables][2] Undecided = Undecided; Unprotect[And]; And[Undecided, True] := Undecided And[Undecided, Undecided] := Undecided Protect[And]; Unprotect[Boole]; Boole[Undecided] := 0 Boole[False] := -1 Protect[Boole]; Unprotect[Or]; Or[Undecided, False] := Undecided Or[Undecided, Undecided] := Undecided Protect[Or]; Unprotect[Not]; Not[Undecided] := Undecided Unprotect[Implies]; Implies[True, Undecided] := Undecided Implies[Undecided, Undecided] := True Implies[False, Undecided] := True Implies[Undecided, True] := True Implies[Undecided, False] := Undecided Protect[Implies]; Unprotect[Nand]; Nand[Undecided, Undecided] := Undecided Protect[Nand]; Unprotect[Nor]; Nor[Undecided, Undecided] := Undecided Protect[And]; <br> These functions ensured that the rest of the functions created worked smoothly. The next step was creating a function that would generate truth tables based on a given operation and the list of the variables used. The TernaryTable function used an input of a logic expression and the list of used variables and converts it into a truth table. Where Boolean logic has $2^2 = 4$ unary operators, the addition of a third value in ternary logic leads to a total of $3^3 = 27$ distinct operators on a single input value. It uses the Tuples function to run through all of the possible permutations of the three truth values and runs them through the given expression. <br> <br> TernaryTable[expr_, vars__] := ReplaceAll[expr, Thread[vars -> #]] & /@ Tuples[{True, False, Undecided}, {Length[vars]}] <br> An example of TernaryTable in action: ![enter image description here][3] This function uses the Tuples function to run through the various combinations and permutations of the three different truth values. The truth table generated has length $3^n$ in which $n$ is the number of variables used in the logic expression. In the case of this example, since four variables are present (x, y, z, w), the length of its truth table is $3^4$ or 81. This is because all possible permutations of the three truth values are considered when generating the truth table. Even though many of the outputs are the same, their individual logic expressions were unique. Creating a function that created truth tables was a good first step and helped me better visualize and understand the topic. <hr> <h2>Cooking Up Some Functions</h2><br> The main strategy for determining the identity of the truth table was brute-force-esque. All of the possible arrangements of the basic logic functions were ran through the tuples of the three logic values. Their logic expression was also calculated and correlated to their truth table. First, I made a function called LotsOfTernaryTables that produces a lot of ternary tables. Given the number of variables, it produces every possible truth table for every possible arrangement of the functions And, Or, Nand, Nor, and Not for the given variables. <br> LotsOfTernaryTables[x_] := MatrixForm[ Groupings[#, {And -> 2, Or -> 2, Nand -> 2, Nor -> 2, Not -> 1}, HoldForm] & /@ Tuples[{True, False, Undecided}, {x}]] <br> In this function, Groupings was used in coordination with Tuples to produce a huge number of different tables. <br><br> In order to visualize these massive tables, I created a function called TernaryPlot that generates a colorful plot of the different logic truth tables. It converts the outputs from LotsOfTernaryTables into numerical values and creates a colorful array plot. It uses similar mechanics to the previous function.<br> TernaryPlot[x_] := ArrayPlot[ Boole[Groupings[#, {And -> 2, Or -> 2, Nand -> 2, Nor -> 2, Not -> 1}]] & /@ Tuples[{True, False, Undecided}, {x}], ColorRules -> {1 -> Green, 0 -> LightBlue, -1 -> Red}] <br> The array plot created by this function has several visible patterns and sequences and makes very interesting art. A ternary plot with 3 variables, for example, looks like so:<br> ![enter image description here][4] <br><br> In this plot, every column represents an individual truth table. In this case, since there are three variables, each column contains $3^3=27$ values. When creating ternary plots with more variables, patterns become crazier and the resulting image has some pretty appealing qualities. The ternary plot for 6 variables looks like so:<br> ![enter image description here][5] <br> Finally, the last function I created was called TernaryFunction and was based off of the pre-existing BooleanFunction. When given a ternary truth table, this function would return the logic expression associated with it. After generating a list of truth tables and a list of logic expressions, the two lists were then correlated with each other. After retrieving the correct truth table, its corresponding logic expression was derived and returned. In order to assist with this process, the logarithm base 3 of the length of the truth table was calculated and used to narrow down the number of arguments that had to be processed. The function still works with an unlimited number of arguments as long as $log_3n$ is an integer with $n$ representing the length of the inputted truth table. <br><br> This is an example of TernaryFunction in action:<br> ![enter image description here][6] <br> The logic function is returned with the given variables as defined by the user. <hr> <h2>Differences From Binary Logic</h2><br> <p>Multi-valued logics are intended to preserve the property of designationhood, or being designated. Since there are more than two truth values, rules of inference may be intended to preserve more than just whichever corresponds to truth. For example, in a three-valued logic, sometimes the two greatest truth-values (when they are represented as e.g. positive integers) are designated and the rules of inference preserve these values. Precisely, a valid argument will be such that the value of the premises taken jointly will always be less than or equal to the conclusion.</p> <br> <hr> <h2>Applications of Ternary Logic</h2> <br> <p>An application of many valued logic is geared towards the design of electronic circuits which employ more than two discrete levels of signals, such as many-valued memories, arithmetic circuits, and field programmable gate arrays. Many-valued circuits have a number of theoretical advantages over standard binary circuits. For example, the interconnect on and off chip can be reduced if signals in the circuit assume four or more levels rather than only two. In memory design, storing two instead of one bit of information per memory cell doubles the density of the memory in the same die size. Applications using arithmetic circuits often benefit from using alternatives to binary number systems. For example, residue and redundant number systems can reduce or eliminate the ripple-through carries which are involved in normal binary addition or subtraction, resulting in high-speed arithmetic operations.</p> [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=tablemyb.png&userId=1138154 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=allthetables.png&userId=1138154 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=terntable.png&userId=1138154 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=plotarry.png&userId=1138154 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ternarylogic6-1.png&userId=1138154 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ternfunc.png&userId=1138154 Taha Shaikh 2017-07-07T11:10:37Z https://community.wolfram.com/groups/-/m/t/1000247 I have a habit of trying out correctness about some logical statements with worlfram alpha by generating truth table for them. For example, I can try if this: ((¬x?y)?(¬x?¬y))?x is correct or not by geerating truth table for [`((¬x?y)?(¬x?¬y))`](http://www.wolframalpha.com/input/?i=((not+x+implies+y)+and+(not+x+implies+not+y))) which turns out to be the same as `x` column in the same truth table. Hence the above is correct. However is there any way I can check same for biconditionals involving nested existential and universal quantifiers and predicates? For example can I somehow verify rules of this kind?: (?x)(?y)?(x,y)?(?y)(?x)?(x,y) **Update** I am able to do following check `?x,y(x?y)` as follows: [`Resolve[ForAll[{x,y}, x or y]]`](http://www.wolframalpha.com/input/?i=Resolve%5BForAll%5B%7Bx,y%7D,+x+or+y%5D%5D) which correctly returns `False` as `(x?y)` does not hold for all `x` and `y`. So now I thought I can do something similar to obtain `True` for following (which is a general fact): `¬(?x)?(x)?(?x)¬?(x)`. I tried this: [`Resolve[ForAll[x,(not ForAll[x, x]) xnor (exists[x,not x])]]`](http://www.wolframalpha.com/input/?i=Resolve%5BForAll%5Bx,(not+ForAll%5Bx,+x%5D)+xnor+(exists%5Bx,not+x%5D)%5D%5D) But it did not work. Note that `?` is nothing but `xnor`. So how do I do this especially something like following also correctly returns `True`: [`Resolve[not ForAll[x, x]]`](http://www.wolframalpha.com/input/?i=Resolve%5Bnot+ForAll%5Bx,+x%5D%5D) which stands for `¬?x(x)`. Mahesh Abnave 2017-01-23T15:39:00Z https://community.wolfram.com/groups/-/m/t/967268 A new SystemModeler example has been added to the list of downloadable models available on the SystemModeler site, [Binary Counter][1]. Counters can be used for a huge array of applications. They can, for example, be used to count pulses from a sensor attached to a wheel to count the number of revolutions, which in turn can be used to calculate the speed of the wheel. Counters also can be used as digital clocks for different purposes. Another typical use of a digital counter is in central processing units (CPUs), where a certain kind of counter (program counters, or PCs) is used as a way for the CPU to walk through program instructions, one by one, from a memory. Flip-flops or latches are used as basic components in digital circuitry and work as a kind of memory that stores the state of one bit. By using multiple flip-flops, it is possible to construct digital state machines. A binary counter is basically a state machine that just cycles through its states for each cycle of a clock signal. A diagram of the counter component can be seen below. ![Diagram view of the counter][2] The example utilizes a new feature in SystemModeler 4.3. Enumeration types, such as the [logic levels][3] in digital circuitry are now plotted using their discrete levels on the y-axis. This is apparent when plotting the internal states of the counter, for example: ![Digital levels][4] This of course not limited to built-in enumerations. The following custom enumeration type: ![Modelica code][5] Could look like this, when plotted in Simulation Center: ![Temperature levels][6] For more information on what is new in SystemModeler 4.3, check out the [What's New][7] page. [1]: https://www.wolfram.com/system-modeler/examples/more/electrical-engineering/binary-counter "Binary Counter" [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=modeldiagram.png&userId=554806 [3]: http://reference.wolfram.com/system-modeler/libraries/Modelica/Modelica.Electrical.Digital.Interfaces.Logic.html [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=digitallevels.jpg&userId=554806 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=CODE.png&userId=554806 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=customunits.jpg&userId=554806 [7]: http://www.wolfram.com/system-modeler/new-in-4/ Patrik Ekenberg 2016-11-21T08:46:56Z https://community.wolfram.com/groups/-/m/t/947678 Hello, I would like to use the Fuzzy Logic in Mathematica. I found the following [page][1] at Wolfram. Is there a possibility to use this in the current Mathematica Version ? thanks Sebastian [1]: http://reference.wolfram.com/applications/fuzzylogic/ Sebastian Lehmann 2016-10-21T10:33:38Z https://community.wolfram.com/groups/-/m/t/865899 We are developing a course on Logic for high school students, and are seeking to work with teachers who are willing to offer it as a semester long course. We are interested in creating an offering of this course using the Wolfram platform. In this note, we give our rationale for the need for such a course and outline our approach. Interested teachers can get in touch with us via email as specified at the end of this article. Some elements of logic already appear in secondary school courses, for example, elementary proofs in Geometry, discussion of fallacies in writing courses, etc. Logic, however, is not taught as a standalone topic in most secondary schools today. It is our belief that logic is important enough to deserve treatment as a standalone topic. First of all, it is essential for many STEM disciplines, and especially for computer science. Logic is important to Computer Science in the same way as Calculus is important to Physics. In modern times, as Computer Science is as important as Physics, it only behooves us to teach Logic at the high school level. More broadly, logic is useful to everyone. For example, in government and politics, logic plays a central role in understanding and analyzing political arguments. Logic is a more relate-able mathematical subject for students who see relationships between people and things but who are uncomfortable reducing everything to numbers. Logic is closely related to two of the standards for mathematical practice required by Common Core. (1) Reason abstractly and quantitatively: The students are able to abstract a given situation and represent it symbolically and manipulate the representing symbols as if they have a life of their own, without necessarily attending to their referents. (2) Construct viable arguments and critique the reasoning of others: Students can build a logical progression of statements to explore the truth of their conjectures. They justify their conclusions, communicate them to others, and respond to the arguments of others. They can distinguish correct logic or reasoning from that which is flawed, and—if there is a flaw in an argument—explain what it is. Logic directly supports two of the practices for science and engineering identified by the Next Generation Science Standards. (1) Constructing explanations and designing solutions: The goal for students is to construct logically coherent explanations of phenomena that incorporate their current understanding of science, or a model that represents it, and are consistent with the available evidence. (2) Engaging in argument from evidence: In science, reasoning and argument are essential for identifying the strengths and weaknesses of a line of reasoning and for finding the best explanation for a natural phenomenon. In engineering, reasoning and argument are essential for finding the best possible solution to a problem. Engineers use systematic methods to compare alternatives, formulate evidence based on test data, make arguments from evidence to defend their conclusions, evaluate critically the ideas of others, and revise their designs in order to achieve the best solution to the problem at hand. We propose that Logic should be a one semester course to be offered to advanced high school students (in grades 11 or 12). The course material will cover two broad topics: propositional logic and relational logic. In the module on propositional logic, we will introduce the students to logical connectives (and, or, not), contrapositives, converses, inverses, counterfactuals, deMorgan’s laws, truth tables, and simple propositional proofs. The module on relational logic will cover variables and quantifiers, quantifier order, model checking, and simple relational proofs. We will also introduce the distinction between knowing not versus not knowing (i.e., negation as failure), and computer applications such as spreadsheets and general game playing. We already have available a textbook on logic for high school students that features interactive exercises, a hyperlinked glossary, and online tools such as truth tables, proof editors, and logic-enabled immersive games (see http://logic.stanford.edu/intrologic ). We also provide an annotated slide deck that can be adapted by high school teachers for courses aimed at students or teacher training. Our material is based on experience in teaching Stanford undergraduate students over a period of 20 years, and also in using the same material in a Massively Open Online Course with an enrollment of over 500,000 students. While our course can be taught in a standalone manner in the current form, we are interested in working with a teacher who can develop a version of this course by leveraging Wolfram's platform. We are open to discussion on how this might be done. There are three innovative aspects of our teaching of logic as compared to other prevalent approaches: (a) our research has developed new semantics for logic making it much easier to teach; (b) we have new interactive textbook technology that can help the students in learning; (c) we have developed computational metaphor in which the students can immediately apply the logic concepts to solve practical problems. We are driven by the vision that Logic is an essential skill for succeeding in the 21st century. The time is right to introduce this subject as a stand-alone course in the high school curriculum. In addition to providing necessary mathematical foundation for students who will major in computer science, it will impart students with critical thinking skills that cut across all disciplines. Interested teachers can get in touch with us at genesereth@stanford.edu and vinay_chaudhri@yahoo.com. Vinay Chaudhri 2016-06-01T21:16:43Z https://community.wolfram.com/groups/-/m/t/814543 Dear Wolframers, regarding the problem of Quantified Boolean Formula satisfiability checking, how are the capabilities of the Wolfram Language best harnessed ? On the one hand, we have Resolve that performs quantifier elimination, for example : ![Quantifier elimination using Resolve][1] And and the other hand, we have the SatisfiableQ and TautologyQ builtin functions dealing with (non quantified) boolean formula satisfiability. I surmise then that the correct way of checking the satisfiability of Quantified Boolean Formula is to perform quantifier elimination using Resolve, and to then check the satisfiability of the resulting formula using SatisfiableQ. Could anyone give some advice about the best way to deal with Quantified Boolean Formula in the Wolfram Language ? Thanks for your much appreciated help. [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=%28unnamed%29-WolframDevelopmentPlatform-MozillaFirefox.jpg&userId=790058 Fabien Todescato 2016-03-02T07:52:30Z https://community.wolfram.com/groups/-/m/t/749947 The Reddit math forum [turned up][1] this [nice site][2] of sudokuish Garam puzzles yesterday. Fill in the blanks. ![A Garam puzzle][3] Someone was quick to post [their Mathematica reduction][4]: ![enter image description here][5] They had to enter the whole puzzle manually, a tedious task. The regular format and clean composition make these puzzles a tempting target for automation. Using colour frequency, I pick out the tiles of the puzzle with morphological tools. ![Said puzzles tiles][6] By checking tile adjacency, I compile lists of 'equations' reading down or across. Then the dark pixels in these tiles are extracted to collect the equation data. ![Some equation imagery][7] A classifier turns the images into equations. ![Some equations][8] Reduce solves all the equations for us, and churns out the answers left to right! ![Solutions][9] Notebook attached for all your Garam cheating needs. [1]: https://www.reddit.com/r/math/comments/3v9ik1/an_interesting_japanese_equation_puzzle_it_took/ [2]: https://www.garamgame.com/ [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=PuzzlePaste.png&userId=445606 [4]: http://i.snag.gy/8cmhp.jpg [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=8cmhp.jpg&userId=11733 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=PuzzleTiles.png&userId=445606 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Someequationimagery.PNG&userId=445606 [8]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Someequations.PNG&userId=445606 [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Solutions.PNG&userId=445606 David Gathercole 2015-12-04T09:04:41Z