🤖 machine learning

Slice and Explain: Logic-Based Explanations for Neural Networks through Domain Slicing

This paper proposes a domain slicing approach to enhance the scalability of logic-based explanations for neural networks, demonstrating a reduction in explanation time of up to 40% through comparative experiments.

Original authors: Luiz Fernando Paulino Queiroz, Carlos Henrique Leitão Cavalcante, Thiago Alves Rocha

Published 2026-02-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Luiz Fernando Paulino Queiroz, Carlos Henrique Leitão Cavalcante, Thiago Alves Rocha

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Black Box"

Imagine you have a super-smart robot (a Neural Network) that decides whether to approve your loan. You apply, and the robot says "Approved!" But when you ask, "Why?" the robot just shrugs. It's a Black Box. It knows the answer, but it can't explain how it got there.

In the real world, this is scary. If a robot denies a loan or misdiagnoses a disease, we need to know why so we can trust it.

The Current Solution: The "Logic Detective"

Scientists have developed a method called Logic-Based Explainability. Think of this as a super-strict Logic Detective.

Instead of guessing, the detective translates the robot's brain into a giant math puzzle (using Mixed Integer Linear Programming or MILP).
The detective asks: "If I change your income, does the decision change? If I change your age, does it change?"
The goal is to find the minimum set of facts needed to guarantee the same result.
- Example: The detective might realize, "Actually, we don't care about your age or your job. As long as your loan history is good, the robot will always approve you."
- That short list ("Good Loan History") is the Explanation.

The Catch: This detective is incredibly thorough, but also incredibly slow. If the robot is complex (a deep neural network), the math puzzle becomes so huge that the detective takes hours or days to solve it. It's like trying to find a needle in a haystack by checking every single piece of hay one by one.

The New Idea: "Slice and Explain"

The authors of this paper came up with a clever trick to speed up the detective: Domain Slicing.

Imagine you are trying to find a specific book in a massive library.

The Old Way: You walk down every single aisle, checking every shelf, from the front door to the back wall.
The New Way (Slicing): You realize the library is huge, so you split it into smaller rooms.
1. You lock the "Fiction" room and only look in "Non-Fiction."
2. Inside "Non-Fiction," you split it again: "History" vs. "Science."
3. By narrowing down the area, you don't have to check the whole library. You only check the specific room where the book might be.

In the paper, they do this with data:

They take a feature (like "Income") and split its range in half (e.g., $0–$ 50k and $50k–$ 100k).
They create a smaller, simpler version of the robot's brain for just that specific slice of income.
Because the "slice" is smaller, the math puzzle is much simpler. The constraints (the rules the robot follows) become tighter and easier to solve.
They do this for a few key features, creating a grid of small "slices" to check.

Why Does This Work?

The magic happens because smaller rooms mean fewer rules.

When the detective looks at the whole library, they have to account for every possible scenario. But when they look at just the "Science" room, they can ignore all the rules about "Fiction."

In the math world, this means they can remove binary variables (the "on/off" switches in the logic puzzle).
Fewer switches = a much faster puzzle to solve.

What Did They Find?

The researchers tested this on different types of "robots" (Neural Networks) with different sizes:

Small Robots (Shallow Networks): Slicing didn't help. It was like trying to organize a small closet by splitting it into tiny boxes. The time it took to set up the boxes was longer than just organizing the closet normally.
Big Robots (Deep Networks): This is where the magic happened. For complex robots, slicing cut the explanation time by up to 40%.
- Analogy: If the old detective took 10 hours to solve a complex case, the new "Slicing Detective" could do it in 6 hours.

However, it depends on the case.
Sometimes, the data didn't have clear "cuts" to make. If the features you slice don't actually simplify the rules, you just waste time setting up the slices. It's like trying to slice a block of jelly; sometimes it just falls apart messily. But if you slice a block of cheese (structured data), it works perfectly.

The Bottom Line

This paper proposes a way to make AI explanations faster and more scalable without losing their accuracy.

Old Way: Check the whole universe to find the answer. (Slow, accurate).
New Way: Slice the universe into manageable chunks, solve the puzzle in each chunk, and combine the results. (Fast, accurate).

It's a bit like saying, "We don't need to search the entire ocean for a lost coin; let's just search the specific beach where it was last seen." This makes it possible to explain complex AI decisions in a reasonable amount of time, bringing us one step closer to trusting our AI friends.

1. Problem Statement

Neural Networks (NNs) are widely used but suffer from a lack of interpretability, making them "black boxes." While heuristic Explainable AI (XAI) methods (e.g., LIME, Anchors) exist, they lack formal guarantees of correctness. Logic-based XAI approaches, such as the method proposed by Ignatiev et al. [9], offer abductive explanations with guarantees of correctness and irredundancy. These methods encode the NN and input domain into Mixed Integer Linear Programming (MILP) constraints to find the minimal subset of features sufficient to justify a prediction.

