@rsconcept/domain 2.1.2 → 2.2.0

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);
+  });
+});

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

@@ -0,0 +1,195 @@
+/**
+ * Formal dependency graph and declaration-order restore for RSForm constituents.
+ */
+
+import { Graph } from '../../graph';
+import { extractGlobals } from '../../rslang/api';
+import { CstType } from '../rsform';
+
+import { computeSemanticRelations } from './semantic-relations';
+import { type OrderableConstituenta, type SemanticRelations } from './types';
+
+/**
+ * Build the formal dependency graph: supplier → dependent.
+ * Matches backend {@code RSForm.graph_formal}.
+ */
+export function buildFormalDependencyGraph(items: readonly OrderableConstituenta[]): Graph<number> {
+  const graph = new Graph<number>();
+  const byAlias = new Map(items.map(cst => [cst.alias, cst]));
+  for (const cst of items) {
+    graph.addNode(cst.id);
+  }
+  for (const cst of items) {
+    for (const alias of extractGlobals(cst.definition_formal)) {
+      const supplier = byAlias.get(alias);
+      if (supplier) {
+        graph.addEdge(supplier.id, cst.id);
+      }
+    }
+  }
+  return graph;
+}
+
+/**
+ * Reorder constituents: formal topology hard, semantic children sticky when ready,
+ * otherwise stable against type/kernel preferred ranks.
+ *
+ * One Kahn pass over the formal dependency graph.
+ */
+export function restoreConstituentOrder<T extends OrderableConstituenta>(
+  items: readonly T[],
+  graph: Graph<number> = buildFormalDependencyGraph(items),
+  relations: SemanticRelations = computeSemanticRelations(items, graph)
+): T[] {
+  if (items.length <= 1) {
+    return [...items];
+  }
+
+  const byId = new Map(items.map(cst => [cst.id, cst]));
+  const preferred = kernelPriority(items, graph, relations.parentOf);
+  const rank = new Map(preferred.map((cst, index) => [cst.id, index]));
+
+  const remainingInputs = new Map<number, number>();
+  for (const cst of preferred) {
+    const inputs = graph.at(cst.id)?.inputs ?? [];
+    remainingInputs.set(
+      cst.id,
+      inputs.reduce((count, src) => count + (rank.has(src) ? 1 : 0), 0)
+    );
+  }
+
+  const ready = new Set<number>();
+  for (const cst of preferred) {
+    if ((remainingInputs.get(cst.id) ?? 0) === 0) {
+      ready.add(cst.id);
+    }
+  }
+
+  const children = new Map<number, number[]>();
+  for (const cst of preferred) {
+    children.set(
+      cst.id,
+      (relations.childrenOf.get(cst.id) ?? []).filter(childId => rank.has(childId))
+    );
+  }
+
+  const result: T[] = [];
+  const pendingChildren: number[] = [];
+
+  function enqueueSticky(candidateIds: readonly number[]): void {
+    const sticky = candidateIds.filter(
+      childId => ready.has(childId) && !pendingChildren.includes(childId)
+    );
+    sticky.sort((left, right) => (rank.get(left) ?? 0) - (rank.get(right) ?? 0));
+    pendingChildren.push(...sticky);
+  }
+
+  function pickReady(): number {
+    while (pendingChildren.length > 0) {
+      const childId = pendingChildren.shift()!;
+      if (ready.has(childId)) {
+        return childId;
+      }
+    }
+    let best = -1;
+    let bestRank = Number.POSITIVE_INFINITY;
+    for (const nodeId of ready) {
+      const nodeRank = rank.get(nodeId) ?? Number.POSITIVE_INFINITY;
+      if (nodeRank < bestRank) {
+        best = nodeId;
+        bestRank = nodeRank;
+      }
+    }
+    return best;
+  }
+
+  while (ready.size > 0 || pendingChildren.length > 0) {
+    if (ready.size === 0) {
+      pendingChildren.length = 0;
+      continue;
+    }
+    const nodeId = pickReady();
+    ready.delete(nodeId);
+    result.push(byId.get(nodeId)!);
+
+    for (const dependentId of graph.at(nodeId)?.outputs ?? []) {
+      if (!remainingInputs.has(dependentId)) {
+        continue;
+      }
+      const next = (remainingInputs.get(dependentId) ?? 0) - 1;
+      remainingInputs.set(dependentId, next);
+      if (next === 0) {
+        ready.add(dependentId);
+      }
+    }
+
+    enqueueSticky(children.get(nodeId) ?? []);
+  }
+
+  if (result.length < preferred.length) {
+    const placed = new Set(result.map(cst => cst.id));
+    for (const cst of preferred) {
+      if (!placed.has(cst.id)) {
+        result.push(cst);
+      }
+    }
+  }
+
+  return result;
+}
+
+function kernelPriority<T extends OrderableConstituenta>(
+  items: readonly T[],
+  graph: Graph<number>,
+  parentOf: Map<number, number>
+): T[] {
+  const byId = new Map(items.map(cst => [cst.id, cst]));
+  const seen = new Set<number>();
+  const result: T[] = [];
+
+  function push(cst: T): void {
+    if (seen.has(cst.id)) {
+      return;
+    }
+    seen.add(cst.id);
+    result.push(cst);
+  }
+
+  for (const cst of items) {
+    if (cst.cst_type === CstType.BASE) {
+      push(cst);
+    }
+  }
+  for (const cst of items) {
+    if (cst.cst_type === CstType.CONSTANT) {
+      push(cst);
+    }
+  }
+  for (const cst of items) {
+    if ((graph.at(cst.id)?.inputs.length ?? 0) === 0) {
+      push(cst);
+    }
+  }
+
+  const kernelSeeds = items
+    .filter(cst => {
+      const parentId = parentOf.get(cst.id) ?? cst.id;
+      const parent = byId.get(parentId);
+      return (
+        cst.cst_type === CstType.STRUCTURED ||
+        cst.cst_type === CstType.AXIOM ||
+        parent?.cst_type === CstType.STRUCTURED
+      );
+    })
+    .map(cst => cst.id);
+  const kernel = new Set<number>([...kernelSeeds, ...graph.expandAllInputs(kernelSeeds)]);
+  for (const cst of items) {
+    if (kernel.has(cst.id)) {
+      push(cst);
+    }
+  }
+  for (const cst of items) {
+    push(cst);
+  }
+  return result;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Module: API for formal representation for systems of concepts.
+ */
+
+export {
+  addAliasReference,
+  applyMappingToConstituents,
+  argumentValuesToMapping,
+  generateAlias,
+  removeAliasReference,
+  validateAliasFormat,
+  validateNewAlias
+} from './alias';
+export { getAnalysisFor, refineAnalysisForDependencyCycles } from './analysis';
+export {
+  canHaveManualTypification,
+  canProduceStructure,
+  getCstTypePrefix,
+  guessCstType,
+  inferClass,
+  isBaseSet,
+  isBasicConcept,
+  isFunctional,
+  isLogical,
+  isTemplateCst,
+  typeClassForCstType
+} from './cst-type';
+export { applyFilterCategory, inferStatus, inferTemplate, inferTemplatedType, normalizeExpression } from './expression';
+export { restoreConstituentOrder } from './formal-graph';
+export { calculateSchemaStats, isSchemaIssue } from './stats';
+export { findCstByStructure, getStructureName, inferNewSpawnPosition } from './structure';
+export { sortItemsForInlineSynthesis } from './synthesis';

package/src/library/rsform-api/semantic-relations.ts

@@ -0,0 +1,117 @@
+/**
+ * Semantic parent/children used when restoring constituent order.
+ */
+
+import { type Graph } from '../../graph';
+import { extractGlobals, isSimpleExpression, splitTemplateDefinition } from '../../rslang/api';
+import { CstType } from '../rsform';
+
+import { isBaseSet, isFunctional } from './cst-type';
+import { inferTemplate } from './expression';
+import { type OrderableConstituenta, type SemanticRelations } from './types';
+
+/**
+ * Infer semantic parent/children used for clustering during restore order.
+ * Port of backend {@code SemanticInfo}.
+ */
+export function computeSemanticRelations(
+  items: readonly OrderableConstituenta[],
+  graph: Graph<number>
+): SemanticRelations {
+  const byId = new Map(items.map(cst => [cst.id, cst]));
+  const byAlias = new Map(items.map(cst => [cst.alias, cst]));
+  const isTemplate = new Map<number, boolean>();
+  const isSimple = new Map<number, boolean>();
+  const parentOf = new Map<number, number>();
+  const childrenOf = new Map<number, number[]>();
+
+  for (const cst of items) {
+    parentOf.set(cst.id, cst.id);
+    childrenOf.set(cst.id, []);
+  }
+
+  function needCheckHead(sources: Set<number>, head: string): boolean {
+    if (sources.size === 0) {
+      return true;
+    }
+    if (sources.size !== 1) {
+      return false;
+    }
+    const base = byId.get([...sources][0])!;
+    return !isFunctional(base.cst_type) || splitTemplateDefinition(base.definition_formal).head !== head;
+  }
+
+  function extractSources(target: OrderableConstituenta): Set<number> {
+    const sources = new Set<number>();
+    if (!isFunctional(target.cst_type)) {
+      for (const parentId of graph.at(target.id)?.inputs ?? []) {
+        if (!(isTemplate.get(parentId) && isSimple.get(parentId))) {
+          sources.add(parentOf.get(parentId) ?? parentId);
+        }
+      }
+      return sources;
+    }
+
+    const expression = splitTemplateDefinition(target.definition_formal);
+    for (const alias of extractGlobals(expression.body)) {
+      const parent = byAlias.get(alias);
+      if (!parent) {
+        continue;
+      }
+      if (!(isTemplate.get(parent.id) && isSimple.get(parent.id))) {
+        sources.add(parentOf.get(parent.id) ?? parent.id);
+      }
+    }
+    if (needCheckHead(sources, expression.head)) {
+      for (const alias of extractGlobals(expression.head)) {
+        const parent = byAlias.get(alias);
+        if (!parent) {
+          continue;
+        }
+        if (!isBaseSet(parent.cst_type) && !(isTemplate.get(parent.id) && isSimple.get(parent.id))) {
+          sources.add(parentOf.get(parent.id) ?? parent.id);
+        }
+      }
+    }
+    return sources;
+  }
+
+  function inferSimple(target: OrderableConstituenta): boolean {
+    if (target.cst_type === CstType.STRUCTURED || isBaseSet(target.cst_type)) {
+      return false;
+    }
+    const dependencies = graph.at(target.id)?.inputs ?? [];
+    if (dependencies.some(id => isTemplate.get(id) && !isSimple.get(id))) {
+      return false;
+    }
+    const expression = isFunctional(target.cst_type)
+      ? splitTemplateDefinition(target.definition_formal).body
+      : target.definition_formal;
+    return isSimpleExpression(expression);
+  }
+
+  for (const cstId of graph.topologicalOrder()) {
+    const cst = byId.get(cstId);
+    if (!cst) {
+      continue;
+    }
+    isTemplate.set(cstId, inferTemplate(cst.definition_formal));
+    isSimple.set(cstId, inferSimple(cst));
+    if (!isSimple.get(cstId) || cst.cst_type === CstType.STRUCTURED) {
+      continue;
+    }
+    const sources = extractSources(cst);
+    if (sources.size !== 1) {
+      continue;
+    }
+    const parentId = [...sources][0];
+    const parent = byId.get(parentId);
+    if (!parent || isBaseSet(parent.cst_type)) {
+      continue;
+    }
+    parentOf.set(cstId, parentId);
+    childrenOf.get(parentId)!.push(cstId);
+  }
+
+  return { parentOf, childrenOf };
+}