These examples give a working starting point for each major Kalika library. The generated TypeDoc pages document every exported symbol; this guide covers the primary functions and classes users should reach for first.
CAS, Algebra, and Analysis#
ts
import {
createSymmetricGroup,
characteristicPolynomial,
} from '@kalika/algebra';
import { complex, fft, inverseFft, ratioTest } from '@kalika/analysis';
import {
binomial,
catalanNumber,
integerPartitions,
} from '@kalika/combinatorics';
import {
createCategory,
object,
morphism,
productObject,
} from '@kalika/category-theory';
const s3 = createSymmetricGroup(3);
const characteristic = characteristicPolynomial([
[1n, 0n],
[0n, 2n],
]);
const signal = [complex(1), complex(0), complex(-1), complex(0)];
const spectrum = fft(signal);
const reconstructed = inverseFft(spectrum);
const harmonicVerdict = ratioTest((n) => 1 / (n + 1));
const combinations = binomial(10, 3);
const partitions = integerPartitions(6);
const catalan = catalanNumber(5);
const category = createCategory({
name: 'walking-arrow',
objects: [object('A'), object('B')],
morphisms: [morphism('f', 'A', 'B')],
});
const product = productObject(category, ['A', 'B']);
Number Theory and Topology#
ts
import {
isPrime,
factorInteger,
divisorSigma,
shortWeierstrassCurve,
} from '@kalika/number-theory';
import {
sphereCWComplex,
cellularHomology,
fundamentalGroup,
vietorisRipsFiltration,
persistenceDiagram,
} from '@kalika/topology';
const prime = isPrime(6700417n);
const factorization = factorInteger(1234567890n);
const divisorSum = divisorSigma(360n);
const curve = shortWeierstrassCurve(-1n, 0n);
const sphere = sphereCWComplex(2);
const homology = cellularHomology(sphere);
const pi1 = fundamentalGroup(sphere);
const filtration = vietorisRipsFiltration(
[
[0, 0],
[1, 0],
[0, 1],
],
1.5
);
const diagram = persistenceDiagram(filtration);
Physics Domains#
ts
import {
hydrogenAtomSolution,
harmonicOscillatorSolution,
} from '@kalika/quantum-mechanics';
import {
createGaugeTheoryModel,
createQftBenchmarkSuite,
productGaugeGroup,
summarizeQftBenchmark,
u1Group,
} from '@kalika/quantum-field-theory';
import {
schwarzschildPenroseDiagram,
createGrCurvatureBenchmarkSuite,
summarizeGrCurvatureBenchmark,
} from '@kalika/general-relativity';
import {
compactBinaryChirpMass,
lalSuiteWaveformCatalog,
} from '@kalika/gravitational-waves';
import {
PLANCK_2018_COSMOLOGY,
linearGrowthFactor,
starobinskyPredictions,
} from '@kalika/cosmology';
import { solveBcsGapEquation, hallConductance } from '@kalika/condensed-matter';
const hydrogen = hydrogenAtomSolution({ maxPrincipalQuantumNumber: 4 });
const oscillator = harmonicOscillatorSolution({ omega: 1, levels: 6 });
const standardModel = createGaugeTheoryModel(
'U1-demo',
productGaugeGroup('U1-demo-group', [u1Group()])
);
const qftBenchmarks = summarizeQftBenchmark(createQftBenchmarkSuite());
const schwarzschild = schwarzschildPenroseDiagram();
const grSummary = summarizeGrCurvatureBenchmark(
createGrCurvatureBenchmarkSuite()
);
const chirpMass = compactBinaryChirpMass({
mass1SolarMass: 36,
mass2SolarMass: 29,
});
const waveformApproximants = lalSuiteWaveformCatalog();
const inflation = starobinskyPredictions(55);
const growth = linearGrowthFactor(PLANCK_2018_COSMOLOGY, 1);
const bcs = solveBcsGapEquation({
coupling: 0.3,
cutoffEnergy: 1,
temperature: 0.01,
});
const conductance = hallConductance(1 / 3);
High-Energy, String, Lattice, and Quantum Gravity#
ts
import {
createPdgDatabase,
generateMssmSpectrum,
} from '@kalika/hep-phenomenology';
import {
coldGaugeField,
createHypercubicLattice,
hmcTrajectory,
wilsonPlaquetteAction,
} from '@kalika/lattice';
import {
sl2z,
transformAxioDilaton,
virasoroBracket,
} from '@kalika/string-theory';
import {
areaSpectrum,
findEinsteinHilbertFixedPoint,
} from '@kalika/quantum-gravity';
import { classifyLieAlgebra, quadraticCasimir } from '@kalika/lie-theory';
const pdg = createPdgDatabase();
const electron = pdg.get(11);
const spectrum = generateMssmSpectrum({
tanBeta: 10,
m0: 1000,
m12: 1000,
a0: 0,
signMu: 1,
});
const lattice = createHypercubicLattice([4, 4, 4, 4]);
const gaugeField = coldGaugeField(lattice);
const action = wilsonPlaquetteAction(gaugeField, 6);
const trajectory = hmcTrajectory(gaugeField, [], {
stepSize: 0.01,
steps: 20,
integrator: 'leapfrog',
});
const sDuality = sl2z(0, -1, 1, 0);
const transformedTau = transformAxioDilaton({ re: 0, im: 1 }, sDuality);
const virasoro = virasoroBracket(2, -2, 24);
const fixedPoint = findEinsteinHilbertFixedPoint();
const lqgArea = areaSpectrum({ nodes: [], edges: [] }, 'horizon');
const casimir = quadraticCasimir({ family: 'A', rank: 2 }, [1, 0]);
const lieType = classifyLieAlgebra('A2');
Numerical Methods, Probability, and Information Theory#
ts
import {
createDenseLinearAlgebraBenchmarkSuite,
createOdeBenchmarkSuite,
} from '@kalika/numerical';
import {
createMarkovChain,
normalDistribution,
nStepTransition,
} from '@kalika/probability';
import { concurrence, vonNeumannEntropy } from '@kalika/information-theory';
import { contractTensors, zeros } from '@kalika/tensor-networks';
import { createDenseNetwork, trainDenseNetwork } from '@kalika/neural-physics';
const denseBenchmarks = createDenseLinearAlgebraBenchmarkSuite();
const odeBenchmarks = createOdeBenchmarkSuite();
const normal = normalDistribution(0, 1);
const chain = createMarkovChain(
['sunny', 'rainy'],
[
[0.9, 0.1],
[0.2, 0.8],
]
);
const twoStep = nStepTransition(chain, 2);
const entropy = vonNeumannEntropy([
[0.5, 0],
[0, 0.5],
]);
const bellConcurrence = concurrence([1 / Math.SQRT2, 0, 0, 1 / Math.SQRT2]);
const tensor = zeros([2, 2], ['i', 'j']);
const contraction = contractTensors([tensor, tensor], {
outputLabels: ['i', 'j'],
});
const network = createDenseNetwork({
layerSizes: [2, 8, 1],
activation: 'tanh',
});
const trained = trainDenseNetwork(network, [{ input: [0, 0], target: [0] }], {
iterations: 10,
});
Data, Documents, and Rendering#
ts
import {
computeKalikaComputationCacheHash,
getKalikaDatabaseMigrations,
KALIKA_KNOWLEDGE_COLLECTION,
} from '@kalika/database';
import {
CitationManager,
InMemoryCitationDatabase,
exportCitations,
} from '@kalika/citations';
import {
buildDefaultKalikaOntology,
KnowledgeGraphQueryEngine,
} from '@kalika/knowledge-graph';
import {
renderLatexEquation,
exprToLatex,
draftPaperFromNotebook,
} from '@kalika/typesetting';
import {
plotFunctions,
plotSurface3D,
renderTensorNetworkDiagram,
} from '@kalika/renderer';
const cacheKey = computeKalikaComputationCacheHash({
inputExpression: 'integrate(sin(x), x)',
parameters: {},
libraryVersion: '0.1.0',
});
const migrations = getKalikaDatabaseMigrations();
const vectorCollection = KALIKA_KNOWLEDGE_COLLECTION;
const citationDb = new InMemoryCitationDatabase();
const citationManager = new CitationManager(citationDb);
const bibliography = exportCitations(
await citationManager.search({ query: 'Noether theorem' }),
'bibtex'
);
const ontology = buildDefaultKalikaOntology();
const graphQuery = new KnowledgeGraphQueryEngine({ ontology });
const answer = await graphQuery.answer('index theorem and Dirac operator');
const latex = exprToLatex({ kind: 'Symbol', name: 'x' });
const equation = renderLatexEquation({
latex: 'E = mc^2',
label: 'eq:mass-energy',
});
const draft = draftPaperFromNotebook({
title: 'Kalika Study',
cells: [{ id: 'intro', type: 'markdown', content: 'A short derivation.' }],
});
const plot = plotFunctions(
[{ id: 'sin', label: 'sin', expression: Math.sin }],
{
xDomain: { min: 0, max: Math.PI },
}
);
const surface = plotSurface3D({
id: 'sine-product',
z: (x, y) => Math.sin(x * y),
});
const diagram = renderTensorNetworkDiagram({ nodes: [], edges: [] });
SDK, Notebooks, Agents, and Verification#
ts
import { createKalikaSdk, evaluateNumericExpression } from '@kalika/sdk';
import {
createNotebookCell,
createNotebookDocument,
executeNotebookCell,
} from '@kalika/notebooks';
import {
LiteratureAgent,
detectMathematicalPatterns,
formulateConjectures,
summarizeConjectureGenerationBenchmark,
} from '@kalika/research-agents';
import {
translateKalikaExprToLean,
buildVerificationCandidates,
summarizeFormalVerificationBenchmark,
} from '@kalika/formal-verification';
import {
fitSymbolicRegression,
detectSeparability,
} from '@kalika/symbolic-regression';
const sdk = await createKalikaSdk();
const numeric = evaluateNumericExpression('sin(pi / 2)');
const simplified = sdk.simplify('x + x');
const cell = createNotebookCell({
id: 'cell-1',
type: 'code',
content: '2 + 2',
});
const notebook = createNotebookDocument({ title: 'Demo', cells: [cell] });
const execution = await executeNotebookCell(cell);
const literature = new LiteratureAgent({ fetch: fetch.bind(globalThis) });
const review = await literature.review({ query: 'Calabi-Yau mirror symmetry' });
const patterns = await detectMathematicalPatterns([
{ id: 'catalan-4', kind: 'sequence', invariants: { n: 4, value: 14 } },
{ id: 'catalan-5', kind: 'sequence', invariants: { n: 5, value: 42 } },
]);
const conjectures = formulateConjectures(patterns);
const conjectureBenchmark = summarizeConjectureGenerationBenchmark();
const lean = translateKalikaExprToLean({ kind: 'Symbol', name: 'x' });
const candidates = buildVerificationCandidates({ kind: 'Symbol', name: 'x' });
const verificationBenchmark = summarizeFormalVerificationBenchmark();
const regression = fitSymbolicRegression({
variables: ['x'],
samples: [
{ inputs: [1], target: 2 },
{ inputs: [2], target: 4 },
],
});
const separability = detectSeparability({
variables: ['x', 'y'],
samples: [
{ inputs: [1, 2], target: 3 },
{ inputs: [2, 4], target: 6 },
],
});
Units and Constants#
ts
import {
createDimension,
LENGTH_DIMENSION,
createPhysicalQuantity,
convertPhysicalQuantity,
getPhysicalConstant,
} from '@kalika/utils';
const velocityDimension = createDimension({ length: 1, time: -1 });
const distance = createPhysicalQuantity(
{ kind: 'IntegerLiteral', value: 3n },
LENGTH_DIMENSION
);
const siDistance = convertPhysicalQuantity(distance, 'si');
const c = getPhysicalConstant('speed-of-light-in-vacuum');