Name	Name	Last commit message	Last commit date
parent directory ..
README.md	README.md

NornicDB Complete Functions Index

Comprehensive documentation with real-world examples and ELI12 explanations

Last Updated: November 25, 2025

Quick Navigation

📁 Detailed Function Docs - Complete guides with examples
🧠 Memory Decay System - How memory fading works
📊 Status: 52 functions documented (100% coverage)

All Functions by Category

🔍 Node & Relationship Functions (11 functions)

Function	What It Does	Example
`id(n)`	Get unique ID	`MATCH (n) RETURN id(n)`
`elementId(n)`	Neo4j-compatible ID	`RETURN elementId(n)`
`labels(n)`	Get node labels/types	`RETURN labels(n)`
`type(r)`	Get relationship type	`MATCH ()-[r]->() RETURN type(r)`
`keys(n)`	List property names	`RETURN keys(n)`
`properties(n)`	Get all properties	`RETURN properties(n)`
`startNode(r)`	Get relationship start node	`RETURN startNode(r)`
`endNode(r)`	Get relationship end node	`RETURN endNode(r)`
`nodes(path)`	Get nodes in path	`RETURN nodes(path)`
`relationships(path)`	Get rels in path	`RETURN relationships(path)`
`exists(n.prop)`	Check if property exists	`WHERE exists(n.email)`

📝 String Functions (15 functions)

Function	What It Does	Example
`toString(val)`	Convert to string	`RETURN toString(42)`
`toLower(s)`	Convert to lowercase	`RETURN toLower("HELLO")`
`toUpper(s)`	Convert to UPPERCASE	`RETURN toUpper("hello")`
`trim(s)`	Remove edge whitespace	`RETURN trim(" hi ")`
`ltrim(s)`	Trim left side	`RETURN ltrim(" hi")`
`rtrim(s)`	Trim right side	`RETURN rtrim("hi ")`
`replace(s, find, repl)`	Find & replace	`RETURN replace("cat", "c", "b")`
`split(s, delim)`	Split into list	`RETURN split("a,b,c", ",")`
`substring(s, start, len)`	Extract substring	`RETURN substring("hello", 0, 3)`
`left(s, n)`	First n characters	`RETURN left("hello", 2)`
`right(s, n)`	Last n characters	`RETURN right("hello", 2)`
`size(s)`	String/list length	`RETURN size("hello")`
`char_length(s)`	Character count	`RETURN char_length("hi")`
`normalize(s)`	Unicode normalization	`RETURN normalize(s)`
`btrim(s, chars)`	Trim specific chars	`RETURN btrim("!!hi!!", "!")`

🔢 Type Conversion Functions (4 functions)

Function	What It Does	Example
`toInteger(val)`	Convert to integer	`RETURN toInteger("42")`
`toInt(val)`	Alias for toInteger	`RETURN toInt("42")`
`toFloat(val)`	Convert to decimal	`RETURN toFloat("3.14")`
`toBoolean(val)`	Convert to true/false	`RETURN toBoolean("true")`

📐 Mathematical Functions (7 functions)

Function	What It Does	Example	ELI12
`abs(x)`	Absolute value	`RETURN abs(-5)`	Remove the minus sign
`ceil(x)`	Round up	`RETURN ceil(3.2)`	Always round UP to next whole number
`floor(x)`	Round down	`RETURN floor(3.8)`	Always round DOWN to previous number
`round(x)`	Round normally	`RETURN round(3.5)`	Round to nearest (0.5+ goes up)
`sign(x)`	Get sign (-1/0/1)	`RETURN sign(-5)`	Is it positive(+1), negative(-1), or zero(0)?
`sqrt(x)`	Square root	`RETURN sqrt(16)`	What number × itself = x?
`rand()`	Random 0-1	`RETURN rand()`	Random decimal between 0 and 1

📊 Trigonometric Functions (11 functions)

Function	What It Does	Example	ELI12
`sin(x)`	Sine	`RETURN sin(radians(90))`	Height on a circle
`cos(x)`	Cosine	`RETURN cos(radians(0))`	Distance forward on a circle
`tan(x)`	Tangent	`RETURN tan(radians(45))`	Slope of the angle
`cot(x)`	Cotangent	`RETURN cot(radians(45))`	Opposite of tangent
`asin(x)`	Arc sine	`RETURN asin(0.5)`	What angle gives this height?
`acos(x)`	Arc cosine	`RETURN acos(0.5)`	What angle gives this distance?
`atan(x)`	Arc tangent	`RETURN atan(1)`	What angle has this slope?
`atan2(y, x)`	2-arg arc tangent	`RETURN atan2(y, x)`	Angle from origin to point
`radians(deg)`	Degrees→radians	`RETURN radians(180)`	Convert 360° circle to 2π radians
`degrees(rad)`	Radians→degrees	`RETURN degrees(3.14)`	Convert radians to 360° circle
`haversin(x)`	Haversine	`RETURN haversin(x)`	Special function for Earth distances

