Abstract

JUBAP/Phylons did not attempt an exhaustive evaluation of all predictive-factor states and all of their combinations. It built a dynamic, budgeted search system in which the representation, candidate set, evaluation depth, temporal evidence and active rule portfolio changed over time. The supplied source snapshot confirms four especially important mechanisms. Quantitative factors were expanded into one-sided and bounded predicates at multiple granularities; active predicates were materialized on waves; positive combinations were extended only when every pair of states satisfied a positive performance-interaction relation; and negative exceptions were extended only under complete adverse pairwise constraints. These mechanisms operated alongside occupancy-constrained discretization, multi-horizon occurrence filters, timed worker hand-offs, persistent rule statistics and residual-focused combination discovery.

The paper formalizes this architecture as an anytime, coarse-to-fine, selectively incremental search over interpretable context rules. The actual cost object is not a simple 2^N space: it depends on the size of the predicate lattice, graph density, maximum rule depth, temporal memories, books, targets and compute budget. Support supplies a safe anti-monotone pruning rule; performance interactions constrain search heuristically; positive bases become cliques in a positive-interaction graph; and exception sets form adverse structures relative to their bases. The result is a code-grounded explanation of how a large semantic-context space was made operational without claiming exhaustive completeness, global optimality or proven minimal contextual sufficiency.

Reader map and evidence discipline

Implementation claims from the supplied sources are retained as part of the historical record. Mathematical properties are claimed only where they follow from the stated definitions. In particular, no global-optimum, complexity-separation, or predictive-performance theorem is inferred from implementation alone.

1. The actual optimization problem

The computational object was not a flat list of 14 Boolean factors. The design contained continuous and qualitative predictive factors, many control-point states, multiple timeframes, raw and event-defined resolutions, books, exchanges, targets, and rules that could include one positive combination plus several negative combinations. At any observation, only a subset of those states was active; across history, however, the learner could consider a large universe of candidate items and rules.

1.1 Representation levels

1.2 The correct size of the naive candidate space

Let U be the universe of active subpf item types after timeframe, book, factor-series and compatibility constraints have been applied, and let M = |U|. If positive combinations are allowed up to length K, the unconstrained set count is:

A mutually exclusive-state model gives one useful comparison bound:

N_product = product_f (1 + s_f) - 1
The +1 means that the factor may be absent. Timeframe, book and
cross-asset variants enlarge the item universe, while incompatibility
constraints reduce it.

The supplied quantitative-factor model is richer than a mutually exclusive partition. With k_f unique control points, each asset category instantiates k_f lower-threshold predicates, k_f upper-threshold predicates and C(k_f,2) bounded intervals. Thus:

m_f = 2k_f + C(k_f,2) = k_f(k_f+3)/2 per asset category; Bitcoin and non-Bitcoin variants together yield k_f(k_f+3).

Only a compact subset is active on a given wave because predicates are grouped into ranked series and at most one match per series is emitted. The search therefore begins from an overlapping predicate lattice but operates on a compressed active-state representation.

A strategy with q negative exception combinations has a much larger syntactic space because each B_j is itself a conjunction. The historical system avoided generating that full grammar. It discovered A first, B second, and additional exceptions only among strategies sharing the same A. This staged construction is the first major reason that the operational search was much smaller than the abstract rule space.

2. The optimization stack in one view

The important architectural point is that later layers never begin from the raw Cartesian product. They begin from the survivors of earlier representational, statistical and structural filters. Some filters are mathematically safe for support; others are deliberate heuristics that trade recall for speed. The system retained a background slow path to reduce the risk that an aggressive fast screen permanently removed a valuable context.

3. Layer 0 – Compact state encoding and materialized decision memory

Before searching combinations, the system changed the unit of computation. Continuous PF values were converted into subpf states and stored in wave.subpf or waves_n.subpf. Targets and their realized utilities and times were also materialized. A later rule evaluation therefore became a containment and aggregation problem rather than a repeated recomputation of every factor and target trajectory.

3.1 Hierarchical predicate series and compact identifiers

CODE-XBOT. The supplied model defines SubPredictiveFactors with gt, lt, eq and is_bitcoin fields. Quantitative states are organized into three ranked series: bounded intervals, lower-threshold predicates and upper-threshold predicates. The factor-evaluation layer returns at most one matched state from each series, while qualitative factors use equality states. This preserves several useful granularities without storing every redundant predicate as an independent active item.

