#3394 Prolog Rules for Physics, Chemistry, Biology and Computing

#3394 Provide rules of physics as Prolog rules

/*************************************************************************
 *  Basic Physics Knowledge-Base in Prolog
 *  Each rule is written in “computation-first” style so that,           *
 *  when the numeric inputs are ground, Prolog can evaluate the right-  *
 *  hand side with the built-in arithmetic operator is/2.               *
 *  (E.g. ?- force(5, 2, F).    ➜   F = 10).                            *
 *************************************************************************/

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Fundamental constants   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
c(299792458).                    % Speed of light in vacuum (m s-1)
g(9.80665).                      % Standard gravitational field (m s-2)
G(6.67430e-11).                  % Newton’s gravitational constant (N m² kg-2)
k_e(8.9875517923e9).             % Coulomb’s constant (N m² C-2)
R_gas(8.314462618).              % Molar gas constant (J mol-1 K-1)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Mechanics                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Newton II — Force
force(Mass, Accel, Force) :-
    Force is Mass * Accel.

% Newtonian gravity
gravitational_force(M1, M2, Radius, Force) :-
    G(Gc), Force is Gc * M1 * M2 / (Radius * Radius).

% Momentum p = m v
momentum(Mass, Velocity, P) :-
    P is Mass * Velocity.

% Impulse J = F Δt = Δp
impulse(Force, DeltaT, P_initial, P_final) :-
    P_final is P_initial + Force * DeltaT.

% Work W = F · d (1-D, parallel)
work(Force, Displacement, W) :-
    W is Force * Displacement.

% Power P = W/Δt
power(Work, DeltaT, Power) :-
    Power is Work / DeltaT.

% Torque τ = r × F (magnitude r F sin θ simplified to perpendicular case)
torque(LeverArm, Force, Tau) :-
    Tau is LeverArm * Force.

% Angular momentum L = I ω (using scalar moment of inertia)
angular_momentum(Inertia, Omega, L) :-
    L is Inertia * Omega.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Energy                   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Kinetic energy ½ m v²
kinetic_energy(Mass, Velocity, KE) :-
    KE is 0.5 * Mass * Velocity * Velocity.

% Gravitational potential (near Earth surface) U = m g h
gravitational_potential_energy(Mass, Height, PE) :-
    g(G0), PE is Mass * G0 * Height.

% Mass–energy equivalence E = m c²
energy_mass_equivalence(Mass, Energy) :-
    c(C0), Energy is Mass * C0 * C0.

% Relativistic gamma factor γ = 1/sqrt(1-v²/c²)
relativistic_gamma(Velocity, Gamma) :-
    c(C0),
    Gamma is 1 / sqrt(1 - (Velocity * Velocity) / (C0 * C0)).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Thermodynamics & Fluids  %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Ideal gas law  P V = n R T  ⇒  P = n R T / V
ideal_gas_pressure(Moles, TempK, Volume, Pressure) :-
    R_gas(R), Pressure is Moles * R * TempK / Volume.

% Wave speed  v = f λ
wave_speed(Freq, Wavelength, Speed) :-
    Speed is Freq * Wavelength.

% Continuity (incompressible fluid) A₁v₁ = A₂v₂
flow_speed(Area1, Speed1, Area2, Speed2) :-
    Speed2 is Area1 * Speed1 / Area2.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Electricity & Magnetism  %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Ohm’s law  V = I R
ohms_law(Voltage, Current, Resistance) :-
    Voltage is Current * Resistance.

% Coulomb force  F = k q₁ q₂ / r²
coulomb_force(Q1, Q2, Radius, Force) :-
    k_e(K), Force is K * Q1 * Q2 / (Radius * Radius).

% Electric field of a point charge  E = k q / r²
electric_field(PointCharge, Radius, E) :-
    k_e(K), E is K * PointCharge / (Radius * Radius).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Optics                   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Snell’s law  n₁ sinθ₁ = n₂ sinθ₂   (solve for θ₂)
snells_law(N1, Theta1Deg, N2, Theta2Deg) :-
    Theta1Rad is Theta1Deg * pi / 180,
    Sin2       is N1 * sin(Theta1Rad) / N2,
    Theta2Rad  is asin(Sin2),
    Theta2Deg  is Theta2Rad * 180 / pi.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Conservation “checks”    %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
