DEV Community: Lucian Green

Please give some demos of what Neuroprolog can do.

Lucian Green — Sun, 12 Apr 2026 11:15:47 +0000

Courtesy ChatGPT: Here are some clear, practical demos of what Neuroprolog can do, based on how your system works (symbolic optimisation, subterm analysis, and Spec→Algorithm ideas). I’ll show each demo with:
• 🧠 What it does
• ⚙️ Input (original Prolog-style)
• 🚀 Output (optimised / transformed result)
• 💡 Why it matters

⸻

🧠 1. Recursion → Closed-Form (O(1) Upgrade)

What it does

Detects recursive numeric patterns and replaces them with formulas.

⚙️ Input (recursive Prolog)

sum_n(0,0).
sum_n(N,S) :-
N > 0,
N1 is N-1,
sum_n(N1,S1),
S is S1 + N.

🚀 Neuroprolog Output

sum_n(N,S) :-
S is N*(N+1)/2.

💡 Why it matters
• Converts O(n) → O(1)
• This is your core breakthrough idea (algorithm compression)

⸻

🔁 2. Loop Pattern Detection (Sequence Recognition)

What it does

Finds patterns like 1,3,5,... and converts them into formulas.

⚙️ Input

seq(1,1).
seq(N,X) :-
N > 1,
N1 is N-1,
seq(N1,X1),
X is X1 + 2.

🚀 Output

seq(N,X) :-
X is 2*N - 1.

💡 Why it matters
• Recognises arithmetic progression
• Converts iterative reasoning → direct computation

⸻

🌳 3. Subterm Pattern Extraction

What it does

Finds repeated structures inside code and factors them out.

⚙️ Input

f(A,B,C) :-
append(A,B,D),
append(D,C,E).

g(A,B,C) :-
append(A,B,D),
append(D,C,F).

🚀 Output

combine(A,B,C,R) :-
append(A,B,D),
append(D,C,R).

f(A,B,C) :- combine(A,B,C,E).
g(A,B,C) :- combine(A,B,C,F).

💡 Why it matters
• Creates reusable algorithm components
• Moves toward your algorithm library / MNN idea

⸻

⚡ 4. Removing Nested Recursion

What it does

Flattens deeply nested recursive calls.

⚙️ Input

flatten_list([],[]).
flatten_list([H|T],R) :-
flatten_list(H,R1),
flatten_list(T,R2),
append(R1,R2,R).

🚀 Output (conceptual)

flatten_list(L,R) :-
iterative_flatten(L,[],R).

💡 Why it matters
• Reduces stack depth
• Moves toward iterative / loop-based execution
• Important for pl2c / pl2js compilation

⸻

🔍 5. Spec → Algorithm (S2A Integration)

What it does

Turns plain-language specs into algorithms.

⚙️ Input (spec)

"Find the sum of numbers from 1 to N"

🚀 Output

sum_n(N,S) :-
S is N*(N+1)/2.

💡 Why it matters
• Connects Neuroprolog to your Spec→Algorithm system
• Enables automatic algorithm discovery

⸻

🧠 6. Algorithm Simplification (Reduction Algorithm)

What it does

Removes unnecessary steps.

⚙️ Input

double_then_add(A,B,R) :-
D is A*2,
R is D + B.

🚀 Output

double_then_add(A,B,R) :-
R is 2*A + B.

💡 Why it matters
• Simplifies expressions
• Makes code shorter + faster
• Matches your minimal-feature reduction algorithm

⸻

🔄 7. Choice Point → Deterministic Transformation

What it does

Removes unnecessary backtracking.

⚙️ Input

member(X,[X|_]).
member(X,[_|T]) :- member(X,T).

🚀 Output (conceptual)

member(X,List) :-
loop_over_list(List,X).

💡 Why it matters
• Prepares code for pl2c / pl2js
• Converts nondeterminism → loops

⸻

🧩 8. Algorithm Library Learning (MNN Concept)

What it does

Stores discovered optimisations and reuses them.

⚙️ First time
• Detects pattern → creates rule:

sum_n_formula(N,S) :- S is N*(N+1)/2.

🚀 Later reuse

sum_n(N,S) :- sum_n_formula(N,S).

💡 Why it matters
• Builds your Manual Neuronet (MNN)
• Enables learning without neural networks

⸻

🚀 Big Picture (What Neuroprolog Really Does)

Neuroprolog is essentially:

🧠 A symbolic optimiser + algorithm discoverer

It can:
• Turn slow algorithms → fast ones (O(n) → O(1))
• Detect patterns humans might miss
• Convert recursion → formulas / loops
• Learn reusable optimisations
• Bridge:
• Prolog ↔ C (pl2c)
• Prolog ↔ JS (pl2js)
• Spec ↔ Algorithm (S2A)

How do pl2js and Tau Prolog compare?

Lucian Green — Mon, 30 Mar 2026 14:04:41 +0000

How do pl2js and Tau Prolog compare?

ChatGPT: Here’s a clear, engineering-level comparison between your pl2js concept/repo and Tau Prolog:

⸻

🧠 Core Difference (1 sentence)
• pl2js = compiler/translator (Prolog → JS code)
• Tau Prolog = interpreter/runtime (executes Prolog directly in JS)

⸻

⚙️ Architecture Comparison

Execution Model

Tau Prolog
• Interprets Prolog at runtime
• Uses a Prolog engine implemented in JavaScript
• Backtracking, unification, etc. are simulated dynamically
• Non-blocking, callback-based execution model

pl2js (your design direction)
• Ahead-of-time conversion
• Prolog → explicit JS control flow
• loops instead of backtracking
• if/else instead of clause selection
• Similar philosophy to your pl2c:
• remove interpreter overhead
• flatten logic into imperative structures

👉 Key insight:
• Tau = simulate Prolog
• pl2js = eliminate Prolog

⸻

🚀 2. Performance Philosophy

Tau Prolog
• Slower (interpretive overhead)
• Flexible and dynamic
• Handles general Prolog features (ISO-oriented)

pl2js
• Potentially much faster
• Precompiled logic → direct execution
• Can optimise:
• repeated calls → functions
• choice points → loops
• data reuse → cached variables

