eyeprolog 1.1.28 → 1.2.0

package/README.md

@@ -79,6 +79,27 @@ member_test ?- member(X, [prolog, logic]).
 ;  X = logic.
 ```
 
+## Strict ISO/IEC 13211-1 core
+
+For portability and conformance work, run the Part 1 core with Technical
+Corrigenda 1–3 in strict mode:
+
+```sh
+eyeprolog --iso-strict
+eyeprolog --iso-strict --goal 'p(X)' program.pl
+```
+
+The equivalent JavaScript option is `isoStrict: true`. Strict mode rejects
+EyeProlog language extensions, Part 2 module directives, and Part 3 grammar-rule
+expansion/`phrase/2-3`; it also removes the EyeProlog `occurs_check` flag and
+disables automatic tabling. Normal mode is unchanged and continues to support
+modules, DCGs, quads, libraries, proofs, and the other documented extensions.
+
+The auditable processor-requirement checklist lives in
+[`test/conformance/ISO-COMPLIANCE.md`](test/conformance/ISO-COMPLIANCE.md).
+EyeProlog does not yet claim independent certification or closure of every
+normative Part 1 requirement.
+
 ## ISO modules and definite clause grammars
 
 EyeProlog implements ISO/IEC 13211-2 modules and the grammar rules and

package/conformance-report.md

@@ -11,7 +11,7 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | builtins | 11 | 0 | 0 | 0 | 11 |
 | context | 11 | 0 | 0 | 0 | 11 |
 | control | 15 | 0 | 0 | 0 | 15 |
-| iso | 166 | 209 | 0 | 0 | 375 |
+| iso | 167 | 209 | 0 | 0 | 376 |
 | lists | 52 | 3 | 0 | 0 | 55 |
 | modules | 2 | 0 | 0 | 0 | 2 |
 | negation | 8 | 0 | 19 | 0 | 27 |
@@ -23,4 +23,4 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | terms | 26 | 3 | 0 | 0 | 29 |
 | unification | 18 | 0 | 0 | 0 | 18 |
 | variables | 16 | 9 | 0 | 0 | 25 |
-| **Total** | **481** | **260** | **19** | **21** | **781** |
+| **Total** | **482** | **260** | **19** | **21** | **782** |

package/index.d.ts

@@ -17,6 +17,8 @@ export interface EyePrologRunOptions {
   sourceMetadata?: boolean;
   strictNegation?: boolean;
   analyzeNegation?: boolean;
+  /** Restrict parsing and execution to ISO/IEC 13211-1:1995 plus Corrigenda 1-3. */
+  isoStrict?: boolean;
   /** Initial ISO interpretation of double-quoted list notation. Defaults to chars. */
   doubleQuotes?: 'chars' | 'codes' | 'atom';
   ioOptions?: {
@@ -120,6 +122,7 @@ export class Program {
   moduleImports: Map<string, Map<string, string>>;
   quads: EyePrologQuad[];
   doubleQuotes: 'chars' | 'codes' | 'atom';
+  strictIso: boolean;
   negationDependencies: Array<{ from: string; to: string; negative: boolean }>;
   negationStratificationErrors: Array<{ from: string; to: string }>;
   stratifiedNegation: boolean;
@@ -155,12 +158,14 @@ export class BuiltinRegistry {
   eyePrologLibrary?: boolean;
   add(name: string, arity: number, handler: BuiltinHandler, options?: Partial<BuiltinDefinition>): this;
   get(name: string, arity: number): BuiltinDefinition | null;
+  remove(name: string, arity: number): this;
 }
 
 export class Solver {
   constructor(program: Program, options?: EyePrologRunOptions);
   program: Program;
   registry: BuiltinRegistry;
+  isoStrict: boolean;
   maxDepth: number;
   depthLimitExceeded: boolean;
   maxInferences: number;
@@ -219,8 +224,10 @@ export function parseClauses(source: string, options?: EyePrologRunOptions): Arr
 export function parseProgramText(source: string, options?: EyePrologRunOptions): Array<EyePrologClause | EyePrologQuad>;
 export function parseGoalText(source: string, options?: EyePrologRunOptions): EyePrologTerm;
 export function createDefaultRegistry(): BuiltinRegistry;
+export function createStrictIsoRegistry(): BuiltinRegistry;
 export function createEyePrologRegistry(): BuiltinRegistry;
 export function getDefaultRegistry(): BuiltinRegistry;
+export function getStrictIsoRegistry(): BuiltinRegistry;
 export function getEyePrologRegistry(): BuiltinRegistry;
 export const standardLibrarySources: ReadonlyMap<string, { filename: string; source: string }>;
 export const eyePrologLibraryIndicators: readonly string[];
@@ -291,8 +298,10 @@ declare const eyeprolog: {
   parseGoalText: typeof parseGoalText;
   parseProgramText: typeof parseProgramText;
   createDefaultRegistry: typeof createDefaultRegistry;
+  createStrictIsoRegistry: typeof createStrictIsoRegistry;
   createEyePrologRegistry: typeof createEyePrologRegistry;
   getDefaultRegistry: typeof getDefaultRegistry;
+  getStrictIsoRegistry: typeof getStrictIsoRegistry;
   getEyePrologRegistry: typeof getEyePrologRegistry;
   standardLibrarySources: typeof standardLibrarySources;
   eyePrologLibraryIndicators: typeof eyePrologLibraryIndicators;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.1.28",
+  "version": "1.2.0",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",
@@ -49,6 +49,7 @@
     "generate": "node tools/extract-book-examples.mjs",
     "test:eyeprolog": "node test/run-all.mjs",
     "test:conformance": "node test/run-conformance.mjs",
+    "test:iso-strict": "node test/run-iso-strict.mjs",
     "test:examples": "node test/run-examples.mjs",
     "test:regression": "node test/run-regression.mjs",
     "test:playground": "node test/run-playground.mjs",

package/src/cli.js

@@ -26,6 +26,7 @@ export async function main(argv) {
     proof: false,
     quads: false,
     stats: false,
+    isoStrict: false,
     version: false,
     warnings: false,
     goals: [],
@@ -47,6 +48,8 @@ export async function main(argv) {
       options.quads = true;
     } else if (!endOptions && (arg === '--stats' || arg === '-s')) {
       options.stats = true;
+    } else if (!endOptions && arg === '--iso-strict') {
+      options.isoStrict = true;
     } else if (!endOptions && (arg === '--version' || arg === '-v')) {
       options.version = true;
     } else if (!endOptions && (arg === '--warnings' || arg === '-w')) {
@@ -81,6 +84,24 @@ export async function main(argv) {
     return;
   }
 
+  if (options.isoStrict && options.quads) {
+    throw new Error('--iso-strict cannot be combined with --quads');
+  }
+
+  if (options.isoStrict && options.files.length === 0 && options.goals.length === 0 &&
+      !options.proof && !options.stats && !options.warnings) {
+    const engine = await loadEngine();
+    const { runRepl } = await import('./repl.js');
+    const exitCode = await runRepl(engine, {
+      input: process.stdin,
+      output: process.stdout,
+      errorOutput: process.stderr,
+      isoStrict: true,
+    });
+    if (exitCode !== 0) process.exitCode = exitCode;
+    return;
+  }
+
   if (options.files.length === 0) {
     options.files.push('-');
   }
@@ -121,7 +142,10 @@ export async function main(argv) {
   }
 
   const engine = await loadEngine();
-  let program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof });
+  let program = engine.Program.parseSources(sourceParts, {
+    sourceMetadata: options.proof || options.isoStrict,
+    isoStrict: options.isoStrict,
+  });
 
   if (options.warnings) printWarnings(program);
 
@@ -156,15 +180,18 @@ async function loadExplanation() {
 }
 
 async function runDefault(engine, program, options) {
-  const registry = engine.getEyePrologRegistry();
+  const registry = options.isoStrict ? engine.getStrictIsoRegistry() : engine.getEyePrologRegistry();
   const solver = new engine.Solver(program, {
     registry,
+    isoStrict: options.isoStrict,
     ioOptions: { write: (text) => process.stdout.write(String(text)) },
   });
   program = solver.program;
   const goals = options.goals.map((text) => {
     const goal = engine.parseGoalText(text, {
       doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+      operatorDefinitions: [...program.operators.values()],
+      isoStrict: options.isoStrict,
     });
     if (goal.type === 'var') throw new engine.PrologError('instantiation_error');
     if (goal.type !== 'atom' && goal.type !== 'compound') throw new engine.PrologError('type_error(callable)', goal);
@@ -233,6 +260,8 @@ Options:
   -p, --proof           Enable proof explanations.
   -q, --quads           Run embedded quad tests and fail if any do not hold.
   -s, --stats           Print solver statistics to stderr after execution.
+  --iso-strict          Use ISO/IEC 13211-1 core + Corrigenda 1-3 only;
+                        reject EyeProlog language extensions and disable automatic tabling.
   -v, --version         Show the package version and exit.
   -w, --warnings        Print non-fatal portability warnings to stderr.
   -g, --goal goal       Solve goal and print its ground answers; may be repeated.

package/src/index.js

@@ -7,7 +7,9 @@ export * from './term.js';
 export {
   BuiltinRegistry,
   createDefaultRegistry,
+  createStrictIsoRegistry,
   getDefaultRegistry,
+  getStrictIsoRegistry,
   HaltSignal,
   PrologError,
 } from './iso.js';
@@ -26,16 +28,23 @@ import { ATOM, COMPOUND, VAR, Env, copyResolved, termIsGround } from './term.js'
 import { Program } from './program.js';
 import { Solver } from './solver.js';
 import { whyNoProof, whyProof } from './explain.js';
-import { HaltSignal, PrologError } from './iso.js';
+import { HaltSignal, PrologError, getStrictIsoRegistry } from './iso.js';
 import { getEyePrologRegistry } from './standard-library.js';
 import { parseGoalText } from './parser.js';
 import { formatTermForWrite } from './write.js';
 
 export function run(source, options = {}) {
   const includeWhy = options.proof === true || options.why === true || options.explain === true;
-  const parseOptions = { ...options, sourceMetadata: includeWhy };
+  const requestedStrictIso = options.isoStrict === true;
+  if (source instanceof Program && requestedStrictIso && source.strictIso !== true) {
+    throw new Error('strict ISO mode requires a Program parsed with isoStrict: true');
+  }
+  const parseOptions = { ...options, sourceMetadata: includeWhy || requestedStrictIso };
   let program = source instanceof Program ? source : Program.parse(source, parseOptions);
-  const runOptions = options.registry ? options : { ...options, registry: getEyePrologRegistry() };
+  const strictIso = requestedStrictIso || program.strictIso === true;
+  const runOptions = strictIso
+    ? { ...options, isoStrict: true, registry: getStrictIsoRegistry() }
+    : options.registry ? options : { ...options, registry: getEyePrologRegistry() };
   const output = [];
   const solver = new Solver(program, {
     ...runOptions,
@@ -91,6 +100,8 @@ function normalizeGoals(options, solver) {
     const goal = typeof requestedGoal === 'string'
       ? parseGoalText(requestedGoal, {
           doubleQuotes: solver.prologFlags.get('double_quotes')?.value?.name ?? 'chars',
+          operatorDefinitions: [...solver.program.operators.values()],
+          isoStrict: solver.isoStrict,
         })
       : requestedGoal;
     if (goal.type === VAR) throw new PrologError('instantiation_error');

package/src/iso.js

@@ -508,11 +508,18 @@ function* clauseBuiltin({ solver, goal, env }) {
   if (head.type !== ATOM && head.type !== COMPOUND) throw new PrologError('type_error(callable)', head);
   callableOrVariable(goal.args[1], env);
   const indicator = compound('/', [atom(head.name), numberTerm(head.arity)]);
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head)) {
     throw new PrologError('permission_error(access, private_procedure)', indicator);
   }
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
   if (!group) return;
+  // ISO 7.5.3 makes dynamic procedures public and static user-defined
+  // procedures private by default.  EyeProlog's normal profile keeps static
+  // clauses inspectable for proof tooling; strict core mode restores the ISO
+  // access rule used by clause/2.
+  if (solver.isoStrict && !group.dynamic) {
+    throw new PrologError('permission_error(access, private_procedure)', indicator);
+  }
   for (const clause of group.clauses) {
     const pair = compound('$clause', [clause.head, clauseBodyTerm(clause.body)]);
     const copied = freshCopy(pair, new Env());
@@ -547,13 +554,13 @@ function procedureIndicator(head) {
   return compound('/', [atom(head.name), numberTerm(head.arity)]);
 }
 
-function isGrammarRuleProcedure(head) {
-  return head.name === '-->' && head.arity === 2;
+function isGrammarRuleProcedure(solver, head) {
+  return !solver.isoStrict && head.name === '-->' && head.arity === 2;
 }
 
 function assertModifiable(solver, head, module = 'user') {
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? module);
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head) || (group && !group.dynamic)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
 }
@@ -580,7 +587,7 @@ function* retractBuiltin({ solver, goal, env }) {
   const parts = clauseParts(goal.args[0], env);
   requireClauseHead(parts.head);
   const group = solver.program.findGroup(parts.head.name, parts.head.arity, parts.head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(parts.head.name, parts.head.arity) || isGrammarRuleProcedure(parts.head) || (group && !group.dynamic)) {
+  if (solver.registry.get(parts.head.name, parts.head.arity) || isGrammarRuleProcedure(solver, parts.head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(parts.head));
   }
   if (!group) return;
@@ -603,7 +610,7 @@ function* retractAllBuiltin({ solver, goal, env }) {
   const head = deref(goal.args[0], env);
   requireClauseHead(head);
   const group = solver.program.findGroup(head.name, head.arity, head.module ?? goal.module ?? 'user');
-  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(head) || (group && !group.dynamic)) {
+  if (solver.registry.get(head.name, head.arity) || isGrammarRuleProcedure(solver, head) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', procedureIndicator(head));
   }
   if (group) {
@@ -637,7 +644,7 @@ function* abolishBuiltin({ solver, goal, env }) {
   const target = predicateIndicatorParts(goal.args[0], env);
   const module = goal.module ?? 'user';
   const group = solver.program.findGroup(target.name, target.arity, module);
-  if (solver.registry.get(target.name, target.arity) || isGrammarRuleProcedure(target) || (group && !group.dynamic)) {
+  if (solver.registry.get(target.name, target.arity) || isGrammarRuleProcedure(solver, target) || (group && !group.dynamic)) {
     throw new PrologError('permission_error(modify, static_procedure)', target.indicator);
   }
   solver.program.abolishDynamicGroup(target.name, target.arity, module);
@@ -2057,6 +2064,11 @@ export class BuiltinRegistry {
   get(name, arity) {
     return this.defs.get(`${name}/${arity}`) ?? null;
   }
+
+  remove(name, arity) {
+    this.defs.delete(`${name}/${arity}`);
+    return this;
+  }
 }
 
 export function createDefaultRegistry() {
@@ -2065,9 +2077,24 @@ export function createDefaultRegistry() {
   return registry;
 }
 
+// ISO/IEC 13211-1:1995 + Corrigenda 1-3 only.  phrase/2-3 and grammar-rule
+// expansion belong to the separate grammar-rule specification, while the
+// EyeProlog standard-library/CLP(Z) adapters are registered elsewhere.
+export function createStrictIsoRegistry() {
+  return createDefaultRegistry()
+    .remove('phrase', 2)
+    .remove('phrase', 3);
+}
+
 let defaultRegistry = null;
+let strictIsoRegistry = null;
 
 export function getDefaultRegistry() {
   if (defaultRegistry == null) defaultRegistry = createDefaultRegistry();
   return defaultRegistry;
 }
+
+export function getStrictIsoRegistry() {
+  if (strictIsoRegistry == null) strictIsoRegistry = createStrictIsoRegistry();
+  return strictIsoRegistry;
+}

package/src/parser.js

@@ -139,12 +139,16 @@ function defineParserOperator(state, priority, specifier, name) {
   }
 }
 
-export function createParserOperatorState(definitions = [], includeDefaults = true) {
+export function createParserOperatorState(definitions = [], includeDefaults = true, options = {}) {
   const state = {
     infixOperators: includeDefaults ? new Map(INFIX_OPERATORS) : new Map(),
     prefixOperators: includeDefaults ? new Map(PREFIX_OPERATORS) : new Map(),
     postfixOperators: new Map(),
   };
+  // The infix ?-/2 form is an EyeProlog quad extension.  ISO 13211-1
+  // predefines only the 1200 fx ?- operator; strict core mode starts from that
+  // table and still permits an explicit op/3 directive to add an infix form.
+  if (options.isoStrict === true) state.infixOperators.delete('?-');
   for (const definition of definitions) {
     const [priority, specifier, name] = Array.isArray(definition)
       ? definition
@@ -162,6 +166,7 @@ class Parser {
     this.line = 1;
     this.anonymous = 0;
     this.sourceMetadata = options.sourceMetadata !== false;
+    this.strictIso = options.isoStrict === true;
     this.parserFlagState = options.parserFlagState ?? {
       doubleQuotes: options.doubleQuotes ?? 'chars',
     };
@@ -171,6 +176,7 @@ class Parser {
     const operatorState = options.operatorState ?? createParserOperatorState(
       options.operatorDefinitions ?? [],
       options.includeDefaultOperators !== false,
+      { isoStrict: this.strictIso },
     );
     this.infixOperators = operatorState.infixOperators;
     this.prefixOperators = operatorState.prefixOperators;
@@ -685,6 +691,19 @@ class Parser {
     while (this.token.type !== TOK.EOF) {
       const line = this.token.line;
       if (this.operatorTokenName() === '?-') {
+        if (this.strictIso) {
+          // In Part 1, ?- is the predefined 1200 fx operator.  A strict-core
+          // source therefore reads it as an ordinary term rather than giving
+          // it EyeProlog's top-level quad meaning.
+          const head = this.parseTerm(0, true);
+          this.expect(TOK.DOT, '.');
+          this.advance();
+          const clause = { head, body: [] };
+          clauseNumber++;
+          if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
+          accept(clause);
+          continue;
+        }
         this.advance();
         this.parseQuad(null, line, accept);
         continue;
@@ -692,13 +711,19 @@ class Parser {
       if (this.token.type === TOK.IF) {
         this.advance();
         const directive = this.parseTerm();
-        const supportedDirective = directive.type === 'compound' && (
-          (['dynamic', 'multifile', 'discontiguous', 'initialization', 'include', 'ensure_loaded',
-            'use_module', 'meta_predicate'].includes(directive.name) && directive.arity === 1) ||
-          (['char_conversion', 'set_prolog_flag', 'module', 'use_module'].includes(directive.name) && directive.arity === 2)
+        const coreDirective = directive.type === 'compound' && (
+          (['dynamic', 'multifile', 'discontiguous', 'initialization', 'include', 'ensure_loaded'].includes(directive.name) && directive.arity === 1) ||
+          (['char_conversion', 'set_prolog_flag'].includes(directive.name) && directive.arity === 2)
         );
+        const extensionDirective = directive.type === 'compound' && (
+          (['use_module', 'meta_predicate'].includes(directive.name) && directive.arity === 1) ||
+          (['module', 'use_module'].includes(directive.name) && directive.arity === 2)
+        );
+        if (this.strictIso && extensionDirective) {
+          throw new Error(`parse line ${line}: implementation-specific directive ${directive.name}/${directive.arity} is not available in strict ISO core mode`);
+        }
         const operator = this.applyOperatorDirective(directive, line);
-        if (!supportedDirective && !operator) {
+        if (!coreDirective && !extensionDirective && !operator) {
           throw new Error(`parse line ${line}: bad term`);
         }
         this.expect(TOK.DOT, '.');
@@ -716,6 +741,22 @@ class Parser {
       }
       let head = this.parseTerm(3);
       if (this.operatorTokenName() === '?-') {
+        if (this.strictIso) {
+          // There is no predefined infix ?-/2 in strict core mode.  If a
+          // conforming source explicitly introduced one with op/3, read it as
+          // an ordinary operator term rather than as a quad label.
+          const info = this.infixOperators.get('?-');
+          if (!info) throw new Error(`parse line ${line}: expected ., got ?-`);
+          this.advance();
+          const right = this.parseTerm(info.associativity === 'right' ? info.precedence : info.precedence + 1, true);
+          const clause = { head: compound('?-', [head, right]), body: [] };
+          this.expect(TOK.DOT, '.');
+          this.advance();
+          clauseNumber++;
+          if (this.sourceMetadata) clause.source = { filename: this.filename, line, clause: clauseNumber };
+          accept(clause);
+          continue;
+        }
         this.advance();
         this.parseQuad(head, line, accept);
         continue;

package/src/program.js

@@ -10,7 +10,7 @@ import {
   parseClausesInto,
   tryParseClausesFastInto,
 } from './parser.js';
-import { PrologError } from './iso.js';
+import { PrologError, getStrictIsoRegistry } from './iso.js';
 import { currentWorkingDirectory, fs, path } from './platform.js';
 import { standardLibrarySources } from './standard-library.js';
 import { expandDcgRuleClause } from './dcg.js';
@@ -101,8 +101,12 @@ export class Program {
     this.moduleImports = new Map();
     this.moduleMetaPredicates = new Map();
     this.dynamicPredicates = new Set();
+    this.strictIso = options.isoStrict === true;
     this.operators = new Map();
-    for (const definitions of [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS]) {
+    const predefinedOperatorSets = this.strictIso
+      ? [ISO_OPERATOR_DEFINITIONS]
+      : [ISO_OPERATOR_DEFINITIONS, QUAD_OPERATOR_DEFINITIONS];
+    for (const definitions of predefinedOperatorSets) {
       for (const [priority, specifier, name] of definitions) {
         this.defineOperator(priority, specifier, name);
       }
@@ -162,7 +166,7 @@ export class Program {
   }
   _indexClause(clause, initialBuild) {
     const head = clause.head;
-    if (!initialBuild) assertHeadIsDefinable(head);
+    if (!initialBuild) assertHeadIsDefinable(head, this.strictIso);
     if (head.type !== ATOM && head.type !== COMPOUND) return;
     const module = clause.module ?? 'user';
     const key = modulePredicateKey(module, head.name, head.arity);
@@ -229,7 +233,7 @@ export class Program {
     if (group) group.metaArgumentPositions = positions;
   }
   ensureDynamicGroup(name, arity, module = 'user') {
-    assertPredicateIsDefinable(name, arity);
+    assertPredicateIsDefinable(name, arity, this.strictIso);
     const key = modulePredicateKey(module, name, arity);
     let group = this.groups.get(key);
     if (!group) {
@@ -280,7 +284,7 @@ export class Program {
   noteMutation(reanalyze = false) {
     this._revisionState.value++;
     this._negationAnalysis = null;
-    if (reanalyze) this.markRecursivePredicates();
+    if (reanalyze && !this.strictIso) this.markRecursivePredicates();
   }
   markRecursivePredicates() {
     // Recursion analysis drives automatic tabling and is always part of program setup.
@@ -467,7 +471,7 @@ export class Program {
 class ProgramBuilder {
   constructor(options = {}, program = null) {
     this.options = options;
-    this.program = program ?? new Program([], { [DEFER_PROGRAM_BUILD]: true });
+    this.program = program ?? new Program([], { ...options, [DEFER_PROGRAM_BUILD]: true });
     this.declaredDynamicIndicators = new Map();
     this.lastGroupKey = null;
     this.lastGroup = null;
@@ -491,7 +495,7 @@ class ProgramBuilder {
       program.clauses.push(clause);
 
       if (isCompactBinaryClause(clause)) {
-        assertPredicateIsDefinable(clause.headName, 2);
+        assertPredicateIsDefinable(clause.headName, 2, program.strictIso);
         const module = clause.module ?? 'user';
         const key = modulePredicateKey(module, clause.headName, 2);
         let group = key === lastGroupKey ? lastGroup : program.groups.get(key);
@@ -512,7 +516,7 @@ class ProgramBuilder {
       }
 
       if (!isDirectiveClause(clause)) {
-        assertHeadIsDefinable(clause.head);
+        assertHeadIsDefinable(clause.head, program.strictIso);
         const head = clause.head;
         if (head.type !== ATOM && head.type !== COMPOUND) continue;
         const module = clause.module ?? 'user';
@@ -546,7 +550,7 @@ class ProgramBuilder {
     const program = this.program;
     const module = clause.module ?? 'user';
     for (const indicator of dynamicDirectiveIndicators(clause)) {
-      assertDynamicIndicatorIsDefinable(indicator);
+      assertDynamicIndicatorIsDefinable(indicator, program.strictIso);
       const key = modulePredicateKey(module, indicator.name, indicator.arity);
       program.dynamicPredicates.add(key);
       this.declaredDynamicIndicators.set(key, { ...indicator, key, module });
@@ -597,7 +601,11 @@ class ProgramBuilder {
 
     // Static indexes are built while clauses stream into the builder. Dynamic
     // updates still rebuild only the affected predicate group.
-    program.markRecursivePredicates();
+    // Strict ISO core mode follows ordinary ISO clause selection rather than
+    // EyeProlog's automatic recursion guards, numeric recursion shortcuts, or
+    // tabled fixed points.  Leaving the recursion-planning fields at their
+    // neutral defaults preserves the standard depth-first execution model.
+    if (!program.strictIso) program.markRecursivePredicates();
     if (this.options.analyzeNegation === true || this.options.strictNegation === true) {
       program.analyzeNegationStratification();
     }
@@ -629,7 +637,7 @@ function buildProgramFromSources(sources, options) {
 function loadSourcesIntoBuilder(builder, sources, options, fast) {
   const ensured = new Set();
   const loadedModules = new Set();
-  const operatorState = createParserOperatorState();
+  const operatorState = createParserOperatorState([], true, { isoStrict: options.isoStrict === true });
   const parserFlagState = { doubleQuotes: options.doubleQuotes ?? 'chars' };
   const prepared = sources.map((source) => ({
     source,
@@ -686,7 +694,10 @@ function loadSourceIntoBuilder(builder, source, options, ensured, loadedModules,
       builder.addClauses([clause]);
       return;
     }
-    const grammarClause = expandDcgRuleClause(clause, context.module);
+    // Grammar-rule expansion belongs to ISO/IEC TS 13211-3 rather than the
+    // Part 1 strict-core language.  In strict core mode -->/2 remains the
+    // ordinary predefined operator term from Table 7 and is not rewritten.
+    const grammarClause = builder.program.strictIso ? null : expandDcgRuleClause(clause, context.module);
     if (grammarClause) clause = grammarClause;
     const moduleDeclaration = moduleDirective(clause);
     if (moduleDeclaration) {
@@ -911,16 +922,23 @@ function operatorDirective(clause) {
   };
 }
 
-function assertHeadIsDefinable(head) {
-  if (head.type === ATOM) assertPredicateIsDefinable(head.name, head.arity);
+function assertHeadIsDefinable(head, strictIso = false) {
+  if (head.type === ATOM || head.type === COMPOUND) {
+    assertPredicateIsDefinable(head.name, head.arity, strictIso);
+  }
 }
 
-function assertDynamicIndicatorIsDefinable(indicator) {
-  assertPredicateIsDefinable(indicator.name, indicator.arity);
+function assertDynamicIndicatorIsDefinable(indicator, strictIso = false) {
+  assertPredicateIsDefinable(indicator.name, indicator.arity, strictIso);
 }
 
-function assertPredicateIsDefinable(name, arity) {
-  if (name === 'false' && arity === 0) {
+function assertPredicateIsDefinable(name, arity, strictIso = false) {
+  // false/0 is standardized as a static built-in by Corrigendum 2 and cannot
+  // be redefined in either profile.  Strict core mode extends the same ISO
+  // rule to every Part-1 built-in/control construct; the normal EyeProlog
+  // profile keeps its historical source-compatibility behavior.
+  if ((name === 'false' && arity === 0) ||
+      (strictIso && (getStrictIsoRegistry().get(name, arity) || (name === ',' && arity === 2)))) {
     throw staticProcedureModificationError(name, arity);
   }
 }