How can i fragment a long boolean query string into multiple small boolean queries - boolean-logic

Question

I have a long boolean expression that needs to be fragmented into multiple small boolean expressions. For example:
Original expression: 1 or (2 and 3) and (not 4 or 5) or (6 and (7 or 8 or (9 and 10)))
expression1: 1
expression2: 2 and 3 and not 4
expression3: 2 and 3 and 5
expression4: 6 and 7
expression5: 6 and 8
expression6: 6 and 9 and 10
if I am evaluating (expression1 or expression2 or expression3 or expression4 or expression5 or expression6), then I am getting my original expression.
Practically I have the expression up to 10000 characters with very complex and nested boolean expressions. Any suggestions or ideas?

Answer 1

It looks like what you are trying to do is convert the query into Disjunctive Normal Form. Not hard to do in principle (parse as AST, then apply equalities as per link) but the problem is that the size of your DNF representation can grow exponentially. So for arbitrary expressions on 10k characters you simply won't be able to do so (you'd run out of time & memory).

Answer 2

If you can use variables then you could refactor parts of the expression into variables and then use those variables in your expression. Here's an example
// initial complex boolean expression
const x = "blah";
if (x === "asdfasd" || (x !== "asdfasd" && x.length < 4)) {
// match
}
// save parts of the complex boolean expression into variables
const isCondition1 = x === "asdfasd";
const isCondition2 = x !== "asdfasd";
const isCondition3 = x.length < 4;
// use those variable
if (isCondition1 || (isCondition2 && isCondition3)) {
// match
}
// use the variables to continue simplifying the expression
const isCondition4 = isCondition2 && isCondition3;
if (isCondition1 || isCondition4) {
// match
}
// until you are left with one expression
const isCondition5 = isCondition1 || isCondition4;
if (isCondition5) {
// match
}
So
if (x === "asdfasd" || (x !== "asdfasd" && x.length < 4)) {
// match
}
Can be rewritten as
const isCondition1 = x === "asdfasd";
const isCondition2 = x !== "asdfasd";
const isCondition3 = x.length < 4;
const isCondition4 = isCondition2 && isCondition3;
const isCondition5 = isCondition1 || isCondition4;
if (isCondition5) {
// match
}
I'd also move those expressions into functions and organize those functions in separate folders/files.
isCondition1.js
module.exports = x => x === "asdfasd";
isCondition2.js
module.exports = x => x !== "asdfasd";
isCondition3.js
module.exports = x => x.length < 4;
isCondition4.js
const isCondition2 = require("isCondition2");
const isCondition3 = require("isCondition3");
module.exports = x => isCondition2(x) && isCondition3(x);
isCondition5.js
const isCondition1 = require("isCondition1");
const isCondition4 = require("isCondition4");
module.exports = x => isCondition1(x) || isCondition4(x);
index.js
const isCondition5 = require("isCondition5");
if (isCondition5(x)) {
// match
}