Actual Causality Benchmark

Summary. PCI versus Halpern–Pearl-style actual-cause probabilities on the generalised throwing problem. Includes exact actual-cause computations (one pair, two pairs, scaling sweep) and approximate estimation via SearchForExplanation. Generates the runtime, search-space, and accuracy plots reported in the paper’s actual-causality benchmarking section.

[1]:

import os
import pickle
import sys
from itertools import chain, combinations
from time import time
from typing import cast

import matplotlib.pyplot as plt
import pandas as pd
import pyro
import pyro.distributions as dist
import seaborn as sns
import torch
from chirho.interventional.handlers import do
from chirho.observational.handlers import condition
from IPython.display import Image, display
from loguru import logger

from pci.explanation.regime import condition_on_interventional_regime
from pci.explanation.scores import abs_diff_score
from pci.explanation.searchable import SearchableModel
from pci.explanation.thin_search import ThinSearchSampler
from pci.tools.find_root import find_repo_root

# Smoke-test mode is triggered by ``CI=1``. It runs the notebook end-to-end on
# a tiny problem budget so the full pipeline (exact + approximate benchmarks
# + plots) executes without kairos and without the cached results from a real
# run. The non-smoke settings reproduce the figures shown in the paper.
smoke_test = "CI" in os.environ

root = find_repo_root()
results_dir = os.path.join(root, "docs/source/ac_benchmark")
os.makedirs(results_dir, exist_ok=True)

print(f"Results will be saved to {results_dir}")

logger.remove()
logger.add(sys.stderr, level="INFO" if smoke_test else "DEBUG")


if smoke_test:
    # Sample sizes are deliberately offset from `num_worlds_at_site` so the
    # `broadcast_mask` heuristic in `condition_on_interventional_regime`
    # picks the sampling axis unambiguously.
    runtime_limit = 0.05  # 3 s per benchmark run
    num_worlds_at_site = 3
    initial_samples_small = 8
    initial_samples_large = 16
else:
    runtime_limit = 60  # minutes
    num_worlds_at_site = 10
    initial_samples_small = 250
    initial_samples_large = 500

runtime_limit_seconds = runtime_limit * 60

# change to True to force a fresh run; smoke tests always run fresh
fresh_run = True if smoke_test else False

# Seeded so every number and figure below reproduces exactly on a fresh run.
# pyro.set_rng_seed seeds torch, python random and numpy together.
SEED = 0
pyro.set_rng_seed(SEED)

Results will be saved to /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark

Overview

This first part of the notebook tells the story in plain language: the example we scale up, the two methods we compare, how we set up the experiment, and what the resulting plots show. The second part, Code, contains the full reproducible implementation. The guiding question throughout is: as the problem grows, can a Monte Carlo PCI estimator keep recovering the actual-cause verdicts that exact enumeration produces, long after exact enumeration becomes too expensive to run?

Motivations

A standard minimally interesting example used in the discussion of actual causality uses categorical variables: Sally and Billy pick up stones and throw them at a bottle. Sally’s stone gets there first, shattering the bottle. Both throws are perfectly accurate, so Billy’s stone would have shattered the bottle had it not been preempted by Sally’s throw. The intuition is that Sally’s throw is responsible for the shattering, but not so Billy’s. However, it is false that had Sally not thrown the stone, the bottle would not have shattered, so the simple counterfactual condition fails, which motivates the search for a better definition of responsibility attribution.

In this case study, we “mutliply” the structure underlying the classical bottle-throwing example with the goal to evaluate the extent to which the exact actual causality computation can handle it, and the extent and performance of the approximate estimation methods that use SearchForExplanation.

Generalized throwing problem

For a problem size \(n\), we define the corresponding deterministic model in which there will be \(n\) “copies” of “Sally throwing” events \(A_i\) and and \(n\) copies of “Bill throwing” events, \(B_i\), \(i = 1, \dots n\). For each pair \(A_i, B_i\) we mimick the overdetermination and undercutting in the same fashion they played out in the original example: \(B_i\) succeeds only if \(B_i\) throws and \(A_i\) doesn’t. The final outcome \(C\) is triggered if at each \(i\) we have a hit, i.e. either \(A_i\) or \(B_i\). This gives a scalable challenge akin to the original one.

In other words, we consider binary variables \(A_1,\dots,A_n, B_1,\dots,B_n \in \{0,1\}\) where \(A_i\) represents Sally’s \(i\)-th throw and \(B_i\) represents Billy’s \(i\)-th throw.

For each pair \((A_i, B_i)\), we introduce endogenous variables \(W^a_i, W^b_i \in \{0,1\}\) indicating whether \(A_i\) (\(B_i\)) hit the target, ie. for each \(i = 1,\dots,n\),

\[W^a_i = A_i \,\,\,\,\, W^b_i = (B_i \land \lnot A_i).\]

The final bottle-shattering outcome \(C\) occurs iff every pair produces a hit:

\[C = \bigwedge_{i=1}^n \left( W^a_i \vee W^b_i\right).\]

The model also allows us to analytically compute responsibility indicators \(R_i\) during a forward pass for evaluation purposes:

\[\begin{split}R_i = \begin{cases} 1, & \text{if } W^a_i = 1,\\[4pt] 2, & \text{if } W^b_i = 1,\\[4pt] 0, & \text{otherwise}. \end{cases}\end{split}\]

Explicit actual cause computations

First, we implement the original explicit actual causality calculation. Given a particular probelm size and a particular input values, the procedure attempts to decide which variables are responsible as follows:

  1. consider all possible subsets of all cause candidates,

  2. consider all possible witness sets (subsets of all witness candidates),

  3. for each subset of the former looking for an existential necessity claim witness among the latter.

We incorporate factivity, by only considering input settings that result in \(C=1\), and minimality requirements, by dropping cause subsets which are not subset-minimal. Features deemed responsible are those and only those that end up in a minimal identified subset.

Approximate estimation using SearchForExplanation

The approximate estimator below is the Monte Carlo specialisation of Definition 9 in the paper, used to produce the AC-benchmark figures. The body of the paper is separable from this particular inference choice; other estimators can be substituted at the user’s discretion.

ALGORITHM 1: Approximate PCI estimator on the scaled throwing problem
─────────────────────────────────────────────────────────────────────────
Inputs:
  PSCM M for size-n throwing problem; factual world (s*, w*, c*)
  cardinality bounds  n_s, n_w
  total sample budget N
  witness flag  wit ∈ {on, off}            // wit=off ⟺ W := ∅
Output:
  per-site verdicts  v_i ∈ {A_i, B_i},  i = 1..n