🌟 Advanced Math Functions (4 functions)

Function	What It Does	Example	ELI12
`exp(x)`	e^x	`RETURN exp(1)`	e (2.718...) raised to power x
`log(x)`	Natural log	`RETURN log(2.718)`	Opposite of exp(), returns ~1
`log10(x)`	Base-10 log	`RETURN log10(100)`	How many 10s multiply to get x? (answer: 2)
`pi()`	π constant	`RETURN pi()`	3.14159... (circle circumference ÷ diameter)
`e()`	e constant	`RETURN e()`	2.71828... (natural growth rate)

📋 List Functions (9 functions)

Function	What It Does	Example
`size(list)`	List length	`RETURN size([1,2,3])`
`head(list)`	First element	`RETURN head([1,2,3])`
`last(list)`	Last element	`RETURN last([1,2,3])`
`tail(list)`	All except first	`RETURN tail([1,2,3])`
`reverse(list)`	Reverse order	`RETURN reverse([1,2,3])`
`range(start, end, step)`	Create number sequence	`RETURN range(1, 10, 2)`
`coalesce(v1, v2, ...)`	First non-null value	`RETURN coalesce(null, 5, 10)`
`reduce(...)`	Reduce list to value	See examples below
`isEmpty(x)`	Check if empty	`RETURN isEmpty([])`

🎯 Vector Functions (2 functions)

Function	What It Does	Example	ELI12
`vector.similarity.cosine(v1, v2)`	Cosine similarity	`RETURN vector.similarity.cosine([1,2,3], [2,3,4])`	How similar are two lists of numbers? (angle between them)
`vector.similarity.euclidean(v1, v2)`	Euclidean distance	`RETURN vector.similarity.euclidean([0,0], [3,4])`	Straight-line distance between two points

📈 Kalman Filter Functions (10 functions)

Real-time signal filtering and prediction for time series data. Perfect for smoothing noisy sensor readings, tracking market sentiment, or predicting trends.

Function	What It Does	Example
`kalman.init(config?)`	Create basic filter state	`RETURN kalman.init()`
`kalman.process(val, state, target?)`	Filter a measurement	`kalman.process(23.5, s.state)`
`kalman.predict(state, steps)`	Predict future value	`kalman.predict(s.state, 5)`
`kalman.state(state)`	Get current estimate	`kalman.state(s.state)`
`kalman.reset(state)`	Reset filter	`kalman.reset(s.state)`
`kalman.velocity.init(pos?, vel?)`	Create trend-tracking filter	`kalman.velocity.init()`
`kalman.velocity.process(val, state)`	Filter with velocity tracking	Returns `{value, velocity, state}`
`kalman.velocity.predict(state, steps)`	Predict with momentum	`kalman.velocity.predict(s.state, 5)`
`kalman.adaptive.init(config?)`	Create auto-switching filter	`kalman.adaptive.init()`
`kalman.adaptive.process(val, state)`	Filter with auto mode-switch	Returns `{value, mode, state}`

⏰ Date/Time Functions (4 functions)

Function	What It Does	Example
`timestamp()`	Current Unix timestamp (ms)	`RETURN timestamp()`
`datetime()`	Current datetime	`RETURN datetime()`
`date()`	Current date	`RETURN date()`
`time()`	Current time	`RETURN time()`

✅ Null/Check Functions (3 functions)

Function	What It Does	Example
`isEmpty(x)`	Check if empty	`RETURN isEmpty("")`
`isNaN(x)`	Check if not-a-number	`RETURN isNaN(0/0)`
`nullIf(v1, v2)`	Return null if equal	`RETURN nullIf(5, 5)`

🔄 Aggregation Functions (2 functions)

Function	What It Does	Example
`count(x)`	Count items	`MATCH (n) RETURN count(n)`
`length(path)`	Path length	`RETURN length(path)`

🎲 Utility Functions (2 functions)

Function	What It Does	Example
`randomUUID()`	Generate UUID	`RETURN randomUUID()`
`rand()`	Random number 0-1	`RETURN rand()`

Real-World Example Collections

Example 1: Memory Search with Decay

// Find strong memories about a topic
MATCH (m:Memory)
WHERE m.content CONTAINS "database"
  AND m.decayScore > 0.6
