@rsconcept/domain 2.1.2 → 2.3.0

package/src/library/rsform-api/analysis.ts

@@ -0,0 +1,157 @@
+/**
+ * Formal expression analysis against an RSForm schema.
+ */
+
+import { type Graph } from '../../graph';
+import { type AnalysisFull, RSErrorCode, ValueClass } from '../../rslang';
+import { extractGlobals } from '../../rslang/api';
+import { basic, bool, constant } from '../../rslang/semantic/typification';
+import { formatDependencyCycle, RSDiagnosticCode } from '../diagnostics';
+import { CstType, type RSForm } from '../rsform';
+
+import { canHaveFormalDefinition, typeClassForCstType } from './cst-type';
+
+export function getAnalysisFor(expression: string, cstType: CstType, schema: RSForm, alias?: string): AnalysisFull {
+  if (!canHaveFormalDefinition(cstType)) {
+    if (expression.trim().length === 0) {
+      const fallbackAlias = alias && alias.length > 0 ? alias : 'X0';
+      const type = cstType === CstType.BASE ? bool(basic(fallbackAlias)) : bool(constant(fallbackAlias));
+      return {
+        success: true,
+        type,
+        valueClass: ValueClass.VALUE,
+        errors: [],
+        ast: null
+      };
+    }
+    return {
+      success: false,
+      type: null,
+      valueClass: null,
+      errors: [
+        {
+          code: RSErrorCode.definitionNotAllowed,
+          from: 0,
+          to: Math.max(expression.length, 1),
+          params: [cstType, alias ?? '']
+        }
+      ],
+      ast: null
+    };
+  }
+  const analysis = schema.analyzer.checkFull(expression, {
+    expected: typeClassForCstType(cstType),
+    isDomain: cstType === CstType.STRUCTURED
+  });
+  return refineAnalysisForDependencyCycles(analysis, expression, schema, alias);
+}
+
+/**
+ * When an untyped / bare F·P reference names a constituent on a definition cycle with the
+ * current expression, replace that error with {@link RSDiagnosticCode.schemaDependencyCycle}.
+ *
+ * Covers both semantic `globalNotTyped` (e.g. `F3[σ]`) and parser `globalFuncWithoutArgs`
+ * (bare `P1` / `F1` treated as a call without arguments).
+ *
+ * Uses a draft dependency graph: incoming edges of the edited constituent are taken from
+ * `expression`, so Check works before Save.
+ */
+export function refineAnalysisForDependencyCycles(
+  analysis: AnalysisFull,
+  expression: string,
+  schema: RSForm,
+  alias?: string
+): AnalysisFull {
+  if (analysis.errors.length === 0 || !schema.graph) {
+    return analysis;
+  }
+
+  const currentId = alias ? schema.cstByAlias.get(alias)?.id : undefined;
+  const expressionGlobals = extractGlobals(expression);
+  const draftGraph =
+    currentId !== undefined ? buildDraftDependencyGraph(schema, currentId, expressionGlobals) : schema.graph;
+
+  let changed = false;
+  const errors = analysis.errors.map(error => {
+    if (error.code !== RSErrorCode.globalNotTyped && error.code !== RSErrorCode.globalFuncWithoutArgs) {
+      return error;
+    }
+    const missingAlias = error.params?.[0];
+    if (!missingAlias) {
+      return error;
+    }
+    const missing = schema.cstByAlias.get(missingAlias);
+    if (!missing) {
+      return error;
+    }
+    const cycleText = resolveDependencyCycleText(schema, draftGraph, currentId, missing.id);
+    if (!cycleText) {
+      return error;
+    }
+    changed = true;
+    return {
+      ...error,
+      code: RSErrorCode.schemaDependencyCycle,
+      params: [cycleText]
+    };
+  });
+  return changed ? { ...analysis, errors } : analysis;
+}
+
+/**
+ * Clone the schema graph and replace dependencies of `currentId` with globals from the
+ * expression under check (unsaved draft).
+ */
+function buildDraftDependencyGraph(schema: RSForm, currentId: number, expressionGlobals: ReadonlySet<string>): Graph {
+  const graph = schema.graph.clone();
+  const node = graph.at(currentId);
+  if (node) {
+    for (const parentId of [...node.inputs]) {
+      graph.removeEdge(parentId, currentId);
+    }
+  } else {
+    graph.addNode(currentId);
+  }
+  for (const globalAlias of expressionGlobals) {
+    const source = schema.cstByAlias.get(globalAlias);
+    if (source) {
+      graph.addEdge(source.id, currentId);
+    }
+  }
+  return graph;
+}
+
+/**
+ * Resolve formatted cycle text for an untyped global reference in analysis.
+ *
+ * Uses `graph` (often a draft graph built from the expression under check). When
+ * `currentId` is omitted, falls back to schema diagnostics on `missingId`.
+ *
+ * @returns Closed alias path such as `F3 → P1 → F3`, or `null` when no shared cycle exists.
+ */
+function resolveDependencyCycleText(
+  schema: RSForm,
+  graph: Graph,
+  currentId: number | undefined,
+  missingId: number
+): string | null {
+  for (const cycle of graph.findCycles()) {
+    const members = new Set(cycle);
+    if (!members.has(missingId)) {
+      continue;
+    }
+    if (currentId !== undefined && !members.has(currentId)) {
+      continue;
+    }
+    return formatDependencyCycle(cycle.map(id => schema.cstByID.get(id)?.alias ?? String(id)));
+  }
+
+  if (currentId === undefined) {
+    const cycleDiag = schema.cstByID
+      .get(missingId)
+      ?.diagnostics.find(item => item.code === RSDiagnosticCode.schemaDependencyCycle);
+    return cycleDiag?.params?.[0] ?? null;
+  }
+
+  return null;
+}

