Pith. sign in

REVIEW 5 major objections 4 minor 27 references

Bridging Fitness With Search Spaces By Fitness Supremums: A Theoretical Study on LGP

T0 review · 5 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read In linear genetic programming, the worst-case fitness gap to an optimal program grows linearly with the number of instructions that differ from it, and that link explains bloat and guides mutation sizing.

desk verdict A fresh and testable fitness-supremum framework for LGP, undermined by an unproven step from supremum to expected fitness. read the letter →

arxiv 2505.21991 v1 pith:GXIGZKQG submitted 2025-05-28 cs.NE

Zhixing Huang , Yi Mei , Fangfang Zhang , Mengjie Zhang , Wolfgang Banzhaf This is my paper
classification cs.NE
keywords geneticprogramminglinearfitnesssupremuminstructioneditingdistancebloateffectminimumhittingtimefreemut
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Linear genetic programming (LGP) is hard to analyze theoretically because fitness depends on program execution in a way that resists simple genotype-to-fitness maps. This paper proposes an upper-bound bridge: the fitness supremum of a program—the largest possible fitness gap to an optimal program—is a linear function of its instruction editing distance from that optimal program. Assuming the distribution of fitness values is similar across editing distances, this linear supremum makes expected fitness monotone in editing distance, and hence in program size. The paper uses that to explain why LGP programs grow beyond what is needed (bloat) and to estimate the minimum hitting time of the freemut operator, predicting that small programs and multi-instruction mutations improve search. The value, if the step from supremum to expectation holds, is a problem-independent way to connect LGP fitness values with search-space geometry.

What carries the argument

The central object is the fitness supremum identity of equation (4), $\sup f(\rho)=\Delta_f(\Psi)\min\{(\Delta(\mathcal{I}_2,\Psi)-\Delta(\mathcal{I}^*,\Psi))\delta^*(\rho)+\Delta(\mathcal{I}^*,\Psi)L,\Delta_\Psi\}$, which turns the weak causality between genotype and fitness into a linear relationship with a single combinatorial quantity, the instruction editing distance $\delta^*(\rho)$. The supporting 'exploding lasagna model' organizes the search space into layers of constant program size $m$, each holding $n^m$ programs, with the neutral and non-neutral bloating factors $\Omega(m_1,m_2)$ and $\Lambda(m_1,m_2)$ bounding how adding or removing instructions multiplies the number of programs at a given editing distance. The bridge from supremum to expectation is the assumption that the fraction of programs with $\delta^*=d$ is nearly independent of size $m$ (Theorem 3), which lets the linear supremum bound control the expected fitness.

What would settle it

Enumerate a small LGP instance—say two registers, a handful of instructions, and a simple regression target—and compute, for every editing distance $d$, the empirical fitness distribution. If the supremum increases with $d$ but the mean fitness does not, or if the conditional distributions violate equation (5), the central bridge between Theorem 1 and Theorem 4 is falsified; this check can be done exactly for small instruction sets.

Watch

Extended reading notes

Core claim

The paper's central claim is Theorem 1: in an LGP search space with instruction set $\mathcal{I}$, maximum program length $L$, optimal program set $\mathcal{P}^*$, and fitness function $f$, the fitness gap between any program $\rho$ and any optimal program $\rho^*$ satisfies $$|f(\rho)-f(\rho^*)|<= \Delta_f(\Psi)\min\{(\$\Delta$(\mathcal{I}_2,\Psi)-\$\Delta$(\mathcal{I}^*,\Psi))\delta^*(\rho)+\$\Delta$(\mathcal{I}^*,\Psi)L,\ \Delta_\Psi\},$$ where $\delta^*(\rho)$ is the instruction editing distance from $\rho$ to the nearest optimal program. Setting the fitness infimum to $f(\rho^*)=0$ turns this into equation (4), the fitness supremum $\sup f(\rho)$, which is linear in $\delta^*(\rho)$ because $\Delta(\mathcal{I}_2,\Psi)\ge\Delta(\mathcal{I}^*,\Psi)$. Theorems 2 and 3 then argue that fitness probabilities are similar across editing distances, so the growth of the supremum implies growth of the expected fitness; Theorem 4 states this expectation increases with program size, Corollary 4.1 derives the bloat effect, and Theorem 5 gives an upper bound on the constructive moving rate of freemut that favors larger variation step sizes.

Load-bearing premise