RETURN m.title,
       m.decayScore,
       m.accessCount,
       m.tier
ORDER BY m.decayScore DESC
LIMIT 10

Example 2: Data Cleaning

// Clean up user input
MATCH (user:User)
SET user.email = toLower(trim(user.email)),
    user.name = trim(user.name)
WHERE user.email CONTAINS " " OR user.email <> toLower(user.email)
RETURN count(user) AS cleanedCount

Example 3: Calculate Distances

// Find nearby locations using Pythagorean theorem
MATCH (loc1:Location), (loc2:Location)
WHERE id(loc1) < id(loc2)
WITH loc1, loc2,
     sqrt(pow(loc1.x - loc2.x, 2) + pow(loc1.y - loc2.y, 2)) AS distance
WHERE distance < 10
RETURN loc1.name, loc2.name, round(distance * 100) / 100 AS distanceKm
ORDER BY distance

Example 4: Text Processing

// Parse and normalize tags
MATCH (post:Post)
WITH post,
     [tag IN split(toLower(post.tagString), ",") | trim(tag)] AS cleanTags
SET post.tags = cleanTags
RETURN count(post) AS processed

Example 5: Find Similar Memories (Vector Search)

// Find memories similar to a query embedding
MATCH (m:Memory)
WHERE m.embedding IS NOT NULL
WITH m, vector.similarity.cosine(m.embedding, $queryEmbedding) AS similarity
WHERE similarity > 0.8
RETURN m.content,
       similarity,
       m.decayScore,
       similarity * m.decayScore AS combinedScore
ORDER BY combinedScore DESC
LIMIT 5

Example 6: Statistical Analysis

// Analyze memory access patterns
MATCH (m:Memory)
WHERE m.tier = "SEMANTIC"
WITH m.tier AS tier,
     count(m) AS total,
     avg(m.accessCount) AS avgAccess,
     avg(m.decayScore) AS avgScore,
     sqrt(avg(pow(m.accessCount - avg(m.accessCount), 2))) AS stdDev
RETURN tier, total, 
       round(avgAccess * 100) / 100,
       round(avgScore * 100) / 100,
       round(stdDev * 100) / 100

Example 7: Conditional Logic with Coalesce

// Handle missing data gracefully
MATCH (user:User)
RETURN user.name,
       coalesce(user.email, user.phone, "No contact info") AS contact,
       coalesce(user.age, 0) AS age

Example 8: Generate Sequences

// Create pagination links
RETURN [page IN range(1, 10) | 
        "https://example.com/page/" + toString(page)] AS pageLinks

Example 9: Complex String Manipulation

// Format display names
MATCH (person:Person)
WITH person,
     split(person.fullName, " ") AS nameParts
RETURN person.fullName,
       left(nameParts[0], 1) + ". " + last(nameParts) AS shortName,
       toUpper(left(nameParts[0], 1) + left(last(nameParts), 1)) AS initials

Example 10: Trigonometry for Geo-coordinates

// Haversine formula for Earth distance
MATCH (p1:Place), (p2:Place)
WITH p1, p2,
     radians(p1.lat) AS lat1, radians(p1.lon) AS lon1,
     radians(p2.lat) AS lat2, radians(p2.lon) AS lon2
WITH p1, p2,
     haversin(lat2 - lat1) + cos(lat1) * cos(lat2) * haversin(lon2 - lon1) AS h
RETURN p1.name, p2.name,
       2 * 6371 * asin(sqrt(h)) AS distanceKm

Example 11: Real-Time News Sentiment → Stock Prediction (Kalman Filter)

An LLM watches the Associated Press news feed in real-time, scoring each headline's market sentiment (-1.0 to +1.0). The Kalman filter smooths these noisy signals to predict stock movements.

// Step 1: Create stock trackers with Kalman filtering
UNWIND ["AAPL", "MSFT", "GOOGL", "TSLA", "NVDA"] AS symbol
CREATE (s:Stock {
    symbol: symbol,
    kalmanState: kalman.velocity.init(),  // Track trends
    sentiment: 0.0,
    momentum: 0.0
})

// Step 2: LLM processes AP news headline and scores sentiment
// headline: "Apple announces record iPhone sales in China"
// $symbol = "AAPL", $sentimentScore = 0.72

// Step 3: Process the sentiment score through Kalman filter
MATCH (s:Stock {symbol: $symbol})
WITH s, kalman.velocity.process($sentimentScore, s.kalmanState) AS result
SET s.kalmanState = result.state,
    s.sentiment = result.value,
    s.momentum = result.velocity,
    s.lastUpdate = timestamp()