package/src/library/rsform-api/attribution.ts

@@ -0,0 +1,87 @@
+/**
+ * Attribution remapping helpers for substitution and schema embedding.
+ */
+
+import { type Attribution } from '../rsform';
+
+function attributionKey(attr: Attribution): string {
+  return `${attr.container}:${attr.attribute}`;
+}
+
+/**
+ * Remap attributions when constituents are substituted (original → replacement).
+ * Drops self-loops and duplicates. Matches sandbox / backend substitute attribution rewrite.
+ */
+export function remapAttributionsUnderSubstitution(
+  attributions: readonly Attribution[],
+  origToSub: ReadonlyMap<number, number>
+): Attribution[] {
+  const result: Attribution[] = [];
+  const seen = new Set<string>();
+
+  for (const attr of attributions) {
+    if (!origToSub.has(attr.container) && !origToSub.has(attr.attribute)) {
+      const key = attributionKey(attr);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push({ ...attr });
+      }
+      continue;
+    }
+
+    const container = origToSub.get(attr.container) ?? attr.container;
+    const attribute = origToSub.get(attr.attribute) ?? attr.attribute;
+    if (container === attribute) {
+      continue;
+    }
+    const key = `${container}:${attribute}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push({ container, attribute });
+  }
+
+  return result;
+}
+
+/**
+ * Copy attributions whose both endpoints are in {@link sourceIdSet}, remapping ids via {@link idMap}.
+ * Appends onto a clone of {@link existing} with dedupe. Used by schema embedding / insert.
+ */
+export function importAttributions(
+  sourceAttributions: readonly Attribution[],
+  sourceIdSet: ReadonlySet<number>,
+  idMap: Readonly<Record<number, number>>,
+  existing: readonly Attribution[] = []
+): Attribution[] {
+  const result = existing.map(attr => ({ ...attr }));
+  const seen = new Set(result.map(attributionKey));
+
+  for (const attr of sourceAttributions) {
+    if (!sourceIdSet.has(attr.container) || !sourceIdSet.has(attr.attribute)) {
+      continue;
+    }
+    const container = idMap[attr.container];
+    const attribute = idMap[attr.attribute];
+    if (container === undefined || attribute === undefined || container === attribute) {
+      continue;
+    }
+    const key = `${container}:${attribute}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push({ container, attribute });
+  }
+
+  return result;
+}
+
+/** Drop attributions that reference any id in {@link deletedIds}. */
+export function filterAttributions(
+  attributions: readonly Attribution[],
+  deletedIds: ReadonlySet<number>
+): Attribution[] {
+  return attributions.filter(attr => !deletedIds.has(attr.container) && !deletedIds.has(attr.attribute));
+}

package/src/library/rsform-api/cst-type.ts