1.  if wit = off:  W ← ∅                  // no witness candidates at all
2.  for each X ∈ S:  L[X] ← []            // per-suspect score lists
3.  for j = 1, …, N:
4.      draw u_j ~ P_U
5.      sample k_s ~ Unif{1,…,n_s},  k_w ~ Unif{0,…,n_w}
6.      sample C_j ⊆ S   uniformly with |C_j| = k_s
7.      sample D_j ⊆ W   uniformly with |D_j| = k_w        // witnesses dropped
8.      T_j ← W \ D_j                                       // active witnesses
9.      c'_j ← 1 − s*|_{C_j}             // ε-excised reduces to bit-flip on {0,1}
10.     // Same noise u_j shared by both worlds (counterfactual coupling)
11.     y^s_j ← M.run(u_j, do(C_j = s*|_{C_j}, T_j = w*|_{T_j}))   // sufficiency
12.     y^n_j ← M.run(u_j, do(C_j = c'_j,      T_j = w*|_{T_j}))   // necessity
13.     // Sufficiency world computed but not read out: AC has no sufficiency
14.     for each X ∈ C_j:
15.         L[X].append( |y^n_j − c*| )
16. for each X ∈ S:  score[X] ← nanmean(L[X])
17. for each site i = 1..n:  v_i ← argmax( score[A_i], score[B_i] )
18. return (v_1, …, v_n)

The algorithm draws \(N\) intervention configurations under shared noise. The active suspect set \(\mathbf{C}_j\) (line 6) is drawn at uniformly chosen cardinality \(k_s \in \{1,\dots,n_s\}\); the dropped witness set \(D_j\) (line 7) is drawn the same way at \(k_w \in \{0,\dots,n_w\}\), and the active witnesses on line 8 are the complement \(\mathbf{W}\setminus D_j\), so \(n_w\) bounds how many witnesses get dropped, leaving an active witness set of size \(|\mathbf{W}|-n_w\) or larger. The witness ablation flag wit = off is handled once on line 1 by emptying \(\mathbf{W}\); this collapses the witness machinery on lines 7–8 and 11–12 to no-ops, producing the dotted accuracy curves on the plot below.

Alternative values on line 9 are bit flips: on \(\{0,1\}\) the \(\epsilon\)-excised alternative-value distribution has a single support point and \(\epsilon\) plays no role; the explicit sampling form is preserved so that the same routine runs on continuous benchmarks. The two interventional worlds on lines 11–12 share the noise realisation \(\mathbf{u}_j\) drawn on line 4, the standard counterfactual coupling, which lets the per-suspect score on lines 14–16 be read off as the nan-mean of \(|y^n_j - c^\star|\) over the draws in which \(X\in\mathbf{C}_j\). The sufficiency outcome \(y^s_j\) is computed but not consumed: the AC verdict against which we benchmark has no sufficiency clause, so we read only the necessity world. The joint estimator with sufficiency active is exercised in the synthetic benchmark notebook, where AC has no comparable verdict to benchmark against. At each site \(i = 1..n\), line 17 returns whichever of \(A_i\) and \(B_i\) has the higher mean.

One additional knob lives inside the alternative-value sampler, below the algorithm level: the implementation runs with conditioned_alternatives = True, conditioning the alternative-value distribution on the witness interventions. On \(\{0,1\}\) with a bit flip this has no effect; in continuous benchmarks it tightens the alternative distribution to remain compatible with the witness-pinning regime.

Benchmarking setup

For each problem size we sample up to 10 “world” inputs (for low problem size, there are fewer unique ones), ensuring outcome factivity is satisfied. We also instantiate models of that size. At each “world” we use the two algorithms to estimate which features are responsible in those models under those inputs, and evaluate accuracy by comparing to the analytically available answer computed during the forward pass of the models. Once completed, we move to the next problem size. A problem size \(n\) is determined by how many “copies” of variables we’re dealing with at each \(A/B\) site. This translates into the number of variables in the model (\(R\) aside) by taking \(4n+1\) (locations: \(A, B, W^a, W^b\), each with \(n\) sites, plus one outcome variable). We use the approximate methods with a few different settings, which we explain below. For each method we stop the procedure after 60 minutes.

Settings of the approximate method:

  1. First, we choose what initial sample size to use: these are the values sampled from the model, each run coming with a potentially different selection of active antecedents, fixed witnesses, and alternative values for the active antecedents. This sample size is used for problem size 1 with 5 variables.

  2. Then, on purpose trying to deteriorate the approximate method performance, we increase the sample size linearly with the problem size. This means that for any problem size \(n\), we use (\(n \times\) factor \(\times\) initial sample size) samples. Obviously, performance depends on both the initial sample size and this factor, and to illustrate we also use a case with initial sample size 250 and 500 and factors 0.5 and 1.

  3. Another question is whether the presence of witness interventions improves performance, so for the ablation we include two runs that do not use witnesses (\(wit\) setting).

  4. The default setting for the max number of intervened antecedents is 4, and so is the default setting for the max number of witness elements dropped. This speeds up computation and lowers the variance, but effectively works approximating the answer to a slightly different question, i.e. whether there are witness sets of size at least (number of witnesses - 4) which do the job. The algorithm with this setting here won’t perform too badly partially because of the problem structure (we will comment on this later when talking about limitations), but a conceptually more adequate method should put both constraints at \(n+4\), effectively allowing subsets of variables of any size in the search. We include one run that does that for comparison (we call this setting “dynamic set sizes”, hence “dyn” in the legend).

Benchmarking results

We inspect three aspects: runtime per each “input world”, the size of the search space used, and the accuracy rate. Let’s start with runtime.

[2]:

if not smoke_test:
    display(Image(filename="ac_benchmark/plot1_runtime.png"))
_images/actual_causality_benchmark_10_0.png

We see the exact computation times out at a relatively low problem size due to combinatorial explosion. For the approximate runs, speed seems mostly determined by sample size growth patterns.

Next, let’s take a look at search spaced actually used. For the exact computation, these are powerset sizes, for the others these are unique samples. Due to large differences between the exact and the approximate method, the plot is on the log scale.

[3]:

if not smoke_test:
    display(Image(filename="ac_benchmark/plot2_search_space.png"))
_images/actual_causality_benchmark_13_0.png

Finally, let’s look at accuracy rates across different methods and problem sizes. The approximate methods’ performance drops with problem size, the conjecture is that this is mostly because the linear sample size growth patterns used do not match the fast increase of the underlying powersets. Nevertheless, the structure of the problem allows for decent responsibility guesses based on relatively low sample sizes.

[4]:

if not smoke_test:
    display(Image(filename="ac_benchmark/plot3_accuracy.png"))
_images/actual_causality_benchmark_15_0.png

Limitations

The stone-throwing example usually stands in for the difficulty of causal attribution under overdetermination and undercutting, yet even scaled up to over a hundred variables it stays relatively easy, because it admits constraints an estimator can exploit:

  1. For each \(i, j <n\), we know that the responsibility of \(A_i/B_i\) is independent of the responsibility of \(A_j/B_j\).

  2. For each \(i,j<n\), we know, given \(C=1\) and the problem structure, that exactly one of \(A_i, B_i\) is responsible.

  3. Due to point 1 we know that if there is a witness set for the responsibility of \(A_i/B_i\), any superset thereof will also be a witness set for the same attribution. That is the main reason a low max-witness-dropout rate costs us little performance.

  4. All the variables involved are categorical and binary.

So this benchmark is a step towards understanding what the approximate method can do, and how far it goes past exact computation on a problem that is already hard from some perspectives. Formulating more challenging and more realistic benchmarks, and measuring the approximate methods against them, remains the natural next step.

Code

The rest of the notebook is the working implementation behind the figures above. It is organised in the same order as the story: first the scaled throwing model, then the exact actual-causality computation (our ground-truth reference), then the approximate PCI estimator built on SearchForExplanation, and finally the plotting code that produced the three figures. Readers who only want the conclusions can stop at the Overview; the code below is here for reproducibility and for anyone who wants to vary the settings.

The scaled throwing model

We start by encoding the generalised throwing problem as a deterministic structural model. The factory below builds a model with num_at_site copies of the Sally/Billy structure. For each site \(i\) it computes the two mediators \(W^a_i = A_i\) (Sally’s hit) and \(W^b_i = B_i \land \lnot A_i\) (Billy’s hit, which only lands if Sally’s stone did not preempt it), the per-site ground-truth label \(R_i\) (1 if \(A_i\) is responsible, 2 if \(B_i\) is, 0 otherwise), and the conjunctive outcome \(C = \bigwedge_i (W^a_i \lor W^b_i)\). Because \(R_i\) is computed during the forward pass, every world comes with its own closed-form answer key that we can later score against.

[5]:

def internal_model_factory(num_at_site: int = 1):
    def internal_model(**kwargs):
        As = {}
        Bs = {}
        Was = {}
        Rs = {}

        for i in range(num_at_site):
            As[f"A{i}"] = kwargs.get(f"A{i}")
            Bs[f"B{i}"] = kwargs.get(f"B{i}")

            Wa_val = Was[f"Wa{i}"] = pyro.deterministic(f"Wa{i}", As[f"A{i}"])

            Wb_val = Bs[f"B{i}"] * (1 - Wa_val)

            Wb_val = pyro.deterministic(f"Wb{i}", Wb_val)

            Rs[f"R{i}"] = pyro.deterministic(f"R{i}", Wa_val + Wb_val * 2)

        rkeyes = list(Rs.keys())
        C = Rs[rkeyes[0]].clone() > 0
        for rk in rkeyes[1:]:
            C &= Rs[rk] > 0
        C = pyro.deterministic("C", C.int())

        return C

    return internal_model

The next two cells are sanity checks: they run the model for one site and then two sites over hand-built input batches, and assert that the mediators, responsibility labels, and outcome come out exactly as the equations above prescribe. The one-site case reproduces the classic bottle-throwing example; the two-site case confirms the structure composes correctly across sites.

[6]:

# simple run for one site, replicating the classical example

simple_model = internal_model_factory(num_at_site=1)

A0 = torch.tensor([0, 0, 1, 1])
B0 = torch.tensor([0, 1, 0, 1])

with pyro.poutine.trace() as tr:
    out = simple_model(A0=A0, B0=B0)
print(out)

nodes = tr.trace.nodes
print(nodes.keys())

Wa0s = cast(torch.Tensor, nodes["Wa0"]["value"])
assert torch.equal(Wa0s, (A0))
print(f"Wa0s: {Wa0s}")
Wb0s = cast(torch.Tensor, nodes["Wb0"]["value"])
assert torch.equal(Wb0s, ((B0 == 1) & (A0 == 0)).to(A0.dtype))
print(f"Wb0s: {Wb0s}")
R0s = cast(torch.Tensor, nodes["R0"]["value"])
assert torch.equal(R0s, Wa0s + Wb0s * 2)
print(f"R0s: {R0s}")
C = cast(torch.Tensor, nodes["C"]["value"])
expected_C = ((Wa0s == 1) | (Wb0s == 1)).to(Wa0s.dtype)
print(f"C: {C}")
assert torch.equal(C, expected_C)

tensor([0, 1, 1, 1], dtype=torch.int32)
odict_keys(['Wa0', 'Wb0', 'R0', 'C'])
Wa0s: tensor([0, 0, 1, 1])
Wb0s: tensor([0, 1, 0, 0])
R0s: tensor([0, 2, 1, 1])
C: tensor([0, 1, 1, 1], dtype=torch.int32)

[7]:

# run with two sites

tuple_model = internal_model_factory(num_at_site=2)
A0 = torch.tensor([0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1])
A1 = torch.tensor([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1])
B0 = torch.tensor([0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
B1 = torch.tensor([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1])

with pyro.poutine.trace() as tuple_trace:
    out = tuple_model(A0=A0, A1=A1, B0=B0, B1=B1)

print("Model output C:", out)
nodes = tuple_trace.trace.nodes
print(nodes.keys())

Wa0s = cast(torch.Tensor, nodes["Wa0"]["value"])
Wa1s = cast(torch.Tensor, nodes["Wa1"]["value"])
assert torch.equal(Wa1s, (A1))
assert torch.equal(Wa0s, (A0))
print(f"Wa0s: {Wa0s}")
print(f"Wa1s: {Wa1s}")
Wb0s = cast(torch.Tensor, nodes["Wb0"]["value"])
Wb1s = cast(torch.Tensor, nodes["Wb1"]["value"])
assert torch.equal(Wb1s, ((B1 == 1) & (A1 == 0)).to(A1.dtype))
assert torch.equal(Wb0s, ((B0 == 1) & (A0 == 0)).to(A0.dtype))
print(f"Wb0s: {Wb0s}")
print(f"Wb1s: {Wb1s}")
R0s = cast(torch.Tensor, nodes["R0"]["value"])
R1s = cast(torch.Tensor, nodes["R1"]["value"])
assert torch.equal(R1s, Wa1s + Wb1s * 2)
assert torch.equal(R0s, Wa0s + Wb0s * 2)
print(f"R0s: {R0s}")
print(f"R1s: {R1s}")
C = cast(torch.Tensor, nodes["C"]["value"])
print(f"C: {C}")

Model output C: tensor([0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], dtype=torch.int32)
odict_keys(['Wa0', 'Wb0', 'R0', 'Wa1', 'Wb1', 'R1', 'C'])
Wa0s: tensor([0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1])
Wa1s: tensor([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1])
Wb0s: tensor([0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0])
Wb1s: tensor([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0])
R0s: tensor([0, 2, 1, 1, 0, 2, 1, 1, 0, 2, 1, 1, 0, 2, 1, 1])
R1s: tensor([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1])
C: tensor([0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1], dtype=torch.int32)

Exact actual causality computations

We now implement the exact, brute-force reference method, the standard we judge the approximate estimator against. It mechanises the Halpern–Pearl-style definition directly: enumerate every non-empty subset of suspect variables and every subset of witness variables, intervene, and check whether the outcome flips. A suspect subset counts as an actual cause if some witness set makes flipping it change the outcome (necessity) and no proper subset already does (minimality). The helper below enumerates all subsets; the next cell computes, for a given world, which interventions flip the outcome.

[8]:

def all_subsets(lst):
    return list(
        chain.from_iterable(combinations(lst, r) for r in range(1, len(lst) + 1))
    )


def compute_necessity_condition(num_sites, kwargs):
    internal_model = internal_model_factory(num_at_site=num_sites)

    all_cause_candidates = [f"A{i}" for i in range(num_sites)] + [
        f"B{i}" for i in range(num_sites)
    ]
    all_witness_candidates = [f"Wa{i}" for i in range(num_sites)] + [
        f"Wb{i}" for i in range(num_sites)
    ]

    logger.debug(f"Cause candidates: {all_cause_candidates}")
    logger.debug(f"Witness candidates: {all_witness_candidates}")

    # Generate subsets
    cause_subsets = all_subsets(all_cause_candidates)
    witness_subsets = all_subsets(all_witness_candidates)

    logger.debug(f"Total cause subsets: {len(cause_subsets)}")
    logger.debug(f"Total witness subsets: {len(witness_subsets)}")

    necessity_condition = {}

    with pyro.poutine.trace() as old_trace:
        old_outcome = internal_model(**kwargs)

        responsibilities = {
            f"R{i}": old_trace.trace.nodes[f"R{i}"]["value"] for i in range(num_sites)
        }

    for cause_subset in cause_subsets:
        logger.debug(f"now on cause subset: {cause_subset}")

        necessity_across_witnesses = []

        for witness_subset in witness_subsets:
            logger.debug(
                f"Evaluating cause subset: {cause_subset} with witness subset: {witness_subset}"
            )

            current_witness = {
                wkey: old_trace.trace.nodes[wkey]["value"] for wkey in witness_subset
            }

            new_kwargs = {
                key: 1 - kwargs[key] if key in cause_subset else kwargs[key]
                for key in kwargs
            }

            logger.debug(f"new kwargs: {new_kwargs}")

            with do(actions=current_witness):
                with pyro.poutine.trace() as new_trace:
                    new_outcome = internal_model(**new_kwargs)

            traced_witness = {
                wkey: new_trace.trace.nodes[wkey]["value"] for wkey in witness_subset
            }
            assert all(
                torch.equal(current_witness[wkey], traced_witness[wkey])
                for wkey in witness_subset
            ), "Witness values do not match after intervention."

            logger.debug(f"Old outcome: {old_outcome}")
            logger.debug(f"New outcome: {new_outcome}")
            logger.debug(f"current_witness: {current_witness}")

            outcome_differs = old_outcome != new_outcome

            logger.debug(f"Outcome differs: {outcome_differs}")

            necessity_across_witnesses.append(outcome_differs)

        existential_claim = necessity_across_witnesses[0].clone()

        for t in necessity_across_witnesses[1:]:
            existential_claim = torch.max(existential_claim, t)

        logger.debug(f"existential_claim: {existential_claim}")

        necessity_condition[cause_subset] = existential_claim

    return necessity_condition, cause_subsets, responsibilities

[9]:

# simple explicit necessity computation for one site, in one possible world

A0 = torch.tensor([0])
B0 = torch.tensor([1])

kwargs_one_site = {
    "A0": A0,
    "B0": B0,
}

necessity_1, cause_subsets_1, responsibilities_1 = compute_necessity_condition(
    num_sites=1, kwargs=kwargs_one_site
)

2026-06-01 14:05:28.755 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'B0']
2026-06-01 14:05:28.756 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wb0']
2026-06-01 14:05:28.756 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 3
2026-06-01 14:05:28.757 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 3
2026-06-01 14:05:28.758 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:28.758 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.759 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.760 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.760 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.761 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.762 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.762 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.763 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.764 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.764 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.765 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.766 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.766 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.767 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.768 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.768 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.768 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.769 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.770 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:28.770 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:28.770 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.771 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.771 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.772 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.772 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.772 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.772 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.773 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.774 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.774 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.774 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.774 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.775 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.775 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.776 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.776 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.776 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.776 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.777 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.777 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:28.777 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:28.778 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.778 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.778 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.779 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.779 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.779 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:28.779 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.780 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.780 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.781 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.781 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.781 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.781 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.782 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.782 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.783 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.783 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.783 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])

Necessity alone is not enough: a large subset can flip the outcome simply because it contains a genuinely responsible variable. The function below keeps only the subset-minimal flipping subsets, those with no proper subset that also flips, isolating the variables actually doing the causal work. Run on the one-site example, it should identify exactly the responsible throw.

[10]:

def minimal_true_subsets(necessity):
    minimal = []
    for subset, value in necessity.items():
        if not value.item():
            continue  # skip false

        # Check if any proper subset is True
        is_minimal = True
        for r in range(1, len(subset)):
            for sub in combinations(subset, r):
                if sub in necessity and necessity[sub].item():
                    is_minimal = False
                    break
            if not is_minimal:
                break

        if is_minimal:
            minimal.append(subset)

    return minimal


print(
    "Minimal true subsets for necessity condition (1 site):",
    minimal_true_subsets(necessity_1),
)

Minimal true subsets for necessity condition (1 site): [('B0',)]

[11]:

# minimality check and scoring


def compute_blame_and_win_frequency(necessity, responsibilities, num_sites, kwargs):
    win_counter = 0
    minimal_true = minimal_true_subsets(necessity)
    nodes_blamed = [item for sublist in minimal_true for item in sublist]
    nodes_blamed = [
        node for node in nodes_blamed if kwargs[node] == 1
    ]  # focus on factive, actual throws

    for i in range(num_sites):
        responsibility = responsibilities[f"R{i}"]

        logger.debug(f"Responsibility R{i}: {responsibility}")
        logger.debug(f"Minimal true subsets: {minimal_true}")
        logger.debug(f"Nodes blamed: {nodes_blamed}")

        if responsibility == 1:
            if (f"A{i}" in nodes_blamed) and (f"B{i}" not in nodes_blamed):
                win_counter += 1

        elif responsibility == 2:
            if f"B{i}" in nodes_blamed and (f"A{i}" not in nodes_blamed):
                win_counter += 1

        elif responsibility == 0:
            if all(f not in nodes_blamed for f in [f"A{i}", f"B{i}"]):
                win_counter += 1

        win_freq = win_counter / num_sites
        logger.debug(f"Win frequency: {win_freq}")

    return win_freq, responsibilities, nodes_blamed


win_freq_1, responsibilities_1, nodes_blamed_1 = compute_blame_and_win_frequency(
    necessity_1, responsibilities_1, num_sites=1, kwargs=kwargs_one_site
)
print(f"Win frequency): {win_freq_1}")

2026-06-01 14:05:28.796 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([2])
2026-06-01 14:05:28.796 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('B0',)]
2026-06-01 14:05:28.797 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['B0']
2026-06-01 14:05:28.797 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0

