# Kalika API Examples

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');
```