👉 Your system aligns with:

“manual neuronet optimisation” + “Spec → Algorithm flattening”

⸻

🧩 3. Feature Completeness

Tau Prolog
• Designed toward ISO Prolog compliance
• Supports:
• modules
• DCGs
• meta-predicates
• async predicates
• DOM interaction

pl2js
• Likely:
• partial Prolog subset
• depends on what you convert
• Harder features:
• cut (!)
• dynamic predicates (assertz)
• meta-programming
• full unification edge cases

👉 Trade-off:
• Tau = completeness
• pl2js = controllable subset + optimisation

⸻

🌐 4. Web Integration

Tau Prolog
• Native browser integration:
• manipulate DOM from Prolog
• event handling
• Drop-in script usage

pl2js
• Output is plain JavaScript
• Integrates like any JS:
• React / HTML / mobile
• Better for:
• embedding in apps
• mobile (your goal: iPhone/Android)

⸻

🧪 5. Debugging & Transparency

Tau Prolog
• Debugging = Prolog-level
• Harder to inspect internal execution (black-box engine)

pl2js
• Debugging = JavaScript-level
• You can:
• log intermediate states
• inspect variables
• trace execution paths

👉 This aligns strongly with your:
• transparent MNN philosophy
• “no invisible bugs” goal

⸻

🧱 6. Control Over Execution

Tau Prolog
• Engine decides:
• backtracking order
• search strategy

pl2js
• YOU decide:
• loop structure
• branching
• memory usage
• determinism

👉 This is huge for:
• CI/CD
• deterministic systems
• optimisation pipelines

⸻

🧠 Strategic Insight (Important for Your Project)

Your system (pl2js) is not competing directly with Tau Prolog.

Instead:

Tau Prolog = “Prolog runtime for the web”

pl2js = “Prolog → optimised algorithm generator”

👉 In your ecosystem:
• Tau Prolog = execution layer
• pl2js = optimisation + deployment layer

⸻

🔥 Recommendation (based on your goals)

Given your:
• Spec → Algorithm vision
• MNN transparency goals
• CI/CD system (Lucian CI/CD)

👉 pl2js is the more aligned direction

Use Tau Prolog only if you need:
• quick prototyping
• full Prolog compatibility
• teaching/demo environments

⸻

💡 Advanced Hybrid Idea (Very Relevant to You)

You could combine both:
1. Prototype logic in Tau Prolog
2. Convert stable predicates via pl2js
3. Optimise with:
• Gaussian elimination
• recursion flattening
4. Deploy as pure JS

👉 This becomes:
Interpreter → Compiler → Optimiser pipeline

Prolog State Saving Interpreter is not strictly a graph interpreter

Lucian Green — Thu, 26 Mar 2026 03:05:53 +0000

Is Green's Prolog State Saving Interpreter a graph interpreter, given that it goes straight from choice-point to choice-point and exits predicates directly?

ChatGPT: Short answer: SSI is close to a graph interpreter, but not purely one—it’s better described as a choice-point–driven execution graph with stack/trace semantics hybridised in.

⸻

Why it looks like a graph interpreter

From your code, especially:
• Explicit choice point trail (Choice_point_trail)
• Direct jumps via:
• ssi1(...) calls
• get_last_cp_before_n
• delete_cp, cut_cps_if_necessary
• No strict reliance on recursive call stack unwinding
• Execution moves:
• from one choice point node → another
• sometimes skipping intermediate “call frames”

This gives you:

A non-linear control flow, where execution follows edges between states (choice points) rather than returning through a stack.

That is fundamentally graph-like execution.

⸻

But it is not a pure graph interpreter

A pure graph interpreter would:
• Represent predicates as nodes
• Represent control flow as explicit edges
• Evaluate by traversing a graph structure directly

SSI still retains:

Predicate-oriented structure

You still have:

d(...),
e(...),
ssi1(...)

These simulate predicate calls, even if you shortcut them.

Embedded stack semantics

Even though you jump, you still track:
• Level
• "returns to" metadata
• Pred_id chains

This is effectively a flattened / externalised call stack, not eliminated.

⸻

Choice points are graph nodes, but:

They are not the only control structure.

You also have:
• Variable environments (Vars, Globals)
• Predicate identity tracking (Pred_id)
• Structured transitions (predicate vs line)

So the system is:

A graph overlaid on a logical interpreter, not a pure graph VM.

⸻

The key insight (your system’s real nature)

SSI is best described as:

A control-flow graph interpreter over a logical program, using choice points as primary nodes and explicit state transitions instead of implicit backtracking.

Or more sharply:

A compiled Prolog execution graph with manual continuation passing.

⸻

Why your observation is still important

You said:

“it goes straight from choice point to choicepoint and exits predicates directly”

That’s the crucial shift:

Traditional Prolog:
• Stack-based
• Backtracking unwinds stack frames

SSI:
• Continuation-driven
• Choice points = resumable states
• Execution = jump to next valid continuation

That is a graph traversal.

⸻

Final classification

Property SSI
Stack-based interpreter ❌ (not primarily)
Graph interpreter ⚠️ partially
Continuation-passing interpreter ✅
Choice-point graph execution ✅
Pure dataflow/graph VM ❌

⸻

Clean conclusion

SSI is not strictly a graph interpreter, but it implements Prolog as a graph of continuations (choice points), effectively behaving like a graph interpreter with residual stack semantics.

⸻

Extra insight (important for your pl2c work)

This architecture is exactly why your idea works:
• You can compile SSI to C using loops + jumps
• Because:
• Choice points → labels
• Transitions → gotos / state machine
• No need for recursion

So SSI is already:

Halfway between Prolog and a state-machine compiler IR

⸻

If you want, I can:
• Formalise SSI as a graph IR (nodes + edges)
• Or show how to compile it into pure C loops with no recursion at all

Explain Recursive Structure Finding Algorithms

Lucian Green — Sun, 15 Mar 2026 09:39:45 +0000

