% Facts
human(socrates).
human(plato).

% Rules
mortal(X) :- human(X).

% Query
?- mortal(socrates).

% Unquoted atoms (start with lowercase)
hello
customer_service
product123
x

% Quoted atoms (any characters)
'Hello World'
'contains spaces'
'special-chars!'

X              % Regular variable
Name           % Descriptive variable
CustomerID     % CamelCase variable
_              % Anonymous variable (matches anything, not bound)
_Unused        % Named but intentionally unused

42             % Integer
-17            % Negative integer
3.14           % Float
-0.5           % Negative float
1.0e10         % Scientific notation

"hello world"           % Double-quoted string
"contains \"quotes\""   % Escaped quotes
"line1\nline2"          % Escape sequences

atom           % Atom constant
42             % Integer constant
3.14           % Float constant
"string"       % String constant

X              % Unbound variable
_              % Anonymous variable

person(john, 30)                    % Functor with arguments
node(left(a), right(b))             % Nested structure
pair(X, Y)                          % With variables
address(city("NYC"), zip(10001))    % Complex nesting

[]                        % Empty list
[a, b, c]                 % List of atoms
[1, 2, 3]                 % List of integers
[X, Y, Z]                 % List of variables
[Head | Tail]             % Head/tail decomposition
[A, B | Rest]             % First two elements + rest
[[1,2], [3,4]]            % Nested lists

predicate(arg1, arg2, ...)

human(socrates)
parent(tom, mary)
age(john, 30)
product(wide_awake, eye_cream)

human(X) & mortal(X)          % Using &
human(X), mortal(X)           % Using ,
parent(X, Y) & parent(Y, Z)   % Grandparent pattern

male(X) | female(X)           % Using |
cat(X) ; dog(X)               % Using ;

Head :- Body                  % Prolog-style rule
human(X) -> mortal(X)         % Arrow notation
A <-> B                       % Biconditional (iff)

~positive(X)                  % Classical negation (strong)
\+ found(X)                   % Negation as failure (weak)
not(present(X))               % Alternative NAF syntax

human(socrates).
product(wide_awake, eye_cream).
return_window_days(30).
prohibited_phrase("contact the manufacturer").
~ships_internationally.           % Negative fact

% Basic rule
mortal(X) :- human(X).

% Rule with conjunction
grandparent(X, Z) :- parent(X, Y) & parent(Y, Z).

% Rule with disjunction
animal(X) :- cat(X) | dog(X) | bird(X).

% Rule with negation
eligible(X) :- member(X) & ~suspended(X).

% Rule with comparison
adult(X) :- age(X, Age) & Age >= 18.

% Complex rule
response_valid(R) :-
    ~response_invalid(R) &
    ~contains_internal_reasoning(R) &
    ~promises_replacement(R).

?- mortal(socrates).              % Yes/no query
?- parent(X, mary).               % Find X
?- ancestor(X, Y).                % Find all pairs
?- age(john, Age), Age > 18.      % Query with condition

X = Y                  % Unify X and Y
X \= Y                 % X and Y do not unify
X == Y                 % X and Y are identical
X \== Y                % X and Y are not identical

atom(X)                % X is an atom
number(X)              % X is a number
integer(X)             % X is an integer
float(X)               % X is a float
compound(X)            % X is a compound term
is_list(X)             % X is a list
var(X)                 % X is unbound
nonvar(X)              % X is bound
ground(X)              % X contains no variables

X is Expr              % Evaluate Expr and bind to X

% Examples:
Sum is 2 + 3.          % Sum = 5
Prod is X * Y.         % Prod = X * Y
Mod is 17 mod 5.       % Mod = 2

abs(X)                 % Absolute value
min(X, Y)              % Minimum
max(X, Y)              % Maximum
sqrt(X)                % Square root
X ** Y                 % Power (X^Y)
sin(X), cos(X), tan(X) % Trigonometric
log(X), exp(X)         % Logarithm, exponential
floor(X), ceiling(X)   % Rounding
round(X)               % Round to nearest integer

!                      % Cut (commit to current choice)
true                   % Always succeeds
false                  % Always fails
fail                   % Always fails

member(X, [a, b, c])           % X = a; X = b; X = c
member(b, [a, b, c])           % true
member(d, [a, b, c])           % false

append([1,2], [3,4], Result)   % Result = [1,2,3,4]
append(X, [4,5], [1,2,3,4,5])  % X = [1,2,3]
append(X, Y, [a,b,c])          % Generate all splits

length([a,b,c], N)             % N = 3
length(L, 5)                   % L = [_,_,_,_,_]

reverse([1,2,3], R)            % R = [3,2,1]

nth0(0, [a,b,c], X)            % X = a (0-indexed)
nth1(1, [a,b,c], X)            % X = a (1-indexed)
nth0(Index, [a,b,c], b)        % Index = 1

