@rsconcept/domain 1.0.0

package/src/library/rsform.ts

@@ -0,0 +1,228 @@
+/**
+ * Module: Models for formal representation for systems of concepts.
+ */
+
+import { type Graph } from '../graph';
+import { type AnalysisBase, type ExpressionType, type RSLangAnalyzer, type TypePath } from '../rslang';
+
+import { type CurrentVersion, type LibraryItem, type LibraryItemReference, type VersionInfo } from './library';
+
+/** Represents {@link Constituenta} type. */
+export const CstType = {
+  NOMINAL: 'nominal',
+  BASE: 'basic',
+  STRUCTURED: 'structure',
+  TERM: 'term',
+  AXIOM: 'axiom',
+  FUNCTION: 'function',
+  PREDICATE: 'predicate',
+  CONSTANT: 'constant',
+  STATEMENT: 'statement'
+} as const;
+export type CstType = (typeof CstType)[keyof typeof CstType];
+
+/** Represents attribution of a {@link Constituenta} to another {@link Constituenta}. */
+export interface Attribution {
+  container: number;
+  attribute: number;
+}
+
+/** Represents global identifier type info. */
+export interface TypeInfo {
+  alias: string;
+  type: ExpressionType;
+}
+
+/** Represents function argument value. */
+export interface ArgumentValue {
+  alias: string;
+  typification: string;
+  value?: string;
+}
+
+/** Represents Constituenta classification in terms of system of concepts. */
+export const CstClass = {
+  NOMINAL: 'nominal',
+  BASIC: 'basic',
+  DERIVED: 'derived',
+  STATEMENT: 'statement',
+  TEMPLATE: 'template'
+} as const;
+export type CstClass = (typeof CstClass)[keyof typeof CstClass];
+
+/** Represents formal expression Status. */
+export const CstStatus = {
+  VERIFIED: 'verified',
+  INCORRECT: 'incorrect',
+  INCALCULABLE: 'incalculable',
+  PROPERTY: 'property',
+  UNKNOWN: 'unknown'
+} as const;
+export type CstStatus = (typeof CstStatus)[keyof typeof CstStatus];
+
+/** Represents substitution of {@link Constituenta}. */
+export interface Substitution {
+  original: number;
+  substitution: number;
+}
+
+/** Represents word form for natural language. */
+interface TermForm {
+  text: string;
+  tags: string;
+}
+
+/** Represents Constituenta. */
+export interface Constituenta {
+  id: number;
+  crucial: boolean;
+  alias: string;
+  convention: string;
+  cst_type: CstType;
+  definition_formal: string;
+  definition_raw: string;
+  definition_resolved: string;
+  term_raw: string;
+  term_resolved: string;
+  term_forms: TermForm[];
+  attributes: number[];
+
+  /** Manual typification of the constituent */
+  typification_manual: string;
+
+  /** Controls whether base concepts expose property values or full values */
+  value_is_property: boolean;
+
+  homonyms: number[];
+  formalDuplicates: number[];
+  analysis: AnalysisBase;
+
+  /** Typification used for dependents, model values, and display (manual when it overrides computed). */
+  effectiveType: ExpressionType | null;
+
+  /**
+   * True when manual typification is non-empty, parses to a type, and its label differs from the
+   * typification inferred from the formal definition ({@link Constituenta.analysis}.type).
+   */
+  is_type_mismatch: boolean;
+
+  /** Identifier of {@link LibraryItem} containing this {@link Constituenta}. */
+  schema: number;
+
+  /** {@link CstClass} of this {@link Constituenta}. */
+  cst_class: CstClass;
+  /** {@link CstStatus} of this {@link Constituenta}. */
+  status: CstStatus;
+
+  /** Indicates if this {@link Constituenta} is a template. */
+  is_template: boolean;
+  /** Indicates if this {@link Constituenta} has a simple expression. */
+  is_simple_expression: boolean;
+
+  /** Index of {@link LibraryItem} that contains this cst (or inheritance parent).
+   *  0 - not inherited, 1 - inherited by 1st schema, 2 - inherited by 2nd schema, etc.
+   */
+  parent_schema_index: number;
+  /** {@link LibraryItem} that contains parent of this inherited {@link Constituenta}. */
+  parent_schema: number | null;
+  /** Indicates if this {@link Constituenta} is inherited. */
+  is_inherited: boolean;
+  /** Indicates if this {@link Constituenta} has children that are inherited. */
+  has_inherited_children: boolean;
+
+  /** {@link Constituenta} that spawned this one. */
+  spawner?: number;
+  /** Alias of {@link Constituenta} that spawned this one. */
+  spawner_alias?: string;
+  /** Structure path that spawned this one. */
+  spawner_path?: TypePath;
+
+  /** List of {@link Constituenta} that are spawned by this one. */
+  spawn: number[];
+  /** List of aliases of {@link Constituenta} that are spawned by this one. */
+  spawn_alias: string[];
+}
+
+/** Represents {@link RSForm} statistics. */
+export interface RSFormStats {
+  step_complexity: number;
+
+  /** Total number of constituents in the RSForm. */
+  count_all: number;
+  /** Number of crucial constituents in the RSForm. */
+  count_crucial: number;
+
+  count_problematic: number;
+  /** Constituents that have same term. */
+  count_homonyms: number;
+  /** Constituents that have same formal definition and term. */
+  count_formal_duplicates: number;
+  /** Base constituents with no convention and alias. */
+  count_missing_convention: number;
+  /** Constituents with non-empty manual typification that disagrees with inferred typification. */
+  count_type_mismatch: number;
+
+  count_incorrect: number;
+  count_property: number;
+  count_incalculable: number;
+  count_inherited: number;
+
+  count_text_term: number;
+  count_definition: number;
+  count_convention: number;
+  count_comment: number;
+
+  count_base: number;
+  count_constant: number;
+  count_structured: number;
+  count_axiom: number;
+  count_term: number;
+  count_function: number;
+  count_predicate: number;
+  count_statement: number;
+  count_nominal: number;
+}
+
+/** Represents inheritance data for {@link RSForm}. */
+interface InheritanceInfo {
+  child: number;
+  child_source: number;
+  parent: number;
+  parent_source: number;
+}
+
+/** Represents formal explication for set of concepts. */
+export interface RSForm extends LibraryItem {
+  /** Whether this RSForm was produced (vs imported or inherited) */
+  is_produced: boolean;
+  /** Whether this RSForm has attribution feature */
+  is_attributive: boolean;
+  /** List of user IDs who can edit this RSForm */
+  editors: number[];
+  /** Information about the current version of this RSForm */
+  version: CurrentVersion;
+  /** Full version history of this RSForm */
+  versions: VersionInfo[];
+
+  /** Full list of constituents in the RSForm */
+  items: Constituenta[];
+  /** List of inheritance relationships between constituents */
+  inheritance: InheritanceInfo[];
+  /** List of constituent attribution relationships */
+  attribution: Attribution[];
+  /** References to Operational Schemes/Systems associated with the RSForm */
+  oss: LibraryItemReference[];
+  /** References to conceptual models associated with the RSForm */
+  models: LibraryItemReference[];
+
+  /** Analyzer instance for RS language features and validation */
+  analyzer: RSLangAnalyzer;
+  /** Graph structure representing formal dependencies between constituents */
+  graph: Graph;
+  /** Graph structure representing attribution relationships */
+  attribution_graph: Graph;
+  /** Map for quick lookup of constituents by alias */
+  cstByAlias: Map<string, Constituenta>;
+  /** Map for quick lookup of constituents by ID */
+  cstByID: Map<number, Constituenta>;
+}