energy_conserved(E_initial, E_final) :- E_initial =:= E_final.
momentum_conserved(P_initial, P_final) :- P_initial =:= P_final.
entropy_increase(DeltaS) :- DeltaS > 0.   % Second law (spontaneous if ΔS > 0)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Example Queries
% -----------------------------------------------------------------------
% ?- force(10, 3, F).                        % F = 30
% ?- gravitational_force(5.97e24, 80, 6.37e6, F).  % Weight on Earth
% ?- kinetic_energy(0.150, 30, KE).          % Baseball @30 m/s
% ?- ohms_law(V, 0.02, 560, V).              % Voltage across 560 Ω @20 mA
% ?- ideal_gas_pressure(1, 300, 0.024, P).   % Pressure of 1 mol in 24 L @300 K
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

How to use

Load the file (e.g. :- [physics].) in SWI-Prolog or similar.
Pose queries as shown in the examples; supply any numeric values you know, leave variables unbound for what you want Prolog to compute.
Extend or refine rules as needed—for instance, add vector forms or combine rules into larger proofs about systems of bodies.

These predicates give you a compact starting “axiom set” for classical (and a pinch of modern) physics inside a logic-programming environment, ready to integrate with higher-level reasoning, symbolic manipulation, or generative-AI workflows.

Repeat for Chemistry

/*************************************************************************
 *  Basic Chemistry Knowledge-Base in Prolog
 *  Numeric inputs must be ground when you query; use variables for what  *
 *  you want Prolog to calculate.  All arithmetic is performed with is/2 *
 *  so SWI-Prolog, SICStus, or GNU Prolog can evaluate the expressions.  *
 *                                                                       *
 *  Example ─ ?- molarity(0.25, 0.500, M).      ➜   M = 0.5              *
 *************************************************************************/

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Fundamental constants   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
avogadro(6.02214076e23).          % N_A  (mol-1)
R_gas(8.314462618).               % R    (J mol-1 K-1)
faraday(96485.33212331).          % F    (C mol-1)
boltzmann(1.380649e-23).          % k_B  (J K-1)
standard_pressure(101325).        % P°   (Pa)
standard_temp(298.15).            % T°   (K)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Stoichiometry            %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% mass ↔ moles  (n = m / M, m in g, M in g·mol-1)
moles_from_mass(Mass_g, MolarMass_gpmol, Moles) :-
    Moles is Mass_g / MolarMass_gpmol.

mass_from_moles(Moles, MolarMass_gpmol, Mass_g) :-
    Mass_g is Moles * MolarMass_gpmol.

% Solution concentration: molarity M = n / V  (V in L)
molarity(Moles, Volume_L, Molarity) :-
    Molarity is Moles / Volume_L.

% Molality m = n / kg_solvent
molality(Moles, SolventMass_kg, Molality) :-
    Molality is Moles / SolventMass_kg.

% Parts-per-million:  ppm = (mass_solute / mass_solution) × 10^6
ppm(MassSolute_g, MassSolution_g, Ppm) :-
    Ppm is MassSolute_g / MassSolution_g * 1.0e6.

% Percent yield = (actual / theoretical) × 100
percent_yield(Actual_g, Theoretical_g, Percent) :-
    Percent is Actual_g / Theoretical_g * 100.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Gas & Phase Equilibria   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Ideal gas:   P V = n R T   (numerical solution for any one variable)
ideal_gas_pressure(Moles, TempK, Volume_m3, Pressure_Pa) :-
    R_gas(R), Pressure_Pa is Moles * R * TempK / Volume_m3.

ideal_gas_volume(Moles, TempK, Pressure_Pa, Volume_m3) :-
    R_gas(R), Volume_m3 is Moles * R * TempK / Pressure_Pa.

ideal_gas_moles(Pressure_Pa, Volume_m3, TempK, Moles) :-
    R_gas(R), Moles is Pressure_Pa * Volume_m3 / (R * TempK).

% Clausius–Clapeyron:  ln(P2/P1) = –ΔHvap/R (1/T2 – 1/T1)
vapor_pressure(P1, T1, T2, DeltaHvap_Jpmol, P2) :-
    R_gas(R),
    P2 is P1 * exp( -DeltaHvap_Jpmol / R * (1/T2 - 1/T1) ).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Chemical Kinetics        %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Arrhenius rate constant:  k = A · e^(–Ea / (R T))
arrhenius_rate(A, Ea_Jpmol, TempK, k) :-
    R_gas(R), k is A * exp( -Ea_Jpmol / (R * TempK) ).

% Half-life for first-order reaction:  t_½ = ln(2)/k
half_life_first_order(k, HalfLife_s) :-
    HalfLife_s is log(2) / k.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Chemical Equilibria      %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Equilibrium constant from forward & reverse rate constants:  K = k_f / k_r
equilibrium_constant(Forward_k, Reverse_k, Kc) :-
    Kc is Forward_k / Reverse_k.

