Andy.CK.Patterns 1.0.0

Andy Computable Knowledge

A .NET 10 implementation blueprint for a symbolic computational knowledge engine inspired by the public architectural principles behind Wolfram|Alpha and Wolfram Language.

This package is an implementation specification, not a claim of compatibility with or reproduction of proprietary Wolfram algorithms, datasets, parsers, ranking logic, or presentation rules.

Status

1.0.0. The engine answers a question asked in words, end to end, and can say where every number came from.

$ andy-ck "population density of France in 1990"
**88.0847 people per square kilometer**

*Exact:* 56709000/643801 People/Kilometers^2
*Approximately:* 88.0847 People/Kilometers^2
*Sources:* andy.ck.sample.geography (illustrative sample data, no onward licence)

Not included at 1.0

The engine is complete and the pipeline runs end to end, but a deployment needs more than an engine. These are named in each module's Boundary section rather than half-built:

The shipped domain data is a deliberately illustrative sample of 24 entities under clearly-marked sample sources — enough to exercise the engine end to end, and not a dataset to answer real questions from.

What the engine will not do

These are load-bearing decisions, each enforced by tests:

• It does not guess. A question no grammar form matches is reported as unrecognized. A property applied to the wrong kind of entity is rejected with its reason. A value the store does not hold leaves the query unevaluated.
• It does not fabricate provenance. Every answer carries the sources it rests on. The shipped datasets are illustrative approximations under clearly-marked sample sources — never attributed to a statistical office that did not publish them.
• It does not lose exactness quietly. Exact input gives exact output; an irrational result stays symbolic until N asks for digits; an inexact operand is what makes an operation inexact, and it is recorded when it happens.
• It does not invent conversions. Dollars and euros are separate dimensions, because an exchange rate is an observation on a date, not a definition.
• It does not read the clock. Recording instants, load instants, and as-of times are supplied by the caller, so the same query gives the same answer on any machine at any time.
• It does not need a language model. ICandidateProposer marks where one may propose candidates under ADR-003; nothing implements it, and every golden query is answered without one.

Quick start

var engine = ComputableKnowledgeEngine.Create(
    loadedAt: DateTimeOffset.Parse("2026-07-01T00:00:00Z"),
    new GeographyDomain(), new DemographicsDomain(), new EconomicsDomain());

var report = engine.Ask("GDP per capita of Germany versus France");
Console.WriteLine(new MarkdownReportRenderer().Render(report));

Getting started

Requires the .NET 10 SDK (see global.json).

If dotnet reports that .NET 10 is not installed when it is, the SDK is probably installed somewhere other than the one on your PATH — a per-user install under ~/.dotnet alongside a system one under /usr/local/share/dotnet, say. global.json pins the 10.0 band, so a dotnet that resolves to an older install reports the SDK as missing rather than falling back. Point the shell at the right one:

export DOTNET_ROOT="$HOME/.dotnet"
export PATH="$HOME/.dotnet:$PATH"
dotnet --version   # should print 10.0.x

./run-example does this for you and runs any of the examples: ./run-example lists them, ./run-example geometry runs one, ./run-example all runs every one.

dotnet restore
dotnet build -c Release
dotnet test -c Release

The engine has no runtime dependencies. Every package references only the base class library; the sole PackageReference in src/ is Microsoft.SourceLink.GitHub, which is build-time only. The exact numerics, algebra, calculus, statistics, and number theory are implemented here rather than taken from a numerics library, because those libraries are double-precision and the point of this one is exactness.

Benchmarks are development-time only, and are the one place a third-party dependency (BenchmarkDotNet) is allowed:

dotnet run -c Release --project benchmarks/Andy.CK.Benchmarks
dotnet run -c Release --project benchmarks/Andy.CK.Benchmarks -- --filter '*Numerics*'

Committed numbers are in docs/09-testing/03-performance-baseline.md.

See CONTRIBUTING.md for conventions and docs/INDEX.md for the documentation entry point.

Goals

The project provides a modular foundation for:

• typed symbolic expressions;
• immutable expression DAGs;
• deterministic evaluation;
• rule and pattern-based rewriting;
• exact and arbitrary-precision arithmetic;
• symbolic algebra and calculus;
• numerical computation;
• quantities, dimensions, dates, uncertainty, and missing values;
• computable entity knowledge;
• natural-language interpretation into typed symbolic programs;
• query planning and isolated execution;
• provenance-aware result composition;
• extensible computational domains.

Document map

Repository structure

andy-computable-knowledge/
├── README.md
├── docs/
├── examples/          runnable counterparts to docs/12-examples
├── benchmarks/        BenchmarkDotNet; development-time only
├── src/
│   ├── Andy.CK.Algebra
│   ├── Andy.CK.Calculus
│   ├── Andy.CK.Cli
│   ├── Andy.CK.Domains.Abstractions
│   ├── Andy.CK.Domains.Demographics
│   ├── Andy.CK.Domains.Economics
│   ├── Andy.CK.Domains.Geography
│   ├── Andy.CK.Engine
│   ├── Andy.CK.Entities
│   ├── Andy.CK.Evaluation
│   ├── Andy.CK.Execution
│   ├── Andy.CK.Expressions
│   ├── Andy.CK.Finance
│   ├── Andy.CK.Geometry
│   ├── Andy.CK.Knowledge.Persistence
│   ├── Andy.CK.Knowledge.Provenance
│   ├── Andy.CK.Knowledge.Schema
│   ├── Andy.CK.Knowledge.Store
│   ├── Andy.CK.Language
│   ├── Andy.CK.Numerics
│   ├── Andy.CK.Patterns
│   ├── Andy.CK.Planning
│   ├── Andy.CK.Platform
│   ├── Andy.CK.Presentation
│   ├── Andy.CK.Statistics
│   ├── Andy.CK.Symbols
│   ├── Andy.CK.Time
│   ├── Andy.CK.Units
│   └── Andy.CK.Workers
└── tests/

Twenty-nine packages, none with a runtime dependency.

Two more are named in the design and deliberately absent: Andy.CK.Api awaits the HTTP surface, and Andy.CK.Knowledge.Ingestion awaits the pipeline of docs/07-data/01-ingestion-pipeline.md. Andy.CK.Workers — ADR-005's worker isolation — now exists (the envelope protocol, the sandbox policy, and an out-of-process host); see the "Not included at 1.0" table above for exactly what it does and does not enforce. Each remaining gap is a boundary rather than an omission — see the table above and the open issues.

An earlier plan also named Andy.CK.Types, Andy.CK.Rewriting, Andy.CK.LinearAlgebra and Andy.CK.Optimization. The first three exist as capabilities inside Andy.CK.Symbols, Andy.CK.Patterns and Andy.CK.Calculus respectively, where they turned out to belong; optimization is not implemented at all.

Recommended implementation sequence

1. symbolic substrate;
2. evaluator;
3. pattern compiler;
4. numeric tower;
5. algebra and calculus;
6. units and time;
7. entity knowledge;
8. ingestion;
9. semantic interpretation;
10. planning and execution;
11. result composition;
12. domain expansion.