Fractal Algebra

Fractal Algebra is a Rust research crate for exploring generative, graph-based, and resonance-aware structures. The project blends geometric object construction, symbolic scoring, and evolutionary mutation into a single experimental framework.

The project exists to investigate a simple question: how do you represent, evolve, and compare structured patterns when the relationships between parts matter as much as the parts themselves?

The core ideas are simple:

• model complex patterns as structured collections of geometric edges,
• compare and score those patterns using lightweight signal or resonance heuristics,
• evolve them through mutation and critic-driven selection,
• and treat relationships between objects as part of the system itself.

This is not a polished numerical library in the strict scientific sense; it is best understood as a programmable research sandbox for fractal and graph-inspired experimentation.

Current status

The crate is active as a research prototype and now includes a small example suite demonstrating the main APIs.

Core concepts

FractalField

A geometric field structure built from a collection of graph edges. It supports basic algebraic operations such as addition, negation, and scalar multiplication.

FractalGraph

A directed graph for storing semantic relationships between nodes. It is designed for lightweight network-style experimentation, with edge types and complex-valued weights.

Resonance model

The resonance layer provides a way to score, compare, and classify patterns based on coherence-like heuristics. This is the more symbolic and exploratory part of the project, rather than a strict scientific model.

Evolutionary loop

The project includes a generator/critic loop for evolving candidate fields through mutation and weighted evaluation.

Getting started

The fastest way to understand the crate is to work from the core types outward:

1. build a FractalField,
2. connect nodes in a FractalGraph,
3. score candidates with a critic suite,
4. then explore resonance and transformation behavior.

Quick example

use fractal_algebra::FractalField;
use num_complex::Complex;

let base = FractalField::one();
let scaled = base.clone() * Complex::new(2.0, 0.5);
let combined = base + scaled;

println!("edge count: {}", combined.edges.len());
println!("signature: {:?}", combined.signature());

Examples

This project includes runnable examples in the repository:

cargo run --example 01_basic_field

cargo run --example 02_graph

cargo run --example 03_evolutionary

cargo run --example 04_resonance

These examples cover:

• constructing and scaling a basic field,
• creating a simple directed graph,
• running a generator/critic evolutionary loop,
• scoring and comparing resonance between fractal edges.

Design philosophy

The project is intentionally exploratory. It sits between formulaic algebra, procedural generation, and symbolic systems design. The abstractions are meant to be expressive and extensible rather than maximally minimal.

This produces a strong creative/research flavor, especially for:

• graph-based idea exploration,
• fractal-inspired generation,
• signal-like and resonance-like scoring,
• experimentation with structured symbolic systems.

Quick API map

If you want the fastest way to learn this crate, start here:

• FractalField — the core geometric/algebraic object
• FractalGraph — graph structure for semantic relationships
• FractalEdge — signal-like abstract edge with amplitude, location, and phase
• GeneratorCriticLoop — evolutionary search loop
• CriticSuite — weighted scoring and candidate selection
• ResonanceLaw — classification of resonance behavior
• PhaseShift — a simple resonance transform example

A good learning order is: FractalField → FractalGraph → GeneratorCriticLoop → FractalEdge + ResonanceLaw.

Best mental model

The project is essentially:

• geometry + graph structure
• combined with mutation and scoring
• and filtered through resonance-style semantics

So the “entry question” is not “what is the theorem?” but rather:

“How do I build a pattern, score it, and evolve it?”

That is the actual design center of the crate.

Roadmap

This project is best thought of as a research platform with a few clear directions:

• expand the example set around field generation, graph composition, and resonance scoring,
• tighten the public API around the most stable core abstractions,
• separate exploratory semantics from more reusable computational primitives,
• and keep the crate flexible enough for experimental iteration.

The near-term goal is not to become a massive, fully general framework, but to make the core concepts more legible and useful.

Related workspace projects

1. factorial_engine

A utility crate for efficient factorial-based number theory work, including prime-factor reasoning and related computations.

2. tma_engine

A geometry-oriented crate for affine/transformation work, useful for more classical fractal generation and iterative geometry systems.

Related crates

This crate is part of a broader collection of crates by the same author:

• MOMA
• MOMA_simulation_engine
• tma_engine
• factorial_engine
• fa_slow_ai
• Coheron

License

MIT or Apache License © Neil Crago

This crate is best viewed as a living research project: expressive, exploratory, and intentionally open-ended.