package/src/library/rsmodel-api.ts

@@ -0,0 +1,340 @@
+import { type ExpressionType, TypeID, type Typification, type Value } from '../rslang';
+import { compare, tuple, TUPLE_ID, VALUE_TRUE, type ValuePath } from '../rslang/eval/value';
+import { extractValue, isTupleValue, makeDefaultValue, setNestedValue } from '../rslang/eval/value-api';
+import { type EchelonCollection } from '../rslang/semantic/typification';
+
+import { type RSEngine } from './rsengine';
+import { type Constituenta, CstType, type RSForm } from './rsform';
+import { calculateSchemaStats, isBaseSet, isBasicConcept } from './rsform-api';
+import { type BasicBinding, EvalStatus, type RSModelStats } from './rsmodel';
+
+const RANDOM_INTEGER_MIN = -100;
+const RANDOM_INTEGER_MAX = 100;
+const DEFAULT_RANDOM_SET_ELEMENTS_COUNT = 5;
+
+/** Evaluate if parsed data is a basic binding data. */
+export function validateBasicBindingData(data: unknown): data is Record<string, string> {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    return false;
+  }
+  return Object.entries(data).every(([key, value]) => typeof value === 'string' && Number.isInteger(Number(key)));
+}
+
+/** Convert parsed data to a basic binding. */
+export function toBasicBinding(data: Record<string | number, string>): BasicBinding {
+  const result: BasicBinding = {};
+  for (const [k, v] of Object.entries(data)) {
+    result[Number(k)] = v;
+  }
+  return result;
+}
+
+/** Evaluate if parsed data is a {@link Value} data. */
+export function validateValueData(data: unknown): data is Value {
+  if (typeof data === 'number') {
+    return Number.isFinite(data);
+  }
+  if (!Array.isArray(data)) {
+    return false;
+  }
+  return data.every(item => validateValueData(item));
+}
+
+export function generateRandomValue(
+  type: Typification,
+  basics: Map<number, BasicBinding>,
+  cstByAlias: Map<string, Constituenta>,
+  setElementsCount: number = DEFAULT_RANDOM_SET_ELEMENTS_COUNT
+): Value | null {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return Math.floor(Math.random() * (RANDOM_INTEGER_MAX - RANDOM_INTEGER_MIN + 1)) + RANDOM_INTEGER_MIN;
+    case TypeID.basic: {
+      const cst = cstByAlias.get(type.baseID);
+      const binding = cst ? basics.get(cst.id) : undefined;
+      const ids = Object.keys(binding ?? {}).map(Number);
+      if (ids.length === 0) {
+        return null;
+      }
+      return ids[Math.floor(Math.random() * ids.length)];
+    }
+    case TypeID.tuple: {
+      const factors: Value[] = [];
+      for (const factor of type.factors) {
+        const sample = generateRandomValue(factor, basics, cstByAlias, setElementsCount);
+        if (sample === null) {
+          return null;
+        }
+        factors.push(sample);
+      }
+      return tuple(factors);
+    }
+    case TypeID.collection: {
+      const result: Value[] = [];
+      const randomElementsCount = Math.floor(Math.random() * (setElementsCount + 1));
+      for (let i = 0; i < randomElementsCount; i++) {
+        const sample = generateRandomValue(type.base, basics, cstByAlias, setElementsCount);
+        if (sample === null) {
+          return null;
+        }
+        result.push(sample);
+      }
+      return result;
+    }
+    case TypeID.anyTypification:
+      return null;
+  }
+}
+
+/** Calculate statistics for {@link RSModel}. */
+export function calculateModelStats(schema: RSForm, engine: RSEngine, _engineGeneration?: number): RSModelStats {
+  const items = schema.items;
+  const statusByID = new Map<number, EvalStatus>();
+  for (const cst of items) {
+    statusByID.set(cst.id, engine.getCstStatus(cst.id));
+  }
+  return {
+    ...calculateSchemaStats(schema),
+    base_elements: items.reduce((sum, cst) => sum + countBaseElements(cst, engine), 0),
+    count_missing_base: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.EMPTY && isBasicConcept(cst.cst_type) ? 1 : 0),
+      0
+    ),
+    count_false_axioms: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.AXIOM_FALSE ? 1 : 0),
+      0
+    ),
+    count_invalid_data: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.INVALID_DATA ? 1 : 0),
+      0
+    ),
+    count_invalid_calculations: items.reduce(
+      (sum, cst) =>
+        sum +
+        (statusByID.get(cst.id) === EvalStatus.EVAL_FAIL || statusByID.get(cst.id) === EvalStatus.NOT_PROCESSED
+          ? 1
+          : 0),
+      0
+    ),
+    count_empty_terms: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.EMPTY && cst.cst_type === CstType.TERM ? 1 : 0),
+      0
+    )
+  };
+}
+
+/** Checks whether evaluation status contributes to model status issues. */
+export function isModelIssue(engine: RSEngine, cst: Constituenta): boolean {
+  const status = engine.getCstStatus(cst.id);
+  const isBasic = isBasicConcept(cst.cst_type);
+  return (
+    status === EvalStatus.EVAL_FAIL ||
+    status === EvalStatus.AXIOM_FALSE ||
+    status === EvalStatus.INVALID_DATA ||
+    (isBasic && status === EvalStatus.EMPTY)
+  );
+}
+
+/** Evaluate if {@link CstType} is interpretable. */
+export function isInterpretable(type: CstType): boolean {
+  switch (type) {
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.STATEMENT:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+
+/** Evaluate if {@link CstType} is inferrable. */
+export function isInferrable(type: CstType): boolean {
+  switch (type) {
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+    case CstType.TERM:
+      return true;
+
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+
+/** Infers status of a given {@link Value} and {@link CstType}. */
+export function inferEvalStatus(
+  value: Value | null,
+  cstType: CstType,
+  wasCalculated: boolean = true,
+  isInvalid: boolean = false
+): EvalStatus {
+  if (isBaseSet(cstType) || cstType === CstType.STRUCTURED) {
+    if (isInvalid) {
+      return EvalStatus.INVALID_DATA;
+    }
+    if (value === null || (Array.isArray(value) && value.length === 0)) {
+      return EvalStatus.EMPTY;
+    }
+    return EvalStatus.HAS_DATA;
+  }
+  if (!isInferrable(cstType)) {
+    return EvalStatus.NO_EVAL;
+  }
+  if (!wasCalculated) {
+    return EvalStatus.NOT_PROCESSED;
+  }
+  if (value === null) {
+    return EvalStatus.EVAL_FAIL;
+  }
+  if (cstType === CstType.AXIOM && value !== VALUE_TRUE) {
+    return EvalStatus.AXIOM_FALSE;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return EvalStatus.EMPTY;
+  }
+  return EvalStatus.HAS_DATA;
+}
+
+/** Tries to fix value removing invalid base elements not present in the target value.
+ * returns null if no fixing is possible.
+ * returns true if fixing was successful.
+ * returns false if fixing was not needed.
+ */
+export function tryFixValue(
+  value: Value,
+  type: ExpressionType,
+  targetAlias: string,
+  targetValue: Value[]
+): boolean | null {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return false;
+    case TypeID.basic:
+      if (type.baseID !== targetAlias) {
+        return false;
+      }
+      if (typeof value !== 'number') {
+        return null;
+      }
+      if (!targetValue.includes(value)) {
+        return null;
+      }
+      return false;
+    case TypeID.tuple: {
+      if (!isTupleValue(value)) {
+        return null;
+      }
+      let wasChanged = false;
+      for (let i = 0; i < type.factors.length; i++) {
+        const componentChanged = tryFixValue(value[i + 1], type.factors[i], targetAlias, targetValue);
+        if (componentChanged === null) {
+          return null;
+        }
+        if (componentChanged) {
+          wasChanged = true;
+        }
+      }
+      return wasChanged;
+    }
+    case TypeID.collection:
+      if (!Array.isArray(value) || (value.length > 1 && value[0] === TUPLE_ID)) {
+        return null;
+      }
+      let wasChanged = false;
+      const removeElements: Value[] = [];
+      for (const item of value) {
+        const elementChanged = tryFixValue(item, type.base, targetAlias, targetValue);
+        if (elementChanged === null || elementChanged === true) {
+          wasChanged = true;
+          if (elementChanged === null) {
+            removeElements.push(item);
+          }
+        }
+      }
+      for (const item of removeElements) {
+        const index = value.indexOf(item);
+        if (index !== -1) {
+          value.splice(index, 1);
+        }
+      }
+      if (wasChanged) {
+        value.sort((a, b) => compare(a, b));
+        let i = 1;
+        while (i < value.length) {
+          if (compare(value[i], value[i - 1]) === 0) {
+            value.splice(i, 1);
+          } else {
+            i++;
+          }
+        }
+      }
+      return wasChanged;
+
+    case TypeID.logic:
+    case TypeID.anyTypification:
+    case TypeID.predicate:
+    case TypeID.function:
+      return null;
+  }
+}
+
+export function updateValueElement(value: Value | null, path: ValuePath, newValue: number): Value | null {
+  return setNestedValue(value, path, newValue);
+}
+
+export function deleteValueElement(
+  value: Value | null,
+  path: ValuePath,
+  type: Typification,
+  target: number
+): Value | null {
+  if (path.length === 0 && type.typeID !== TypeID.collection) {
+    return null;
+  }
+
+  const arrayValue = extractValue(value!, path)! as Value[];
+  const updatedArray = [...arrayValue.slice(0, target), ...arrayValue.slice(target + 1)];
+  return setNestedValue(value, path, updatedArray);
+}
+
+export function addValueElement(
+  value: Value | null,
+  path: ValuePath,
+  type: Typification,
+  currentType: Typification
+): Value | null {
+  if (path.length === 0 && type.typeID !== TypeID.collection) {
+    return makeDefaultValue(type);
+  }
+
+  const newElem = makeDefaultValue((currentType as EchelonCollection).base);
+  const arrayValue = (extractValue(value!, path) as Value[] | null) ?? [];
+  const updatedArray = [newElem, ...arrayValue];
+  return setNestedValue(value, path, updatedArray);
+}
+
+// ========= Internal functions ==========
+
+function countBaseElements(cst: Constituenta, engine: RSEngine): number {
+  if (!isBasicConcept(cst.cst_type)) {
+    return 0;
+  }
+  const value = engine.getCstValue(cst.id);
+  if (value === null) {
+    return 0;
+  }
+  if (!Array.isArray(value) || value[0] === TUPLE_ID) {
+    return 1;
+  }
+  return value.length;
+}

package/src/library/rsmodel.ts

@@ -0,0 +1,50 @@
+import { type Value } from '../rslang';
+
+import { type LibraryItem } from './library';
+import { type RSFormStats } from './rsform';
+
+export const TYPE_BASIC = 'basic';
+
+/** Evaluation status enumeration. */
+export const EvalStatus = {
+  NO_EVAL: 1, // не вычисляется
+  NOT_PROCESSED: 2, // Интерпретация не вычислялась
+  INVALID_DATA: 3, // Неверные данные
+  EVAL_FAIL: 4, // Ошибка при вычислении
+  AXIOM_FALSE: 5, // Значение аксиомы = FALSE
+  EMPTY: 6, // Значение пусто
+  HAS_DATA: 7 // Интерпретация вычислена и не пуста
+} as const;
+export type EvalStatus = (typeof EvalStatus)[keyof typeof EvalStatus];
+
+/** Represents basic element binding. */
+export type BasicBinding = Record<number, string>;
+
+/** Represents {@link RSModel} basic sets binding. */
+export type BasicsContext = Map<number, BasicBinding>;
+
+/** Default value for structured data. */
+export const DEFAULT_VALUE_TEXT = 'N/A';
+
+interface RSModelData extends LibraryItem {
+  editors: number[];
+  schema: number;
+  items: {
+    id: number;
+    type: string;
+    value: Value | BasicBinding;
+  }[];
+}
+
+/** Represents {@link RSModel} structured data. */
+export type RSModel = RSModelData;
+
+/** Represents {@link RSModel} statistics. */
+export interface RSModelStats extends RSFormStats {
+  count_missing_base: number;
+  count_false_axioms: number;
+  count_invalid_data: number;
+  count_invalid_calculations: number;
+  count_empty_terms: number;
+  base_elements: number;
+}