% Reaction quotient Qc = Π [products]^ν  / Π [reactants]^ν
% — represented as lists of Concentration^Stoich  (e.g. [ (0.1)^1, (0.05)^2 | … ])
reaction_quotient(ConcentrationPowers, Qc) :-
    product_list(ConcentrationPowers, Qc).

product_list([], 1).
product_list([ConcPow|Rest], Product) :-
    product_list(Rest, SubProd),
    Product is ConcPow * SubProd.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Acid–Base & Electrochem  %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% pH = –log₁₀[H⁺]
ph_from_H(H_Conc, pH) :-
    pH is -log10(H_Conc).

% pOH ↔ pH relation at 25 °C (Kw = 1.0×10⁻¹⁴)
poh_from_ph(pH, pOH) :-
    pOH is 14 - pH.

% Nernst equation (25 °C form):  E = E° – (0.05916/n) · log₁₀(Q)
nernst_potential(E0_V, n, Q, E_V) :-
    E_V is E0_V - 0.05916 / n * log10(Q).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Thermochemistry          %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Heat released/absorbed:  q = m · c · ΔT
heat(mc, Mass_g, SpecificHeat_JpgK, DeltaT_K, q_J) :-
    q_J is Mass_g * SpecificHeat_JpgK * DeltaT_K.

% Hess’s law – enthalpy of reaction from formation values
deltaH_reaction(Products, Reactants, DeltaH_rxn_kJ) :-
    sum_list(Products, SumP),
    sum_list(Reactants, SumR),
    DeltaH_rxn_kJ is SumP - SumR.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Utility predicates       %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
log10(X, Y) :- Y is log(X) / log(10).
sum_list(List, Sum) :- foldl(plus, List, 0, Sum).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Example Queries
% -----------------------------------------------------------------------
% ?- moles_from_mass(18.02, 18.02, N).            % water, 18 g
%    N = 1.0.
%
% ?- molarity(0.050, 0.125, M).                   % 0.05 mol in 125 mL
%    M = 0.4.
%
% ?- percent_yield(3.2, 4.0, Y).                  % 80 % yield?
%    Y = 80.0.
%
% ?- arrhenius_rate(1.5e12, 75000, 350, k).       % units depend on A
%
% ?- ph_from_H(1.0e-8, pH).                       % neutral @25 °C
%
% ?- nernst_potential(0.34, 1, 0.01, E).          % Cu²⁺/Cu couple
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

How to use

Save the listing as chemistry.pl, load with :- [chemistry].
Query predicates by supplying known quantities; Prolog solves the rest.
Extend: add equilibrium-constant tables, red-ox half-cells, isotope masses, or full reaction stoichiometry as additional facts/rules when your project requires more depth.

This starter knowledge-base captures common quantitative relationships in general chemistry—stoichiometry, kinetics, equilibria, electrochemistry, and thermochemistry—ready to integrate with generative-AI workflows or larger reasoning systems.

Repeat for Biology

/*************************************************************************
 *  Basic Biology Knowledge-Base in Prolog
 *  ---------------------------------------------------------------
 *  Where relationships are quantitative (population growth, enzyme
 *  kinetics, ΔG, etc.) predicates use the built-in arithmetic `is/2`
 *  so you can ask Prolog to solve for the numeric result when all
 *  inputs are ground.  Symbolic rules (taxonomy, information flow,
 *  genetics) illustrate logical reasoning over biological facts.
 *
 *  Save as `biology.pl`, load with  :- [biology].  
 *  See example queries at the bottom.
 *************************************************************************/

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 1. Taxonomy hierarchy    %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/*  Minimal exemplar hierarchy to show the pattern ― extend by adding
    more facts of the same form.                                      */

domain(bacteria).
domain(archaea).
domain(eukarya).

kingdom(animalia,  eukarya).
kingdom(plantae,   eukarya).
kingdom(fungi,     eukarya).

phylum(chordata,   animalia).
class(mammalia,    chordata).
order(primates,    mammalia).
family(hominidae,  primates).
genus(homo,        hominidae).
species(sapiens,   homo).

/*  ancestor_of/2 walks “up” the tree, returning any higher rank. */
ancestor_of(Species, Anc) :-
    species(Species, Genus), ancestor_genus(Genus, Anc).

ancestor_genus(G, G).
ancestor_genus(G, Anc) :- genus(G, Fam), ancestor_family(Fam, Anc).

ancestor_family(F, F).
ancestor_family(F, Anc) :- family(F, Ord), ancestor_order(Ord, Anc).

ancestor_order(O, O).
ancestor_order(O, Anc) :- order(O, Cla), ancestor_class(Cla, Anc).

