generate_built_in(Name/Arity) :-
    predicate_property(system:Head, built_in),
    functor(Head, Name, Arity),
    \+ sub_atom(Name, 0, _, _, $).   % discard reserved names

The predicate predicate_property/2 is covered by part-II of the ISO standard (modules). Although we are not aware of any Prolog system that implements part-II of the ISO standard, predicate_property/2 is available in most systems. There is little consensus on the implemented properties though. SWI-Prolog's auto loading feature further complicate this predicate.

Property is one of:

autoload(File)

True if the predicate can be autoloaded from the file File. Like undefined, this property is not generated.

built_in

True if the predicate is locked as a built-in predicate. This implies it cannot be redefined in its definition module and it can normally not be seen in the tracer.

defined

True if the predicate is defined. This property is aware of sources being reloaded, in which case it claims the predicate defined only if it is defined in another source or it has seen a definition in the current source. See compile_aux_clauses/1.

det

The predicate is defined to be deterministic using det/1.

discontiguous

True after discontiguous/1 was used to flag that the clauses of the predicates may not be contiguous.

dynamic

True if assert/1 and retract/1 may be used to modify the predicate. This property is set using dynamic/1.

exported

True if the predicate is in the public list of the context module.

imported_from(Module)

Is true if the predicate is imported into the context module from module Module.

file(FileName)

Unify FileName with the name of the source file in which the predicate is defined. See also source_file/2 and the property line_count. Note that this reports the file of the first clause of a predicate. A more robust interface can be achieved using nth_clause/3 and clause_property/2.

foreign

True if the predicate is defined in the C language.

implementation_module(-Module)

True when Module is the module in which Head is or will be defined. Resolving this property goes through the same search mechanism as when an undefined predicate is encountered, but does not perform any loading. It searches (1) the module inheritance hierarchy (see default_module/2) and (2) the autoload index if the unknown flag is not set to fail in the target module.

indexed(Indexes)

Indexes is a list of additional (hash) indexes on the predicate. Each element of the list is a dict holding the following keys:

arguments: List

1-based argument numbers of the predicate or compound used for the index.

position: List

1-based argument numbers to find the compound for a deep index. Empty list ([]) for predicate arguments. A list [1,2] implies we index on the 2nd argument of the 1st argument of the predicate, i.e., on the I in the head p(f(_,I))

buckets: Count

Number of buckets of the hash

list: Boolean

The hash is a deep index, i.e., it points at compounds and there may be sub-indexes on these compounds.

realised: Boolean

If false, the index is associated with the predicate but not filled. It will be filled if the predicate is called such that this index is at least ci_min_speedup times better than the best already realised index.

size: Bytes

Memory usage in bytes of the index.

speedup: Float

Estimated speedup. The basic value is the number of unique values in the argument of the clauses to which this index applies. The value is reduced when there are clauses with a variable in this position and when the standard deviation for the sets of clauses with the same value is high, i.e., we prefer indexes where the number of candidate clauses is similar, regardless of the value used in the call.

Note: This predicate property should be used for analysis and statistics only. The exact representation of Indexes may change between versions. The utilities jiti_list/0 jiti_list/1 list the jit indexes of matching predicates in a user friendly way.

interpreted

True if the predicate is defined in Prolog. We return true on this because, although the code is actually compiled, it is completely transparent, just like interpreted code.

iso

True if the predicate is covered by the ISO standard (ISO/IEC 13211-1).

line_count(LineNumber)

Unify LineNumber with the line number of the first clause of the predicate. Fails if the predicate is not associated with a file. See also source_file/2. See also the file property above, notably the reference to clause_property/2.

multifile

True if there may be multiple (or no) files providing clauses for the predicate. This property is set using multifile/1.

meta_predicate(Head)

If the predicate is declared as a meta-predicate using meta_predicate/1, unify Head with the head-pattern. The head-pattern is a compound term with the same name and arity as the predicate where each argument of the term is a meta-predicate specifier. See meta_predicate/1 for details.