Artifact 1 – hierarchical subpf materialization and matching

def build_predicate_lattice(control_points, asset_scope):

for c in unique(control_points):

add(predicate=(x > c), scope=asset_scope, series='lower')

add(predicate=(x < c), scope=asset_scope, series='upper')

for a, b in combinations(sorted(unique(control_points)), 2):

add(predicate=(a < x < b), scope=asset_scope,
series='bounded')

def materialize_active_states(value, ordered_series):

active = []

for series in ordered_series: # bounded, lower, upper

match = first_state_satisfied(value, series)

if match is not None:

active.append(match.id)

return active

3.2 The representation is a predicate lattice, not a flat binning

The source model creates overlapping statements about the same factor value. A value can simultaneously satisfy a broad threshold, a narrower threshold and a bounded interval. Consequently, a subpf should be understood as an ordinal or interval predicate at a particular granularity, not merely as one cell in a flat partition.

This matters computationally and semantically. Computationally, the lattice increases the potential item universe but the ranked-series materialization compresses the active representation. Semantically, the same observation can be described at broad, intermediate and specific resolutions, which gives the search a built-in mechanism for choosing how much precision a context requires.

Code-grounded contribution
The architecture separates representational richness from online state size: it generates a rich predicate lattice offline, then materializes a small set of active representatives per factor and series on each wave.

3.3 Materialization changes the online complexity

If a wave stores its active subpf set S_t and a candidate combination C is stored once, occurrence testing is the set-containment predicate C subseteq S_t. With bitset representation, matching can be implemented as a small number of machine-word AND operations:

Artifact 2 – bitset occurrence test

def combination_occurs(active_bits, combination_bits):

return (active_bits & combination_bits) == combination_bits
Status: Implementation recommendation consistent with the
documented materialized arrays.

This does not eliminate the combinatorial search, but it drastically lowers the unit cost of evaluating a candidate across many waves. It also supports incremental updates because only new waves need to be tested after the last measurement timestamp.

4. Layer 1 – Adaptive discretization and single-state screening

4.1 Occupancy-constrained adaptive discretization

The retained InspectorSubpfs logic merges a state when it contains less than 5% of cases and splits a state when it contains more than 25%. The intent is twofold: prevent extremely sparse states from creating unsupported combinations, and prevent dominant bins from being too coarse to discriminate contexts.

Artifact 3 – adaptive control-point maintenance

for factor in factors:

repeat up to B passes:

for bin in factor.ordered_bins:

if bin.count < 0.05 * total:

merge bin with the lower-count adjacent bin

elif bin.count > 0.25 * total:

split bin at its midpoint
Status: CODE-XBOT / RECON; thresholds and pass count are
parameters, so this is not parameter-free.

Changing a control-point grid changes the meaning of historical state identifiers. A production reconstruction should therefore version every grid. Historical waves should either retain the grid_version that produced their states or be re-materialized under a new grid before statistics are mixed.

4.2 Preserve both supportive and adverse single states

The Libro Blanco proposes evaluating every one-state combination and ranking it twice: once by occurrence times fulfillment and once by occurrence times one minus fulfillment. Only states in the top quartile of at least one ranking remain active. This is more subtle than ordinary positive feature selection: it deliberately preserves states that are frequent counter-evidence because those states can later form negative exceptions.

Artifact 4 – bidirectional single-state screening

pos_rank = top_quartile(items, key=lambda i: i.occurrence *
i.fulfillment)

neg_rank = top_quartile(items, key=lambda i: i.occurrence * (1 -
i.fulfillment))

active_items = pos_rank union neg_rank
Status: DESIGN-2018 / RECON.

This screen is computationally valuable but not lossless. A state with weak marginal performance can still become useful through interaction. Consequently, screening must be performed only on training history and evaluated through ablation. The background slow path is the historical safeguard against false negatives from this heuristic.

5. Layer 2 – Multi-horizon support pruning

Occurrence is support. For horizon h with dataset D_h, define:

The historical design applies minimum occurrence thresholds globally, over the last month and over the last week. The retained code excerpt similarly uses total, month and week masks. This is where a mathematically safe pruning property becomes available.

5.1 Anti-monotonicity proposition