@@ -0,0 +1,216 @@
+/**
+ * CstType classification, prefixes, and capability predicates.
+ */
+
+import { TypeClass, TypeID, type Typification } from '../../rslang';
+import { type EchelonFunctional, isTypification } from '../../rslang/semantic/typification';
+import { type Constituenta, CstClass, CstType } from '../rsform';
+
+/** Record of {@link CstType} prefixes. */
+const CST_TYPE_PREFIX: Record<CstType, string> = {
+  [CstType.NOMINAL]: 'N',
+  [CstType.BASE]: 'X',
+  [CstType.CONSTANT]: 'C',
+  [CstType.STRUCTURED]: 'S',
+  [CstType.AXIOM]: 'A',
+  [CstType.TERM]: 'D',
+  [CstType.FUNCTION]: 'F',
+  [CstType.PREDICATE]: 'P',
+  [CstType.STATEMENT]: 'T'
+};
+
+/** Record of {@link CstType} to {@link CstClass} mapping. */
+const CST_TYPE_TO_CLASS: Record<CstType, CstClass> = {
+  [CstType.NOMINAL]: CstClass.NOMINAL,
+  [CstType.BASE]: CstClass.BASIC,
+  [CstType.CONSTANT]: CstClass.BASIC,
+  [CstType.STRUCTURED]: CstClass.BASIC,
+  [CstType.TERM]: CstClass.DERIVED,
+  [CstType.FUNCTION]: CstClass.DERIVED,
+  [CstType.AXIOM]: CstClass.STATEMENT,
+  [CstType.PREDICATE]: CstClass.DERIVED,
+  [CstType.STATEMENT]: CstClass.STATEMENT
+};
+
+/** Prefix for alias indicating {@link CstType}. */
+export function getCstTypePrefix(type: CstType): string {
+  return CST_TYPE_PREFIX[type];
+}
+
+/** Guess {@link CstType} from user input hint. */
+export function guessCstType(hint: string): CstType | null {
+  if (hint.length !== 1) {
+    return null;
+  }
+  for (const [type, prefix] of Object.entries(CST_TYPE_PREFIX)) {
+    if (hint === prefix) {
+      return type as CstType;
+    }
+  }
+  return null;
+}
+
+/** Infers the {@link CstClass} based on the provided {@link CstType} and template status. */
+export function inferClass(type: CstType, isTemplate: boolean = false): CstClass {
+  if (isTemplate) {
+    return CstClass.TEMPLATE;
+  }
+  return CST_TYPE_TO_CLASS[type];
+}
+
+/** Check if {@link Constituenta} is a template or a category. */
+export function isTemplateCst(cst: Constituenta): boolean {
+  return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
+}
+
+/** Evaluate if {@link CstType} is basic concept. */
+export function isBasicConcept(type: CstType): boolean {
+  switch (type) {
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+      return true;
+
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+
+/** Evaluate if {@link CstType} is base set or constant set. */
+export function isBaseSet(type: CstType): boolean {
+  switch (type) {
+    case CstType.BASE:
+    case CstType.CONSTANT:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+
+/** Evaluate if {@link CstType} is a function. */
+export function isFunctional(type: CstType): boolean {
+  switch (type) {
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+
+/** Evaluate if {@link CstType} is logical. */
+export function isLogical(type: CstType): boolean {
+  switch (type) {
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+
+/** Evaluate if {@link CstType} can have manual typification. */
+export function canHaveManualTypification(type: CstType): boolean {
+  switch (type) {
+    case CstType.STRUCTURED:
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+
+/** Checks whether a constituenta type supports formal definitions. */
+export function canHaveFormalDefinition(cstType: CstType): boolean {
+  return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
+}
+
+/** Returns expected {@link TypeClass} of formal definition for {@link CstType}. */
+export function typeClassForCstType(cstType: CstType): TypeClass {
+  switch (cstType) {
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.TERM:
+      return TypeClass.typification;
+    case CstType.FUNCTION:
+      return TypeClass.function;
+    case CstType.PREDICATE:
+      return TypeClass.predicate;
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+      return TypeClass.logic;
+  }
+}
+
+/** Evaluate if {@link Constituenta} can be used produce structure. */
+export function canProduceStructure(cst: Constituenta): boolean {
+  switch (cst.cst_type) {
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+    case CstType.PREDICATE:
+      return false;
+  }
+  if (!cst.effectiveType) {
+    return false;
+  }
+  if (cst.cst_type === CstType.FUNCTION) {
+    const result = (cst.effectiveType as EchelonFunctional).result;
+    return typeCanProduceStructure(result);
+  }
+  if (!isTypification(cst.effectiveType)) {
+    return false;
+  }
+  return typeCanProduceStructure(cst.effectiveType as Typification);
+}
+
+function typeCanProduceStructure(type: Typification): boolean {
+  if (type.typeID === TypeID.basic || type.typeID === TypeID.integer || type.typeID === TypeID.anyTypification) {
+    return false;
+  } else if (type.typeID === TypeID.tuple) {
+    return true;
+  } else {
+    return (
+      type.base.typeID !== TypeID.basic &&
+      type.base.typeID !== TypeID.integer &&
+      type.base.typeID !== TypeID.anyTypification
+    );
+  }
+}

package/src/library/rsform-api/expression.ts

@@ -0,0 +1,73 @@
+/**
+ * Formal expression helpers: normalization, templates, status.
+ */
+
+import { type AstNode } from '../../parsing';
+import { ValueClass } from '../../rslang';
+import { generateExpressionFromAst, parseRSLangExpression } from '../../rslang/api';
+import { type ArgumentValue, type Constituenta, CstStatus, CstType } from '../rsform';
+
+import { isBasicConcept } from './cst-type';
+
+/** Infers the status of an expression based on parsing and value information. */
+export function inferStatus(parse: boolean, value?: ValueClass | null): CstStatus {
+  if (!parse) {
+    return CstStatus.INCORRECT;
+  }
+  if (value === null) {
+    return CstStatus.INCALCULABLE;
+  }
+  if (value === ValueClass.PROPERTY) {
+    return CstStatus.PROPERTY;
+  }
+  return CstStatus.VERIFIED;
+}
+
+/** Infers type of constituent for a given template and arguments. */
+export function inferTemplatedType(templateType: CstType, args: ArgumentValue[]): CstType {
+  if (args.length === 0 || args.some(arg => !arg.value)) {
+    return templateType;
+  } else if (templateType === CstType.PREDICATE) {
+    return CstType.AXIOM;
+  } else {
+    return CstType.TERM;
+  }
+}
+
+/**
+ * Normalize a RSLang expression for duplicate comparison.
+ *
+ * Returns `null` for basic concepts without formal definitions. Pass a pre-parsed `ast`
+ * when the expression was already analyzed to avoid re-parsing.
+ */
+export function normalizeExpression(expression: string, cst_type: CstType, ast?: AstNode | null): string | null {
+  if (isBasicConcept(cst_type) && cst_type !== CstType.AXIOM) {
+    return null;
+  }
+  const parsed = ast ?? parseRSLangExpression(expression);
+  let normalized = '';
+  if (parsed && !parsed.hasError) {
+    normalized = generateExpressionFromAst(parsed, { normalize: true });
+  } else {
+    normalized = expression;
+  }
+  normalized = normalized.replace(/\s+/g, '');
+  return normalized === '' ? null : normalized;
+}
+
+/** Checks if given expression is a template. */
+export function inferTemplate(expression: string): boolean {
+  const match = expression.match(/R\d+/g);
+  return (match && match?.length > 0) ?? false;
+}
+
+/** Apply filter based on start {@link Constituenta} type. */
+export function applyFilterCategory(start: Constituenta, items: Constituenta[]): Constituenta[] {
+  const startIndex = items.indexOf(start);
+  if (startIndex === -1) {
+    return [];
+  }
+  const nextCategoryIndex = items.findIndex((cst, index) => index > startIndex && cst.cst_type === CstType.STATEMENT);
+
+  return items.filter((_, index) => index >= startIndex && (nextCategoryIndex === -1 || index < nextCategoryIndex));
+}

package/src/library/rsform-api/formal-graph.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+
+import { CstType } from '../rsform';
+
+import { buildFormalDependencyGraph, restoreConstituentOrder } from './formal-graph';
+import { computeSemanticRelations } from './semantic-relations';
+import { type OrderableConstituenta } from './types';
+
+function cst(id: number, alias: string, cst_type: CstType, definition_formal = ''): OrderableConstituenta {
+  return { id, alias, cst_type, definition_formal };
+}
+
+describe('restoreConstituentOrder', () => {
+  it('keeps short lists unchanged', () => {
+    expect(restoreConstituentOrder([])).toEqual([]);
+    const only = [cst(1, 'X1', CstType.BASE)];
+    expect(restoreConstituentOrder(only)).toEqual(only);
+  });
+
+  it('matches classic kernel order with sticky semantic child', () => {
+    const items = [
+      cst(1, 'D2', CstType.TERM, 'D{ξ∈S1 | 1=1}'),
+      cst(2, 'D1', CstType.TERM, 'Pr1(S1)\\X1'),
+      cst(3, 'X1', CstType.BASE),
+      cst(4, 'X2', CstType.BASE),
+      cst(5, 'S1', CstType.STRUCTURED, 'ℬ(X1×X1)'),
+      cst(6, 'C1', CstType.CONSTANT),
+      cst(7, 'S2', CstType.STRUCTURED, 'ℬ(X2×D1)'),
+      cst(8, 'A1', CstType.AXIOM, 'D3=∅'),
+      cst(9, 'A2', CstType.AXIOM, 'P1[S1]'),
+      cst(10, 'D3', CstType.TERM, 'Pr2(S2)'),
+      cst(11, 'F1', CstType.FUNCTION, '[α∈ℬ(X1)] D{σ∈S1 | α⊆pr1(σ)}'),
+      cst(12, 'D4', CstType.TERM, 'Pr2(D3)'),
+      cst(13, 'F2', CstType.FUNCTION, '[α∈ℬ(X1)] X1\\α'),
+      cst(14, 'P1', CstType.PREDICATE, '[α∈ℬ(R1)] card(α)=0')
+    ];
+
+    const ordered = restoreConstituentOrder(items).map(item => item.alias);
+    expect(ordered).toEqual(['X1', 'X2', 'C1', 'P1', 'S1', 'A2', 'D1', 'S2', 'D3', 'A1', 'D4', 'D2', 'F1', 'F2']);
+  });
+
+  it('keeps formal supplier before semantic child (schema 875 pattern)', () => {
+    const items = [
+      cst(1, 'X1', CstType.BASE),
+      cst(2, 'C1', CstType.CONSTANT),
+      cst(3, 'P2', CstType.PREDICATE, '[σ∈ℬ(C1)] card(σ)=0'),
+      cst(4, 'P6', CstType.PREDICATE, '[σ∈ℬℬ(C1)] ∀ξ∈σ P2[ξ]'),
+      cst(5, 'F7', CstType.FUNCTION, '[σ∈ℬ(R1×R2)] Pr1(σ)'),
+      cst(6, 'F9', CstType.FUNCTION, '[β∈ℬ(R1×R2), α∈F7[β]] pr2(debool(Fi1[{α}](β)))'),
+      cst(7, 'F3', CstType.FUNCTION, '[σ∈D{σ0∈ℬ(ℬ(R1)×ℬ(C1)) | P6[pr2(σ0)]}] F7[σ]'),
+      cst(8, 'F4', CstType.FUNCTION, '[β∈D{β0∈ℬ(ℬ(R1)×ℬ(C1)) | P6[pr2(β0)]}, α∈F3[β]] F9[β,α]'),
+      cst(9, 'S1', CstType.STRUCTURED, 'ℬ(ℬ(X1)×ℬ(C1))'),
+      cst(10, 'A1', CstType.AXIOM, 'P6[ℬ(C1)]')
+    ];
+
+    const ordered = restoreConstituentOrder(items);
+    const aliases = ordered.map(item => item.alias);
+    expect(aliases.indexOf('P6')).toBeLessThan(aliases.indexOf('F3'));
+    expect(aliases.indexOf('F9')).toBeLessThan(aliases.indexOf('F4'));
+
+    const relations = computeSemanticRelations(items, buildFormalDependencyGraph(items));
+    expect(relations.parentOf.get(8)).toBe(4); // F4 → P6
+    expect(relations.childrenOf.get(4)).toEqual(expect.arrayContaining([7, 8]));
+  });
+
+  it('builds supplier → dependent formal edges', () => {
+    const items = [cst(1, 'X1', CstType.BASE), cst(2, 'D1', CstType.TERM, 'ℬ(X1)')];
+    const graph = buildFormalDependencyGraph(items);
+    expect(graph.hasEdge(1, 2)).toBe(true);
+    expect(graph.hasEdge(2, 1)).toBe(false);
+  });
+});