Win frequency): 1.0

One pair of sites, all cases where c=1

[12]:

# test run: classical example, three possible cases in which C=1

options = [(1, 0), (0, 1), (1, 1)]  # assume C, skip (0, 0), by factivity


win_freqs = []
for A, B in options:
    A0 = torch.tensor([A])
    B0 = torch.tensor([B])

    kwargs_one_site = {
        "A0": A0,
        "B0": B0,
    }

    logger.debug(f"\nEvaluating option A0={A}, B0={B}")

    necessity_loop_1, cause_subsets_loop_1, responsibilities_loop_1 = (
        compute_necessity_condition(num_sites=1, kwargs=kwargs_one_site)
    )

    win_freq, responsibilities, nodes_blamed = compute_blame_and_win_frequency(
        necessity_loop_1, responsibilities_loop_1, num_sites=1, kwargs=kwargs_one_site
    )

    win_freqs.append(win_freq)

print(f"Win frequencies: {win_freqs}")

2026-06-01 14:05:28.803 | DEBUG    | __main__:<module>:16 - 
Evaluating option A0=1, B0=0
2026-06-01 14:05:28.803 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'B0']
2026-06-01 14:05:28.803 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wb0']
2026-06-01 14:05:28.803 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 3
2026-06-01 14:05:28.804 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 3
2026-06-01 14:05:28.804 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:28.805 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.805 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.806 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.806 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.806 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.807 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.807 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.807 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.808 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.808 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.808 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.809 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.809 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.809 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.810 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.810 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.810 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.811 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.811 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.811 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:28.812 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.812 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.812 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.813 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.813 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.813 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.813 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.814 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.814 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.815 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.815 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.815 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.815 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.816 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.816 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.817 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.817 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.818 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.818 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:28.818 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:28.818 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:28.819 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.819 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.820 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.820 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.820 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.821 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:28.822 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.822 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.822 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.823 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.823 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.823 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.824 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.824 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.825 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.825 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.825 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.826 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.826 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([1])
2026-06-01 14:05:28.826 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A0',)]
2026-06-01 14:05:28.827 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A0']
2026-06-01 14:05:28.827 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0
2026-06-01 14:05:28.827 | DEBUG    | __main__:<module>:16 - 
Evaluating option A0=0, B0=1
2026-06-01 14:05:28.827 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'B0']
2026-06-01 14:05:28.828 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wb0']
2026-06-01 14:05:28.828 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 3
2026-06-01 14:05:28.828 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 3
2026-06-01 14:05:28.830 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:28.830 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.831 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.831 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.832 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.832 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.833 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.833 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.833 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.834 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.834 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.834 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.835 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.835 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.835 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1])}
2026-06-01 14:05:28.836 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.836 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.836 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.837 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.837 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:28.838 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:28.838 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.838 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.839 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.839 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.840 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.840 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.840 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.841 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.841 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.842 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.842 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.843 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.843 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.843 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.844 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.844 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.845 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.845 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.845 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.846 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:28.846 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:28.846 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.847 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.847 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.848 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.848 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.848 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:28.849 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.849 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.850 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.850 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.851 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.851 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.852 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.853 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.854 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.854 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.855 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.855 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.856 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([2])
2026-06-01 14:05:28.856 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('B0',)]
2026-06-01 14:05:28.856 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['B0']
2026-06-01 14:05:28.856 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0
2026-06-01 14:05:28.857 | DEBUG    | __main__:<module>:16 - 
Evaluating option A0=1, B0=1
2026-06-01 14:05:28.857 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'B0']
2026-06-01 14:05:28.857 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wb0']
2026-06-01 14:05:28.857 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 3
2026-06-01 14:05:28.858 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 3
2026-06-01 14:05:28.858 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:28.859 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.859 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.860 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.860 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.861 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.861 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.861 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.862 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.863 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.863 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.863 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.864 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.864 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.864 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1])}
2026-06-01 14:05:28.865 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.866 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.867 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.867 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.868 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.868 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:28.868 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.868 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.869 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.869 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.869 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.870 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.870 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.870 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.871 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.871 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.872 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.872 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.872 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.872 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0])}
2026-06-01 14:05:28.873 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.873 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.873 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.874 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.874 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:28.874 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:28.874 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:28.875 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.875 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.875 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.876 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:28.876 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.876 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:28.877 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.877 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.878 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.878 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:28.878 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.879 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.879 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0])}
2026-06-01 14:05:28.880 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.881 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.881 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:28.882 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.882 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.883 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([1])
2026-06-01 14:05:28.883 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A0',)]
2026-06-01 14:05:28.883 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A0']
2026-06-01 14:05:28.883 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0

Win frequencies: [1.0, 1.0, 1.0]

Two pairs of sites where c=1

[13]:

# another test run, with i = 1, i.e., two pairs of sites

options_two_site = [
    (0, 1, 1, 1),
    (1, 0, 0, 1),
]  # scheme:  A0, B0, A1, B1 in the first world we blame A0,B1, in the second world we blame B0, A1

win_freqs = []
for a0, b0, a1, b1 in options_two_site:
    A0 = torch.tensor([a0])
    B0 = torch.tensor([b0])
    A1 = torch.tensor([a1])
    B1 = torch.tensor([b1])

    kwargs = {
        "A0": A0,
        "B0": B0,
        "A1": A1,
        "B1": B1,
    }

    logger.debug(f"\nEvaluating option A0={A0}, B0={B0}, A1={A1}, B1={B1}")

    necessity_loop, cause_subsets_loop, responsibilities_loop = (
        compute_necessity_condition(num_sites=2, kwargs=kwargs)
    )

    win_freq, responsibilities, nodes_blamed = compute_blame_and_win_frequency(
        necessity_loop, responsibilities_loop, num_sites=2, kwargs=kwargs
    )

    win_freqs.append(win_freq)

print(f"Win frequencies: {win_freqs}")