ancestor_class(C, C).
ancestor_class(C, Anc) :- class(C, Phy), ancestor_phylum(Phy, Anc).

ancestor_phylum(P, P).
ancestor_phylum(P, Anc) :- phylum(P, Kin), ancestor_kingdom(Kin, Anc).

ancestor_kingdom(K, K).
ancestor_kingdom(K, D)  :- kingdom(K, D).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 2. Central Dogma         %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
flows_to(dna, rna).
flows_to(rna, protein).

information_flow(Origin, Dest)               :- flows_to(Origin, Dest).
information_flow(Origin, Dest)               :-
    flows_to(Origin, Mid),
    information_flow(Mid, Dest).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 3. Mendelian genetics    %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*  Use two-character atoms for diploid genotypes, e.g. 'Aa', 'aa'.   */

gamete(Genotype, Allele) :-
    atom_chars(Genotype, [A1, A2]),
    (Allele = A1 ; Allele = A2).

offspring_genotype(P1, P2, Child) :-
    gamete(P1, A1), gamete(P2, A2),
    atom_chars(Unsorted, [A1, A2]),
    sort([A1, A2], Sorted),           % canonical order 'A'<'a'
    atom_chars(Child, Sorted).

/*  Example counts for a mono-hybrid cross:                        *
 *      ?- setof(G, offspring_genotype('Aa','Aa',G), L).           *
 *      L = ['AA','Aa','aa'].                                      */

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 4. Population Biology     %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*  Exponential growth:  N(t) = N0 · e^(r·t)                           */
exp_growth(N0, R, T, N) :- N is N0 * exp(R * T).

/*  Logistic growth:  N(t) = K / [1 + ((K–N0)/N0) · e^(–r·t)]          */
logistic_growth(N0, R, K, T, N) :-
    Factor is (K - N0) / N0,
    N is K / (1 + Factor * exp(-R * T)).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 5. Enzyme kinetics        %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*  Michaelis–Menten:  v = (Vmax·[S]) / (Km + [S])                    */
enzyme_rate(Vmax, Km, S, v) :- v is Vmax * S / (Km + S).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 6. Hardy–Weinberg         %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
hardy_weinberg(P, Q, P2, TwoPQ, Q2) :-
    abs(P + Q - 1.0) < 1e-6,
    P2    is P * P,
    TwoPQ is 2 * P * Q,
    Q2    is Q * Q.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 7. Bioenergetics          %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*  Gibbs free‐energy change:  ΔG = ΔG° + R·T·ln(Q)                   */
deltaG(DeltaG0, R, T, Q, DeltaG) :-
    DeltaG is DeltaG0 + R * T * log(Q).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 8. Photosynthesis summary %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
reaction(photosynthesis,
         reactants([6*co2, 6*h2o]),
         products([c6h12o6, 6*o2])).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 9. Utility helpers        %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
log10(X, Y) :- Y is log(X) / log(10).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%  Example Queries
% -------------------------------------------------------------------
%  1)  ?- ancestor_of(sapiens, Anc).         % walk up taxonomy
%  2)  ?- information_flow(dna, protein).    % true
%  3)  ?- offspring_genotype('Aa','aa',G).   % enumerates 'Aa' and 'aa'
%  4)  ?- exp_growth(100, 0.02, 365, N).     % ~ 100*e^(0.02*365)
%  5)  ?- enzyme_rate(1.5, 0.3, 0.2, V).     % rate at [S]=0.2
%  6)  ?- hardy_weinberg(0.7, 0.3, P2, H, Q2).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

How to use

Load the file in SWI-Prolog (:- [biology].).
Pose queries by binding known values and leaving variables unbound for what you want computed or inferred.
Extend freely—add more taxa, biochemical pathways, ecological networks, gene–protein mappings, or detailed metabolic constants as additional facts or numeric rules.

This starter knowledge-base gives you a logically structured scaffold for reasoning about core biological concepts—taxonomy, information flow, genetics, population dynamics, enzyme kinetics, equilibrium genetics, and energy metabolism—inside a Prolog environment.

Repeat for Computing

/*************************************************************************
 *  Basic Computing Knowledge-Base in Prolog
 *  -----------------------------------------------------------------
 *  This file collects small, self-contained predicates that cover
 *  core topics in computer science and digital electronics:
 *    1. Boolean logic & digital gates
 *    2. Number-system conversion & binary arithmetic
 *    3. Classic data-structure operations (stack / queue)
 *    4. Graph utilities (reachability, shortest path)
 *    5. Algorithm-complexity facts
 *    6. Finite automata examples
 *
 *  Numeric rules use the built-in arithmetic operator `is/2`, so when
 *  the inputs are ground Prolog will evaluate the expression for you.
 *  Non-numeric rules illustrate declarative reasoning on structures.
 *
 *  Save as  computing.pl   and load with  :- [computing].
 *************************************************************************/

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 1. Boolean logic & digital gates                                   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