However, a critical bottleneck remains: scalability. As NNs grow larger (more layers/neurons) or datasets become more complex, the computational cost of solving the MILP constraints to generate explanations becomes prohibitive. The existing logic-based approaches struggle to scale efficiently for deep networks.

2. Methodology

The authors propose "Slice and Explain," a novel technique that leverages domain slicing to improve the scalability of logic-based XAI without sacrificing correctness.

Core Concept: Domain Slicing

The method partitions the input domain of specific features into smaller subdomains (slices). By restricting the range of input variables, the authors can simplify the logical constraints representing the NN within those subdomains.

Technical Mechanism:

Partitioning: For a selected feature $x_i$ with domain $[l_i, u_i]$ , the domain is split at the midpoint $m_i = (l_i + u_i)/2$ into two subdomains: $[l_i, m_i]$ and $[m_i, u_i]$ .
Constraint Simplification: Within a specific subdomain, the bounds of intermediate neurons in the NN can be tightened.
- ReLU Simplification: Since the activation function is ReLU ($max(0, z)$), tightening the input bounds often allows the solver to determine that a neuron's output is strictly positive or strictly negative.
- Binary Variable Elimination: If a neuron's output is guaranteed to be positive (or negative) within a slice, the binary variable ( $z$ ) and auxiliary variable ( $s$ ) required to model the ReLU behavior in the MILP formulation can be removed or fixed. This reduces the number of binary variables in the MILP problem.
Logical Equivalence: The paper proves (via Propositions 1 and 2) that verifying entailment over the full domain is equivalent to verifying entailment over the partitioned subdomains. If a feature is found to be non-essential in any subdomain, it is non-essential globally. Conversely, if it is essential in any subdomain, it must be retained.
Algorithm: The explanation generation process (Algorithm 1) is adapted to iterate through these slices. The authors limit the slicing to a maximum of three features to prevent the exponential explosion of subdomains.

3. Key Contributions

Novel Application of Slicing: This is the first application of domain slicing techniques specifically for generating logic-based explanations for NNs.
Scalability Enhancement: The approach significantly reduces the computational complexity of MILP solvers by tightening bounds and eliminating binary variables associated with ReLU activations.
Preservation of Guarantees: Unlike heuristic methods, the proposed approach maintains the correctness (the explanation is mathematically proven to be sufficient) and minimality (no redundant features) guarantees of the original logic-based approach.
Empirical Validation: The authors provide extensive experiments across five datasets and varying network depths to quantify the trade-offs between slicing overhead and computational gains.

4. Experimental Results

The authors evaluated the method on five datasets (Auto, Hepatitis, Australian, Heart-Statlog, Glass) using NNs with 2, 3, and 4 hidden layers.

Small Networks (2 Layers): Slicing generally increased explanation time. The overhead of managing multiple slices and solving multiple sub-problems outweighed the benefits of constraint simplification, as few binary variables were removed.
Medium Networks (3 Layers): Mixed results. Some datasets (e.g., Australian, Heart-Statlog) showed time reductions (up to ~15%) correlated with binary variable removal (up to ~16%). Others (e.g., Hepatitis) saw performance degradation.
Large/Deep Networks (4 Layers): Slicing demonstrated significant efficacy.
- Australian Dataset: Explanation time reduced by 37.20% with 3 slices, correlating with a 23.38% reduction in binary variables.
- Heart-Statlog Dataset: Explanation time reduced by 40.46% with 3 slices.
- Negative Cases: The "Auto" dataset showed increased time with no binary variable removal, indicating that slicing is not universally beneficial and depends on data characteristics.

Key Finding: The effectiveness of slicing is strongly correlated with the percentage of binary variables removed. When slicing leads to significant simplification of the MILP (removing binary variables), the speedup is substantial. When it does not, the overhead dominates.

5. Significance and Conclusion

The paper demonstrates that domain slicing is a viable strategy to scale logic-based XAI for deep neural networks.

Practical Impact: It enables the generation of formally correct explanations for larger, more complex models that were previously computationally intractable using standard logic-based methods.
Strategic Insight: The study highlights that the success of slicing is dataset-dependent rather than solely dependent on network depth. It suggests that future work should focus on adaptive feature selection for slicing—identifying which features, when sliced, yield the maximum constraint simplification (binary variable elimination) for a specific dataset.
Future Directions: The authors propose exploring automated strategies to select the optimal features for slicing based on dataset characteristics and network properties to maximize efficiency gains.

In summary, "Slice and Explain" bridges the gap between the theoretical rigor of logic-based XAI and the practical need for scalability, offering a 40%+ reduction in explanation time for deep networks under specific conditions.