Proof. Every wave containing Y necessarily contains X. Hence the occurrence set of Y is a subset of the occurrence set of X, and its normalized count cannot be larger.

Because the thresholds are checked independently at total, month and week horizons, the conjunction remains safe: failure at any one horizon prunes all supersets for that horizon.

Artifact 5 – support-safe candidate pruning

def frequent_on_all_horizons(itemset, stats, thresholds):

for horizon in ('total', 'month', 'week'):

if stats.support(itemset, horizon) < thresholds[horizon]:

return False

return True

def apriori_like_expand(level_k):

for candidate in compatible_joins(level_k):

if every_k_subset_is_frequent(candidate):

yield candidate
Status: MATH plus design-consistent pseudocode. The exact join
implementation is repository-specific.

5.2 What is not anti-monotone

Fulfillment, success index, utility and consolidated performance are conditional outcome statistics. They can rise or fall when a state is added. A low-fulfillment subset can have a high-fulfillment superset. These measures may rank, filter or guide search, but they do not justify Apriori-style deletion of every superset.

5.3 Multiple temporal memories and stage-specific aggregation

CODE-XBOT. The supplied search code maintains several temporal views of the same candidate. Combination scoring computes day, week, month and total statistics; another strategy-scoring path separates recent-month evidence from earlier history before consolidating the result. The exact aggregation therefore varies by search stage, but the architectural principle is consistent: recent evidence can affect selection without discarding long-term support.

A general representation is S(c) = sum_h alpha_h S_h(c), with alpha_h >= 0 and sum_h alpha_h = 1, where each S_h is calculated on a declared temporal memory. The weights and whether memories overlap are versioned implementation choices, not universal statistical constants.

6. Layer 3 – All-pairs interaction-constrained positive growth

After frequent pairs are available, the implementation does not blindly join every factor with every current combination. It builds a relation based on whether the joint context improves fulfillment relative to both parent states. The design calls this correlation; mathematically it is a thresholded performance-interaction tag. The supplied code then checks every pair inside an extended candidate against the positive relation table. A surviving positive base is therefore an all-pairs compatible set – a clique in the positive-interaction graph G+.

The retained code note uses delta = 0.05. The design document describes the same relation without always specifying the margin. Neutral pairs fall between the two thresholds.

For a current base A, the admissible extension set is the common positive neighborhood N_+(A) = intersection_{a in A} N_+(a). A state x can extend A only if (a,x) is in E+ for every a in A.

6.1 Phase I: graph-constrained clique growth of the positive base A

The first search phase creates frequent pairs with positive interactions, ranks survivors by consolidated performance, extends the current best candidate with a state that interacts positively with the existing members, and retains an extension only when occurrence remains sufficient and fulfillment improves.

Artifact 6 – Phase I positive-context search

def grow_positive_bases(active_items, positive_graph, budget):

frontier = priority_queue(frequent_positive_pairs(active_items))

while budget.time_left() and frontier:

A = frontier.pop_max()

persist_if_operational(A)

common = intersection(positive_graph.neighbors(a) for a in A)

for x in order_by_interaction_strength(common - A, A):

A2 = A | {x}

if not frequent_on_all_horizons(A2):

continue

if fulfillment(A2) <= fulfillment(A):

continue

frontier.push(A2, score=consolidated_performance(A2))

6.2 Complexity after graph restriction

The code-grounded search is a support-filtered clique-growth process. In the worst case, clique enumeration remains exponential because a dense positive graph can contain exponentially many cliques. In practice, the candidate count is controlled by graph sparsity, common-neighborhood size, support thresholds, rule-depth limits and time budgets. If b_k is the average common-neighborhood size at depth k, a useful output-sensitive accounting is proportional to the number of surviving partial cliques plus their tested extensions, rather than to the full sum of binomial coefficients.

7. Layer 4 – Negative exceptions and combinations of combinations

The architecture does not force every useful rule into one positive conjunction. It first finds a context A that generally works and then searches for explicit configurations under which A should not be trusted. A strategy has the form:

Each B_j is itself a conjunction. NOT B_j means that at least one state of B_j is absent; it does not mean that every member of B_j is false. This exact semantics is why A-B-C is equivalent to a decision-rule region with explicit exceptions.