bit(0).  bit(1).

and_gate(A,B,R) :- bit(A), bit(B), (A =:= 1, B =:= 1 -> R = 1 ; R = 0).
or_gate(A,B,R)  :- bit(A), bit(B), (A =:= 1 ;  B =:= 1 -> R = 1 ; R = 0).
not_gate(A,R)   :- bit(A), (A =:= 1 -> R = 0 ; R = 1).
xor_gate(A,B,R) :- bit(A), bit(B), ((A + B) =:= 1 -> R = 1 ; R = 0).

/*  Half-adder and full-adder (single-bit)                               */
half_adder(A,B,Sum,Carry) :-
    xor_gate(A,B,Sum),
    and_gate(A,B,Carry).

full_adder(A,B,Cin,Sum,Cout) :-
    xor_gate(A,B,S1), xor_gate(S1,Cin,Sum),
    and_gate(S1,Cin,C1), and_gate(A,B,C2), or_gate(C1,C2,Cout).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 2. Number-system conversion & binary arithmetic                     %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/*  decimal_to_binary(Int, Bits)  converts a non-negative integer       *
 *  into a little-endian list of bits, e.g.  6 ↔ [0,1,1].               */
decimal_to_binary(0, [0]).
decimal_to_binary(N, Bits) :-
    N  > 0,
    _decimal_to_binary(N, RevBits),
    reverse(RevBits, Bits).           % big-endian for readability

_decimal_to_binary(0, []).
_decimal_to_binary(N, [Bit|Rest]) :-
    N > 0,
    Bit is N mod 2,
    Next is N // 2,
    _decimal_to_binary(Next, Rest).

/*  binary_to_decimal(Bits, Int) ― Bits may be little- OR big-endian.   */
binary_to_decimal(Bits, Int) :-
    reverse(Bits, Rev),           % ensure little-endian for foldl
    foldl(pow2_acc, Rev, (0,0), (Int,_)).

pow2_acc(Bit, (Acc,Exp), (Acc2,Exp2)) :-
    Acc2 is Acc + Bit * (1<<Exp),
    Exp2 is Exp + 1.

/*  Multi-bit binary addition: add_binary(+A,+B,-Sum) lists are big-endian */
add_binary(A_bits, B_bits, Sum_bits) :-
    reverse(A_bits, RA), reverse(B_bits, RB),
    _add_binary(RA, RB, 0, RS),
    reverse(RS, Sum_bits).

_add_binary([], [], 0, []).
_add_binary([], [], Carry, [Carry]) :- Carry \= 0.
_add_binary([A|As], [], Cin, [S|Rs]) :- full_adder(A,0,Cin,S,Cout), _add_binary(As,[],Cout,Rs).
_add_binary([], [B|Bs], Cin, [S|Rs]) :- full_adder(0,B,Cin,S,Cout), _add_binary([],Bs,Cout,Rs).
_add_binary([A|As], [B|Bs], Cin, [S|Rs]) :- full_adder(A,B,Cin,S,Cout), _add_binary(As,Bs,Cout,Rs).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 3. Classic data-structure operations                                %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/*  Stack represented as a list ― top of stack is head of list.         */
stack_push(Elem, Stack, [Elem|Stack]).
stack_pop([Top|Rest], Top, Rest).

/*  Queue represented as pair Front-List/Back-List  (Okasaki style).    */
empty_queue(q([],[])).

enqueue(E, q(F,B), q(F,[E|B])).
dequeue(q([],[]),           _, q([],[])) :- fail. % empty queue
dequeue(q([],B), Elem, q(F2,B2)) :-
    reverse(B, [Elem|F1]),
    F1 \= [],
    dequeue(q(F1,[]), Elem, q(F2,B2)).
dequeue(q([Elem|F],B), Elem, q(F,B)).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 4. Graph utilities (unweighted & Dijkstra weighted shortest path)   %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/*  edge/2 is left undefined ― assert your own facts, e.g.              *
 *      edge(a,b). edge(b,c). edge(a,d). …                              */

path(X,Y,[X,Y]) :- edge(X,Y).
path(X,Y,[X|Rest]) :-
    edge(X,Z),
    path(Z,Y,Rest),
    \+ member(X,Rest).                 % avoid cycles