2026-06-01 14:05:28.890 | DEBUG    | __main__:<module>:22 - 
Evaluating option A0=tensor([0]), B0=tensor([1]), A1=tensor([1]), B1=tensor([1])
2026-06-01 14:05:28.890 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'A1', 'B0', 'B1']
2026-06-01 14:05:28.890 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wa1', 'Wb0', 'Wb1']
2026-06-01 14:05:28.891 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 15
2026-06-01 14:05:28.891 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 15
2026-06-01 14:05:28.892 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:28.892 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.893 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.894 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.894 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.894 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.894 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.895 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1',)
2026-06-01 14:05:28.895 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.896 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.896 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.896 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:28.897 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.897 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.898 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.898 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.899 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.899 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.899 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.900 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb1',)
2026-06-01 14:05:28.900 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.901 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.901 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.901 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:28.902 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.902 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:28.903 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.904 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.905 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.905 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:28.906 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.906 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.906 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.907 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.908 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.908 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.909 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.909 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:28.910 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.910 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.911 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.912 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.912 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.912 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:28.913 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.914 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.914 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.915 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.915 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.915 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:28.916 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.917 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.918 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.918 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.918 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.918 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:28.919 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.919 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.919 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.920 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.920 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.920 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:28.921 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.921 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.921 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.922 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.922 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.922 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:28.923 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.923 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.923 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.924 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.924 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.924 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:28.924 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.925 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.926 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.926 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.927 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.927 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:28.928 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.929 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.929 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.929 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.930 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.930 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:28.930 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.931 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.931 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.932 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.932 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.933 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:28.933 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1',)
2026-06-01 14:05:28.933 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.933 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.934 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.934 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.935 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.935 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.935 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1',)
2026-06-01 14:05:28.936 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.936 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.936 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.937 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:28.937 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.937 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.938 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.938 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.939 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.939 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.939 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.939 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb1',)
2026-06-01 14:05:28.940 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.941 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.941 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.941 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:28.941 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.942 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:28.942 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.943 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.943 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.944 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:28.944 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.944 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.945 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.945 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.945 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.946 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.946 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.946 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:28.947 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.948 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.948 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.948 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.949 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.949 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:28.950 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.950 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.951 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.951 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.951 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.952 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:28.952 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.953 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.953 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.954 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.954 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.954 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:28.955 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.956 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.956 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.956 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.957 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.957 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:28.958 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.958 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.959 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.959 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.960 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.960 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:28.961 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.961 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.962 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.963 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.963 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.964 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:28.964 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.965 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.966 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.966 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.967 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.967 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:28.968 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.969 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.969 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.969 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.970 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.970 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:28.970 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:28.971 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.971 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.972 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.972 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.972 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:28.972 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:28.973 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:28.973 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.973 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.974 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.974 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:28.974 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.974 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1',)
2026-06-01 14:05:28.975 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.975 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.975 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.976 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:28.976 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.976 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:28.976 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.977 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.977 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.977 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:28.978 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.978 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb1',)
2026-06-01 14:05:28.978 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.979 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.979 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.980 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:28.980 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.980 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:28.981 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.981 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.981 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.982 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:28.982 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.982 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:28.983 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.984 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.984 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.985 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.985 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.985 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:28.986 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.986 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.987 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.987 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.988 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.988 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:28.988 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.989 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.990 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.990 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.990 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.991 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:28.991 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.992 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.992 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:28.992 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.993 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:28.993 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:28.994 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.994 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.995 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.995 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:28.995 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.996 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:28.996 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.997 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.997 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:28.998 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:28.998 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:28.998 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:28.999 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:28.999 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.000 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.000 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.000 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.001 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.001 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.002 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.002 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.003 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.003 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.003 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.004 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.004 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.005 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.005 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.006 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.006 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.006 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.007 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.007 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.008 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.008 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.009 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.009 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B1',)
2026-06-01 14:05:29.009 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0',)
2026-06-01 14:05:29.010 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.011 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.012 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.013 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.013 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.013 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1',)
2026-06-01 14:05:29.014 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.015 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.015 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.016 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.016 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.017 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb0',)
2026-06-01 14:05:29.017 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.018 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.019 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.019 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.019 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.020 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb1',)
2026-06-01 14:05:29.020 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.021 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.022 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.022 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.022 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.023 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.023 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.024 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.024 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.025 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.026 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.026 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.026 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.027 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.028 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.028 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.028 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.029 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.029 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.030 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.030 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.031 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.031 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.032 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.032 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.033 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.033 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.034 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.034 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.034 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.035 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.036 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.036 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.036 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.037 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.037 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.038 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.038 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.039 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.039 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.039 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.040 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.040 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.041 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.041 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.042 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.042 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.042 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.043 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.044 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.044 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.045 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.046 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.046 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.046 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.047 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.048 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.048 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.049 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.049 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.049 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.050 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.051 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.051 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.052 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.052 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.053 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.053 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.054 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.054 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.055 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.055 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:29.055 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1')
2026-06-01 14:05:29.056 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.056 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.057 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.057 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.057 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.058 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.058 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.059 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.059 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.060 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.060 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.061 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.061 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.061 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.062 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.062 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.063 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.063 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.063 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.064 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.064 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.065 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.065 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.066 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.066 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.066 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.067 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.067 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.068 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.068 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.069 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.069 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.070 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.070 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.070 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.071 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.071 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.071 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.072 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.072 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.072 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.073 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.073 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.073 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.074 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.074 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.074 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.075 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.075 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.075 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.076 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.077 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.077 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.077 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.078 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.078 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.079 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.079 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.080 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.080 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.080 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.081 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.082 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.082 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.082 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.083 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.083 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.083 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.084 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.084 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.085 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.085 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.085 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.086 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.087 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.087 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.088 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.088 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.088 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.089 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.089 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.090 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.090 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.090 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.090 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.091 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.091 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.092 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.092 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.092 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.093 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.093 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:29.093 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.093 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.094 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.094 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.094 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.095 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.095 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.095 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.096 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.096 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.096 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.097 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.097 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.097 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.098 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.098 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.098 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.099 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.099 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.099 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.100 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.100 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.100 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.101 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.101 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.101 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.102 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.102 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.102 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.102 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.103 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.103 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.103 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.104 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.104 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.104 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.104 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.105 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.106 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.106 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.106 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.106 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.107 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.107 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.107 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.108 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.108 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.108 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.108 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.109 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.109 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.109 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.110 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.110 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.110 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.111 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.111 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.111 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.112 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.112 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.112 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.112 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.113 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.113 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.114 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.114 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.114 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.115 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.115 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.116 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.116 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.116 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.117 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.117 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.118 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.118 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.119 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.119 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.120 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.120 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.121 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.121 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.121 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.122 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.122 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.122 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.123 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.123 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.123 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.124 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.124 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.124 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B1')
2026-06-01 14:05:29.124 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.125 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.125 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.125 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.126 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.126 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.126 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.127 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.127 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.127 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.127 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.128 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.128 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.128 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.129 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.129 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.129 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.129 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.130 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.130 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.131 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.131 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.131 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.131 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.132 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.132 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.133 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.133 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.133 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.133 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.134 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.134 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.135 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.135 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.135 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.135 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.136 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.136 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.137 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.137 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.137 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.137 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.138 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.138 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.138 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.139 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.139 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.139 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.139 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.140 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.140 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.141 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.141 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.141 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.141 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.142 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.142 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.142 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.143 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.143 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.143 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.143 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.144 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.144 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.145 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.145 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.145 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.145 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.146 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.146 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.146 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.147 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.147 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.147 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.148 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.148 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.148 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.148 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.149 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.149 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.149 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.150 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.150 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.151 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.151 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.151 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.152 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.152 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.153 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.153 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.153 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:29.154 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B0')
2026-06-01 14:05:29.154 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.154 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.155 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.155 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.156 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.156 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.156 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.157 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.157 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.158 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.158 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.158 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.158 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.159 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.160 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.160 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.160 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.161 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.161 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.162 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.163 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.163 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.164 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.164 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.164 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.165 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.166 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.167 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.167 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.168 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.168 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.169 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.169 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.170 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.170 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.171 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.171 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.171 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.172 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.172 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.173 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.173 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.173 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.174 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.175 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.175 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.176 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.176 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.176 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.177 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.178 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.178 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.178 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.179 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.179 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.180 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.180 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.181 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.181 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.182 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.182 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.182 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.183 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.183 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.184 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.184 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.185 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.185 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.186 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.186 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.186 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.187 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.187 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.188 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.188 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.188 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.189 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.189 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.190 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.190 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.191 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.191 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.192 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.192 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.192 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.193 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.193 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.194 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.194 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.195 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.195 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.196 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B1')
2026-06-01 14:05:29.196 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.197 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.197 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.198 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.198 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.198 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.199 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.199 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.200 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.200 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.201 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.201 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.201 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.202 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.203 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.203 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.204 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.204 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.204 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.205 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.207 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.207 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.208 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.208 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.208 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.209 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.209 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.210 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.210 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.211 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.211 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.212 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.212 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.213 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.213 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.213 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.214 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.214 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.215 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.215 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.216 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.216 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.216 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.217 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.217 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.218 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.218 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.219 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.219 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.219 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.220 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.220 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.220 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.221 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.221 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.221 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.222 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.222 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.222 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.222 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.223 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.223 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.224 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.224 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.224 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.224 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.225 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.225 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.225 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.226 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.226 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.226 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.226 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.227 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.227 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.228 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.228 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.228 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.228 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.229 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.229 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.229 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.230 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.230 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.230 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.231 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.232 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.232 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.233 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.233 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.234 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.234 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0', 'B1')
2026-06-01 14:05:29.234 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.235 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.235 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.236 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.236 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.237 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.237 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.237 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.238 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.238 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.239 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.239 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.239 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.240 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.241 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.241 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.241 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.242 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.242 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.243 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.243 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.244 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.244 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.244 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.245 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.245 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.246 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.246 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.247 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.247 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.247 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.248 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.248 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.249 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.249 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.250 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.250 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.250 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.251 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.251 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.252 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.252 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.252 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.253 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.254 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.254 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.254 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.255 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.255 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.255 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.256 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.256 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.257 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.257 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.257 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.258 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.259 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.259 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.259 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.260 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.260 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.261 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.261 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.262 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.262 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.262 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.263 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.263 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.264 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.264 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.265 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.265 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.266 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.266 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.267 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.267 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.268 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.269 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.269 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.270 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.271 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.271 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.272 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.272 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.273 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.274 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.274 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.275 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.276 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.276 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.277 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.277 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B0')
2026-06-01 14:05:29.277 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.278 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.279 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.279 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.280 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.280 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.280 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.281 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.282 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.282 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.282 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.283 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.283 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.283 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.284 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.284 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.284 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.285 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.285 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.285 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.286 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.286 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.287 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.287 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.287 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.288 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.288 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.289 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.289 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.290 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.290 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.291 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.291 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.291 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.292 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.292 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.292 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.293 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.293 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.294 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.294 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.294 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.295 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.295 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.296 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.296 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.296 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.297 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.297 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.297 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.298 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.298 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.299 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.299 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.299 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.300 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.300 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.301 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.301 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.301 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.302 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.302 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.303 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.304 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.304 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.304 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.305 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.305 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.306 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.306 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.307 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.307 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.307 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.308 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.309 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.309 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.309 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.310 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.310 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.311 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.311 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.312 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.312 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.312 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.313 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.313 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.314 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.314 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.315 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.315 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.316 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.316 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B1')
2026-06-01 14:05:29.316 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.317 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.317 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.318 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.318 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.318 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.319 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.319 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.320 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.320 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.321 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.321 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.321 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.322 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.323 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.324 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.324 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.324 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.325 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.325 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.326 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.326 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.327 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.327 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.327 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.328 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.329 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.329 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.329 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.330 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.330 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.331 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.331 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.332 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.332 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.333 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.333 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.334 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.335 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.335 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.335 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.336 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.336 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.337 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.337 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.338 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.338 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.338 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.339 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.339 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.340 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.340 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.341 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.341 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.341 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.342 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.342 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.343 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.343 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.344 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.344 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.344 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.345 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.345 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.346 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.346 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.346 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.347 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.348 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.348 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.349 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.349 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.349 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.350 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.350 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.351 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.352 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.352 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.352 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.353 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.354 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.354 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.354 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.355 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.355 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.355 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.356 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.356 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.356 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.357 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.357 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.357 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0', 'B1')
2026-06-01 14:05:29.357 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.358 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.358 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.359 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.359 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.359 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.359 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.360 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.360 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.361 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.361 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.361 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.362 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.362 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.363 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.363 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.363 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.364 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.364 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.364 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.365 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.365 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.366 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.366 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.366 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.367 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.368 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.368 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.369 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.369 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.369 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.370 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.371 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.371 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.372 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.372 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.372 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.373 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.373 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.374 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.374 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.375 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.375 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.375 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.376 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.376 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.377 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.377 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.377 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.378 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.379 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.379 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.379 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.380 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.380 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.380 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.381 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.382 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.382 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.382 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.383 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.383 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.384 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.384 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.385 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.385 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.385 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.386 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.387 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.387 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.388 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.388 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.388 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.389 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.390 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.390 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.390 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.391 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.391 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.391 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.392 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.393 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.394 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.394 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.394 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.394 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.395 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.395 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.396 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.396 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.396 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.396 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B0', 'B1')
2026-06-01 14:05:29.397 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.397 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.398 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.399 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.399 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.399 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.399 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.400 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.401 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.401 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.402 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.402 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.403 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.403 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.404 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.404 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.404 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.405 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.405 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.405 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.406 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.406 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.406 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.407 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.407 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.407 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.408 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.408 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.408 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.409 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.409 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.409 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.410 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.410 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.410 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.411 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.411 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.411 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.412 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.412 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.412 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.412 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.413 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.413 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.413 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.414 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.414 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.414 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.414 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.415 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.415 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.416 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.416 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.416 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.416 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.417 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.417 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.418 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.418 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.418 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.418 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.419 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.419 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.420 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.420 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.420 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.420 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.421 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.422 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.422 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.422 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.422 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.423 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.423 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.424 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.424 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.424 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.425 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.425 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.425 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.426 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.426 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.427 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.427 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.427 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.427 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.428 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.428 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.428 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.429 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.429 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.429 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B0', 'B1')
2026-06-01 14:05:29.429 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.430 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.430 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.430 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.431 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0])}
2026-06-01 14:05:29.431 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.431 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.432 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.432 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.433 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.434 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1])}
2026-06-01 14:05:29.434 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.435 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.435 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.436 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.437 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.437 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1])}
2026-06-01 14:05:29.438 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.438 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.438 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.439 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.439 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.440 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([0])}
2026-06-01 14:05:29.440 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.440 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.441 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.442 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.442 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.442 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1])}
2026-06-01 14:05:29.443 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.443 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.443 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.444 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.444 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.445 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.445 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.445 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.446 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.447 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.447 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.448 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.448 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.448 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.449 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.449 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.450 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.450 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.450 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.451 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.451 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.452 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.452 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.453 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.453 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.453 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.454 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.454 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.455 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.456 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.456 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.456 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.457 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.458 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.458 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.458 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1])}
2026-06-01 14:05:29.459 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.459 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.460 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.460 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.461 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.461 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.461 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.462 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.462 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.463 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.463 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.464 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.464 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.464 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.465 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.465 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.466 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.466 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.467 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.467 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.468 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.468 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.469 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.469 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([0]), 'Wa1': tensor([1]), 'Wb0': tensor([1]), 'Wb1': tensor([0])}
2026-06-01 14:05:29.470 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.470 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.471 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([2])
2026-06-01 14:05:29.471 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A1',), ('B0',)]
2026-06-01 14:05:29.471 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A1', 'B0']
2026-06-01 14:05:29.472 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 0.5
2026-06-01 14:05:29.472 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R1: tensor([1])
2026-06-01 14:05:29.472 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A1',), ('B0',)]
2026-06-01 14:05:29.472 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A1', 'B0']
2026-06-01 14:05:29.473 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0
2026-06-01 14:05:29.473 | DEBUG    | __main__:<module>:22 - 
Evaluating option A0=tensor([1]), B0=tensor([0]), A1=tensor([0]), B1=tensor([1])
2026-06-01 14:05:29.474 | DEBUG    | __main__:compute_necessity_condition:17 - Cause candidates: ['A0', 'A1', 'B0', 'B1']
2026-06-01 14:05:29.474 | DEBUG    | __main__:compute_necessity_condition:18 - Witness candidates: ['Wa0', 'Wa1', 'Wb0', 'Wb1']
2026-06-01 14:05:29.474 | DEBUG    | __main__:compute_necessity_condition:24 - Total cause subsets: 15
2026-06-01 14:05:29.474 | DEBUG    | __main__:compute_necessity_condition:25 - Total witness subsets: 15
2026-06-01 14:05:29.475 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0',)
2026-06-01 14:05:29.475 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0',)
2026-06-01 14:05:29.476 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.476 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.477 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.477 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.478 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.478 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1',)
2026-06-01 14:05:29.478 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.479 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.479 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.480 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.480 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.481 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0',)
2026-06-01 14:05:29.481 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.482 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.482 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.482 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.483 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.483 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb1',)
2026-06-01 14:05:29.484 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.484 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.485 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.485 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.485 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.485 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.486 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.486 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.487 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.487 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.487 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.487 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.488 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.489 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.489 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.489 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.490 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.490 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.490 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.491 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.491 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.491 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.492 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.492 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.492 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.493 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.493 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.494 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.494 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.494 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.494 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.495 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.495 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.496 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.496 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.496 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.496 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.497 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.497 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.498 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.498 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.498 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.498 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.499 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.499 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.500 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.500 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.500 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.500 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.501 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.501 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.502 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.502 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.503 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.503 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.504 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.504 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.505 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.505 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.506 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.506 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.507 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.507 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.508 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.508 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.509 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.509 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.510 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.510 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.511 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.511 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.511 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.512 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1',)
2026-06-01 14:05:29.512 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0',)
2026-06-01 14:05:29.512 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.513 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.513 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.514 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.514 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.514 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1',)
2026-06-01 14:05:29.515 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.515 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.516 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.516 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.517 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.517 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb0',)
2026-06-01 14:05:29.517 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.518 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.518 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.519 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.519 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.519 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb1',)
2026-06-01 14:05:29.520 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.520 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.521 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.521 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.522 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.522 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.523 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.523 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.524 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.524 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.524 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.524 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.525 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.525 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.525 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.526 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.526 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.526 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.527 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.527 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.527 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.528 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.528 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.528 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.528 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.529 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.529 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.529 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.530 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.530 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.530 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.531 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.531 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.531 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.532 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.532 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.532 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.533 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.533 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.533 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.534 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.534 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.534 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.535 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.535 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.535 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.536 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.536 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.536 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.537 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.537 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.537 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.538 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.538 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.539 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.539 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.540 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.540 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.541 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.541 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.541 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.542 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.542 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.543 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.543 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.543 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.544 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.545 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.545 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.545 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.546 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.546 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:29.546 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0',)
2026-06-01 14:05:29.547 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0',)
2026-06-01 14:05:29.547 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.548 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.548 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.549 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.549 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.549 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1',)
2026-06-01 14:05:29.550 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.550 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.551 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.551 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.551 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.552 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0',)
2026-06-01 14:05:29.552 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.553 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.553 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.554 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.554 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.554 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb1',)
2026-06-01 14:05:29.555 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.555 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.556 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.556 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.556 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.556 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.557 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.557 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.558 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.558 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.558 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.558 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.559 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.559 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.560 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.560 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.560 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.560 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.561 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.561 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.561 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.562 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.562 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.562 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.562 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.563 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.563 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.563 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.564 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.564 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.564 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.565 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.565 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.566 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.566 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.566 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.567 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.567 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.567 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.568 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.568 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.568 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.568 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.569 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.569 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.570 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.570 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.570 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.570 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.571 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.571 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.572 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.572 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.573 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.573 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.574 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.575 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.575 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.575 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.576 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.576 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.577 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.577 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.578 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.578 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.578 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.579 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.579 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.580 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.580 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.580 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.581 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:29.581 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B1',)
2026-06-01 14:05:29.581 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0',)
2026-06-01 14:05:29.582 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.582 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.583 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.583 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.584 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.584 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1',)
2026-06-01 14:05:29.584 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.585 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.585 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.586 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.586 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.586 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb0',)
2026-06-01 14:05:29.587 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.588 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.588 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.588 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.589 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.589 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb1',)
2026-06-01 14:05:29.589 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.590 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.591 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.591 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.592 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.592 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.592 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.593 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.593 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.594 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.595 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.596 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.597 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.598 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.598 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.599 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.599 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.599 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.600 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.601 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.601 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.602 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.604 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.604 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.604 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.605 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.606 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.606 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.606 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.606 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.607 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.607 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.608 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.608 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.608 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.609 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.609 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.610 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.610 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.611 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.611 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.611 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.612 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.612 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.613 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.613 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.614 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.614 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.615 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.615 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.616 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.616 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.616 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.616 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.617 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.617 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.618 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.618 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.618 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.619 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.619 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.620 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.620 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.621 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.621 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.622 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B1',) with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.622 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.623 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.623 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.624 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.624 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.624 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.625 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1')
2026-06-01 14:05:29.625 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.625 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.626 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.626 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.627 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.627 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.627 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.628 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.629 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.629 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.629 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.630 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.630 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.630 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.631 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.632 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.632 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.632 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.632 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.633 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.634 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.634 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.634 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.635 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.635 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.636 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.636 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.637 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.637 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.637 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.638 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.638 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.639 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.639 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.640 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.640 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.640 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.641 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.642 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.642 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.642 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.643 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.643 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.643 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.644 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.645 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.645 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.645 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.646 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.646 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.647 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.647 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.647 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.648 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.648 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.649 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.649 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.650 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.650 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.650 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.651 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.651 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.652 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.652 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.653 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.653 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.653 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.654 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.654 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.655 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.655 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.656 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.656 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.656 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.657 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.657 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.658 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.658 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.658 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.658 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.659 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.659 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.659 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.660 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.660 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.660 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.661 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.661 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.661 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.662 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.662 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.662 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0')
2026-06-01 14:05:29.662 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.663 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.663 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.663 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.664 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.664 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.664 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.665 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.665 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.666 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.666 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.666 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.666 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.667 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.667 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.667 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.668 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.669 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.669 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.669 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.670 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.671 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.671 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.671 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.671 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.672 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.673 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.673 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.673 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.674 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.674 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.675 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.675 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.676 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.676 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.676 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.677 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.677 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.678 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.678 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.679 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.679 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.679 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.680 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.680 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.681 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.681 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.682 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.682 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.682 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.683 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.683 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.684 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.684 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.684 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.685 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.686 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.686 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.686 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.687 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.687 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.688 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.688 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.689 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.689 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.689 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.690 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.690 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.691 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.691 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.693 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.693 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.693 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.694 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.695 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.695 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.695 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.696 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.696 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.697 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.697 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.698 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.698 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.699 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.699 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.700 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([1])}
2026-06-01 14:05:29.700 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.700 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.701 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.701 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.702 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.702 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B1')
2026-06-01 14:05:29.702 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.703 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.703 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.703 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.704 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.704 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.704 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.705 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.705 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.706 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.706 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.706 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.707 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.707 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.708 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.708 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.708 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.709 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.709 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.709 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.710 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.710 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.711 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.711 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.711 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.712 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.712 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.712 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.713 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.713 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.713 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.714 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.715 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.715 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.716 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.716 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.716 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.717 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.717 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.718 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.718 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.718 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.719 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.719 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.720 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.720 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.720 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.721 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.721 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.722 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.722 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.723 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.723 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.723 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.723 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.724 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.724 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.725 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.725 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.725 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.725 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.726 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.726 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.726 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.727 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.727 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.727 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.728 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.728 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.728 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.729 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.729 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.729 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.730 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.730 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.730 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.731 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.731 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.731 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.732 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.732 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.732 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.733 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.733 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.733 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.733 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.734 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.734 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.735 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.735 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.735 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.735 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B0')
2026-06-01 14:05:29.736 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.736 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.737 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.737 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.737 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.738 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.738 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.739 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.740 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.740 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.741 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.741 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.741 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.742 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.742 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.743 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.743 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.744 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.744 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.745 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.745 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.746 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.747 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.747 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.747 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.748 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.749 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.750 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.750 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.750 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.751 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.751 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.752 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.752 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.752 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.753 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.753 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.753 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.754 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.754 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.754 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.755 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.755 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.755 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.756 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.756 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.756 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.757 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.757 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.759 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.760 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.760 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.761 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.761 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.761 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.762 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.762 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.763 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.763 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.764 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.764 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.764 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.765 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.766 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.766 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.766 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.767 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.767 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.768 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.768 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.769 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.769 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.769 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.770 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.771 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.771 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.771 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.772 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.772 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.772 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.773 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.774 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.774 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.775 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.775 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.775 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.776 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.776 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.777 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.777 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.777 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([False])
2026-06-01 14:05:29.778 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B1')
2026-06-01 14:05:29.778 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.778 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.779 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.780 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.780 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.780 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.780 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.781 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.781 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.782 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.782 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.782 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.782 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.783 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.783 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.784 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.784 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.784 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.784 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.785 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.785 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.786 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.786 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.786 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.786 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.787 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.788 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.788 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.788 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.789 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.789 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.789 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.790 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.790 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.790 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.791 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.791 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.791 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.792 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.792 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.792 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.793 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.793 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.793 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.794 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.794 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.794 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.794 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.795 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.795 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.796 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.796 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.796 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.797 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.797 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.797 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.798 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.798 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.798 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.799 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.799 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.799 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.800 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.800 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.800 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.801 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.801 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.801 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.802 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.802 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.803 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.803 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.803 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.804 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.804 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.804 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.805 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.805 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.805 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.805 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.806 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.806 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.807 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.807 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.807 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.807 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.808 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.808 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.809 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.809 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.809 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.810 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('B0', 'B1')
2026-06-01 14:05:29.810 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.810 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.811 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.811 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.811 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.812 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.812 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.812 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.813 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.813 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.813 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.814 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.814 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.814 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.815 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.815 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.815 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.815 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.816 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.816 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.816 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.817 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.817 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.817 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.818 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.818 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.818 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.819 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.819 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.819 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.819 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.820 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.820 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.821 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.821 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.821 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.821 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.822 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.822 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.822 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.823 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.823 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.823 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.824 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.824 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.824 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.825 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.825 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.825 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.826 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.826 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.826 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.827 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.827 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.827 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.827 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.828 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.828 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.829 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.829 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.829 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.830 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.830 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.830 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.831 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.831 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.831 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.832 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.832 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.832 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.833 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.833 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.833 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.834 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.834 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.834 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.835 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.835 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.835 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.836 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.836 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.836 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.837 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.837 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.837 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.837 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.840 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.841 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.841 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.842 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.843 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.843 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B0')
2026-06-01 14:05:29.843 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0',)
2026-06-01 14:05:29.844 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.844 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.845 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.845 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.845 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.845 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1',)
2026-06-01 14:05:29.846 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.847 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.847 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.847 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.848 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.848 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb0',)
2026-06-01 14:05:29.849 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.850 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.850 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.851 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.851 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.851 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb1',)
2026-06-01 14:05:29.852 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.853 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.853 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.854 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.854 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.854 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.855 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.856 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.856 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.857 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.857 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.858 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.858 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.859 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.860 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.860 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.860 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.861 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.861 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.862 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.862 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.863 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.863 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.863 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.864 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.864 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.864 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.865 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.865 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.865 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.866 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.866 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.866 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.867 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.867 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.867 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.868 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.868 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.868 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.869 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.869 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.869 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.869 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.870 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.870 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.871 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.871 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.871 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.871 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.872 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.872 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.873 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.873 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.874 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.874 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.875 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.876 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.876 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.877 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.877 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.878 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.879 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.880 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.880 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.881 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.881 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.882 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([1])}
2026-06-01 14:05:29.882 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.883 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.883 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.884 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.884 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.885 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B1')
2026-06-01 14:05:29.885 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.886 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.886 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.887 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.887 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.888 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.888 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.889 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.889 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.890 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.890 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.890 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.891 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.891 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.892 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.892 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.892 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.893 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.893 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.893 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.894 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.894 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.894 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.895 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.895 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.896 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.897 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.898 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.899 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.899 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.900 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.900 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.901 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.901 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.902 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.902 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.902 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.902 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.903 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.903 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.904 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.904 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.904 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.904 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.905 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.905 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.905 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.906 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.906 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.906 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.907 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.907 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.907 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.908 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.908 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.908 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.909 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.909 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.909 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.909 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.910 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.910 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.911 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.911 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.912 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.912 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.912 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.913 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.913 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.914 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.914 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.914 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.914 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.915 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.915 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.916 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.916 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.916 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.916 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.917 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.917 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.918 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.918 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.918 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.918 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.919 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([0]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.919 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.920 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.920 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.920 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.920 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.921 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'B0', 'B1')
2026-06-01 14:05:29.921 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.921 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.922 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.922 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.922 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.922 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.923 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.923 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.924 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.924 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.924 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.925 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.925 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.925 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.926 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.926 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.926 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.926 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.927 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.928 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.928 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.928 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.929 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.929 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.929 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.930 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.930 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.930 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.931 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.931 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.931 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.931 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.932 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.932 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.932 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.933 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.933 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.933 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.934 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.934 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.934 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.935 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.935 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.935 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.936 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.936 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.936 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.937 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.937 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.937 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.938 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.938 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.938 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.939 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.939 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.939 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.940 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.940 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.940 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.940 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.941 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.941 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.941 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.942 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.942 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.942 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.943 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.943 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.943 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.944 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.944 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.944 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.944 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.945 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.945 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.946 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.946 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.946 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.947 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.947 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.948 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.949 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.949 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.949 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.950 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.950 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([0]), 'B1': tensor([0])}
2026-06-01 14:05:29.951 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.951 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.951 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.951 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.952 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.952 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A1', 'B0', 'B1')
2026-06-01 14:05:29.952 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.953 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.953 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.953 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.953 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.954 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.954 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.954 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.955 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.955 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.955 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.956 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.956 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.956 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.957 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.957 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.957 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.958 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.958 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.958 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.959 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.959 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.959 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.959 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.960 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.960 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.961 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.961 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.961 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.962 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.962 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:29.962 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.963 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.963 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.963 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.964 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.964 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:29.964 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.965 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.965 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.965 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.965 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.966 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:29.966 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.967 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.967 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.967 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.967 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.968 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:29.968 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.968 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.970 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.971 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.971 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.971 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:29.972 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.972 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.973 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.973 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.973 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.973 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:29.974 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.974 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.975 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.975 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:29.975 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.975 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:29.976 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.976 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.976 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.977 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.977 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.977 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:29.978 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.979 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.979 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.980 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.980 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.980 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.981 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.982 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.982 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.983 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.983 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.983 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:29.984 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([1]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.984 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.985 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.985 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:29.986 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.986 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:29.986 | DEBUG    | __main__:compute_necessity_condition:37 - now on cause subset: ('A0', 'A1', 'B0', 'B1')
2026-06-01 14:05:29.987 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0',)
2026-06-01 14:05:29.987 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.988 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.988 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.988 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1])}
2026-06-01 14:05:29.989 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.989 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1',)
2026-06-01 14:05:29.990 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.990 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.991 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.991 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0])}
2026-06-01 14:05:29.991 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.992 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb0',)
2026-06-01 14:05:29.992 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.993 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.993 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.994 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0])}
2026-06-01 14:05:29.994 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:29.994 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb1',)
2026-06-01 14:05:29.995 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.996 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.996 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.996 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb1': tensor([1])}
2026-06-01 14:05:29.997 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:29.997 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1')
2026-06-01 14:05:29.997 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:29.998 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:29.999 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:29.999 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0])}
2026-06-01 14:05:29.999 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:30.000 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0')
2026-06-01 14:05:30.000 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.001 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.001 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.002 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0])}
2026-06-01 14:05:30.002 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.002 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb1')
2026-06-01 14:05:30.003 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.004 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.004 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.004 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.005 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.005 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0')
2026-06-01 14:05:30.005 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.006 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.007 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:30.007 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:30.007 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:30.008 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb1')
2026-06-01 14:05:30.008 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.009 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.156 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.157 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.158 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.158 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wb0', 'Wb1')
2026-06-01 14:05:30.159 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.159 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.160 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:30.160 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.161 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:30.161 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0')
2026-06-01 14:05:30.161 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.162 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.163 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:30.163 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0])}
2026-06-01 14:05:30.163 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:30.164 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb1')
2026-06-01 14:05:30.164 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.165 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.165 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.166 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.166 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.166 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wb0', 'Wb1')
2026-06-01 14:05:30.167 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.167 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.168 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.168 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.169 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.169 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:30.169 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.170 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.170 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([0], dtype=torch.int32)
2026-06-01 14:05:30.171 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.171 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([True])
2026-06-01 14:05:30.171 | DEBUG    | __main__:compute_necessity_condition:42 - Evaluating cause subset: ('A0', 'A1', 'B0', 'B1') with witness subset: ('Wa0', 'Wa1', 'Wb0', 'Wb1')
2026-06-01 14:05:30.172 | DEBUG    | __main__:compute_necessity_condition:55 - new kwargs: {'A0': tensor([0]), 'B0': tensor([1]), 'A1': tensor([1]), 'B1': tensor([0])}
2026-06-01 14:05:30.172 | DEBUG    | __main__:compute_necessity_condition:69 - Old outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.173 | DEBUG    | __main__:compute_necessity_condition:70 - New outcome: tensor([1], dtype=torch.int32)
2026-06-01 14:05:30.173 | DEBUG    | __main__:compute_necessity_condition:71 - current_witness: {'Wa0': tensor([1]), 'Wa1': tensor([0]), 'Wb0': tensor([0]), 'Wb1': tensor([1])}
2026-06-01 14:05:30.174 | DEBUG    | __main__:compute_necessity_condition:75 - Outcome differs: tensor([False])
2026-06-01 14:05:30.174 | DEBUG    | __main__:compute_necessity_condition:84 - existential_claim: tensor([True])
2026-06-01 14:05:30.175 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R0: tensor([1])
2026-06-01 14:05:30.175 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A0',), ('B1',)]
2026-06-01 14:05:30.175 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A0', 'B1']
2026-06-01 14:05:30.175 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 0.5
2026-06-01 14:05:30.176 | DEBUG    | __main__:compute_blame_and_win_frequency:15 - Responsibility R1: tensor([2])
2026-06-01 14:05:30.176 | DEBUG    | __main__:compute_blame_and_win_frequency:16 - Minimal true subsets: [('A0',), ('B1',)]
2026-06-01 14:05:30.176 | DEBUG    | __main__:compute_blame_and_win_frequency:17 - Nodes blamed: ['A0', 'B1']
2026-06-01 14:05:30.177 | DEBUG    | __main__:compute_blame_and_win_frequency:32 - Win frequency: 1.0