CODE-XBOT. Exception growth is structurally constrained. The supplied implementation compares every positive-negative pair against the adverse relation table and also checks every pair inside the negative set. For a base A and exception B, the searched structure satisfies A x B subseteq E- and C(B,2) subseteq E-. In graph terms, A and B form a complete adverse bipartite relation, while B is also an adverse clique. This sharply reduces the exception search space and makes the learned counter-evidence explicit.

A x B subseteq E- and for all {b_i,b_j} subseteq B: (b_i,b_j) in E-

7.1 Complementary statistics

The source uses a complementary-synergy ratio comparing complementary fulfillment with combined fulfillment. Because the denominator can be zero or very small, a reconstruction should use explicit smoothing and minimum-support rules rather than silently applying an ad hoc fallback.

7.2 Phase II: construct one negative exception B

Artifact 7 – Phase II negative-exception search

def grow_exception_for_base(A, adverse_graph, budget):

frontier = priority_queue()

for x in common_adverse_neighbors(A, adverse_graph):

B = {x}

rule = Rule(base=A, exclusions=[B])

if frequent(rule) and fulfillment(rule) > fulfillment(A):

frontier.push(rule)

while budget.time_left() and frontier:

rule = frontier.pop_max()

persist_if_operational(rule)

B = rule.exclusions[0]

candidates = common_adverse_neighbors(A | B, adverse_graph) - A -
B

for x in candidates:

B2 = B | {x}

rule2 = Rule(base=A, exclusions=[B2])

if frequent(rule2) and fulfillment(rule2) > fulfillment(rule):

frontier.push(rule2)

7.3 Phase III: combine multiple exceptions

Strategies sharing the same base A and book can be combined by adding their exclusion combinations when the combined rule improves performance and retains enough occurrence. This produces A-B-C-D without searching the full grammar from the start.

Artifact 8 – Phase III multiple-exception construction

def combine_exceptions(strategies_with_same_base, budget):

frontier = seed_pairs(strategies_with_same_base)

while budget.time_left() and frontier:

r1, r2 = frontier.pop()

merged = Rule(base=r1.base,

exclusions=deduplicate(r1.exclusions + r2.exclusions))

if frequent(merged) and improves_interaction(merged, r1, r2):

persist(merged)

frontier.add_extensions(merged)
Status: DESIGN-2018 / RECON.

The staged grammar is a major optimization: positive evidence and counter-evidence are mined with different relations and only combined after each side has demonstrated support. It also produces interpretable negative memory rather than burying adverse contexts inside an opaque classifier.

8. Layer 5 – Anytime search, bounded compute and dual-track screening

At design level, the search is bounded by batch, phase and overall process budgets. The supplied JubapStrats implementation verifies one concrete alternating schedule: TIMER_COMBINATIONS = 15 minutes followed by TIMER_STRATS = 45 minutes. Separate combination and strategy workers exchange candidate sets through queues and thread events. The exact durations are version-specific; the architectural invariant is that useful intermediate results remain available while deeper search continues.

8.1 Coarse-to-fine evaluation

A second acceleration cascade tests candidates first on the last week and on three representative assets: Bitcoin, one high-capitalization altcoin and one low-capitalization altcoin. Survivors are then evaluated across the remaining books and longer histories. A slow background process searches more broadly for patterns missed by the fast path.

Artifact 9 – fast path plus slow recovery path

def dual_track_search(candidate_generator):

for c in candidate_generator.fast_frontier():

if not passes(c, history='last_week',
assets='three_representatives'):

continue

if passes(c, history='full', assets='all_books'):

persist(c, channel='fast')

# independent recovery channel; may run for weeks

for c in candidate_generator.slow_background_frontier():

if passes(c, history='full', assets='all_books'):

persist(c, channel='slow_recovery')
Status: DESIGN-2018 / RECON.

9. Layer 6 – Incremental recalculation instead of historical rescans

When a previously measured strategy is revisited, the design proposes calculating its new occurrences and outcomes only on waves created after the last measurement. This is exact for count statistics when sufficient statistics are retained, and it can be exact for means and variances with the correct update formulas. Append-only updating is not sufficient when a historical event, discretization grid or materialized state is revised; those cases require version-aware invalidation and rebuilding as specified in Revision-Aware Event Semantics and Relabeling Cascades, code-grounded v2.0.

9.1 Exact count and mean updates