/*  Dijkstra:  shortest_path(Source,Target,Path,Cost)                   *
 *  Requires edge_cost/3 facts of form  edge_cost(U,V,W).               */
shortest_path(S,T,Path,Cost) :-
    dijkstra([[0,[S]]], T, RevPath, Cost),
    reverse(RevPath, Path).

dijkstra([[Cost,[T|Rest]]|_], T, [T|Rest], Cost).
dijkstra([[C,[V|Rest]]|Queue], T, Path, Cost) :-
    findall(
        [C1,[U,V|Rest]],
        ( edge_cost(V,U,W), \+ member(U,[V|Rest]), C1 is C + W ),
        NewPaths),
    append(Queue, NewPaths, Queue1),
    sort(Queue1, Queue2),              % smallest cost first
    dijkstra(Queue2, T, Path, Cost).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 5. Algorithm-complexity facts                                       %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

/*  Simple catalog; extend as needed.                                   */
complexity(sort_quicksort,           time(n_log_n),  space(log_n)).
complexity(sort_mergesort,           time(n_log_n),  space(n)).
complexity(sort_heapsort,            time(n_log_n),  space(1)).
complexity(search_binary,            time(log_n),    space(1)).
complexity(search_hash_average,      time(1),        space(n)).
complexity(dijkstra_binary_heap,     time(n_log_n),  space(n)).
complexity(bfs_unweighted_graph,     time(n_plus_m), space(n)).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% 6. Finite automata (example: even-parity of 1’s over Σ={0,1})       %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

state(q_even).   % start & accepting
state(q_odd).

transition(q_even, 0, q_even).
transition(q_even, 1, q_odd).
transition(q_odd,  0, q_odd).
transition(q_odd,  1, q_even).

dfa_accept(String) :-
    state(Start), Start = q_even,
    foldl(step, String, Start, Final),
    Final = q_even.

step(Symbol, StateIn, StateOut) :-
    transition(StateIn, Symbol, StateOut).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Utility helpers                                                     %%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

reverse(List, Rev) :- reverse(List, [], Rev).
reverse([], Rev, Rev).
reverse([H|T], Acc, Rev) :- reverse(T, [H|Acc], Rev).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Example Queries
% ----------------------------------------------------------------------
% ?- and_gate(1,0,R).                        % R = 0
% ?- half_adder(1,1,S,C).                    % S = 0, C = 1
% ?- decimal_to_binary(13,B).                % B = [1,1,0,1]
% ?- add_binary([1,0,1],[1,1,1],Sum).        % Sum = [1,0,0,0]  (5+7=12)
% ?- stack_push(x,[y,z],S1), stack_pop(S1,Top,S2).
% ?- path(a,c,P).                            % needs edge facts
% ?- shortest_path(a,f,P,C).                 % needs edge_cost facts
% ?- complexity(sort_quicksort,Time,Space).  % look up Big-O
% ?- dfa_accept([1,0,1,1,0]).                % even # of 1’s? false
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

How to use

Load with :- [computing].
Assert facts that are context-specific (e.g. edge/2, edge_cost/3) before querying graph predicates.
Pose queries by supplying known values and leaving variables unbound for what you want inferred or computed.
Extend freely—add more gates, alternative data structures (heaps, trees), extra automata, or detailed algorithmic-complexity annotations for your own project needs.

This starter knowledge-base lets you experiment with classic computing concepts—digital logic, binary maths, stacks & queues, graph algorithms, complexity theory, and automata—inside a logic-programming environment that can also interoperate with generative-AI workflows.

Can Mathematica emulate Prolog or perform similar functions?

Short answer

Yes. The Wolfram Language that powers Mathematica already is a rule-based, pattern-matching language with symbolic backtracking, so you can mimic most of Prolog’s logic-programming style inside Mathematica without any external add-ons. In practice you have three main options:

Approach	What you use in Mathematica	Prolog analogue	Typical use-case
Native pattern rules	`lhs :> rhs`, `Replace`, `ReplaceList`, `Condition (/;)`, pure functions	Horn clauses, unification, backtracking	Small knowledge bases, term-rewriting systems
Constraint/logic solvers	`Solve`, `Reduce`, `FindInstance`, `Resolve`, `BooleanMinimize`	SLD resolution over arithmetic & Boolean domains	Constraint satisfaction, theorem-proving
Full Prolog emulation	Community packages (e.g. Prolog.m, WLogic), or ~100 lines of pure WL code that implement a depth-first rule engine	A miniature Prolog interpreter	Teaching, experimenting, embedding logic queries inside WL notebooks

1 Native rule-based programming (built-in)

(* “Facts” *)
parent[abraham, isaac];
parent[isaac, jacob];