mode(Head)

If the mode for the predicate is defined using mode/1. Head is a term as in the property meta_predicate(Head), but the specifiers are limited to +, - and ?.

monotonic

True if the predicate is tabled or dynamic using monotonic propagation. See section 7.8.

nodebug

Details of the predicate are not shown by the debugger. This is the default for built-in predicates. User predicates can be compiled this way using the Prolog flag generate_debug_info.

non_terminal

True if the predicate implements a grammar rule. See non_terminal/1.

notrace

Do not show ports of this predicate in the debugger.

number_of_clauses(ClauseCount)

Unify ClauseCount to the number of clauses associated with the predicate. Fails for foreign predicates. This property respects the logical update view and counts visible clauses at the moment the predicate was started.

number_of_rules(RuleCount)

Similar to number_of_clauses(ClauseCount), but only counts rules. A rule is defined as a clauses that has a body that is not just true (i.e., a fact).

last_modified_generation(Generation)

Database generation at which the predicate was modified for the last time. Intended to quickly assesses the validity of caches.

opaque

This property applies to dynamic and tabled predicates. For dynamic predicates it (temporary) stops propagating updates to dependent incrementally or monotonic tabled predicates. For tabled predicates it is not an error for an opaque predicate to depend on incremental or monotonic dynamic or tabled predicates.

public

Predicate is declared public using public/1. Note that without further definition, public predicates are considered undefined and this property is not reported.

quasi_quotation_syntax

The predicate (with arity 4) is declared to provide quasi quotation syntax with quasi_quotation_syntax/1.

size(Bytes)

Memory used for this predicate. This includes the memory of the predicate header, the combined memory of all clauses including erased but not yet garbage collected clauses (see garbage_collect_clauses/0 and clause_property/2) and the memory used by clause indexes (see the indexed(Indexes) property. Excluded are lingering data structures. These are garbage data structures that have been detached from the predicate but cannot yet be reclaimed because they may be in use by some thread.

ssu

The predicate has been defined using single sided unification rules. See section 5.6.

static

The definition can not be modified using assertz/1 and friends. This property is the opposite from dynamic, i.e., for each defined predicate, either static or dynamic is true but never both.

tabled

True of the predicate is tabled. The tabled(?Flag) property can be used to obtain details about how the predicate is tabled.

tabled(?Flag)

True of the predicate is tabled and Flag applies. Any tabled predicate has one of the mutually exclusive flags variant or subsumptive. In addition, tabled predicates may have one or more of the following flags

shared

The table is shared between threads. See section 7.9.

incremental

The table is subject to incremental tabling. See section 7.7

Use the tabled property to enumerate all tabled predicates. See table/1 for details.

thread_local

If true (only possible on the multithreaded version) each thread has its own clauses for the predicate. This property is set using thread_local/1.

transparent

True if the predicate is declared transparent using the module_transparent/1 or meta_predicate/1 declaration. In the latter case the property meta_predicate(Head) is also provided. See chapter 6 for details.

undefined

True if a procedure definition block for the predicate exists, but there are no clauses for it and it is not declared dynamic or multifile. This is true if the predicate occurs in the body of a loaded predicate, an attempt to call it has been made via one of the meta-call predicates, the predicate has been declared as e.g., a meta-predicate or the predicate had a definition in the past. Originally used to find missing predicate definitions. The current implementation of list_undefined/0 used cross-referencing. Deprecated.

visible

True when predicate can be called without raising a predicate existence error. This means that the predicate is (1) defined, (2) can be inherited from one of the default modules (see default_module/2) or (3) can be autoloaded. The behaviour is logically consistent iff the property visible is provided explicitly. If the property is left unbound, only defined predicates are enumerated.

volatile

If true, the clauses are not saved into a saved state by qsave_program/[1,2]. This property is set using volatile/1.