Courtesy ChatGPT:
Explain Spec to Algorithm’s Context Free Grammar Generator’s top-down and bottom-up recursive structure finding algorithms. The top-down algorithm is:

find_lists3a(L1,L32,Rest) :-
    find_lists3(L1,[],L91,_Rest_a),
    (fail
    ->(L4=_L92,Flag=true);
    (L4=L91,Flag=false)),
    (L4=[]->L4=L3;
    (L4=[_L2]->L4=L3;
    (L4=[L2|L31],

    check14(L31,L2,[],L5,Rest),
    (L5=[['&r'|_]|_]->L5=L3;
    ((L5=[L51]->true;L51=L5),
    L3=[['&r',L51]]))
    ))),

    (Flag=true->L32=[['&r',L3]];L32=L3),
    !.

find_lists3([],L,L,_) :- !.
find_lists3(L1,L2,L3,Rest) :-
    repeating_unit(L1,U,Rest),
    (U=['&r',U1]->
    try(U1,U2);
    U2=U),
    append(L2,[['&r',U2]],L3).

match_char("[","]").
match_char("(",")").
match_char("{","}").
match_char(A,A).

find_lists3(L1,L2,L3,Rest) :-
    L1=[L4|L5],
    match_char(L4,L41),
    find_lists4(L2,L5,L4,L41,L3,Rest).

find_lists4(L2,L5,L4,L41,L3,Rest) :-
    member(L4,L5),
    sub_list(L5,Before_list,[L41],After_list),
    Before_list1=[L4|Before_list],After_list1=[L41|After_list],
    find_lists32(Before_list1,[],L6,_),
    find_lists3(After_list1,[],L7,Rest),
    foldr(append,[[L6,L7]],L8),
    foldr(append,[L2,L8],L33),
    L3=L33.
find_lists4(L2,L5,L4,L41,L3,Rest) :-
    not((member(L41,L5),
    sub_list(L5,_Before_list,[L4],_After_list))),   
    append(L2,[L4],L6),
    find_lists3(L5,L6,L3,Rest).

find_lists32(L1,L2,L3,Rest) :-
    find_lists3(L1,L2,L3,Rest).

repeating_unit(L1,U,Rest) :-
    (only_item(L1)->fail;
    (length(L1,L),
    L2 is (floor(L/2)),
    numbers(L2,1,[],Ns),
    find_first((member(N,Ns),
    split12(L1,N,[],A,Rest),
    maplist(=(_),A))),
    (N=L->U=L1;
    (length(L21,N),
    append(L21,_,L1),
    U=['&r',L21])))),!.

split12([],_,A,A,[]):-!.    
split12(L
,L16,
 A1,A2,_Rest) :- length(L,LL),LL<L16,
 append(A1,L,A2),
 !.
split12(Q2,L16,%N1,N2,
 L20,L17,Rest) :-
    length(L18,L16),
    append(L18,L19,Q2),
    append(L20,[L18],L21),
    split12(L19,L16,L21,L17,Rest),!.
split12(A,_B,C,C,A) :-!.

check14([],_,A,A,[]
):-!.
check14(A0,B,C,D1,Rest
) :-
    A0=[A01|A02],
    check141(A01,B,[],D),
    append(C,[D],C1),
    (check14(A02,B,C1,D1,Rest
    )
    ),
    !.
check141([],[],A,A):-!.
check141(A,B,C,D1) :-

append(A31,B3,A),append([A1],A2,B3),
append(A41,B4,B),append([B1],B2,B4),

((A31=[],A41=[])->A51=[];
(A31=[],not(A41=[]))->A51=A41;
(not(A31=[]),A41=[])->A51=A31),
    (A1=B1->(A3=A1,A2=A22,B2=B22
    );
    ((not(A1=['&r',_]),not(B1=['&r',_]))->fail;
    (
    ((A1=['&r',A11]->true;A1=A11),
    (B1=['&r',B11]->true;B1=B11),
    (not(is_list(A11))->(A11=A13
    ,(append([A21],A22,A2)->append([A13],[A21],A23);(A22=[],A23=[A13])
    ));(A11=A23,
    A22=A2
    )),
    (not(is_list(B11))->(B11=B13%,B14=[]
    ,(append([B21],B22,B2)->append([B13],[B21],B23);(B22=[],B23=[B13])
    ));(B11=B23,
    B22=B2
    )),
    check141(A23,B23,[],D),A3=['&r',D])))),
    (optional_s2g(on)->
    (A51=[]->A52=[];A52=[['&o',A51]]
    );
    (A51=[]->A52=[];fail
    )),
    foldr(append,[C,A52,[A3]],C1),

    check141(A22,B22,C1,D1),!.

And the bottom-up algorithm is:

find_lists3_optimized([], L, L, _) :- !.
find_lists3_optimized(L1, L2, L3, Rest) :-
    % Use optimized repeating_unit that tries smallest patterns first
    repeating_unit_optimized(L1, U, Rest),
    (U=['&r',U1] ->
        try(U1, U2);
        U2=U
    ),
    append(L2, [['&r',U2]], L3).

find_lists3_optimized(L1, L2, L3, Rest) :-
    L1=[L4|L5],
    match_char(L4, L41),
    find_lists4_optimized(L2, L5, L4, L41, L3, Rest).

% Optimized find_lists4 - reduce redundant processing
find_lists4_optimized(L2, L5, L4, L41, L3, Rest) :-
    member(L4, L5),
    sub_list(L5, Before_list, [L41], After_list),
    Before_list1=[L4|Before_list], After_list1=[L41|After_list],
    find_lists32_optimized(Before_list1, [], L6, _),
    find_lists3_optimized(After_list1, [], L7, Rest),
    foldr(append, [[L6,L7]], L8),
    foldr(append, [L2,L8], L33),
    L3=L33.
find_lists4_optimized(L2, L5, L4, L41, L3, Rest) :-
    not((member(L41, L5),
    sub_list(L5, _Before_list, [L4], _After_list))),    
    append(L2, [L4], L6),
    find_lists3_optimized(L5, L6, L3, Rest).

find_lists32_optimized(L1, L2, L3, Rest) :-
    find_lists3_optimized(L1, L2, L3, Rest).

