feat: add standard LaTeX operators \ker, \dim, \deg, \hom with implicit arguments and update serialization

Author: arnog

CHANGELOG.md

@@ -315,6 +315,13 @@ ce.simplificationRules.push({
   arguments serialize as `\det A` instead of `\det\left(A\right)`. Matrix
   arguments still serialize as `\begin{vmatrix}...\end{vmatrix}`.
 
+- **Added standard LaTeX operators `\ker`, `\dim`, `\deg`, `\hom`**: These
+  commands are now in the MathJSON LaTeX dictionary as function entries with
+  implicit arguments, so forms like `\ker V`, `\dim V`, `\deg p`, and
+  `\hom(V, W)` parse correctly and serialize back to the corresponding standard
+  operator notation. The corresponding function symbols (`Kernel`, `Dimension`,
+  `Degree`, `Hom`) are also registered in the linear algebra library.
+
 ### LaTeX Parsing
 
 - **`arguments: 'implicit'` option for function dictionary entries**: Function

src/compute-engine/latex-syntax/dictionary/definitions-linear-algebra.ts

@@ -232,19 +232,58 @@ export const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary = [
     kind: 'function',
     latexTrigger: '\\tr',
     arguments: 'implicit',
-    serialize: (serializer: Serializer, expr: Expression): string => {
-      const arg = operand(expr, 1);
-      const argLatex = serializer.serialize(arg);
-      // Use \tr A for simple args, \tr\left(...\right) for complex ones
-      if (typeof arg === 'string' || typeof arg === 'number')
-        return `\\tr ${argLatex}`;
-      return `\\tr\\left(${argLatex}\\right)`;
-    },
+    serialize: (serializer: Serializer, expr: Expression): string =>
+      serializeImplicitOperator(serializer, expr, '\\tr'),
   },
 
   // Also support plain text: tr(A)
   { symbolTrigger: 'tr', kind: 'function', parse: 'Trace', arguments: 'implicit' },
 
+  {
+    name: 'Kernel',
+    kind: 'function',
+    latexTrigger: '\\ker',
+    arguments: 'implicit',
+    serialize: (serializer: Serializer, expr: Expression): string =>
+      serializeImplicitOperator(serializer, expr, '\\ker'),
+  },
+  { symbolTrigger: 'ker', kind: 'function', parse: 'Kernel', arguments: 'implicit' },
+
+  {
+    name: 'Dimension',
+    kind: 'function',
+    latexTrigger: '\\dim',
+    arguments: 'implicit',
+    serialize: (serializer: Serializer, expr: Expression): string =>
+      serializeImplicitOperator(serializer, expr, '\\dim'),
+  },
+  {
+    symbolTrigger: 'dim',
+    kind: 'function',
+    parse: 'Dimension',
+    arguments: 'implicit',
+  },
+
+  {
+    name: 'Degree',
+    kind: 'function',
+    latexTrigger: '\\deg',
+    arguments: 'implicit',
+    serialize: (serializer: Serializer, expr: Expression): string =>
+      serializeImplicitOperator(serializer, expr, '\\deg'),
+  },
+  { symbolTrigger: 'deg', kind: 'function', parse: 'Degree', arguments: 'implicit' },
+
+  {
+    name: 'Hom',
+    kind: 'function',
+    latexTrigger: '\\hom',
+    arguments: 'implicit',
+    serialize: (serializer: Serializer, expr: Expression): string =>
+      serializeImplicitOperator(serializer, expr, '\\hom'),
+  },
+  { symbolTrigger: 'hom', kind: 'function', parse: 'Hom', arguments: 'implicit' },
+
   {
     name: 'Determinant',
     kind: 'function',
@@ -262,11 +301,7 @@ export const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary = [
           stringValue(operand(arg, 2))
         );
       }
-      const argLatex = serializer.serialize(arg);
-      // Use \det A for simple args, \det\left(...\right) for complex ones
-      if (typeof arg === 'string' || typeof arg === 'number')
-        return `\\det ${argLatex}`;
-      return `\\det\\left(${argLatex}\\right)`;
+      return serializeImplicitOperator(serializer, expr, '\\det');
     },
   },
 
