SOURCE-ALIGNED · SIX MODEL FAMILIES · SO + MO

COIN
step by step

Follow one generation from permutation evaluation through better/worse selection, coincidence counting, integer-weight updates, and next-population sampling—then see exactly what Edge, NB, CNB, SNE-COIN, and both Hybrid models learn.

01 · GENERATION LOOP

What COIN learns in one generation

Evaluate

Evaluate every permutation with the same evaluator, producing scalar fitness or an objective vector.

Select

Take reward evidence from the better tail and punishment evidence from the worse tail.

Count

Convert permutations into edge or position events according to the variant.

Learn

Conservative redistributes weight; Reconstruction rebuilds the matrix.

Sample

Roulette-sample only unused items, so validity holds by construction.

Comparison unit: Use objective evaluations = population × effective generations, not generations alone.

02 · EVIDENCE SNAPSHOT

Reward/Punishment ratios are selected population fractions

Minimization example: population 8 with 25:25 ratios gives two best reward solutions and two worst punishment solutions. Middle candidates are evaluated and may update best-so-far, but do not write model evidence this round.

f=19 · REWARD[1,3,5,0,4,2]

f=22 · REWARD[1,5,3,0,2,4]

f=31[3,1,0,5,2,4]

f=35[4,0,2,1,5,3]

f=38[0,4,1,3,2,5]

f=41[5,2,0,4,3,1]

f=50 · PUNISH[2,4,5,1,0,3]

f=57 · PUNISH[4,2,1,5,3,0]

Not selection-round counts. Reward 10% means about 10% of the population supplies positive evidence each generation.

03 · EDGE COIN

Learn what should follow what

Edge COIN stores n×n H[a,b], the weight for b following a. [1,3,5,0,4,2] yields 1→3, 3→5, 5→0, 0→4, 4→2, plus cycle-closing edge 2→1.

STARTsample first item

1 → ?H[1, unused]

1 → 3roulette

3 → ?H[3, unused]

COMPLETE[1,3,5,0,4,2]

used = {start}
while len(order) < n:
  candidates = items - used
  p(j) ∝ H[previous,j]
  next = roulette(candidates,p)
  append(next)

H[i,i] = 0
H[i,j] ≥ 1 for i ≠ j

CONSERVATIVE

Redistribute integer mass

Off-diagonal weights start at round(n×100/training rate). Punishment removes mass from bad observed cells and spreads it to row competitors; reward draws competitor mass into good cells. Every legal edge remains positive.

RECONSTRUCTION

H[i,j] = 10R[i,j] + 1

Rebuild from the latest reward counts. Unseen edges keep weight 1, preserving exploration. This reacts faster but forgets more history.

initial_weight = round(n × 100 / training_rate) · p(j|i) = H[i,j] / Σ H[i,eligible]

04 · NODE/POSITION FAMILY

NB-COIN · CNB-COIN · SNE-COIN

NB-COIN

Random position, then value

Stores W[position,item]. It shuffles position order, then samples an unused item from that position row, reducing left-to-right construction bias.

positions=shuffle(0..n-1)
for p in positions:
  x[p] ~ W[p,unused]

CNB-COIN

Position 0→n, then value

Uses NB’s matrix and learner but fills 0,1,…,n−1 in order—Chained Node-Based COIN.

for p in range(n):
  x[p] ~ W[p,unused]

START-NODE EDGE

Separate start from transitions

Stores S[item] for the first locus and H[a,b] thereafter, useful when a start, depot, or seed has meaning.

x[0] ~ S[unused]
x[p] ~ H[x[p-1],unused]

05 · TWO HYBRIDS

Two non-duplicate Node–Edge mixtures

HYBRID TEMPLATE COIN

Node anchors · Edge fills gaps

Generate a Node template.
Retain scattered 30–70%; locus 0 always stays.
Reserve values required by future anchors.
Complete holes using Edge from the previous value.
Train both models on completed candidates.

template [1,_,3,_,_,6,_,7,_]
result   [1,9,3,5,4,6,8,7,2]

HYBRID CHAIN COIN

Choose Node or Edge per link

Position 0 comes from Node. Every later locus independently selects W[position] or H[previous], and a source mask records provenance.

x[0] ~ W[0,unused]
for p=1..n-1:
  if Bernoulli(.5): x[p]~W[p,unused]
  else:             x[p]~H[x[p-1],unused]

The schema distinction: HNE-COIN freezes a partial schema before reconstruction; Chain chooses a model per link with no pre-frozen template.

06 · COMPLETE TAXONOMY

All variants and their multi-objective forms

Variant	Knowledge	Sampling	MO
Edge COIN	H[previous,next]	edge chain	MO Edge COIN
NB-COIN	W[position,item]	random position first	MO NB-COIN
CNB-COIN	W[position,item]	position 0→n	MO CNB-COIN
SNE-COIN	S[start]+H[edge]	start then edge	MO SNE-COIN
HNE-COIN	W+H	Node template→Edge fill	MO HNE-COIN
CNE-COIN	W+H	Node/Edge per link	MO CNE-COIN

MO changes selection, not representation

Nondominated rank/Pareto depth plus diversity score produces reward/punishment evidence and an external archive; each variant keeps the same matrix and sampler.

F(x)=[f₁(x),…,fₘ(x)]
rank 0 = nondominated
reward ← strong Pareto evidence
punish ← weak/deep-rank evidence
archive ← nondominated union

Multi-objectivization: A scalar fitness can be decomposed into guiding signals, but constant or redundant objectives provide no learning signal.

07 · PARAMETERS & COST

Operational meaning of each control

Reward selection (%)

Smaller is selective but noisy; larger is steadier but may average several basins.

Punishment selection (%)

Fraction of the worse tail used to reduce weights; not a mutation rate.

Training rate

Sets initial mass round(n×100/rate); a higher rate makes new evidence act faster.

Learning mode

Conservative accumulates/redistributes; Reconstruction rebuilds from latest rewards.

Family	Memory	Count	Sample
Edge / NB / CNB	Θ(n²)	Θ(Pn)	Θ(Pn²)
SNE-COIN	Θ(n²+n)	Θ(Pn)	Θ(Pn²)
Hybrids	Θ(2n²)	Θ(Pn)	Θ(Pn²)

Invariants

No missing/duplicate items; Edge diagonal=0; legal weight≥1; identical seeds reproduce.

Diagnostics

Best-so-far per objective, diversity, weight concentration, Pareto depth, archive size, and evaluations-to-solution.

08 · IMPLEMENTATION MAP

Every explanation maps back to the library

Component	Source	Role
Edge	`models/edge_reference.py` `models/edge_optimized.py`	readable + equivalence-tested NumPy/Numba
Learning	`learning/reward_punishment.py`	integer-weight update kernel
NB / CNB	`models/position.py` `models/cnb_position.py`	two position samplers
Composite	`models/start_node_edge.py` `models/hybrid.py` `models/hybrid_chain.py`	start and hybrid variants
Multi-objective	`core/multiobjective.py`	Pareto selection · archive · progress

GitHub · COINCIDENCE algorithms suite ROSE Architecture Order Schema

Uses current reusable-library names and does not reintroduce the duplicate Legacy Hybrid variant.