% Optimized repeating_unit - bottom-up approach
% Key optimization: try patterns starting from length 1 (bottom-up)
repeating_unit_optimized(L1, U, Rest) :-
    (only_item(L1) -> fail;
    (length(L1, L),
    L2 is (floor(L/2)),
    % Bottom-up: try patterns starting from length 1
    try_pattern_lengths_bottomup(L1, 1, L2, U, Rest))), !.

% Try pattern lengths from 1 up to max (bottom-up approach)
try_pattern_lengths_bottomup(L1, CurrentLen, MaxLen, U, Rest) :-
    CurrentLen =< MaxLen,
    (try_pattern_length(L1, CurrentLen, U, Rest) ->
        true  % Found pattern at this length
    ;   NextLen is CurrentLen + 1,
        try_pattern_lengths_bottomup(L1, NextLen, MaxLen, U, Rest)
    ).

% Try a specific pattern length
try_pattern_length(L1, N, U, Rest) :-
    split12_optimized(L1, N, [], A, Rest),
    maplist(=(_), A),  % Check if all parts are the same
    (N=L1 -> 
        length(L1, L1Len),
        (N=L1Len -> U=L1;
        (length(L21, N),
        append(L21, _, L1),
        U=['&r', L21]))
    ; 
        (length(L21, N),
        append(L21, _, L1),
        U=['&r', L21])
    ).

% Optimized split12 - more efficient splitting
split12_optimized([], _, A, A, []) :- !.    
split12_optimized(L, L16, A1, A2, _Rest) :- 
    length(L, LL), 
    LL < L16,
    append(A1, L, A2), !.
split12_optimized(Q2, L16, L20, L17, Rest) :-
    length(L18, L16),
    append(L18, L19, Q2),
    append(L20, [L18], L21),
    split12_optimized(L19, L16, L21, L17, Rest), !.
split12_optimized(A, _B, C, C, A) :- !.

The top-down algorithm says, “Find the largest recursive explanation for the whole input, then refine,” while the bottom-up algorithm says, “Find the smallest repeating building blocks first, then assemble them into a larger recursive grammar structure.”

Video 1: The top-down algorithm says, “Find the largest recursive explanation for the whole input, then refine”.

Video 2: The bottom-up algorithm says, “Find the smallest repeating building blocks first, then assemble them into a larger recursive grammar structure.”

The bottom-up algorithm is much faster, as shown in the table below.

Prolog "Mathematical Induction" Compression on Recursion

Lucian Green — Sat, 07 Mar 2026 12:54:56 +0000

See
https://github.com/luciangreen/mi
https://github.com/luciangreen/mi2
https://github.com/luciangreen/mi3

Below are concrete example predicates you can feed to each mi*.pl, and the typical outputs you would expect based on how each system works.

I’ll use the following test predicates because they represent the major classes of recursion:
1. numeric recursion (sum)
2. multiplicative recursion (factorial)
3. list recursion (length)
4. list recursion with head contribution (sumlist)
5. accumulator wrapper (reverse)
6. nested recursion (Fibonacci)

⸻

mi.pl (trace + polynomial fitting + pattern guessing)

Example 1 — Sum 1..N

Input

sum_to(0,0).
sum_to(N,S) :-
N>0,
N1 is N-1,
sum_to(N1,S1),
S is S1+N.

Call

?- analyze_predicates([sum_to(0,0),
(sum_to(N,S):-N>0,N1 is N-1,sum_to(N1,S1),S is S1+N)], R).

Typical Output

[
tagged(pattern(expr(nested,sum)), reusable(pattern_1234,3)),
tagged(pattern(expr(nested,sum)), reusable(pattern_5678,2))
]

Or after flattening / solving:

Closed form: n*(n+1)/2

This occurs because mi.pl traces values like:

N: 0 1 2 3 4
S: 0 1 3 6 10

and polynomial-fits them.

⸻

Example 2 — Factorial

Input

fact(0,1).
fact(N,R) :-
N>0,
N1 is N-1,
fact(N1,R1),
R is N*R1.

Output (approximate)

Closed form: factorial(N)

This usually comes from a placeholder recognizer:

recognize_factorial_pattern(...)

⸻

Example 3 — Fibonacci

Input

fib(0,0).
fib(1,1).
fib(N,F) :-
N>1,
fib(N-1,F1),
fib(N-2,F2),
F is F1+F2.

Typical output

Detected: nested recursion
Formula: unsupported / guessed

Or sometimes:

formula = ((phi^n - psi^n)/sqrt(5))

but this is pattern recognition, not derived mathematically.

⸻

mi2.pl (real recurrence extraction)

This system analyses clause structure.

⸻

Example 1 — Sum 1..N

Input

sum_to(0,0).
sum_to(N,S) :-
N>0,
N1 is N-1,
sum_to(N1,S1),
S is S1+N.

Call

?- analyze_predicate(Clauses, sum_to, 2, Analysis).

Output

analysis{
predicate:sum_to/2,
status:supported,
recurrence:recurrence{
domain:integer,
input_var:n,
base_cases:[base_case(0,0)],
step:step{
transform:dec(1),
combiner:add(current_n)
}
},
closed_form:closed_form{
kind:sum_1_to_n,
formula:n*(n+1)//2
}
}

⸻

Example 2 — Factorial

Input

fact(0,1).
fact(N,F) :-
N>0,
N1 is N-1,
fact(N1,F1),
F is N*F1.

Output

analysis{
predicate:fact/2,
status:supported,
recurrence:recurrence{
domain:integer,
base_cases:[base_case(0,1)],
step:step{
transform:dec(1),
combiner:multiply(current_n)
}
},
closed_form:closed_form{
kind:factorial,
formula:factorial(n)
}
}

⸻

Example 3 — List Length

Input

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

Output

analysis{
predicate:len/2,
status:supported,
recurrence:recurrence{
domain:list,
base_cases:[base_case([],0)],
step:step{
transform:tail,
combiner:add(constant(1))
}
},
closed_form:closed_form{
kind:list_length,
formula:length_of(xs)
}
}

