Toricelli
A tool to turn a corpus into a feed.
Motivation
I want an inbox of things to write, read about, and expand on that's drawn from my existing corpus. I like feeds. This is an opportunity to do programmable attention !
metadata
algorithm: pagerank-ish
What we want is a cost function:
given a list of nodes (with associated above metadata) and edges between them, compute a score for each node, then return the nodes with updated scores
optionally, figure out how to only re-compute scores for nodes that are affected by a change.
initial guesses
initial guess at a cost function:
treat srsscore as the page weight for pagerank
sid's guess: put srsscore as the damping factor
alternative: supermemo as the "outer loop"
[bollu] Reasoning: we want an SRS-shaped output, spiritually - a queue sort of thing that updates as you interact with it.
[itihas] I find this convincing.
next guess
# srs_score q n EF I -> n EF I
sid:
I = max(1, f(I,page_rank_score))
where
f(I) <= I. super-memo gives us an upper bound on when we should see a page again. PageRank can make us see a page earlier than supermemo wanted us to, because we're trying to keep stuff in working memory that may not optimal for long-term retention, but useful for short-term task clustering.
[itihas] Not really trying to keep task-related stuff together so much as surface things I care about in-context more than I might care about it "naively".
It's meant to produce connections I haven't necessarily made before (generate new knowledge). The "forgetting curve" emphasis in SRS literature treats knowledge as atomic in a way that doesn't make sense to me.
if s1 > s2, f(I, s1) < f(I, s2). If page rank deems a page more important, then see it sooner.
for reference: supermemo, the various algorithms, what they're tracking and how they're trying to track it
# sm_2: q:user_score n:repetition_number EF:easiness_factor I:interval -> n EF I
sm_2 q n EF I :=
if q >= 3:
if n = 0:
I = 1
if n = 1:
I = 6
else:
I = round(I * EF)
n = n + 1
else:
n = 0
I = 1
calc_EF = EF + (0.1 - (5 - q) * (0.08 + (5-q) * 0.02))
EF = min(calc_EF, 1.3)
From https://supermemo.guru/wiki/Algorithm_SM-17#The_Algorithm:_Outline :
The Algorithm: Outline The following procedure can be used to determine the status of memory (DSR status) at any moment of time for a given history of repetitions. Once the DSR status is known, we can determine the next interval using criteria of choice, e.g. forgetting index, maximization of stability, long-term workload minimization, etc.
estimate item difficulty D using the history repetitions for that item determine startup stability S0 using the history of repetitions for all repetition history records repeat the steps below compute theoretical retrievability Rt using current stability estimate Sw and the interval Int update Recall[] matrix using D, Sw[n-1], Rt with the grade-derived recall compute recall-based retrievability Rr compute grade-derived retrievability Rg estimate weighted Rw from Rt, Rr, and Rg compute Rw-based stability Sr compute SInc-based Se (Se=Sw[n-1]*SInc[D,Sw[n-1],Rw]) compute interval derived stability Si estimate weighted Sw from Sr, Se, and Si compute the stability increase SInc on the basis of Sw change update Sinc[] matrix using D, Sw, Rw with the new SInc value compute new interval using Int:=Sw*SInc[D,Sw,Rw] go back computing Rt step
in emacs:
org-roam-db-query funcall to list nodes in score order in a transient buffer
org-roam-db-query funcall to provide dump of nodes as a list of objects for the library to read in some suitably agnostic format (default choice JSON)