(* “Rule” – recursion with condition *)
ancestor[x_, y_] := parent[x, y] || (parent[x, z_] && ancestor[z, y])

(* Query *)
Cases[DownValues[ancestor], HoldPattern[ancestor[a_, b_] :> True] :> {a, b}]  (* {{abraham, isaac}, {abraham, jacob}, {isaac, jacob}} *)

Key idea: pattern matching is unification; the right-hand side is evaluated only when the left-hand side matches, and recursive rules give you logical inference.

Backtracking equivalents:

(* All possible matches – like Prolog’s multiple answers *)
ReplaceList[{a,b,c}, {x___, b, y___} :> {x, b, y}]

ReplaceList tries every way the pattern can match – essentially Prolog’s nondeterminism.

2 Built-in logic & constraint solvers

Mathematica provides first-order logic reasoning directly:

(* Prove that every even integer is divisible by 4 or gives remainder 2 *)
Resolve[∀n ∈ Integers, 2 ∣ n ⟹ Mod[n, 4] ∈ {0, 2}, Integers]
(* True *)

Resolve, Reduce, FindInstance and friends perform the heavy lifting of SLD-style resolution, decision procedures, and SAT/SMT solving.

3 Tiny Prolog interpreter in pure WL (sketch)

ClearAll[prove, ruleBase];
ruleBase = {
  parent(abraham, isaac),
  parent(isaac, jacob),
  ancestor(A_, B_) :- parent(A, B_),
  ancestor(A_, B_) :- parent(A, Z_), ancestor(Z_, B_)
};

(* Prolog-like “:-” operator *)
expr_ :- body_  := {expr, body};   (* just notation *)