RETURN s.symbol,
       round(result.value * 100) / 100 AS smoothedSentiment,
       round(result.velocity * 100) / 100 AS sentimentTrend,
       CASE
           WHEN result.velocity > 0.1 THEN "📈 BULLISH"
           WHEN result.velocity < -0.1 THEN "📉 BEARISH"
           ELSE "➡️ NEUTRAL"
       END AS signal

// Step 4: Predict sentiment 5 time-steps ahead for all stocks
MATCH (s:Stock)
WHERE s.kalmanState IS NOT NULL
RETURN s.symbol,
       round(s.sentiment * 100) / 100 AS currentSentiment,
       round(s.momentum * 100) / 100 AS trend,
       round(kalman.velocity.predict(s.kalmanState, 5) * 100) / 100 AS predictedSentiment,
       CASE
           WHEN kalman.velocity.predict(s.kalmanState, 5) > s.sentiment + 0.15 THEN "🚀 BUY SIGNAL"
           WHEN kalman.velocity.predict(s.kalmanState, 5) < s.sentiment - 0.15 THEN "⚠️ SELL SIGNAL"
           ELSE "HOLD"
       END AS recommendation
ORDER BY abs(s.momentum) DESC

// Step 5: Find stocks about to cross sentiment threshold
MATCH (s:Stock)
WITH s,
     s.sentiment AS current,
     kalman.velocity.predict(s.kalmanState, 3) AS predicted
WHERE current < 0.7 AND predicted >= 0.7  // About to go strongly bullish
RETURN s.symbol, current, predicted, "🎯 BREAKOUT CANDIDATE" AS alert

Example 12: IoT Sensor Smoothing with Kalman

// Initialize temperature sensors with Kalman filtering
CREATE (s:Sensor {
    id: "greenhouse-temp-1",
    location: "Zone A",
    kalmanState: kalman.init({measurementNoise: 50.0})
})

// Process incoming temperature reading and smooth it
MATCH (s:Sensor {id: $sensorId})
WITH s, kalman.process($rawTemperature, s.kalmanState, 25.0) AS result
SET s.kalmanState = result.state,
    s.temperature = result.value,
    s.lastReading = timestamp()
RETURN s.id,
       $rawTemperature AS raw,
       round(result.value * 10) / 10 AS smoothed

// Alert on predicted overheating (predict 10 readings ahead)
MATCH (s:Sensor)
WHERE kalman.predict(s.kalmanState, 10) > 35.0
RETURN s.id, s.location,
       round(kalman.predict(s.kalmanState, 10) * 10) / 10 AS predictedTemp,
       "⚠️ Predicted overheat in ~10 readings" AS alert

Example 13: Adaptive Kalman for Volatile Time Series

// Use adaptive filter for crypto (high volatility) - auto-switches modes
CREATE (c:Crypto {
    symbol: "BTC",
    kalmanState: kalman.adaptive.init({
        trendThreshold: 0.05,   // Switch to velocity mode on 5% trend
        hysteresis: 5           // Quick adaptation
    })
})

// Process price data - filter auto-switches between smoothing and tracking
MATCH (c:Crypto {symbol: $symbol})
WITH c, kalman.adaptive.process($price, c.kalmanState) AS result
SET c.kalmanState = result.state,
    c.price = result.value,
    c.filterMode = result.mode
RETURN c.symbol,
       round(result.value) AS filteredPrice,
       result.mode AS currentMode,
       CASE result.mode
           WHEN "velocity" THEN "📊 Trending market - tracking momentum"
           ELSE "📉 Stable market - smoothing noise"
       END AS interpretation

Function Categories by Use Case

🔍 Data Inspection

id(), labels(), type(), keys(), properties()

🧹 Data Cleaning

trim(), toLower(), toUpper(), replace(), split()

🔄 Type Safety

toInteger(), toFloat(), toString(), toBoolean()

📊 Analytics

count(), avg(), sum(), min(), max()

🧮 Math & Stats

abs(), ceil(), floor(), round(), sqrt(), pow()

🗺️ Spatial/Geo

sin(), cos(), haversin(), atan2(), sqrt() (for distances)

🤖 AI/ML Features

vector.similarity.cosine(), vector.similarity.euclidean()

📈 Signal Processing & Prediction

kalman.init(), kalman.process(), kalman.predict()
kalman.velocity.init(), kalman.velocity.process(), kalman.velocity.predict()
kalman.adaptive.init(), kalman.adaptive.process()

🧠 Memory Management

Decay system functions (see Memory Decay System)

Performance Notes