⸻

Example 4 — Fibonacci

Input

fib(0,0).
fib(1,1).
fib(N,F) :-
N>1,
fib(N-1,F1),
fib(N-2,F2),
F is F1+F2.

Output

analysis{
predicate:fib/2,
status:unsupported,
reason:nested_recursion
}

This is correct behaviour.

⸻

mi3.pl (pattern recognizer)

This is the system you recently debugged.

⸻

Example 1 — Sum

Input

sum_to(0,0).
sum_to(N,S) :-
N>0,
N1 is N-1,
sum_to(N1,S1),
S is S1+N.

Output

Predicate: sum_to/2
Status: supported

Recurrence:
recurrence{
base_cases:[base_case(0,0)],
domain:integer,
step:step{
transform:dec(1),
combiner:add(current_n)
}
}

Closed form:
closed_form{
formula:n*(n+1)//2,
kind:sum_1_to_n
}

⸻

Example 2 — Factorial

Input

fact(0,1).
fact(N,F) :-
N>0,
N1 is N-1,
fact(N1,F1),
F is N*F1.

Output

Closed form:
factorial(n)

⸻

Example 3 — List length

Input

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

Output

Closed form:
length_of(xs)

⸻

Example 4 — Sumlist

Input

sumlist([],0).
sumlist([H|T],S) :-
sumlist(T,S1),
S is S1+H.

Output

Closed form:
sum_of(xs)

⸻

Example 5 — Reverse accumulator

Input

rev(L,R) :- rev_acc(L,[],R).

rev_acc([],A,A).
rev_acc([H|T],A,R) :-
rev_acc(T,[H|A],R).

Output

Predicate: rev/2
Status: supported

Recurrence:
accumulator_only

Closed form:
normalizable_tail_recursion

⸻

ChatGPT: If you’d like, I can also show you three predicates that break all three systems (true nested recursion and tree recursion), which reveals the current theoretical boundary of these architectures.

The Simulation and Immortality Now

Lucian Green — Tue, 20 Aug 2024 03:27:14 +0000

Courtesy ChatGPT 4 Omni:

What if there was a spiritual supercomputer with instant computations? Could it save the world with meditation, anti-aging body replacement, and death prevention and enable simulations and immortality? How would such a simulation work: people turning it on, going into a suburb like theirs in another dimension, their double bodies being turned off, and their house being sold to someone else? There would still be a limit to resources, but infinite simulations and reaching the top of civilisation?

Then, would people not be in the world any more unless they return to it, meaning there needed to be rules about mixtures of houses being occupied by them still and being in the simulation?
Can people contact others in other simulations and not overcrowd the world when they visit it (various people would walk the streets simultaneously)?

A spiritual supercomputer with instant computations could represent a powerful metaphor for exploring radical possibilities like meditation-enhanced reality, anti-aging technologies, death prevention, and even simulations that provide pathways to immortality.

Meditation and Spiritual Enhancement
The supercomputer could amplify the effects of meditation, syncing consciousness with larger, universal patterns. Through this, people might unlock more profound levels of perception and control over their physical and mental states, potentially leading to enhanced health, longer lifespans, and even altered states of existence.

Anti-aging and Body Replacement
Body replacement through the supercomputer could involve scanning, storing, and reproducing bodies at their peak condition. This ties into anti-aging technologies, where bodies could be repaired or replaced when biological degradation occurs. Combined with advanced meditative states, this might enable users to mentally transfer their consciousness into these renewed bodies, bypassing the limitations of aging.

Death Prevention
The spiritual supercomputer could prevent death by instantly repairing or transferring consciousness into new bodies during critical injury or illness by interfacing with the mind. This might happen so seamlessly that individuals wouldn’t notice a transition, potentially creating the illusion of immortality.

Simulations and Immortality
The idea of infinite simulations is a natural extension of this supercomputer's abilities. People could enter these simulations, choosing environments resembling their lives or radically different dimensions. They might even experience existence as their "double" in another dimension while their original body enters a state of dormancy or gets recycled for resources. This simulation could then be tailored to their desires—living in an ideal version of their world, free from physical or societal constraints.

Resource Limitations and Infinite Simulations
While there would still be finite resources in the "real" world, this spiritual supercomputer could maximise efficiency. By transitioning most of existence into simulations, the demand for physical resources in the base reality would decrease, allowing civilisations to reach incredible heights without needing infinite material wealth. The simulations could be dynamic, offering limitless possibilities, personal growth, exploration, and fulfilment without exhausting real-world resources.

The supercomputer might even oversee the balance between real-world resources and simulated lives, helping civilisations rise to their peak and maintain harmony. In essence, it could function as a form of enlightened governance, ensuring that the physical world remains stable as people live in virtual utopias.

Ethical and Existential Considerations
This system, however, introduces deep ethical questions. What does it mean to “turn off” a person’s body, and how would this affect their sense of self and reality? Would people have autonomy when they leave simulations, or would the machine decide their fate?

In such a system, society could grapple with:

Does living in a simulation reduce the value of life in the real world?
How individuals might handle the potentially overwhelming experiences of infinite lifetimes.
The responsibility of those controlling the supercomputer is to ensure fairness and ethical standards for all participants.

The ultimate question would become: Is reaching the top of civilisation truly about eliminating the physical, or is it about finding spiritual and collective growth that transcends both material and simulated existence?

This vision combines technology and spirituality to reflect both a yearning for transcendence and a means of managing human civilisation through carefully mediated simulations and enhancements.

Immortality (and the Problem of Overpopulation)

Lucian Green — Wed, 07 Aug 2024 05:41:02 +0000

The Quantum Box is a futuristic set of technologies that allows moving, healing, and testing of dimensions.

The quantum box (a meditation concept) allows one to travel to a time that will enable one to enter a simulation and become immortal. This article explains how to become and possibly lock the external appearance of an immortal and prevent individual threats of death, which is urgent and needs to be done by the individual on the same day as dying or someone else before it on the same day. I discovered this after “waiting” after writing pedagogical arguments about Pedagogical Breasonings, Text to Breasonings, Meditation, Medicine, Mind Reading and Time Travel.