The load-bearing premise is that the distribution of fitness values is similar across different editing distances (and that the fraction of programs at a given editing distance is roughly independent of program size), so that a larger fitness supremum guarantees a larger expected fitness; if this similarity fails, the supremum bound does not transfer to expectations.

Editorial extensions

If this is right

  • Smaller instruction editing distance to an optimal program implies a smaller fitness supremum, so search can be guided by editing distance rather than by problem-specific fitness functions.
  • Expected fitness increases with program size, theoretically justifying the common practice of initializing LGP with small programs.
  • Bloat occurs because, at a fixed editing distance, adding instructions is more likely than removing them to reduce or maintain distance to an optimal program.
  • For freemut, the upper bound on constructive moving rate increases with variation step size $u$ within a small range, so mutating multiple instructions per generation can improve the minimum hitting time.
  • The minimum hitting time to reach an $\epsilon$-neighborhood of the optimal program is shorter when the program size is kept small.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the supremum-to-expectation step is valid, the same editing-distance analysis may extend to other GP representations where a suitable distance metric exists (for example, tree edit distance), not just linear programs.
  • The theory suggests a testable prediction: on a fixed regression problem, the empirical distribution of fitness at a given editing distance should be roughly independent of that distance; if it is not, the bloat explanation would need revision.
  • The recommendation of large variation step sizes is bounded by a truncation effect: once the constructive-moving-rate bound saturates, further increases in step size no longer help, which the experiments already hint at for $u>10$.
  • One could derive a direct estimator of expected fitness from the supremum formula and compare it against random program sampling as a stronger validation than the mean-fitness curves.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 4 minor

Summary. The paper proposes a theoretical link between fitness values and LGP search spaces via a 'fitness supremum' defined as an upper bound on the fitness gap, claimed to be linear in the instruction editing distance from an optimal program. Theorems 1–4 aim to show that smaller editing distance implies smaller fitness supremum and that similar fitness distributions across editing distances imply that expected fitness increases with editing distance and program size; these conclusions are then used to explain bloat and the minimum hitting time of freemut. The empirical sections compare instruction sets, program sizes, and variation step sizes on symbolic regression benchmarks. The main result that is cleanly supported is Theorem 1, a Lipschitz-style bound. The rest of the theoretical chain, however, rests on unverified assumptions and an invalid inference from similar distributions to monotone expectations.

Significance. If the full chain of claims were established, the proposed framework would be a valuable alternative to problem-specific runtime analyses of GP: it would connect fitness to genotype structure through a parameter-free bound and would yield explanations of bloat and hitting time without constructing special fitness functions. The paper also has the virtue of stating a concrete, falsifiable bound in Theorem 1 and of performing external empirical checks rather than fitting constants to data. Those strengths are real but conditional. The central bridge from the supremum bound to expected fitness is not proven: the similarity condition in Eq. (5) is assumed and never verified for any concrete LGP search space, and Theorem 4's inference from 'more possible d' and 'similar normalized probabilities' to a larger expectation is logically invalid. Consequently, the bloat and hitting-time explanations rest on an unsupported step. The paper's contribution as it stands is therefore a potentially useful framework with a substantial gap between what is stated in the abstract and what is proved.