Fast Functions (< 1μs)

id(), labels(), type()
toString(), toInteger(), toFloat()
toLower(), toUpper()

Medium Functions (1-10μs)

trim(), replace(), split()
abs(), ceil(), floor(), round()

Slower Functions (> 10μs)

sin(), cos(), tan() and other trig functions
sqrt(), exp(), log()
vector.similarity.*() - depends on vector size

Tips for Performance

Cache computed values instead of recalculating
Use indexes for WHERE clauses before function calls
Batch operations instead of per-node function calls
Pre-compute expensive math when possible

Common Patterns

Pattern: Case-Insensitive Search

MATCH (n)
WHERE toLower(n.name) = toLower($searchTerm)
RETURN n

Pattern: Safe Property Access

MATCH (n)
RETURN coalesce(n.optionalProperty, "default value") AS prop

Pattern: Parse CSV Data

MATCH (n:RawData)
WITH n, split(n.csvLine, ",") AS fields
CREATE (p:ParsedData {
    field1: trim(fields[0]),
    field2: toInteger(trim(fields[1])),
    field3: toFloat(trim(fields[2]))
})

Pattern: Calculate Age

MATCH (person:Person)
RETURN person.name,
       floor((timestamp() - person.birthTimestamp) / (365.25 * 24 * 60 * 60 * 1000)) AS age

Pattern: Vector Similarity Search

MATCH (doc:Document)
WHERE doc.embedding IS NOT NULL
WITH doc, vector.similarity.cosine(doc.embedding, $queryVector) AS score
WHERE score > 0.75
RETURN doc.title, score
ORDER BY score DESC
LIMIT 10

ELI12 Math Concepts

What is "Exponential"?

Think of exponential like a virus spreading. One person infects 2, those 2 infect 4, those 4 infect 8, then 16, 32, 64, 128... It doubles each time! That's exponential growth. Exponential DECAY is the opposite - things shrink by half each time (like memory fading).

What is "Logarithmic"?

Logarithmic is the opposite of exponential. If 2^10 = 1024, then log(1024) = 10. It asks "how many times do I multiply the base to get this number?" It grows really fast at first, then super slowly.

What is Cosine Similarity?

Imagine two arrows pointing in different directions. If they point the SAME way, they're very similar (score = 1). If they point OPPOSITE ways, they're very different (score = -1). If they're perpendicular (90°), they're unrelated (score = 0). It measures the ANGLE between two vectors, not their length!

What is Euclidean Distance?

This is just the straight-line distance between two points, like measuring with a ruler. If you're at (0,0) and your friend is at (3,4), the distance is sqrt(3² + 4²) = sqrt(9 + 16) = sqrt(25) = 5. It's the Pythagorean theorem!

What is a Kalman Filter?

Imagine you're trying to guess tomorrow's weather by asking 10 friends. Some say "sunny", some say "rainy" - it's confusing and noisy! The Kalman filter is like having a really smart friend who:

Remembers what everyone said yesterday (state tracking)
Notices if opinions are trending toward "sunny" or "rainy" (velocity)
Doesn't freak out when one person gives a weird answer (noise smoothing)
Uses all this to make a better prediction than any single friend

For stocks and news: Individual headlines are like those friends - some are right, some are wrong, some are just noise. One bad headline doesn't mean the stock will crash! The Kalman filter sees through the noise to find the real trend.

Basic vs Velocity vs Adaptive:

Basic (kalman.*): Just smooths noise. Good for stable measurements like temperature.
Velocity (kalman.velocity.*): Also tracks HOW FAST things are changing. Good for trends like stock sentiment.
Adaptive (kalman.adaptive.*): Auto-switches between modes. Good when you don't know if your signal will be stable or trending.

References & Further Reading

Memory Models

Atkinson-Shiffrin Model (1968) - Three-store memory model
Ebbinghaus Forgetting Curve (1885) - Exponential memory decay
Spaced Repetition - Optimal review timing for retention

Mathematical Functions

Khan Academy - Trigonometry basics
3Blue1Brown - Visual math explanations (YouTube)
Essence of Calculus - Understanding exponentials and logs

Vector Similarity

Cosine Similarity explained: https://en.wikipedia.org/wiki/Cosine_similarity
Euclidean vs Cosine - When to use which

Neo4j Cypher Reference

Official Neo4j Cypher manual
Neo4j function reference

Documentation Status: ✅ Complete
Functions Documented: 62/62 (100%)
Examples Provided: 160+
ELI12 Explanations: All math/science functions covered

Last Updated: November 29, 2025

FilesExpand file tree

cypher-functions

Directory actions

More options