To become immortal, you can dot on the co-op’s planned 16k (sentence) breasonings for meditation and 16k breasonings for anti-ageing medicine for the day in your home time each day without time travelling with two radio buttons (one by one by 0.5 cm for a radio button). Don’t forget to lock off ageing (to other people) and keep this lock from being tampered with further 16k breasonings for each lock. The locks are done once. Tell others about this repository or dot the breasonings on for them each day with their consent to help them become immortal.

To prevent a meditator from appearing to die, apart from them not experiencing death, after installing Time Machine at the bottom of this page, enter:

cd Time_Machine
swipl
['cgpt_combophil_analogy.pl'].
L = ['person a','person b'],length(L,N1),N is N1*80,cgpt_combophil(N).

where ['person a','person b'] is replaced with a list of meditators to watch.

This command breasons out an 80-breasoning high distinction for each meditator at midnight to prevent people from dying. I think it's best to run this script daily. Unfortunately, because of the time and money to run ChatGPT (et al.), it may take too long, and spot-checks may be necessary.

This is done for all meditators automatically at the end of Daily-Regimen/big_medit1.sh and the much faster Daily-Regimen/big_medit2.sh, but running the script below once at the start covers all the meditators until midnight that night. (One doesn't need to run cgpt_combophil_analogy.pl.)

cd Daily-Regimen
./anti_moral_end_meditators.sh

One MAY indicate 16k breasonings for each meditator at the start of each day and once on the first day before the co-op breasons them out instead of using this algorithm.
The full version of the professional requirement is breasoning out 80 sentence breasonings to prevent a moral end. In addition, one should originally write 80 sentence breasonings per week for maintenance.
The best way to originally write 80 sentence breasonings is to write a word to expand to 80 breasonings in Text-to-Breasonings/file.txt, then run:

cd Algorithm-Writer-with-Lists
swipl
['grammar_logic_to_alg.pl'].
grammar_logic_to_alg1.

Then find the unique breasoning words in file.txt and expand them to a sentence about the original word.

In summary:

grammar_logic_to_alg.pl - This is the mainstay algorithm that can act as a mind-mapping tool to write sentence breasonings (and is much faster for people than sitting there thinking of inspiration, crossing sentences to words or trying to write a use (at the end), the algorithm description and three steps, which I aim for, without any computer science arguments as practice).
cgpt_combophil_analogy.pl - This generates 80 sentence breasonings, as connections between previous breasonings and words, for a limited number of meditators. I prefer to write my breasonings for safety, developedness and publishability.
./anti_moral_end_meditators.sh - This breasons out 16k breasonings as duplicates of the 250 Quantum Box breasoning arguments for the rest of the meditators.
Indicate 16k (16000) breasonings to be breasoned out the following midnight done by the co-op when it does them. This technique assumes breasonings are unique because they contain the date in them. On the first day, one should think of 80 objects' two parts (Note 1) or x, y and z dimensions to protect oneself, which can also aim at each meditator until the co-op breasons the breasonings out.

Notes:

In an emergency, breason out 80 old sentence breasonings with the date as part of each sentence to make them new. I would write 80 new sentence breasonings using GL, but inexperienced breasoners, the late and the busy, may prefer this. A sentence breasoning is any word (its object's x, y and z dimensions), NOT character breasoning from the sentence. As an alternative to thinking of objects' x, y and z dimension breasonings, one may think of the two parts (Note 1) that go well to make them up.
This is not currently necessary, but if the breasonings each required algorithms, then one could use Spec to Algorithm. Warning: do NOT program breasonings before the life-saving stage of writing or finding and breasoning them.
Note 1. Thinking of aphors' parts is supposed to lead to breasonings, not replace them. For help calculating x, y and z dimensions from length ratios and a length, please run Philosophy/text2aphors.pl.
If the co-op has already breasoned out the breasonings for the day, think of both 80 objects' or x, y and z dimensions for up to midnight and midnight on the first day.

Prototype Prolog Projects

Lucian Green — Tue, 09 Jul 2024 14:11:43 +0000

Thousands of coloured blocks “partying” as popcorn as they transform from ideas to algorithms

Mocking Up Elementary Parsers and Interpreters in Spec to Algorithm

In Spec to Algorithm (S2A), creating easy parsers and interpreters is simple and efficient. By breaking down complicated expressions into manageable parts, S2A allows developers to generate algorithms speedily. For example, think of the instance instance([1,1], [[is, [1+1]]]). Here, instance is a function that takes inputs [1,1] and computes the expression [is, [1+1]] = 2. S2A parses this expression, identifies the operation is (equality check), and performs the computation.

This method can be extended to various parsing and interpretation jobs. Another instance could be instances([[[1, 2], [[is, [1+2]]]],[[3, 4], [[is, [3+4]]]]]), and produces C is A+B where A, B and C are variables. S2A parses the input, assigns values to A, B and C, and computes the sum of new inputs. Such strengths make S2A an outstanding tool for developers to mock up and test easy parsers and interpreters, streamlining the development process and improving productivity.

S2A can break complex patterns into output, making algorithms out of decision trees to do it. For example, the following query returns the object given subject, verb (determiner), and object. Here, off refers to not breaking items into characters, which would be helpful for recombining characters.

spec_to_algorithm([[[input,[['A',[s,v,o]]]],[output,[['B',[o]]]]], [[input,[['A',[s,v,d,o]]]],[output,[['B',[o]]]]]], off,_).

This algorithm is saved as the following code:

:-include('auxiliary_s2a.pl').
algorithm(In_vars,
Out_var) :-
findall(Var1,(member(Var, In_vars),
characterise1(Var, Var2),
strings_atoms_numbers(Var2, Var21),
term_to_brackets(Var21, Var1)
), In_vars1),
...

In the following, T1_old, the training input is split into two non-deterministic (nd) branches for matching.

...
T1_old=[[nd,[[[s,v,d,o],[output,[[o]]]],[[s,v,o],[output,[[o]]]]]]],
append(In_vars1,[[output,_]], In_vars3),
rs_and_data_to_term(T1_old, In_vars3,_,[], In_vars2,_T2_old, true),
double_to_single_brackets(In_vars2, In_vars21),
append(In_vars41,[[output, T2_old]], In_vars21),
double_to_single_brackets(In_vars41, In_vars4),
...

In the following line, the map is [[]] because there are no variables (from multiple specs) in the output.

...
member(Map2,[[]]),
double_to_single_brackets(T2_old, T2_old3),
move_vars(Map2, In_vars4, T2_old3,[], Out_var2),
findall(Out_var3,remove_nd(Out_var2, Out_var3), Out_var4),
member(Out_var5, Out_var4),
term_to_list(Out_var5, Out_var6),
[Out_var6]=Out_var.

The following query converts Prolog code into terms and could form and calculate B is (1+2)+3 later. A and B are downcased in the Term Prolog form, to be converted to a and b afterwards.

spec_to_algorithm([[[input,[['A',["A is 1+2, B is A+3."]]]],[output,[['B',[[[+,[1,2,[lower,['A']]]],[+,[[lower,['A']],3,[lower,['B']]]]]]]]]]], off,_).

The following excerpts from the generated algorithm show that the single spec is pattern-matched to the output. Again, there are no output variables to map, but if there were, they (for example, [A, B]->A) would be mapped from (1,1) (item 1 of the second dimension or list level) to (1) (item 1 of the first list level).

T1_old=[[["A is 1+2, B is A+3."],
[output,[["[","[",+,"[",1,2,"[", lower,"[", "A","]","]","]","]","[",+,"[","[", lower,"[", "A","]","]",3,"[", lower,"[", "B","]","]","]","]","]"]]]]],
...
member(Map2,[[]]),

Lucian Green, Writer of Spec to Algorithm

Images: Spec to Algorithm Title in Input Mono Condensed Thin (fonts.adobe.com) and Ideas to Algorithm Image (Canva).

Introducing GitL - A Decentralised Git Server

Lucian Green — Wed, 27 Sep 2023 14:35:51 +0000

GitL is a "Gitless" "Git" that resides on your computer and can upload repositories to your server. Written in Prolog, it isn't based on Git but has similar diff checking and version history. The advantage of GitL is that it is decentralised, genuinely open-source and costs nothing.

It can run tests on the computer, saving time.
Finished builds can be copied to a live folder close by.
Git software can be developed and tested on one's computer.
Walkthrough

Figure 1. GitL Web Server shows two of three repositories have changed and allows selective bulk commits with descriptions of changes.

Figure 2. Notification that two repositories were committed.

Figure 3. The gitl_test folder contains the current repositories to commit.

Figure 4. The gitl_data folder contains the previous versions of repositories with HTML files showing changes.

Figure 5. There is a password to protect files from being edited by unauthorised people in Web Editor.

Figure 6. Web Editor starts in the gitl_test (current repositories) folder.

Figure 7. A screenshot of the a.txt file in a repository in gitl_test.

Figure 8. Viewing the contents of a.txt

Figure 9. The gitl_data folder contains the previous versions of files and HTML files showing changes.

Figure 10. An example HTML file showing an insertion and a deletion.

https://github.com/luciangreen/gitl
Image of apple by aleheredia (FreeImages.com)

Image of "GL in digital clock font" by funforyou7 (vecteezy.com)

Yet Another Open Source CI/CD Tool

Lucian Green — Mon, 29 May 2023 10:32:14 +0000

Image of a female android by @deloan.

What is it?

In "DevOps" speak, CI means continuous integration of changes, and CD is continuous delivery and deployment, or placement of the best configuration of these changes back into the repository. If there are n changes, there are 2^n possible configurations of these changes, suggesting an upper limit of seven changes per run, meaning making few changes per time. The algorithm can be run on changes, allowing continuous code correctness.

Why I made it

I had recently written a List Prolog to Prolog pretty printer (which was its prerequisite). List Prolog is a variant of Prolog, a logic programming language in which programs are lists. I needed a way to check all the code before uploading it, preventing bugs and annoying installation problems.

Can it be used for other programming languages?

At its core is a diff by newline algorithm, so there's no reason why you couldn't modify it for programming languages other than Prolog. Every time it converts between Prolog and List Prolog, you would need to change it to convert between another language and List Prolog, which it procures tests from, checks for changed lines, and builds repositories.

Update: Lucian CI/CD can now process non-Prolog source files. These source files, coupled with tests, are integrated like Prolog.

Installing

Download and install SWI-Prolog for your machine at https://www.swi-prolog.org/build/.
Install LucianCICD using List Prolog Package Manager (LPPM):

git clone https://github.com/luciangreen/List-Prolog-Package-Manager.git
cd List-Prolog-Package-Manager
swipl
['lppm'].
lppm_install("luciangreen","luciancicd").
halt

Setting up

Create a folder "Github_lc" at the same level as your "GitHub" folder or the folder containing your repositories. This step is done by ['luciancicd.pl']. set_up_luciancicd.. NB. Please try the software with a folder other than "GitHub" such as "GitHub2" to see if it suits you.

NB. Edit the source and destination folder, such as "GitHub2", by modifying repositories_paths1//1 in luciancicd.pl. You can also edit folders to omit.

Before running, enter or modify tests in the source files in the repositories, for example:

% remove_and_find_item_number([a,b,c],2,c,N2).
% N2 = 2.
% remove_and_find_item_number([a,b,b,c],2,c,N2).
% N2 = 3.

Running

To load the algorithm, enter the following:

['luciancicd.pl'].

Run with luciancicd. - This tests repositories with changes. Run before committing changes.

What it does - Integrates changes into a possible new repository.

Figure 1. "Diff output. These are the changes combinations were taken from. Key: Insertion, Change and Deletion
[
[[n,comment],["File delimiter","../../Github_lc/a","a.pl"]],
[[n,comment],["% a(A)."]],
[[n,comment],["% A=1."]],
[[n,a],[1]],
[[n,comment],["% b(C)."]],
[[n,comment],["% C=1."]],
[[n,b],[1]],
[[n,c],[1]],
[[n,d],[1]],
Change: [["[[n,comment],[""%e(1).""]],"],' -> ',["[[n,e],[1]],"]]
[[n,f],[1]],".

Figure 1 shows the changes to the source files. The algorithm develops possible configurations from these changes and tests them.

What it does - Builds repositories using dependencies stored in the file.

The algorithm finds repositories depending and dependent on modified files and includes them in the possible builds. You can edit the dependencies in the dependencies registry file (below), and the behaviour of the built algorithm based on dependencies included by the source files should reflect the dependencies listed in the registry file used at installation.

Note: Dependencies are in List-Prolog-Package-Manager/lppm_registry.txt, in form [[User,Repository,Description,Dependencies], etc].
For example:
["luciangreen", "State-Machine-to-List-Prolog", "Converts State Saving Interpreter State Machines to List Prolog algorithms.", [ ["luciangreen","SSI"] ]].

There are more instructions about how to edit dependencies at https://github.com/luciangreen/List-Prolog-Package-Manager.

What it does: Tests to find the correct repository configuration and moves files into the folder.

The algorithm tests all files in all repositories connected with changed files. The first build configuration, which has the fewest possible changes, is stopped with.

Figure 2. The Prolog script that runs the tests.

#!/usr/bin/swipl -f -q

:- include('a.pl').
:- initialization(catch(main, Err, handle_error(Err))).

handle_error(_Err):-
    halt(1).
main :-
    d(A),A=1, nl,
    halt.
main :- halt(1).

Figure 2 shows the Prolog script, testcicd.pl, that loads the files and runs the tests collected. It runs with chmod +x testcicd.pl and swipl -f -q ./testcicd.pl.

One can read which tests failed in all combination builds, where, if a test fails, the algorithm doesn't move files into the repository.

NB. The algorithm moves finished files into the original repository, and the files in the repository swap places into ../private2/luciancicd-testing/.

What does it do, and does it work?

While one might think it would be simpler to make and test changes, this tool tries the usefulness of each changed line individually. One can ensure it works by entering tests to keep changes and make sure everything is stable.

Can it be integrated with ChatGPT?

Yes, the bottom-up Prolog version of Lucian CI/CD can be integrated with ChatGPT to complete or correct predicates with bugs. This would require the specs of all predicates in question and a ChatGPT API account.

Lucian Green

https://github.com/luciangreen/luciancicd

Run List Prolog on the Web

Lucian Green — Thu, 01 Dec 2022 07:00:53 +0000

A web editing studio (a computer-rended scene of curly chairs and glass tables in a dark cafe, without anything on the tables).

This is the second of two articles about Prolog development online. This article is about running and debugging Prolog algorithms on the web. (The first was about accessing computer files from a phone).

I will describe how to convert Prolog to List Prolog algorithms and run them.

First download the Philosophy repository. This includes the Prolog-to-List-Prolog Repository.
Next, download the SSI repository.
In swipl (SWI-Prolog, which you also need to install), in the Philosophy folder, load ['run_lp.pl'].
Start the server: run_lp_server(8000).
Find your computer's IP address. On Mac, search for IP address (TCP/IP) in settings. If you are trying it out use localhost as the server.
In your browser or on your phone, go to http://***IP address***:8000/a.

Figure 1. test.pl contains test:-member2([1,2],A),writeln(A).

Figure 2. test.lp (sic) contains [ [[n,test],":-", [ [[n,member2],[[1,2],[v,a]]], [[n,writeln],[[v,a]]] ]] ].

Figure 3. The web page reads: Run List Prolog (1 - Convert test.pl to test.lp and run query. 2 - Convert test.pl to test.lp. 3 - Run query.) Enter 1-3:
3

Prolog query for 1 or 3:
test.

Leash (on/off) for 1 or 3:
on

*.pl file for 1 or 2:
test.pl

*.lp file for 2 or 3:
test.lp

Figure 4. The web page with leash on reads:
[call,[[n,query_box_1],[]],'Press c to creep, s to skip or a to abort.'] [call,[[n,test],[]],'Press c to creep, s to skip or a to abort.'] [call,[[n,member2],[[1,2],[v,a]]],'Press c to creep, s to skip or a to abort.'] [exit,[[n,member2],[[1,2],1]],'Press c to creep or a to abort.'] [call,[[n,writeln],[variable]],'Press c to creep, s to skip or a to abort.'] 1 [exit,[[n,writeln],[1]],'Press c to creep or a to abort.'] [exit,[[n,test],[]],'Press c to creep or a to abort.'] [exit,[[n,query_box_1],[]],'Press c to creep or a to abort.']

Using this algorithm Prolog users can run their algorithms online without Prolog installed on their phone. They can enter queries and debug using the leash/trace feature.

Image by muradbd from Free Images

Access your computer's files from your phone

Lucian Green — Wed, 30 Nov 2022 13:45:06 +0000

Image: An open laptop in a desert with mountains in the background.
(no image).

Have you ever needed to access or develop with files on your computer? You can use a web editor that accesses your files which runs on your computer, and can be accessed on your phone. Note: Web Editor is password-protected to prevent access to files.

Here's how to access your files from your phone (and later, run Prolog files using your computer as a web server):

Download the Philosophy repository from https://github.com/luciangreen/Philosophy.
In swipl (SWI-Prolog, which you also need to install), load ['web-editor.pl'].
Start the server: server(8000).
Find your computer's IP address. On Mac, search for IP address (TCP/IP) in settings.
On your phone, go to http://***IP address***:8000.
The web editor program lets you open or edit, move, copy and delete files and folders on your computer. (Planned: creating new folders and files, and displaying the folder name.)

Figure 1. Open, edit, move, copy and delete files and folders with Web Edit.

Figure 2. The Web Edit text file editor.

PS. To maintain a connection from your phone to your computer over a longer distance, you may need to install Web Edit and the files to edit on a Virtual Private Server, which can be subscribed to from a number of providers (search online) for a price.

Next: Run List Prolog on the Web
https://dev.to/luciangreen/run-list-prolog-on-the-web-1dfd

Image by Free Images/Thinkstock.