@@ -314,6 +349,21 @@ function parseColumnFormat(parser: Parser, optional = true): string {
   return result;
 }
 
+function serializeImplicitOperator(
+  serializer: Serializer,
+  expr: Expression,
+  command: string
+): string {
+  const args = operands(expr);
+  if (args.length !== 1) return `${command}${serializer.wrapArguments(expr)}`;
+  const arg = operand(expr, 1);
+  const argLatex = serializer.serialize(arg);
+  // Use \foo A for simple args, \foo\left(...\right) for complex ones
+  if (typeof arg === 'string' || typeof arg === 'number')
+    return `${command} ${argLatex}`;
+  return `${command}\\left(${argLatex}\\right)`;
+}
+
 function serializeTabular(
   serializer: Serializer,
   rows: ReadonlyArray<Expression>,

src/compute-engine/library/linear-algebra.ts

@@ -406,6 +406,30 @@ export const LINEAR_ALGEBRA_LIBRARY: SymbolDefinitions[] = [
       },
     },
 
+    Kernel: {
+      description: 'Kernel (null space) of a linear map',
+      complexity: 8200,
+      signature: '(value) -> value',
+    },
+
+    Dimension: {
+      description: 'Dimension of an object',
+      complexity: 8200,
+      signature: '(value) -> value',
+    },
+
+    Degree: {
+      description: 'Degree of an object',
+      complexity: 8200,
+      signature: '(value) -> value',
+    },
+
+    Hom: {
+      description: 'Hom-set of morphisms between objects',
+      complexity: 8200,
+      signature: '(value*) -> value',
+    },
+
     // Matrix multiplication: A (m×n) × B (n×p) → result (m×p)
     // Handles matrix × matrix, matrix × vector, vector × matrix
     MatrixMultiply: {

test/compute-engine/latex-syntax/linear-algebra.test.ts

@@ -245,3 +245,60 @@ describe('MatrixMultiply LaTeX', () => {
     );
   });
 });
+
+describe('Trace LaTeX', () => {
+  it('should serialize simple symbol argument without parentheses', () => {
+    const result = ce.box(['Trace', 'A']);
+    expect(result.latex).toBe('\\tr A');
+  });
+
+  it('should serialize simple numeric argument without parentheses', () => {
+    const result = ce.box(['Trace', 2]);
+    expect(result.latex).toBe('\\tr 2');
+  });
+
+  it('should serialize complex argument with parentheses', () => {
+    const result = ce.box(['Trace', ['Add', 'A', 'B']]);
+    expect(result.latex).toBe('\\tr\\left(A+B\\right)');
+  });
+});
+
+describe('Standard operator commands', () => {
+  it('should parse \\ker with implicit argument', () => {
+    expect(ce.parse('\\ker V').json).toEqual(['Kernel', 'V']);
+  });
+
+  it('should parse \\dim with implicit argument', () => {
+    expect(ce.parse('\\dim V').json).toEqual(['Dimension', 'V']);
+  });
+
+  it('should parse \\deg with implicit argument', () => {
+    expect(ce.parse('\\deg p').json).toEqual(['Degree', 'p']);
+  });
+
+  it('should parse \\hom with explicit argument list', () => {
+    expect(ce.parse('\\hom(V, W)').json).toEqual(['Hom', 'V', 'W']);
+  });
+});
+
+describe('Kernel/Dimension/Degree/Hom LaTeX', () => {
+  it('should serialize simple kernel argument without parentheses', () => {
+    const result = ce.box(['Kernel', 'V']);
+    expect(result.latex).toBe('\\ker V');
+  });
+
+  it('should serialize complex dimension argument with parentheses', () => {
+    const result = ce.box(['Dimension', ['Add', 'V', 'W']]);
+    expect(result.latex).toBe('\\dim\\left(V+W\\right)');
+  });
+
+  it('should serialize simple degree argument without parentheses', () => {
+    const result = ce.box(['Degree', 'p']);
+    expect(result.latex).toBe('\\deg p');
+  });
+
+  it('should serialize multiple hom arguments without dropping any', () => {
+    const result = ce.box(['Hom', 'V', 'W']);
+    expect(result.latex).toMatchInlineSnapshot(`\\hom(V, W)`);
+  });
+});