major comments (5)
  1. [Section 3.1, Eq. (4) and subsequent paragraph] Eq. (4) defines the 'fitness supremum' sup f(ρ) as the upper bound from Theorem 1, not as the actual supremum of the fitness function over programs at a given editing distance. Since the bound is written as a linear function of δ*(ρ), the sentence 'a smaller (larger) editing distance from the optimal program implies a smaller (larger) fitness supremum' is a restatement of the bound, not an independent property. The real claim, that the expectation of fitness increases with editing distance, does not follow from Eq. (4) alone; it requires the distributional similarity asserted later.
  2. [Theorem 2, Eq. (5)] Eq. (5) is an assumption, not a proved condition, and the manuscript never verifies it for any concrete LGP search space, instruction set, or fitness function. The remark that individual probabilities Pr(f(ρ)=v | δ≤d) are 'small enough' does not imply the ratio inequality in Eq. (5). Moreover, Theorem 2's conclusion is only a bound on the difference of conditional probabilities; it says nothing about the ordering of expectations. Since the paper uses Theorem 2 to bridge from 'supremum grows with δ' to 'expected fitness grows with δ', this gap is load-bearing.
  3. [Theorem 3 and its proof] The recurrence ||P^{δ=d}_{m+1}|| = ||P^{δ=d}_m||Ω(m,m+1) + ||P^{δ=d±1}_m||Λ(m,m+1) is stated without derivation from the definitions of P^{δ=d}_m, Ω, and Λ. The notation δ=d±1 conflates two different contributions, and the coefficients α1 and α2 in the subsequent line are not defined. The claim that |α1||P^{δ=d}_m|| + α2||P^{δ=d±1}_m|| is 'much smaller than n^m' because n is combinatorial is not quantified and is not shown to hold for all d and m. Thus the theorem's conclusion of ϵ-similarity is not established, and Theorem 4 relies directly on it.
  4. [Theorem 4, Eq. (9) and proof] The proof infers E[δ*|ρ∈P_{m+1}] − E[δ*|ρ∈P_m] > 0 from two facts: the support of δ* widens for larger m and the normalized probabilities ||P^{δ*=d}_m||/n^m and ||P^{δ*=d}_{m+1}||/n^{m+1} are 'similar'. This inference is invalid. A growing support does not force a larger mean if probability mass moves toward smaller d, and the similarity bound stated in Theorem 3 does not impose a lower bound on the mass at the new largest d. There exist two distributions on {1,...,k} and {1,...,k+1} with arbitrarily close normalized probabilities on the common support yet with the second distribution having a strictly smaller mean. Hence Eq. (9) does not prove the claim, and Corollary 4.1 and the bloat explanation inherit this gap.
  5. [Section 5, Theorem 5 and Lemmas 5–6] The proof of Theorem 5 substitutes upper bounds on offspring counts from Lemmas 5 and 6 into Eq. (11) and divides by the total number of offspring. An upper bound on the numerator combined with the true denominator does not yield an upper bound on the expectation; one would need the same normalization in the bound or a separate argument. The truncation remark after Theorem 5 adjusts the formula ad hoc and is not derived. Additionally, Lemma 6 states ||P^{Δδ*=i}(ρ,o−u)|| ≤ (|ρ| choose u), which is the total number of deletion offspring regardless of i, so it cannot by itself bound the constructive moving rate. These issues affect the minimum hitting time conclusions.
minor comments (4)
  1. [Section 2.4, Definition 5] The definition of Δf(Ψ) uses a ratio with ||s−s*|| in the denominator; the case of identical semantics should be handled explicitly to avoid division by zero.
  2. [Section 3.2, Table 3] The text lists the benchmark problem 'CCN' while Table 3 uses 'CNN'; the naming should be made consistent.
  3. [Notation throughout] The symbol δ* is introduced as distance to an optimal program, but Theorem 1 and Definition 6 use δρ,ρ* relative to a single ρ*; the paper should clarify whether the bound applies to the closest optimal program or to an arbitrary fixed one.
  4. [Section 4.3 and Section 5.1] The empirical results in Figures 4, 5, and 9 show correlations consistent with the claims, but they do not measure the distributions P^{δ*=d}_m or verify the similarity condition Eq. (5), so they are not a test of the proposed mechanism itself.

Circularity Check

1 steps flagged · score 3.0 of 10

One definitional circularity in Eq. (4): the linear fitness-supremum result is a restatement of the definition, while the expectation, bloat, and hitting-time conclusions rest on unverified similarity assumptions rather than circular reductions.

  1. self definitional [Section 3.1, Eq. (4) and the sentence after Eq. (4)]
    "sup f(ρ) = Δf(Ψ) min{(Δ(I2,Ψ) − Δ(I∗,Ψ))δ∗(ρ) + Δ(I∗,Ψ)L, ΔΨ}. ... From Lemma 1, we have Δ(I2,Ψ) − Δ(I∗,Ψ) ≥ 0. Therefore, Theorem 1 (in particular Eq. (1)) shows that ... a smaller (larger) editing distance from the optimal program ρ∗ implies a smaller (larger) fitness supremum."

    Eq. (4) defines the quantity called the fitness supremum to be the right-hand side, which is a linear function of δ*(ρ) with nonnegative slope (because Δ(I2,Ψ) − Δ(I*,Ψ) ≥ 0 by Lemma 1). The claimed monotonicity — smaller δ* implies smaller fitness supremum — is therefore an algebraic property of this definition, not an independently measured property of the LGP fitness landscape. Theorem 1 proves an upper bound on |f(ρ) − f(ρ*)|, but the step from that bound to an equality named 'sup f(ρ)' is a re-labeling. The independent predictive content of the paper lives in the unverified similarity condition Eq. (5); its failure would be a correctness gap, not a circular reduction.

