Great British Intelligence Test

• GBIT is a numerical series challenge used in IQ tests to assess pattern detection and logical extrapolation.
• The KitBit framework applies a set of algorithmic operators, such as BAS and RED, to extract and extend latent numerical patterns.
• State-tree search with MDL selection and operator ranking enables rapid and accurate prediction of subsequent series elements.

The Great British Intelligence Test (GBIT) refers to a class of numerical series problems commonly used in standardized IQ and intelligence assessments in the United Kingdom and elsewhere. These problems typically present a finite sequence $X = \{x_1, x_2, ..., x_n\}$ and require the test taker to infer the underlying rule(s) and predict subsequent terms. Recent developments in artificial intelligence—most notably the KitBit model—provide a systematic and computationally efficient framework for solving such series by algorithmic pattern extraction, operator composition, and automatic hypothesis selection (Corsino et al., 2022).

1. Problem Formulation and Relevance

GBIT-style number series are designed to probe abilities in pattern detection, rule induction, and logical extrapolation using minimal input evidence. Each item consists of an observed sequence (typically 4–7 numbers) with an implied generative rule. The participant’s task is to predict the next element(s) in the sequence. These problems embody algorithmic challenges in numerical cognition and generalization and are extensively used to benchmark both human and AI reasoning capabilities.

A computational solution must contend with variability in underlying rules: arithmetic or geometric progressions, differences of differences, alternating patterns, symmetry, concatenation of subseries, or multiple interleaved rules. This variety motivates the need for a generalizable, composable operator framework capable of uncovering a wide spectrum of latent patterns.

2. The KitBit Framework and Kita Operators

KitBit models each series as a transformation pipeline constructed from a fixed set of algorithmic operators termed "kitas." Each kita can be applied directly to the input sequence or to recursively built derivative tables (“edks”). The principal operators are:

Kita Operator	Core Function	Notation/Formulation
BAS	Build forward-difference table	$y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$
DIV	Construct forward-ratio table	$y_i^{1} = x_{i+1}/x_i$
RED	Reduce on row $r$ of edk	$\mathrm{RED}(r)[\mathrm{edk}_n]$
ML	Trace off-diagonals in edk	$\mathrm{ML}(\Delta y,\Delta x)[\mathrm{edk}_n]$
FOC	Split into subseries by offset/block-size	$S_m = \{x_{s+f(m)+q+p\sum d_r}\}$
ANA	Analogy by grouped partitioning	Apply edk across groups of length $e$
EXP	Exponentiate base elements	$\mathrm{EXP}(e)[\mathrm{edk}_n]$
LOG	Logarithm on adjacent pairs	$y_i^{1} = \log_{|x_i|}|x_{i+1}|$
DOP	Alternate two operators	$y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$0
SSYM/RSYM	Detect symmetry and repetition	Extend/mirror or repeat pattern
DGE/DGD/SOE	Specialized decompositions	Grouping equal or patterned elements

KitBit’s pipeline composes kitas in ordered sequences $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$1. Each operator modifies the state (the current edk or list of edks), and further kitas are applied until a solution—detection of a constant row within a small $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$2—emerges.

3. State-Tree Search and Inference Procedure

KitBit constructs an acyclic search tree where each node represents a 4-tuple encoding the current edks, applied kitas, solved flags, and parent links. Successive child states result from branching on all possible applicable kitas.

• Traversal: Both breadth-first and depth-first search are supported; breadth-first search (BFS) is default, exploring all possibilities up to depth $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$3 (typically $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$4).
• Solution Selection: Multiple solution paths may be valid. Selection is governed by the Minimum Description Length (MDL) principle—preferring the shortest $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$5 that fits the maximum observed terms and allows deepest extrapolation.
• Early Pruning: Immediate retention of states producing a constant row prevents unnecessary search.
• Operator Ranking: Empirically successful kitas (RED, ML, BAS) are prioritized to accelerate solution discovery.

The computational complexity scales as $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$6, where $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$7 is the number of candidate kitas and $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$8 the maximum composition depth.

4. Worked Solutions: Mapping to GBIT-Style Series

A canonical example series considered is $y_i^{j} = y_{i+1}^{j-1} - y_i^{j-1}$9 (Corsino et al., 2022). KitBit applies the BAS operator to construct forward differences:

$y_i^{1} = x_{i+1}/x_i$0

Detection of constancy at $y_i^{1} = x_{i+1}/x_i$1 (i.e., second-differences constant at $y_i^{1} = x_{i+1}/x_i$2) provides a direct solution: the series is quadratic, and subsequent terms are found by inverting the difference table, with the next value being $y_i^{1} = x_{i+1}/x_i$3. This single-kita solution $y_i^{1} = x_{i+1}/x_i$4 provides both immediate and extended prediction capability.

KitBit handles more complex GBIT-type puzzles by composing multiple kitas. For example, in cases with interleaved or alternating patterns, operators such as ANA or DOP correctly partition the sequence, extract regularities, and extrapolate according to independent subrules.

5. Implementation and Computational Results

KitBit demonstrated high solution coverage and computational efficiency on GBIT-style and IQ-related series. In benchmark tests on 90 IQ-test number series, KitBit achieved a solution rate of 97.8% with mean per-series compute time under 20 ms (Core i7 baseline). On a set of 67 series from literature, accuracy was up to 91% at 30–40 ms per series. When all 341,553 OEIS sequences were analyzed (to a depth of four kita compositions using Google Colab compute), KitBit found valid extrapolatory rules in 25.6% of cases (Corsino et al., 2022).

Heuristics such as operator ranking and early constancy detection are essential to maintaining sub-second run times for small GBIT-style test items.

6. Significance and Broader Context

The use of an explicit, compositional operator framework for solving GBIT number series establishes an interpretable and extensible computational model of numerical pattern induction. KitBit’s deterministic, state-tree search with MDL selection offers a principled alternative to opaque neural or end-to-end learning approaches for this domain.

The framework is directly adaptable to a broad class of intelligence-test challenges, supporting both explainable evaluation of candidate pattern rules and benchmarking of AI systems relative to human cognitive tasks. The methodology is also applicable to large-scale sequence databases such as the OEIS, supporting pattern mining and conjecture generation at scale (Corsino et al., 2022).

This suggests that operator-based, compositional models provide a scalable computational counterpart to traditional intelligence test problems, enabling standardized, rapid assessment, and advancing the study of algorithmic pattern recognition in artificial intelligence.