For variance, use a numerically stable parallel update such as Chan-Golub-LeVeque or retain count, sum and sum of squares. A rolling window additionally requires removing the expired aggregate.

9.2 Correct rolling-average recurrence

The source expresses the intended daily rolling update informally. For a W-day simple moving average of daily values x_t, the exact recurrence is:

Artifact 10 – sufficient-statistic update

def update_candidate_stats(stats, new_waves,
expired_daily=None):

for wave in new_waves:

if candidate_occurs(wave):

stats.occurrences += 1

stats.successes += int(target_occurs(wave))

stats.utility_sum += realized_utility(wave)

stats.utility_sumsq += realized_utility(wave) ** 2

stats.time_sum += realized_time(wave)

stats.measurement_time = new_waves[-1].time

return stats
Status: RECON; exact field set depends on the target and utility
definitions.

10. Layer 7 – Selective online monitoring and active-set maintenance

The offline search does not imply that every discovered strategy is monitored continuously. The design selects strategies above utility and success thresholds, plus manually programmed strategies, and updates recent statistics only for that active set. Recent estimates combine the last five and last two occurrences and are blended with the longer estimate. Strategies that cease to pass the online filters are deactivated or deprogrammed according to account policy.

Artifact 11 – selective online strategy maintenance

def online_active_set_update(strategies):

for s in strategies:

if not (s.programmed_manually or (s.utility > 1.01 and s.success >
0.65)):

continue

recent_5 = mean(last_occurrences(s, 5))

recent_2 = mean(last_occurrences(s, 2))

s.current_I = (recent_5 + recent_2) / 2

s.current_II = (s.long_term + s.current_I) / 2

if auto_policy(s.account) and not passes_current_filters(s):

deactivate_or_deprogram(s)
Status: DESIGN-2018 / RECON; current-I/current-II are recency
heuristics, not unbiased estimators.

This completes the dynamic search loop: discovery creates an interpretable candidate; online evidence changes its active status; new observations update its statistics; changing occupancy can modify representation; and the next search cycle begins from persisted state rather than from zero. Once an active rule becomes a proposal for action, shared-resource authorization and execution feedback belong to the separate coordination boundary documented in From Expert-System Knowledge Sources to Exchange-Level Liquidity Orchestration, code-grounded v2.1.

11. A second optimization engine: residual-focused representative combinations

The Libro Blanco strategy miner searches rules that achieve targets. PHYLONS LM 4.x also describes a second engine that improves numerical predictions by discovering representative combinations in contexts where the current weighted estimate performs poorly. These two engines should not be conflated, but they share the same optimization principles.

11.1 Initial weighted estimate

For a rule or state j, LM 4.x defines a version-specific coefficient based on combination size, occurrence and dispersion. The supplied LM 4.x document gives:

w_j = numsubs_j * occurrence_j^(1/3) / (1 + std_j)
The source also floors std at 0.02. Other LM versions must carry
their own formula; formulas should not be merged across
versions.

The mathematically coherent weighted estimate is:

11.2 Mine the residuals, not the whole combination universe

The learner estimates historical macros, computes prediction error, selects macros whose absolute error exceeds the global mean absolute error, and generates only size-2 and size-3 combinations from their subpf states. Combinations with fewer than three cases are discarded. High-error combinations are retained as representative contexts and participate in the next weighted estimate.

Artifact 12 – residual-focused representative-combination learning

def residual_combination_learning(macros, compute_budget):

predictions = weighted_predict(macros, representative_rules)

errors = [(p - m.real_value) / safe_denominator(p) for m, p in
zip(macros, predictions)]

threshold = mean(abs(e) for e in errors)

difficult = [m for m, e in zip(macros, errors) if abs(e) >
threshold]

for m in difficult:

for comb in combinations(m.active_subpf, sizes=(2, 3)):

stats[comb].update(m)

for comb, st in stats.items():

if st.count >= 3 and abs(st.predictive_error) > threshold:

representative_rules.add(comb)

return representative_rules
Status: DESIGN-2018 / RECON. The source note saying low-error
macros were selected contradicts its own inequality; the inequality and
objective indicate high-error macros.

This is related to residual modeling or boosting in spirit, but it is not standard gradient boosting. It searches explicit conjunctions that identify systematic failure regions and then reweights estimates within those regions.

11.3 Control the representation before increasing rule depth