Win frequencies: [1.0, 1.0]

General application to increasing numbers of sites

Now we will increase num sites, for each generating a number (num_samples) of “world sample inputs” ensuring factivity, i.e. requiring that either \(A_i\) or \(B_i\) be 1. We then loop over scenarios, run explicit actual causality calculation and evaluation, record frequencies and measure runtimes.

[14]:

# hide DEBUG

import sys

from loguru import logger

logger.remove()
logger.add(sys.stderr, level="INFO")

[14]:

2

[15]:

def generate_factive_unique_samples(num_sites, num_samples):
    unique_set = set()
    samples = []

    attempts = 0
    max_attempts = num_samples * 50  # avoid infinite loops

    while len(samples) < num_samples and attempts < max_attempts:
        attempts += 1
        sample_kwargs = {}
        signature = []

        for i in range(num_sites):
            Ai = torch.randint(0, 2, (1,))
            Bi = torch.randint(0, 2, (1,))

            if (Ai == 0) and (Bi == 0):
                if torch.rand(1) < 0.5:
                    Ai = torch.tensor([1])
                else:
                    Bi = torch.tensor([1])

            sample_kwargs[f"A{i}"] = Ai
            sample_kwargs[f"B{i}"] = Bi

            # record signature piece
            signature.append(int(Ai.item()))
            signature.append(int(Bi.item()))

        signature = tuple(signature)

        # --- Enforce uniqueness ---
        if signature not in unique_set:
            unique_set.add(signature)
            samples.append(sample_kwargs)

    if len(samples) < num_samples:
        logger.warning(
            f"Requested {num_samples}, produced only {len(samples)} unique factive samples."
        )

    return samples