last([a,b,c], X)               % X = c

sort([3,1,2,1], S)             % S = [1,2,3] (removes duplicates)
msort([3,1,2,1], S)            % S = [1,1,2,3] (keeps duplicates)

sumlist([1,2,3,4], Sum)        % Sum = 10

flatten([[1,2],[3,[4,5]]], F)  % F = [1,2,3,4,5]

permutation([1,2,3], P)        % P = [1,2,3]; P = [1,3,2]; ...

X is 2 + 3.                    % X = 5
Y is X * 2.                    % Y = 10
Z is sqrt(16).                 % Z = 4.0

X < Y                          % X less than Y
X > Y                          % X greater than Y
X =< Y                         % X less than or equal to Y
X >= Y                         % X greater than or equal to Y
X =:= Y                        % X arithmetically equal to Y
X =\= Y                        % X arithmetically not equal to Y

% Check if adult
adult(Person) :-
    age(Person, Age),
    Age >= 18.

% Calculate discount
final_price(Product, Price) :-
    base_price(Product, Base),
    discount(Product, Percent),
    Price is Base * (100 - Percent) / 100.

% Factorial (recursive)
factorial(0, 1).
factorial(N, F) :-
    N > 0,
    N1 is N - 1,
    factorial(N1, F1),
    F is N * F1.

% Hard constraint: Never say prohibited phrases
response_invalid(R) :-
    prohibited_phrase(P) &
    contains_text(R, P).

% Soft preference: Include link when relevant
should_include_link(R, Link) :-
    topic_detected(R, Topic) &
    required_link(Topic, Link) &
    ~contains_text(R, Link).

{
  "id": "no_prohibited_phrases",
  "description": "Response must not contain prohibited phrases",
  "strength": {"type": "hard"},
  "expression": "~violates_prohibited_phrase(Response, Phrase)",
  "source": "domain_rule"
}

~alive(X)                      % X is definitely not alive
~ships_internationally.        % Definitely does not ship internationally