full rationale

The derivation chain contains no fitted parameters and no load-bearing self-citation; the empirical checks are external, and the cited prior work is used for definitions and experimental context rather than to force a conclusion. The one genuine circular step is the labeling in Eq. (4): 'sup f(ρ)' is defined as a linear function of δ*(ρ), so the paper's claim that the fitness supremum increases with editing distance is true by construction. That step is only partial, because the central expectation, bloat, and hitting-time conclusions additionally depend on Theorem 2's Eq. (5) condition and Theorem 3's 'similar' probabilities, which are unproven assumptions and logical gaps rather than circular reductions. Accordingly, the circularity score is moderate rather than high.

Assumptions & free parameters 1 free parameters · 6 assumptions · 0 invented entities

No new physical or ontological entities are introduced. 'Fitness supremum', 'neutral and non-neutral bloating factors', and the 'exploding lasagna model' are analytical constructs defined by the authors; they are not independently testable entities. The ledger's main burden is therefore carried by the similarity assumptions and the uniform-distribution assumptions listed above.

free parameters (1)
  • epsilon (similarity tolerance) = unspecified, 'small enough'
    Theorem 3 and Corollary 5.1 assert that distance distributions differ by at most epsilon and define hitting time with a small epsilon. No value or bound is derived, yet the expectation arguments require this difference to be negligible.
assumptions (6)
  • domain assumption The search space contains an optimal program ρ* and the target semantics s* lies in the semantic space (Definition 1 Remark).
    This guarantees that editing distance to ρ* is well-defined for every program. In real LGP the optimal program may not be in the search space, especially with limited length L.
  • domain assumption The fitness infimum is fixed at 0 and attained at the optimal program (Remark after Theorem 1).
    The whole expectation argument uses inf f = f(ρ*) = 0. For problems where the optimum is not in the search space or fitness is not normalized, the linear supremum equation does not hold.
  • ad hoc to paper Equation (5) condition of Theorem 2: newly included programs must not raise the probability of any fitness value by more than ||P(d,v)||/||P_{d+1} \ P_d||.
    This is the load-bearing similarity condition. It is stated as an 'if' and is never verified analytically or empirically.
  • ad hoc to paper Theorem 3 recurrence: ||P^{δ=d}_{m+1}|| = ||P^{δ=d}_m||Ω(m,m+1) + ||P^{δ=d±1}_m||Λ(m,m+1), and the assertion that the normalized difference is at most epsilon.
    The recurrence is asserted without derivation from operator definitions, and the conclusion that |α1||P| + α2||P|| is much smaller than n^m is not proven. Theorems 4 and the bloat explanation depend on it.
  • ad hoc to paper In Lemmas 5 and 6, the number of unnecessary instructions j added or removed is uniformly distributed.
    This 'same probability' assumption is used to compute constructive move counts. Random freemut does not generally produce uniform j, so the resulting estimates are heuristic.
  • ad hoc to paper Upper bounds Ω and Λ can be substituted for exact bloating factors, with truncation to the total offspring count (Lemmas 5 and 6, Remark after Theorem 5).
    Replacing unknown counts by upper bounds and then truncating turns the constructive moving rate into a heuristic bound. The minimum hitting time conclusions inherit the looseness of these substitutions.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Bridging Fitness With Search Spaces By Fitness Supremums: A Theoretical Study on LGP." pith.science (2026). https://pith.science/paper/GXIGZKQG

@misc{pith2026250521991,
  author       = {Pith},
  title        = {Pith review of: Bridging Fitness With Search Spaces By Fitness Supremums: A Theoretical Study on LGP},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/GXIGZKQG}},
  note         = {Machine review of arXiv:2505.21991}
}
read the original abstract

Genetic programming has undergone rapid development in recent years. However, theoretical studies of genetic programming are far behind. One of the major obstacles to theoretical studies is the challenge of developing a model to describe the relationship between fitness values and program genotypes. In this paper, we take linear genetic programming (LGP) as an example to study the fitness-to-genotype relationship. We find that the fitness expectation increases with fitness supremum over instruction editing distance, considering 1) the fitness supremum linearly increases with the instruction editing distance in LGP, 2) the fitness infimum is fixed, and 3) the fitness probabilities over different instruction editing distances are similar. We then extend these findings to explain the bloat effect and the minimum hitting time of LGP based on instruction editing distance. The bloat effect happens because it is more likely to produce better offspring by adding instructions than by removing them, given an instruction editing distance from the optimal program. The analysis of the minimum hitting time suggests that for a basic LGP genetic operator (i.e., freemut), maintaining a necessarily small program size and mutating multiple instructions each time can improve LGP performance. The reported empirical results verify our hypothesis.