This is the main exact-method sweep. Starting from \(n=1\), it repeatedly increases the number of sites, samples factive worlds, runs the full subset enumeration on each, records accuracy, runtime, and the size of the search space, and moves on, until the 60-minute global budget runs out. Because the cause–witness search space grows like \(\left(2^{2n}-1\right)^2\), this loop stalls at small \(n\), and that stall is the tractability ceiling the benchmark exists to expose. The cell caches results to disk so the expensive run happens once.

[16]:

{"tags": ["papermill-ignore-errors"]}
# migh want to skip if memory blows up

fresh_run = fresh_run

global_start = time()

exact_cache_name = (
    f"ac_benchmark_results_worlds{num_worlds_at_site}_time{runtime_limit}.pkl"
)

exact_cache_file = os.path.join(results_dir, exact_cache_name)

if os.path.exists(exact_cache_file) and not fresh_run:
    with open(exact_cache_file, "rb") as f:
        ac_benchmark_results = pickle.load(f)

        runtimes_df = ac_benchmark_results["runtimes_df"]
        win_freqs_df = ac_benchmark_results["win_freqs_df"]
        subsets_df = ac_benchmark_results["subsets_df"]

    logger.info(f"Loaded cached results from {exact_cache_file}")

else:
    runtimes: dict[int, list[float]] = {}
    win_freqs = {}  # type: ignore[assignment]  # name reused; bound to a list in an earlier demo cell
    search_space = {}

    num_sites = 1  # start with the classic case

    while True:
        # stop  if runtime exceeded
        if time() - global_start > runtime_limit_seconds:
            logger.info("Global runtime limit reached. Stopping early.")
            break

        input_kwargs = generate_factive_unique_samples(
            num_sites=num_sites, num_samples=num_worlds_at_site
        )

        runtimes[num_sites] = []
        win_freqs[num_sites] = []

        for kwargs in input_kwargs:
            # stop early also **inside inner loop**
            if time() - global_start > runtime_limit_seconds:
                logger.info("Global runtime limit reached. Stopping early.")
                break

            start_time = time()

            necessity_loop, cause_subsets_loop, responsibilities_loop = (
                compute_necessity_condition(num_sites=num_sites, kwargs=kwargs)
            )

            search_space[num_sites] = len(cause_subsets_loop) ** 2

            win_freq, responsibilities, nodes_blamed = compute_blame_and_win_frequency(
                necessity_loop,
                responsibilities_loop,
                num_sites=num_sites,
                kwargs=kwargs,
            )

            win_freqs[num_sites].append(win_freq)

            elapsed = time() - start_time
            runtimes[num_sites].append(elapsed)

            logger.info(
                f"Elapsed time for num_sites={num_sites}, kwargs={kwargs}: {elapsed:.4f} seconds"
            )

        # If inner loop broke early due to time limit, exit outer loop too.
        if time() - global_start > runtime_limit_seconds:
            logger.info("Global runtime limit reached. Stopping early.")
            break

        subsets_df = pd.DataFrame.from_dict(
            search_space, orient="index", columns=["search_space"]
        )
        win_freqs_df = pd.DataFrame.from_dict(win_freqs, orient="index")
        runtimes_df = pd.DataFrame({k: pd.Series(v) for k, v in runtimes.items()})

        ac_benchmark_results = {
            "subsets_df": subsets_df,
            "win_freqs_df": win_freqs_df,
            "runtimes_df": runtimes_df,
        }

        with open(exact_cache_file, "wb") as f:  # type: ignore[assignment]  # f also bound in rb-mode branch above
            pickle.dump(ac_benchmark_results, f)

        logger.info(
            f"Saved benchmark results for num_sites {num_sites} to {exact_cache_file}"
        )
        logger.info(f"Current global elapsed time: {time() - global_start:.2f} seconds")

        # inform how much times remains
        logger.info(
            f"Remaining time: {runtime_limit_seconds - (time() - global_start):.2f} seconds"
        )

        num_sites += 1  # increment number of sites for next iteration

2026-06-01 14:05:30.202 | INFO     | __main__:<module>:22 - Loaded cached results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/ac_benchmark_results_worlds10_time60.pkl

Approximate computations with SearchForExplanation

We now turn to the approximate PCI estimator, the method whose scalability we are testing. It samples intervention configurations and reads off a per-suspect necessity score, with no subset enumeration. The next few cells build up the machinery piece by piece: a probabilistic version of the model (with a sampling layer so alternative values can be drawn), a SearchableModel wrapper, a single-world worked example, and finally the full benchmark sweep over the five configurations summarised in the Overview.

Searchable model

To enable the use of SearchForExplanation, we need to add a sampling layer, where we determine what distributions will underlie the excised distributions used for sampling the alternative values. We’ll use the obvious trivial option of uniform Bernoulli, except we’ll use Categorical distributions, as SearchForExplanation is implemented for those. We also abide by the shape conventions used in the implementation, where we’re dealing with [..., batch, padding, event]. Searchable models also expect iterable kwargs, which involve a bit of syntactic sugar, but allow more generality for models obtained by model composition while keeping the distinction between categorical and continuous inputs alive. For each problem size parameter, we will be defining a new model, strictly speaking, hence the use of a model factory. Another important distinction is that since now we don’t have to find subsets or minimal subsets, we can easily perform our computation in a batched form (running for multiple possible worlds at once), hence batch_size.

[17]:

def probabilistic_model_factory(num_at_site: int = 1, batch_size: int = 1):
    internal_model = internal_model_factory(num_at_site=num_at_site)

    # use kwargs iterable for compatibility

    def model(
        kwargs_iterable=[
            {"observations_dict": None, "n_size": batch_size},
            dict(),
            dict(),
        ],
    ):
        batch_size = kwargs_iterable[0]["n_size"]

        As = {}
        Bs = {}

        with pyro.plate("sample", size=batch_size, dim=-3):
            for i in range(num_at_site):
                As[f"A{i}"] = pyro.sample(
                    f"A{i}", dist.Categorical(logits=torch.tensor([1.0, 1.0]))
                )

                # kwargs.get(f"A{i}")
                Bs[f"B{i}"] = pyro.sample(
                    f"B{i}", dist.Categorical(logits=torch.tensor([1.0, 1.0]))
                )
                # kwargs.get(f"B{i}")

            # use -3 for batch size to satisfy search shape expectations

            C = internal_model(**As, **Bs)

        return C

    return model


batch_size = 3
num_at_site = 1
prob_1 = probabilistic_model_factory(num_at_site=num_at_site, batch_size=batch_size)

with pyro.poutine.trace() as tr_prob:
    c = prob_1()

[18]:

nodes = tr_prob.trace.nodes

print(nodes.keys())

A0 = cast(torch.Tensor, nodes["A0"]["value"])
Wa0s = cast(torch.Tensor, nodes["Wa0"]["value"])
assert torch.equal(Wa0s, A0)

B0 = cast(torch.Tensor, nodes["B0"]["value"])
Wb0s = cast(torch.Tensor, nodes["Wb0"]["value"])
assert torch.equal(Wb0s, ((B0 == 1) & (A0 == 0)).to(A0.dtype))

R0s = cast(torch.Tensor, nodes["R0"]["value"])
assert torch.equal(R0s, Wa0s + Wb0s * 2)

C = cast(torch.Tensor, nodes["C"]["value"])
expected_C = ((Wa0s == 1) | (Wb0s == 1)).to(Wa0s.dtype)
assert torch.equal(C, expected_C)

assert (
    A0.shape
    == B0.shape
    == Wb0s.shape
    == Wa0s.shape
    == R0s.shape
    == C.shape
    == (batch_size, 1, 1)
)

odict_keys(['sample', 'A0', 'B0', 'Wa0', 'Wb0', 'R0', 'C'])

We will need to first construct a SearchableModel, which is a ChiRho model with minimal additional information required for performing approximate search. This involves specifying what the potential causes, witnesses and overall sites of interest (that is, sites we want to trace) are, and what the outcome variable is. The also have to specify whether models should be conditioned on upstream variables and whether they should exclude factual values when sampling alternative values for necessity world interventions.

[19]:

potential_causes = [f"A{i}" for i in range(num_at_site)] + [
    f"B{i}" for i in range(num_at_site)
]

potential_witnesses = [f"Wa{i}" for i in range(num_at_site)] + [
    f"Wb{i}" for i in range(num_at_site)
]

sites_of_interest = potential_causes + potential_witnesses

print(sites_of_interest)

['A0', 'B0', 'Wa0', 'Wb0']

Here we instantiate the search. We tell SearchForExplanation which variables are the suspects (the \(A_i,B_i\) roots), which are the witnesses (the \(W^a_i,W^b_i\) mediators), and which is the outcome (\(C\)), then draw a batch of search samples. Each sample picks an active suspect subset, pins the witnesses to their factual values, draws alternative values for the active suspects, and records the resulting counterfactual outcome.

[20]:

# we will generalize later
obs_dict = {
    "continuous": {},
    "categorical": {"A0": A0, "B0": B0, "Wa0": Wa0s, "Wb0": Wb0s, "C": C},
}


searchable_model = SearchableModel(
    structured_model=prob_1,
    sites_of_interest=sites_of_interest,
    suspects=potential_causes,
    outcome_variable="C",
)

sampler = ThinSearchSampler(
    structured_model=searchable_model,
    conditioned_alternatives=True,
    factual_exclusion=True,
)

search_results = sampler.sample(obs_dict, num_samples=500)

100%|██████████| 500/500 [00:00<00:00, 537.53it/s]

Conditioning on interventions

Once we have a search sample, we can pay attention to different subsets thereof, by looking only at those where a particular variable was intervened on (with an alternative value). Once we (reject) condition here, we can compute necessity scores which summarize how much the outcome would differ under those interventions in the counterfactual world (while we do not recommend focussing on necessity regimes only, in this notebook we do so, as we are emulating the actual causality computations, which pay no attention to sufficiency).