Neuron 3.3 reapplies the 5-25% occupancy adaptation so that representative states remain neither too sparse nor too coarse. Neuron 3.4 proposes sharing representative combination identities across books, exchanges and N values, optionally estimating global coefficients. This amortizes discovery cost but introduces a transferability hypothesis that must be tested rather than assumed.

11.4 Levels 4-6 and stochastic deepening

The design grows deeper representative contexts by combining already useful negative or positive combinations with compatible states, subject to minimum-case thresholds and an error condition. It also proposes an optional randomized search for levels 5 and 7-10: sample pairs among the worst-error macros, intersect their common states, and test fixed-size combinations. This is a Monte Carlo candidate generator that spends computation where residual evidence is concentrated.

Artifact 13 – optional randomized higher-level search

def randomized_deepening(worst_macros, level_k,
samples=1000):

for m1, m2 in random_distinct_pairs(worst_macros, samples):

common = m1.active_subpf intersection m2.active_subpf

for comb in combinations(common, size=level_k):

if occurrence(comb) > minimum_cases and error(comb) >
global_error:

representative_rules.add(comb)
Status: DESIGN-2018 / RECON; randomized search has no
completeness guarantee.

11.5 Meta-factors and separate objective models

Neuron 4 applies residual calibration after primary learning and maintains separate representative-rule sets for increment, time, optimal points, optimal price and stop loss. The important optimization principle is modularity: expensive search can be limited by objective and level, and each objective can stop at the depth its error reduction justifies.

12. Unified anytime algorithm

Artifact 14 – unified reconstruction

def dynamic_semantic_context_search(data, config):

# 0. Representation and materialization

grids = adapt_control_points(data.train, min_occ=0.05,
max_occ=0.25)

waves = materialize_factor_states_and_targets(data, grids)

active_items = bidirectional_single_state_screen(waves,
top_fraction=0.25)

# 1. Safe support pruning and interaction graph

frequent = frequent_items_multi_horizon(active_items,
config.support_thresholds)

interaction_graph = build_performance_interaction_graph(frequent,
delta=0.05)

# 2. Timed rule grammar

state = load_previous_frontiers()

while state.process_time < config.process_budget:

phase_I_positive_bases(state, interaction_graph,
budget=config.phase_budget)

checkpoint_operational_survivors(state, every=config.batch_budget)

phase_II_negative_exceptions(state, interaction_graph,
budget=config.phase_budget)

checkpoint_operational_survivors(state, every=config.batch_budget)

phase_III_multiple_exceptions(state, budget=config.phase_budget)

checkpoint_operational_survivors(state, every=config.batch_budget)

update_stats_only_on_new_waves(state)

# 3. Independent residual learner

residual_rules = residual_combination_learning(waves.macros,
config.residual_budget)

calibrators = fit_meta_factors(residual_rules,
objectives=config.objectives)

# 4. Online active set

return activate_and_monitor(best_rules(state), calibrators)
Status: RECON synthesizing the two documented optimization
loops.

13. What the architecture guarantees – and what it does not

13.1 This is not dynamic programming

The source architecture is dynamic because its representation, frontier, statistics, budgets and active portfolio evolve. It is not dynamic programming in the Bellman sense: there is no documented state-value recurrence that decomposes an optimal global objective into overlapping subproblems. The accurate terms are dynamic combinatorial search, anytime optimization, staged rule mining and selective incremental maintenance.

14. Relationship to semantic windows

Paper V, From Predictive Factors to Semantic Windows, code-grounded v1.1, explains how a factor state fixes a variable, transformation, historical support, resolution, relational scope and discretization band. This paper explains how the system searched that context space without enumerating every candidate. The 2018 engine therefore supplies a heuristic context-construction process; the 2026 programme supplies the later questions of sufficiency, minimality, stability and contamination.

None of these mappings means that the 2018 engine proved T_t*. The correct research question is whether its survivors approximate compact sufficient contexts better than fixed windows, unconstrained feature selection, standard frequent-itemset mining and modern time-series representations.

15. Cross-system lineage: the same optimization discipline in xSeil

