SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2004.11170 · 2020

Learning a Formula of Interpretability to Learn Interpretable Formulas

arXiv · PDF · Open in the Atlas

Code that ran

4 of 4 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 3 have no contract verdict; 1 failure of our instrument; 0 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2004.11170.json · badge: /api/ran/2004.11170.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
marcovirgolin/SimpleGP community (classifier label)
classifier basis not recorded on the link
4 ran · 0 no recorded run
FunctionStatusWhere it lives
GenerateRandomTree Ran
ran on a synthesized input
marcovirgolin/SimpleGP/simplegp/Variation/Variation.py
code served (permissive licence) · get_code("b7932d05a7fff2cd")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned TreeNode. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

class TreeNode:
    def __init__(self, arity=0, name="node"):
        self.arity = arity
        self.name = name
        self.children = []
    
    def AppendChild(self, child):
        self.children.append(child)

# Create function nodes with different arities
func_add = TreeNode(arity=2, name="add")
func_mul = TreeNode(arity=2, name="mul")
func_sin = TreeNode(arity=1, name="sin")

functions = [func_add, func_mul, func_sin]

# Create terminal nodes (leaf nodes with arity 0)
term_x = TreeNode(arity=0, name="x")
term_const = TreeNode(arity=0, name="const")

terminals = [term_x, term_const]