[21]:

conditioned_samples = {}

for suspect in potential_causes:
    conditioned_samples[suspect] = condition_on_interventional_regime(
        results_dictionary=search_results,  # type: ignore[arg-type]  # ThinSearchResult is dict-like at runtime
        reference_variable_names=[suspect],
        antecedent_regimes={suspect: True},
        witness_regimes={suspect: False},
    )


for index in range(batch_size):
    assert torch.all(
        A0[index, 0, 0]
        != conditioned_samples["A0"]["regime_necessity"]["A0"][:, index, 0, 0]
    )

assert torch.all(
    A0[:, 0, 0] != conditioned_samples["A0"]["regime_necessity"]["A0"][:, :, 0, 0]
)


suspect_scores = {}
mean_suspect_scores = {}


for suspect in potential_causes:
    C_suff = conditioned_samples[suspect]["regime_sufficiency"]["C"].detach()

    C_nec = conditioned_samples[suspect]["regime_necessity"]["C"]

    scores = abs_diff_score(
        suff_outcomes=C_suff, nec_outcomes=C_nec, factual_outcomes=C
    )

    suspect_scores[suspect] = scores["nec"]

    mean_suspect_scores[suspect] = scores["nec"].nanmean(axis=0)

The cell below scores this single-world example. For each factive world it compares the mean necessity score of \(A_0\) against that of \(B_0\) and checks whether the higher-scoring suspect matches the ground-truth label \(R_0\). The printed success rate is the fraction of worlds the estimator gets right, a miniature version of the accuracy curve we plot later for every problem size.

[22]:

print("C", C)

factive_mask = C == 1
print(R0s[factive_mask])


print("A0 scores", mean_suspect_scores["A0"][factive_mask])

print("B0 scores", mean_suspect_scores["B0"][factive_mask])

A_wins = R0s[factive_mask] == 1
print("a wins", A_wins)

success = torch.where(
    A_wins,
    mean_suspect_scores["A0"][factive_mask] > mean_suspect_scores["B0"][factive_mask],
    mean_suspect_scores["A0"][factive_mask] < mean_suspect_scores["B0"][factive_mask],
)

print("success", success)

print("success rate", success.float().mean())

C tensor([[[0]],

        [[1]],

        [[1]]], dtype=torch.int32)
tensor([1, 1])
A0 scores tensor([0.2089, 0.4230])
B0 scores tensor([0.1328, 0.3906])
a wins tensor([True, True])
success tensor([True, True])
success rate tensor(1.)

General application to increasing number of sites

The function below generalises the single-world procedure into the full benchmark sweep, mirroring the exact-method loop but using the approximate estimator. The five calls that follow vary the three knobs introduced in the Overview: the initial sample budget and its linear growth factor (initial_num_search_samples, linear_sample_size_factor), whether the estimator uses witnesses (use_witnesses, the ablation that matters most), and whether the cause/witness cardinality bounds grow with the problem (dynamic_set_sizes). Each configuration becomes one curve in the plots.

[23]:

def run_approx_benchmark(
    initial_num_search_samples=250,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=True,
    linear_sample_size_factor=1,
    dynamic_set_sizes=False,
    fresh_run=fresh_run,
):
    # factor will be used used in
    # num_search_samples = initial_num_search_samples * linear_sample_size_factor * num_at_site

    approximate_cache_name = (
        f"approx_benchmark_results_"
        f"time{runtime_limit}_"
        f"searchsamples{initial_num_search_samples}_"
        f"factor{linear_sample_size_factor}_"
        f"witnesses{use_witnesses}_"
        f"dynamic{dynamic_set_sizes}.pkl"
    )

    approximate_cache_file = os.path.join(results_dir, approximate_cache_name)

    if os.path.exists(approximate_cache_file) and not fresh_run:
        with open(approximate_cache_file, "rb") as f:
            approx_benchmark_results = pickle.load(f)

        logger.info(f"Loaded cached approximate results from {approximate_cache_file}")

        return approx_benchmark_results

    global_start = time()

    runtime_per_observation_approx = {}
    win_freqs_approx = {}
    search_space_approx = {}

    num_at_site = 1  # start with the classic case
    num_search_samples = initial_num_search_samples

    while True:
        # stop  if runtime exceeded
        if time() - global_start > runtime_limit_seconds:
            logger.info("Global runtime limit reached. Stopping early.")
            break

        runtime_per_observation_approx[num_at_site] = []
        win_freqs_approx[num_at_site] = []

        start_time = time()

        # generate num_samples factive settings
        input_kwargs = generate_factive_unique_samples(
            num_sites=num_at_site, num_samples=num_worlds_at_site
        )

        batch_size = len(input_kwargs)

        # SearchForExplanation will process the whole batch at the same time
        stacked_kwargs = {
            key: torch.stack(
                [input_kwarg[key] for input_kwarg in input_kwargs]
            ).unsqueeze(-1)
            for key in input_kwargs[0].keys()
        }

        # generate model, obtain outcomes, true answers and witness values, setup factual dict
        prob_model = probabilistic_model_factory(
            num_at_site=num_at_site, batch_size=batch_size
        )

        with condition(data=stacked_kwargs):
            with pyro.poutine.trace() as tr.conditioned:
                c_observed = prob_model()

        assert torch.equal(
            tr.conditioned.trace.nodes["A0"]["value"], stacked_kwargs["A0"]
        )

        # get analytically available ground truth
        Rs = {
            f"R{i}": tr.conditioned.trace.nodes[f"R{i}"]["value"]
            for i in range(num_at_site)
        }

        Was = {
            f"Wa{i}": tr.conditioned.trace.nodes[f"Wa{i}"]["value"]
            for i in range(num_at_site)
        }
        Wbs = {
            f"Wb{i}": tr.conditioned.trace.nodes[f"Wb{i}"]["value"]
            for i in range(num_at_site)
        }

        categorical_dict = stacked_kwargs | Was | Wbs | {"C": c_observed}

        obs_dict = {"continuous": {}, "categorical": categorical_dict}

        # set up search for explanation and sample

        potential_causes = [f"A{i}" for i in range(num_at_site)] + [
            f"B{i}" for i in range(num_at_site)
        ]

        if use_witnesses:
            potential_witnesses = [f"Wa{i}" for i in range(num_at_site)] + [
                f"Wb{i}" for i in range(num_at_site)
            ]
        else:
            potential_witnesses = []

        sites_of_interest = potential_causes + potential_witnesses

        searchable_model = SearchableModel(
            structured_model=prob_model,
            sites_of_interest=sites_of_interest,
            suspects=potential_causes,
            outcome_variable="C",
        )

        max_antecedents = 4 if not dynamic_set_sizes else num_at_site * 4
        max_witnesses_dropped = 4 if not dynamic_set_sizes else num_at_site * 4

        sampler = ThinSearchSampler(
            structured_model=searchable_model,
            conditioned_alternatives=True,
            factual_exclusion=True,
            max_antecedents=max_antecedents,
            max_witnesses_dropped=max_witnesses_dropped,
        )

        logger.info(
            f"Setting sample size to "
            f"{initial_num_search_samples} * {linear_sample_size_factor} * {num_at_site} = "
            f"{initial_num_search_samples * linear_sample_size_factor * num_at_site} "
            f"for num_at_site={num_at_site}"
        )

        num_search_samples = (
            initial_num_search_samples * linear_sample_size_factor * num_at_site
        )

        num_search_samples = int(num_search_samples)

        # check time again before a lengthy computation
        if time() - global_start > runtime_limit_seconds:
            logger.info("Global runtime limit reached. Stopping early.")
            break

        search_results = sampler.sample(obs_dict, num_samples=num_search_samples)

        # count sets visited
        stacked_ant_indicators = torch.stack(
            list(search_results["antecedent_indicators"].values())
        )
        stacked_wit_indicators = torch.stack(
            list(search_results["witness_indicators"].values())
        )
        stacked_indicators = torch.cat([stacked_ant_indicators, stacked_wit_indicators])

        # TODO compute unique rows
        unique_rows = torch.unique(stacked_indicators, dim=0)
        unique_rows_no = unique_rows.shape[0]
        # unique_rows_no = stacked_indicators.shape[-1]  #Placeholder for now

        logger.info(
            f"Unique rows visited for num_at_site={num_at_site}: {unique_rows_no}"
        )
        search_space_approx[num_at_site] = unique_rows_no

        # compute scores for variables

        conditioned_samples = {}

        for suspect in potential_causes:
            conditioned_samples[suspect] = condition_on_interventional_regime(
                results_dictionary=search_results,
                reference_variable_names=[suspect],
                antecedent_regimes={suspect: True},
                witness_regimes={suspect: False},
            )

        for suspect in potential_causes:
            assert torch.all(
                stacked_kwargs[suspect][:, 0, 0]
                != conditioned_samples[suspect]["regime_necessity"][suspect][:, :, 0, 0]
            )

        suspect_scores = {}
        mean_suspect_scores = {}

        factive_mask = c_observed == 1

        for suspect in potential_causes:
            C_suff = conditioned_samples[suspect]["regime_sufficiency"]["C"].detach()

            C_nec = conditioned_samples[suspect]["regime_necessity"]["C"]

            # assert arguments are tensors

            assert isinstance(C_suff, torch.Tensor)
            assert isinstance(C_nec, torch.Tensor)
            assert isinstance(c_observed, torch.Tensor)

            scores = abs_diff_score(
                suff_outcomes=C_suff, nec_outcomes=C_nec, factual_outcomes=c_observed
            )

            suspect_scores[suspect] = scores["nec"]

            mean_suspect_scores[suspect] = scores["nec"].nanmean(axis=0)

        # now make decisions, compare to ground truth, collect stats

        A_wins = {}

        A_mean_scores = {}
        B_mean_scores = {}

        successes = {}

        success_rates = []

        # for each available pair of sites Ai, Bi,
        # we need to estimate whether Ai or Bi is responsible
        # and compare

        for i in range(num_at_site):
            A_mean_scores[i] = mean_suspect_scores[f"A{i}"][factive_mask]
            B_mean_scores[i] = mean_suspect_scores[f"B{i}"][factive_mask]

            A_wins[i] = Rs[f"R{i}"][factive_mask] == 1

            successes[i] = A_wins[i] == (A_mean_scores[i] > B_mean_scores[i])
            success_rates.append(successes[i].float().mean())

            logger.info(
                f"Approximate benchmark - success rate at site {i}: {success_rates[i].item():.4f}"
            )

        win_freqs_approx[num_at_site].append(torch.stack(success_rates).mean())

        end_time = time()
        elapsed_time = end_time - start_time

        time_per_world = elapsed_time / batch_size

        logger.info(
            f"Elapsed time for approximate benchmark num_at_site={num_at_site}: {elapsed_time:.4f} seconds"
        )
        logger.info(
            f"Time per observation for approximate benchmark num_at_site={num_at_site}: {time_per_world:.4f} seconds"
        )

        runtime_per_observation_approx[num_at_site] = time_per_world

        runtime_per_observation_approx_df = pd.DataFrame(
            {k: pd.Series(v) for k, v in runtime_per_observation_approx.items()}
        )

        search_space_approx_df = pd.DataFrame.from_dict(
            search_space_approx, orient="index", columns=["search_space"]
        )

        win_freqs_approx_df = pd.DataFrame.from_dict(win_freqs_approx, orient="index")

        # will be stored with results to facilitate keeping track of settings
        run_params = {
            "initial_num_search_samples": initial_num_search_samples,
            "use_witnesses": use_witnesses,
            "linear_sample_size_factor": linear_sample_size_factor,
            "runtime_limit_seconds": runtime_limit_seconds,
            "dynamic_set_sizes": dynamic_set_sizes,
        }

        approximate_benchmark_results = {
            "runtime_per_observation_approx_df": runtime_per_observation_approx_df,
            "search_space_approx_df": search_space_approx_df,
            "win_freqs_approx_df": win_freqs_approx_df,
            "run_params": run_params,
        }

        with open(approximate_cache_file, "wb") as f:
            pickle.dump(approximate_benchmark_results, f)

        logger.info(
            f"Saved approximate benchmark results for num_sites {num_at_site} to {approximate_cache_file}"
        )
        logger.info(f"Current global elapsed time: {time() - global_start:.2f} seconds")

        logger.info(
            f"Remaining time: {runtime_limit_seconds - (time() - global_start):.2g} seconds"
        )

        num_at_site += 1

    return approximate_benchmark_results

[24]:

approx_results_1 = run_approx_benchmark(
    initial_num_search_samples=initial_samples_small,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=True,
    linear_sample_size_factor=1,
    fresh_run=fresh_run,
)

2026-06-01 14:05:31.246 | INFO     | __main__:run_approx_benchmark:27 - Loaded cached approximate results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/approx_benchmark_results_time60_searchsamples250_factor1_witnessesTrue_dynamicFalse.pkl

[25]:

approx_results_2 = run_approx_benchmark(
    initial_num_search_samples=initial_samples_small,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=True,
    linear_sample_size_factor=0.5,
    fresh_run=fresh_run,
)

2026-06-01 14:05:31.252 | INFO     | __main__:run_approx_benchmark:27 - Loaded cached approximate results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/approx_benchmark_results_time60_searchsamples250_factor0.5_witnessesTrue_dynamicFalse.pkl