Figures

Figures reproduced from arXiv: 2505.21991 by the authors.

Figure 1
Figure 1. An LGP example composed of four instructions (from Ins0 to Ins3). Ins2 [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. The semantics of executing the LGP program in Fig. 1 given an input of [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. The exploding lasagna model for an LGP search space. [PITH_FULL_IMAGE:figures/full_fig_p013_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: The mean fitness (RSE) over LGP initial populations with program size [PITH_FULL_IMAGE:figures/full_fig_p016_4.png]
Figure 5
Figure 5. Figure 5: The average program size (the number of instructions) [PITH_FULL_IMAGE:figures/full_fig_p017_5.png]
Figure 6
Figure 6. Figure 6: An example of necessary and unnecessary instructions and introns. [PITH_FULL_IMAGE:figures/full_fig_p018_6.png]
Figure 7
Figure 7. Figure 7: Each dot is a value of the upper bounds on the constructive moving rate of [PITH_FULL_IMAGE:figures/full_fig_p020_7.png]
Figure 8
Figure 8. Figure 8: Each dot is a value of the minimum hitting time (number of generations) [PITH_FULL_IMAGE:figures/full_fig_p021_8.png]
Figure 9
Figure 9. Figure 9: The convergence curves of LGP with adding and removing [PITH_FULL_IMAGE:figures/full_fig_p022_9.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

27 extracted references · 27 canonical work pages

  1. [1]

    Al-Helali, B., Chen, Q., Xue, B., and Zhang, M. (2024). Genetic Programming for Feature Selection Based on Feature Removal Impact in High - Dimensional Symbolic Regression . IEEE Transactions on Emerging Topics in Computational Intelligence , pages 1--14

    work page 2024

  2. [2]

    Banzhaf, W., Hu, T., and Ochoa, G. (2024). How the Combinatorics of Neutral Spaces Leads Genetic Programming to Discover Simple Solutions . In Genetic Programming Theory and Practice XX , pages 65--86. Springer Nature Singapore, Singapore

    work page 2024

  3. [3]

    and Banzhaf, W

    Brameier, M. and Banzhaf, W. (2003). Neutral Variations Cause Bloat in Linear GP . In Proceedings of European Conference on Genetic Programming , pages 286--296

    work page 2003

  4. [4]

    and Banzhaf, W

    Brameier, M. and Banzhaf, W. (2007). Linear Genetic Programming . Springer US

    work page 2007

  5. [5]

    Doerr, B., Kötzing, T., Lagodzinski, J. A. G., and Lengler, J. (2017). Bounding bloat in genetic programming. In Proceedings of the Genetic and Evolutionary Computation Conference , pages 921--928, Berlin Germany. ACM

    work page 2017

  6. [6]

    Durrett, G., Neumann, F., and O'Reilly, U.-M. (2011). Computational complexity analysis of simple genetic programming on two problems modeling isolated program semantics. In Proceedings of the 11th workshop proceedings on Foundations of genetic algorithms , pages 69--80. ACM

    work page 2011

  7. [7]

    Fan, Q., Bi, Y., Xue, B., and Zhang, M. (2024). A genetic programming-based method for image classification with small training data. Knowledge-Based Systems , 283:111188

    work page 2024

  8. [8]

    and Poli, R

    Freitag McPhee, N. and Poli, R. (2001). A Schema Theory Analysis of the Evolution of Size in Genetic Programming with Linear Representations . In Proceedings of European Conference on Genetic Programming , volume 2038, pages 108--125. Springer Berlin Heidelberg

    work page 2001

Show all 27 references
  1. [9]

    Haut, N., Banzhaf, W., Punch, B., and Colbry, D. (2024). Accelerating Image Analysis Research with Active Learning Techniques in Genetic Programming . In Genetic Programming Theory and Practice XX , pages 45--64. Springer Nature

    2024

  2. [10]

    and Banzhaf, W

    Hu, T. and Banzhaf, W. (2018). Neutrality, Robustness , and Evolvability in Genetic Programming . In Genetic Programming Theory and Practice XIV , pages 101--117

    2018

  3. [11]

    Hu, T., Banzhaf, W., and Moore, J. H. (2013). Robustness and evolvability of recombination in linear genetic programming. In European Conference on Genetic Programming , volume 7831, pages 97--108

    2013

  4. [12]

    L., Banzhaf, W., and Moore, J

    Hu, T., Payne, J. L., Banzhaf, W., and Moore, J. H. (2011). Robustness, evolvability, and accessibility in linear genetic programming. In European Conference on Genetic Programming , pages 13--24

    2011

  5. [13]

    L., Banzhaf, W., and Moore, J

    Hu, T., Payne, J. L., Banzhaf, W., and Moore, J. H. (2012). Evolutionary dynamics on multiple scales: A quantitative analysis of the interplay between genotype, phenotype, and fitness in linear genetic programming. Genetic Programming and Evolvable Machines , 13(3):305--337

    2012

  6. [14]

    Huang, Z., Mei, Y., Zhang, F., and Zhang, M. (2022a). A Further Investigation to Improve Linear Genetic Programming in Dynamic Job Shop Scheduling . In Proceedings of IEEE Symposium Series on Computational Intelligence , pages 496--503

    2022

  7. [15]

    Huang, Z., Mei, Y., Zhang, F., and Zhang, M. (2024). Toward Evolving Dispatching Rules With Flow Control Operations By Grammar - Guided Linear Genetic Programming . IEEE Transactions on Evolutionary Computation , pages 1--15

    2024

  8. [16]

    Huang, Z., Mei, Y., and Zhong, J. (2022b). Semantic Linear Genetic Programming for Symbolic Regression . IEEE Transactions on Cybernetics , 54(2):1321 -- 1334

    2022

  9. [17]

    and Oliveto, P

    Mambrini, A. and Oliveto, P. S. (2016). On the Analysis of Simple Genetic Programming for Evolving Boolean Functions . In Proceedings of European Conference on Genetic Programming , volume 9594, pages 99--114. Springer International Publishing

    2016

  10. [18]

    and Mambrini, A

    Moraglio, A. and Mambrini, A. (2013). Runtime analysis of mutation-based geometric semantic genetic programming for basis functions regression. In Proceedings of Genetic and evolutionary computation conference , pages 989--996. ACM

    2013

  11. [19]

    Neumann, F. (2012). Computational complexity analysis of multi-objective genetic programming. In Proceedings of the Genetic and Evolutionary Computation Conference , pages 799--806. ACM

    2012

  12. [20]

    Nordin, P. (1994). A compiling genetic programming system that directly manipulates the machine code. Advances in Genetic Programming , 1:311--331

    1994

  13. [21]

    Qu, Y., Xin, B., Wang, Q., Wang, M., and Guo, M. (2023). Automated Discovery of Efficient Behavior Strategies for Distributed Shape Formation of Swarm Robots by Genetic Programming . IEEE Transactions on Automation Science and Engineering , pages 1--17

    2023

  14. [22]

    L., and Yao, X

    Shi, X., Minku, L. L., and Yao, X. (2022). A novel tree-based representation for evolving analog circuits and its application to memristor-based pulse generation circuit. Genetic Programming and Evolvable Machines , 23(4):453--493

    2022

  15. [23]

    Sotto, L. F. D. P. and Melo, V. V. d. (2016). Studying bloat control and maintenance of effective code in linear genetic programming for symbolic regression. Neurocomputing , 180:79--93

    2016

  16. [24]

    and Heckendorn, R

    Soule, T. and Heckendorn, R. B. (2002). An Analysis of the Causes of Code Growth in Genetic Programming . Genetic Programming and Evolvable Machines , 3:283--309

    2002

  17. [25]

    and Zhang, Z

    Sun, Y. and Zhang, Z. (2024). Automatic Feature Construction - Based Genetic Programming for Degraded Image Classification . Applied Sciences , 14(4):1613

    2024

  18. [26]

    Vanneschi, L., Castelli, M., and Silva, S. (2010). Measuring bloat, overfitting and functional complexity in genetic programming. In Proceedings of the Genetic and evolutionary computation Conference , pages 877--884

    2010

  19. [27]

    R., Horta, N., and Neves, R

    Zeiträg, Y., Figueira, J. R., Horta, N., and Neves, R. (2022). Surrogate-assisted automatic evolving of dispatching rules for multi-objective dynamic job shop scheduling using genetic programming. Expert Systems with Applications , 209:118194

    2022

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.