Optimization Methods Across the Lineage, code-grounded v2.0, compares JUBAP with xSeil and separates safe elimination, heuristic guidance and unverified potential. The algorithms are different, but the systems share a discipline: structure the space before expensive evaluation, persist reusable decisions, solve sequentially under changing state, and keep a valid operational result while deeper computation continues. In xSeil, this appears as precomputed feasible route libraries, sequential allocation, state-dependent repricing and decision reuse. In JUBAP, it appears as materialized factor states, staged rule search, persistent frontiers and incremental statistics. Revision-aware maintenance is treated in the relabeling paper v2.0, while resource-constrained execution of surviving rules is treated in the liquidity-orchestration paper v2.1.

16. Residual quantum questions after classical optimization

The classical optimization stack is the primary result. Quantum computation is not needed to justify it. A quantum formulation is potentially relevant only after the classical system has defined a residual candidate set and an expensive stochastic scoring problem. The companion revision-aware paper v2.0 applies the same discipline to cascade triage: a candidate quantum role remains conditional on an explicit universe, oracle, state-preparation model, error target and end-to-end resource ledger.

16.1 Scope conditions

• A deterministic comparison of four or five dpoints does not incur O(1/Delta^2) sampling cost. That scaling arises only if each score is an expectation estimated from stochastic scenarios or samples.

• Amplitude estimation can reduce query dependence from O(1/epsilon^2) to O(1/epsilon) only under a suitable state-preparation and reversible-oracle model. End-to-end advantage must include those costs.

• Grover-style search is relevant only when the candidate space is implicit and the marked predicate is not already materialized or classically indexed.

• The A/B/C/D sell taxonomy cannot be mapped to stakes as previously written: A is sale by signal, B profit within the wave, C profit on a remainder, and D a fallback/protective exit conditioned by utility and stop-loss logic.

A defensible future object is stochastic residual discrimination: for surviving context c, estimate S(c) = E_omega[g(c, omega)] under perturbation or replay scenarios, and compare candidates separated by a small gap Delta. This remains an open formulation, not a property of the 2018 deterministic selector.

17. Reimplementation and evaluation programme

17.1 Fidelity implementation

1. Freeze one historical configuration: factor registry, control-point grids, support thresholds, delta margin, timers, target definitions and LM version.

2. Implement materialized states and targets with explicit knowledge-time fields for provisional/confirmed truepeaks.

3. Implement the two search loops independently: strategy mining and residual representative-combination learning.

4. Add deterministic seeds for randomized deepening and persist every candidate rejection reason.

5. Version every discretization grid and prevent statistics from mixing incompatible state meanings.

17.2 Baselines

• Exhaustive search on a deliberately small universe, to measure recall of the optimized search.

• Pure Apriori or FP-growth using support and confidence.

• Beam search with the same maximum width and depth.

• Greedy forward selection without an interaction graph.

• Rule lists / decision trees / subgroup discovery with equivalent state inputs.

• Random search and successive halving under the same compute budget.

17.3 Metrics

17.4 Required ablations

• No adaptive discretization versus 5-25% occupancy adaptation.

• No single-state screening versus positive-only screening versus positive-and-negative screening.

• Support pruning only versus support plus interaction graph.

• Positive A rules only versus A-B and A-B-C rules.

• Full replay versus last-week / three-asset fast screen.

• Full historical rescans versus sufficient-statistic updates.

• Random higher levels disabled versus enabled at equal compute.

• Book-specific versus globally shared representative combinations.

18. Conclusions

The JUBAP/Phylons combinatorial engine is best understood as an adaptive search-and-maintenance architecture, not as an attempted exhaustive solver. It generated a rich predicate lattice but materialized only compact active representatives; used support to prune safely; grew positive contexts as all-pairs compatible structures in a performance-interaction graph; represented failures through separately mined adverse exception structures; allocated computation through explicit worker budgets; persisted intermediate results; updated new evidence selectively; and maintained a coupled residual learner for poorly explained contexts.

This architecture is scientifically interesting because it makes the cost of context construction visible. It shows that a semantic window is not found by evaluating every possible history and feature subset. It is approached through a sequence of compression, screening, structural search, exception discovery, residual refinement and selective re-evaluation. The 2026 theory can now ask which parts of that heuristic preserve sufficiency, which introduce bias, and how much clarity is purchased by each additional unit of computation.

Appendix A – Optimization layers and evidence map

Appendix B – Precise terminology and mathematical scope

Appendix C – Source register

Ivan Abril Palma – IMSV.org / tegrity.ai working group – Technical working paper v2.1 – July 2026