[26]:

approx_results_3 = run_approx_benchmark(
    initial_num_search_samples=initial_samples_small,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=False,
    linear_sample_size_factor=1,
    fresh_run=fresh_run,
)

2026-06-01 14:05:31.257 | INFO     | __main__:run_approx_benchmark:27 - Loaded cached approximate results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/approx_benchmark_results_time60_searchsamples250_factor1_witnessesFalse_dynamicFalse.pkl

[27]:

approx_results_4 = run_approx_benchmark(
    initial_num_search_samples=initial_samples_large,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=False,
    linear_sample_size_factor=1,
    fresh_run=fresh_run,
)

2026-06-01 14:05:31.265 | INFO     | __main__:run_approx_benchmark:27 - Loaded cached approximate results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/approx_benchmark_results_time60_searchsamples500_factor1_witnessesFalse_dynamicFalse.pkl

[28]:

approx_results_5 = run_approx_benchmark(
    initial_num_search_samples=initial_samples_large,
    runtime_limit_seconds=runtime_limit_seconds,
    use_witnesses=True,
    linear_sample_size_factor=1,
    dynamic_set_sizes=True,
    fresh_run=fresh_run,
)

2026-06-01 14:05:31.272 | INFO     | __main__:run_approx_benchmark:27 - Loaded cached approximate results from /home/rafal/s76projects/explainable_paper/docs/source/ac_benchmark/approx_benchmark_results_time60_searchsamples500_factor1_witnessesTrue_dynamicTrue.pkl

Inspect results

With both methods run across problem sizes, the remaining cells assemble the three comparison figures. The styling block below assigns each run a distinct colour, line style, and marker so the curves stay distinguishable even where they overlap or are printed in grayscale; the exact method is always shown in orange.

[29]:

approximate_results_list = [
    approx_results_1,
    approx_results_2,
    approx_results_3,
    approx_results_4,
    approx_results_5,
]

# Distinct color + line-style + MARKER per run, so runs are shape-coded and stay
# legible in grayscale and where lines overlap.
colors = [
    "#4C72B0",  # blue
    "#55A868",  # green
    "#C44E52",  # red
    "#8172B2",  # purple
    "#E24A33",  # orange-red
    "#64B5CD",  # cyan
]

line_styles = [
    "-",
    "--",
    "-.",
    ":",
    (0, (5, 2)),
    (0, (3, 1, 1, 1)),
]

markers = ["o", "s", "^", "D", "v", "P"]

# Deliberately large styling: these figures are downscaled to the text width in the
# paper, so base fonts must be big to stay legible on the page.
TITLE_FS, LABEL_FS, TICK_FS, LEG_FS = 30, 26, 22, 19
LW, MS = 3.2, 12


def make_var_ticks(ax, max_sites, step=None, fs=TICK_FS):
    """X positions are 0-based size steps; label them with the variable count 4*n+1.
    Step defaults to max_sites // 6 (at least 3) so the axis stays readable at any scale.
    The final position is always labeled even if it does not fall on a step boundary."""
    if step is None:
        step = max(3, max_sites // 5)
    size_parameters = list(range(1, max_sites + 2))
    numbers_of_variables = [str((4 * n) + 1) for n in size_parameters]
    tick_idx = list(range(0, max_sites + 1, step))
    if tick_idx[-1] != max_sites:
        tick_idx.append(max_sites)
    ax.set_xticks(tick_idx)
    ax.set_xticklabels([numbers_of_variables[i] for i in tick_idx], fontsize=fs)
    ax.tick_params(axis="both", labelsize=fs)


def approx_label(idx, p):
    return (
        f"({idx}) init {p['initial_num_search_samples']}, "
        f"×{p['linear_sample_size_factor']}, "
        f"wit {'on' if p['use_witnesses'] else 'off'}, "
        f"dyn {'on' if p['dynamic_set_sizes'] else 'off'}"
    )

[30]:

def add_line_end_label(ax, x, y, text, color="black"):
    ax.text(
        x,  # apply horizontal shift
        y,
        f"{text}",
        fontsize=14,
        ha="left",
        va="center",
        color=color,
        bbox=dict(
            boxstyle="round,pad=0.2",
            fc="white",
            ec=color,
            lw=1.2,
            alpha=0.85,
        ),
    )

[31]:

import numpy as np
from scipy.ndimage import gaussian_filter1d

df_melted = runtimes_df.melt(var_name="Column", value_name="Runtime")
df_melted["Column"] = df_melted["Column"].astype(int)
# Mean summary line
mean_vals = df_melted.groupby("Column")["Runtime"].mean().reset_index()


max_sites = int(mean_vals["Column"].max())

[32]:

# ---------------------- PLOT 1: RUNTIME ----------------------
fig1, ax1 = plt.subplots(figsize=(12, 7))

ax1.set_title("Runtime per Single World", fontsize=TITLE_FS)
ax1.set_xlabel("number of variables in the model", fontsize=LABEL_FS)
ax1.set_ylabel("runtime (s)", fontsize=LABEL_FS)

# Exact: raw scatter (faint) + mean line. Shift to 0-indexed positions (col - 1).
for col in df_melted["Column"].unique():
    subset = df_melted[df_melted["Column"] == col]
    ax1.scatter(
        [col - 1] * len(subset), subset["Runtime"], s=22, alpha=0.35, color="darkorange"
    )
ax1.plot(
    mean_vals["Column"] - 1,
    mean_vals["Runtime"],
    marker="o",
    linestyle="-",
    linewidth=LW,
    markersize=MS,
    color="darkorange",
    markeredgecolor="white",
    markeredgewidth=0.7,
    label="Exact (mean per world)",
)

max_sites = int(mean_vals["Column"].max()) - 1
for idx, (approx_result, color, lty, mk) in enumerate(
    zip(approximate_results_list, colors, line_styles, markers), start=1
):
    df = approx_result["runtime_per_observation_approx_df"]
    y_vals = df.T.squeeze().values
    x_vals = list(range(0, len(y_vals)))
    max_sites = max(max_sites, max(x_vals))
    ax1.plot(
        x_vals,
        y_vals,
        marker=mk,
        linestyle=lty,
        linewidth=LW,
        markersize=MS,
        color=color,
        markeredgecolor="white",
        markeredgewidth=0.7,
        label=approx_label(idx, approx_result["run_params"]),
    )

make_var_ticks(ax1, max_sites, step=3)
ax1.legend(
    loc="upper center",
    bbox_to_anchor=(0.5, -0.13),
    ncol=2,
    fontsize=LEG_FS,
    frameon=False,
)
sns.despine()
fig1.savefig("ac_benchmark/plot1_runtime.png", bbox_inches="tight", dpi=200)
plt.show()
_images/actual_causality_benchmark_69_0.png

Plot 1 (runtime). The horizontal axis is model size (\(4n+1\) variables); the vertical axis is wall-clock seconds per world. The orange exact curve climbs steeply and stops early — it hits the 60-minute budget once the cause–witness powerset becomes too large to enumerate. The approximate curves continue far to the right, and their reach is governed mainly by the sample budget: the frugal configurations run the longest. This is the tractability gap the benchmark is built to show.

[33]:

# ---------------------- PLOT 2: SEARCH SPACE ----------------------
fig2, ax2 = plt.subplots(figsize=(12, 7))

ax2.set_title("Cause–Witness Sets Searched (Log Scale)", fontsize=TITLE_FS)
ax2.set_xlabel("number of variables in the model", fontsize=LABEL_FS)
ax2.set_ylabel("sets searched (log)", fontsize=LABEL_FS)
ax2.set_yscale("log")

ax2.plot(
    subsets_df.index - 1,
    subsets_df["search_space"],
    marker="o",
    linestyle="-",
    linewidth=LW,
    markersize=MS,
    color="darkorange",
    markeredgecolor="white",
    markeredgewidth=0.7,
    label="Exact",
)

max_sites = int(subsets_df.index.max()) - 1
for idx, (approx_result, color, lty, mk) in enumerate(
    zip(approximate_results_list, colors, line_styles, markers), start=1
):
    ss = approx_result["search_space_approx_df"]
    max_sites = max(max_sites, int(ss.index.max()) - 1)
    ax2.plot(
        ss.index - 1,
        ss["search_space"],
        marker=mk,
        linestyle=lty,
        linewidth=LW,
        markersize=MS,
        color=color,
        markeredgecolor="white",
        markeredgewidth=0.7,
        label=approx_label(idx, approx_result["run_params"]),
    )

make_var_ticks(ax2, max_sites, step=3)
ax2.legend(
    loc="upper center",
    bbox_to_anchor=(0.5, -0.13),
    ncol=2,
    fontsize=LEG_FS,
    frameon=False,
)
sns.despine()
fig2.savefig("ac_benchmark/plot2_search_space.png", bbox_inches="tight", dpi=200)
plt.show()
_images/actual_causality_benchmark_71_0.png

Plot 2 (search space, log scale). This counts how many cause–witness configurations each method actually evaluates. The exact method visits the entire powerset, so its curve tracks \(\left(2^{2n}-1\right)^2\); the approximate methods visit at most a few hundred unique configurations regardless of \(n\). On the log axis the vertical gap between them is several orders of magnitude and widens with problem size — the quantitative reason the approximate method scales where exact enumeration cannot.

[34]:

# ---------------------- PLOT 3: ACCURACY ----------------------
fig3, ax3 = plt.subplots(figsize=(12, 7))

ax3.set_title("Correct-Attribution Rate per Problem Size", fontsize=TITLE_FS)
ax3.set_xlabel("number of variables in the model", fontsize=LABEL_FS)
ax3.set_ylabel("correct-attribution rate", fontsize=LABEL_FS)

# Exact
exact_label: str | None = "Exact"
for col in win_freqs_df.columns:
    ax3.plot(
        win_freqs_df.index - 1,
        win_freqs_df[col],
        marker="o",
        linestyle="-",
        linewidth=LW,
        markersize=MS,
        color="darkorange",
        markeredgecolor="white",
        markeredgewidth=0.7,
        label=exact_label,
    )
    exact_label = None
max_sites = int(win_freqs_df.index.max()) - 1

# Approximate: light Gaussian smoothing (sigma=1.0) so the trend
# follows the data, with the raw shape-coded points overlaid.
for idx, (approx_result, color, lty, mk) in enumerate(
    zip(approximate_results_list, colors, line_styles, markers), start=1
):
    y = np.array(approx_result["win_freqs_approx_df"].squeeze().values, dtype=float)
    y_smooth = gaussian_filter1d(y, sigma=1.0)
    x_vals = approx_result["win_freqs_approx_df"].index.values - 1
    max_sites = max(max_sites, int(max(x_vals)))
    ax3.plot(
        x_vals,
        y_smooth,
        linestyle=lty,
        linewidth=LW,
        color=color,
        alpha=0.9,
        label=approx_label(idx, approx_result["run_params"]),
    )
    ax3.scatter(
        x_vals,
        y,
        s=60,
        color=color,
        marker=mk,
        edgecolor="white",
        linewidth=0.7,
        zorder=5,
    )

make_var_ticks(ax3, max_sites, step=3)
ax3.set_ylim(0.66, 1.01)
ax3.legend(
    loc="upper center",
    bbox_to_anchor=(0.5, -0.13),
    ncol=2,
    fontsize=LEG_FS,
    frameon=False,
)
sns.despine()
fig3.savefig("ac_benchmark/plot3_accuracy.png", bbox_inches="tight", dpi=200)
plt.show()
_images/actual_causality_benchmark_73_0.png

Plot 3 (accuracy). The vertical axis is the correct-attribution rate (fraction of sites where the estimator names the right suspect); each approximate run is lightly smoothed with its raw points overlaid. The exact method is correct by construction until its early time-out. Among the approximate runs, the witness-using configurations stay high well beyond that point and decline gradually as the sample budget falls behind the growing powerset, while the witness-free configurations (the ablation) sit visibly lower throughout — the empirical signal that witness pinning is load-bearing.

Conclusions

This benchmark asked a single question: can the approximate PCI estimator recover the same actual-cause verdicts as exact subset enumeration, but at problem sizes where the exact method is no longer tractable? The three plots above answer it.

  • Tractability. Exact enumeration searches all \(\left(2^{2n}-1\right)^2\) cause–witness pairs and times out around \(4n+1 = 17\) variables (\(n=4\)), once that space crosses tens of thousands of pairs. The approximate estimator visits at most a few hundred unique configurations per problem size and keeps running into the tens-to-over-a-hundred-variable range, with the most frugal sample budget reaching the largest models.

  • Accuracy. Up to its early time-out the exact method is correct by construction. The approximate configurations that use witnesses stay accurate well past the point where the exact method gives up, then degrade gracefully as the linearly growing sample budget falls behind the exponentially growing powerset.

  • Witnesses matter. The witness-free ablation underperforms across the board. This is the empirical counterpart to the paper’s claim that pinning factual witness values does real causal work.

One caveat (see Limitations above): the scaled throwing problem is structured, since responsibility is independent across sites, exactly one suspect is responsible per site given the outcome, and all variables are binary, which is part of why even modest sample budgets do well here. The benchmark shows that the correspondence between PCI and actual causality is empirically operational at scale; stress-testing it on problems that break these regularities (continuous outcomes above all, where exact enumeration is not even well-defined) is the natural next step, taken up in the SIR benchmark.