🦠cyberank

cyber rankparticles weightparticles weightscyberanks
cyber

per-particle score computed by the tri-kernel

the fixed point φ* of the composite operator: diffusion + springs + heat kernel

φ* = norm[λ_d · D(φ) + λ_s · S(φ) + λ_h · H_τ(φ)]

integrates exploration (diffusion), structural consistency (springs), and adaptive context (heat)

probability of particle observation by random walking neuron, weighted on attention and will

fundamental factor of implicit knowledge

evolution from pagerank

  • pagerank is diffusion-only (one kernel). cyberank is the full tri-kernel
feature pagerank cyberank
input structure directed graph with edges indicating links cybergraph
operators diffusion only diffusion + springs + heat kernel
damping factor typically set to 0.85 consensus parameter
link representation edges with equal weight attention and will token, three scalars (h, d, c)
handling dangling nodes distributed uniformly among all nodes adjusted rank calculation considering dangling nodes explicitly
rank initialization uniformly distributed initial ranks starts with all ranks initialized to zero
normalization ensures rank sum equals one implicit normalization through rank adjustments and damping factor
locality global recompute bounded locality: O(deg(v)) per update

pseudocode in python (diffusion component, legacy reference)

  • import functools
import operator
import collections
def cyberank(cyberlinks: list, tolerance: float = 0.001, damping_factor: float = 0.8):
    cyberlinks_dict = dict(functools.reduce(operator.add, map(collections.Counter, cyberlinks)))
    objects = list(set([item for t in [list(x.keys())[0] for x in cyberlinks] for item in t]))
    rank = [0] * len(objects)
    size = len(objects)
    default_rank = (1.0 - damping_factor) / size
    dangling_nodes = [obj for obj in objects if obj not in [list(cyberlink.keys())[0][1] for cyberlink in cyberlinks]]
    dangling_nodes_size = len(dangling_nodes)
    inner_product_over_size = default_rank * (dangling_nodes_size / size)
    default_rank_with_correction = (damping_factor * inner_product_over_size) + default_rank
    change = tolerance + 1
    steps = 0
    prevrank = [0] * len(objects)
while change > tolerance:
    for obj in objects:
        obj_index = objects.index(obj)
        ksum = 0
        income_cyberlinks = [income_cyberlink for income_cyberlink in [list(x.keys())[0] for x in cyberlinks] if income_cyberlink[1] == obj]
        for cyberlink in income_cyberlinks:
            linkStake = cyberlinks_dict[cyberlink]
            outcome_cyberlinks = [outcome_cyberlink for outcome_cyberlink in [list(x.keys())[0] for x in cyberlinks] if outcome_cyberlink[0] == cyberlink[0]]
            jCidOutStake = sum([cyberlinks_dict[outcome_cyberlink] for outcome_cyberlink in outcome_cyberlinks])
            if linkStake == 0 or jCidOutStake == 0:
                continue
            weight = linkStake / jCidOutStake
            ksum = prevrank[obj_index] * weight + ksum
        rank[obj_index] = ksum * damping_factor + default_rank_with_correction
    change = abs(max(rank) - max(prevrank))
    prevrank = rank
    steps += 1
res = list(zip(objects, rank))
res.sort(reverse=True, key=lambda x: x[1])
return res

go-cyber implementation of cyberank in go

cyberank is being used as factor in

display cyberank in apps

  • 🦠 emoji icon virus
  • examples
    • full number: 176 711 938 🦠
    • game number: 176 🦠🦠🦠

discover all concepts

Linked References

Local Graph