ARGS = {
    'functions': functions,
    'terminals': terminals,
    'max_height': 3,
    'curr_height': 0,
    'method': 'grow',
    'min_height': 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type TreeNode — a TreeNode output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a TreeNode output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
OnePointMutation Ran
ran; our contract draft was wrong, not the code
marcovirgolin/SimpleGP/simplegp/Variation/Variation.py
code served (permissive licence) · get_code("5e17fb71cfcaa4a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Individual. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from copy import deepcopy
from numpy.random import randint, random

# Define a simple Node class that the function expects
class Node:
    def __init__(self, arity=0, name="node"):
        self.arity = arity
        self.name = name
        self._children = []
        self.parent = None
    
    def AppendChild(self, child):
        self._children.append(child)
        child.parent = self
    
    def DetachChild(self, child):
        idx = self._children.index(child)
        self._children.pop(idx)
        child.parent = None
        return idx
    
    def InsertChildAtPosition(self, idx, child):
        self._children.insert(idx, child)
        child.parent = self


# Define a simple Individual class that has GetSubtree method
class Individual:
    def __init__(self, root_node):
        self.root = root_node
    
    def GetSubtree(self):
        # Return a list of all nodes in the tree
        nodes = []
        
        def traverse(node):
            nodes.append(node)
            for child in node._children:
                traverse(child)
        
        traverse(self.root)
        return nodes


# Create terminal nodes (arity = 0)
terminal1 = Node(arity=0, name="x")
terminal2 = Node(arity=0, name="y")
terminal3 = Node(arity=0, name="const")
terminals = [terminal1, terminal2, terminal3]

# Create function nodes with different arities
func_add = Node(arity=2, name="add")
func_mul = Node(arity=2, name="mul")
func_neg = Node(arity=1, name="neg")
func_sin = Node(arity=1, name="sin")
functions = [func_add, func_mul, func_neg, func_sin]

# Build a simple tree structure for the individual
root = Node(arity=2, name="root_func")
left_child = Node(arity=0, name="left_terminal")
right_child = Node(arity=0, name="right_terminal")
root.AppendChild(left_child)
root.AppendChild(right_child)

individual = Individual(root)

ARGS = {
    "individual": individual,
    "functions": functions,
    "terminals": terminals
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Individual — a Individual output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Individual output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
SubtreeMutation Ran
ran on a synthesized input
marcovirgolin/SimpleGP/simplegp/Variation/Variation.py
code served (permissive licence) · get_code("d2c94d44140ff297")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Node. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from copy import deepcopy
import numpy as np
from numpy.random import randint

# Define a simple Node class to represent tree nodes
class Node:
    def __init__(self, arity=0, is_terminal=False):
        self.arity = arity
        self.is_terminal = is_terminal
        self.children = []
        self.parent = None
    
    def AppendChild(self, child):
        self.children.append(child)
        child.parent = self
    
    def DetachChild(self, child):
        idx = self.children.index(child)
        self.children.pop(idx)
        child.parent = None
        return idx
    
    def InsertChildAtPosition(self, idx, child):
        self.children.insert(idx, child)
        child.parent = self
    
    def GetDepth(self):
        if not self.children:
            return 0
        return 1 + max(child.GetDepth() for child in self.children)
    
    def GetSubtree(self):
        nodes = [self]
        for child in self.children:
            nodes.extend(child.GetSubtree())
        return nodes

# Define a simple Individual class
class Individual:
    def __init__(self, root):
        self.root = root
    
    def GetSubtree(self):
        return self.root.GetSubtree()

# Create function nodes (non-terminals)
function_nodes = [
    Node(arity=2, is_terminal=False),
    Node(arity=2, is_terminal=False),
    Node(arity=3, is_terminal=False),
]

# Create terminal nodes
terminal_nodes = [
    Node(arity=0, is_terminal=True),
    Node(arity=0, is_terminal=True),
]

# Create an individual with a root node
root = Node(arity=2, is_terminal=False)
root.children = [
    Node(arity=0, is_terminal=True),
    Node(arity=0, is_terminal=True),
]
for child in root.children:
    child.parent = root

individual = Individual(root)

ARGS = {
    'individual': individual,
    'functions': function_nodes,
    'terminals': terminal_nodes,
    'max_height': 4,
    'min_height': 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Node — a Node output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Node output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
TournamentSelect Ran
ran on a synthesized input
marcovirgolin/SimpleGP/simplegp/Selection/Selection.py
code served (permissive licence) · get_code("aa2e46796afb142a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from copy import deepcopy
from numpy.random import randint

class Individual:
    def __init__(self, fitness_value):
        self.fitness = fitness_value

population = [
    Individual(fitness_value=5.0),
    Individual(fitness_value=3.2),
    Individual(fitness_value=7.1),
    Individual(fitness_value=2.8),
    Individual(fitness_value=4.5),
]

how_many_to_select = 3
tournament_size = 4

ARGS = {
    "population": population,
    "how_many_to_select": how_many_to_select,
    "tournament_size": tournament_size,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block

Also present in other papers' code

Of 4 samples lifted from this paper's linked repositories, 4 carry a function identity and 0 do not. Of the 4 distinct functions with an identity, 1 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 1 later) and 3 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
OnePointMutation 1 other paper
1 later
2104.06060 (2021-04)
Model Learning with Personalized Interpretability Estimation (ML-PIE)

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Many risk-sensitive applications require Machine Learning (ML) models to be interpretable. Attempts to obtain interpretable models typically rely on tuning, by trial-and-error, hyper-parameters of model complexity that are only loosely related to interpretability. We show that it is instead possible to take a meta-learning approach: an ML model of non-trivial Proxies of Human Interpretability (PHIs) can be learned from human feedback, then this model can be incorporated within an ML training process to directly optimize for interpretability. We show this for evolutionary symbolic regression. We first design and distribute a survey finalized at finding a link between features of mathematical formulas and two established PHIs, simulatability and decomposability. Next, we use the resulting dataset to learn an ML model of interpretability. Lastly, we query this model to estimate the interpretability of evolving solutions within bi-objective genetic programming. We perform experiments on five synthetic and eight real-world symbolic regression problems, comparing to the traditional use of solution size minimization. The results show that the use of our model leads to formulas that are, for a same level of accuracy-interpretability trade-off, either significantly more or equally accurate. Moreover, the formulas are also arguably more interpretable. Given the very positive results, we believe that our approach represents an important stepping stone for the design of next-generation interpretable (evolutionary) ML algorithms.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2004.11170")
get_code_for_paper("2004.11170")
have("2004.11170")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2004.11170.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2004.11170.svg)](https://syntology.ai/paper/2004.11170)

Connect an agent — have() is free.