import init, { CohomologyEngine } from 'prime-radiant-advanced-wasm';

await init();

// Create coherence validator for 768-dim embeddings (e.g., sentence-transformers)
const coherence = new CohomologyEngine(768);

// Add retrieved documents as nodes
const docs = [
  { id: 'doc1', embedding: embed("The capital of France is Paris.") },
  { id: 'doc2', embedding: embed("Paris is known for the Eiffel Tower.") },
  { id: 'doc3', embedding: embed("Python is a programming language.") }  // outlier!
];

docs.forEach(doc => coherence.add_node(doc.id, doc.embedding));

// Connect documents based on retrieval order
coherence.add_edge('doc1', 'doc2', 0.9);  // high similarity
coherence.add_edge('doc2', 'doc3', 0.2);  // low similarity (incoherent!)

// Compute coherence energy (lower = more coherent)
const energy = coherence.sheaf_laplacian_energy();
console.log(`Coherence energy: ${energy}`);  // High energy indicates inconsistency

// Check cohomological obstruction
const h1 = coherence.compute_cohomology_dimension(1);
console.log(`H¹ dimension: ${h1}`);  // Non-zero indicates "holes" in coherence

import init, { SpectralEngine } from 'prime-radiant-advanced-wasm';

await init();

const spectral = new SpectralEngine();

// Build interaction graph (e.g., agent communication network)
['agent1', 'agent2', 'agent3', 'agent4'].forEach(id => spectral.add_node(id));

spectral.add_edge('agent1', 'agent2', 1.0);
spectral.add_edge('agent2', 'agent3', 1.0);
spectral.add_edge('agent3', 'agent4', 1.0);
spectral.add_edge('agent4', 'agent1', 1.0);  // ring topology

// Analyze stability
const fiedler = spectral.compute_fiedler_value();
const cheeger = spectral.compute_cheeger_constant();
const risk = spectral.predict_collapse_risk();

console.log(`Fiedler value (λ₂): ${fiedler}`);  // Low = weak connectivity
console.log(`Cheeger constant: ${cheeger}`);     // Low = easy to partition
console.log(`Collapse risk: ${(risk * 100).toFixed(1)}%`);

// Cheeger inequality: λ₂/2 ≤ h(G) ≤ √(2λ₂)
if (risk > 0.7) {
  console.warn('High collapse risk detected! Consider adding redundant connections.');
}

import init, { CausalEngine } from 'prime-radiant-advanced-wasm';

await init();

const causal = new CausalEngine();

// Define variables in the causal model
causal.add_variable('Treatment', true);   // observed
causal.add_variable('Outcome', true);     // observed
causal.add_variable('Confounder', true);  // observed
causal.add_variable('Mediator', true);    // observed

// Define causal structure (DAG)
causal.add_causal_edge('Confounder', 'Treatment');
causal.add_causal_edge('Confounder', 'Outcome');
causal.add_causal_edge('Treatment', 'Mediator');
causal.add_causal_edge('Mediator', 'Outcome');

// Check if causal effect is identifiable
const identifiable = causal.is_identifiable('Treatment', 'Outcome');
console.log(`Effect identifiable: ${identifiable}`);  // true

// Get adjustment set for backdoor criterion
const adjustmentSet = causal.get_adjustment_set('Treatment', 'Outcome');
console.log(`Adjust for: ${adjustmentSet}`);  // ['Confounder']

// Perform intervention do(Treatment=1)
causal.do_intervention('Treatment', 1.0);

// Compute Average Treatment Effect
const ate = causal.compute_ate('Treatment', 'Outcome');
console.log(`ATE: ${ate}`);

import init, { QuantumEngine } from 'prime-radiant-advanced-wasm';

await init();

const tda = new QuantumEngine();

// Add points (e.g., embedding vectors reduced to 2D/3D)
const points = [
  [0, 0], [1, 0], [0.5, 0.866],  // triangle
  [3, 0], [4, 0], [3.5, 0.866],  // another triangle
  [1.5, 0.433]  // bridge point
];

points.forEach(p => tda.add_point(new Float64Array(p)));

// Compute persistent homology up to dimension 1
const persistence = tda.compute_persistence(1);

console.log('Persistence pairs (birth, death):');
persistence.forEach(pair => {
  const lifetime = pair.death - pair.birth;
  console.log(`  H${pair.dimension}: [${pair.birth.toFixed(2)}, ${pair.death.toFixed(2)}] (lifetime: ${lifetime.toFixed(2)})`);
});

// Get Betti numbers at a specific scale
const betti = tda.get_betti_numbers(0.5);
console.log(`Betti numbers at ε=0.5: β₀=${betti[0]}, β₁=${betti[1]}`);
// β₀ = connected components, β₁ = 1-dimensional holes (loops)

import init, { CategoryEngine } from 'prime-radiant-advanced-wasm';

await init();

const cat = new CategoryEngine();

// Define objects (types)
cat.add_object('RawText');
cat.add_object('Tokens');
cat.add_object('Embeddings');
cat.add_object('Attention');
cat.add_object('Output');

// Define morphisms (transformations)
cat.add_morphism('tokenize', 'RawText', 'Tokens');
cat.add_morphism('embed', 'Tokens', 'Embeddings');
cat.add_morphism('attend', 'Embeddings', 'Attention');
cat.add_morphism('decode', 'Attention', 'Output');

// Compose transformations
const embed_then_attend = cat.compose('embed', 'attend');
console.log(`embed ; attend = ${embed_then_attend}`);

// Full pipeline composition
const tokenize_embed = cat.compose('tokenize', 'embed');
const full_pipeline = cat.compose(
  cat.compose(tokenize_embed, 'attend'),
  'decode'
);
console.log(`Full pipeline: RawText → Output`);

// Verify identity laws
const id_tokens = cat.identity('Tokens');
const should_equal_embed = cat.compose(id_tokens, 'embed');
console.log(`id_Tokens ; embed = embed: ${should_equal_embed === 'embed'}`);

import init, { HottEngine } from 'prime-radiant-advanced-wasm';

await init();

const hott = new HottEngine();

// Define types
hott.define_type('Nat', 'inductive(zero, succ)');
hott.define_type('Vec', 'dependent(Nat, Type)');
hott.define_type('List', 'inductive(nil, cons)');

// Type checking
const wellTyped = hott.check_type('succ(succ(zero))', 'Nat');
console.log(`2 : Nat is well-typed: ${wellTyped}`);  // true

// Path types (equality proofs)
// If we have a proof that n = m, we can transport properties
const path_2_eq_2 = hott.reflexivity('succ(succ(zero))');

// Transport: if P(n) and n = m, then P(m)
// This is the foundation of proof reuse
const transported = hott.transport(path_2_eq_2, 'property_at_2');
console.log('Transported proof successfully');

// Univalence: equivalent types can be treated as equal
// (A ≃ B) ≃ (A = B)
// This allows swapping implementations transparently