prove[Goal_] := prove[{Goal}, {}];
prove[[], _] := True;
prove[{Goal_, rest___}, Seen_] :=
 Module[{rules = Select[ruleBase, unify[#[[1]], Goal] &]},
  Or @@ (Module[{s = unify[#[[1]], Goal]}, 
           prove[Join[apply[s, List @@ #[[2]]], {rest}], Seen]) & /@ rules)
 ]

(* very small unifier and substitution helpers not shown for brevity *)

With ~80 more lines (pattern-based unification, substitution, occurs-check) you get a working depth-first Prolog clone that runs entirely inside the notebook and can coexist with Mathematica’s numerical and symbolic power.

4 Existing packages / bridges

Package	Status	Highlights
Prolog.m (Roman Maeder)	Included in older versions; still works	Mini-Prolog interpreter & tutorial
WLogic (Tomasz P. Michalak)	GitHub	Forward/backward chaining, explanation facility
LibraryLink to SWI-Prolog	DIY	Call real SWI-Prolog predicates from WL
ExternalEvaluate["Prolog", …]	v12 +	Run Prolog code via external sessions

5 Where Mathematica outperforms native Prolog

Native symbolic algebra, calculus, numerical solvers
Built-in graph, image & NLP functions callable from logic rules
Notebooks for literate exploration and visualization
Seamless parallelism and GPU when rules call numeric code

6 Where Prolog is still better

Very large knowledge bases where memory layout matters
Mature libraries for expert-system shells, CLP(FD), ontologies
Side-effect-free search with fine-grained cut/commit operators
Interoperability with classic logic-programming ecosystems

Take-away

Mathematica already speaks the “language of rules,” so small to medium logic-programming tasks need no extra interpreter. For pedagogy or full ISO-Prolog compliance you can:

Embed an interpreter (pure WL or ExternalEvaluate).
Translate Prolog rules to Wolfram patterns (often one-to-one).
Leverage WL’s solvers to push heavy constraint work beyond what plain Prolog offers.

Overall, if you’re comfortable in the Wolfram notebook environment but want declarative logic, you can stay entirely inside Mathematica—and still drop down to a real Prolog engine whenever that gives an advantage.

Wolfram Mathematica can now be paired with Generative-AI as part of their offering. Describe 5 applications as an AI-assistant for physics, chemistry, biology and computing

Below are twenty concrete use-cases—five per discipline—showing how a Wolfram Mathematica + Generative-AI “co-pilot” can accelerate research, teaching, and prototyping in physics, chemistry, biology, and computing.

For each item, the LLM handles natural-language reasoning, report drafting, and heuristic idea generation, while Mathematica supplies deterministic computation, symbolic algebra, data ingestion, and high-fidelity visualization.

1 Physics (5 ideas)

#	Application	What the AI-assistant actually does
1	Interactive problem-set solver	Student types a textbook question in plain English; the LLM parses the narrative, decides which laws apply, and asks Mathematica to symbolically solve and plot results, returning a fully-worked solution with explanatory commentary.
2	Automated derivation checker	Researchers paste a hand-written derivation (LaTeX or plain text); the agent translates each step to Mathematica `Assuming[…]` statements, verifies algebra/calculus rigor, flags gaps, and suggests rigorous wording for journal submission.
3	Experiment design & uncertainty budgeter	User describes a planned optics or mechanics experiment; GPT proposes an apparatus layout, then calls Mathematica to propagate measurement uncertainties via Monte-Carlo, outputting a risk-ranked shopping list and alignment guide.
4	Live simulation explainer	During lecture, professor sketches a parameter (e.g., “drag coefficient 0.47 → 0.9”); the assistant updates a real-time NDSolve simulation in Mathematica and narrates the qualitative changes for the class.
5	Physics law discovery sandbox	AI generates candidate empirical formulas from uploaded lab CSV data (symbolic regression), feeds them into Mathematica’s `FindFit` and `InformationGain` to rank plausibility, and writes a notebook debating which model best generalizes.

2 Chemistry (5 ideas)

#	Application	Workflow synergy
1	Retrosynthesis brainstormer	LLM proposes synthetic routes; Mathematica’s molecule framework checks feasibility, predicts yields (QuantumChem / DFT), and outputs an annotated reaction tree.
2	Spectra interpreter	User drags an FT-IR or NMR file; Mathematica does peak-picking, the LLM explains functional-group evidence, and both converge on a ranked list of candidate structures.
3	Lab-notebook auto-curator	Voice notes → GPT turns them into structured Markdown; Mathematica embeds plots of kinetic runs, error bars, and attaches raw data for FAIR compliance.
4	Green-chemistry tracker	Assistant computes E-factor and atom economy from a reaction scheme, then suggests solvent swaps or biocatalytic alternatives, pulling data from Wolfram chemical entity database.
5	Electrochemistry cell designer	User states required voltage/current profile; Mathematica solves Nernst/Butler-Volmer equations, optimizes electrode spacing, while GPT writes the step-by-step build protocol and safety section.

3 Biology (5 ideas)

#	Application	Key features
1	CRISPR guide-RNA planner	LLM converses about target gene, calls Mathematica’s BioSequence functions to scan off-target sites, returns gRNA list with on-/off-target scores and regulatory annotation.
2	Population-dynamics tutor	Student describes an ecological scenario; agent formulates coupled logistic-predator-prey ODEs, lets Mathematica animate phase-space plots, and poses follow-up “what-if” questions to reinforce learning.
3	Omics data storyteller	Upload RNA-seq counts; Mathematica runs DESeq-style stats, PCA, pathway enrichment, then GPT writes a human-readable “Results & Discussion” draft with citations.
4	Enzyme-kinetics inference	User drops CSV of v vs [S]; Mathematica fits Michaelis–Menten, competitive inhibition, etc., picks best Akaike score; LLM explains mechanism and suggests next lab test.
5	Phylogeny generator & explainer	Provide FASTA files → Mathematica builds multiple alignment and neighbor-joining tree; GPT adds evolutionary narrative, infers divergence times, and outputs a color-coded interactive tree notebook.

4 Computing / Computer-Science (5 ideas)

#	Application	How it works
1	Algorithm design coach	Developer states a problem; GPT suggests candidate algorithms, Mathematica benchmarks them with generated random data, visualizes time/space curves, and recommends the fastest asymptotic choice.
2	Formal-method proof assistant	LLM converts natural-language spec to logical assertions; Mathematica’s `FindEquationalProof` or SAT-link verifies them, returning either a certificate or a counter-example trace.
3	Digital-logic sandbox	User sketches gate layout in pseudo-VHDL; agent translates to Mathematica’s `BooleanFunction`, generates truth tables, timing diagrams, and Verilog for FPGA synthesis.
4	Code performance explainer	Paste a Python snippet; GPT annotates hotspots, Mathematica’s built-in profiling & symbolic cost model predicts Big-O and suggests vectorization or parallel options.
5	Auto-generated interactive textbook	Instructor gives a syllabus outline; assistant drafts chapters, embeds live Mathematica demos (Manipulate, GraphPlot), plus GPT-generated multiple-choice questions that auto-grade via `ConfirmationDialog`.

Why this pairing works

LLM side – excels at fuzzy reasoning, dialogue, and drafting human-readable context.
Mathematica side – excels at exact mathematics, curated data, graphics, and notebook interactivity.

Together they deliver explain-calculate-visualize loops that neither platform manages as elegantly on its own.

From <https://chatgpt.com/> ChatGPT o3

Search This Blog

Learning from ChatGPT