\+ found(X)                    % X was not found (maybe doesn't exist)
not(member(X, L))              % X is not provably in L

% Classical: We know X is not alive
~alive(zombie).

% NAF: We cannot prove X is alive (doesn't mean X is dead)
\+ alive(X).

% Database only has:
employee(alice).
employee(bob).

% Query: Is carol an employee?
?- employee(carol).        % Fails (no fact)
?- \+ employee(carol).     % Succeeds (NAF)
?- ~employee(carol).       % Fails (no explicit negative fact)

forall X (human(X) -> mortal(X))

mortal(X) :- human(X).         % Implicitly forall X

exists X (person(X) & rich(X))

has_rich_person :- person(X), rich(X).

% All humans have some parent
forall X (human(X) -> exists Y parent(Y, X))

% There exists someone who is everyone's friend
exists X forall Y friend(X, Y)

% This is a line comment
human(socrates).  % Inline comment

% ==============================================================================
% SECTION HEADER
% ==============================================================================
%
% Multiple lines of explanation.
% Each line starts with %.
%
% ==============================================================================

program     = { statement } ;

statement   = fact | rule | query ;

fact        = expression "." ;

rule        = expression ":-" expression "." ;

query       = "?-" expression "." ;

expression  = disjunction ;

disjunction = conjunction { ( "|" | ";" ) conjunction } ;

conjunction = unary { ( "&" | "," ) unary } ;

unary       = "~" unary
            | "\+" unary
            | "not" "(" expression ")"
            | "forall" variable "(" expression ")"
            | "exists" variable "(" expression ")"
            | comparison ;

comparison  = arithmetic [ comp_op arithmetic ] ;

comp_op     = "=" | "\=" | "==" | "\=="
            | "<" | ">" | "=<" | "<=" | ">="
            | "=:=" | "=\=" | "is" ;

arithmetic  = term { ( "+" | "-" ) term } ;

term        = factor { ( "*" | "/" | "//" | "mod" | "%" ) factor } ;

factor      = [ "-" ] primary ;

primary     = atom [ "(" args ")" ]
            | variable
            | number
            | string
            | list
            | "(" expression ")"
            | "!" ;                         (* cut *)

args        = expression { "," expression } ;

list        = "[" [ list_items ] "]" ;

list_items  = expression { "," expression } [ "|" expression ] ;

atom        = lowercase { alphanumeric | "_" }
            | "'" { any_char } "'" ;

variable    = uppercase { alphanumeric | "_" }
            | "_" { alphanumeric | "_" } ;

number      = integer | float ;

integer     = [ "-" ] digit { digit } ;

float       = [ "-" ] digit { digit } "." digit { digit } [ exponent ] ;

exponent    = ( "e" | "E" ) [ "+" | "-" ] digit { digit } ;

string      = '"' { string_char } '"' ;

string_char = any_char_except_quote | '\\"' | "\\n" | "\\t" | "\\\\" ;

lowercase   = "a" | ... | "z" ;

uppercase   = "A" | ... | "Z" | "_" ;

digit       = "0" | ... | "9" ;

alphanumeric = lowercase | uppercase | digit ;

% Facts
parent(tom, mary).
parent(tom, jim).
parent(mary, ann).
parent(mary, pat).
parent(jim, bob).

male(tom).
male(jim).
male(bob).
male(pat).

female(mary).
female(ann).

% Rules
father(X, Y) :- parent(X, Y) & male(X).
mother(X, Y) :- parent(X, Y) & female(X).

grandparent(X, Z) :- parent(X, Y) & parent(Y, Z).

ancestor(X, Y) :- parent(X, Y).
ancestor(X, Y) :- parent(X, Z) & ancestor(Z, Y).

sibling(X, Y) :- parent(P, X) & parent(P, Y) & X \= Y.

% Queries
?- father(tom, X).          % X = mary; X = jim
?- grandparent(tom, X).     % X = ann; X = pat; X = bob
?- sibling(mary, X).        % X = jim

% Products
product(wide_awake, eye_cream).
product(skin_glow_primer, primer).
has_mini(skin_glow_primer).
~has_mini(wide_awake).

% Prohibited phrases
prohibited_phrase("contact the manufacturer").
prohibited_phrase("30-40 pumps").

% Validation rules
response_invalid(R) :-
    prohibited_phrase(P) &
    contains_text(R, P).

response_valid(R) :-
    ~response_invalid(R) &
    ~contains_internal_reasoning(R).

% Escalation rules
requires_escalation(allergic_reaction).
requires_escalation(skin_irritation).

should_escalate(Topic) :-
    requires_escalation(Topic) &
    detected_topic(Topic).

% Topic detection
topic_detected(Inquiry, returns) :-
    contains_text(Inquiry, "return") |
    contains_text(Inquiry, "refund").

topic_detected(Inquiry, allergic_reaction) :-
    contains_text(Inquiry, "allergic") |
    contains_text(Inquiry, "rash").

% Sum of list
sum([], 0).
sum([H|T], S) :- sum(T, S1), S is H + S1.

% List length
len([], 0).
len([_|T], N) :- len(T, N1), N is N1 + 1.

% Maximum in list
max_list([X], X).
max_list([H|T], Max) :-
    max_list(T, MaxT),
    Max is max(H, MaxT).

% Filter positive numbers
filter_positive([], []).
filter_positive([H|T], [H|R]) :- H > 0, filter_positive(T, R).
filter_positive([H|T], R) :- H =< 0, filter_positive(T, R).

% Quicksort
quicksort([], []).
quicksort([H|T], Sorted) :-
    partition(H, T, Less, Greater),
    quicksort(Less, SortedLess),
    quicksort(Greater, SortedGreater),
    append(SortedLess, [H|SortedGreater], Sorted).

partition(_, [], [], []).
partition(Pivot, [H|T], [H|Less], Greater) :-
    H =< Pivot, partition(Pivot, T, Less, Greater).
partition(Pivot, [H|T], Less, [H|Greater]) :-
    H > Pivot, partition(Pivot, T, Less, Greater).

% Initial beliefs with confidence
belief(human(socrates), 1.0).
belief(philosopher(socrates), 1.0).
belief(lived_in(socrates, athens), 0.95).

% Derived rules
mortal(X) :- human(X).
wise(X) :- philosopher(X).

% Hard constraint: Cannot live in two places at once
~valid_kb :-
    lived_in(X, Place1) &
    lived_in(X, Place2) &
    Place1 \= Place2 &
    overlapping_time(Place1, Place2).

% Soft constraint: Philosophers usually teach
expected(teaches(X)) :- philosopher(X).

% Query with explanation
?- mortal(socrates).
% Result: true
% Explanation: mortal(socrates) via human(socrates)

error: Unexpected ')' after expression
  --> 3:15
   |
3  | mortal(X) :- human(X)).
   |              ^^^^^^^^^
   = help: Check for unbalanced parentheses

curl -X POST "$BASE_URL/api/v1/nsrl/execute" \
  -H "X-API-Key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "human(socrates). mortal(X) :- human(X). ?- mortal(X).",
    "persist": false
  }'

% Good
customer_eligible_for_discount(C) :- ...

% Avoid
ced(C) :- ...

% Always handle empty list
process([], []).
process([H|T], Result) :- ...

% When you don't need the value
has_child(X) :- parent(X, _).

% Calculate final price after applying all discounts
% Precondition: base_price(Product, Price) exists
% Returns: Final price after discounts
final_price(Product, Final) :- ...

% Bad: left recursion
ancestor(X, Y) :- ancestor(X, Z), parent(Z, Y).

% Good: base case first
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).